diff --git a/crates/der/Android.bp b/crates/der/Android.bp
index 4d9d6e1..5658e47 100644
--- a/crates/der/Android.bp
+++ b/crates/der/Android.bp
@@ -43,8 +43,8 @@
     visibility: [
         "//external/rust/crates/sec1:__subpackages__",
         "//external/rust/crates/spki:__subpackages__",
-        "//external/rust/crates/pkcs1:__subpackages__",
-        "//external/rust/crates/pkcs8:__subpackages__",
+        "//external/rust/android-crates-io/crates/pkcs1:__subpackages__",
+        "//external/rust/android-crates-io/crates/pkcs8:__subpackages__",
         "//external/rust/crates/x509-cert:__subpackages__",
         "//packages/modules/Virtualization:__subpackages__",
         "//system/keymint:__subpackages__",
@@ -88,8 +88,8 @@
     visibility: [
         "//external/rust/crates/sec1:__subpackages__",
         "//external/rust/crates/spki:__subpackages__",
-        "//external/rust/crates/pkcs1:__subpackages__",
-        "//external/rust/crates/pkcs8:__subpackages__",
+        "//external/rust/android-crates-io/crates/pkcs1:__subpackages__",
+        "//external/rust/android-crates-io/crates/pkcs8:__subpackages__",
         "//external/rust/crates/x509-cert:__subpackages__",
         "//packages/modules/Virtualization:__subpackages__",
         "//system/keymint:__subpackages__",
diff --git a/crates/der/cargo2android_viz.bp b/crates/der/cargo2android_viz.bp
index 02cda1f..e9d8bf7 100644
--- a/crates/der/cargo2android_viz.bp
+++ b/crates/der/cargo2android_viz.bp
@@ -1,8 +1,8 @@
 visibility: [
      "//external/rust/crates/sec1:__subpackages__",
      "//external/rust/crates/spki:__subpackages__",
-     "//external/rust/crates/pkcs1:__subpackages__",
-     "//external/rust/crates/pkcs8:__subpackages__",
+     "//external/rust/android-crates-io/crates/pkcs1:__subpackages__",
+     "//external/rust/android-crates-io/crates/pkcs8:__subpackages__",
      "//external/rust/crates/x509-cert:__subpackages__",
      "//packages/modules/Virtualization:__subpackages__",
      "//system/keymint:__subpackages__",
diff --git a/crates/pin-project-internal/.cargo-checksum.json b/crates/pin-project-internal/.cargo-checksum.json
new file mode 100644
index 0000000..1b5977d
--- /dev/null
+++ b/crates/pin-project-internal/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"5e768e7665606e603a7a85f9cc100a5898c94d3a12cd8e540d939e403c6c56eb","LICENSE-APACHE":"0d542e0c8804e39aa7f37eb00da5a762149dc682d7829451287e11b938e94594","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","src/lib.rs":"19e5ab2e30ce5ca53e877826e4eadf7cb7311e72b568573be38ecc8c39556896","src/pin_project/args.rs":"68ded73aff6f7fa66b77581940b5e7ce4eaa71411c796668f165da863795cdf5","src/pin_project/attribute.rs":"0c18445c98a056e7cbf2b43b6442f3702ecece25686c4f4cecb96c76c3f9e22e","src/pin_project/derive.rs":"985efa8d4b87084ebe76fc4f0876ccf1a5c43c365bafee0992436f00a02e9109","src/pin_project/mod.rs":"83e6fc982a8c136811332512abc7d368e5d09b94f245de5d19490f835e85943a","src/pinned_drop.rs":"1d4cffdd4176a16c440a2a3a5039dfcf14ff42ef9e2aa7069134dfac8ba69658","src/utils.rs":"063cd0422c69afbbd0a0b532a46d463ead82c85637af55c6e2a72706a8f01eee"},"package":"4359fd9c9171ec6e8c62926d6faaf553a8dc3f64e1507e76da7911b4f6a04405"}
\ No newline at end of file
diff --git a/crates/pin-project-internal/Android.bp b/crates/pin-project-internal/Android.bp
new file mode 100644
index 0000000..702a9b0
--- /dev/null
+++ b/crates/pin-project-internal/Android.bp
@@ -0,0 +1,28 @@
+// This file is generated by cargo_embargo.
+// Do not modify this file because the changes will be overridden on upgrade.
+
+package {
+    default_applicable_licenses: ["external_rust_crates_pin-project-internal_license"],
+    default_team: "trendy_team_android_rust",
+}
+
+license {
+    name: "external_rust_crates_pin-project-internal_license",
+    visibility: [":__subpackages__"],
+    license_kinds: ["SPDX-license-identifier-Apache-2.0"],
+    license_text: ["LICENSE"],
+}
+
+rust_proc_macro {
+    name: "libpin_project_internal",
+    crate_name: "pin_project_internal",
+    cargo_env_compat: true,
+    cargo_pkg_version: "1.1.3",
+    crate_root: "src/lib.rs",
+    edition: "2021",
+    rustlibs: [
+        "libproc_macro2",
+        "libquote",
+        "libsyn",
+    ],
+}
diff --git a/crates/pin-project-internal/Cargo.lock b/crates/pin-project-internal/Cargo.lock
new file mode 100644
index 0000000..cb26d2c
--- /dev/null
+++ b/crates/pin-project-internal/Cargo.lock
@@ -0,0 +1,47 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "pin-project-internal"
+version = "1.1.3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.86"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.76"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "578e081a14e0cefc3279b0472138c513f37b41a08d5a3cca9b6e4e8ceb6cd525"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
diff --git a/crates/pin-project-internal/Cargo.toml b/crates/pin-project-internal/Cargo.toml
new file mode 100644
index 0000000..1ab542e
--- /dev/null
+++ b/crates/pin-project-internal/Cargo.toml
@@ -0,0 +1,52 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2021"
+rust-version = "1.56"
+name = "pin-project-internal"
+version = "1.1.3"
+description = """
+Implementation detail of the `pin-project` crate.
+"""
+keywords = [
+    "pin",
+    "macros",
+    "attribute",
+]
+categories = [
+    "no-std",
+    "no-std::no-alloc",
+    "rust-patterns",
+]
+license = "Apache-2.0 OR MIT"
+repository = "https://github.com/taiki-e/pin-project"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[lib]
+proc-macro = true
+
+[dependencies.proc-macro2]
+version = "1.0.60"
+
+[dependencies.quote]
+version = "1"
+
+[dependencies.syn]
+version = "2.0.1"
+features = [
+    "full",
+    "visit-mut",
+]
+
+[dev-dependencies]
diff --git a/crates/pin-project-internal/LICENSE b/crates/pin-project-internal/LICENSE
new file mode 120000
index 0000000..6b579aa
--- /dev/null
+++ b/crates/pin-project-internal/LICENSE
@@ -0,0 +1 @@
+LICENSE-APACHE
\ No newline at end of file
diff --git a/crates/pin-project-internal/LICENSE-APACHE b/crates/pin-project-internal/LICENSE-APACHE
new file mode 100644
index 0000000..f433b1a
--- /dev/null
+++ b/crates/pin-project-internal/LICENSE-APACHE
@@ -0,0 +1,177 @@
+
+                                 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
diff --git a/crates/pin-project-internal/LICENSE-MIT b/crates/pin-project-internal/LICENSE-MIT
new file mode 100644
index 0000000..31aa793
--- /dev/null
+++ b/crates/pin-project-internal/LICENSE-MIT
@@ -0,0 +1,23 @@
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/crates/pin-project-internal/METADATA b/crates/pin-project-internal/METADATA
new file mode 100644
index 0000000..cb08287
--- /dev/null
+++ b/crates/pin-project-internal/METADATA
@@ -0,0 +1,23 @@
+# This project was upgraded with external_updater.
+# Usage: tools/external_updater/updater.sh update rust/crates/pin-project-internal
+# For more info, check https://cs.android.com/android/platform/superproject/+/main:tools/external_updater/README.md
+
+name: "pin-project-internal"
+description: "Implementation detail of the `pin-project` crate."
+third_party {
+  url {
+    type: HOMEPAGE
+    value: "https://crates.io/crates/pin-project-internal"
+  }
+  url {
+    type: ARCHIVE
+    value: "https://static.crates.io/crates/pin-project-internal/pin-project-internal-1.1.3.crate"
+  }
+  version: "1.1.3"
+  license_type: NOTICE
+  last_upgrade_date {
+    year: 2023
+    month: 11
+    day: 14
+  }
+}
diff --git a/crates/pin-project-internal/MODULE_LICENSE_APACHE2 b/crates/pin-project-internal/MODULE_LICENSE_APACHE2
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/crates/pin-project-internal/MODULE_LICENSE_APACHE2
diff --git a/crates/pin-project-internal/NOTICE b/crates/pin-project-internal/NOTICE
new file mode 120000
index 0000000..7a694c9
--- /dev/null
+++ b/crates/pin-project-internal/NOTICE
@@ -0,0 +1 @@
+LICENSE
\ No newline at end of file
diff --git a/crates/pin-project-internal/TEST_MAPPING b/crates/pin-project-internal/TEST_MAPPING
new file mode 100644
index 0000000..664c4df
--- /dev/null
+++ b/crates/pin-project-internal/TEST_MAPPING
@@ -0,0 +1,11 @@
+// Generated by update_crate_tests.py for tests that depend on this crate.
+{
+  "imports": [
+    {
+      "path": "external/rust/crates/futures-channel"
+    },
+    {
+      "path": "external/rust/crates/futures-test"
+    }
+  ]
+}
diff --git a/crates/pin-project-internal/cargo_embargo.json b/crates/pin-project-internal/cargo_embargo.json
new file mode 100644
index 0000000..175f0bf
--- /dev/null
+++ b/crates/pin-project-internal/cargo_embargo.json
@@ -0,0 +1,8 @@
+{
+  "package": {
+    "pin-project-internal": {
+      "device_supported": false
+    }
+  },
+  "run_cargo": false
+}
diff --git a/crates/pin-project-internal/src/lib.rs b/crates/pin-project-internal/src/lib.rs
new file mode 100644
index 0000000..3eb3323
--- /dev/null
+++ b/crates/pin-project-internal/src/lib.rs
@@ -0,0 +1,583 @@
+//! Implementation detail of the `pin-project` crate. - **do not use directly**
+
+#![doc(test(
+    no_crate_inject,
+    attr(
+        deny(warnings, rust_2018_idioms, single_use_lifetimes),
+        allow(dead_code, unused_variables)
+    )
+))]
+#![forbid(unsafe_code)]
+#![warn(rust_2018_idioms, single_use_lifetimes, unreachable_pub)]
+#![warn(clippy::pedantic)]
+#![allow(
+    clippy::needless_doctest_main,
+    clippy::similar_names,
+    clippy::single_match_else,
+    clippy::too_many_lines
+)]
+
+// older compilers require explicit `extern crate`.
+#[allow(unused_extern_crates)]
+extern crate proc_macro;
+
+#[macro_use]
+mod utils;
+
+mod pin_project;
+mod pinned_drop;
+
+use proc_macro::TokenStream;
+
+/// An attribute that creates projection types covering all the fields of
+/// struct or enum.
+///
+/// This attribute creates projection types according to the following rules:
+///
+/// - For the fields that use `#[pin]` attribute, create the pinned reference to
+///   the field.
+/// - For the other fields, create a normal reference to the field.
+///
+/// And the following methods are implemented on the original type:
+///
+/// ```rust
+/// # use std::pin::Pin;
+/// # type Projection<'a> = &'a ();
+/// # type ProjectionRef<'a> = &'a ();
+/// # trait Dox {
+/// fn project(self: Pin<&mut Self>) -> Projection<'_>;
+/// fn project_ref(self: Pin<&Self>) -> ProjectionRef<'_>;
+/// # }
+/// ```
+///
+/// By passing an argument with the same name as the method to the attribute,
+/// you can name the projection type returned from the method. This allows you
+/// to use pattern matching on the projected types.
+///
+/// ```rust
+/// # use pin_project::pin_project;
+/// # use std::pin::Pin;
+/// #[pin_project(project = EnumProj)]
+/// enum Enum<T> {
+///     Variant(#[pin] T),
+/// }
+///
+/// impl<T> Enum<T> {
+///     fn method(self: Pin<&mut Self>) {
+///         let this: EnumProj<'_, T> = self.project();
+///         match this {
+///             EnumProj::Variant(x) => {
+///                 let _: Pin<&mut T> = x;
+///             }
+///         }
+///     }
+/// }
+/// ```
+///
+/// Note that the projection types returned by `project` and `project_ref` have
+/// an additional lifetime at the beginning of generics.
+///
+/// ```text
+/// let this: EnumProj<'_, T> = self.project();
+///                    ^^
+/// ```
+///
+/// The visibility of the projected types and projection methods is based on the
+/// original type. However, if the visibility of the original type is `pub`, the
+/// visibility of the projected types and the projection methods is downgraded
+/// to `pub(crate)`.
+///
+/// # Safety
+///
+/// This attribute is completely safe. In the absence of other `unsafe` code
+/// *that you write*, it is impossible to cause [undefined
+/// behavior][undefined-behavior] with this attribute.
+///
+/// This is accomplished by enforcing the four requirements for pin projection
+/// stated in [the Rust documentation][pin-projection]:
+///
+/// 1. The struct must only be [`Unpin`] if all the structural fields are
+///    [`Unpin`].
+///
+///    To enforce this, this attribute will automatically generate an [`Unpin`]
+///    implementation for you, which will require that all structurally pinned
+///    fields be [`Unpin`].
+///
+///    If you attempt to provide an [`Unpin`] impl, the blanket impl will then
+///    apply to your type, causing a compile-time error due to the conflict with
+///    the second impl.
+///
+///    If you wish to provide a manual [`Unpin`] impl, you can do so via the
+///    [`UnsafeUnpin`][unsafe-unpin] argument.
+///
+/// 2. The destructor of the struct must not move structural fields out of its
+///    argument.
+///
+///    To enforce this, this attribute will generate code like this:
+///
+///    ```rust
+///    struct MyStruct {}
+///    trait MyStructMustNotImplDrop {}
+///    # #[allow(unknown_lints, drop_bounds)]
+///    impl<T: Drop> MyStructMustNotImplDrop for T {}
+///    impl MyStructMustNotImplDrop for MyStruct {}
+///    ```
+///
+///    If you attempt to provide an [`Drop`] impl, the blanket impl will then
+///    apply to your type, causing a compile-time error due to the conflict with
+///    the second impl.
+///
+///    If you wish to provide a custom [`Drop`] impl, you can annotate an impl
+///    with [`#[pinned_drop]`][pinned-drop]. This impl takes a pinned version of
+///    your struct - that is, [`Pin`]`<&mut MyStruct>` where `MyStruct` is the
+///    type of your struct.
+///
+///    You can call `.project()` on this type as usual, along with any other
+///    methods you have defined. Because your code is never provided with
+///    a `&mut MyStruct`, it is impossible to move out of pin-projectable
+///    fields in safe code in your destructor.
+///
+/// 3. You must make sure that you uphold the [`Drop`
+///    guarantee][drop-guarantee]: once your struct is pinned, the memory that
+///    contains the content is not overwritten or deallocated without calling
+///    the content's destructors.
+///
+///    Safe code doesn't need to worry about this - the only way to violate
+///    this requirement is to manually deallocate memory (which is `unsafe`),
+///    or to overwrite a field with something else.
+///    Because your custom destructor takes [`Pin`]`<&mut MyStruct>`, it's
+///    impossible to obtain a mutable reference to a pin-projected field in safe
+///    code.
+///
+/// 4. You must not offer any other operations that could lead to data being
+///    moved out of the structural fields when your type is pinned.
+///
+///    As with requirement 3, it is impossible for safe code to violate this.
+///    This crate ensures that safe code can never obtain a mutable reference to
+///    `#[pin]` fields, which prevents you from ever moving out of them in safe
+///    code.
+///
+/// Pin projections are also incompatible with [`#[repr(packed)]`][repr-packed]
+/// types. Attempting to use this attribute on a `#[repr(packed)]` type results
+/// in a compile-time error.
+///
+/// # Examples
+///
+/// `#[pin_project]` can be used on structs and enums.
+///
+/// ```rust
+/// use std::pin::Pin;
+///
+/// use pin_project::pin_project;
+///
+/// #[pin_project]
+/// struct Struct<T, U> {
+///     #[pin]
+///     pinned: T,
+///     unpinned: U,
+/// }
+///
+/// impl<T, U> Struct<T, U> {
+///     fn method(self: Pin<&mut Self>) {
+///         let this = self.project();
+///         let _: Pin<&mut T> = this.pinned;
+///         let _: &mut U = this.unpinned;
+///     }
+/// }
+/// ```
+///
+/// ```rust
+/// use std::pin::Pin;
+///
+/// use pin_project::pin_project;
+///
+/// #[pin_project]
+/// struct TupleStruct<T, U>(#[pin] T, U);
+///
+/// impl<T, U> TupleStruct<T, U> {
+///     fn method(self: Pin<&mut Self>) {
+///         let this = self.project();
+///         let _: Pin<&mut T> = this.0;
+///         let _: &mut U = this.1;
+///     }
+/// }
+/// ```
+///
+/// To use `#[pin_project]` on enums, you need to name the projection type
+/// returned from the method.
+///
+/// ```rust
+/// use std::pin::Pin;
+///
+/// use pin_project::pin_project;
+///
+/// #[pin_project(project = EnumProj)]
+/// enum Enum<T, U> {
+///     Tuple(#[pin] T),
+///     Struct { field: U },
+///     Unit,
+/// }
+///
+/// impl<T, U> Enum<T, U> {
+///     fn method(self: Pin<&mut Self>) {
+///         match self.project() {
+///             EnumProj::Tuple(x) => {
+///                 let _: Pin<&mut T> = x;
+///             }
+///             EnumProj::Struct { field } => {
+///                 let _: &mut U = field;
+///             }
+///             EnumProj::Unit => {}
+///         }
+///     }
+/// }
+/// ```
+///
+/// When `#[pin_project]` is used on enums, only named projection types and
+/// methods are generated because there is no way to access variants of
+/// projected types without naming it.
+/// For example, in the above example, only the `project` method is generated,
+/// and the `project_ref` method is not generated.
+/// (When `#[pin_project]` is used on structs, both methods are always generated.)
+///
+/// ```rust,compile_fail,E0599
+/// # use pin_project::pin_project;
+/// # use std::pin::Pin;
+/// #
+/// # #[pin_project(project = EnumProj)]
+/// # enum Enum<T, U> {
+/// #     Tuple(#[pin] T),
+/// #     Struct { field: U },
+/// #     Unit,
+/// # }
+/// #
+/// impl<T, U> Enum<T, U> {
+///     fn call_project_ref(self: Pin<&Self>) {
+///         let _this = self.project_ref();
+///         //~^ ERROR no method named `project_ref` found for struct `Pin<&Enum<T, U>>` in the current scope
+///     }
+/// }
+/// ```
+///
+/// If you want to call `.project()` multiple times or later use the
+/// original [`Pin`] type, it needs to use [`.as_mut()`][`Pin::as_mut`] to avoid
+/// consuming the [`Pin`].
+///
+/// ```rust
+/// use std::pin::Pin;
+///
+/// use pin_project::pin_project;
+///
+/// #[pin_project]
+/// struct Struct<T> {
+///     #[pin]
+///     field: T,
+/// }
+///
+/// impl<T> Struct<T> {
+///     fn call_project_twice(mut self: Pin<&mut Self>) {
+///         // `project` consumes `self`, so reborrow the `Pin<&mut Self>` via `as_mut`.
+///         self.as_mut().project();
+///         self.as_mut().project();
+///     }
+/// }
+/// ```
+///
+/// # `!Unpin`
+///
+/// If you want to ensure that [`Unpin`] is not implemented, use the `!Unpin`
+/// argument to `#[pin_project]`.
+///
+/// ```rust
+/// use pin_project::pin_project;
+///
+/// #[pin_project(!Unpin)]
+/// struct Struct<T> {
+///     field: T,
+/// }
+/// ```
+///
+/// This is equivalent to using `#[pin]` attribute for the [`PhantomPinned`]
+/// field.
+///
+/// ```rust
+/// use std::marker::PhantomPinned;
+///
+/// use pin_project::pin_project;
+///
+/// #[pin_project]
+/// struct Struct<T> {
+///     field: T,
+///     #[pin] // <------ This `#[pin]` is required to make `Struct` to `!Unpin`.
+///     _pin: PhantomPinned,
+/// }
+/// ```
+///
+/// Note that using [`PhantomPinned`] without `#[pin]` attribute has no effect.
+///
+/// # `UnsafeUnpin`
+///
+/// If you want to implement [`Unpin`] manually, you must use the `UnsafeUnpin`
+/// argument to `#[pin_project]`.
+///
+/// ```rust
+/// use pin_project::{pin_project, UnsafeUnpin};
+///
+/// #[pin_project(UnsafeUnpin)]
+/// struct Struct<T, U> {
+///     #[pin]
+///     pinned: T,
+///     unpinned: U,
+/// }
+///
+/// unsafe impl<T: Unpin, U> UnsafeUnpin for Struct<T, U> {}
+/// ```
+///
+/// Note the usage of the unsafe [`UnsafeUnpin`] trait, instead of the usual
+/// [`Unpin`] trait. [`UnsafeUnpin`] behaves exactly like [`Unpin`], except that
+/// is unsafe to implement. This unsafety comes from the fact that pin
+/// projections are being used. If you implement [`UnsafeUnpin`], you must
+/// ensure that it is only implemented when all pin-projected fields implement
+/// [`Unpin`].
+///
+/// See [`UnsafeUnpin`] trait for more details.
+///
+/// # `#[pinned_drop]`
+///
+/// In order to correctly implement pin projections, a type's [`Drop`] impl must
+/// not move out of any structurally pinned fields. Unfortunately,
+/// [`Drop::drop`] takes `&mut Self`, not [`Pin`]`<&mut Self>`.
+///
+/// To ensure that this requirement is upheld, the `#[pin_project]` attribute
+/// will provide a [`Drop`] impl for you. This [`Drop`] impl will delegate to
+/// an impl block annotated with `#[pinned_drop]` if you use the `PinnedDrop`
+/// argument to `#[pin_project]`.
+///
+/// This impl block acts just like a normal [`Drop`] impl,
+/// except for the following two:
+///
+/// - `drop` method takes [`Pin`]`<&mut Self>`
+/// - Name of the trait is `PinnedDrop`.
+///
+/// ```rust
+/// # use std::pin::Pin;
+/// pub trait PinnedDrop {
+///     fn drop(self: Pin<&mut Self>);
+/// }
+/// ```
+///
+/// `#[pin_project]` implements the actual [`Drop`] trait via `PinnedDrop` you
+/// implemented. To drop a type that implements `PinnedDrop`, use the [`drop`]
+/// function just like dropping a type that directly implements [`Drop`].
+///
+/// In particular, it will never be called more than once, just like
+/// [`Drop::drop`].
+///
+/// For example:
+///
+/// ```rust
+/// use std::{fmt::Debug, pin::Pin};
+///
+/// use pin_project::{pin_project, pinned_drop};
+///
+/// #[pin_project(PinnedDrop)]
+/// struct PrintOnDrop<T: Debug, U: Debug> {
+///     #[pin]
+///     pinned_field: T,
+///     unpin_field: U,
+/// }
+///
+/// #[pinned_drop]
+/// impl<T: Debug, U: Debug> PinnedDrop for PrintOnDrop<T, U> {
+///     fn drop(self: Pin<&mut Self>) {
+///         println!("Dropping pinned field: {:?}", self.pinned_field);
+///         println!("Dropping unpin field: {:?}", self.unpin_field);
+///     }
+/// }
+///
+/// fn main() {
+///     let _x = PrintOnDrop { pinned_field: true, unpin_field: 40 };
+/// }
+/// ```
+///
+/// See also [`#[pinned_drop]`][macro@pinned_drop] attribute.
+///
+/// # `project_replace` method
+///
+/// In addition to the `project` and `project_ref` methods which are always
+/// provided when you use the `#[pin_project]` attribute, there is a third
+/// method, `project_replace` which can be useful in some situations. It is
+/// equivalent to [`Pin::set`], except that the unpinned fields are moved and
+/// returned, instead of being dropped in-place.
+///
+/// ```rust
+/// # use std::pin::Pin;
+/// # type ProjectionOwned = ();
+/// # trait Dox {
+/// fn project_replace(self: Pin<&mut Self>, other: Self) -> ProjectionOwned;
+/// # }
+/// ```
+///
+/// The `ProjectionOwned` type is identical to the `Self` type, except that
+/// all pinned fields have been replaced by equivalent [`PhantomData`] types.
+///
+/// This method is opt-in, because it is only supported for [`Sized`] types, and
+/// because it is incompatible with the [`#[pinned_drop]`][pinned-drop]
+/// attribute described above. It can be enabled by using
+/// `#[pin_project(project_replace)]`.
+///
+/// For example:
+///
+/// ```rust
+/// use std::{marker::PhantomData, pin::Pin};
+///
+/// use pin_project::pin_project;
+///
+/// #[pin_project(project_replace)]
+/// struct Struct<T, U> {
+///     #[pin]
+///     pinned_field: T,
+///     unpinned_field: U,
+/// }
+///
+/// impl<T, U> Struct<T, U> {
+///     fn method(self: Pin<&mut Self>, other: Self) {
+///         let this = self.project_replace(other);
+///         let _: U = this.unpinned_field;
+///         let _: PhantomData<T> = this.pinned_field;
+///     }
+/// }
+/// ```
+///
+/// By passing the value to the `project_replace` argument, you can name the
+/// returned type of the `project_replace` method. This is necessary whenever
+/// destructuring the return type of the `project_replace` method, and work in exactly
+/// the same way as the `project` and `project_ref` arguments.
+///
+/// ```rust
+/// use pin_project::pin_project;
+///
+/// #[pin_project(project_replace = EnumProjOwn)]
+/// enum Enum<T, U> {
+///     A {
+///         #[pin]
+///         pinned_field: T,
+///         unpinned_field: U,
+///     },
+///     B,
+/// }
+///
+/// let mut x = Box::pin(Enum::A { pinned_field: 42, unpinned_field: "hello" });
+///
+/// match x.as_mut().project_replace(Enum::B) {
+///     EnumProjOwn::A { unpinned_field, .. } => assert_eq!(unpinned_field, "hello"),
+///     EnumProjOwn::B => unreachable!(),
+/// }
+/// ```
+///
+/// [`PhantomData`]: core::marker::PhantomData
+/// [`PhantomPinned`]: core::marker::PhantomPinned
+/// [`Pin::as_mut`]: core::pin::Pin::as_mut
+/// [`Pin::set`]: core::pin::Pin::set
+/// [`Pin`]: core::pin::Pin
+/// [`UnsafeUnpin`]: https://docs.rs/pin-project/1/pin_project/trait.UnsafeUnpin.html
+/// [drop-guarantee]: core::pin#drop-guarantee
+/// [pin-projection]: core::pin#projections-and-structural-pinning
+/// [pinned-drop]: macro@pin_project#pinned_drop
+/// [repr-packed]: https://doc.rust-lang.org/nomicon/other-reprs.html#reprpacked
+/// [undefined-behavior]: https://doc.rust-lang.org/reference/behavior-considered-undefined.html
+/// [unsafe-unpin]: macro@pin_project#unsafeunpin
+#[proc_macro_attribute]
+pub fn pin_project(args: TokenStream, input: TokenStream) -> TokenStream {
+    pin_project::attribute(&args.into(), input.into()).into()
+}
+
+/// An attribute used for custom implementations of [`Drop`].
+///
+/// This attribute is used in conjunction with the `PinnedDrop` argument to
+/// the [`#[pin_project]`][macro@pin_project] attribute.
+///
+/// The impl block annotated with this attribute acts just like a normal
+/// [`Drop`] impl, except for the following two:
+///
+/// - `drop` method takes [`Pin`]`<&mut Self>`
+/// - Name of the trait is `PinnedDrop`.
+///
+/// ```rust
+/// # use std::pin::Pin;
+/// pub trait PinnedDrop {
+///     fn drop(self: Pin<&mut Self>);
+/// }
+/// ```
+///
+/// `#[pin_project]` implements the actual [`Drop`] trait via `PinnedDrop` you
+/// implemented. To drop a type that implements `PinnedDrop`, use the [`drop`]
+/// function just like dropping a type that directly implements [`Drop`].
+///
+/// In particular, it will never be called more than once, just like
+/// [`Drop::drop`].
+///
+/// # Examples
+///
+/// ```rust
+/// use std::pin::Pin;
+///
+/// use pin_project::{pin_project, pinned_drop};
+///
+/// #[pin_project(PinnedDrop)]
+/// struct PrintOnDrop {
+///     #[pin]
+///     field: u8,
+/// }
+///
+/// #[pinned_drop]
+/// impl PinnedDrop for PrintOnDrop {
+///     fn drop(self: Pin<&mut Self>) {
+///         println!("Dropping: {}", self.field);
+///     }
+/// }
+///
+/// fn main() {
+///     let _x = PrintOnDrop { field: 50 };
+/// }
+/// ```
+///
+/// See also ["pinned-drop" section of `#[pin_project]` attribute][pinned-drop].
+///
+/// # Why `#[pinned_drop]` attribute is needed?
+///
+/// Implementing `PinnedDrop::drop` is safe, but calling it is not safe.
+/// This is because destructors can be called multiple times in safe code and
+/// [double dropping is unsound][rust-lang/rust#62360].
+///
+/// Ideally, it would be desirable to be able to forbid manual calls in
+/// the same way as [`Drop::drop`], but the library cannot do it. So, by using
+/// macros and replacing them with private traits like the following,
+/// this crate prevent users from calling `PinnedDrop::drop` in safe code.
+///
+/// ```rust
+/// # use std::pin::Pin;
+/// pub trait PinnedDrop {
+///     unsafe fn drop(self: Pin<&mut Self>);
+/// }
+/// ```
+///
+/// This allows implementing [`Drop`] safely using `#[pinned_drop]`.
+/// Also by using the [`drop`] function just like dropping a type that directly
+/// implements [`Drop`], can drop safely a type that implements `PinnedDrop`.
+///
+/// [rust-lang/rust#62360]: https://github.com/rust-lang/rust/pull/62360
+/// [`Pin`]: core::pin::Pin
+/// [pinned-drop]: macro@pin_project#pinned_drop
+#[proc_macro_attribute]
+pub fn pinned_drop(args: TokenStream, input: TokenStream) -> TokenStream {
+    let input = syn::parse_macro_input!(input);
+    pinned_drop::attribute(&args.into(), input).into()
+}
+
+// Not public API.
+#[doc(hidden)]
+#[proc_macro_derive(__PinProjectInternalDerive, attributes(pin))]
+pub fn __pin_project_internal_derive(input: TokenStream) -> TokenStream {
+    pin_project::derive(input.into()).into()
+}
diff --git a/crates/pin-project-internal/src/pin_project/args.rs b/crates/pin-project-internal/src/pin_project/args.rs
new file mode 100644
index 0000000..0c688a5
--- /dev/null
+++ b/crates/pin-project-internal/src/pin_project/args.rs
@@ -0,0 +1,252 @@
+use proc_macro2::{Span, TokenStream};
+use quote::quote;
+use syn::{
+    parse::{Parse, ParseStream},
+    spanned::Spanned,
+    Attribute, Error, Ident, Result, Token,
+};
+
+use super::PIN;
+use crate::utils::{ParseBufferExt, SliceExt};
+
+pub(super) fn parse_args(attrs: &[Attribute]) -> Result<Args> {
+    // `(__private(<args>))` -> `<args>`
+    struct Input(Option<TokenStream>);
+
+    impl Parse for Input {
+        fn parse(input: ParseStream<'_>) -> Result<Self> {
+            Ok(Self((|| {
+                let private = input.parse::<Ident>().ok()?;
+                if private == "__private" {
+                    input.parenthesized().ok()?.parse::<TokenStream>().ok()
+                } else {
+                    None
+                }
+            })()))
+        }
+    }
+
+    if let Some(attr) = attrs.find("pin_project") {
+        bail!(attr, "duplicate #[pin_project] attribute");
+    }
+
+    let mut attrs = attrs.iter().filter(|attr| attr.path().is_ident(PIN));
+
+    let prev = if let Some(attr) = attrs.next() {
+        (attr, syn::parse2::<Input>(attr.meta.require_list()?.tokens.clone())?.0)
+    } else {
+        // This only fails if another macro removes `#[pin]`.
+        bail!(TokenStream::new(), "#[pin_project] attribute has been removed");
+    };
+
+    if let Some(attr) = attrs.next() {
+        let (prev_attr, prev_res) = &prev;
+        // As the `#[pin]` attribute generated by `#[pin_project]`
+        // has the same span as `#[pin_project]`, it is possible
+        // that a useless error message will be generated.
+        // So, use the span of `prev_attr` if it is not a valid attribute.
+        let res = syn::parse2::<Input>(attr.meta.require_list()?.tokens.clone())?.0;
+        let span = match (prev_res, res) {
+            (Some(_), _) => attr,
+            (None, _) => prev_attr,
+        };
+        bail!(span, "duplicate #[pin] attribute");
+    }
+    // This `unwrap` only fails if another macro removes `#[pin]` and inserts own `#[pin]`.
+    syn::parse2(prev.1.unwrap())
+}
+
+pub(super) struct Args {
+    /// `PinnedDrop` argument.
+    pub(super) pinned_drop: Option<Span>,
+    /// `UnsafeUnpin` or `!Unpin` argument.
+    pub(super) unpin_impl: UnpinImpl,
+    /// `project = <ident>` argument.
+    pub(super) project: Option<Ident>,
+    /// `project_ref = <ident>` argument.
+    pub(super) project_ref: Option<Ident>,
+    /// `project_replace [= <ident>]` argument.
+    pub(super) project_replace: ProjReplace,
+}
+
+impl Parse for Args {
+    fn parse(input: ParseStream<'_>) -> Result<Self> {
+        mod kw {
+            syn::custom_keyword!(Unpin);
+        }
+
+        /// Parses `= <value>` in `<name> = <value>` and returns value and span of name-value pair.
+        fn parse_value(
+            input: ParseStream<'_>,
+            name: &Ident,
+            has_prev: bool,
+        ) -> Result<(Ident, TokenStream)> {
+            if input.is_empty() {
+                bail!(name, "expected `{0} = <identifier>`, found `{0}`", name);
+            }
+            let eq_token: Token![=] = input.parse()?;
+            if input.is_empty() {
+                let span = quote!(#name #eq_token);
+                bail!(span, "expected `{0} = <identifier>`, found `{0} =`", name);
+            }
+            let value: Ident = input.parse()?;
+            let span = quote!(#name #value);
+            if has_prev {
+                bail!(span, "duplicate `{}` argument", name);
+            }
+            Ok((value, span))
+        }
+
+        let mut pinned_drop = None;
+        let mut unsafe_unpin = None;
+        let mut not_unpin = None;
+        let mut project = None;
+        let mut project_ref = None;
+        let mut project_replace_value = None;
+        let mut project_replace_span = None;
+
+        while !input.is_empty() {
+            if input.peek(Token![!]) {
+                let bang: Token![!] = input.parse()?;
+                if input.is_empty() {
+                    bail!(bang, "expected `!Unpin`, found `!`");
+                }
+                let unpin: kw::Unpin = input.parse()?;
+                let span = quote!(#bang #unpin);
+                if not_unpin.replace(span.span()).is_some() {
+                    bail!(span, "duplicate `!Unpin` argument");
+                }
+            } else {
+                let token = input.parse::<Ident>()?;
+                match &*token.to_string() {
+                    "PinnedDrop" => {
+                        if pinned_drop.replace(token.span()).is_some() {
+                            bail!(token, "duplicate `PinnedDrop` argument");
+                        }
+                    }
+                    "UnsafeUnpin" => {
+                        if unsafe_unpin.replace(token.span()).is_some() {
+                            bail!(token, "duplicate `UnsafeUnpin` argument");
+                        }
+                    }
+                    "project" => {
+                        project = Some(parse_value(input, &token, project.is_some())?.0);
+                    }
+                    "project_ref" => {
+                        project_ref = Some(parse_value(input, &token, project_ref.is_some())?.0);
+                    }
+                    "project_replace" => {
+                        if input.peek(Token![=]) {
+                            let (value, span) =
+                                parse_value(input, &token, project_replace_span.is_some())?;
+                            project_replace_value = Some(value);
+                            project_replace_span = Some(span.span());
+                        } else if project_replace_span.is_some() {
+                            bail!(token, "duplicate `project_replace` argument");
+                        } else {
+                            project_replace_span = Some(token.span());
+                        }
+                    }
+                    "Replace" => {
+                        bail!(
+                            token,
+                            "`Replace` argument was removed, use `project_replace` argument instead"
+                        );
+                    }
+                    _ => bail!(token, "unexpected argument: {}", token),
+                }
+            }
+
+            if input.is_empty() {
+                break;
+            }
+            let _: Token![,] = input.parse()?;
+        }
+
+        if project.is_some() || project_ref.is_some() {
+            if project == project_ref {
+                bail!(
+                    project_ref,
+                    "name `{}` is already specified by `project` argument",
+                    project_ref.as_ref().unwrap()
+                );
+            }
+            if let Some(ident) = &project_replace_value {
+                if project == project_replace_value {
+                    bail!(ident, "name `{}` is already specified by `project` argument", ident);
+                } else if project_ref == project_replace_value {
+                    bail!(ident, "name `{}` is already specified by `project_ref` argument", ident);
+                }
+            }
+        }
+
+        if let Some(span) = pinned_drop {
+            if project_replace_span.is_some() {
+                return Err(Error::new(
+                    span,
+                    "arguments `PinnedDrop` and `project_replace` are mutually exclusive",
+                ));
+            }
+        }
+        let project_replace = match (project_replace_span, project_replace_value) {
+            (None, _) => ProjReplace::None,
+            (Some(span), Some(ident)) => ProjReplace::Named { ident, span },
+            (Some(span), None) => ProjReplace::Unnamed { span },
+        };
+        let unpin_impl = match (unsafe_unpin, not_unpin) {
+            (None, None) => UnpinImpl::Default,
+            (Some(span), None) => UnpinImpl::Unsafe(span),
+            (None, Some(span)) => UnpinImpl::Negative(span),
+            (Some(span), Some(_)) => {
+                return Err(Error::new(
+                    span,
+                    "arguments `UnsafeUnpin` and `!Unpin` are mutually exclusive",
+                ));
+            }
+        };
+
+        Ok(Self { pinned_drop, unpin_impl, project, project_ref, project_replace })
+    }
+}
+
+/// `UnsafeUnpin` or `!Unpin` argument.
+#[derive(Clone, Copy)]
+pub(super) enum UnpinImpl {
+    Default,
+    /// `UnsafeUnpin`.
+    Unsafe(Span),
+    /// `!Unpin`.
+    Negative(Span),
+}
+
+/// `project_replace [= <ident>]` argument.
+pub(super) enum ProjReplace {
+    None,
+    /// `project_replace`.
+    Unnamed {
+        span: Span,
+    },
+    /// `project_replace = <ident>`.
+    Named {
+        span: Span,
+        ident: Ident,
+    },
+}
+
+impl ProjReplace {
+    /// Return the span of this argument.
+    pub(super) fn span(&self) -> Option<Span> {
+        match self {
+            Self::None => None,
+            Self::Named { span, .. } | Self::Unnamed { span, .. } => Some(*span),
+        }
+    }
+
+    pub(super) fn ident(&self) -> Option<&Ident> {
+        if let Self::Named { ident, .. } = self {
+            Some(ident)
+        } else {
+            None
+        }
+    }
+}
diff --git a/crates/pin-project-internal/src/pin_project/attribute.rs b/crates/pin-project-internal/src/pin_project/attribute.rs
new file mode 100644
index 0000000..09cd8c7
--- /dev/null
+++ b/crates/pin-project-internal/src/pin_project/attribute.rs
@@ -0,0 +1,64 @@
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{
+    parse::{Parse, ParseStream},
+    Attribute, Result, Token, Visibility,
+};
+
+use super::PIN;
+use crate::utils::SliceExt;
+
+// To generate the correct `Unpin` implementation and the projection methods,
+// we need to collect the types of the pinned fields.
+// However, since proc-macro-attribute is applied before `cfg` and `cfg_attr`
+// on fields, we cannot be collecting field types properly at this timing.
+// So instead of generating the `Unpin` implementation and the projection
+// methods here, delegate their processing to proc-macro-derive.
+//
+// At this stage, only attributes are parsed and the following attributes are
+// added to the attributes of the item.
+// - `#[derive(InternalDerive)]` - An internal helper macro that does the above
+//   processing.
+// - `#[pin(__private(#args))]` - Pass the argument of `#[pin_project]` to
+//   proc-macro-derive (`InternalDerive`).
+
+pub(super) fn parse_attribute(args: &TokenStream, input: TokenStream) -> Result<TokenStream> {
+    let Input { attrs, body } = syn::parse2(input)?;
+
+    Ok(quote! {
+        #(#attrs)*
+        #[derive(::pin_project::__private::__PinProjectInternalDerive)]
+        // Use `__private` to prevent users from trying to control `InternalDerive`
+        // manually. `__private` does not guarantee compatibility between patch
+        // versions, so it should be sufficient for this purpose in most cases.
+        #[pin(__private(#args))]
+        #body
+    })
+}
+
+struct Input {
+    attrs: Vec<Attribute>,
+    body: TokenStream,
+}
+
+impl Parse for Input {
+    fn parse(input: ParseStream<'_>) -> Result<Self> {
+        let attrs = input.call(Attribute::parse_outer)?;
+
+        let ahead = input.fork();
+        let _vis: Visibility = ahead.parse()?;
+        if !ahead.peek(Token![struct]) && !ahead.peek(Token![enum]) {
+            // If we check this only on proc-macro-derive, it may generate unhelpful error
+            // messages. So it is preferable to be able to detect it here.
+            bail!(
+                input.parse::<TokenStream>()?,
+                "#[pin_project] attribute may only be used on structs or enums"
+            );
+        } else if let Some(attr) = attrs.find(PIN) {
+            bail!(attr, "#[pin] attribute may only be used on fields of structs or variants");
+        } else if let Some(attr) = attrs.find("pin_project") {
+            bail!(attr, "duplicate #[pin_project] attribute");
+        }
+        Ok(Self { attrs, body: input.parse()? })
+    }
+}
diff --git a/crates/pin-project-internal/src/pin_project/derive.rs b/crates/pin-project-internal/src/pin_project/derive.rs
new file mode 100644
index 0000000..bea17fe
--- /dev/null
+++ b/crates/pin-project-internal/src/pin_project/derive.rs
@@ -0,0 +1,1126 @@
+use proc_macro2::{Delimiter, Group, Span, TokenStream};
+use quote::{format_ident, quote, quote_spanned, ToTokens};
+use syn::{
+    parse_quote, punctuated::Punctuated, token, visit_mut::VisitMut, Attribute, Data, DataEnum,
+    DeriveInput, Error, Field, Fields, FieldsNamed, FieldsUnnamed, Generics, Ident, Index,
+    Lifetime, LifetimeParam, Meta, Result, Token, Type, Variant, Visibility, WhereClause,
+};
+
+use super::{
+    args::{parse_args, Args, ProjReplace, UnpinImpl},
+    PIN,
+};
+use crate::utils::{
+    determine_lifetime_name, determine_visibility, insert_lifetime_and_bound, ReplaceReceiver,
+    SliceExt, Variants,
+};
+
+pub(super) fn parse_derive(input: TokenStream) -> Result<TokenStream> {
+    let mut input: DeriveInput = syn::parse2(input)?;
+
+    let mut cx;
+    let mut generate = GenerateTokens::default();
+
+    let ident = &input.ident;
+    let ty_generics = input.generics.split_for_impl().1;
+    let self_ty = parse_quote!(#ident #ty_generics);
+    let mut visitor = ReplaceReceiver(&self_ty);
+    visitor.visit_generics_mut(&mut input.generics);
+    visitor.visit_data_mut(&mut input.data);
+
+    match &input.data {
+        Data::Struct(data) => {
+            cx = Context::new(&input.attrs, &input.vis, ident, &mut input.generics, Struct)?;
+            parse_struct(&mut cx, &data.fields, &mut generate)?;
+        }
+        Data::Enum(data) => {
+            cx = Context::new(&input.attrs, &input.vis, ident, &mut input.generics, Enum)?;
+            parse_enum(&mut cx, data, &mut generate)?;
+        }
+        Data::Union(_) => {
+            bail!(input, "#[pin_project] attribute may only be used on structs or enums");
+        }
+    }
+
+    Ok(generate.into_tokens(&cx))
+}
+
+#[derive(Default)]
+struct GenerateTokens {
+    exposed: TokenStream,
+    scoped: TokenStream,
+}
+
+impl GenerateTokens {
+    fn extend(&mut self, expose: bool, tokens: TokenStream) {
+        if expose {
+            self.exposed.extend(tokens);
+        } else {
+            self.scoped.extend(tokens);
+        }
+    }
+
+    fn into_tokens(self, cx: &Context<'_>) -> TokenStream {
+        let mut tokens = self.exposed;
+        let scoped = self.scoped;
+
+        let unpin_impl = make_unpin_impl(cx);
+        let drop_impl = make_drop_impl(cx);
+        let allowed_lints = global_allowed_lints();
+
+        tokens.extend(quote! {
+            // All items except projected types are generated inside a `const` scope.
+            // This makes it impossible for user code to refer to these types.
+            // However, this prevents Rustdoc from displaying docs for any
+            // of our types. In particular, users cannot see the
+            // automatically generated `Unpin` impl for the '__UnpinStruct' types
+            //
+            // Previously, we provided a flag to correctly document the
+            // automatically generated `Unpin` impl by using def-site hygiene,
+            // but it is now removed.
+            //
+            // Refs:
+            // - https://github.com/rust-lang/rust/issues/63281
+            // - https://github.com/taiki-e/pin-project/pull/53#issuecomment-525906867
+            // - https://github.com/taiki-e/pin-project/pull/70
+            #allowed_lints
+            #[allow(unused_qualifications)]
+            #[allow(clippy::semicolon_if_nothing_returned)]
+            #[allow(clippy::use_self)]
+            #[allow(clippy::used_underscore_binding)]
+            const _: () = {
+                #[allow(unused_extern_crates)]
+                extern crate pin_project as _pin_project;
+                #scoped
+                #unpin_impl
+                #drop_impl
+            };
+        });
+        tokens
+    }
+}
+
+/// Returns attributes that should be applied to all generated code.
+fn global_allowed_lints() -> TokenStream {
+    quote! {
+        #[allow(box_pointers)] // This lint warns use of the `Box` type.
+        #[allow(deprecated)]
+        #[allow(explicit_outlives_requirements)] // https://github.com/rust-lang/rust/issues/60993
+        #[allow(single_use_lifetimes)] // https://github.com/rust-lang/rust/issues/55058
+        #[allow(unreachable_pub)] // This lint warns `pub` field in private struct.
+        #[allow(unused_tuple_struct_fields)]
+        // This lint warns of `clippy::*` generated by external macros.
+        // We allow this lint for compatibility with older compilers.
+        #[allow(clippy::unknown_clippy_lints)]
+        #[allow(clippy::pattern_type_mismatch)]
+        #[allow(clippy::redundant_pub_crate)] // This lint warns `pub(crate)` field in private struct.
+        #[allow(clippy::type_repetition_in_bounds)] // https://github.com/rust-lang/rust-clippy/issues/4326
+    }
+}
+
+/// Returns attributes used on projected types.
+fn proj_allowed_lints(cx: &Context<'_>) -> (TokenStream, TokenStream, TokenStream) {
+    let large_enum_variant = if cx.kind == Enum {
+        Some(quote! {
+            #[allow(variant_size_differences)]
+            #[allow(clippy::large_enum_variant)]
+        })
+    } else {
+        None
+    };
+    let global_allowed_lints = global_allowed_lints();
+    let proj_mut_allowed_lints = if cx.project { Some(&global_allowed_lints) } else { None };
+    let proj_mut = quote! {
+        #proj_mut_allowed_lints
+        #[allow(dead_code)] // This lint warns unused fields/variants.
+        #[allow(clippy::mut_mut)] // This lint warns `&mut &mut <ty>`.
+    };
+    let proj_ref_allowed_lints = if cx.project_ref { Some(&global_allowed_lints) } else { None };
+    let proj_ref = quote! {
+        #proj_ref_allowed_lints
+        #[allow(dead_code)] // This lint warns unused fields/variants.
+        #[allow(clippy::ref_option_ref)] // This lint warns `&Option<&<ty>>`.
+    };
+    let proj_own_allowed_lints =
+        if cx.project_replace.ident().is_some() { Some(&global_allowed_lints) } else { None };
+    let proj_own = quote! {
+        #proj_own_allowed_lints
+        #[allow(dead_code)] // This lint warns unused fields/variants.
+        #large_enum_variant
+    };
+    (proj_mut, proj_ref, proj_own)
+}
+
+struct Context<'a> {
+    /// The original type.
+    orig: OriginalType<'a>,
+    /// The projected types.
+    proj: ProjectedType,
+    /// Types of the pinned fields.
+    pinned_fields: Vec<&'a Type>,
+    /// Kind of the original type: struct or enum
+    kind: TypeKind,
+
+    /// `PinnedDrop` argument.
+    pinned_drop: Option<Span>,
+    /// `UnsafeUnpin` or `!Unpin` argument.
+    unpin_impl: UnpinImpl,
+    /// `project` argument.
+    project: bool,
+    /// `project_ref` argument.
+    project_ref: bool,
+    /// `project_replace [= <ident>]` argument.
+    project_replace: ProjReplace,
+}
+
+impl<'a> Context<'a> {
+    fn new(
+        attrs: &'a [Attribute],
+        vis: &'a Visibility,
+        ident: &'a Ident,
+        generics: &'a mut Generics,
+        kind: TypeKind,
+    ) -> Result<Self> {
+        let Args { pinned_drop, unpin_impl, project, project_ref, project_replace } =
+            parse_args(attrs)?;
+
+        if let Some(name) = [project.as_ref(), project_ref.as_ref(), project_replace.ident()]
+            .iter()
+            .filter_map(Option::as_ref)
+            .find(|name| **name == ident)
+        {
+            bail!(name, "name `{}` is the same as the original type name", name);
+        }
+
+        let mut lifetime_name = String::from("'pin");
+        determine_lifetime_name(&mut lifetime_name, generics);
+        let lifetime = Lifetime::new(&lifetime_name, Span::call_site());
+
+        let ty_generics = generics.split_for_impl().1;
+        let ty_generics_as_generics = parse_quote!(#ty_generics);
+        let mut proj_generics = generics.clone();
+        let pred = insert_lifetime_and_bound(
+            &mut proj_generics,
+            lifetime.clone(),
+            &ty_generics_as_generics,
+            ident,
+        );
+        let mut where_clause = generics.make_where_clause().clone();
+        where_clause.predicates.push(pred);
+
+        let own_ident = project_replace
+            .ident()
+            .cloned()
+            .unwrap_or_else(|| format_ident!("__{}ProjectionOwned", ident));
+
+        Ok(Self {
+            kind,
+            pinned_drop,
+            unpin_impl,
+            project: project.is_some(),
+            project_ref: project_ref.is_some(),
+            project_replace,
+            proj: ProjectedType {
+                vis: determine_visibility(vis),
+                mut_ident: project.unwrap_or_else(|| format_ident!("__{}Projection", ident)),
+                ref_ident: project_ref.unwrap_or_else(|| format_ident!("__{}ProjectionRef", ident)),
+                own_ident,
+                lifetime,
+                generics: proj_generics,
+                where_clause,
+            },
+            orig: OriginalType { attrs, vis, ident, generics },
+            pinned_fields: Vec::new(),
+        })
+    }
+}
+
+#[derive(Copy, Clone, PartialEq)]
+enum TypeKind {
+    Enum,
+    Struct,
+}
+
+use TypeKind::{Enum, Struct};
+
+struct OriginalType<'a> {
+    /// Attributes of the original type.
+    attrs: &'a [Attribute],
+    /// Visibility of the original type.
+    vis: &'a Visibility,
+    /// Name of the original type.
+    ident: &'a Ident,
+    /// Generics of the original type.
+    generics: &'a Generics,
+}
+
+struct ProjectedType {
+    /// Visibility of the projected types.
+    vis: Visibility,
+    /// Name of the projected type returned by `project` method.
+    mut_ident: Ident,
+    /// Name of the projected type returned by `project_ref` method.
+    ref_ident: Ident,
+    /// Name of the projected type returned by `project_replace` method.
+    own_ident: Ident,
+    /// Lifetime on the generated projected types.
+    lifetime: Lifetime,
+    /// Generics of the projected types.
+    generics: Generics,
+    /// `where` clause of the projected types. This has an additional
+    /// bound generated by `insert_lifetime_and_bound`
+    where_clause: WhereClause,
+}
+
+struct ProjectedVariants {
+    proj_variants: TokenStream,
+    proj_ref_variants: TokenStream,
+    proj_own_variants: TokenStream,
+    proj_arms: TokenStream,
+    proj_ref_arms: TokenStream,
+    proj_own_arms: TokenStream,
+}
+
+#[derive(Default)]
+struct ProjectedFields {
+    proj_pat: TokenStream,
+    proj_body: TokenStream,
+    proj_own_body: TokenStream,
+    proj_fields: TokenStream,
+    proj_ref_fields: TokenStream,
+    proj_own_fields: TokenStream,
+}
+
+fn validate_struct(ident: &Ident, fields: &Fields) -> Result<()> {
+    if fields.is_empty() {
+        let msg = "#[pin_project] attribute may not be used on structs with zero fields";
+        if let Fields::Unit = fields {
+            bail!(ident, msg)
+        }
+        bail!(fields, msg)
+    }
+    Ok(())
+}
+
+fn validate_enum(brace_token: token::Brace, variants: &Variants) -> Result<()> {
+    if variants.is_empty() {
+        return Err(Error::new(
+            brace_token.span.join(),
+            "#[pin_project] attribute may not be used on enums without variants",
+        ));
+    }
+    let has_field = variants.iter().try_fold(false, |has_field, v| {
+        if let Some((_, e)) = &v.discriminant {
+            bail!(e, "#[pin_project] attribute may not be used on enums with discriminants");
+        } else if let Some(attr) = v.attrs.find(PIN) {
+            bail!(attr, "#[pin] attribute may only be used on fields of structs or variants");
+        } else if v.fields.is_empty() {
+            Ok(has_field)
+        } else {
+            Ok(true)
+        }
+    })?;
+    if has_field {
+        Ok(())
+    } else {
+        bail!(variants, "#[pin_project] attribute may not be used on enums with zero fields");
+    }
+}
+
+fn parse_struct<'a>(
+    cx: &mut Context<'a>,
+    fields: &'a Fields,
+    generate: &mut GenerateTokens,
+) -> Result<()> {
+    // Do this first for a better error message.
+    let packed_check = ensure_not_packed(&cx.orig, Some(fields))?;
+
+    validate_struct(cx.orig.ident, fields)?;
+
+    let ProjectedFields {
+        proj_pat,
+        proj_body,
+        proj_fields,
+        proj_ref_fields,
+        proj_own_fields,
+        proj_own_body,
+    } = match fields {
+        Fields::Named(_) => visit_fields(cx, None, fields, Delimiter::Brace)?,
+        Fields::Unnamed(_) => visit_fields(cx, None, fields, Delimiter::Parenthesis)?,
+        Fields::Unit => unreachable!(),
+    };
+
+    let proj_ident = &cx.proj.mut_ident;
+    let proj_ref_ident = &cx.proj.ref_ident;
+    let proj_own_ident = &cx.proj.own_ident;
+    let vis = &cx.proj.vis;
+    let mut orig_generics = cx.orig.generics.clone();
+    let orig_where_clause = orig_generics.where_clause.take();
+    let proj_generics = &cx.proj.generics;
+    let proj_where_clause = &cx.proj.where_clause;
+
+    // For tuple structs, we need to generate `(T1, T2) where Foo: Bar`
+    // For non-tuple structs, we need to generate `where Foo: Bar { field1: T }`
+    let (where_clause_fields, where_clause_ref_fields, where_clause_own_fields) = match fields {
+        Fields::Named(_) => (
+            quote!(#proj_where_clause #proj_fields),
+            quote!(#proj_where_clause #proj_ref_fields),
+            quote!(#orig_where_clause #proj_own_fields),
+        ),
+        Fields::Unnamed(_) => (
+            quote!(#proj_fields #proj_where_clause;),
+            quote!(#proj_ref_fields #proj_where_clause;),
+            quote!(#proj_own_fields #orig_where_clause;),
+        ),
+        Fields::Unit => unreachable!(),
+    };
+
+    let (proj_attrs, proj_ref_attrs, proj_own_attrs) = proj_allowed_lints(cx);
+    generate.extend(cx.project, quote! {
+        #proj_attrs
+        #vis struct #proj_ident #proj_generics #where_clause_fields
+    });
+    generate.extend(cx.project_ref, quote! {
+        #proj_ref_attrs
+        #vis struct #proj_ref_ident #proj_generics #where_clause_ref_fields
+    });
+    if cx.project_replace.span().is_some() {
+        generate.extend(cx.project_replace.ident().is_some(), quote! {
+            #proj_own_attrs
+            #vis struct #proj_own_ident #orig_generics #where_clause_own_fields
+        });
+    }
+
+    let proj_mut_body = quote! {
+        let Self #proj_pat = self.get_unchecked_mut();
+        #proj_ident #proj_body
+    };
+    let proj_ref_body = quote! {
+        let Self #proj_pat = self.get_ref();
+        #proj_ref_ident #proj_body
+    };
+    let proj_own_body = quote! {
+        let Self #proj_pat = &mut *__self_ptr;
+        #proj_own_body
+    };
+    generate.extend(false, make_proj_impl(cx, &proj_mut_body, &proj_ref_body, &proj_own_body));
+
+    generate.extend(false, packed_check);
+    Ok(())
+}
+
+fn parse_enum<'a>(
+    cx: &mut Context<'a>,
+    DataEnum { brace_token, variants, .. }: &'a DataEnum,
+    generate: &mut GenerateTokens,
+) -> Result<()> {
+    if let ProjReplace::Unnamed { span } = &cx.project_replace {
+        return Err(Error::new(
+            *span,
+            "`project_replace` argument requires a value when used on enums",
+        ));
+    }
+
+    // #[repr(packed)] cannot be apply on enums and will be rejected by rustc.
+    // However, we should not rely on the behavior of rustc that rejects this.
+    // https://github.com/taiki-e/pin-project/pull/324#discussion_r612388001
+    //
+    // Do this first for a better error message.
+    ensure_not_packed(&cx.orig, None)?;
+
+    validate_enum(*brace_token, variants)?;
+
+    let ProjectedVariants {
+        proj_variants,
+        proj_ref_variants,
+        proj_own_variants,
+        proj_arms,
+        proj_ref_arms,
+        proj_own_arms,
+    } = visit_variants(cx, variants)?;
+
+    let proj_ident = &cx.proj.mut_ident;
+    let proj_ref_ident = &cx.proj.ref_ident;
+    let proj_own_ident = &cx.proj.own_ident;
+    let vis = &cx.proj.vis;
+    let mut orig_generics = cx.orig.generics.clone();
+    let orig_where_clause = orig_generics.where_clause.take();
+    let proj_generics = &cx.proj.generics;
+    let proj_where_clause = &cx.proj.where_clause;
+
+    let (proj_attrs, proj_ref_attrs, proj_own_attrs) = proj_allowed_lints(cx);
+    if cx.project {
+        generate.extend(true, quote! {
+            #proj_attrs
+            #vis enum #proj_ident #proj_generics #proj_where_clause {
+                #proj_variants
+            }
+        });
+    }
+    if cx.project_ref {
+        generate.extend(true, quote! {
+            #proj_ref_attrs
+            #vis enum #proj_ref_ident #proj_generics #proj_where_clause {
+                #proj_ref_variants
+            }
+        });
+    }
+    if cx.project_replace.ident().is_some() {
+        generate.extend(true, quote! {
+            #proj_own_attrs
+            #vis enum #proj_own_ident #orig_generics #orig_where_clause {
+                #proj_own_variants
+            }
+        });
+    }
+
+    let proj_mut_body = quote! {
+        match self.get_unchecked_mut() {
+            #proj_arms
+        }
+    };
+    let proj_ref_body = quote! {
+        match self.get_ref() {
+            #proj_ref_arms
+        }
+    };
+    let proj_own_body = quote! {
+        match &mut *__self_ptr {
+            #proj_own_arms
+        }
+    };
+    generate.extend(false, make_proj_impl(cx, &proj_mut_body, &proj_ref_body, &proj_own_body));
+
+    Ok(())
+}
+
+fn visit_variants<'a>(cx: &mut Context<'a>, variants: &'a Variants) -> Result<ProjectedVariants> {
+    let mut proj_variants = TokenStream::new();
+    let mut proj_ref_variants = TokenStream::new();
+    let mut proj_own_variants = TokenStream::new();
+    let mut proj_arms = TokenStream::new();
+    let mut proj_ref_arms = TokenStream::new();
+    let mut proj_own_arms = TokenStream::new();
+
+    for Variant { ident, fields, .. } in variants {
+        let ProjectedFields {
+            proj_pat,
+            proj_body,
+            proj_fields,
+            proj_ref_fields,
+            proj_own_fields,
+            proj_own_body,
+        } = match fields {
+            Fields::Named(_) => visit_fields(cx, Some(ident), fields, Delimiter::Brace)?,
+            Fields::Unnamed(_) => visit_fields(cx, Some(ident), fields, Delimiter::Parenthesis)?,
+            Fields::Unit => ProjectedFields {
+                proj_own_body: proj_own_body(cx, Some(ident), None, &[]),
+                ..Default::default()
+            },
+        };
+
+        let proj_ident = &cx.proj.mut_ident;
+        let proj_ref_ident = &cx.proj.ref_ident;
+        proj_variants.extend(quote! {
+            #ident #proj_fields,
+        });
+        proj_ref_variants.extend(quote! {
+            #ident #proj_ref_fields,
+        });
+        proj_own_variants.extend(quote! {
+            #ident #proj_own_fields,
+        });
+        proj_arms.extend(quote! {
+            Self::#ident #proj_pat => #proj_ident::#ident #proj_body,
+        });
+        proj_ref_arms.extend(quote! {
+            Self::#ident #proj_pat => #proj_ref_ident::#ident #proj_body,
+        });
+        proj_own_arms.extend(quote! {
+            Self::#ident #proj_pat => { #proj_own_body }
+        });
+    }
+
+    Ok(ProjectedVariants {
+        proj_variants,
+        proj_ref_variants,
+        proj_own_variants,
+        proj_arms,
+        proj_ref_arms,
+        proj_own_arms,
+    })
+}
+
+fn visit_fields<'a>(
+    cx: &mut Context<'a>,
+    variant_ident: Option<&Ident>,
+    fields: &'a Fields,
+    delim: Delimiter,
+) -> Result<ProjectedFields> {
+    fn surround(delim: Delimiter, tokens: TokenStream) -> TokenStream {
+        Group::new(delim, tokens).into_token_stream()
+    }
+
+    let mut proj_pat = TokenStream::new();
+    let mut proj_body = TokenStream::new();
+    let mut proj_fields = TokenStream::new();
+    let mut proj_ref_fields = TokenStream::new();
+    let mut proj_own_fields = TokenStream::new();
+    let mut proj_move = TokenStream::new();
+    let mut pinned_bindings = Vec::with_capacity(fields.len());
+
+    for (i, Field { attrs, vis, ident, colon_token, ty, mutability: _ }) in
+        fields.iter().enumerate()
+    {
+        let binding = ident.clone().unwrap_or_else(|| format_ident!("_{}", i));
+        proj_pat.extend(quote!(#binding,));
+        let lifetime = &cx.proj.lifetime;
+        if attrs.position_exact(PIN)?.is_some() {
+            proj_fields.extend(quote! {
+                #vis #ident #colon_token ::pin_project::__private::Pin<&#lifetime mut (#ty)>,
+            });
+            proj_ref_fields.extend(quote! {
+                #vis #ident #colon_token ::pin_project::__private::Pin<&#lifetime (#ty)>,
+            });
+            proj_own_fields.extend(quote! {
+                #vis #ident #colon_token ::pin_project::__private::PhantomData<#ty>,
+            });
+            proj_body.extend(quote! {
+                #ident #colon_token _pin_project::__private::Pin::new_unchecked(#binding),
+            });
+            proj_move.extend(quote! {
+                #ident #colon_token _pin_project::__private::PhantomData,
+            });
+
+            cx.pinned_fields.push(ty);
+            pinned_bindings.push(binding);
+        } else {
+            proj_fields.extend(quote! {
+                #vis #ident #colon_token &#lifetime mut (#ty),
+            });
+            proj_ref_fields.extend(quote! {
+                #vis #ident #colon_token &#lifetime (#ty),
+            });
+            proj_own_fields.extend(quote! {
+                #vis #ident #colon_token #ty,
+            });
+            proj_body.extend(quote! {
+                #binding,
+            });
+            proj_move.extend(quote! {
+                #ident #colon_token _pin_project::__private::ptr::read(#binding),
+            });
+        }
+    }
+
+    let proj_pat = surround(delim, proj_pat);
+    let proj_body = surround(delim, proj_body);
+    let proj_fields = surround(delim, proj_fields);
+    let proj_ref_fields = surround(delim, proj_ref_fields);
+    let proj_own_fields = surround(delim, proj_own_fields);
+
+    let proj_move = Group::new(delim, proj_move);
+    let proj_own_body = proj_own_body(cx, variant_ident, Some(&proj_move), &pinned_bindings);
+
+    Ok(ProjectedFields {
+        proj_pat,
+        proj_body,
+        proj_own_body,
+        proj_fields,
+        proj_ref_fields,
+        proj_own_fields,
+    })
+}
+
+/// Generates the processing that `project_replace` does for the struct or each variant.
+///
+/// Note: `pinned_fields` must be in declaration order.
+fn proj_own_body(
+    cx: &Context<'_>,
+    variant_ident: Option<&Ident>,
+    proj_move: Option<&Group>,
+    pinned_fields: &[Ident],
+) -> TokenStream {
+    let ident = &cx.proj.own_ident;
+    let proj_own = match variant_ident {
+        Some(variant_ident) => quote!(#ident::#variant_ident),
+        None => quote!(#ident),
+    };
+
+    // The fields of the struct and the active enum variant are dropped
+    // in declaration order.
+    // Refs: https://doc.rust-lang.org/reference/destructors.html
+    let pinned_fields = pinned_fields.iter().rev();
+
+    quote! {
+        // First, extract all the unpinned fields.
+        let __result = #proj_own #proj_move;
+
+        // Now create guards to drop all the pinned fields.
+        //
+        // Due to a compiler bug (https://github.com/rust-lang/rust/issues/47949)
+        // this must be in its own scope, or else `__result` will not be dropped
+        // if any of the destructors panic.
+        {
+            #(
+                let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(#pinned_fields);
+            )*
+        }
+
+        // Finally, return the result.
+        __result
+    }
+}
+
+/// Creates `Unpin` implementation for the original type.
+///
+/// The kind of `Unpin` impl generated depends on `unpin_impl` field:
+/// - `UnpinImpl::Unsafe` - Implements `Unpin` via `UnsafeUnpin` impl.
+/// - `UnpinImpl::Negative` - Generates `Unpin` impl with bounds that will never be true.
+/// - `UnpinImpl::Default` - Generates `Unpin` impl that requires `Unpin` for all pinned fields.
+fn make_unpin_impl(cx: &Context<'_>) -> TokenStream {
+    match cx.unpin_impl {
+        UnpinImpl::Unsafe(span) => {
+            let mut proj_generics = cx.proj.generics.clone();
+            let orig_ident = cx.orig.ident;
+            let lifetime = &cx.proj.lifetime;
+
+            // Make the error message highlight `UnsafeUnpin` argument.
+            proj_generics.make_where_clause().predicates.push(parse_quote_spanned! { span =>
+                _pin_project::__private::Wrapper<#lifetime, Self>: _pin_project::UnsafeUnpin
+            });
+
+            let (impl_generics, _, where_clause) = proj_generics.split_for_impl();
+            let ty_generics = cx.orig.generics.split_for_impl().1;
+
+            quote_spanned! { span =>
+                impl #impl_generics _pin_project::__private::Unpin for #orig_ident #ty_generics
+                #where_clause
+                {
+                }
+            }
+        }
+        UnpinImpl::Negative(span) => {
+            let mut proj_generics = cx.proj.generics.clone();
+            let orig_ident = cx.orig.ident;
+            let lifetime = &cx.proj.lifetime;
+
+            proj_generics.make_where_clause().predicates.push(parse_quote! {
+                _pin_project::__private::Wrapper<
+                    #lifetime, _pin_project::__private::PhantomPinned
+                >: _pin_project::__private::Unpin
+            });
+
+            let (proj_impl_generics, _, proj_where_clause) = proj_generics.split_for_impl();
+            let ty_generics = cx.orig.generics.split_for_impl().1;
+
+            // For interoperability with `forbid(unsafe_code)`, `unsafe` token should be
+            // call-site span.
+            let unsafety = <Token![unsafe]>::default();
+            quote_spanned! { span =>
+                #[doc(hidden)]
+                impl #proj_impl_generics _pin_project::__private::Unpin
+                    for #orig_ident #ty_generics
+                #proj_where_clause
+                {
+                }
+
+                // Generate a dummy impl of `UnsafeUnpin`, to ensure that the user cannot implement it.
+                //
+                // To ensure that users don't accidentally write a non-functional `UnsafeUnpin`
+                // impls, we emit one ourselves. If the user ends up writing an `UnsafeUnpin`
+                // impl, they'll get a "conflicting implementations of trait" error when
+                // coherence checks are run.
+                #[doc(hidden)]
+                #unsafety impl #proj_impl_generics _pin_project::UnsafeUnpin
+                    for #orig_ident #ty_generics
+                #proj_where_clause
+                {
+                }
+            }
+        }
+        UnpinImpl::Default => {
+            let mut full_where_clause = cx.orig.generics.where_clause.clone().unwrap();
+
+            // Generate a field in our new struct for every
+            // pinned field in the original type.
+            let fields = cx.pinned_fields.iter().enumerate().map(|(i, ty)| {
+                let field_ident = format_ident!("__field{}", i);
+                quote!(#field_ident: #ty)
+            });
+
+            // We could try to determine the subset of type parameters
+            // and lifetimes that are actually used by the pinned fields
+            // (as opposed to those only used by unpinned fields).
+            // However, this would be tricky and error-prone, since
+            // it's possible for users to create types that would alias
+            // with generic parameters (e.g. 'struct T').
+            //
+            // Instead, we generate a use of every single type parameter
+            // and lifetime used in the original struct. For type parameters,
+            // we generate code like this:
+            //
+            // ```rust
+            // struct AlwaysUnpin<T: ?Sized>(PhantomData<T>) {}
+            // impl<T: ?Sized> Unpin for AlwaysUnpin<T> {}
+            //
+            // ...
+            // _field: AlwaysUnpin<(A, B, C)>
+            // ```
+            //
+            // This ensures that any unused type parameters
+            // don't end up with `Unpin` bounds.
+            let lifetime_fields = cx.orig.generics.lifetimes().enumerate().map(
+                |(i, LifetimeParam { lifetime, .. })| {
+                    let field_ident = format_ident!("__lifetime{}", i);
+                    quote!(#field_ident: &#lifetime ())
+                },
+            );
+
+            let orig_ident = cx.orig.ident;
+            let struct_ident = format_ident!("__{}", orig_ident);
+            let vis = cx.orig.vis;
+            let lifetime = &cx.proj.lifetime;
+            let type_params = cx.orig.generics.type_params().map(|t| &t.ident);
+            let proj_generics = &cx.proj.generics;
+            let (proj_impl_generics, proj_ty_generics, _) = proj_generics.split_for_impl();
+            let (_, ty_generics, where_clause) = cx.orig.generics.split_for_impl();
+
+            full_where_clause.predicates.push(parse_quote! {
+                #struct_ident #proj_ty_generics: _pin_project::__private::Unpin
+            });
+
+            quote! {
+                // This needs to have the same visibility as the original type,
+                // due to the limitations of the 'public in private' error.
+                //
+                // Our goal is to implement the public trait `Unpin` for
+                // a potentially public user type. Because of this, rust
+                // requires that any types mentioned in the where clause of
+                // our `Unpin` impl also be public. This means that our generated
+                // `__UnpinStruct` type must also be public.
+                // However, we ensure that the user can never actually reference
+                // this 'public' type by creating this type in the inside of `const`.
+                #[allow(missing_debug_implementations)]
+                #vis struct #struct_ident #proj_generics #where_clause {
+                    __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+                        #lifetime, (#(_pin_project::__private::PhantomData<#type_params>),*)
+                    >,
+
+                    #(#fields,)*
+                    #(#lifetime_fields,)*
+                }
+
+                impl #proj_impl_generics _pin_project::__private::Unpin
+                    for #orig_ident #ty_generics
+                #full_where_clause
+                {
+                }
+
+                // Generate a dummy impl of `UnsafeUnpin`, to ensure that the user cannot implement it.
+                //
+                // To ensure that users don't accidentally write a non-functional `UnsafeUnpin`
+                // impls, we emit one ourselves. If the user ends up writing an `UnsafeUnpin`
+                // impl, they'll get a "conflicting implementations of trait" error when
+                // coherence checks are run.
+                #[doc(hidden)]
+                unsafe impl #proj_impl_generics _pin_project::UnsafeUnpin
+                    for #orig_ident #ty_generics
+                #full_where_clause
+                {
+                }
+            }
+        }
+    }
+}
+
+/// Creates `Drop` implementation for the original type.
+///
+/// The kind of `Drop` impl generated depends on `pinned_drop` field:
+/// - `Some` - implements `Drop` via `PinnedDrop` impl.
+/// - `None` - generates code that ensures that `Drop` trait is not implemented,
+///            instead of generating `Drop` impl.
+fn make_drop_impl(cx: &Context<'_>) -> TokenStream {
+    let ident = cx.orig.ident;
+    let (impl_generics, ty_generics, where_clause) = cx.orig.generics.split_for_impl();
+
+    if let Some(span) = cx.pinned_drop {
+        // For interoperability with `forbid(unsafe_code)`, `unsafe` token should be
+        // call-site span.
+        let unsafety = <Token![unsafe]>::default();
+        quote_spanned! { span =>
+            impl #impl_generics _pin_project::__private::Drop for #ident #ty_generics
+            #where_clause
+            {
+                fn drop(&mut self) {
+                    #unsafety {
+                        // Safety - we're in 'drop', so we know that 'self' will
+                        // never move again.
+                        let __pinned_self = _pin_project::__private::Pin::new_unchecked(self);
+                        // We call `pinned_drop` only once. Since `PinnedDrop::drop`
+                        // is an unsafe method and a private API, it is never called again in safe
+                        // code *unless the user uses a maliciously crafted macro*.
+                        _pin_project::__private::PinnedDrop::drop(__pinned_self);
+                    }
+                }
+            }
+        }
+    } else {
+        // If the user does not provide a `PinnedDrop` impl,
+        // we need to ensure that they don't provide a `Drop` impl of their
+        // own.
+        // Based on https://github.com/upsuper/assert-impl/blob/f503255b292ab0ba8d085b657f4065403cfa46eb/src/lib.rs#L80-L87
+        //
+        // We create a new identifier for each struct, so that the traits
+        // for different types do not conflict with each other.
+        //
+        // Another approach would be to provide an empty Drop impl,
+        // which would conflict with a user-provided Drop impl.
+        // However, this would trigger the compiler's special handling
+        // of Drop types (e.g. fields cannot be moved out of a Drop type).
+        // This approach prevents the creation of needless Drop impls,
+        // giving users more flexibility.
+        let trait_ident = format_ident!("{}MustNotImplDrop", ident);
+
+        quote! {
+            // There are two possible cases:
+            // 1. The user type does not implement Drop. In this case,
+            // the first blanked impl will not apply to it. This code
+            // will compile, as there is only one impl of MustNotImplDrop for the user type
+            // 2. The user type does impl Drop. This will make the blanket impl applicable,
+            // which will then conflict with the explicit MustNotImplDrop impl below.
+            // This will result in a compilation error, which is exactly what we want.
+            trait #trait_ident {}
+            #[allow(clippy::drop_bounds, drop_bounds)]
+            impl<T: _pin_project::__private::Drop> #trait_ident for T {}
+            impl #impl_generics #trait_ident for #ident #ty_generics #where_clause {}
+
+            // Generate a dummy impl of `PinnedDrop`, to ensure that the user cannot implement it.
+            // Since the user did not pass `PinnedDrop` to `#[pin_project]`, any `PinnedDrop`
+            // impl will not actually be called. Unfortunately, we can't detect this situation
+            // directly from either the `#[pin_project]` or `#[pinned_drop]` attributes, since
+            // we don't know what other attributes/impl may exist.
+            //
+            // To ensure that users don't accidentally write a non-functional `PinnedDrop`
+            // impls, we emit one ourselves. If the user ends up writing a `PinnedDrop` impl,
+            // they'll get a "conflicting implementations of trait" error when coherence
+            // checks are run.
+            #[doc(hidden)]
+            impl #impl_generics _pin_project::__private::PinnedDrop for #ident #ty_generics
+            #where_clause
+            {
+                unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+            }
+        }
+    }
+}
+
+/// Creates an implementation of the projection methods.
+///
+/// On structs, both the `project` and `project_ref` methods are always generated,
+/// and the `project_replace` method is only generated if `ProjReplace::span` is `Some`.
+///
+/// On enums, only methods that the returned projected type is named will be generated.
+fn make_proj_impl(
+    cx: &Context<'_>,
+    proj_body: &TokenStream,
+    proj_ref_body: &TokenStream,
+    proj_own_body: &TokenStream,
+) -> TokenStream {
+    let vis = &cx.proj.vis;
+    let lifetime = &cx.proj.lifetime;
+    let orig_ident = cx.orig.ident;
+    let proj_ident = &cx.proj.mut_ident;
+    let proj_ref_ident = &cx.proj.ref_ident;
+    let proj_own_ident = &cx.proj.own_ident;
+
+    let orig_ty_generics = cx.orig.generics.split_for_impl().1;
+    let proj_ty_generics = cx.proj.generics.split_for_impl().1;
+    let (impl_generics, ty_generics, where_clause) = cx.orig.generics.split_for_impl();
+    // TODO: For enums and project_replace, dead_code warnings should not be
+    // allowed because methods are not generated unless explicitly specified.
+    // However, there is currently no good way to allow warnings for generated
+    // code, so we allow warnings for all methods for now.
+    let allow_dead_code = quote! { #[allow(dead_code)] };
+
+    let mut project = Some(quote! {
+        #allow_dead_code
+        #[inline]
+        #vis fn project<#lifetime>(
+            self: _pin_project::__private::Pin<&#lifetime mut Self>,
+        ) -> #proj_ident #proj_ty_generics {
+            unsafe {
+                #proj_body
+            }
+        }
+    });
+    let mut project_ref = Some(quote! {
+        #allow_dead_code
+        #[allow(clippy::missing_const_for_fn)]
+        #[inline]
+        #vis fn project_ref<#lifetime>(
+            self: _pin_project::__private::Pin<&#lifetime Self>,
+        ) -> #proj_ref_ident #proj_ty_generics {
+            unsafe {
+                #proj_ref_body
+            }
+        }
+    });
+    let mut project_replace = cx.project_replace.span().map(|span| {
+        // It is enough to only set the span of the signature.
+        let sig = quote_spanned! { span =>
+            #allow_dead_code
+            #[inline]
+            #vis fn project_replace(
+                self: _pin_project::__private::Pin<&mut Self>,
+                __replacement: Self,
+            ) -> #proj_own_ident #orig_ty_generics
+        };
+        quote! {
+            #sig {
+                unsafe {
+                    let __self_ptr: *mut Self = self.get_unchecked_mut();
+
+                    // Destructors will run in reverse order, so next create a guard to overwrite
+                    // `self` with the replacement value without calling destructors.
+                    let __guard = _pin_project::__private::UnsafeOverwriteGuard::new(
+                        __self_ptr,
+                        __replacement,
+                    );
+
+                    #proj_own_body
+                }
+            }
+        }
+    });
+
+    if cx.kind == Enum {
+        if !cx.project {
+            project = None;
+        }
+        if !cx.project_ref {
+            project_ref = None;
+        }
+        if cx.project_replace.ident().is_none() {
+            project_replace = None;
+        }
+    }
+
+    quote! {
+        impl #impl_generics #orig_ident #ty_generics #where_clause {
+            #project
+            #project_ref
+            #project_replace
+        }
+    }
+}
+
+/// Checks that the `[repr(packed)]` attribute is not included.
+///
+/// This currently does two checks:
+/// - Checks the attributes of structs to ensure there is no `[repr(packed)]`.
+/// - Generates a function that borrows fields without an unsafe block and
+///   forbidding `unaligned_references` lint.
+fn ensure_not_packed(orig: &OriginalType<'_>, fields: Option<&Fields>) -> Result<TokenStream> {
+    for attr in orig.attrs {
+        if let Meta::List(ref list) = attr.meta {
+            if list.path.is_ident("repr") {
+                for repr in list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)? {
+                    if repr.path().is_ident("packed") {
+                        let msg = if fields.is_none() {
+                            // #[repr(packed)] cannot be apply on enums and will be rejected by rustc.
+                            // However, we should not rely on the behavior of rustc that rejects this.
+                            // https://github.com/taiki-e/pin-project/pull/324#discussion_r612388001
+                            "#[repr(packed)] attribute should be applied to a struct or union"
+                        } else if repr.require_name_value().is_ok() {
+                            // #[repr(packed = "")] is not valid format of #[repr(packed)] and will be
+                            // rejected by rustc.
+                            // However, we should not rely on the behavior of rustc that rejects this.
+                            // https://github.com/taiki-e/pin-project/pull/324#discussion_r612388001
+                            "#[repr(packed)] attribute should not be name-value pair"
+                        } else {
+                            "#[pin_project] attribute may not be used on #[repr(packed)] types"
+                        };
+                        bail!(repr, msg);
+                    }
+                }
+            }
+        }
+    }
+
+    let fields = match fields {
+        Some(fields) => fields,
+        None => return Ok(TokenStream::new()),
+    };
+
+    // Workaround for https://github.com/taiki-e/pin-project/issues/32
+    // Through the tricky use of proc macros, it's possible to bypass
+    // the above check for the `repr` attribute.
+    // To ensure that it's impossible to use pin projections on a `#[repr(packed)]`
+    // struct, we generate code like this:
+    //
+    // ```rust
+    // #[forbid(unaligned_references)]
+    // fn assert_not_repr_packed(val: &MyStruct) {
+    //     let _field_1 = &val.field_1;
+    //     let _field_2 = &val.field_2;
+    //     ...
+    //     let _field_n = &val.field_n;
+    // }
+    // ```
+    //
+    // Taking a reference to a packed field is UB, and applying
+    // `#[forbid(unaligned_references)]` makes sure that doing this is a hard error.
+    //
+    // If the struct ends up having `#[repr(packed)]` applied somehow,
+    // this will generate an (unfriendly) error message. Under all reasonable
+    // circumstances, we'll detect the `#[repr(packed)]` attribute, and generate
+    // a much nicer error above.
+    //
+    // There is one exception: If the type of a struct field has an alignment of 1
+    // (e.g. u8), it is always safe to take a reference to it, even if the struct
+    // is `#[repr(packed)]`. If the struct is composed entirely of types of
+    // alignment 1, our generated method will not trigger an error if the
+    // struct is `#[repr(packed)]`.
+    //
+    // Fortunately, this should have no observable consequence - `#[repr(packed)]`
+    // is essentially a no-op on such a type. Nevertheless, we include a test
+    // to ensure that the compiler doesn't ever try to copy the fields on
+    // such a struct when trying to drop it - which is reason we prevent
+    // `#[repr(packed)]` in the first place.
+    //
+    // See also https://github.com/taiki-e/pin-project/pull/34.
+    //
+    // Note:
+    // - Lint-based tricks aren't perfect, but they're much better than nothing:
+    //   https://github.com/taiki-e/pin-project-lite/issues/26
+    //
+    // - Enable both unaligned_references and safe_packed_borrows lints
+    //   because unaligned_references lint does not exist in older compilers:
+    //   https://github.com/taiki-e/pin-project-lite/pull/55
+    //   https://github.com/rust-lang/rust/pull/82525
+    let mut field_refs = vec![];
+    match fields {
+        Fields::Named(FieldsNamed { named, .. }) => {
+            for Field { ident, .. } in named {
+                field_refs.push(quote!(&this.#ident));
+            }
+        }
+        Fields::Unnamed(FieldsUnnamed { unnamed, .. }) => {
+            for (index, _) in unnamed.iter().enumerate() {
+                let index = Index::from(index);
+                field_refs.push(quote!(&this.#index));
+            }
+        }
+        Fields::Unit => {}
+    }
+
+    let (impl_generics, ty_generics, where_clause) = orig.generics.split_for_impl();
+    let ident = orig.ident;
+    Ok(quote! {
+        #[forbid(unaligned_references, safe_packed_borrows)]
+        fn __assert_not_repr_packed #impl_generics (this: &#ident #ty_generics) #where_clause {
+            #(let _ = #field_refs;)*
+        }
+    })
+}
diff --git a/crates/pin-project-internal/src/pin_project/mod.rs b/crates/pin-project-internal/src/pin_project/mod.rs
new file mode 100644
index 0000000..2dce78f
--- /dev/null
+++ b/crates/pin-project-internal/src/pin_project/mod.rs
@@ -0,0 +1,17 @@
+mod args;
+mod attribute;
+mod derive;
+
+use proc_macro2::TokenStream;
+use syn::Error;
+
+/// The annotation for pinned type.
+const PIN: &str = "pin";
+
+pub(crate) fn attribute(args: &TokenStream, input: TokenStream) -> TokenStream {
+    attribute::parse_attribute(args, input).unwrap_or_else(Error::into_compile_error)
+}
+
+pub(crate) fn derive(input: TokenStream) -> TokenStream {
+    derive::parse_derive(input).unwrap_or_else(Error::into_compile_error)
+}
diff --git a/crates/pin-project-internal/src/pinned_drop.rs b/crates/pin-project-internal/src/pinned_drop.rs
new file mode 100644
index 0000000..d30ecbe
--- /dev/null
+++ b/crates/pin-project-internal/src/pinned_drop.rs
@@ -0,0 +1,235 @@
+use proc_macro2::TokenStream;
+use quote::{format_ident, quote, ToTokens};
+use syn::{
+    parse_quote, spanned::Spanned, token::Colon, visit_mut::VisitMut, Error, FnArg,
+    GenericArgument, Ident, ImplItem, ItemImpl, Pat, PatIdent, PatType, Path, PathArguments,
+    Result, ReturnType, Signature, Token, Type, TypePath, TypeReference,
+};
+
+use crate::utils::{ReplaceReceiver, SliceExt};
+
+pub(crate) fn attribute(args: &TokenStream, mut input: ItemImpl) -> TokenStream {
+    let res = (|| -> Result<()> {
+        if !args.is_empty() {
+            bail!(args, "unexpected argument: `{}`", args)
+        }
+        validate_impl(&input)?;
+        expand_impl(&mut input);
+        Ok(())
+    })();
+
+    if let Err(e) = res {
+        let mut tokens = e.to_compile_error();
+        if let Type::Path(self_ty) = &*input.self_ty {
+            let (impl_generics, _, where_clause) = input.generics.split_for_impl();
+
+            // Generate a dummy impl of `PinnedDrop`.
+            // In many cases, `#[pinned_drop] impl` is declared after `#[pin_project]`.
+            // Therefore, if `pinned_drop` compile fails, you will also get an error
+            // about `PinnedDrop` not being implemented.
+            // This can be prevented to some extent by generating a dummy
+            // `PinnedDrop` implementation.
+            // We already know that we will get a compile error, so this won't
+            // accidentally compile successfully.
+            //
+            // However, if `input.self_ty` is not Type::Path, there is a high possibility that
+            // the type does not exist (since #[pin_project] can only be used on struct/enum
+            // definitions), so do not generate a dummy impl.
+            tokens.extend(quote! {
+                impl #impl_generics ::pin_project::__private::PinnedDrop for #self_ty
+                #where_clause
+                {
+                    unsafe fn drop(self: ::pin_project::__private::Pin<&mut Self>) {}
+                }
+            });
+        }
+        tokens
+    } else {
+        input.into_token_stream()
+    }
+}
+
+/// Validates the signature of given `PinnedDrop` impl.
+fn validate_impl(item: &ItemImpl) -> Result<()> {
+    const INVALID_ITEM: &str =
+        "#[pinned_drop] may only be used on implementation for the `PinnedDrop` trait";
+
+    if let Some(attr) = item.attrs.find("pinned_drop") {
+        bail!(attr, "duplicate #[pinned_drop] attribute");
+    }
+
+    if let Some((_, path, _)) = &item.trait_ {
+        if !path.is_ident("PinnedDrop") {
+            bail!(path, INVALID_ITEM);
+        }
+    } else {
+        bail!(item.self_ty, INVALID_ITEM);
+    }
+
+    if item.unsafety.is_some() {
+        bail!(item.unsafety, "implementing the trait `PinnedDrop` is not unsafe");
+    }
+    if item.items.is_empty() {
+        bail!(item, "not all trait items implemented, missing: `drop`");
+    }
+
+    match &*item.self_ty {
+        Type::Path(_) => {}
+        ty => {
+            bail!(ty, "implementing the trait `PinnedDrop` on this type is unsupported");
+        }
+    }
+
+    item.items.iter().enumerate().try_for_each(|(i, item)| match item {
+        ImplItem::Const(item) => {
+            bail!(item, "const `{}` is not a member of trait `PinnedDrop`", item.ident)
+        }
+        ImplItem::Type(item) => {
+            bail!(item, "type `{}` is not a member of trait `PinnedDrop`", item.ident)
+        }
+        ImplItem::Fn(method) => {
+            validate_sig(&method.sig)?;
+            if i == 0 {
+                Ok(())
+            } else {
+                bail!(method, "duplicate definitions with name `drop`")
+            }
+        }
+        _ => unreachable!("unexpected ImplItem"),
+    })
+}
+
+/// Validates the signature of given `PinnedDrop::drop` method.
+///
+/// The correct signature is: `(mut) self: (<path>::)Pin<&mut Self>`
+fn validate_sig(sig: &Signature) -> Result<()> {
+    fn get_ty_path(ty: &Type) -> Option<&Path> {
+        if let Type::Path(TypePath { qself: None, path }) = ty {
+            Some(path)
+        } else {
+            None
+        }
+    }
+
+    const INVALID_ARGUMENT: &str = "method `drop` must take an argument `self: Pin<&mut Self>`";
+
+    if sig.ident != "drop" {
+        bail!(sig.ident, "method `{}` is not a member of trait `PinnedDrop", sig.ident,);
+    }
+
+    if let ReturnType::Type(_, ty) = &sig.output {
+        match &**ty {
+            Type::Tuple(ty) if ty.elems.is_empty() => {}
+            _ => bail!(ty, "method `drop` must return the unit type"),
+        }
+    }
+
+    match sig.inputs.len() {
+        1 => {}
+        0 => return Err(Error::new(sig.paren_token.span.join(), INVALID_ARGUMENT)),
+        _ => bail!(sig.inputs, INVALID_ARGUMENT),
+    }
+
+    if let Some(arg) = sig.receiver() {
+        // (mut) self: <path>
+        if let Some(path) = get_ty_path(&arg.ty) {
+            let ty =
+                path.segments.last().expect("Type paths should always have at least one segment");
+            if let PathArguments::AngleBracketed(args) = &ty.arguments {
+                // (mut) self: (<path>::)<ty><&mut <elem>..>
+                if let Some(GenericArgument::Type(Type::Reference(TypeReference {
+                    mutability: Some(_),
+                    elem,
+                    ..
+                }))) = args.args.first()
+                {
+                    // (mut) self: (<path>::)Pin<&mut Self>
+                    if args.args.len() == 1
+                        && ty.ident == "Pin"
+                        && get_ty_path(elem).map_or(false, |path| path.is_ident("Self"))
+                    {
+                        if sig.unsafety.is_some() {
+                            bail!(sig.unsafety, "implementing the method `drop` is not unsafe");
+                        }
+                        return Ok(());
+                    }
+                }
+            }
+        }
+    }
+
+    bail!(sig.inputs[0], INVALID_ARGUMENT)
+}
+
+// from:
+//
+// fn drop(self: Pin<&mut Self>) {
+//     // ...
+// }
+//
+// into:
+//
+// unsafe fn drop(self: Pin<&mut Self>) {
+//     fn __drop_inner<T>(__self: Pin<&mut Foo<'_, T>>) {
+//         fn __drop_inner() {}
+//         // ...
+//     }
+//     __drop_inner(self);
+// }
+//
+fn expand_impl(item: &mut ItemImpl) {
+    // `PinnedDrop` is a private trait and should not appear in docs.
+    item.attrs.push(parse_quote!(#[doc(hidden)]));
+
+    let path = &mut item.trait_.as_mut().expect("unexpected inherent impl").1;
+    *path = parse_quote_spanned! { path.span() =>
+        ::pin_project::__private::PinnedDrop
+    };
+
+    let method =
+        if let ImplItem::Fn(method) = &mut item.items[0] { method } else { unreachable!() };
+
+    // `fn drop(mut self: Pin<&mut Self>)` -> `fn __drop_inner<T>(mut __self: Pin<&mut Receiver>)`
+    let drop_inner = {
+        let mut drop_inner = method.clone();
+        let ident = format_ident!("__drop_inner");
+        // Add a dummy `__drop_inner` function to prevent users call outer `__drop_inner`.
+        drop_inner.block.stmts.insert(0, parse_quote!(fn #ident() {}));
+        drop_inner.sig.ident = ident;
+        drop_inner.sig.generics = item.generics.clone();
+        let receiver = drop_inner.sig.receiver().expect("drop() should have a receiver").clone();
+        let pat = Box::new(Pat::Ident(PatIdent {
+            attrs: Vec::new(),
+            by_ref: None,
+            mutability: receiver.mutability,
+            ident: Ident::new("__self", receiver.self_token.span()),
+            subpat: None,
+        }));
+        drop_inner.sig.inputs[0] = FnArg::Typed(PatType {
+            attrs: receiver.attrs,
+            pat,
+            colon_token: Colon::default(),
+            ty: receiver.ty,
+        });
+        let self_ty = if let Type::Path(ty) = &*item.self_ty { ty } else { unreachable!() };
+        let mut visitor = ReplaceReceiver(self_ty);
+        visitor.visit_signature_mut(&mut drop_inner.sig);
+        visitor.visit_block_mut(&mut drop_inner.block);
+        drop_inner
+    };
+
+    // `fn drop(mut self: Pin<&mut Self>)` -> `unsafe fn drop(self: Pin<&mut Self>)`
+    method.sig.unsafety = Some(<Token![unsafe]>::default());
+    let self_token = if let FnArg::Receiver(ref mut rec) = method.sig.inputs[0] {
+        rec.mutability = None;
+        &rec.self_token
+    } else {
+        panic!("drop() should have a receiver")
+    };
+
+    method.block.stmts = parse_quote! {
+        #[allow(clippy::needless_pass_by_value)] // This lint does not warn the receiver.
+        #drop_inner
+        __drop_inner(#self_token);
+    };
+}
diff --git a/crates/pin-project-internal/src/utils.rs b/crates/pin-project-internal/src/utils.rs
new file mode 100644
index 0000000..55089cd
--- /dev/null
+++ b/crates/pin-project-internal/src/utils.rs
@@ -0,0 +1,383 @@
+use std::mem;
+
+use proc_macro2::{Group, Spacing, Span, TokenStream, TokenTree};
+use quote::{quote, quote_spanned, ToTokens};
+use syn::{
+    parse::{Parse, ParseBuffer, ParseStream},
+    parse_quote,
+    punctuated::Punctuated,
+    token,
+    visit_mut::{self, VisitMut},
+    Attribute, ExprPath, ExprStruct, Generics, Ident, Item, Lifetime, LifetimeParam, Macro,
+    PatStruct, PatTupleStruct, Path, PathArguments, PredicateType, QSelf, Result, Token, Type,
+    TypeParamBound, TypePath, Variant, Visibility, WherePredicate,
+};
+
+pub(crate) type Variants = Punctuated<Variant, Token![,]>;
+
+macro_rules! format_err {
+    ($span:expr, $msg:expr $(,)?) => {
+        syn::Error::new_spanned(&$span as &dyn quote::ToTokens, &$msg as &dyn std::fmt::Display)
+    };
+    ($span:expr, $($tt:tt)*) => {
+        format_err!($span, format!($($tt)*))
+    };
+}
+
+macro_rules! bail {
+    ($($tt:tt)*) => {
+        return Err(format_err!($($tt)*))
+    };
+}
+
+macro_rules! parse_quote_spanned {
+    ($span:expr => $($tt:tt)*) => {
+        syn::parse2(quote::quote_spanned!($span => $($tt)*)).unwrap_or_else(|e| panic!("{}", e))
+    };
+}
+
+/// Determines the lifetime names. Ensure it doesn't overlap with any existing
+/// lifetime names.
+pub(crate) fn determine_lifetime_name(lifetime_name: &mut String, generics: &mut Generics) {
+    struct CollectLifetimes(Vec<String>);
+
+    impl VisitMut for CollectLifetimes {
+        fn visit_lifetime_param_mut(&mut self, def: &mut LifetimeParam) {
+            self.0.push(def.lifetime.to_string());
+        }
+    }
+
+    debug_assert!(lifetime_name.starts_with('\''));
+
+    let mut lifetimes = CollectLifetimes(Vec::new());
+    lifetimes.visit_generics_mut(generics);
+
+    while lifetimes.0.iter().any(|name| name.starts_with(&**lifetime_name)) {
+        lifetime_name.push('_');
+    }
+}
+
+/// Like `insert_lifetime`, but also generates a bound of the form
+/// `OriginalType<A, B>: 'lifetime`. Used when generating the definition
+/// of a projection type
+pub(crate) fn insert_lifetime_and_bound(
+    generics: &mut Generics,
+    lifetime: Lifetime,
+    orig_generics: &Generics,
+    orig_ident: &Ident,
+) -> WherePredicate {
+    insert_lifetime(generics, lifetime.clone());
+
+    let orig_type: Type = parse_quote!(#orig_ident #orig_generics);
+    let mut punct = Punctuated::new();
+    punct.push(TypeParamBound::Lifetime(lifetime));
+
+    WherePredicate::Type(PredicateType {
+        lifetimes: None,
+        bounded_ty: orig_type,
+        colon_token: <Token![:]>::default(),
+        bounds: punct,
+    })
+}
+
+/// Inserts a `lifetime` at position `0` of `generics.params`.
+pub(crate) fn insert_lifetime(generics: &mut Generics, lifetime: Lifetime) {
+    generics.lt_token.get_or_insert_with(<Token![<]>::default);
+    generics.gt_token.get_or_insert_with(<Token![>]>::default);
+    generics.params.insert(0, LifetimeParam::new(lifetime).into());
+}
+
+/// Determines the visibility of the projected types and projection methods.
+///
+/// If given visibility is `pub`, returned visibility is `pub(crate)`.
+/// Otherwise, returned visibility is the same as given visibility.
+pub(crate) fn determine_visibility(vis: &Visibility) -> Visibility {
+    if let Visibility::Public(token) = vis {
+        parse_quote_spanned!(token.span => pub(crate))
+    } else {
+        vis.clone()
+    }
+}
+
+pub(crate) fn respan<T>(node: &T, span: Span) -> T
+where
+    T: ToTokens + Parse,
+{
+    let tokens = node.to_token_stream();
+    let respanned = respan_tokens(tokens, span);
+    syn::parse2(respanned).unwrap()
+}
+
+fn respan_tokens(tokens: TokenStream, span: Span) -> TokenStream {
+    tokens
+        .into_iter()
+        .map(|mut token| {
+            token.set_span(span);
+            token
+        })
+        .collect()
+}
+
+// =================================================================================================
+// extension traits
+
+pub(crate) trait SliceExt {
+    fn position_exact(&self, ident: &str) -> Result<Option<usize>>;
+    fn find(&self, ident: &str) -> Option<&Attribute>;
+}
+
+impl SliceExt for [Attribute] {
+    /// # Errors
+    ///
+    /// - There are multiple specified attributes.
+    /// - The `Attribute::tokens` field of the specified attribute is not empty.
+    fn position_exact(&self, ident: &str) -> Result<Option<usize>> {
+        self.iter()
+            .try_fold((0, None), |(i, mut prev), attr| {
+                if attr.path().is_ident(ident) {
+                    if prev.replace(i).is_some() {
+                        bail!(attr, "duplicate #[{}] attribute", ident);
+                    }
+                    attr.meta.require_path_only()?;
+                }
+                Ok((i + 1, prev))
+            })
+            .map(|(_, pos)| pos)
+    }
+
+    fn find(&self, ident: &str) -> Option<&Attribute> {
+        self.iter().position(|attr| attr.path().is_ident(ident)).map(|i| &self[i])
+    }
+}
+
+pub(crate) trait ParseBufferExt<'a> {
+    fn parenthesized(self) -> Result<ParseBuffer<'a>>;
+}
+
+impl<'a> ParseBufferExt<'a> for ParseStream<'a> {
+    fn parenthesized(self) -> Result<ParseBuffer<'a>> {
+        let content;
+        let _: token::Paren = syn::parenthesized!(content in self);
+        Ok(content)
+    }
+}
+
+impl<'a> ParseBufferExt<'a> for ParseBuffer<'a> {
+    fn parenthesized(self) -> Result<ParseBuffer<'a>> {
+        let content;
+        let _: token::Paren = syn::parenthesized!(content in self);
+        Ok(content)
+    }
+}
+
+// =================================================================================================
+// visitors
+
+// Replace `self`/`Self` with `__self`/`self_ty`.
+// Based on:
+// - https://github.com/dtolnay/async-trait/blob/0.1.35/src/receiver.rs
+// - https://github.com/dtolnay/async-trait/commit/6029cbf375c562ca98fa5748e9d950a8ff93b0e7
+
+pub(crate) struct ReplaceReceiver<'a>(pub(crate) &'a TypePath);
+
+impl ReplaceReceiver<'_> {
+    fn self_ty(&self, span: Span) -> TypePath {
+        respan(self.0, span)
+    }
+
+    fn self_to_qself(&self, qself: &mut Option<QSelf>, path: &mut Path) {
+        if path.leading_colon.is_some() {
+            return;
+        }
+
+        let first = &path.segments[0];
+        if first.ident != "Self" || !first.arguments.is_empty() {
+            return;
+        }
+
+        if path.segments.len() == 1 {
+            self.self_to_expr_path(path);
+            return;
+        }
+
+        let span = first.ident.span();
+        *qself = Some(QSelf {
+            lt_token: Token![<](span),
+            ty: Box::new(self.self_ty(span).into()),
+            position: 0,
+            as_token: None,
+            gt_token: Token![>](span),
+        });
+
+        path.leading_colon = Some(**path.segments.pairs().next().unwrap().punct().unwrap());
+
+        let segments = mem::replace(&mut path.segments, Punctuated::new());
+        path.segments = segments.into_pairs().skip(1).collect();
+    }
+
+    fn self_to_expr_path(&self, path: &mut Path) {
+        if path.leading_colon.is_some() {
+            return;
+        }
+
+        let first = &path.segments[0];
+        if first.ident != "Self" || !first.arguments.is_empty() {
+            return;
+        }
+
+        let self_ty = self.self_ty(first.ident.span());
+        let variant = mem::replace(path, self_ty.path);
+        for segment in &mut path.segments {
+            if let PathArguments::AngleBracketed(bracketed) = &mut segment.arguments {
+                if bracketed.colon2_token.is_none() && !bracketed.args.is_empty() {
+                    bracketed.colon2_token = Some(<Token![::]>::default());
+                }
+            }
+        }
+        if variant.segments.len() > 1 {
+            path.segments.push_punct(<Token![::]>::default());
+            path.segments.extend(variant.segments.into_pairs().skip(1));
+        }
+    }
+
+    fn visit_token_stream(&self, tokens: &mut TokenStream) -> bool {
+        let mut out = Vec::new();
+        let mut modified = false;
+        let mut iter = tokens.clone().into_iter().peekable();
+        while let Some(tt) = iter.next() {
+            match tt {
+                TokenTree::Ident(mut ident) => {
+                    modified |= prepend_underscore_to_self(&mut ident);
+                    if ident == "Self" {
+                        modified = true;
+                        let self_ty = self.self_ty(ident.span());
+                        match iter.peek() {
+                            Some(TokenTree::Punct(p))
+                                if p.as_char() == ':' && p.spacing() == Spacing::Joint =>
+                            {
+                                let next = iter.next().unwrap();
+                                match iter.peek() {
+                                    Some(TokenTree::Punct(p)) if p.as_char() == ':' => {
+                                        let span = ident.span();
+                                        out.extend(quote_spanned!(span=> <#self_ty>));
+                                    }
+                                    _ => out.extend(quote!(#self_ty)),
+                                }
+                                out.push(next);
+                            }
+                            _ => out.extend(quote!(#self_ty)),
+                        }
+                    } else {
+                        out.push(TokenTree::Ident(ident));
+                    }
+                }
+                TokenTree::Group(group) => {
+                    let mut content = group.stream();
+                    modified |= self.visit_token_stream(&mut content);
+                    let mut new = Group::new(group.delimiter(), content);
+                    new.set_span(group.span());
+                    out.push(TokenTree::Group(new));
+                }
+                other => out.push(other),
+            }
+        }
+        if modified {
+            *tokens = TokenStream::from_iter(out);
+        }
+        modified
+    }
+}
+
+impl VisitMut for ReplaceReceiver<'_> {
+    // `Self` -> `Receiver`
+    fn visit_type_mut(&mut self, ty: &mut Type) {
+        if let Type::Path(node) = ty {
+            if node.qself.is_none() && node.path.is_ident("Self") {
+                *ty = self.self_ty(node.path.segments[0].ident.span()).into();
+            } else {
+                self.visit_type_path_mut(node);
+            }
+        } else {
+            visit_mut::visit_type_mut(self, ty);
+        }
+    }
+
+    // `Self::Assoc` -> `<Receiver>::Assoc`
+    fn visit_type_path_mut(&mut self, ty: &mut TypePath) {
+        if ty.qself.is_none() {
+            self.self_to_qself(&mut ty.qself, &mut ty.path);
+        }
+        visit_mut::visit_type_path_mut(self, ty);
+    }
+
+    // `Self::method` -> `<Receiver>::method`
+    fn visit_expr_path_mut(&mut self, expr: &mut ExprPath) {
+        if expr.qself.is_none() {
+            self.self_to_qself(&mut expr.qself, &mut expr.path);
+        }
+        visit_mut::visit_expr_path_mut(self, expr);
+    }
+
+    fn visit_expr_struct_mut(&mut self, expr: &mut ExprStruct) {
+        self.self_to_expr_path(&mut expr.path);
+        visit_mut::visit_expr_struct_mut(self, expr);
+    }
+
+    fn visit_pat_struct_mut(&mut self, pat: &mut PatStruct) {
+        self.self_to_expr_path(&mut pat.path);
+        visit_mut::visit_pat_struct_mut(self, pat);
+    }
+
+    fn visit_pat_tuple_struct_mut(&mut self, pat: &mut PatTupleStruct) {
+        self.self_to_expr_path(&mut pat.path);
+        visit_mut::visit_pat_tuple_struct_mut(self, pat);
+    }
+
+    fn visit_path_mut(&mut self, path: &mut Path) {
+        if path.segments.len() == 1 {
+            // Replace `self`, but not `self::function`.
+            prepend_underscore_to_self(&mut path.segments[0].ident);
+        }
+        for segment in &mut path.segments {
+            self.visit_path_arguments_mut(&mut segment.arguments);
+        }
+    }
+
+    fn visit_item_mut(&mut self, item: &mut Item) {
+        match item {
+            // Visit `macro_rules!` because locally defined macros can refer to `self`.
+            Item::Macro(item) if item.mac.path.is_ident("macro_rules") => {
+                self.visit_macro_mut(&mut item.mac);
+            }
+            // Otherwise, do not recurse into nested items.
+            _ => {}
+        }
+    }
+
+    fn visit_macro_mut(&mut self, mac: &mut Macro) {
+        // We can't tell in general whether `self` inside a macro invocation
+        // refers to the self in the argument list or a different self
+        // introduced within the macro. Heuristic: if the macro input contains
+        // `fn`, then `self` is more likely to refer to something other than the
+        // outer function's self argument.
+        if !contains_fn(mac.tokens.clone()) {
+            self.visit_token_stream(&mut mac.tokens);
+        }
+    }
+}
+
+fn contains_fn(tokens: TokenStream) -> bool {
+    tokens.into_iter().any(|tt| match tt {
+        TokenTree::Ident(ident) => ident == "fn",
+        TokenTree::Group(group) => contains_fn(group.stream()),
+        _ => false,
+    })
+}
+
+pub(crate) fn prepend_underscore_to_self(ident: &mut Ident) -> bool {
+    let modified = ident == "self";
+    if modified {
+        *ident = Ident::new("__self", ident.span());
+    }
+    modified
+}
diff --git a/crates/pin-project-lite/.cargo-checksum.json b/crates/pin-project-lite/.cargo-checksum.json
new file mode 100644
index 0000000..f13fc41
--- /dev/null
+++ b/crates/pin-project-lite/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"CHANGELOG.md":"8746b4b5d094fb8998c411987f4145ece4b11107d1eab24fce3f8075f1d3dbb5","Cargo.toml":"39e8ac3108dc0099ea98f012927dba1eb4b93220f23e3366896bb2fa2f66870d","LICENSE-APACHE":"0d542e0c8804e39aa7f37eb00da5a762149dc682d7829451287e11b938e94594","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","README.md":"84c64307110253c7348fb56e22ff36460b4b0c797fc931dbb748bef6921a8009","src/lib.rs":"94c2eb6f58fea1ecba2ada4c8e6d7a62f9ee54e0844200c5d6609549c896e8b5","tests/auxiliary/mod.rs":"7e263e987e09b77e384f734384a00a71c5b70230bb1b5376446ef003a8da9372","tests/compiletest.rs":"af34ced23541134e26259a52cae588520c7111e98bff59e0c2e2d73faf43ca3f","tests/drop_order.rs":"2cb31a8cd5cf4d9a4ba9faf25f99f0e85f9bd7b4778649f843d9c617c6af43fc","tests/expand/default/enum.expanded.rs":"7944e0ff3a49ef1bccff5681a32a0b306c5eaa7a5f4838132eca8e9a62d40722","tests/expand/default/enum.rs":"493d5752c4baa87ed4c48bd41b8e5e263fd5e3f43c4f9195818ef6d26951f63e","tests/expand/default/struct.expanded.rs":"c0a2a411462f2570340e095963c277da229f7b7dcbe661512ac5f051478d5905","tests/expand/default/struct.rs":"5a6e57d9b6d00cfd4e1e69f37ce0c9d5165a21230d0363f0791665b1015870ce","tests/expand/multifields/enum.expanded.rs":"fc3a86d536060cbd1aa58a2e565d00033f677c0e02f1dd1ee6e30e8379b152fe","tests/expand/multifields/enum.rs":"9c79270a7d6d1d42cf8194b579d79e7d44a3fd003243742f0a568ecf0a4f3be3","tests/expand/multifields/struct.expanded.rs":"cf2dd15e6a0a66afcb8c5d7fef235964a4326c91732de65597f880285fdffe2a","tests/expand/multifields/struct.rs":"17f0447d522d48f14d516808bd66baacebdf3ac38188df72f649702a893cda68","tests/expand/naming/enum-all.expanded.rs":"7944e0ff3a49ef1bccff5681a32a0b306c5eaa7a5f4838132eca8e9a62d40722","tests/expand/naming/enum-all.rs":"493d5752c4baa87ed4c48bd41b8e5e263fd5e3f43c4f9195818ef6d26951f63e","tests/expand/naming/enum-mut.expanded.rs":"49bd8b7e0a469823e1e7d4dbfcb7108ef5db16844ef7d4686cb6600768123877","tests/expand/naming/enum-mut.rs":"c1ff4ade049ebbceb2acb99dbc1af5db14de3ba9710ea1ff1b64348766a9e080","tests/expand/naming/enum-none.expanded.rs":"dbac25a5370153bad9165346c49f831d051b22f0c40bc4d81aa1dd44346d04cc","tests/expand/naming/enum-none.rs":"ff22be4ecf4168e2bc68ab249a0ed809a37e3b8e840ef8977d24209ef28ac839","tests/expand/naming/enum-ref.expanded.rs":"ec4dedf4618e6b9dc4e98a2846b769dc5c9ad9eb51cb645ebfcca09c9ec9458f","tests/expand/naming/enum-ref.rs":"394cbd5d872449e9226cd0834ce7117c395a582567584218dabbef4eb2c1fbac","tests/expand/naming/struct-all.expanded.rs":"1573eb22f4f68b2d2621a5b3d4bda0edfd38ef16efc7f29d9697fc5564a9f615","tests/expand/naming/struct-all.rs":"c13c0aacee85b8fca58f85d2d75d2e3907b3e7642f8710ed8c8e54d6015881cc","tests/expand/naming/struct-mut.expanded.rs":"6e52a2d4c9fe105307d2cf07882897027713ebcac94249aab7ba0a1ffc2f2f77","tests/expand/naming/struct-mut.rs":"9a7752a6d30e0b7033f3577a72676676900a642cdaf59f942179d1f2a8ba2bb0","tests/expand/naming/struct-none.expanded.rs":"c0a2a411462f2570340e095963c277da229f7b7dcbe661512ac5f051478d5905","tests/expand/naming/struct-none.rs":"5a6e57d9b6d00cfd4e1e69f37ce0c9d5165a21230d0363f0791665b1015870ce","tests/expand/naming/struct-ref.expanded.rs":"b8744cb83e6764c4c9718c4ad6898ce2c80420730456579ce250e1839bad6027","tests/expand/naming/struct-ref.rs":"33c4fd344b65650dee44087ada31d4b5acd9d122123360fb7d41718c46699574","tests/expand/not_unpin/enum.expanded.rs":"c71d04b6c6ed0c334724b395e44679111703adaf19f3d697f5bfce58f8313cfc","tests/expand/not_unpin/enum.rs":"b626f3390a6afa36ec3505bdb61457e8eb2a6eee58dc8ab5a85c9e1a10699b20","tests/expand/not_unpin/struct.expanded.rs":"e3bb42319076fa8ecfec3e47356bb5afc95da5454467a2b0b471f76ced0f284f","tests/expand/not_unpin/struct.rs":"84af744f600ef0c0276a64a07d427b28e0b649fb634fa9880a9fd8cd475517c9","tests/expand/pinned_drop/enum.expanded.rs":"9b7d9d0c16045400c93de9a47f39aae3859d922f81432f76f96e7dd81f27cdb8","tests/expand/pinned_drop/enum.rs":"3178d479b9b42dc74c5a2207f70c9959070672c03009021e335c34290ef620ba","tests/expand/pinned_drop/struct.expanded.rs":"e802ab01b59f09d6397f9235eab51e07859b2582465a39f5621fa4d33e270fd3","tests/expand/pinned_drop/struct.rs":"cf6a7b04451c59ce697c3ef15855c7740b0e72a6005b1f47db326bd93b1849c3","tests/expand/pub/enum.expanded.rs":"ddc80984cc8cfd30a27c385c3e53ae7c178d774a717040d0e791e81adc7004fe","tests/expand/pub/enum.rs":"5b60dd354a489b0326f5c4f1026b89d1471ddbb45906bc3046a65425c4e5e160","tests/expand/pub/struct.expanded.rs":"435a2322ab580327bfecd40b309b3f2079667ed627bc25bdb41ee03dae0596bb","tests/expand/pub/struct.rs":"15b7940ce0ad1d5d133dde1870319f2f96a000bfcf29508b8cce1a62876cbd80","tests/expandtest.rs":"66bd80992a1696994ec2d14c3edc36350a0cb896d8081f1c0f8893ebeed72d03","tests/include/basic.rs":"9e399b682bc74c899d26924c2cab52a911f7392e29300defb6521e561fafafe4","tests/lint.rs":"36005c64524a2ed4f738d22d5310539e063e75833e8ab1b81afa6c9d1ba14bf6","tests/proper_unpin.rs":"35894ab482a5409aa32b261ff729c0ce23230232ecf43b3227a401fd218828e1","tests/test.rs":"b5c1bde0fa45513b6a0f0f2126e70aa41a8f5aba2bdf55bfb2b8b6b415c0e98b","tests/ui/pin_project/conflict-drop.rs":"55e6809b5f59dd81e32c2c89b742c0c76db6b099a1d2621e5b882c0d20f92837","tests/ui/pin_project/conflict-drop.stderr":"7cadbfe2b8e9659c69e8d61d45128d3589444f563e1f179d6d4c9bd1d98e96e1","tests/ui/pin_project/conflict-unpin.rs":"eae4f6b2084e32001a5a965b4a9ebf76a3a628830ca5f93bf4799eea96accbf9","tests/ui/pin_project/conflict-unpin.stderr":"c5bc8f97a5917548eb66e6099adf9371416a02ffc4feb2e20432c60782cd6ba2","tests/ui/pin_project/invalid-bounds.rs":"f86f23d377df015182f2f5dae6464a4f98c37f2198e0646f721fedc4017cb82c","tests/ui/pin_project/invalid-bounds.stderr":"200e6fab99f8ebd75116294ba9c43ae9487563239f2d57462157f5cc47c37cc3","tests/ui/pin_project/invalid.rs":"7304bd4a5bac1419382742432cfa8af83535d7be8cfad52c661410e0e9e8207a","tests/ui/pin_project/invalid.stderr":"6e8693c3341972e329e7c7a1836f308c433e0ba677fc99808d75a53e695654b1","tests/ui/pin_project/overlapping_lifetime_names.rs":"36c849a4570c8c0c32ca6c01aa75afbe1136ef73d45f17eb66175e1936678722","tests/ui/pin_project/overlapping_lifetime_names.stderr":"6958a5c0c983f3ed782203d8f221e80e154b71cb4fe2a9fb633058ec636c4cbc","tests/ui/pin_project/overlapping_unpin_struct.rs":"9a126182d1fe15a30ac60bb223b376aad747d11293d3cf512ad2dce546e3725c","tests/ui/pin_project/overlapping_unpin_struct.stderr":"406feb5169cd79293853b76a5cc599e692d2af3b5169fca32cb5cf1cb2ad0fc0","tests/ui/pin_project/packed.rs":"1f1a34aafbff9a59b94cdf3a53df03e9fc661d9e27e0f9962bad7f9bdad03b14","tests/ui/pin_project/packed.stderr":"5c5f08d339d4e5e2596f1f8a64158d8c2df2ea7116c04a578004f30f48ca7b0a","tests/ui/pin_project/unpin_sneaky.rs":"12e97a387ce1af6ee6a567687674aab70e96962a48f2433c39976d0b3e2c3341","tests/ui/pin_project/unpin_sneaky.stderr":"7a540e26a0e9c66794bcc10cbc337b3459a9208d32b0012f0b55fb84cfc15cf1","tests/ui/pin_project/unsupported.rs":"14defa90e736f314bbbc219973929b77bdd22e5f7e4c4c88403db764f4d167d6","tests/ui/pin_project/unsupported.stderr":"7b161bda371caeb26df426fde4dadcff61a807ffd476b2344c6b77072d6c0cc0","tests/ui/pinned_drop/call-drop-inner.rs":"032260da1fc0e649d97167a8a4ac47eea915000efebdfdc490f050b6f9351027","tests/ui/pinned_drop/call-drop-inner.stderr":"abec9d82aeb49c860e313db0a3ad0d2024d7500750d4f9a0f8b0ce00478dbcbf","tests/ui/pinned_drop/conditional-drop-impl.rs":"0b28c74213cee83e7b27223d7d37f903f79abd3dddcc0f969e14047674908085","tests/ui/pinned_drop/conditional-drop-impl.stderr":"a845afaa89054f7c516029090a201f3beecf59d6e9e4fca18ca3678d27666a92"},"package":"8afb450f006bf6385ca15ef45d71d2288452bc3683ce2e2cacc0d18e4be60b58"}
\ No newline at end of file
diff --git a/crates/pin-project-lite/Android.bp b/crates/pin-project-lite/Android.bp
new file mode 100644
index 0000000..39faee6
--- /dev/null
+++ b/crates/pin-project-lite/Android.bp
@@ -0,0 +1,31 @@
+// This file is generated by cargo_embargo.
+// Do not modify this file because the changes will be overridden on upgrade.
+
+package {
+    default_applicable_licenses: ["external_rust_crates_pin-project-lite_license"],
+    default_team: "trendy_team_android_rust",
+}
+
+license {
+    name: "external_rust_crates_pin-project-lite_license",
+    visibility: [":__subpackages__"],
+    license_kinds: ["SPDX-license-identifier-Apache-2.0"],
+    license_text: ["LICENSE"],
+}
+
+rust_library {
+    name: "libpin_project_lite",
+    host_supported: true,
+    crate_name: "pin_project_lite",
+    cargo_env_compat: true,
+    cargo_pkg_version: "0.2.13",
+    crate_root: "src/lib.rs",
+    edition: "2018",
+    apex_available: [
+        "//apex_available:platform",
+        "//apex_available:anyapex",
+    ],
+    product_available: true,
+    vendor_available: true,
+    min_sdk_version: "29",
+}
diff --git a/crates/pin-project-lite/CHANGELOG.md b/crates/pin-project-lite/CHANGELOG.md
new file mode 100644
index 0000000..dc463fc
--- /dev/null
+++ b/crates/pin-project-lite/CHANGELOG.md
@@ -0,0 +1,242 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+This project adheres to [Semantic Versioning](https://semver.org).
+
+<!--
+Note: In this file, do not use the hard wrap in the middle of a sentence for compatibility with GitHub comment style markdown rendering.
+-->
+
+## [Unreleased]
+
+## [0.2.13] - 2023-08-25
+
+- Allow attributes in impl and method of `PinnedDrop` implementation.
+
+## [0.2.12] - 2023-08-09
+
+- Work around an issue where the projected types/methods appear in the documentation as if they were part of the public API if the visibility is not correctly parsed due to the rustc bug. See [#77](https://github.com/taiki-e/pin-project-lite/issues/77#issuecomment-1671540180) for details.
+
+## [0.2.11] - 2023-08-06
+
+- Add support for `#[project(!Unpin)]`. This is equivalent to pin-project's [!Unpin](https://docs.rs/pin-project/latest/pin_project/attr.pin_project.html#unpin) option. ([#76](https://github.com/taiki-e/pin-project-lite/pull/76), thanks @matheus-consoli)
+
+## [0.2.10] - 2023-07-02
+
+- Inline project methods. ([#74](https://github.com/taiki-e/pin-project-lite/pull/74), thanks @EFanZh)
+
+## [0.2.9] - 2022-04-26
+
+- Improve compile time of `pin_project!` calls. ([#71](https://github.com/taiki-e/pin-project-lite/pull/71), thanks @nnethercote)
+
+## [0.2.8] - 2021-12-31
+
+- Fix handling of trailing commas in `PinnedDrop` impl. ([#64](https://github.com/taiki-e/pin-project-lite/pull/64), thanks @Michael-J-Ward)
+
+## [0.2.7] - 2021-06-26
+
+- [Support custom Drop implementation.](https://github.com/taiki-e/pin-project-lite/pull/25) See [#25](https://github.com/taiki-e/pin-project-lite/pull/25) for details.
+
+## [0.2.6] - 2021-03-04
+
+- Support item attributes in any order. ([#57](https://github.com/taiki-e/pin-project-lite/pull/57), thanks @SabrinaJewson)
+
+## [0.2.5] - 2021-03-02
+
+- [Prepare for removal of `safe_packed_borrows` lint.](https://github.com/taiki-e/pin-project-lite/pull/55) See [#55](https://github.com/taiki-e/pin-project-lite/pull/55) for details.
+
+## [0.2.4] - 2021-01-11
+
+**Note:** This release has been yanked. See [#55](https://github.com/taiki-e/pin-project-lite/pull/55) for details.
+
+- Add `project_replace`. ([#43](https://github.com/taiki-e/pin-project-lite/pull/43), thanks @Marwes)
+
+## [0.2.3] - 2021-01-09
+
+**Note:** This release has been yanked. See [#55](https://github.com/taiki-e/pin-project-lite/pull/55) for details.
+
+- [Suppress `clippy::unknown_clippy_lints` lint in generated code.](https://github.com/taiki-e/pin-project-lite/pull/47)
+
+## [0.2.2] - 2021-01-09
+
+**Note:** This release has been yanked.** See [#55](https://github.com/taiki-e/pin-project-lite/pull/55) for details.
+
+- [Suppress `clippy::ref_option_ref` lint in generated code.](https://github.com/taiki-e/pin-project-lite/pull/45)
+
+## [0.2.1] - 2021-01-05
+
+**Note:** This release has been yanked. See [#55](https://github.com/taiki-e/pin-project-lite/pull/55) for details.
+
+- Exclude unneeded files from crates.io.
+
+## [0.2.0] - 2020-11-13
+
+**Note:** This release has been yanked. See [#55](https://github.com/taiki-e/pin-project-lite/pull/55) for details.
+
+- [`pin_project!` macro now supports enums.](https://github.com/taiki-e/pin-project-lite/pull/28)
+
+  To use `pin_project!` on enums, you need to name the projection type returned from the method.
+
+  ```rust
+  use pin_project_lite::pin_project;
+  use std::pin::Pin;
+
+  pin_project! {
+      #[project = EnumProj]
+      enum Enum<T, U> {
+          Variant { #[pin] pinned: T, unpinned: U },
+      }
+  }
+
+  impl<T, U> Enum<T, U> {
+      fn method(self: Pin<&mut Self>) {
+          match self.project() {
+              EnumProj::Variant { pinned, unpinned } => {
+                  let _: Pin<&mut T> = pinned;
+                  let _: &mut U = unpinned;
+              }
+          }
+      }
+  }
+  ```
+
+- [Support naming the projection types.](https://github.com/taiki-e/pin-project-lite/pull/28)
+
+  By passing an attribute with the same name as the method, you can name the projection type returned from the method:
+
+  ```rust
+  use pin_project_lite::pin_project;
+  use std::pin::Pin;
+
+  pin_project! {
+      #[project = StructProj]
+      struct Struct<T> {
+          #[pin]
+          field: T,
+      }
+  }
+
+  fn func<T>(x: Pin<&mut Struct<T>>) {
+      let StructProj { field } = x.project();
+      let _: Pin<&mut T> = field;
+  }
+  ```
+
+## [0.1.12] - 2021-03-02
+
+- [Prepare for removal of `safe_packed_borrows` lint.](https://github.com/taiki-e/pin-project-lite/pull/55) See [#55](https://github.com/taiki-e/pin-project-lite/pull/55) for details.
+
+## [0.1.11] - 2020-10-20
+
+**Note:** This release has been yanked. See [#55](https://github.com/taiki-e/pin-project-lite/pull/55) for details.
+
+- Suppress `clippy::redundant_pub_crate` lint in generated code.
+
+- Documentation improvements.
+
+## [0.1.10] - 2020-10-01
+
+**Note:** This release has been yanked. See [#55](https://github.com/taiki-e/pin-project-lite/pull/55) for details.
+
+- Suppress `drop_bounds` lint, which will be added to rustc in the future. See [taiki-e/pin-project#272](https://github.com/taiki-e/pin-project/issues/272) for more details.
+
+## [0.1.9] - 2020-09-29
+
+**Note:** This release has been yanked. See [#55](https://github.com/taiki-e/pin-project-lite/pull/55) for details.
+
+- [Fix trailing comma support in generics.](https://github.com/taiki-e/pin-project-lite/pull/32)
+
+## [0.1.8] - 2020-09-26
+
+**Note:** This release has been yanked. See [#55](https://github.com/taiki-e/pin-project-lite/pull/55) for details.
+
+- [Fix compatibility of generated code with `forbid(future_incompatible)`.](https://github.com/taiki-e/pin-project-lite/pull/30)
+
+  Note: This does not guarantee compatibility with `forbid(future_incompatible)` in the future.
+  If rustc adds a new lint, we may not be able to keep this.
+
+## [0.1.7] - 2020-06-04
+
+**Note:** This release has been yanked. See [#55](https://github.com/taiki-e/pin-project-lite/pull/55) for details.
+
+- [Support `?Sized` bounds in where clauses.](https://github.com/taiki-e/pin-project-lite/pull/22)
+
+- [Fix lifetime inference error when an associated type is used in fields.](https://github.com/taiki-e/pin-project-lite/pull/20)
+
+- Suppress `clippy::used_underscore_binding` lint in generated code.
+
+- Documentation improvements.
+
+## [0.1.6] - 2020-05-31
+
+**Note:** This release has been yanked. See [#55](https://github.com/taiki-e/pin-project-lite/pull/55) for details.
+
+- [Support lifetime bounds in where clauses.](https://github.com/taiki-e/pin-project-lite/pull/18)
+
+- Documentation improvements.
+
+## [0.1.5] - 2020-05-07
+
+**Note:** This release has been yanked. See [#55](https://github.com/taiki-e/pin-project-lite/pull/55) for details.
+
+- [Support overwriting the name of `core` crate.](https://github.com/taiki-e/pin-project-lite/pull/14)
+
+## [0.1.4] - 2020-01-20
+
+**Note:** This release has been yanked. See [#55](https://github.com/taiki-e/pin-project-lite/pull/55) for details.
+
+- [Support ?Sized bounds in generic parameters.](https://github.com/taiki-e/pin-project-lite/pull/9)
+
+## [0.1.3] - 2020-01-20
+
+**Note:** This release has been yanked. See [#55](https://github.com/taiki-e/pin-project-lite/pull/55) for details.
+
+- [Support lifetime bounds in generic parameters.](https://github.com/taiki-e/pin-project-lite/pull/7)
+
+## [0.1.2] - 2020-01-05
+
+**Note:** This release has been yanked. See [#55](https://github.com/taiki-e/pin-project-lite/pull/55) for details.
+
+- Support recognizing default generic parameters. ([#6](https://github.com/taiki-e/pin-project-lite/pull/6), thanks @kennytm)
+
+## [0.1.1] - 2019-11-15
+
+**Note:** This release has been yanked. See [#55](https://github.com/taiki-e/pin-project-lite/pull/55) for details.
+
+- [`pin_project!` macro now determines the visibility of the projection type/method is based on the original type.](https://github.com/taiki-e/pin-project-lite/pull/5)
+
+## [0.1.0] - 2019-10-22
+
+**Note:** This release has been yanked. See [#55](https://github.com/taiki-e/pin-project-lite/pull/55) for details.
+
+Initial release
+
+[Unreleased]: https://github.com/taiki-e/pin-project-lite/compare/v0.2.13...HEAD
+[0.2.13]: https://github.com/taiki-e/pin-project-lite/compare/v0.2.12...v0.2.13
+[0.2.12]: https://github.com/taiki-e/pin-project-lite/compare/v0.2.11...v0.2.12
+[0.2.11]: https://github.com/taiki-e/pin-project-lite/compare/v0.2.10...v0.2.11
+[0.2.10]: https://github.com/taiki-e/pin-project-lite/compare/v0.2.9...v0.2.10
+[0.2.9]: https://github.com/taiki-e/pin-project-lite/compare/v0.2.8...v0.2.9
+[0.2.8]: https://github.com/taiki-e/pin-project-lite/compare/v0.2.7...v0.2.8
+[0.2.7]: https://github.com/taiki-e/pin-project-lite/compare/v0.2.6...v0.2.7
+[0.2.6]: https://github.com/taiki-e/pin-project-lite/compare/v0.2.5...v0.2.6
+[0.2.5]: https://github.com/taiki-e/pin-project-lite/compare/v0.2.4...v0.2.5
+[0.2.4]: https://github.com/taiki-e/pin-project-lite/compare/v0.2.3...v0.2.4
+[0.2.3]: https://github.com/taiki-e/pin-project-lite/compare/v0.2.2...v0.2.3
+[0.2.2]: https://github.com/taiki-e/pin-project-lite/compare/v0.2.1...v0.2.2
+[0.2.1]: https://github.com/taiki-e/pin-project-lite/compare/v0.2.0...v0.2.1
+[0.2.0]: https://github.com/taiki-e/pin-project-lite/compare/v0.1.11...v0.2.0
+[0.1.12]: https://github.com/taiki-e/pin-project-lite/compare/v0.1.11...v0.1.12
+[0.1.11]: https://github.com/taiki-e/pin-project-lite/compare/v0.1.10...v0.1.11
+[0.1.10]: https://github.com/taiki-e/pin-project-lite/compare/v0.1.9...v0.1.10
+[0.1.9]: https://github.com/taiki-e/pin-project-lite/compare/v0.1.8...v0.1.9
+[0.1.8]: https://github.com/taiki-e/pin-project-lite/compare/v0.1.7...v0.1.8
+[0.1.7]: https://github.com/taiki-e/pin-project-lite/compare/v0.1.6...v0.1.7
+[0.1.6]: https://github.com/taiki-e/pin-project-lite/compare/v0.1.5...v0.1.6
+[0.1.5]: https://github.com/taiki-e/pin-project-lite/compare/v0.1.4...v0.1.5
+[0.1.4]: https://github.com/taiki-e/pin-project-lite/compare/v0.1.3...v0.1.4
+[0.1.3]: https://github.com/taiki-e/pin-project-lite/compare/v0.1.2...v0.1.3
+[0.1.2]: https://github.com/taiki-e/pin-project-lite/compare/v0.1.1...v0.1.2
+[0.1.1]: https://github.com/taiki-e/pin-project-lite/compare/v0.1.0...v0.1.1
+[0.1.0]: https://github.com/taiki-e/pin-project-lite/releases/tag/v0.1.0
diff --git a/crates/pin-project-lite/Cargo.lock b/crates/pin-project-lite/Cargo.lock
new file mode 100644
index 0000000..e967d06
--- /dev/null
+++ b/crates/pin-project-lite/Cargo.lock
@@ -0,0 +1,273 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+[[package]]
+name = "basic-toml"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "serde 1.0.156 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "diff"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "glob"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "itoa"
+version = "1.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "macrotest"
+version = "1.0.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "basic-toml 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "diff 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
+ "glob 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "prettyplease 0.2.15 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde 1.0.156 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde_derive 1.0.193 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde_json 1.0.99 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 2.0.32 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.13"
+dependencies = [
+ "macrotest 1.0.13 (registry+https://github.com/rust-lang/crates.io-index)",
+ "once_cell 1.14.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "proc-macro2 1.0.65 (registry+https://github.com/rust-lang/crates.io-index)",
+ "quote 1.0.30 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustversion 1.0.17 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde 1.0.156 (registry+https://github.com/rust-lang/crates.io-index)",
+ "static_assertions 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "toml 0.5.9 (registry+https://github.com/rust-lang/crates.io-index)",
+ "trybuild 1.0.67 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "prettyplease"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "proc-macro2 1.0.65 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 2.0.32 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.65"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "unicode-ident 1.0.12 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "proc-macro2 1.0.65 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "ryu"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "serde"
+version = "1.0.156"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "serde_derive"
+version = "1.0.193"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "proc-macro2 1.0.65 (registry+https://github.com/rust-lang/crates.io-index)",
+ "quote 1.0.30 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 2.0.32 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.99"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "itoa 1.0.11 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ryu 1.0.18 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde 1.0.156 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "static_assertions"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "syn"
+version = "2.0.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "proc-macro2 1.0.65 (registry+https://github.com/rust-lang/crates.io-index)",
+ "quote 1.0.30 (registry+https://github.com/rust-lang/crates.io-index)",
+ "unicode-ident 1.0.12 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "termcolor"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "winapi-util 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "toml"
+version = "0.5.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "serde 1.0.156 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "trybuild"
+version = "1.0.67"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "glob 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "once_cell 1.14.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde 1.0.156 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde_derive 1.0.193 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde_json 1.0.99 (registry+https://github.com/rust-lang/crates.io-index)",
+ "termcolor 1.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "toml 0.5.9 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "windows-sys 0.59.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "windows-targets 0.52.6 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "windows_aarch64_gnullvm 0.52.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "windows_aarch64_msvc 0.52.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "windows_i686_gnu 0.52.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "windows_i686_gnullvm 0.52.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "windows_i686_msvc 0.52.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "windows_x86_64_gnu 0.52.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "windows_x86_64_gnullvm 0.52.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "windows_x86_64_msvc 0.52.6 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[metadata]
+"checksum basic-toml 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "5c0de75129aa8d0cceaf750b89013f0e08804d6ec61416da787b35ad0d7cddf1"
+"checksum diff 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8"
+"checksum glob 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"
+"checksum itoa 1.0.11 (registry+https://github.com/rust-lang/crates.io-index)" = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
+"checksum macrotest 1.0.13 (registry+https://github.com/rust-lang/crates.io-index)" = "4e2035deb453578ff1cd2da2761ac78abbffffd1d06a0f59261c082ea713fdad"
+"checksum once_cell 1.14.0 (registry+https://github.com/rust-lang/crates.io-index)" = "2f7254b99e31cad77da24b08ebf628882739a608578bb1bcdfc1f9c21260d7c0"
+"checksum prettyplease 0.2.15 (registry+https://github.com/rust-lang/crates.io-index)" = "ae005bd773ab59b4725093fd7df83fd7892f7d8eafb48dbd7de6e024e4215f9d"
+"checksum proc-macro2 1.0.65 (registry+https://github.com/rust-lang/crates.io-index)" = "92de25114670a878b1261c79c9f8f729fb97e95bac93f6312f583c60dd6a1dfe"
+"checksum quote 1.0.30 (registry+https://github.com/rust-lang/crates.io-index)" = "5907a1b7c277254a8b15170f6e7c97cfa60ee7872a3217663bb81151e48184bb"
+"checksum rustversion 1.0.17 (registry+https://github.com/rust-lang/crates.io-index)" = "955d28af4278de8121b7ebeb796b6a45735dc01436d898801014aced2773a3d6"
+"checksum ryu 1.0.18 (registry+https://github.com/rust-lang/crates.io-index)" = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
+"checksum serde 1.0.156 (registry+https://github.com/rust-lang/crates.io-index)" = "314b5b092c0ade17c00142951e50ced110ec27cea304b1037c6969246c2469a4"
+"checksum serde_derive 1.0.193 (registry+https://github.com/rust-lang/crates.io-index)" = "43576ca501357b9b071ac53cdc7da8ef0cbd9493d8df094cd821777ea6e894d3"
+"checksum serde_json 1.0.99 (registry+https://github.com/rust-lang/crates.io-index)" = "46266871c240a00b8f503b877622fe33430b3c7d963bdc0f2adc511e54a1eae3"
+"checksum static_assertions 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
+"checksum syn 2.0.32 (registry+https://github.com/rust-lang/crates.io-index)" = "239814284fd6f1a4ffe4ca893952cdd93c224b6a1571c9a9eadd670295c0c9e2"
+"checksum termcolor 1.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755"
+"checksum toml 0.5.9 (registry+https://github.com/rust-lang/crates.io-index)" = "8d82e1a7758622a465f8cee077614c73484dac5b836c02ff6a40d5d1010324d7"
+"checksum trybuild 1.0.67 (registry+https://github.com/rust-lang/crates.io-index)" = "225e61c62e5d347c29e8fdd2c92e4efd5993b00256b5e5640a7d9e072b0df9c4"
+"checksum unicode-ident 1.0.12 (registry+https://github.com/rust-lang/crates.io-index)" = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
+"checksum winapi-util 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
+"checksum windows-sys 0.59.0 (registry+https://github.com/rust-lang/crates.io-index)" = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+"checksum windows-targets 0.52.6 (registry+https://github.com/rust-lang/crates.io-index)" = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+"checksum windows_aarch64_gnullvm 0.52.6 (registry+https://github.com/rust-lang/crates.io-index)" = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+"checksum windows_aarch64_msvc 0.52.6 (registry+https://github.com/rust-lang/crates.io-index)" = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+"checksum windows_i686_gnu 0.52.6 (registry+https://github.com/rust-lang/crates.io-index)" = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+"checksum windows_i686_gnullvm 0.52.6 (registry+https://github.com/rust-lang/crates.io-index)" = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+"checksum windows_i686_msvc 0.52.6 (registry+https://github.com/rust-lang/crates.io-index)" = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+"checksum windows_x86_64_gnu 0.52.6 (registry+https://github.com/rust-lang/crates.io-index)" = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+"checksum windows_x86_64_gnullvm 0.52.6 (registry+https://github.com/rust-lang/crates.io-index)" = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+"checksum windows_x86_64_msvc 0.52.6 (registry+https://github.com/rust-lang/crates.io-index)" = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
diff --git a/crates/pin-project-lite/Cargo.toml b/crates/pin-project-lite/Cargo.toml
new file mode 100644
index 0000000..ae3d4fb
--- /dev/null
+++ b/crates/pin-project-lite/Cargo.toml
@@ -0,0 +1,69 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2018"
+rust-version = "1.37"
+name = "pin-project-lite"
+version = "0.2.13"
+exclude = [
+    "/.*",
+    "/tools",
+    "/DEVELOPMENT.md",
+]
+description = """
+A lightweight version of pin-project written with declarative macros.
+"""
+readme = "README.md"
+keywords = [
+    "pin",
+    "macros",
+]
+categories = [
+    "no-std",
+    "no-std::no-alloc",
+    "rust-patterns",
+]
+license = "Apache-2.0 OR MIT"
+repository = "https://github.com/taiki-e/pin-project-lite"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[lib]
+doc-scrape-examples = false
+
+[dev-dependencies.macrotest]
+version = "1.0.9"
+
+[dev-dependencies.once_cell]
+version = "=1.14"
+
+[dev-dependencies.proc-macro2]
+version = "=1.0.65"
+
+[dev-dependencies.quote]
+version = "=1.0.30"
+
+[dev-dependencies.rustversion]
+version = "1"
+
+[dev-dependencies.serde]
+version = "=1.0.156"
+
+[dev-dependencies.static_assertions]
+version = "1"
+
+[dev-dependencies.toml]
+version = "=0.5.9"
+
+[dev-dependencies.trybuild]
+version = "=1.0.67"
diff --git a/crates/pin-project-lite/LICENSE b/crates/pin-project-lite/LICENSE
new file mode 120000
index 0000000..6b579aa
--- /dev/null
+++ b/crates/pin-project-lite/LICENSE
@@ -0,0 +1 @@
+LICENSE-APACHE
\ No newline at end of file
diff --git a/crates/pin-project-lite/LICENSE-APACHE b/crates/pin-project-lite/LICENSE-APACHE
new file mode 100644
index 0000000..f433b1a
--- /dev/null
+++ b/crates/pin-project-lite/LICENSE-APACHE
@@ -0,0 +1,177 @@
+
+                                 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
diff --git a/crates/pin-project-lite/LICENSE-MIT b/crates/pin-project-lite/LICENSE-MIT
new file mode 100644
index 0000000..31aa793
--- /dev/null
+++ b/crates/pin-project-lite/LICENSE-MIT
@@ -0,0 +1,23 @@
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/crates/pin-project-lite/METADATA b/crates/pin-project-lite/METADATA
new file mode 100644
index 0000000..ba19ea9
--- /dev/null
+++ b/crates/pin-project-lite/METADATA
@@ -0,0 +1,21 @@
+# This project was upgraded manually.
+
+name: "pin-project-lite"
+description: "A lightweight version of pin-project written with declarative macros."
+third_party {
+  url {
+    type: HOMEPAGE
+    value: "https://crates.io/crates/pin-project-lite"
+  }
+  url {
+    type: ARCHIVE
+    value: "https://static.crates.io/crates/pin-project-lite/pin-project-lite-0.2.9.crate"
+  }
+  version: "0.2.13"
+  license_type: NOTICE
+  last_upgrade_date {
+    year: 2023
+    month: 10
+    day: 25
+  }
+}
diff --git a/crates/pin-project-lite/MODULE_LICENSE_APACHE2 b/crates/pin-project-lite/MODULE_LICENSE_APACHE2
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/crates/pin-project-lite/MODULE_LICENSE_APACHE2
diff --git a/crates/pin-project-lite/README.md b/crates/pin-project-lite/README.md
new file mode 100644
index 0000000..40b909a
--- /dev/null
+++ b/crates/pin-project-lite/README.md
@@ -0,0 +1,130 @@
+# pin-project-lite
+
+[![crates.io](https://img.shields.io/crates/v/pin-project-lite?style=flat-square&logo=rust)](https://crates.io/crates/pin-project-lite)
+[![docs.rs](https://img.shields.io/badge/docs.rs-pin--project--lite-blue?style=flat-square&logo=docs.rs)](https://docs.rs/pin-project-lite)
+[![license](https://img.shields.io/badge/license-Apache--2.0_OR_MIT-blue?style=flat-square)](#license)
+[![rustc](https://img.shields.io/badge/rustc-1.37+-blue?style=flat-square&logo=rust)](https://www.rust-lang.org)
+[![build status](https://img.shields.io/github/actions/workflow/status/taiki-e/pin-project-lite/ci.yml?branch=main&style=flat-square&logo=github)](https://github.com/taiki-e/pin-project-lite/actions)
+
+<!-- tidy:crate-doc:start -->
+A lightweight version of [pin-project] written with declarative macros.
+
+## Usage
+
+Add this to your `Cargo.toml`:
+
+```toml
+[dependencies]
+pin-project-lite = "0.2"
+```
+
+*Compiler support: requires rustc 1.37+*
+
+## Examples
+
+[`pin_project!`] macro creates a projection type covering all the fields of
+struct.
+
+```rust
+use std::pin::Pin;
+
+use pin_project_lite::pin_project;
+
+pin_project! {
+    struct Struct<T, U> {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    }
+}
+
+impl<T, U> Struct<T, U> {
+    fn method(self: Pin<&mut Self>) {
+        let this = self.project();
+        let _: Pin<&mut T> = this.pinned; // Pinned reference to the field
+        let _: &mut U = this.unpinned; // Normal reference to the field
+    }
+}
+```
+
+To use [`pin_project!`] on enums, you need to name the projection type
+returned from the method.
+
+```rust
+use std::pin::Pin;
+
+use pin_project_lite::pin_project;
+
+pin_project! {
+    #[project = EnumProj]
+    enum Enum<T, U> {
+        Variant { #[pin] pinned: T, unpinned: U },
+    }
+}
+
+impl<T, U> Enum<T, U> {
+    fn method(self: Pin<&mut Self>) {
+        match self.project() {
+            EnumProj::Variant { pinned, unpinned } => {
+                let _: Pin<&mut T> = pinned;
+                let _: &mut U = unpinned;
+            }
+        }
+    }
+}
+```
+
+## [pin-project] vs pin-project-lite
+
+Here are some similarities and differences compared to [pin-project].
+
+### Similar: Safety
+
+pin-project-lite guarantees safety in much the same way as [pin-project].
+Both are completely safe unless you write other unsafe code.
+
+### Different: Minimal design
+
+This library does not tackle as expansive of a range of use cases as
+[pin-project] does. If your use case is not already covered, please use
+[pin-project].
+
+### Different: No proc-macro related dependencies
+
+This is the **only** reason to use this crate. However, **if you already
+have proc-macro related dependencies in your crate's dependency graph, there
+is no benefit from using this crate.** (Note: There is almost no difference
+in the amount of code generated between [pin-project] and pin-project-lite.)
+
+### Different: No useful error messages
+
+This macro does not handle any invalid input. So error messages are not to
+be useful in most cases. If you do need useful error messages, then upon
+error you can pass the same input to [pin-project] to receive a helpful
+description of the compile error.
+
+### Different: No support for custom Unpin implementation
+
+pin-project supports this by [`UnsafeUnpin`][unsafe-unpin]. (`!Unpin` is supported by both [pin-project][not-unpin] and [pin-project-lite][not-unpin-lite].)
+
+### Different: No support for tuple structs and tuple variants
+
+pin-project supports this.
+
+[not-unpin]: https://docs.rs/pin-project/1/pin_project/attr.pin_project.html#unpin
+[not-unpin-lite]: https://docs.rs/pin-project-lite/0.2/pin_project_lite/macro.pin_project.html#unpin
+[pin-project]: https://github.com/taiki-e/pin-project
+[unsafe-unpin]: https://docs.rs/pin-project/1/pin_project/attr.pin_project.html#unsafeunpin
+
+<!-- tidy:crate-doc:end -->
+
+[`pin_project!`]: https://docs.rs/pin-project-lite/0.2/pin_project_lite/macro.pin_project.html
+
+## License
+
+Licensed under either of [Apache License, Version 2.0](LICENSE-APACHE) or
+[MIT license](LICENSE-MIT) at your option.
+
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in the work by you, as defined in the Apache-2.0 license, shall
+be dual licensed as above, without any additional terms or conditions.
diff --git a/crates/pin-project-lite/TEST_MAPPING b/crates/pin-project-lite/TEST_MAPPING
new file mode 100644
index 0000000..9ef8931
--- /dev/null
+++ b/crates/pin-project-lite/TEST_MAPPING
@@ -0,0 +1,50 @@
+// Generated by update_crate_tests.py for tests that depend on this crate.
+{
+  "imports": [
+    {
+      "path": "external/rust/crates/anyhow"
+    },
+    {
+      "path": "external/rust/crates/async-stream"
+    },
+    {
+      "path": "external/rust/crates/futures-channel"
+    },
+    {
+      "path": "external/rust/crates/futures-executor"
+    },
+    {
+      "path": "external/rust/crates/futures-test"
+    },
+    {
+      "path": "external/rust/crates/futures-util"
+    },
+    {
+      "path": "external/rust/crates/tokio"
+    },
+    {
+      "path": "external/rust/crates/tokio-test"
+    },
+    {
+      "path": "external/uwb/src"
+    },
+    {
+      "path": "packages/modules/DnsResolver"
+    },
+    {
+      "path": "packages/modules/Virtualization/authfs"
+    },
+    {
+      "path": "packages/modules/Virtualization/virtualizationmanager"
+    },
+    {
+      "path": "packages/modules/Virtualization/zipfuse"
+    },
+    {
+      "path": "system/security/keystore2"
+    },
+    {
+      "path": "system/security/keystore2/legacykeystore"
+    }
+  ]
+}
diff --git a/crates/pin-project-lite/cargo_embargo.json b/crates/pin-project-lite/cargo_embargo.json
new file mode 100644
index 0000000..a6d8815
--- /dev/null
+++ b/crates/pin-project-lite/cargo_embargo.json
@@ -0,0 +1,4 @@
+{
+  "min_sdk_version": "29",
+  "run_cargo": false
+}
diff --git a/crates/pin-project-lite/patches/std.diff b/crates/pin-project-lite/patches/std.diff
new file mode 100644
index 0000000..1bc1240
--- /dev/null
+++ b/crates/pin-project-lite/patches/std.diff
@@ -0,0 +1,14 @@
+diff --git a/src/lib.rs b/src/lib.rs
+index 6ec2021..7e46d02 100644
+--- a/src/lib.rs
++++ b/src/lib.rs
+@@ -137,6 +137,9 @@ pin-project supports this.
+     clippy::undocumented_unsafe_blocks,
+ )]
+ 
++// ANDROID: Use std to allow building as a dylib.
++extern crate std;
++
+ /// A macro that creates a projection type covering all the fields of struct.
+ ///
+ /// This macro creates a projection type according to the following rules:
diff --git a/crates/pin-project-lite/src/lib.rs b/crates/pin-project-lite/src/lib.rs
new file mode 100644
index 0000000..7e46d02
--- /dev/null
+++ b/crates/pin-project-lite/src/lib.rs
@@ -0,0 +1,1685 @@
+/*!
+<!-- tidy:crate-doc:start -->
+A lightweight version of [pin-project] written with declarative macros.
+
+## Usage
+
+Add this to your `Cargo.toml`:
+
+```toml
+[dependencies]
+pin-project-lite = "0.2"
+```
+
+*Compiler support: requires rustc 1.37+*
+
+## Examples
+
+[`pin_project!`] macro creates a projection type covering all the fields of
+struct.
+
+```rust
+use std::pin::Pin;
+
+use pin_project_lite::pin_project;
+
+pin_project! {
+    struct Struct<T, U> {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    }
+}
+
+impl<T, U> Struct<T, U> {
+    fn method(self: Pin<&mut Self>) {
+        let this = self.project();
+        let _: Pin<&mut T> = this.pinned; // Pinned reference to the field
+        let _: &mut U = this.unpinned; // Normal reference to the field
+    }
+}
+```
+
+To use [`pin_project!`] on enums, you need to name the projection type
+returned from the method.
+
+```rust
+use std::pin::Pin;
+
+use pin_project_lite::pin_project;
+
+pin_project! {
+    #[project = EnumProj]
+    enum Enum<T, U> {
+        Variant { #[pin] pinned: T, unpinned: U },
+    }
+}
+
+impl<T, U> Enum<T, U> {
+    fn method(self: Pin<&mut Self>) {
+        match self.project() {
+            EnumProj::Variant { pinned, unpinned } => {
+                let _: Pin<&mut T> = pinned;
+                let _: &mut U = unpinned;
+            }
+        }
+    }
+}
+```
+
+## [pin-project] vs pin-project-lite
+
+Here are some similarities and differences compared to [pin-project].
+
+### Similar: Safety
+
+pin-project-lite guarantees safety in much the same way as [pin-project].
+Both are completely safe unless you write other unsafe code.
+
+### Different: Minimal design
+
+This library does not tackle as expansive of a range of use cases as
+[pin-project] does. If your use case is not already covered, please use
+[pin-project].
+
+### Different: No proc-macro related dependencies
+
+This is the **only** reason to use this crate. However, **if you already
+have proc-macro related dependencies in your crate's dependency graph, there
+is no benefit from using this crate.** (Note: There is almost no difference
+in the amount of code generated between [pin-project] and pin-project-lite.)
+
+### Different: No useful error messages
+
+This macro does not handle any invalid input. So error messages are not to
+be useful in most cases. If you do need useful error messages, then upon
+error you can pass the same input to [pin-project] to receive a helpful
+description of the compile error.
+
+### Different: No support for custom Unpin implementation
+
+pin-project supports this by [`UnsafeUnpin`][unsafe-unpin]. (`!Unpin` is supported by both [pin-project][not-unpin] and [pin-project-lite][not-unpin-lite].)
+
+### Different: No support for tuple structs and tuple variants
+
+pin-project supports this.
+
+[not-unpin]: https://docs.rs/pin-project/1/pin_project/attr.pin_project.html#unpin
+[not-unpin-lite]: https://docs.rs/pin-project-lite/0.2/pin_project_lite/macro.pin_project.html#unpin
+[pin-project]: https://github.com/taiki-e/pin-project
+[unsafe-unpin]: https://docs.rs/pin-project/1/pin_project/attr.pin_project.html#unsafeunpin
+
+<!-- tidy:crate-doc:end -->
+*/
+
+#![no_std]
+#![doc(test(
+    no_crate_inject,
+    attr(
+        deny(warnings, rust_2018_idioms, single_use_lifetimes),
+        allow(dead_code, unused_variables)
+    )
+))]
+#![warn(rust_2018_idioms, single_use_lifetimes, unreachable_pub)]
+#![warn(
+    clippy::pedantic,
+    // lints for public library
+    clippy::alloc_instead_of_core,
+    clippy::exhaustive_enums,
+    clippy::exhaustive_structs,
+    clippy::std_instead_of_alloc,
+    clippy::std_instead_of_core,
+    // lints that help writing unsafe code
+    clippy::as_ptr_cast_mut,
+    clippy::default_union_representation,
+    clippy::trailing_empty_array,
+    clippy::transmute_undefined_repr,
+    clippy::undocumented_unsafe_blocks,
+)]
+
+// ANDROID: Use std to allow building as a dylib.
+extern crate std;
+
+/// A macro that creates a projection type covering all the fields of struct.
+///
+/// This macro creates a projection type according to the following rules:
+///
+/// - For the field that uses `#[pin]` attribute, makes the pinned reference to the field.
+/// - For the other fields, makes the unpinned reference to the field.
+///
+/// And the following methods are implemented on the original type:
+///
+/// ```rust
+/// # use std::pin::Pin;
+/// # type Projection<'a> = &'a ();
+/// # type ProjectionRef<'a> = &'a ();
+/// # trait Dox {
+/// fn project(self: Pin<&mut Self>) -> Projection<'_>;
+/// fn project_ref(self: Pin<&Self>) -> ProjectionRef<'_>;
+/// # }
+/// ```
+///
+/// By passing an attribute with the same name as the method to the macro,
+/// you can name the projection type returned from the method. This allows you
+/// to use pattern matching on the projected types.
+///
+/// ```rust
+/// # use pin_project_lite::pin_project;
+/// # use std::pin::Pin;
+/// pin_project! {
+///     #[project = EnumProj]
+///     enum Enum<T> {
+///         Variant { #[pin] field: T },
+///     }
+/// }
+///
+/// impl<T> Enum<T> {
+///     fn method(self: Pin<&mut Self>) {
+///         let this: EnumProj<'_, T> = self.project();
+///         match this {
+///             EnumProj::Variant { field } => {
+///                 let _: Pin<&mut T> = field;
+///             }
+///         }
+///     }
+/// }
+/// ```
+///
+/// By passing the `#[project_replace = MyProjReplace]` attribute you may create an additional
+/// method which allows the contents of `Pin<&mut Self>` to be replaced while simultaneously moving
+/// out all unpinned fields in `Self`.
+///
+/// ```rust
+/// # use std::pin::Pin;
+/// # type MyProjReplace = ();
+/// # trait Dox {
+/// fn project_replace(self: Pin<&mut Self>, replacement: Self) -> MyProjReplace;
+/// # }
+/// ```
+///
+/// Also, note that the projection types returned by `project` and `project_ref` have
+/// an additional lifetime at the beginning of generics.
+///
+/// ```text
+/// let this: EnumProj<'_, T> = self.project();
+///                    ^^
+/// ```
+///
+/// The visibility of the projected types and projection methods is based on the
+/// original type. However, if the visibility of the original type is `pub`, the
+/// visibility of the projected types and the projection methods is downgraded
+/// to `pub(crate)`.
+///
+/// # Safety
+///
+/// `pin_project!` macro guarantees safety in much the same way as [pin-project] crate.
+/// Both are completely safe unless you write other unsafe code.
+///
+/// See [pin-project] crate for more details.
+///
+/// # Examples
+///
+/// ```rust
+/// use std::pin::Pin;
+///
+/// use pin_project_lite::pin_project;
+///
+/// pin_project! {
+///     struct Struct<T, U> {
+///         #[pin]
+///         pinned: T,
+///         unpinned: U,
+///     }
+/// }
+///
+/// impl<T, U> Struct<T, U> {
+///     fn method(self: Pin<&mut Self>) {
+///         let this = self.project();
+///         let _: Pin<&mut T> = this.pinned; // Pinned reference to the field
+///         let _: &mut U = this.unpinned; // Normal reference to the field
+///     }
+/// }
+/// ```
+///
+/// To use `pin_project!` on enums, you need to name the projection type
+/// returned from the method.
+///
+/// ```rust
+/// use std::pin::Pin;
+///
+/// use pin_project_lite::pin_project;
+///
+/// pin_project! {
+///     #[project = EnumProj]
+///     enum Enum<T> {
+///         Struct {
+///             #[pin]
+///             field: T,
+///         },
+///         Unit,
+///     }
+/// }
+///
+/// impl<T> Enum<T> {
+///     fn method(self: Pin<&mut Self>) {
+///         match self.project() {
+///             EnumProj::Struct { field } => {
+///                 let _: Pin<&mut T> = field;
+///             }
+///             EnumProj::Unit => {}
+///         }
+///     }
+/// }
+/// ```
+///
+/// If you want to call the `project()` method multiple times or later use the
+/// original [`Pin`] type, it needs to use [`.as_mut()`][`Pin::as_mut`] to avoid
+/// consuming the [`Pin`].
+///
+/// ```rust
+/// use std::pin::Pin;
+///
+/// use pin_project_lite::pin_project;
+///
+/// pin_project! {
+///     struct Struct<T> {
+///         #[pin]
+///         field: T,
+///     }
+/// }
+///
+/// impl<T> Struct<T> {
+///     fn call_project_twice(mut self: Pin<&mut Self>) {
+///         // `project` consumes `self`, so reborrow the `Pin<&mut Self>` via `as_mut`.
+///         self.as_mut().project();
+///         self.as_mut().project();
+///     }
+/// }
+/// ```
+///
+/// # `!Unpin`
+///
+/// If you want to make sure `Unpin` is not implemented, use the `#[project(!Unpin)]`
+/// attribute.
+///
+/// ```
+/// use pin_project_lite::pin_project;
+///
+/// pin_project! {
+///      #[project(!Unpin)]
+///      struct Struct<T> {
+///          #[pin]
+///          field: T,
+///      }
+/// }
+/// ```
+///
+/// This is equivalent to using `#[pin]` attribute for a [`PhantomPinned`] field.
+///
+/// ```rust
+/// use std::marker::PhantomPinned;
+///
+/// use pin_project_lite::pin_project;
+///
+/// pin_project! {
+///     struct Struct<T> {
+///         field: T,
+///         #[pin]
+///         _pin: PhantomPinned,
+///     }
+/// }
+/// ```
+///
+/// Note that using [`PhantomPinned`] without `#[pin]` or `#[project(!Unpin)]`
+/// attribute has no effect.
+///
+/// [`PhantomPinned`]: core::marker::PhantomPinned
+/// [`Pin::as_mut`]: core::pin::Pin::as_mut
+/// [`Pin`]: core::pin::Pin
+/// [pin-project]: https://github.com/taiki-e/pin-project
+#[macro_export]
+macro_rules! pin_project {
+    ($($tt:tt)*) => {
+        $crate::__pin_project_internal! {
+            [][][][][]
+            $($tt)*
+        }
+    };
+}
+
+// limitations:
+// - no support for tuple structs and tuple variant (wontfix).
+// - no support for multiple trait/lifetime bounds.
+// - no support for `Self` in where clauses. (wontfix)
+// - no support for overlapping lifetime names. (wontfix)
+// - no interoperability with other field attributes.
+// - no useful error messages. (wontfix)
+// etc...
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __pin_project_expand {
+    (
+        [$($proj_mut_ident:ident)?]
+        [$($proj_ref_ident:ident)?]
+        [$($proj_replace_ident:ident)?]
+        [$($proj_not_unpin_mark:ident)?]
+        [$proj_vis:vis]
+        [$(#[$attrs:meta])* $vis:vis $struct_ty_ident:ident $ident:ident]
+        [$($def_generics:tt)*]
+        [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)*)?]
+        {
+            $($body_data:tt)*
+        }
+        $($(#[$drop_impl_attrs:meta])* impl $($pinned_drop:tt)*)?
+    ) => {
+        $crate::__pin_project_reconstruct! {
+            [$(#[$attrs])* $vis $struct_ty_ident $ident]
+            [$($def_generics)*] [$($impl_generics)*]
+            [$($ty_generics)*] [$(where $($where_clause)*)?]
+            {
+                $($body_data)*
+            }
+        }
+
+        $crate::__pin_project_make_proj_ty! {
+            [$($proj_mut_ident)?]
+            [$proj_vis $struct_ty_ident $ident]
+            [__pin_project_make_proj_field_mut]
+            [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?]
+            {
+                $($body_data)*
+            }
+        }
+        $crate::__pin_project_make_proj_ty! {
+            [$($proj_ref_ident)?]
+            [$proj_vis $struct_ty_ident $ident]
+            [__pin_project_make_proj_field_ref]
+            [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?]
+            {
+                $($body_data)*
+            }
+        }
+        $crate::__pin_project_make_proj_replace_ty! {
+            [$($proj_replace_ident)?]
+            [$proj_vis $struct_ty_ident]
+            [__pin_project_make_proj_field_replace]
+            [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?]
+            {
+                $($body_data)*
+            }
+        }
+
+        $crate::__pin_project_constant! {
+            [$(#[$attrs])* $vis $struct_ty_ident $ident]
+            [$($proj_mut_ident)?] [$($proj_ref_ident)?] [$($proj_replace_ident)?]
+            [$($proj_not_unpin_mark)?]
+            [$proj_vis]
+            [$($def_generics)*] [$($impl_generics)*]
+            [$($ty_generics)*] [$(where $($where_clause)*)?]
+            {
+                $($body_data)*
+            }
+            $($(#[$drop_impl_attrs])* impl $($pinned_drop)*)?
+        }
+    };
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __pin_project_constant {
+    (
+        [$(#[$attrs:meta])* $vis:vis struct $ident:ident]
+        [$($proj_mut_ident:ident)?] [$($proj_ref_ident:ident)?] [$($proj_replace_ident:ident)?]
+        [$($proj_not_unpin_mark:ident)?]
+        [$proj_vis:vis]
+        [$($def_generics:tt)*]
+        [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)*)?]
+        {
+            $(
+                $(#[$pin:ident])?
+                $field_vis:vis $field:ident: $field_ty:ty
+            ),+ $(,)?
+        }
+        $($(#[$drop_impl_attrs:meta])* impl $($pinned_drop:tt)*)?
+    ) => {
+        #[allow(explicit_outlives_requirements)] // https://github.com/rust-lang/rust/issues/60993
+        #[allow(single_use_lifetimes)] // https://github.com/rust-lang/rust/issues/55058
+        // This lint warns of `clippy::*` generated by external macros.
+        // We allow this lint for compatibility with older compilers.
+        #[allow(clippy::unknown_clippy_lints)]
+        #[allow(clippy::redundant_pub_crate)] // This lint warns `pub(crate)` field in private struct.
+        #[allow(clippy::used_underscore_binding)]
+        const _: () = {
+            $crate::__pin_project_make_proj_ty! {
+                [$($proj_mut_ident)? Projection]
+                [$proj_vis struct $ident]
+                [__pin_project_make_proj_field_mut]
+                [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?]
+                {
+                    $(
+                        $(#[$pin])?
+                        $field_vis $field: $field_ty
+                    ),+
+                }
+            }
+            $crate::__pin_project_make_proj_ty! {
+                [$($proj_ref_ident)? ProjectionRef]
+                [$proj_vis struct $ident]
+                [__pin_project_make_proj_field_ref]
+                [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?]
+                {
+                    $(
+                        $(#[$pin])?
+                        $field_vis $field: $field_ty
+                    ),+
+                }
+            }
+
+            impl <$($impl_generics)*> $ident <$($ty_generics)*>
+            $(where
+                $($where_clause)*)?
+            {
+                $crate::__pin_project_struct_make_proj_method! {
+                    [$($proj_mut_ident)? Projection]
+                    [$proj_vis]
+                    [project get_unchecked_mut mut]
+                    [$($ty_generics)*]
+                    {
+                        $(
+                            $(#[$pin])?
+                            $field_vis $field
+                        ),+
+                    }
+                }
+                $crate::__pin_project_struct_make_proj_method! {
+                    [$($proj_ref_ident)? ProjectionRef]
+                    [$proj_vis]
+                    [project_ref get_ref]
+                    [$($ty_generics)*]
+                    {
+                        $(
+                            $(#[$pin])?
+                            $field_vis $field
+                        ),+
+                    }
+                }
+                $crate::__pin_project_struct_make_proj_replace_method! {
+                    [$($proj_replace_ident)?]
+                    [$proj_vis]
+                    [ProjectionReplace]
+                    [$($ty_generics)*]
+                    {
+                        $(
+                            $(#[$pin])?
+                            $field_vis $field
+                        ),+
+                    }
+                }
+            }
+
+            $crate::__pin_project_make_unpin_impl! {
+                [$($proj_not_unpin_mark)?]
+                [$vis $ident]
+                [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?]
+                $(
+                    $field: $crate::__pin_project_make_unpin_bound!(
+                        $(#[$pin])? $field_ty
+                    )
+                ),+
+            }
+
+            $crate::__pin_project_make_drop_impl! {
+                [$ident]
+                [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?]
+                $($(#[$drop_impl_attrs])* impl $($pinned_drop)*)?
+            }
+
+            // Ensure that it's impossible to use pin projections on a #[repr(packed)] struct.
+            //
+            // Taking a reference to a packed field is UB, and applying
+            // `#[forbid(unaligned_references)]` makes sure that doing this is a hard error.
+            //
+            // If the struct ends up having #[repr(packed)] applied somehow,
+            // this will generate an (unfriendly) error message. Under all reasonable
+            // circumstances, we'll detect the #[repr(packed)] attribute, and generate
+            // a much nicer error above.
+            //
+            // See https://github.com/taiki-e/pin-project/pull/34 for more details.
+            //
+            // Note:
+            // - Lint-based tricks aren't perfect, but they're much better than nothing:
+            //   https://github.com/taiki-e/pin-project-lite/issues/26
+            //
+            // - Enable both unaligned_references and safe_packed_borrows lints
+            //   because unaligned_references lint does not exist in older compilers:
+            //   https://github.com/taiki-e/pin-project-lite/pull/55
+            //   https://github.com/rust-lang/rust/pull/82525
+            #[forbid(unaligned_references, safe_packed_borrows)]
+            fn __assert_not_repr_packed <$($impl_generics)*> (this: &$ident <$($ty_generics)*>)
+            $(where
+                $($where_clause)*)?
+            {
+                $(
+                    let _ = &this.$field;
+                )+
+            }
+        };
+    };
+    (
+        [$(#[$attrs:meta])* $vis:vis enum $ident:ident]
+        [$($proj_mut_ident:ident)?] [$($proj_ref_ident:ident)?] [$($proj_replace_ident:ident)?]
+        [$($proj_not_unpin_mark:ident)?]
+        [$proj_vis:vis]
+        [$($def_generics:tt)*]
+        [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)*)?]
+        {
+            $(
+                $(#[$variant_attrs:meta])*
+                $variant:ident $({
+                    $(
+                        $(#[$pin:ident])?
+                        $field:ident: $field_ty:ty
+                    ),+ $(,)?
+                })?
+            ),+ $(,)?
+        }
+        $($(#[$drop_impl_attrs:meta])* impl $($pinned_drop:tt)*)?
+    ) => {
+        #[allow(single_use_lifetimes)] // https://github.com/rust-lang/rust/issues/55058
+        // This lint warns of `clippy::*` generated by external macros.
+        // We allow this lint for compatibility with older compilers.
+        #[allow(clippy::unknown_clippy_lints)]
+        #[allow(clippy::used_underscore_binding)]
+        const _: () = {
+            impl <$($impl_generics)*> $ident <$($ty_generics)*>
+            $(where
+                $($where_clause)*)?
+            {
+                $crate::__pin_project_enum_make_proj_method! {
+                    [$($proj_mut_ident)?]
+                    [$proj_vis]
+                    [project get_unchecked_mut mut]
+                    [$($ty_generics)*]
+                    {
+                        $(
+                            $variant $({
+                                $(
+                                    $(#[$pin])?
+                                    $field
+                                ),+
+                            })?
+                        ),+
+                    }
+                }
+                $crate::__pin_project_enum_make_proj_method! {
+                    [$($proj_ref_ident)?]
+                    [$proj_vis]
+                    [project_ref get_ref]
+                    [$($ty_generics)*]
+                    {
+                        $(
+                            $variant $({
+                                $(
+                                    $(#[$pin])?
+                                    $field
+                                ),+
+                            })?
+                        ),+
+                    }
+                }
+                $crate::__pin_project_enum_make_proj_replace_method! {
+                    [$($proj_replace_ident)?]
+                    [$proj_vis]
+                    [$($ty_generics)*]
+                    {
+                        $(
+                            $variant $({
+                                $(
+                                    $(#[$pin])?
+                                    $field
+                                ),+
+                            })?
+                        ),+
+                    }
+                }
+            }
+
+            $crate::__pin_project_make_unpin_impl! {
+                [$($proj_not_unpin_mark)?]
+                [$vis $ident]
+                [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?]
+                $(
+                    $variant: ($(
+                        $(
+                            $crate::__pin_project_make_unpin_bound!(
+                                $(#[$pin])? $field_ty
+                            )
+                        ),+
+                    )?)
+                ),+
+            }
+
+            $crate::__pin_project_make_drop_impl! {
+                [$ident]
+                [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?]
+                $($(#[$drop_impl_attrs])* impl $($pinned_drop)*)?
+            }
+
+            // We don't need to check for '#[repr(packed)]',
+            // since it does not apply to enums.
+        };
+    };
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __pin_project_reconstruct {
+    (
+        [$(#[$attrs:meta])* $vis:vis struct $ident:ident]
+        [$($def_generics:tt)*] [$($impl_generics:tt)*]
+        [$($ty_generics:tt)*] [$(where $($where_clause:tt)*)?]
+        {
+            $(
+                $(#[$pin:ident])?
+                $field_vis:vis $field:ident: $field_ty:ty
+            ),+ $(,)?
+        }
+    ) => {
+        $(#[$attrs])*
+        $vis struct $ident $($def_generics)*
+        $(where
+            $($where_clause)*)?
+        {
+            $(
+                $field_vis $field: $field_ty
+            ),+
+        }
+    };
+    (
+        [$(#[$attrs:meta])* $vis:vis enum $ident:ident]
+        [$($def_generics:tt)*] [$($impl_generics:tt)*]
+        [$($ty_generics:tt)*] [$(where $($where_clause:tt)*)?]
+        {
+            $(
+                $(#[$variant_attrs:meta])*
+                $variant:ident $({
+                    $(
+                        $(#[$pin:ident])?
+                        $field:ident: $field_ty:ty
+                    ),+ $(,)?
+                })?
+            ),+ $(,)?
+        }
+    ) => {
+        $(#[$attrs])*
+        $vis enum $ident $($def_generics)*
+        $(where
+            $($where_clause)*)?
+        {
+            $(
+                $(#[$variant_attrs])*
+                $variant $({
+                    $(
+                        $field: $field_ty
+                    ),+
+                })?
+            ),+
+        }
+    };
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __pin_project_make_proj_ty {
+    ([] $($field:tt)*) => {};
+    (
+        [$proj_ty_ident:ident $default_ident:ident]
+        [$proj_vis:vis struct $ident:ident]
+        $($field:tt)*
+    ) => {};
+    (
+        [$proj_ty_ident:ident]
+        [$proj_vis:vis struct $ident:ident]
+        [$__pin_project_make_proj_field:ident]
+        [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)*)?]
+        {
+            $(
+                $(#[$pin:ident])?
+                $field_vis:vis $field:ident: $field_ty:ty
+            ),+ $(,)?
+        }
+    ) => {
+        $crate::__pin_project_make_proj_ty_body! {
+            [$proj_ty_ident]
+            [$proj_vis struct $ident]
+            [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?]
+            [
+                $(
+                    $field_vis $field: $crate::$__pin_project_make_proj_field!(
+                        $(#[$pin])? $field_ty
+                    )
+                ),+
+            ]
+        }
+    };
+    (
+        [$proj_ty_ident:ident]
+        [$proj_vis:vis enum $ident:ident]
+        [$__pin_project_make_proj_field:ident]
+        [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)*)?]
+        {
+            $(
+                $(#[$variant_attrs:meta])*
+                $variant:ident $({
+                    $(
+                        $(#[$pin:ident])?
+                        $field:ident: $field_ty:ty
+                    ),+ $(,)?
+                })?
+            ),+ $(,)?
+        }
+    ) => {
+        $crate::__pin_project_make_proj_ty_body! {
+            [$proj_ty_ident]
+            [$proj_vis enum $ident]
+            [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?]
+            [
+                $(
+                    $variant $({
+                        $(
+                            $field: $crate::$__pin_project_make_proj_field!(
+                                $(#[$pin])? $field_ty
+                            )
+                        ),+
+                    })?
+                ),+
+            ]
+        }
+    };
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __pin_project_make_proj_ty_body {
+    (
+        [$proj_ty_ident:ident]
+        [$proj_vis:vis $struct_ty_ident:ident $ident:ident]
+        [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)*)?]
+        [$($body_data:tt)+]
+    ) => {
+        #[doc(hidden)] // Workaround for rustc bug: see https://github.com/taiki-e/pin-project-lite/issues/77#issuecomment-1671540180 for more.
+        #[allow(dead_code)] // This lint warns unused fields/variants.
+        #[allow(single_use_lifetimes)] // https://github.com/rust-lang/rust/issues/55058
+        // This lint warns of `clippy::*` generated by external macros.
+        // We allow this lint for compatibility with older compilers.
+        #[allow(clippy::unknown_clippy_lints)]
+        #[allow(clippy::mut_mut)] // This lint warns `&mut &mut <ty>`. (only needed for project)
+        #[allow(clippy::redundant_pub_crate)] // This lint warns `pub(crate)` field in private struct.
+        #[allow(clippy::ref_option_ref)] // This lint warns `&Option<&<ty>>`. (only needed for project_ref)
+        #[allow(clippy::type_repetition_in_bounds)] // https://github.com/rust-lang/rust-clippy/issues/4326
+        $proj_vis $struct_ty_ident $proj_ty_ident <'__pin, $($impl_generics)*>
+        where
+            $ident <$($ty_generics)*>: '__pin
+            $(, $($where_clause)*)?
+        {
+            $($body_data)+
+        }
+    };
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __pin_project_make_proj_replace_ty {
+    ([] $($field:tt)*) => {};
+    (
+        [$proj_ty_ident:ident]
+        [$proj_vis:vis struct]
+        [$__pin_project_make_proj_field:ident]
+        [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)*)?]
+        {
+            $(
+                $(#[$pin:ident])?
+                $field_vis:vis $field:ident: $field_ty:ty
+            ),+ $(,)?
+        }
+    ) => {
+        $crate::__pin_project_make_proj_replace_ty_body! {
+            [$proj_ty_ident]
+            [$proj_vis struct]
+            [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?]
+            [
+                $(
+                    $field_vis $field: $crate::$__pin_project_make_proj_field!(
+                        $(#[$pin])? $field_ty
+                    )
+                ),+
+            ]
+        }
+    };
+    (
+        [$proj_ty_ident:ident]
+        [$proj_vis:vis enum]
+        [$__pin_project_make_proj_field:ident]
+        [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)*)?]
+        {
+            $(
+                $(#[$variant_attrs:meta])*
+                $variant:ident $({
+                    $(
+                        $(#[$pin:ident])?
+                        $field:ident: $field_ty:ty
+                    ),+ $(,)?
+                })?
+            ),+ $(,)?
+        }
+    ) => {
+        $crate::__pin_project_make_proj_replace_ty_body! {
+            [$proj_ty_ident]
+            [$proj_vis enum]
+            [$($impl_generics)*] [$($ty_generics)*] [$(where $($where_clause)*)?]
+            [
+                $(
+                    $variant $({
+                        $(
+                            $field: $crate::$__pin_project_make_proj_field!(
+                                $(#[$pin])? $field_ty
+                            )
+                        ),+
+                    })?
+                ),+
+            ]
+        }
+    };
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __pin_project_make_proj_replace_ty_body {
+    (
+        [$proj_ty_ident:ident]
+        [$proj_vis:vis $struct_ty_ident:ident]
+        [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)*)?]
+        [$($body_data:tt)+]
+    ) => {
+        #[doc(hidden)] // Workaround for rustc bug: see https://github.com/taiki-e/pin-project-lite/issues/77#issuecomment-1671540180 for more.
+        #[allow(dead_code)] // This lint warns unused fields/variants.
+        #[allow(single_use_lifetimes)] // https://github.com/rust-lang/rust/issues/55058
+        #[allow(clippy::mut_mut)] // This lint warns `&mut &mut <ty>`. (only needed for project)
+        #[allow(clippy::redundant_pub_crate)] // This lint warns `pub(crate)` field in private struct.
+        #[allow(clippy::type_repetition_in_bounds)] // https://github.com/rust-lang/rust-clippy/issues/4326
+        $proj_vis $struct_ty_ident $proj_ty_ident <$($impl_generics)*>
+        where
+            $($($where_clause)*)?
+        {
+            $($body_data)+
+        }
+    };
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __pin_project_make_proj_replace_block {
+    (
+        [$($proj_path:tt)+]
+        {
+            $(
+                $(#[$pin:ident])?
+                $field_vis:vis $field:ident
+            ),+
+        }
+    ) => {
+        let result = $($proj_path)* {
+            $(
+                $field: $crate::__pin_project_make_replace_field_proj!(
+                    $(#[$pin])? $field
+                )
+            ),+
+        };
+
+        {
+            ( $(
+                $crate::__pin_project_make_unsafe_drop_in_place_guard!(
+                    $(#[$pin])? $field
+                ),
+            )* );
+        }
+
+        result
+    };
+    ([$($proj_path:tt)+]) => { $($proj_path)* };
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __pin_project_struct_make_proj_method {
+    ([] $($variant:tt)*) => {};
+    (
+        [$proj_ty_ident:ident $_ignored_default_arg:ident]
+        [$proj_vis:vis]
+        [$method_ident:ident $get_method:ident $($mut:ident)?]
+        [$($ty_generics:tt)*]
+        $($variant:tt)*
+    ) => {
+        $crate::__pin_project_struct_make_proj_method! {
+            [$proj_ty_ident]
+            [$proj_vis]
+            [$method_ident $get_method $($mut)?]
+            [$($ty_generics)*]
+            $($variant)*
+        }
+    };
+    (
+        [$proj_ty_ident:ident]
+        [$proj_vis:vis]
+        [$method_ident:ident $get_method:ident $($mut:ident)?]
+        [$($ty_generics:tt)*]
+        {
+            $(
+                $(#[$pin:ident])?
+                $field_vis:vis $field:ident
+            ),+
+        }
+    ) => {
+        #[doc(hidden)] // Workaround for rustc bug: see https://github.com/taiki-e/pin-project-lite/issues/77#issuecomment-1671540180 for more.
+        #[inline]
+        $proj_vis fn $method_ident<'__pin>(
+            self: $crate::__private::Pin<&'__pin $($mut)? Self>,
+        ) -> $proj_ty_ident <'__pin, $($ty_generics)*> {
+            unsafe {
+                let Self { $($field),* } = self.$get_method();
+                $proj_ty_ident {
+                    $(
+                        $field: $crate::__pin_project_make_unsafe_field_proj!(
+                            $(#[$pin])? $field
+                        )
+                    ),+
+                }
+            }
+        }
+    };
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __pin_project_struct_make_proj_replace_method {
+    ([] $($field:tt)*) => {};
+    (
+        [$proj_ty_ident:ident]
+        [$proj_vis:vis]
+        [$_proj_ty_ident:ident]
+        [$($ty_generics:tt)*]
+        {
+            $(
+                $(#[$pin:ident])?
+                $field_vis:vis $field:ident
+            ),+
+        }
+    ) => {
+        #[doc(hidden)] // Workaround for rustc bug: see https://github.com/taiki-e/pin-project-lite/issues/77#issuecomment-1671540180 for more.
+        #[inline]
+        $proj_vis fn project_replace(
+            self: $crate::__private::Pin<&mut Self>,
+            replacement: Self,
+        ) -> $proj_ty_ident <$($ty_generics)*> {
+            unsafe {
+                let __self_ptr: *mut Self = self.get_unchecked_mut();
+
+                // Destructors will run in reverse order, so next create a guard to overwrite
+                // `self` with the replacement value without calling destructors.
+                let __guard = $crate::__private::UnsafeOverwriteGuard::new(__self_ptr, replacement);
+
+                let Self { $($field),* } = &mut *__self_ptr;
+
+                $crate::__pin_project_make_proj_replace_block! {
+                    [$proj_ty_ident]
+                    {
+                        $(
+                            $(#[$pin])?
+                            $field
+                        ),+
+                    }
+                }
+            }
+        }
+    };
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __pin_project_enum_make_proj_method {
+    ([] $($variant:tt)*) => {};
+    (
+        [$proj_ty_ident:ident]
+        [$proj_vis:vis]
+        [$method_ident:ident $get_method:ident $($mut:ident)?]
+        [$($ty_generics:tt)*]
+        {
+            $(
+                $variant:ident $({
+                    $(
+                        $(#[$pin:ident])?
+                        $field:ident
+                    ),+
+                })?
+            ),+
+        }
+    ) => {
+        #[doc(hidden)] // Workaround for rustc bug: see https://github.com/taiki-e/pin-project-lite/issues/77#issuecomment-1671540180 for more.
+        #[inline]
+        $proj_vis fn $method_ident<'__pin>(
+            self: $crate::__private::Pin<&'__pin $($mut)? Self>,
+        ) -> $proj_ty_ident <'__pin, $($ty_generics)*> {
+            unsafe {
+                match self.$get_method() {
+                    $(
+                        Self::$variant $({
+                            $($field),+
+                        })? => {
+                            $proj_ty_ident::$variant $({
+                                $(
+                                    $field: $crate::__pin_project_make_unsafe_field_proj!(
+                                        $(#[$pin])? $field
+                                    )
+                                ),+
+                            })?
+                        }
+                    ),+
+                }
+            }
+        }
+    };
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __pin_project_enum_make_proj_replace_method {
+    ([] $($field:tt)*) => {};
+    (
+        [$proj_ty_ident:ident]
+        [$proj_vis:vis]
+        [$($ty_generics:tt)*]
+        {
+            $(
+                $variant:ident $({
+                    $(
+                        $(#[$pin:ident])?
+                        $field:ident
+                    ),+
+                })?
+            ),+
+        }
+    ) => {
+        #[doc(hidden)] // Workaround for rustc bug: see https://github.com/taiki-e/pin-project-lite/issues/77#issuecomment-1671540180 for more.
+        #[inline]
+        $proj_vis fn project_replace(
+            self: $crate::__private::Pin<&mut Self>,
+            replacement: Self,
+        ) -> $proj_ty_ident <$($ty_generics)*> {
+            unsafe {
+                let __self_ptr: *mut Self = self.get_unchecked_mut();
+
+                // Destructors will run in reverse order, so next create a guard to overwrite
+                // `self` with the replacement value without calling destructors.
+                let __guard = $crate::__private::UnsafeOverwriteGuard::new(__self_ptr, replacement);
+
+                match &mut *__self_ptr {
+                    $(
+                        Self::$variant $({
+                            $($field),+
+                        })? => {
+                            $crate::__pin_project_make_proj_replace_block! {
+                                [$proj_ty_ident :: $variant]
+                                $({
+                                    $(
+                                        $(#[$pin])?
+                                        $field
+                                    ),+
+                                })?
+                            }
+                        }
+                    ),+
+                }
+            }
+        }
+    };
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __pin_project_make_unpin_impl {
+    (
+        []
+        [$vis:vis $ident:ident]
+        [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)*)?]
+        $($field:tt)*
+    ) => {
+        // Automatically create the appropriate conditional `Unpin` implementation.
+        //
+        // Basically this is equivalent to the following code:
+        // ```rust
+        // impl<T, U> Unpin for Struct<T, U> where T: Unpin {}
+        // ```
+        //
+        // However, if struct is public and there is a private type field,
+        // this would cause an E0446 (private type in public interface).
+        //
+        // When RFC 2145 is implemented (rust-lang/rust#48054),
+        // this will become a lint, rather then a hard error.
+        //
+        // As a workaround for this, we generate a new struct, containing all of the pinned
+        // fields from our #[pin_project] type. This struct is declared within
+        // a function, which makes it impossible to be named by user code.
+        // This guarantees that it will use the default auto-trait impl for Unpin -
+        // that is, it will implement Unpin iff all of its fields implement Unpin.
+        // This type can be safely declared as 'public', satisfying the privacy
+        // checker without actually allowing user code to access it.
+        //
+        // This allows users to apply the #[pin_project] attribute to types
+        // regardless of the privacy of the types of their fields.
+        //
+        // See also https://github.com/taiki-e/pin-project/pull/53.
+        #[allow(non_snake_case)]
+        $vis struct __Origin <'__pin, $($impl_generics)*>
+        $(where
+            $($where_clause)*)?
+        {
+            __dummy_lifetime: $crate::__private::PhantomData<&'__pin ()>,
+            $($field)*
+        }
+        impl <'__pin, $($impl_generics)*> $crate::__private::Unpin for $ident <$($ty_generics)*>
+        where
+            __Origin <'__pin, $($ty_generics)*>: $crate::__private::Unpin
+            $(, $($where_clause)*)?
+        {
+        }
+    };
+    (
+        [$proj_not_unpin_mark:ident]
+        [$vis:vis $ident:ident]
+        [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)*)?]
+        $($field:tt)*
+    ) => {
+        #[doc(hidden)]
+        impl <'__pin, $($impl_generics)*> $crate::__private::Unpin for $ident <$($ty_generics)*>
+        where
+            (
+                ::core::marker::PhantomData<&'__pin ()>,
+                ::core::marker::PhantomPinned,
+            ): $crate::__private::Unpin
+            $(, $($where_clause)*)?
+        {
+        }
+    }
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __pin_project_make_drop_impl {
+    (
+        [$_ident:ident]
+        [$($_impl_generics:tt)*] [$($_ty_generics:tt)*] [$(where $($_where_clause:tt)*)?]
+        $(#[$drop_impl_attrs:meta])*
+        impl $(<
+            $( $lifetime:lifetime $(: $lifetime_bound:lifetime)? ),* $(,)?
+            $( $generics:ident
+                $(: $generics_bound:path)?
+                $(: ?$generics_unsized_bound:path)?
+                $(: $generics_lifetime_bound:lifetime)?
+            ),*
+        >)? PinnedDrop for $self_ty:ty
+        $(where
+            $( $where_clause_ty:ty
+                $(: $where_clause_bound:path)?
+                $(: ?$where_clause_unsized_bound:path)?
+                $(: $where_clause_lifetime_bound:lifetime)?
+            ),* $(,)?
+        )?
+        {
+            $(#[$drop_fn_attrs:meta])*
+            fn drop($($arg:ident)+: Pin<&mut Self>) {
+                $($tt:tt)*
+            }
+        }
+    ) => {
+        $(#[$drop_impl_attrs])*
+        impl $(<
+            $( $lifetime $(: $lifetime_bound)? ,)*
+            $( $generics
+                $(: $generics_bound)?
+                $(: ?$generics_unsized_bound)?
+                $(: $generics_lifetime_bound)?
+            ),*
+        >)? $crate::__private::Drop for $self_ty
+        $(where
+            $( $where_clause_ty
+                $(: $where_clause_bound)?
+                $(: ?$where_clause_unsized_bound)?
+                $(: $where_clause_lifetime_bound)?
+            ),*
+        )?
+        {
+            $(#[$drop_fn_attrs])*
+            fn drop(&mut self) {
+                // Implementing `__DropInner::__drop_inner` is safe, but calling it is not safe.
+                // This is because destructors can be called multiple times in safe code and
+                // [double dropping is unsound](https://github.com/rust-lang/rust/pull/62360).
+                //
+                // `__drop_inner` is defined as a safe method, but this is fine since
+                // `__drop_inner` is not accessible by the users and we call `__drop_inner` only
+                // once.
+                //
+                // Users can implement [`Drop`] safely using `pin_project!` and can drop a
+                // type that implements `PinnedDrop` using the [`drop`] function safely.
+                fn __drop_inner $(<
+                    $( $lifetime $(: $lifetime_bound)? ,)*
+                    $( $generics
+                        $(: $generics_bound)?
+                        $(: ?$generics_unsized_bound)?
+                        $(: $generics_lifetime_bound)?
+                    ),*
+                >)? (
+                    $($arg)+: $crate::__private::Pin<&mut $self_ty>,
+                )
+                $(where
+                    $( $where_clause_ty
+                        $(: $where_clause_bound)?
+                        $(: ?$where_clause_unsized_bound)?
+                        $(: $where_clause_lifetime_bound)?
+                    ),*
+                )?
+                {
+                    // A dummy `__drop_inner` function to prevent users call outer `__drop_inner`.
+                    fn __drop_inner() {}
+                    $($tt)*
+                }
+
+                // Safety - we're in 'drop', so we know that 'self' will
+                // never move again.
+                let pinned_self: $crate::__private::Pin<&mut Self>
+                    = unsafe { $crate::__private::Pin::new_unchecked(self) };
+                // We call `__drop_inner` only once. Since `__DropInner::__drop_inner`
+                // is not accessible by the users, it is never called again.
+                __drop_inner(pinned_self);
+            }
+        }
+    };
+    (
+        [$ident:ident]
+        [$($impl_generics:tt)*] [$($ty_generics:tt)*] [$(where $($where_clause:tt)*)?]
+    ) => {
+        // Ensure that struct does not implement `Drop`.
+        //
+        // There are two possible cases:
+        // 1. The user type does not implement Drop. In this case,
+        // the first blanked impl will not apply to it. This code
+        // will compile, as there is only one impl of MustNotImplDrop for the user type
+        // 2. The user type does impl Drop. This will make the blanket impl applicable,
+        // which will then conflict with the explicit MustNotImplDrop impl below.
+        // This will result in a compilation error, which is exactly what we want.
+        trait MustNotImplDrop {}
+        #[allow(clippy::drop_bounds, drop_bounds)]
+        impl<T: $crate::__private::Drop> MustNotImplDrop for T {}
+        impl <$($impl_generics)*> MustNotImplDrop for $ident <$($ty_generics)*>
+        $(where
+            $($where_clause)*)?
+        {
+        }
+    };
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __pin_project_make_unpin_bound {
+    (#[pin] $field_ty:ty) => {
+        $field_ty
+    };
+    ($field_ty:ty) => {
+        $crate::__private::AlwaysUnpin<$field_ty>
+    };
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __pin_project_make_unsafe_field_proj {
+    (#[pin] $field:ident) => {
+        $crate::__private::Pin::new_unchecked($field)
+    };
+    ($field:ident) => {
+        $field
+    };
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __pin_project_make_replace_field_proj {
+    (#[pin] $field:ident) => {
+        $crate::__private::PhantomData
+    };
+    ($field:ident) => {
+        $crate::__private::ptr::read($field)
+    };
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __pin_project_make_unsafe_drop_in_place_guard {
+    (#[pin] $field:ident) => {
+        $crate::__private::UnsafeDropInPlaceGuard::new($field)
+    };
+    ($field:ident) => {
+        ()
+    };
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __pin_project_make_proj_field_mut {
+    (#[pin] $field_ty:ty) => {
+        $crate::__private::Pin<&'__pin mut ($field_ty)>
+    };
+    ($field_ty:ty) => {
+        &'__pin mut ($field_ty)
+    };
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __pin_project_make_proj_field_ref {
+    (#[pin] $field_ty:ty) => {
+        $crate::__private::Pin<&'__pin ($field_ty)>
+    };
+    ($field_ty:ty) => {
+        &'__pin ($field_ty)
+    };
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __pin_project_make_proj_field_replace {
+    (#[pin] $field_ty:ty) => {
+        $crate::__private::PhantomData<$field_ty>
+    };
+    ($field_ty:ty) => {
+        $field_ty
+    };
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __pin_project_internal {
+    // parsing proj_mut_ident
+    (
+        []
+        [$($proj_ref_ident:ident)?]
+        [$($proj_replace_ident:ident)?]
+        [$( ! $proj_not_unpin_mark:ident)?]
+        [$($attrs:tt)*]
+
+        #[project = $proj_mut_ident:ident]
+        $($tt:tt)*
+    ) => {
+        $crate::__pin_project_internal! {
+            [$proj_mut_ident]
+            [$($proj_ref_ident)?]
+            [$($proj_replace_ident)?]
+            [$( ! $proj_not_unpin_mark)?]
+            [$($attrs)*]
+            $($tt)*
+        }
+    };
+    // parsing proj_ref_ident
+    (
+        [$($proj_mut_ident:ident)?]
+        []
+        [$($proj_replace_ident:ident)?]
+        [$( ! $proj_not_unpin_mark:ident)?]
+        [$($attrs:tt)*]
+
+        #[project_ref = $proj_ref_ident:ident]
+        $($tt:tt)*
+    ) => {
+        $crate::__pin_project_internal! {
+            [$($proj_mut_ident)?]
+            [$proj_ref_ident]
+            [$($proj_replace_ident)?]
+            [$( ! $proj_not_unpin_mark)?]
+            [$($attrs)*]
+            $($tt)*
+        }
+    };
+    // parsing proj_replace_ident
+    (
+        [$($proj_mut_ident:ident)?]
+        [$($proj_ref_ident:ident)?]
+        []
+        [$( ! $proj_not_unpin_mark:ident)?]
+        [$($attrs:tt)*]
+
+        #[project_replace = $proj_replace_ident:ident]
+        $($tt:tt)*
+    ) => {
+        $crate::__pin_project_internal! {
+            [$($proj_mut_ident)?]
+            [$($proj_ref_ident)?]
+            [$proj_replace_ident]
+            [$( ! $proj_not_unpin_mark)?]
+            [$($attrs)*]
+            $($tt)*
+        }
+    };
+    // parsing !Unpin
+    (
+        [$($proj_mut_ident:ident)?]
+        [$($proj_ref_ident:ident)?]
+        [$($proj_replace_ident:ident)?]
+        []
+        [$($attrs:tt)*]
+
+        #[project( ! $proj_not_unpin_mark:ident)]
+        $($tt:tt)*
+    ) => {
+        $crate::__pin_project_internal! {
+            [$($proj_mut_ident)?]
+            [$($proj_ref_ident)?]
+            [$($proj_replace_ident)?]
+            [ ! $proj_not_unpin_mark]
+            [$($attrs)*]
+            $($tt)*
+        }
+    };
+    // this is actually part of a recursive step that picks off a single non-`pin_project_lite` attribute
+    // there could be more to parse
+    (
+        [$($proj_mut_ident:ident)?]
+        [$($proj_ref_ident:ident)?]
+        [$($proj_replace_ident:ident)?]
+        [$( ! $proj_not_unpin_mark:ident)?]
+        [$($attrs:tt)*]
+
+        #[$($attr:tt)*]
+        $($tt:tt)*
+    ) => {
+        $crate::__pin_project_internal! {
+            [$($proj_mut_ident)?]
+            [$($proj_ref_ident)?]
+            [$($proj_replace_ident)?]
+            [$( ! $proj_not_unpin_mark)?]
+            [$($attrs)* #[$($attr)*]]
+            $($tt)*
+        }
+    };
+    // now determine visibility
+    // if public, downgrade
+    (
+        [$($proj_mut_ident:ident)?]
+        [$($proj_ref_ident:ident)?]
+        [$($proj_replace_ident:ident)?]
+        [$( ! $proj_not_unpin_mark:ident)?]
+        [$($attrs:tt)*]
+        pub $struct_ty_ident:ident $ident:ident
+        $($tt:tt)*
+    ) => {
+        $crate::__pin_project_parse_generics! {
+            [$($proj_mut_ident)?]
+            [$($proj_ref_ident)?]
+            [$($proj_replace_ident)?]
+            [$($proj_not_unpin_mark)?]
+            [$($attrs)*]
+            [pub $struct_ty_ident $ident pub(crate)]
+            $($tt)*
+        }
+    };
+    (
+        [$($proj_mut_ident:ident)?]
+        [$($proj_ref_ident:ident)?]
+        [$($proj_replace_ident:ident)?]
+        [$( ! $proj_not_unpin_mark:ident)?]
+        [$($attrs:tt)*]
+        $vis:vis $struct_ty_ident:ident $ident:ident
+        $($tt:tt)*
+    ) => {
+        $crate::__pin_project_parse_generics! {
+            [$($proj_mut_ident)?]
+            [$($proj_ref_ident)?]
+            [$($proj_replace_ident)?]
+            [$($proj_not_unpin_mark)?]
+            [$($attrs)*]
+            [$vis $struct_ty_ident $ident $vis]
+            $($tt)*
+        }
+    };
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __pin_project_parse_generics {
+    (
+        [$($proj_mut_ident:ident)?]
+        [$($proj_ref_ident:ident)?]
+        [$($proj_replace_ident:ident)?]
+        [$($proj_not_unpin_mark:ident)?]
+        [$($attrs:tt)*]
+        [$vis:vis $struct_ty_ident:ident $ident:ident $proj_vis:vis]
+        $(<
+            $( $lifetime:lifetime $(: $lifetime_bound:lifetime)? ),* $(,)?
+            $( $generics:ident
+                $(: $generics_bound:path)?
+                $(: ?$generics_unsized_bound:path)?
+                $(: $generics_lifetime_bound:lifetime)?
+                $(= $generics_default:ty)?
+            ),* $(,)?
+        >)?
+        $(where
+            $( $where_clause_ty:ty
+                $(: $where_clause_bound:path)?
+                $(: ?$where_clause_unsized_bound:path)?
+                $(: $where_clause_lifetime_bound:lifetime)?
+            ),* $(,)?
+        )?
+        {
+            $($body_data:tt)*
+        }
+        $($(#[$drop_impl_attrs:meta])* impl $($pinned_drop:tt)*)?
+    ) => {
+        $crate::__pin_project_expand! {
+            [$($proj_mut_ident)?]
+            [$($proj_ref_ident)?]
+            [$($proj_replace_ident)?]
+            [$($proj_not_unpin_mark)?]
+            [$proj_vis]
+            [$($attrs)* $vis $struct_ty_ident $ident]
+            [$(<
+                $( $lifetime $(: $lifetime_bound)? ,)*
+                $( $generics
+                    $(: $generics_bound)?
+                    $(: ?$generics_unsized_bound)?
+                    $(: $generics_lifetime_bound)?
+                    $(= $generics_default)?
+                ),*
+            >)?]
+            [$(
+                $( $lifetime $(: $lifetime_bound)? ,)*
+                $( $generics
+                    $(: $generics_bound)?
+                    $(: ?$generics_unsized_bound)?
+                    $(: $generics_lifetime_bound)?
+                ),*
+            )?]
+            [$( $( $lifetime ,)* $( $generics ),* )?]
+            [$(where $( $where_clause_ty
+                $(: $where_clause_bound)?
+                $(: ?$where_clause_unsized_bound)?
+                $(: $where_clause_lifetime_bound)?
+            ),* )?]
+            {
+                $($body_data)*
+            }
+            $($(#[$drop_impl_attrs])* impl $($pinned_drop)*)?
+        }
+    };
+}
+
+#[doc(hidden)]
+pub mod __private {
+    use core::mem::ManuallyDrop;
+    #[doc(hidden)]
+    pub use core::{
+        marker::{PhantomData, Unpin},
+        ops::Drop,
+        pin::Pin,
+        ptr,
+    };
+
+    // This is an internal helper struct used by `pin_project!`.
+    #[doc(hidden)]
+    pub struct AlwaysUnpin<T: ?Sized>(PhantomData<T>);
+
+    impl<T: ?Sized> Unpin for AlwaysUnpin<T> {}
+
+    // This is an internal helper used to ensure a value is dropped.
+    #[doc(hidden)]
+    pub struct UnsafeDropInPlaceGuard<T: ?Sized>(*mut T);
+
+    impl<T: ?Sized> UnsafeDropInPlaceGuard<T> {
+        #[doc(hidden)]
+        pub unsafe fn new(ptr: *mut T) -> Self {
+            Self(ptr)
+        }
+    }
+
+    impl<T: ?Sized> Drop for UnsafeDropInPlaceGuard<T> {
+        fn drop(&mut self) {
+            // SAFETY: the caller of `UnsafeDropInPlaceGuard::new` must guarantee
+            // that `ptr` is valid for drop when this guard is destructed.
+            unsafe {
+                ptr::drop_in_place(self.0);
+            }
+        }
+    }
+
+    // This is an internal helper used to ensure a value is overwritten without
+    // its destructor being called.
+    #[doc(hidden)]
+    pub struct UnsafeOverwriteGuard<T> {
+        target: *mut T,
+        value: ManuallyDrop<T>,
+    }
+
+    impl<T> UnsafeOverwriteGuard<T> {
+        #[doc(hidden)]
+        pub unsafe fn new(target: *mut T, value: T) -> Self {
+            Self { target, value: ManuallyDrop::new(value) }
+        }
+    }
+
+    impl<T> Drop for UnsafeOverwriteGuard<T> {
+        fn drop(&mut self) {
+            // SAFETY: the caller of `UnsafeOverwriteGuard::new` must guarantee
+            // that `target` is valid for writes when this guard is destructed.
+            unsafe {
+                ptr::write(self.target, ptr::read(&*self.value));
+            }
+        }
+    }
+}
diff --git a/crates/pin-project-lite/tests/auxiliary/mod.rs b/crates/pin-project-lite/tests/auxiliary/mod.rs
new file mode 100644
index 0000000..1457099
--- /dev/null
+++ b/crates/pin-project-lite/tests/auxiliary/mod.rs
@@ -0,0 +1,12 @@
+#![allow(dead_code, unused_macros)]
+
+macro_rules! assert_unpin {
+    ($ty:ty) => {
+        static_assertions::assert_impl_all!($ty: Unpin);
+    };
+}
+macro_rules! assert_not_unpin {
+    ($ty:ty) => {
+        static_assertions::assert_not_impl_all!($ty: Unpin);
+    };
+}
diff --git a/crates/pin-project-lite/tests/compiletest.rs b/crates/pin-project-lite/tests/compiletest.rs
new file mode 100644
index 0000000..06712d0
--- /dev/null
+++ b/crates/pin-project-lite/tests/compiletest.rs
@@ -0,0 +1,16 @@
+#![cfg(not(miri))]
+#![cfg(not(careful))]
+#![warn(rust_2018_idioms, single_use_lifetimes)]
+
+use std::env;
+
+#[rustversion::attr(not(nightly), ignore)]
+#[test]
+fn ui() {
+    if env::var_os("CI").is_none() {
+        env::set_var("TRYBUILD", "overwrite");
+    }
+
+    let t = trybuild::TestCases::new();
+    t.compile_fail("tests/ui/**/*.rs");
+}
diff --git a/crates/pin-project-lite/tests/drop_order.rs b/crates/pin-project-lite/tests/drop_order.rs
new file mode 100644
index 0000000..6e5deaf
--- /dev/null
+++ b/crates/pin-project-lite/tests/drop_order.rs
@@ -0,0 +1,169 @@
+#![warn(rust_2018_idioms, single_use_lifetimes)]
+
+// Refs: https://doc.rust-lang.org/reference/destructors.html
+
+use std::{cell::Cell, panic, pin::Pin, thread};
+
+use pin_project_lite::pin_project;
+
+struct D<'a>(&'a Cell<usize>, usize);
+
+impl Drop for D<'_> {
+    fn drop(&mut self) {
+        if !thread::panicking() {
+            let old = self.0.replace(self.1);
+            assert_eq!(old, self.1 - 1);
+        }
+    }
+}
+
+pin_project! {
+#[project = StructPinnedProj]
+#[project_ref = StructPinnedProjRef]
+#[project_replace = StructPinnedProjReplace]
+struct StructPinned<'a> {
+    #[pin]
+    f1: D<'a>,
+    #[pin]
+    f2: D<'a>,
+}
+}
+
+pin_project! {
+#[project = StructUnpinnedProj]
+#[project_ref = StructUnpinnedProjRef]
+#[project_replace = StructUnpinnedProjReplace]
+struct StructUnpinned<'a> {
+    f1: D<'a>,
+    f2: D<'a>,
+}
+}
+
+pin_project! {
+#[project_replace = EnumProjReplace]
+enum Enum<'a> {
+    #[allow(dead_code)] // false positive that fixed in Rust 1.38
+    StructPinned {
+        #[pin]
+        f1: D<'a>,
+        #[pin]
+        f2: D<'a>,
+    },
+    #[allow(dead_code)] // false positive that fixed in Rust 1.38
+    StructUnpinned {
+        f1: D<'a>,
+        f2: D<'a>,
+    },
+}
+}
+
+#[test]
+fn struct_pinned() {
+    {
+        let c = Cell::new(0);
+        let _x = StructPinned { f1: D(&c, 1), f2: D(&c, 2) };
+    }
+    {
+        let c = Cell::new(0);
+        let mut x = StructPinned { f1: D(&c, 1), f2: D(&c, 2) };
+        let y = Pin::new(&mut x);
+        let _z = y.project_replace(StructPinned { f1: D(&c, 3), f2: D(&c, 4) });
+    }
+}
+
+#[test]
+fn struct_unpinned() {
+    {
+        let c = Cell::new(0);
+        let _x = StructUnpinned { f1: D(&c, 1), f2: D(&c, 2) };
+    }
+    {
+        let c = Cell::new(0);
+        let mut x = StructUnpinned { f1: D(&c, 1), f2: D(&c, 2) };
+        let y = Pin::new(&mut x);
+        let _z = y.project_replace(StructUnpinned { f1: D(&c, 3), f2: D(&c, 4) });
+    }
+}
+
+#[test]
+fn enum_struct() {
+    {
+        let c = Cell::new(0);
+        let _x = Enum::StructPinned { f1: D(&c, 1), f2: D(&c, 2) };
+    }
+    {
+        let c = Cell::new(0);
+        let mut x = Enum::StructPinned { f1: D(&c, 1), f2: D(&c, 2) };
+        let y = Pin::new(&mut x);
+        let _z = y.project_replace(Enum::StructPinned { f1: D(&c, 3), f2: D(&c, 4) });
+    }
+
+    {
+        let c = Cell::new(0);
+        let _x = Enum::StructUnpinned { f1: D(&c, 1), f2: D(&c, 2) };
+    }
+    {
+        let c = Cell::new(0);
+        let mut x = Enum::StructUnpinned { f1: D(&c, 1), f2: D(&c, 2) };
+        let y = Pin::new(&mut x);
+        let _z = y.project_replace(Enum::StructUnpinned { f1: D(&c, 3), f2: D(&c, 4) });
+    }
+}
+
+// https://github.com/rust-lang/rust/issues/47949
+// https://github.com/taiki-e/pin-project/pull/194#discussion_r419098111
+#[allow(clippy::many_single_char_names)]
+#[test]
+fn project_replace_panic() {
+    pin_project! {
+    #[project_replace = SProjReplace]
+    struct S<T, U> {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    }
+    }
+
+    struct D<'a>(&'a mut bool, bool);
+    impl Drop for D<'_> {
+        fn drop(&mut self) {
+            *self.0 = true;
+            if self.1 {
+                panic!();
+            }
+        }
+    }
+
+    let (mut a, mut b, mut c, mut d) = (false, false, false, false);
+    let res = panic::catch_unwind(panic::AssertUnwindSafe(|| {
+        let mut x = S { pinned: D(&mut a, true), unpinned: D(&mut b, false) };
+        let _y = Pin::new(&mut x)
+            .project_replace(S { pinned: D(&mut c, false), unpinned: D(&mut d, false) });
+        // Previous `x.pinned` was dropped and panicked when `project_replace` is
+        // called, so this is unreachable.
+        unreachable!();
+    }));
+    assert!(res.is_err());
+    assert!(a);
+    assert!(b);
+    assert!(c);
+    assert!(d);
+
+    let (mut a, mut b, mut c, mut d) = (false, false, false, false);
+    let res = panic::catch_unwind(panic::AssertUnwindSafe(|| {
+        let mut x = S { pinned: D(&mut a, false), unpinned: D(&mut b, true) };
+        {
+            let _y = Pin::new(&mut x)
+                .project_replace(S { pinned: D(&mut c, false), unpinned: D(&mut d, false) });
+            // `_y` (previous `x.unpinned`) live to the end of this scope, so
+            // this is not unreachable.
+            // unreachable!();
+        }
+        unreachable!();
+    }));
+    assert!(res.is_err());
+    assert!(a);
+    assert!(b);
+    assert!(c);
+    assert!(d);
+}
diff --git a/crates/pin-project-lite/tests/expand/default/enum.expanded.rs b/crates/pin-project-lite/tests/expand/default/enum.expanded.rs
new file mode 100644
index 0000000..456b8cc
--- /dev/null
+++ b/crates/pin-project-lite/tests/expand/default/enum.expanded.rs
@@ -0,0 +1,143 @@
+use pin_project_lite::pin_project;
+enum Enum<T, U> {
+    Struct { pinned: T, unpinned: U },
+    Unit,
+}
+#[doc(hidden)]
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::ref_option_ref)]
+#[allow(clippy::type_repetition_in_bounds)]
+enum EnumProj<'__pin, T, U>
+where
+    Enum<T, U>: '__pin,
+{
+    Struct {
+        pinned: ::pin_project_lite::__private::Pin<&'__pin mut (T)>,
+        unpinned: &'__pin mut (U),
+    },
+    Unit,
+}
+#[doc(hidden)]
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::ref_option_ref)]
+#[allow(clippy::type_repetition_in_bounds)]
+enum EnumProjRef<'__pin, T, U>
+where
+    Enum<T, U>: '__pin,
+{
+    Struct {
+        pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>,
+        unpinned: &'__pin (U),
+    },
+    Unit,
+}
+#[doc(hidden)]
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+enum EnumProjReplace<T, U> {
+    Struct { pinned: ::pin_project_lite::__private::PhantomData<T>, unpinned: U },
+    Unit,
+}
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    impl<T, U> Enum<T, U> {
+        #[doc(hidden)]
+        #[inline]
+        fn project<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin mut Self>,
+        ) -> EnumProj<'__pin, T, U> {
+            unsafe {
+                match self.get_unchecked_mut() {
+                    Self::Struct { pinned, unpinned } => {
+                        EnumProj::Struct {
+                            pinned: ::pin_project_lite::__private::Pin::new_unchecked(
+                                pinned,
+                            ),
+                            unpinned: unpinned,
+                        }
+                    }
+                    Self::Unit => EnumProj::Unit,
+                }
+            }
+        }
+        #[doc(hidden)]
+        #[inline]
+        fn project_ref<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin Self>,
+        ) -> EnumProjRef<'__pin, T, U> {
+            unsafe {
+                match self.get_ref() {
+                    Self::Struct { pinned, unpinned } => {
+                        EnumProjRef::Struct {
+                            pinned: ::pin_project_lite::__private::Pin::new_unchecked(
+                                pinned,
+                            ),
+                            unpinned: unpinned,
+                        }
+                    }
+                    Self::Unit => EnumProjRef::Unit,
+                }
+            }
+        }
+        #[doc(hidden)]
+        #[inline]
+        fn project_replace(
+            self: ::pin_project_lite::__private::Pin<&mut Self>,
+            replacement: Self,
+        ) -> EnumProjReplace<T, U> {
+            unsafe {
+                let __self_ptr: *mut Self = self.get_unchecked_mut();
+                let __guard = ::pin_project_lite::__private::UnsafeOverwriteGuard::new(
+                    __self_ptr,
+                    replacement,
+                );
+                match &mut *__self_ptr {
+                    Self::Struct { pinned, unpinned } => {
+                        let result = EnumProjReplace::Struct {
+                            pinned: ::pin_project_lite::__private::PhantomData,
+                            unpinned: ::pin_project_lite::__private::ptr::read(unpinned),
+                        };
+                        {
+                            (
+                                ::pin_project_lite::__private::UnsafeDropInPlaceGuard::new(
+                                    pinned,
+                                ),
+                                (),
+                            );
+                        }
+                        result
+                    }
+                    Self::Unit => EnumProjReplace::Unit,
+                }
+            }
+        }
+    }
+    #[allow(non_snake_case)]
+    struct __Origin<'__pin, T, U> {
+        __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>,
+        Struct: (T, ::pin_project_lite::__private::AlwaysUnpin<U>),
+        Unit: (),
+    }
+    impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Enum<T, U>
+    where
+        __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin,
+    {}
+    trait MustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {}
+    impl<T, U> MustNotImplDrop for Enum<T, U> {}
+};
+fn main() {}
diff --git a/crates/pin-project-lite/tests/expand/default/enum.rs b/crates/pin-project-lite/tests/expand/default/enum.rs
new file mode 100644
index 0000000..90d6860
--- /dev/null
+++ b/crates/pin-project-lite/tests/expand/default/enum.rs
@@ -0,0 +1,17 @@
+use pin_project_lite::pin_project;
+
+pin_project! {
+    #[project = EnumProj]
+    #[project_ref = EnumProjRef]
+    #[project_replace = EnumProjReplace]
+    enum Enum<T, U> {
+        Struct {
+            #[pin]
+            pinned: T,
+            unpinned: U,
+        },
+        Unit,
+    }
+}
+
+fn main() {}
diff --git a/crates/pin-project-lite/tests/expand/default/struct.expanded.rs b/crates/pin-project-lite/tests/expand/default/struct.expanded.rs
new file mode 100644
index 0000000..a9792e1
--- /dev/null
+++ b/crates/pin-project-lite/tests/expand/default/struct.expanded.rs
@@ -0,0 +1,90 @@
+use pin_project_lite::pin_project;
+struct Struct<T, U> {
+    pinned: T,
+    unpinned: U,
+}
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[doc(hidden)]
+    #[allow(dead_code)]
+    #[allow(single_use_lifetimes)]
+    #[allow(clippy::unknown_clippy_lints)]
+    #[allow(clippy::mut_mut)]
+    #[allow(clippy::redundant_pub_crate)]
+    #[allow(clippy::ref_option_ref)]
+    #[allow(clippy::type_repetition_in_bounds)]
+    struct Projection<'__pin, T, U>
+    where
+        Struct<T, U>: '__pin,
+    {
+        pinned: ::pin_project_lite::__private::Pin<&'__pin mut (T)>,
+        unpinned: &'__pin mut (U),
+    }
+    #[doc(hidden)]
+    #[allow(dead_code)]
+    #[allow(single_use_lifetimes)]
+    #[allow(clippy::unknown_clippy_lints)]
+    #[allow(clippy::mut_mut)]
+    #[allow(clippy::redundant_pub_crate)]
+    #[allow(clippy::ref_option_ref)]
+    #[allow(clippy::type_repetition_in_bounds)]
+    struct ProjectionRef<'__pin, T, U>
+    where
+        Struct<T, U>: '__pin,
+    {
+        pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>,
+        unpinned: &'__pin (U),
+    }
+    impl<T, U> Struct<T, U> {
+        #[doc(hidden)]
+        #[inline]
+        fn project<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin mut Self>,
+        ) -> Projection<'__pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_unchecked_mut();
+                Projection {
+                    pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
+                    unpinned: unpinned,
+                }
+            }
+        }
+        #[doc(hidden)]
+        #[inline]
+        fn project_ref<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin Self>,
+        ) -> ProjectionRef<'__pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_ref();
+                ProjectionRef {
+                    pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
+                    unpinned: unpinned,
+                }
+            }
+        }
+    }
+    #[allow(non_snake_case)]
+    struct __Origin<'__pin, T, U> {
+        __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>,
+        pinned: T,
+        unpinned: ::pin_project_lite::__private::AlwaysUnpin<U>,
+    }
+    impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Struct<T, U>
+    where
+        __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin,
+    {}
+    trait MustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {}
+    impl<T, U> MustNotImplDrop for Struct<T, U> {}
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+        let _ = &this.pinned;
+        let _ = &this.unpinned;
+    }
+};
+fn main() {}
diff --git a/crates/pin-project-lite/tests/expand/default/struct.rs b/crates/pin-project-lite/tests/expand/default/struct.rs
new file mode 100644
index 0000000..e5447c7
--- /dev/null
+++ b/crates/pin-project-lite/tests/expand/default/struct.rs
@@ -0,0 +1,11 @@
+use pin_project_lite::pin_project;
+
+pin_project! {
+    struct Struct<T, U> {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    }
+}
+
+fn main() {}
diff --git a/crates/pin-project-lite/tests/expand/multifields/enum.expanded.rs b/crates/pin-project-lite/tests/expand/multifields/enum.expanded.rs
new file mode 100644
index 0000000..f722a14
--- /dev/null
+++ b/crates/pin-project-lite/tests/expand/multifields/enum.expanded.rs
@@ -0,0 +1,89 @@
+use pin_project_lite::pin_project;
+enum Enum<T, U> {
+    Struct { pinned1: T, pinned2: T, unpinned1: U, unpinned2: U },
+    Unit,
+}
+#[doc(hidden)]
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+enum EnumProjReplace<T, U> {
+    Struct {
+        pinned1: ::pin_project_lite::__private::PhantomData<T>,
+        pinned2: ::pin_project_lite::__private::PhantomData<T>,
+        unpinned1: U,
+        unpinned2: U,
+    },
+    Unit,
+}
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    impl<T, U> Enum<T, U> {
+        #[doc(hidden)]
+        #[inline]
+        fn project_replace(
+            self: ::pin_project_lite::__private::Pin<&mut Self>,
+            replacement: Self,
+        ) -> EnumProjReplace<T, U> {
+            unsafe {
+                let __self_ptr: *mut Self = self.get_unchecked_mut();
+                let __guard = ::pin_project_lite::__private::UnsafeOverwriteGuard::new(
+                    __self_ptr,
+                    replacement,
+                );
+                match &mut *__self_ptr {
+                    Self::Struct { pinned1, pinned2, unpinned1, unpinned2 } => {
+                        let result = EnumProjReplace::Struct {
+                            pinned1: ::pin_project_lite::__private::PhantomData,
+                            pinned2: ::pin_project_lite::__private::PhantomData,
+                            unpinned1: ::pin_project_lite::__private::ptr::read(
+                                unpinned1,
+                            ),
+                            unpinned2: ::pin_project_lite::__private::ptr::read(
+                                unpinned2,
+                            ),
+                        };
+                        {
+                            (
+                                ::pin_project_lite::__private::UnsafeDropInPlaceGuard::new(
+                                    pinned1,
+                                ),
+                                ::pin_project_lite::__private::UnsafeDropInPlaceGuard::new(
+                                    pinned2,
+                                ),
+                                (),
+                                (),
+                            );
+                        }
+                        result
+                    }
+                    Self::Unit => EnumProjReplace::Unit,
+                }
+            }
+        }
+    }
+    #[allow(non_snake_case)]
+    struct __Origin<'__pin, T, U> {
+        __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>,
+        Struct: (
+            T,
+            T,
+            ::pin_project_lite::__private::AlwaysUnpin<U>,
+            ::pin_project_lite::__private::AlwaysUnpin<U>,
+        ),
+        Unit: (),
+    }
+    impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Enum<T, U>
+    where
+        __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin,
+    {}
+    trait MustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {}
+    impl<T, U> MustNotImplDrop for Enum<T, U> {}
+};
+fn main() {}
diff --git a/crates/pin-project-lite/tests/expand/multifields/enum.rs b/crates/pin-project-lite/tests/expand/multifields/enum.rs
new file mode 100644
index 0000000..c713362
--- /dev/null
+++ b/crates/pin-project-lite/tests/expand/multifields/enum.rs
@@ -0,0 +1,18 @@
+use pin_project_lite::pin_project;
+
+pin_project! {
+#[project_replace = EnumProjReplace]
+enum Enum<T, U> {
+    Struct {
+        #[pin]
+        pinned1: T,
+        #[pin]
+        pinned2: T,
+        unpinned1: U,
+        unpinned2: U,
+    },
+    Unit,
+}
+}
+
+fn main() {}
diff --git a/crates/pin-project-lite/tests/expand/multifields/struct.expanded.rs b/crates/pin-project-lite/tests/expand/multifields/struct.expanded.rs
new file mode 100644
index 0000000..83ebefe
--- /dev/null
+++ b/crates/pin-project-lite/tests/expand/multifields/struct.expanded.rs
@@ -0,0 +1,151 @@
+use pin_project_lite::pin_project;
+struct Struct<T, U> {
+    pinned1: T,
+    pinned2: T,
+    unpinned1: U,
+    unpinned2: U,
+}
+#[doc(hidden)]
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+struct StructProjReplace<T, U> {
+    pinned1: ::pin_project_lite::__private::PhantomData<T>,
+    pinned2: ::pin_project_lite::__private::PhantomData<T>,
+    unpinned1: U,
+    unpinned2: U,
+}
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[doc(hidden)]
+    #[allow(dead_code)]
+    #[allow(single_use_lifetimes)]
+    #[allow(clippy::unknown_clippy_lints)]
+    #[allow(clippy::mut_mut)]
+    #[allow(clippy::redundant_pub_crate)]
+    #[allow(clippy::ref_option_ref)]
+    #[allow(clippy::type_repetition_in_bounds)]
+    struct Projection<'__pin, T, U>
+    where
+        Struct<T, U>: '__pin,
+    {
+        pinned1: ::pin_project_lite::__private::Pin<&'__pin mut (T)>,
+        pinned2: ::pin_project_lite::__private::Pin<&'__pin mut (T)>,
+        unpinned1: &'__pin mut (U),
+        unpinned2: &'__pin mut (U),
+    }
+    #[doc(hidden)]
+    #[allow(dead_code)]
+    #[allow(single_use_lifetimes)]
+    #[allow(clippy::unknown_clippy_lints)]
+    #[allow(clippy::mut_mut)]
+    #[allow(clippy::redundant_pub_crate)]
+    #[allow(clippy::ref_option_ref)]
+    #[allow(clippy::type_repetition_in_bounds)]
+    struct ProjectionRef<'__pin, T, U>
+    where
+        Struct<T, U>: '__pin,
+    {
+        pinned1: ::pin_project_lite::__private::Pin<&'__pin (T)>,
+        pinned2: ::pin_project_lite::__private::Pin<&'__pin (T)>,
+        unpinned1: &'__pin (U),
+        unpinned2: &'__pin (U),
+    }
+    impl<T, U> Struct<T, U> {
+        #[doc(hidden)]
+        #[inline]
+        fn project<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin mut Self>,
+        ) -> Projection<'__pin, T, U> {
+            unsafe {
+                let Self { pinned1, pinned2, unpinned1, unpinned2 } = self
+                    .get_unchecked_mut();
+                Projection {
+                    pinned1: ::pin_project_lite::__private::Pin::new_unchecked(pinned1),
+                    pinned2: ::pin_project_lite::__private::Pin::new_unchecked(pinned2),
+                    unpinned1: unpinned1,
+                    unpinned2: unpinned2,
+                }
+            }
+        }
+        #[doc(hidden)]
+        #[inline]
+        fn project_ref<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin Self>,
+        ) -> ProjectionRef<'__pin, T, U> {
+            unsafe {
+                let Self { pinned1, pinned2, unpinned1, unpinned2 } = self.get_ref();
+                ProjectionRef {
+                    pinned1: ::pin_project_lite::__private::Pin::new_unchecked(pinned1),
+                    pinned2: ::pin_project_lite::__private::Pin::new_unchecked(pinned2),
+                    unpinned1: unpinned1,
+                    unpinned2: unpinned2,
+                }
+            }
+        }
+        #[doc(hidden)]
+        #[inline]
+        fn project_replace(
+            self: ::pin_project_lite::__private::Pin<&mut Self>,
+            replacement: Self,
+        ) -> StructProjReplace<T, U> {
+            unsafe {
+                let __self_ptr: *mut Self = self.get_unchecked_mut();
+                let __guard = ::pin_project_lite::__private::UnsafeOverwriteGuard::new(
+                    __self_ptr,
+                    replacement,
+                );
+                let Self { pinned1, pinned2, unpinned1, unpinned2 } = &mut *__self_ptr;
+                let result = StructProjReplace {
+                    pinned1: ::pin_project_lite::__private::PhantomData,
+                    pinned2: ::pin_project_lite::__private::PhantomData,
+                    unpinned1: ::pin_project_lite::__private::ptr::read(unpinned1),
+                    unpinned2: ::pin_project_lite::__private::ptr::read(unpinned2),
+                };
+                {
+                    (
+                        ::pin_project_lite::__private::UnsafeDropInPlaceGuard::new(
+                            pinned1,
+                        ),
+                        ::pin_project_lite::__private::UnsafeDropInPlaceGuard::new(
+                            pinned2,
+                        ),
+                        (),
+                        (),
+                    );
+                }
+                result
+            }
+        }
+    }
+    #[allow(non_snake_case)]
+    struct __Origin<'__pin, T, U> {
+        __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>,
+        pinned1: T,
+        pinned2: T,
+        unpinned1: ::pin_project_lite::__private::AlwaysUnpin<U>,
+        unpinned2: ::pin_project_lite::__private::AlwaysUnpin<U>,
+    }
+    impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Struct<T, U>
+    where
+        __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin,
+    {}
+    trait MustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {}
+    impl<T, U> MustNotImplDrop for Struct<T, U> {}
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+        let _ = &this.pinned1;
+        let _ = &this.pinned2;
+        let _ = &this.unpinned1;
+        let _ = &this.unpinned2;
+    }
+};
+fn main() {}
diff --git a/crates/pin-project-lite/tests/expand/multifields/struct.rs b/crates/pin-project-lite/tests/expand/multifields/struct.rs
new file mode 100644
index 0000000..a1d45d1
--- /dev/null
+++ b/crates/pin-project-lite/tests/expand/multifields/struct.rs
@@ -0,0 +1,15 @@
+use pin_project_lite::pin_project;
+
+pin_project! {
+#[project_replace = StructProjReplace]
+struct Struct<T, U> {
+    #[pin]
+    pinned1: T,
+    #[pin]
+    pinned2: T,
+    unpinned1: U,
+    unpinned2: U,
+}
+}
+
+fn main() {}
diff --git a/crates/pin-project-lite/tests/expand/naming/enum-all.expanded.rs b/crates/pin-project-lite/tests/expand/naming/enum-all.expanded.rs
new file mode 100644
index 0000000..456b8cc
--- /dev/null
+++ b/crates/pin-project-lite/tests/expand/naming/enum-all.expanded.rs
@@ -0,0 +1,143 @@
+use pin_project_lite::pin_project;
+enum Enum<T, U> {
+    Struct { pinned: T, unpinned: U },
+    Unit,
+}
+#[doc(hidden)]
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::ref_option_ref)]
+#[allow(clippy::type_repetition_in_bounds)]
+enum EnumProj<'__pin, T, U>
+where
+    Enum<T, U>: '__pin,
+{
+    Struct {
+        pinned: ::pin_project_lite::__private::Pin<&'__pin mut (T)>,
+        unpinned: &'__pin mut (U),
+    },
+    Unit,
+}
+#[doc(hidden)]
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::ref_option_ref)]
+#[allow(clippy::type_repetition_in_bounds)]
+enum EnumProjRef<'__pin, T, U>
+where
+    Enum<T, U>: '__pin,
+{
+    Struct {
+        pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>,
+        unpinned: &'__pin (U),
+    },
+    Unit,
+}
+#[doc(hidden)]
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+enum EnumProjReplace<T, U> {
+    Struct { pinned: ::pin_project_lite::__private::PhantomData<T>, unpinned: U },
+    Unit,
+}
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    impl<T, U> Enum<T, U> {
+        #[doc(hidden)]
+        #[inline]
+        fn project<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin mut Self>,
+        ) -> EnumProj<'__pin, T, U> {
+            unsafe {
+                match self.get_unchecked_mut() {
+                    Self::Struct { pinned, unpinned } => {
+                        EnumProj::Struct {
+                            pinned: ::pin_project_lite::__private::Pin::new_unchecked(
+                                pinned,
+                            ),
+                            unpinned: unpinned,
+                        }
+                    }
+                    Self::Unit => EnumProj::Unit,
+                }
+            }
+        }
+        #[doc(hidden)]
+        #[inline]
+        fn project_ref<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin Self>,
+        ) -> EnumProjRef<'__pin, T, U> {
+            unsafe {
+                match self.get_ref() {
+                    Self::Struct { pinned, unpinned } => {
+                        EnumProjRef::Struct {
+                            pinned: ::pin_project_lite::__private::Pin::new_unchecked(
+                                pinned,
+                            ),
+                            unpinned: unpinned,
+                        }
+                    }
+                    Self::Unit => EnumProjRef::Unit,
+                }
+            }
+        }
+        #[doc(hidden)]
+        #[inline]
+        fn project_replace(
+            self: ::pin_project_lite::__private::Pin<&mut Self>,
+            replacement: Self,
+        ) -> EnumProjReplace<T, U> {
+            unsafe {
+                let __self_ptr: *mut Self = self.get_unchecked_mut();
+                let __guard = ::pin_project_lite::__private::UnsafeOverwriteGuard::new(
+                    __self_ptr,
+                    replacement,
+                );
+                match &mut *__self_ptr {
+                    Self::Struct { pinned, unpinned } => {
+                        let result = EnumProjReplace::Struct {
+                            pinned: ::pin_project_lite::__private::PhantomData,
+                            unpinned: ::pin_project_lite::__private::ptr::read(unpinned),
+                        };
+                        {
+                            (
+                                ::pin_project_lite::__private::UnsafeDropInPlaceGuard::new(
+                                    pinned,
+                                ),
+                                (),
+                            );
+                        }
+                        result
+                    }
+                    Self::Unit => EnumProjReplace::Unit,
+                }
+            }
+        }
+    }
+    #[allow(non_snake_case)]
+    struct __Origin<'__pin, T, U> {
+        __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>,
+        Struct: (T, ::pin_project_lite::__private::AlwaysUnpin<U>),
+        Unit: (),
+    }
+    impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Enum<T, U>
+    where
+        __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin,
+    {}
+    trait MustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {}
+    impl<T, U> MustNotImplDrop for Enum<T, U> {}
+};
+fn main() {}
diff --git a/crates/pin-project-lite/tests/expand/naming/enum-all.rs b/crates/pin-project-lite/tests/expand/naming/enum-all.rs
new file mode 100644
index 0000000..90d6860
--- /dev/null
+++ b/crates/pin-project-lite/tests/expand/naming/enum-all.rs
@@ -0,0 +1,17 @@
+use pin_project_lite::pin_project;
+
+pin_project! {
+    #[project = EnumProj]
+    #[project_ref = EnumProjRef]
+    #[project_replace = EnumProjReplace]
+    enum Enum<T, U> {
+        Struct {
+            #[pin]
+            pinned: T,
+            unpinned: U,
+        },
+        Unit,
+    }
+}
+
+fn main() {}
diff --git a/crates/pin-project-lite/tests/expand/naming/enum-mut.expanded.rs b/crates/pin-project-lite/tests/expand/naming/enum-mut.expanded.rs
new file mode 100644
index 0000000..342588c
--- /dev/null
+++ b/crates/pin-project-lite/tests/expand/naming/enum-mut.expanded.rs
@@ -0,0 +1,64 @@
+use pin_project_lite::pin_project;
+enum Enum<T, U> {
+    Struct { pinned: T, unpinned: U },
+    Unit,
+}
+#[doc(hidden)]
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::ref_option_ref)]
+#[allow(clippy::type_repetition_in_bounds)]
+enum EnumProj<'__pin, T, U>
+where
+    Enum<T, U>: '__pin,
+{
+    Struct {
+        pinned: ::pin_project_lite::__private::Pin<&'__pin mut (T)>,
+        unpinned: &'__pin mut (U),
+    },
+    Unit,
+}
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    impl<T, U> Enum<T, U> {
+        #[doc(hidden)]
+        #[inline]
+        fn project<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin mut Self>,
+        ) -> EnumProj<'__pin, T, U> {
+            unsafe {
+                match self.get_unchecked_mut() {
+                    Self::Struct { pinned, unpinned } => {
+                        EnumProj::Struct {
+                            pinned: ::pin_project_lite::__private::Pin::new_unchecked(
+                                pinned,
+                            ),
+                            unpinned: unpinned,
+                        }
+                    }
+                    Self::Unit => EnumProj::Unit,
+                }
+            }
+        }
+    }
+    #[allow(non_snake_case)]
+    struct __Origin<'__pin, T, U> {
+        __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>,
+        Struct: (T, ::pin_project_lite::__private::AlwaysUnpin<U>),
+        Unit: (),
+    }
+    impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Enum<T, U>
+    where
+        __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin,
+    {}
+    trait MustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {}
+    impl<T, U> MustNotImplDrop for Enum<T, U> {}
+};
+fn main() {}
diff --git a/crates/pin-project-lite/tests/expand/naming/enum-mut.rs b/crates/pin-project-lite/tests/expand/naming/enum-mut.rs
new file mode 100644
index 0000000..69beecd
--- /dev/null
+++ b/crates/pin-project-lite/tests/expand/naming/enum-mut.rs
@@ -0,0 +1,15 @@
+use pin_project_lite::pin_project;
+
+pin_project! {
+    #[project = EnumProj]
+    enum Enum<T, U> {
+        Struct {
+            #[pin]
+            pinned: T,
+            unpinned: U,
+        },
+        Unit,
+    }
+}
+
+fn main() {}
diff --git a/crates/pin-project-lite/tests/expand/naming/enum-none.expanded.rs b/crates/pin-project-lite/tests/expand/naming/enum-none.expanded.rs
new file mode 100644
index 0000000..fc3b3dc
--- /dev/null
+++ b/crates/pin-project-lite/tests/expand/naming/enum-none.expanded.rs
@@ -0,0 +1,26 @@
+use pin_project_lite::pin_project;
+enum Enum<T, U> {
+    Struct { pinned: T, unpinned: U },
+    Unit,
+}
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    impl<T, U> Enum<T, U> {}
+    #[allow(non_snake_case)]
+    struct __Origin<'__pin, T, U> {
+        __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>,
+        Struct: (T, ::pin_project_lite::__private::AlwaysUnpin<U>),
+        Unit: (),
+    }
+    impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Enum<T, U>
+    where
+        __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin,
+    {}
+    trait MustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {}
+    impl<T, U> MustNotImplDrop for Enum<T, U> {}
+};
+fn main() {}
diff --git a/crates/pin-project-lite/tests/expand/naming/enum-none.rs b/crates/pin-project-lite/tests/expand/naming/enum-none.rs
new file mode 100644
index 0000000..b2e3f9d
--- /dev/null
+++ b/crates/pin-project-lite/tests/expand/naming/enum-none.rs
@@ -0,0 +1,14 @@
+use pin_project_lite::pin_project;
+
+pin_project! {
+    enum Enum<T, U> {
+        Struct {
+            #[pin]
+            pinned: T,
+            unpinned: U,
+        },
+        Unit,
+    }
+}
+
+fn main() {}
diff --git a/crates/pin-project-lite/tests/expand/naming/enum-ref.expanded.rs b/crates/pin-project-lite/tests/expand/naming/enum-ref.expanded.rs
new file mode 100644
index 0000000..5270e12
--- /dev/null
+++ b/crates/pin-project-lite/tests/expand/naming/enum-ref.expanded.rs
@@ -0,0 +1,64 @@
+use pin_project_lite::pin_project;
+enum Enum<T, U> {
+    Struct { pinned: T, unpinned: U },
+    Unit,
+}
+#[doc(hidden)]
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::ref_option_ref)]
+#[allow(clippy::type_repetition_in_bounds)]
+enum EnumProjRef<'__pin, T, U>
+where
+    Enum<T, U>: '__pin,
+{
+    Struct {
+        pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>,
+        unpinned: &'__pin (U),
+    },
+    Unit,
+}
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    impl<T, U> Enum<T, U> {
+        #[doc(hidden)]
+        #[inline]
+        fn project_ref<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin Self>,
+        ) -> EnumProjRef<'__pin, T, U> {
+            unsafe {
+                match self.get_ref() {
+                    Self::Struct { pinned, unpinned } => {
+                        EnumProjRef::Struct {
+                            pinned: ::pin_project_lite::__private::Pin::new_unchecked(
+                                pinned,
+                            ),
+                            unpinned: unpinned,
+                        }
+                    }
+                    Self::Unit => EnumProjRef::Unit,
+                }
+            }
+        }
+    }
+    #[allow(non_snake_case)]
+    struct __Origin<'__pin, T, U> {
+        __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>,
+        Struct: (T, ::pin_project_lite::__private::AlwaysUnpin<U>),
+        Unit: (),
+    }
+    impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Enum<T, U>
+    where
+        __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin,
+    {}
+    trait MustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {}
+    impl<T, U> MustNotImplDrop for Enum<T, U> {}
+};
+fn main() {}
diff --git a/crates/pin-project-lite/tests/expand/naming/enum-ref.rs b/crates/pin-project-lite/tests/expand/naming/enum-ref.rs
new file mode 100644
index 0000000..480d592
--- /dev/null
+++ b/crates/pin-project-lite/tests/expand/naming/enum-ref.rs
@@ -0,0 +1,15 @@
+use pin_project_lite::pin_project;
+
+pin_project! {
+    #[project_ref = EnumProjRef]
+    enum Enum<T, U> {
+        Struct {
+            #[pin]
+            pinned: T,
+            unpinned: U,
+        },
+        Unit,
+    }
+}
+
+fn main() {}
diff --git a/crates/pin-project-lite/tests/expand/naming/struct-all.expanded.rs b/crates/pin-project-lite/tests/expand/naming/struct-all.expanded.rs
new file mode 100644
index 0000000..13c4079
--- /dev/null
+++ b/crates/pin-project-lite/tests/expand/naming/struct-all.expanded.rs
@@ -0,0 +1,128 @@
+use pin_project_lite::pin_project;
+struct Struct<T, U> {
+    pinned: T,
+    unpinned: U,
+}
+#[doc(hidden)]
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::ref_option_ref)]
+#[allow(clippy::type_repetition_in_bounds)]
+struct StructProj<'__pin, T, U>
+where
+    Struct<T, U>: '__pin,
+{
+    pinned: ::pin_project_lite::__private::Pin<&'__pin mut (T)>,
+    unpinned: &'__pin mut (U),
+}
+#[doc(hidden)]
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::ref_option_ref)]
+#[allow(clippy::type_repetition_in_bounds)]
+struct StructProjRef<'__pin, T, U>
+where
+    Struct<T, U>: '__pin,
+{
+    pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>,
+    unpinned: &'__pin (U),
+}
+#[doc(hidden)]
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+struct StructProjReplace<T, U> {
+    pinned: ::pin_project_lite::__private::PhantomData<T>,
+    unpinned: U,
+}
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    impl<T, U> Struct<T, U> {
+        #[doc(hidden)]
+        #[inline]
+        fn project<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin mut Self>,
+        ) -> StructProj<'__pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_unchecked_mut();
+                StructProj {
+                    pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
+                    unpinned: unpinned,
+                }
+            }
+        }
+        #[doc(hidden)]
+        #[inline]
+        fn project_ref<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin Self>,
+        ) -> StructProjRef<'__pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_ref();
+                StructProjRef {
+                    pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
+                    unpinned: unpinned,
+                }
+            }
+        }
+        #[doc(hidden)]
+        #[inline]
+        fn project_replace(
+            self: ::pin_project_lite::__private::Pin<&mut Self>,
+            replacement: Self,
+        ) -> StructProjReplace<T, U> {
+            unsafe {
+                let __self_ptr: *mut Self = self.get_unchecked_mut();
+                let __guard = ::pin_project_lite::__private::UnsafeOverwriteGuard::new(
+                    __self_ptr,
+                    replacement,
+                );
+                let Self { pinned, unpinned } = &mut *__self_ptr;
+                let result = StructProjReplace {
+                    pinned: ::pin_project_lite::__private::PhantomData,
+                    unpinned: ::pin_project_lite::__private::ptr::read(unpinned),
+                };
+                {
+                    (
+                        ::pin_project_lite::__private::UnsafeDropInPlaceGuard::new(
+                            pinned,
+                        ),
+                        (),
+                    );
+                }
+                result
+            }
+        }
+    }
+    #[allow(non_snake_case)]
+    struct __Origin<'__pin, T, U> {
+        __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>,
+        pinned: T,
+        unpinned: ::pin_project_lite::__private::AlwaysUnpin<U>,
+    }
+    impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Struct<T, U>
+    where
+        __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin,
+    {}
+    trait MustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {}
+    impl<T, U> MustNotImplDrop for Struct<T, U> {}
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+        let _ = &this.pinned;
+        let _ = &this.unpinned;
+    }
+};
+fn main() {}
diff --git a/crates/pin-project-lite/tests/expand/naming/struct-all.rs b/crates/pin-project-lite/tests/expand/naming/struct-all.rs
new file mode 100644
index 0000000..cb08753
--- /dev/null
+++ b/crates/pin-project-lite/tests/expand/naming/struct-all.rs
@@ -0,0 +1,14 @@
+use pin_project_lite::pin_project;
+
+pin_project! {
+    #[project = StructProj]
+    #[project_ref = StructProjRef]
+    #[project_replace = StructProjReplace]
+    struct Struct<T, U> {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    }
+}
+
+fn main() {}
diff --git a/crates/pin-project-lite/tests/expand/naming/struct-mut.expanded.rs b/crates/pin-project-lite/tests/expand/naming/struct-mut.expanded.rs
new file mode 100644
index 0000000..9b6dae8
--- /dev/null
+++ b/crates/pin-project-lite/tests/expand/naming/struct-mut.expanded.rs
@@ -0,0 +1,90 @@
+use pin_project_lite::pin_project;
+struct Struct<T, U> {
+    pinned: T,
+    unpinned: U,
+}
+#[doc(hidden)]
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::ref_option_ref)]
+#[allow(clippy::type_repetition_in_bounds)]
+struct StructProj<'__pin, T, U>
+where
+    Struct<T, U>: '__pin,
+{
+    pinned: ::pin_project_lite::__private::Pin<&'__pin mut (T)>,
+    unpinned: &'__pin mut (U),
+}
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[doc(hidden)]
+    #[allow(dead_code)]
+    #[allow(single_use_lifetimes)]
+    #[allow(clippy::unknown_clippy_lints)]
+    #[allow(clippy::mut_mut)]
+    #[allow(clippy::redundant_pub_crate)]
+    #[allow(clippy::ref_option_ref)]
+    #[allow(clippy::type_repetition_in_bounds)]
+    struct ProjectionRef<'__pin, T, U>
+    where
+        Struct<T, U>: '__pin,
+    {
+        pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>,
+        unpinned: &'__pin (U),
+    }
+    impl<T, U> Struct<T, U> {
+        #[doc(hidden)]
+        #[inline]
+        fn project<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin mut Self>,
+        ) -> StructProj<'__pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_unchecked_mut();
+                StructProj {
+                    pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
+                    unpinned: unpinned,
+                }
+            }
+        }
+        #[doc(hidden)]
+        #[inline]
+        fn project_ref<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin Self>,
+        ) -> ProjectionRef<'__pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_ref();
+                ProjectionRef {
+                    pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
+                    unpinned: unpinned,
+                }
+            }
+        }
+    }
+    #[allow(non_snake_case)]
+    struct __Origin<'__pin, T, U> {
+        __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>,
+        pinned: T,
+        unpinned: ::pin_project_lite::__private::AlwaysUnpin<U>,
+    }
+    impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Struct<T, U>
+    where
+        __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin,
+    {}
+    trait MustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {}
+    impl<T, U> MustNotImplDrop for Struct<T, U> {}
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+        let _ = &this.pinned;
+        let _ = &this.unpinned;
+    }
+};
+fn main() {}
diff --git a/crates/pin-project-lite/tests/expand/naming/struct-mut.rs b/crates/pin-project-lite/tests/expand/naming/struct-mut.rs
new file mode 100644
index 0000000..59db445
--- /dev/null
+++ b/crates/pin-project-lite/tests/expand/naming/struct-mut.rs
@@ -0,0 +1,12 @@
+use pin_project_lite::pin_project;
+
+pin_project! {
+    #[project = StructProj]
+    struct Struct<T, U> {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    }
+}
+
+fn main() {}
diff --git a/crates/pin-project-lite/tests/expand/naming/struct-none.expanded.rs b/crates/pin-project-lite/tests/expand/naming/struct-none.expanded.rs
new file mode 100644
index 0000000..a9792e1
--- /dev/null
+++ b/crates/pin-project-lite/tests/expand/naming/struct-none.expanded.rs
@@ -0,0 +1,90 @@
+use pin_project_lite::pin_project;
+struct Struct<T, U> {
+    pinned: T,
+    unpinned: U,
+}
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[doc(hidden)]
+    #[allow(dead_code)]
+    #[allow(single_use_lifetimes)]
+    #[allow(clippy::unknown_clippy_lints)]
+    #[allow(clippy::mut_mut)]
+    #[allow(clippy::redundant_pub_crate)]
+    #[allow(clippy::ref_option_ref)]
+    #[allow(clippy::type_repetition_in_bounds)]
+    struct Projection<'__pin, T, U>
+    where
+        Struct<T, U>: '__pin,
+    {
+        pinned: ::pin_project_lite::__private::Pin<&'__pin mut (T)>,
+        unpinned: &'__pin mut (U),
+    }
+    #[doc(hidden)]
+    #[allow(dead_code)]
+    #[allow(single_use_lifetimes)]
+    #[allow(clippy::unknown_clippy_lints)]
+    #[allow(clippy::mut_mut)]
+    #[allow(clippy::redundant_pub_crate)]
+    #[allow(clippy::ref_option_ref)]
+    #[allow(clippy::type_repetition_in_bounds)]
+    struct ProjectionRef<'__pin, T, U>
+    where
+        Struct<T, U>: '__pin,
+    {
+        pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>,
+        unpinned: &'__pin (U),
+    }
+    impl<T, U> Struct<T, U> {
+        #[doc(hidden)]
+        #[inline]
+        fn project<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin mut Self>,
+        ) -> Projection<'__pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_unchecked_mut();
+                Projection {
+                    pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
+                    unpinned: unpinned,
+                }
+            }
+        }
+        #[doc(hidden)]
+        #[inline]
+        fn project_ref<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin Self>,
+        ) -> ProjectionRef<'__pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_ref();
+                ProjectionRef {
+                    pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
+                    unpinned: unpinned,
+                }
+            }
+        }
+    }
+    #[allow(non_snake_case)]
+    struct __Origin<'__pin, T, U> {
+        __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>,
+        pinned: T,
+        unpinned: ::pin_project_lite::__private::AlwaysUnpin<U>,
+    }
+    impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Struct<T, U>
+    where
+        __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin,
+    {}
+    trait MustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {}
+    impl<T, U> MustNotImplDrop for Struct<T, U> {}
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+        let _ = &this.pinned;
+        let _ = &this.unpinned;
+    }
+};
+fn main() {}
diff --git a/crates/pin-project-lite/tests/expand/naming/struct-none.rs b/crates/pin-project-lite/tests/expand/naming/struct-none.rs
new file mode 100644
index 0000000..e5447c7
--- /dev/null
+++ b/crates/pin-project-lite/tests/expand/naming/struct-none.rs
@@ -0,0 +1,11 @@
+use pin_project_lite::pin_project;
+
+pin_project! {
+    struct Struct<T, U> {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    }
+}
+
+fn main() {}
diff --git a/crates/pin-project-lite/tests/expand/naming/struct-ref.expanded.rs b/crates/pin-project-lite/tests/expand/naming/struct-ref.expanded.rs
new file mode 100644
index 0000000..9fea20d
--- /dev/null
+++ b/crates/pin-project-lite/tests/expand/naming/struct-ref.expanded.rs
@@ -0,0 +1,90 @@
+use pin_project_lite::pin_project;
+struct Struct<T, U> {
+    pinned: T,
+    unpinned: U,
+}
+#[doc(hidden)]
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::ref_option_ref)]
+#[allow(clippy::type_repetition_in_bounds)]
+struct StructProjRef<'__pin, T, U>
+where
+    Struct<T, U>: '__pin,
+{
+    pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>,
+    unpinned: &'__pin (U),
+}
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[doc(hidden)]
+    #[allow(dead_code)]
+    #[allow(single_use_lifetimes)]
+    #[allow(clippy::unknown_clippy_lints)]
+    #[allow(clippy::mut_mut)]
+    #[allow(clippy::redundant_pub_crate)]
+    #[allow(clippy::ref_option_ref)]
+    #[allow(clippy::type_repetition_in_bounds)]
+    struct Projection<'__pin, T, U>
+    where
+        Struct<T, U>: '__pin,
+    {
+        pinned: ::pin_project_lite::__private::Pin<&'__pin mut (T)>,
+        unpinned: &'__pin mut (U),
+    }
+    impl<T, U> Struct<T, U> {
+        #[doc(hidden)]
+        #[inline]
+        fn project<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin mut Self>,
+        ) -> Projection<'__pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_unchecked_mut();
+                Projection {
+                    pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
+                    unpinned: unpinned,
+                }
+            }
+        }
+        #[doc(hidden)]
+        #[inline]
+        fn project_ref<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin Self>,
+        ) -> StructProjRef<'__pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_ref();
+                StructProjRef {
+                    pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
+                    unpinned: unpinned,
+                }
+            }
+        }
+    }
+    #[allow(non_snake_case)]
+    struct __Origin<'__pin, T, U> {
+        __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>,
+        pinned: T,
+        unpinned: ::pin_project_lite::__private::AlwaysUnpin<U>,
+    }
+    impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Struct<T, U>
+    where
+        __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin,
+    {}
+    trait MustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {}
+    impl<T, U> MustNotImplDrop for Struct<T, U> {}
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+        let _ = &this.pinned;
+        let _ = &this.unpinned;
+    }
+};
+fn main() {}
diff --git a/crates/pin-project-lite/tests/expand/naming/struct-ref.rs b/crates/pin-project-lite/tests/expand/naming/struct-ref.rs
new file mode 100644
index 0000000..6821af8
--- /dev/null
+++ b/crates/pin-project-lite/tests/expand/naming/struct-ref.rs
@@ -0,0 +1,12 @@
+use pin_project_lite::pin_project;
+
+pin_project! {
+    #[project_ref = StructProjRef]
+    struct Struct<T, U> {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    }
+}
+
+fn main() {}
diff --git a/crates/pin-project-lite/tests/expand/not_unpin/enum.expanded.rs b/crates/pin-project-lite/tests/expand/not_unpin/enum.expanded.rs
new file mode 100644
index 0000000..02cdc23
--- /dev/null
+++ b/crates/pin-project-lite/tests/expand/not_unpin/enum.expanded.rs
@@ -0,0 +1,99 @@
+use pin_project_lite::pin_project;
+enum Enum<T, U> {
+    Struct { pinned: T, unpinned: U },
+    Unit,
+}
+#[doc(hidden)]
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::ref_option_ref)]
+#[allow(clippy::type_repetition_in_bounds)]
+enum EnumProj<'__pin, T, U>
+where
+    Enum<T, U>: '__pin,
+{
+    Struct {
+        pinned: ::pin_project_lite::__private::Pin<&'__pin mut (T)>,
+        unpinned: &'__pin mut (U),
+    },
+    Unit,
+}
+#[doc(hidden)]
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::ref_option_ref)]
+#[allow(clippy::type_repetition_in_bounds)]
+enum EnumProjRef<'__pin, T, U>
+where
+    Enum<T, U>: '__pin,
+{
+    Struct {
+        pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>,
+        unpinned: &'__pin (U),
+    },
+    Unit,
+}
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    impl<T, U> Enum<T, U> {
+        #[doc(hidden)]
+        #[inline]
+        fn project<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin mut Self>,
+        ) -> EnumProj<'__pin, T, U> {
+            unsafe {
+                match self.get_unchecked_mut() {
+                    Self::Struct { pinned, unpinned } => {
+                        EnumProj::Struct {
+                            pinned: ::pin_project_lite::__private::Pin::new_unchecked(
+                                pinned,
+                            ),
+                            unpinned: unpinned,
+                        }
+                    }
+                    Self::Unit => EnumProj::Unit,
+                }
+            }
+        }
+        #[doc(hidden)]
+        #[inline]
+        fn project_ref<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin Self>,
+        ) -> EnumProjRef<'__pin, T, U> {
+            unsafe {
+                match self.get_ref() {
+                    Self::Struct { pinned, unpinned } => {
+                        EnumProjRef::Struct {
+                            pinned: ::pin_project_lite::__private::Pin::new_unchecked(
+                                pinned,
+                            ),
+                            unpinned: unpinned,
+                        }
+                    }
+                    Self::Unit => EnumProjRef::Unit,
+                }
+            }
+        }
+    }
+    #[doc(hidden)]
+    impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Enum<T, U>
+    where
+        (
+            ::core::marker::PhantomData<&'__pin ()>,
+            ::core::marker::PhantomPinned,
+        ): ::pin_project_lite::__private::Unpin,
+    {}
+    trait MustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {}
+    impl<T, U> MustNotImplDrop for Enum<T, U> {}
+};
+fn main() {}
diff --git a/crates/pin-project-lite/tests/expand/not_unpin/enum.rs b/crates/pin-project-lite/tests/expand/not_unpin/enum.rs
new file mode 100644
index 0000000..0896716
--- /dev/null
+++ b/crates/pin-project-lite/tests/expand/not_unpin/enum.rs
@@ -0,0 +1,17 @@
+use pin_project_lite::pin_project;
+
+pin_project! {
+    #[project(!Unpin)]
+    #[project = EnumProj]
+    #[project_ref = EnumProjRef]
+    enum Enum<T, U> {
+        Struct {
+            #[pin]
+            pinned: T,
+            unpinned: U,
+        },
+        Unit,
+    }
+}
+
+fn main() {}
diff --git a/crates/pin-project-lite/tests/expand/not_unpin/struct.expanded.rs b/crates/pin-project-lite/tests/expand/not_unpin/struct.expanded.rs
new file mode 100644
index 0000000..2e590b6
--- /dev/null
+++ b/crates/pin-project-lite/tests/expand/not_unpin/struct.expanded.rs
@@ -0,0 +1,88 @@
+use pin_project_lite::pin_project;
+struct Struct<T, U> {
+    pinned: T,
+    unpinned: U,
+}
+#[doc(hidden)]
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::ref_option_ref)]
+#[allow(clippy::type_repetition_in_bounds)]
+struct StructProj<'__pin, T, U>
+where
+    Struct<T, U>: '__pin,
+{
+    pinned: ::pin_project_lite::__private::Pin<&'__pin mut (T)>,
+    unpinned: &'__pin mut (U),
+}
+#[doc(hidden)]
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::ref_option_ref)]
+#[allow(clippy::type_repetition_in_bounds)]
+struct StructProjRef<'__pin, T, U>
+where
+    Struct<T, U>: '__pin,
+{
+    pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>,
+    unpinned: &'__pin (U),
+}
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    impl<T, U> Struct<T, U> {
+        #[doc(hidden)]
+        #[inline]
+        fn project<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin mut Self>,
+        ) -> StructProj<'__pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_unchecked_mut();
+                StructProj {
+                    pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
+                    unpinned: unpinned,
+                }
+            }
+        }
+        #[doc(hidden)]
+        #[inline]
+        fn project_ref<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin Self>,
+        ) -> StructProjRef<'__pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_ref();
+                StructProjRef {
+                    pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
+                    unpinned: unpinned,
+                }
+            }
+        }
+    }
+    #[doc(hidden)]
+    impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Struct<T, U>
+    where
+        (
+            ::core::marker::PhantomData<&'__pin ()>,
+            ::core::marker::PhantomPinned,
+        ): ::pin_project_lite::__private::Unpin,
+    {}
+    trait MustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {}
+    impl<T, U> MustNotImplDrop for Struct<T, U> {}
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+        let _ = &this.pinned;
+        let _ = &this.unpinned;
+    }
+};
+fn main() {}
diff --git a/crates/pin-project-lite/tests/expand/not_unpin/struct.rs b/crates/pin-project-lite/tests/expand/not_unpin/struct.rs
new file mode 100644
index 0000000..0a2967f
--- /dev/null
+++ b/crates/pin-project-lite/tests/expand/not_unpin/struct.rs
@@ -0,0 +1,14 @@
+use pin_project_lite::pin_project;
+
+pin_project! {
+    #[project = StructProj]
+    #[project(!Unpin)]
+    #[project_ref = StructProjRef]
+    struct Struct<T, U> {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    }
+}
+
+fn main() {}
diff --git a/crates/pin-project-lite/tests/expand/pinned_drop/enum.expanded.rs b/crates/pin-project-lite/tests/expand/pinned_drop/enum.expanded.rs
new file mode 100644
index 0000000..03901ce
--- /dev/null
+++ b/crates/pin-project-lite/tests/expand/pinned_drop/enum.expanded.rs
@@ -0,0 +1,112 @@
+use std::pin::Pin;
+use pin_project_lite::pin_project;
+enum Enum<T, U> {
+    Struct { pinned: T, unpinned: U },
+    Unit,
+}
+#[doc(hidden)]
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::ref_option_ref)]
+#[allow(clippy::type_repetition_in_bounds)]
+enum EnumProj<'__pin, T, U>
+where
+    Enum<T, U>: '__pin,
+{
+    Struct {
+        pinned: ::pin_project_lite::__private::Pin<&'__pin mut (T)>,
+        unpinned: &'__pin mut (U),
+    },
+    Unit,
+}
+#[doc(hidden)]
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::ref_option_ref)]
+#[allow(clippy::type_repetition_in_bounds)]
+enum EnumProjRef<'__pin, T, U>
+where
+    Enum<T, U>: '__pin,
+{
+    Struct {
+        pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>,
+        unpinned: &'__pin (U),
+    },
+    Unit,
+}
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    impl<T, U> Enum<T, U> {
+        #[doc(hidden)]
+        #[inline]
+        fn project<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin mut Self>,
+        ) -> EnumProj<'__pin, T, U> {
+            unsafe {
+                match self.get_unchecked_mut() {
+                    Self::Struct { pinned, unpinned } => {
+                        EnumProj::Struct {
+                            pinned: ::pin_project_lite::__private::Pin::new_unchecked(
+                                pinned,
+                            ),
+                            unpinned: unpinned,
+                        }
+                    }
+                    Self::Unit => EnumProj::Unit,
+                }
+            }
+        }
+        #[doc(hidden)]
+        #[inline]
+        fn project_ref<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin Self>,
+        ) -> EnumProjRef<'__pin, T, U> {
+            unsafe {
+                match self.get_ref() {
+                    Self::Struct { pinned, unpinned } => {
+                        EnumProjRef::Struct {
+                            pinned: ::pin_project_lite::__private::Pin::new_unchecked(
+                                pinned,
+                            ),
+                            unpinned: unpinned,
+                        }
+                    }
+                    Self::Unit => EnumProjRef::Unit,
+                }
+            }
+        }
+    }
+    #[allow(non_snake_case)]
+    struct __Origin<'__pin, T, U> {
+        __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>,
+        Struct: (T, ::pin_project_lite::__private::AlwaysUnpin<U>),
+        Unit: (),
+    }
+    impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Enum<T, U>
+    where
+        __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin,
+    {}
+    impl<T, U> ::pin_project_lite::__private::Drop for Enum<T, U> {
+        fn drop(&mut self) {
+            fn __drop_inner<T, U>(
+                this: ::pin_project_lite::__private::Pin<&mut Enum<T, U>>,
+            ) {
+                fn __drop_inner() {}
+                let _ = this;
+            }
+            let pinned_self: ::pin_project_lite::__private::Pin<&mut Self> = unsafe {
+                ::pin_project_lite::__private::Pin::new_unchecked(self)
+            };
+            __drop_inner(pinned_self);
+        }
+    }
+};
+fn main() {}
diff --git a/crates/pin-project-lite/tests/expand/pinned_drop/enum.rs b/crates/pin-project-lite/tests/expand/pinned_drop/enum.rs
new file mode 100644
index 0000000..5f3508c
--- /dev/null
+++ b/crates/pin-project-lite/tests/expand/pinned_drop/enum.rs
@@ -0,0 +1,23 @@
+use std::pin::Pin;
+
+use pin_project_lite::pin_project;
+
+pin_project! {
+    #[project = EnumProj]
+    #[project_ref = EnumProjRef]
+    enum Enum<T, U> {
+        Struct {
+            #[pin]
+            pinned: T,
+            unpinned: U,
+        },
+        Unit,
+    }
+    impl<T, U> PinnedDrop for Enum<T, U> {
+        fn drop(this: Pin<&mut Self>) {
+            let _ = this;
+        }
+    }
+}
+
+fn main() {}
diff --git a/crates/pin-project-lite/tests/expand/pinned_drop/struct.expanded.rs b/crates/pin-project-lite/tests/expand/pinned_drop/struct.expanded.rs
new file mode 100644
index 0000000..f3fa923
--- /dev/null
+++ b/crates/pin-project-lite/tests/expand/pinned_drop/struct.expanded.rs
@@ -0,0 +1,101 @@
+use std::pin::Pin;
+use pin_project_lite::pin_project;
+struct Struct<T, U> {
+    pinned: T,
+    unpinned: U,
+}
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[doc(hidden)]
+    #[allow(dead_code)]
+    #[allow(single_use_lifetimes)]
+    #[allow(clippy::unknown_clippy_lints)]
+    #[allow(clippy::mut_mut)]
+    #[allow(clippy::redundant_pub_crate)]
+    #[allow(clippy::ref_option_ref)]
+    #[allow(clippy::type_repetition_in_bounds)]
+    struct Projection<'__pin, T, U>
+    where
+        Struct<T, U>: '__pin,
+    {
+        pinned: ::pin_project_lite::__private::Pin<&'__pin mut (T)>,
+        unpinned: &'__pin mut (U),
+    }
+    #[doc(hidden)]
+    #[allow(dead_code)]
+    #[allow(single_use_lifetimes)]
+    #[allow(clippy::unknown_clippy_lints)]
+    #[allow(clippy::mut_mut)]
+    #[allow(clippy::redundant_pub_crate)]
+    #[allow(clippy::ref_option_ref)]
+    #[allow(clippy::type_repetition_in_bounds)]
+    struct ProjectionRef<'__pin, T, U>
+    where
+        Struct<T, U>: '__pin,
+    {
+        pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>,
+        unpinned: &'__pin (U),
+    }
+    impl<T, U> Struct<T, U> {
+        #[doc(hidden)]
+        #[inline]
+        fn project<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin mut Self>,
+        ) -> Projection<'__pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_unchecked_mut();
+                Projection {
+                    pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
+                    unpinned: unpinned,
+                }
+            }
+        }
+        #[doc(hidden)]
+        #[inline]
+        fn project_ref<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin Self>,
+        ) -> ProjectionRef<'__pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_ref();
+                ProjectionRef {
+                    pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
+                    unpinned: unpinned,
+                }
+            }
+        }
+    }
+    #[allow(non_snake_case)]
+    struct __Origin<'__pin, T, U> {
+        __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>,
+        pinned: T,
+        unpinned: ::pin_project_lite::__private::AlwaysUnpin<U>,
+    }
+    impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Struct<T, U>
+    where
+        __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin,
+    {}
+    impl<T, U> ::pin_project_lite::__private::Drop for Struct<T, U> {
+        fn drop(&mut self) {
+            fn __drop_inner<T, U>(
+                this: ::pin_project_lite::__private::Pin<&mut Struct<T, U>>,
+            ) {
+                fn __drop_inner() {}
+                let _ = this;
+            }
+            let pinned_self: ::pin_project_lite::__private::Pin<&mut Self> = unsafe {
+                ::pin_project_lite::__private::Pin::new_unchecked(self)
+            };
+            __drop_inner(pinned_self);
+        }
+    }
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+        let _ = &this.pinned;
+        let _ = &this.unpinned;
+    }
+};
+fn main() {}
diff --git a/crates/pin-project-lite/tests/expand/pinned_drop/struct.rs b/crates/pin-project-lite/tests/expand/pinned_drop/struct.rs
new file mode 100644
index 0000000..5400ecb
--- /dev/null
+++ b/crates/pin-project-lite/tests/expand/pinned_drop/struct.rs
@@ -0,0 +1,18 @@
+use std::pin::Pin;
+
+use pin_project_lite::pin_project;
+
+pin_project! {
+    struct Struct<T, U> {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    }
+    impl<T, U> PinnedDrop for Struct<T, U> {
+        fn drop(this: Pin<&mut Self>) {
+            let _ = this;
+        }
+    }
+}
+
+fn main() {}
diff --git a/crates/pin-project-lite/tests/expand/pub/enum.expanded.rs b/crates/pin-project-lite/tests/expand/pub/enum.expanded.rs
new file mode 100644
index 0000000..85c7770
--- /dev/null
+++ b/crates/pin-project-lite/tests/expand/pub/enum.expanded.rs
@@ -0,0 +1,101 @@
+use pin_project_lite::pin_project;
+pub enum Enum<T, U> {
+    Struct { pinned: T, unpinned: U },
+    Unit,
+}
+#[doc(hidden)]
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::ref_option_ref)]
+#[allow(clippy::type_repetition_in_bounds)]
+pub(crate) enum EnumProj<'__pin, T, U>
+where
+    Enum<T, U>: '__pin,
+{
+    Struct {
+        pinned: ::pin_project_lite::__private::Pin<&'__pin mut (T)>,
+        unpinned: &'__pin mut (U),
+    },
+    Unit,
+}
+#[doc(hidden)]
+#[allow(dead_code)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::mut_mut)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::ref_option_ref)]
+#[allow(clippy::type_repetition_in_bounds)]
+pub(crate) enum EnumProjRef<'__pin, T, U>
+where
+    Enum<T, U>: '__pin,
+{
+    Struct {
+        pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>,
+        unpinned: &'__pin (U),
+    },
+    Unit,
+}
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    impl<T, U> Enum<T, U> {
+        #[doc(hidden)]
+        #[inline]
+        pub(crate) fn project<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin mut Self>,
+        ) -> EnumProj<'__pin, T, U> {
+            unsafe {
+                match self.get_unchecked_mut() {
+                    Self::Struct { pinned, unpinned } => {
+                        EnumProj::Struct {
+                            pinned: ::pin_project_lite::__private::Pin::new_unchecked(
+                                pinned,
+                            ),
+                            unpinned: unpinned,
+                        }
+                    }
+                    Self::Unit => EnumProj::Unit,
+                }
+            }
+        }
+        #[doc(hidden)]
+        #[inline]
+        pub(crate) fn project_ref<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin Self>,
+        ) -> EnumProjRef<'__pin, T, U> {
+            unsafe {
+                match self.get_ref() {
+                    Self::Struct { pinned, unpinned } => {
+                        EnumProjRef::Struct {
+                            pinned: ::pin_project_lite::__private::Pin::new_unchecked(
+                                pinned,
+                            ),
+                            unpinned: unpinned,
+                        }
+                    }
+                    Self::Unit => EnumProjRef::Unit,
+                }
+            }
+        }
+    }
+    #[allow(non_snake_case)]
+    pub struct __Origin<'__pin, T, U> {
+        __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>,
+        Struct: (T, ::pin_project_lite::__private::AlwaysUnpin<U>),
+        Unit: (),
+    }
+    impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Enum<T, U>
+    where
+        __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin,
+    {}
+    trait MustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {}
+    impl<T, U> MustNotImplDrop for Enum<T, U> {}
+};
+fn main() {}
diff --git a/crates/pin-project-lite/tests/expand/pub/enum.rs b/crates/pin-project-lite/tests/expand/pub/enum.rs
new file mode 100644
index 0000000..d3968af
--- /dev/null
+++ b/crates/pin-project-lite/tests/expand/pub/enum.rs
@@ -0,0 +1,16 @@
+use pin_project_lite::pin_project;
+
+pin_project! {
+    #[project = EnumProj]
+    #[project_ref = EnumProjRef]
+    pub enum Enum<T, U> {
+        Struct {
+            #[pin]
+            pinned: T,
+            unpinned: U,
+        },
+        Unit,
+    }
+}
+
+fn main() {}
diff --git a/crates/pin-project-lite/tests/expand/pub/struct.expanded.rs b/crates/pin-project-lite/tests/expand/pub/struct.expanded.rs
new file mode 100644
index 0000000..a06783d
--- /dev/null
+++ b/crates/pin-project-lite/tests/expand/pub/struct.expanded.rs
@@ -0,0 +1,90 @@
+use pin_project_lite::pin_project;
+pub struct Struct<T, U> {
+    pub pinned: T,
+    pub unpinned: U,
+}
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[doc(hidden)]
+    #[allow(dead_code)]
+    #[allow(single_use_lifetimes)]
+    #[allow(clippy::unknown_clippy_lints)]
+    #[allow(clippy::mut_mut)]
+    #[allow(clippy::redundant_pub_crate)]
+    #[allow(clippy::ref_option_ref)]
+    #[allow(clippy::type_repetition_in_bounds)]
+    pub(crate) struct Projection<'__pin, T, U>
+    where
+        Struct<T, U>: '__pin,
+    {
+        pub pinned: ::pin_project_lite::__private::Pin<&'__pin mut (T)>,
+        pub unpinned: &'__pin mut (U),
+    }
+    #[doc(hidden)]
+    #[allow(dead_code)]
+    #[allow(single_use_lifetimes)]
+    #[allow(clippy::unknown_clippy_lints)]
+    #[allow(clippy::mut_mut)]
+    #[allow(clippy::redundant_pub_crate)]
+    #[allow(clippy::ref_option_ref)]
+    #[allow(clippy::type_repetition_in_bounds)]
+    pub(crate) struct ProjectionRef<'__pin, T, U>
+    where
+        Struct<T, U>: '__pin,
+    {
+        pub pinned: ::pin_project_lite::__private::Pin<&'__pin (T)>,
+        pub unpinned: &'__pin (U),
+    }
+    impl<T, U> Struct<T, U> {
+        #[doc(hidden)]
+        #[inline]
+        pub(crate) fn project<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin mut Self>,
+        ) -> Projection<'__pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_unchecked_mut();
+                Projection {
+                    pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
+                    unpinned: unpinned,
+                }
+            }
+        }
+        #[doc(hidden)]
+        #[inline]
+        pub(crate) fn project_ref<'__pin>(
+            self: ::pin_project_lite::__private::Pin<&'__pin Self>,
+        ) -> ProjectionRef<'__pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_ref();
+                ProjectionRef {
+                    pinned: ::pin_project_lite::__private::Pin::new_unchecked(pinned),
+                    unpinned: unpinned,
+                }
+            }
+        }
+    }
+    #[allow(non_snake_case)]
+    pub struct __Origin<'__pin, T, U> {
+        __dummy_lifetime: ::pin_project_lite::__private::PhantomData<&'__pin ()>,
+        pinned: T,
+        unpinned: ::pin_project_lite::__private::AlwaysUnpin<U>,
+    }
+    impl<'__pin, T, U> ::pin_project_lite::__private::Unpin for Struct<T, U>
+    where
+        __Origin<'__pin, T, U>: ::pin_project_lite::__private::Unpin,
+    {}
+    trait MustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: ::pin_project_lite::__private::Drop> MustNotImplDrop for T {}
+    impl<T, U> MustNotImplDrop for Struct<T, U> {}
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+        let _ = &this.pinned;
+        let _ = &this.unpinned;
+    }
+};
+fn main() {}
diff --git a/crates/pin-project-lite/tests/expand/pub/struct.rs b/crates/pin-project-lite/tests/expand/pub/struct.rs
new file mode 100644
index 0000000..6659096
--- /dev/null
+++ b/crates/pin-project-lite/tests/expand/pub/struct.rs
@@ -0,0 +1,11 @@
+use pin_project_lite::pin_project;
+
+pin_project! {
+    pub struct Struct<T, U> {
+        #[pin]
+        pub pinned: T,
+        pub unpinned: U,
+    }
+}
+
+fn main() {}
diff --git a/crates/pin-project-lite/tests/expandtest.rs b/crates/pin-project-lite/tests/expandtest.rs
new file mode 100644
index 0000000..04a0666
--- /dev/null
+++ b/crates/pin-project-lite/tests/expandtest.rs
@@ -0,0 +1,44 @@
+#![cfg(not(miri))]
+#![cfg(not(careful))]
+#![warn(rust_2018_idioms, single_use_lifetimes)]
+
+use std::{
+    env,
+    process::{Command, ExitStatus, Stdio},
+};
+
+const PATH: &str = "tests/expand/**/*.rs";
+
+#[rustversion::attr(not(nightly), ignore)]
+#[test]
+fn expandtest() {
+    let is_ci = env::var_os("CI").is_some();
+    let cargo = &*env::var("CARGO").unwrap_or_else(|_| "cargo".into());
+    if !has_command(&[cargo, "expand"]) {
+        if is_ci {
+            panic!("expandtest requires cargo-expand");
+        }
+        return;
+    }
+
+    let args = &["--all-features"];
+    if is_ci {
+        macrotest::expand_without_refresh_args(PATH, args);
+    } else {
+        env::set_var("MACROTEST", "overwrite");
+        macrotest::expand_args(PATH, args);
+    }
+}
+
+fn has_command(command: &[&str]) -> bool {
+    Command::new(command[0])
+        .args(&command[1..])
+        .arg("--version")
+        .stdin(Stdio::null())
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .status()
+        .as_ref()
+        .map(ExitStatus::success)
+        .unwrap_or(false)
+}
diff --git a/crates/pin-project-lite/tests/include/basic.rs b/crates/pin-project-lite/tests/include/basic.rs
new file mode 100644
index 0000000..25121f2
--- /dev/null
+++ b/crates/pin-project-lite/tests/include/basic.rs
@@ -0,0 +1,35 @@
+// default pin_project! is completely safe.
+
+::pin_project_lite::pin_project! {
+    #[derive(Debug)]
+    pub struct DefaultStruct<T, U> {
+        #[pin]
+        pub pinned: T,
+        pub unpinned: U,
+    }
+}
+
+::pin_project_lite::pin_project! {
+    #[project = DefaultStructProj]
+    #[project_ref = DefaultStructProjRef]
+    #[derive(Debug)]
+    pub struct DefaultStructNamed<T, U> {
+        #[pin]
+        pub pinned: T,
+        pub unpinned: U,
+    }
+}
+
+::pin_project_lite::pin_project! {
+    #[project = DefaultEnumProj]
+    #[project_ref = DefaultEnumProjRef]
+    #[derive(Debug)]
+    pub enum DefaultEnum<T, U> {
+        Struct {
+            #[pin]
+            pinned: T,
+            unpinned: U,
+        },
+        Unit,
+    }
+}
diff --git a/crates/pin-project-lite/tests/lint.rs b/crates/pin-project-lite/tests/lint.rs
new file mode 100644
index 0000000..94f72fd
--- /dev/null
+++ b/crates/pin-project-lite/tests/lint.rs
@@ -0,0 +1,281 @@
+// Check interoperability with rustc and clippy lints.
+
+#![forbid(unsafe_code)]
+// for old compilers
+#![allow(unknown_lints)]
+#![warn(nonstandard_style, rust_2018_idioms, unused)]
+// Note: This does not guarantee compatibility with forbidding these lints in the future.
+// If rustc adds a new lint, we may not be able to keep this.
+#![forbid(future_incompatible, rust_2018_compatibility, rust_2021_compatibility)]
+// lints forbidden as a part of future_incompatible, rust_2018_compatibility, and rust_2021_compatibility are not included in the list below.
+// elided_lifetimes_in_paths, explicit_outlives_requirements, unused_extern_crates:  as a part of rust_2018_idioms
+// unsafe_op_in_unsafe_fn: requires Rust 1.52. and, we don't generate unsafe fn.
+// non_exhaustive_omitted_patterns, multiple_supertrait_upcastable: unstable
+// unstable_features: no way to generate #![feature(..)] by macros, expect for unstable inner attribute. and this lint is deprecated: https://doc.rust-lang.org/rustc/lints/listing/allowed-by-default.html#unstable-features
+// unused_crate_dependencies, must_not_suspend: unrelated
+// unsafe_code: checked in forbid_unsafe module
+#![warn(
+    box_pointers,
+    deprecated_in_future,
+    fuzzy_provenance_casts,
+    invalid_reference_casting,
+    let_underscore_drop,
+    lossy_provenance_casts,
+    macro_use_extern_crate,
+    meta_variable_misuse,
+    missing_abi,
+    missing_copy_implementations,
+    missing_debug_implementations,
+    missing_docs,
+    non_ascii_idents,
+    noop_method_call,
+    private_bounds,
+    private_interfaces,
+    single_use_lifetimes,
+    trivial_casts,
+    trivial_numeric_casts,
+    unnameable_types,
+    unreachable_pub,
+    unused_import_braces,
+    unused_lifetimes,
+    unused_qualifications,
+    unused_results,
+    unused_tuple_struct_fields,
+    variant_size_differences
+)]
+#![warn(clippy::all, clippy::pedantic, clippy::nursery, clippy::restriction)]
+#![allow(clippy::blanket_clippy_restriction_lints)] // this is a test, so enable all restriction lints intentionally.
+#![allow(
+    clippy::exhaustive_enums,
+    clippy::exhaustive_structs,
+    clippy::min_ident_chars,
+    clippy::single_char_lifetime_names
+)] // TODO
+
+pub mod basic {
+    include!("include/basic.rs");
+}
+
+pub mod box_pointers {
+    use pin_project_lite::pin_project;
+
+    pin_project! {
+        #[derive(Debug)]
+        pub struct Struct {
+            #[pin]
+            pub p: Box<isize>,
+            pub u: Box<isize>,
+        }
+    }
+
+    pin_project! {
+        #[project = EnumProj]
+        #[project_ref = EnumProjRef]
+        #[project(!Unpin)]
+        #[derive(Debug)]
+        pub enum Enum {
+            Struct {
+                #[pin]
+                p: Box<isize>,
+                u: Box<isize>,
+            },
+            Unit,
+        }
+    }
+}
+
+pub mod explicit_outlives_requirements {
+    use pin_project_lite::pin_project;
+
+    pin_project! {
+        #[derive(Debug)]
+        pub struct Struct<'a, T, U>
+        where
+            T: ?Sized,
+            U: ?Sized,
+        {
+            #[pin]
+            pub pinned: &'a mut T,
+            pub unpinned: &'a mut U,
+        }
+    }
+
+    pin_project! {
+        #[project = EnumProj]
+        #[project_ref = EnumProjRef]
+        #[project(!Unpin)]
+        #[derive(Debug)]
+        pub enum Enum<'a, T, U>
+        where
+            T: ?Sized,
+            U: ?Sized,
+        {
+            Struct {
+                #[pin]
+                pinned: &'a mut T,
+                unpinned: &'a mut U,
+            },
+            Unit,
+        }
+    }
+}
+
+pub mod variant_size_differences {
+    use pin_project_lite::pin_project;
+
+    pin_project! {
+        #[project = EnumProj]
+        #[project_ref = EnumProjRef]
+        #[project(!Unpin)]
+        #[allow(missing_debug_implementations, missing_copy_implementations)] // https://github.com/rust-lang/rust/pull/74060
+        #[allow(variant_size_differences)] // for the type itself
+        #[allow(clippy::large_enum_variant)] // for the type itself
+        pub enum Enum {
+            V1 { f: u8 },
+            V2 { f: [u8; 1024] },
+        }
+    }
+}
+
+pub mod clippy_mut_mut {
+    use pin_project_lite::pin_project;
+
+    pin_project! {
+        #[derive(Debug)]
+        pub struct Struct<'a, T, U> {
+            #[pin]
+            pub pinned: &'a mut T,
+            pub unpinned: &'a mut U,
+        }
+    }
+
+    pin_project! {
+        #[project = EnumProj]
+        #[project_ref = EnumProjRef]
+        #[project(!Unpin)]
+        #[derive(Debug)]
+        pub enum Enum<'a, T, U> {
+            Struct {
+                #[pin]
+                pinned: &'a mut T,
+                unpinned: &'a mut U,
+            },
+            Unit,
+        }
+    }
+}
+
+#[allow(unreachable_pub)]
+mod clippy_redundant_pub_crate {
+    use pin_project_lite::pin_project;
+
+    pin_project! {
+        #[derive(Debug)]
+        pub struct Struct<T, U> {
+            #[pin]
+            pub pinned: T,
+            pub unpinned: U,
+        }
+    }
+
+    pin_project! {
+        #[project = EnumProj]
+        #[project_ref = EnumProjRef]
+        #[project(!Unpin)]
+        #[derive(Debug)]
+        pub enum Enum<T, U> {
+            Struct {
+                #[pin]
+                pinned: T,
+                unpinned: U,
+            },
+            Unit,
+        }
+    }
+}
+
+#[allow(clippy::use_self)]
+pub mod clippy_type_repetition_in_bounds {
+    use pin_project_lite::pin_project;
+
+    pin_project! {
+        #[derive(Debug)]
+        pub struct Struct<T, U>
+        where
+            Struct<T, U>: Sized,
+        {
+            #[pin]
+            pub pinned: T,
+            pub unpinned: U,
+        }
+    }
+
+    pin_project! {
+        #[project = EnumProj]
+        #[project_ref = EnumProjRef]
+        #[project(!Unpin)]
+        #[derive(Debug)]
+        pub enum Enum<T, U>
+        where
+            Enum<T, U>: Sized,
+        {
+            Struct {
+                #[pin]
+                pinned: T,
+                unpinned: U,
+            },
+            Unit,
+        }
+    }
+}
+
+#[allow(missing_debug_implementations)]
+pub mod clippy_used_underscore_binding {
+    use pin_project_lite::pin_project;
+
+    pin_project! {
+        pub struct Struct<T, U> {
+            #[pin]
+            pub _pinned: T,
+            pub _unpinned: U,
+        }
+    }
+
+    pin_project! {
+        #[project = EnumProj]
+        #[project_ref = EnumProjRef]
+        #[project(!Unpin)]
+        pub enum Enum<T, U> {
+            Struct {
+                #[pin]
+                _pinned: T,
+                _unpinned: U,
+            },
+        }
+    }
+}
+
+pub mod clippy_ref_option_ref {
+    use pin_project_lite::pin_project;
+
+    pin_project! {
+        pub struct Struct<'a> {
+            #[pin]
+            pub _pinned: Option<&'a ()>,
+            pub _unpinned: Option<&'a ()>,
+        }
+    }
+
+    pin_project! {
+        #[project = EnumProj]
+        #[project_ref = EnumProjRef]
+        #[project(!Unpin)]
+        pub enum Enum<'a> {
+            Struct {
+                #[pin]
+                _pinned: Option<&'a ()>,
+                _unpinned: Option<&'a ()>,
+            },
+        }
+    }
+}
diff --git a/crates/pin-project-lite/tests/proper_unpin.rs b/crates/pin-project-lite/tests/proper_unpin.rs
new file mode 100644
index 0000000..89235a4
--- /dev/null
+++ b/crates/pin-project-lite/tests/proper_unpin.rs
@@ -0,0 +1,100 @@
+#![warn(rust_2018_idioms, single_use_lifetimes)]
+#![allow(dead_code)]
+
+#[macro_use]
+mod auxiliary;
+
+pub mod default {
+    use std::marker::PhantomPinned;
+
+    use pin_project_lite::pin_project;
+
+    struct Inner<T> {
+        f: T,
+    }
+
+    assert_unpin!(Inner<()>);
+    assert_not_unpin!(Inner<PhantomPinned>);
+
+    pin_project! {
+        struct Struct<T, U> {
+            #[pin]
+            f1: Inner<T>,
+            f2: U,
+        }
+    }
+
+    assert_unpin!(Struct<(), ()>);
+    assert_unpin!(Struct<(), PhantomPinned>);
+    assert_not_unpin!(Struct<PhantomPinned, ()>);
+    assert_not_unpin!(Struct<PhantomPinned, PhantomPinned>);
+
+    pin_project! {
+        #[project = EnumProj]
+        #[project_ref = EnumProjRef]
+        enum Enum<T, U> {
+            V1 {
+                #[pin]
+                f1: Inner<T>,
+                f2: U,
+            },
+        }
+    }
+
+    assert_unpin!(Enum<(), ()>);
+    assert_unpin!(Enum<(), PhantomPinned>);
+    assert_not_unpin!(Enum<PhantomPinned, ()>);
+    assert_not_unpin!(Enum<PhantomPinned, PhantomPinned>);
+
+    pin_project! {
+        #[project(!Unpin)]
+        enum NotUnpinEnum<T, U> {
+            V1 {
+                #[pin] f1: Inner<T>,
+                f2: U,
+            }
+        }
+    }
+
+    assert_not_unpin!(NotUnpinEnum<(), ()>);
+
+    pin_project! {
+        struct TrivialBounds {
+            #[pin]
+            f: PhantomPinned,
+        }
+    }
+
+    assert_not_unpin!(TrivialBounds);
+
+    pin_project! {
+        struct PinRef<'a, T, U> {
+            #[pin]
+            f1: &'a mut Inner<T>,
+            f2: U,
+        }
+    }
+
+    assert_unpin!(PinRef<'_, PhantomPinned, PhantomPinned>);
+
+    pin_project! {
+        #[project(!Unpin)]
+        struct NotUnpin<U> {
+            #[pin]
+            u: U
+        }
+    }
+
+    assert_not_unpin!(NotUnpin<()>);
+
+    pin_project! {
+        #[project(!Unpin)]
+        struct NotUnpinRef<'a, T, U> {
+            #[pin]
+            f1: &'a mut Inner<T>,
+            f2: U
+        }
+    }
+
+    assert_not_unpin!(NotUnpinRef<'_, (), ()>);
+}
diff --git a/crates/pin-project-lite/tests/test.rs b/crates/pin-project-lite/tests/test.rs
new file mode 100644
index 0000000..d128930
--- /dev/null
+++ b/crates/pin-project-lite/tests/test.rs
@@ -0,0 +1,698 @@
+#![warn(rust_2018_idioms, single_use_lifetimes)]
+#![allow(dead_code)]
+
+#[macro_use]
+mod auxiliary;
+
+use core::{
+    marker::{PhantomData, PhantomPinned},
+    pin::Pin,
+};
+
+use pin_project_lite::pin_project;
+
+#[test]
+fn projection() {
+    pin_project! {
+        #[project = StructProj]
+        #[project_ref = StructProjRef]
+        #[project_replace = StructProjReplace]
+        #[derive(Default)]
+        struct Struct<T, U> {
+            #[pin]
+            f1: T,
+            f2: U,
+        }
+    }
+
+    let mut s = Struct { f1: 1, f2: 2 };
+    let mut s_orig = Pin::new(&mut s);
+    let s = s_orig.as_mut().project();
+
+    let _: Pin<&mut i32> = s.f1;
+    assert_eq!(*s.f1, 1);
+    let _: &mut i32 = s.f2;
+    assert_eq!(*s.f2, 2);
+
+    assert_eq!(s_orig.as_ref().f1, 1);
+    assert_eq!(s_orig.as_ref().f2, 2);
+
+    let mut s = Struct { f1: 1, f2: 2 };
+    let mut s = Pin::new(&mut s);
+    {
+        let StructProj { f1, f2 } = s.as_mut().project();
+        let _: Pin<&mut i32> = f1;
+        let _: &mut i32 = f2;
+    }
+    {
+        let StructProjRef { f1, f2 } = s.as_ref().project_ref();
+        let _: Pin<&i32> = f1;
+        let _: &i32 = f2;
+    }
+
+    {
+        let StructProjReplace { f1: PhantomData, f2 } =
+            s.as_mut().project_replace(Struct::default());
+        assert_eq!(f2, 2);
+        let StructProj { f1, f2 } = s.project();
+        assert_eq!(*f1, 0);
+        assert_eq!(*f2, 0);
+    }
+
+    pin_project! {
+        #[project = EnumProj]
+        #[project_ref = EnumProjRef]
+        #[project_replace = EnumProjReplace]
+        #[derive(Eq, PartialEq, Debug)]
+        enum Enum<C, D> {
+            Struct {
+                #[pin]
+                f1: C,
+                f2: D,
+            },
+            Unit,
+        }
+    }
+
+    let mut e = Enum::Struct { f1: 1, f2: 2 };
+    let mut e = Pin::new(&mut e);
+
+    match e.as_mut().project() {
+        EnumProj::Struct { f1, f2 } => {
+            let _: Pin<&mut i32> = f1;
+            assert_eq!(*f1, 1);
+            let _: &mut i32 = f2;
+            assert_eq!(*f2, 2);
+        }
+        EnumProj::Unit => unreachable!(),
+    }
+
+    assert_eq!(&*e, &Enum::Struct { f1: 1, f2: 2 });
+
+    if let EnumProj::Struct { f1, f2 } = e.as_mut().project() {
+        let _: Pin<&mut i32> = f1;
+        assert_eq!(*f1, 1);
+        let _: &mut i32 = f2;
+        assert_eq!(*f2, 2);
+    }
+
+    if let EnumProjReplace::Struct { f1: PhantomData, f2 } = e.as_mut().project_replace(Enum::Unit)
+    {
+        assert_eq!(f2, 2);
+    }
+}
+
+#[test]
+fn enum_project_set() {
+    pin_project! {
+        #[project = EnumProj]
+        #[project_ref = EnumProjRef]
+        #[derive(Eq, PartialEq, Debug)]
+        enum Enum {
+            V1 { #[pin] f: u8 },
+            V2 { f: bool },
+        }
+    }
+
+    let mut e = Enum::V1 { f: 25 };
+    let mut e_orig = Pin::new(&mut e);
+    let e_proj = e_orig.as_mut().project();
+
+    match e_proj {
+        EnumProj::V1 { f } => {
+            let new_e = Enum::V2 { f: f.as_ref().get_ref() == &25 };
+            e_orig.set(new_e);
+        }
+        EnumProj::V2 { .. } => unreachable!(),
+    }
+
+    assert_eq!(e, Enum::V2 { f: true });
+}
+
+#[test]
+fn where_clause() {
+    pin_project! {
+        struct Struct<T>
+        where
+            T: Copy,
+        {
+            f: T,
+        }
+    }
+
+    pin_project! {
+        #[project = EnumProj]
+        #[project_ref = EnumProjRef]
+        enum Enum<T>
+        where
+            T: Copy,
+        {
+            V { f: T },
+        }
+    }
+}
+
+#[test]
+fn where_clause_and_associated_type_field() {
+    pin_project! {
+        struct Struct1<I>
+        where
+            I: Iterator,
+        {
+            #[pin]
+            f1: I,
+            f2: I::Item,
+        }
+    }
+
+    pin_project! {
+        struct Struct2<I, J>
+        where
+            I: Iterator<Item = J>,
+        {
+            #[pin]
+            f1: I,
+            f2: J,
+        }
+    }
+
+    pin_project! {
+        pub struct Struct3<T>
+        where
+            T: 'static,
+        {
+            f: T,
+        }
+    }
+
+    trait Static: 'static {}
+
+    impl<T> Static for Struct3<T> {}
+
+    pin_project! {
+        #[project = EnumProj]
+        #[project_ref = EnumProjRef]
+        enum Enum<I>
+        where
+            I: Iterator,
+        {
+            V1 { #[pin] f: I },
+            V2 { f: I::Item },
+        }
+    }
+}
+
+#[test]
+fn derive_copy() {
+    pin_project! {
+        #[derive(Clone, Copy)]
+        struct Struct<T> {
+            f: T,
+        }
+    }
+
+    fn is_copy<T: Copy>() {}
+
+    is_copy::<Struct<u8>>();
+}
+
+#[test]
+fn move_out() {
+    struct NotCopy;
+
+    pin_project! {
+        struct Struct {
+            f: NotCopy,
+        }
+    }
+
+    let x = Struct { f: NotCopy };
+    let _val: NotCopy = x.f;
+
+    pin_project! {
+        #[project = EnumProj]
+        #[project_ref = EnumProjRef]
+        enum Enum {
+            V { f: NotCopy },
+        }
+    }
+
+    let x = Enum::V { f: NotCopy };
+    #[allow(clippy::infallible_destructuring_match)]
+    let _val: NotCopy = match x {
+        Enum::V { f } => f,
+    };
+}
+
+#[test]
+fn trait_bounds_on_type_generics() {
+    pin_project! {
+        pub struct Struct1<'a, T: ?Sized> {
+            f: &'a mut T,
+        }
+    }
+
+    pin_project! {
+        pub struct Struct2<'a, T: ::core::fmt::Debug> {
+            f: &'a mut T,
+        }
+    }
+
+    pin_project! {
+        pub struct Struct3<'a, T: core::fmt::Debug> {
+            f: &'a mut T,
+        }
+    }
+
+    // pin_project! {
+    //     pub struct Struct4<'a, T: core::fmt::Debug + core::fmt::Display> {
+    //         f: &'a mut T,
+    //     }
+    // }
+
+    // pin_project! {
+    //     pub struct Struct5<'a, T: core::fmt::Debug + ?Sized> {
+    //         f: &'a mut T,
+    //     }
+    // }
+
+    pin_project! {
+        pub struct Struct6<'a, T: core::fmt::Debug = [u8; 16]> {
+            f: &'a mut T,
+        }
+    }
+
+    let _: Struct6<'_> = Struct6 { f: &mut [0_u8; 16] };
+
+    pin_project! {
+        pub struct Struct7<T: 'static> {
+            f: T,
+        }
+    }
+
+    trait Static: 'static {}
+
+    impl<T> Static for Struct7<T> {}
+
+    pin_project! {
+        pub struct Struct8<'a, 'b: 'a> {
+            f1: &'a u8,
+            f2: &'b u8,
+        }
+    }
+
+    pin_project! {
+        #[project = EnumProj]
+        #[project_ref = EnumProjRef]
+        enum Enum<'a, T: ?Sized> {
+            V { f: &'a mut T },
+        }
+    }
+}
+
+#[test]
+fn private_type_in_public_type() {
+    pin_project! {
+        pub struct PublicStruct<T> {
+            #[pin]
+            inner: PrivateStruct<T>,
+        }
+    }
+
+    struct PrivateStruct<T>(T);
+}
+
+#[allow(clippy::needless_lifetimes)]
+#[test]
+fn lifetime_project() {
+    pin_project! {
+        struct Struct1<T, U> {
+            #[pin]
+            pinned: T,
+            unpinned: U,
+        }
+    }
+
+    pin_project! {
+        struct Struct2<'a, T, U> {
+            #[pin]
+            pinned: &'a T,
+            unpinned: U,
+        }
+    }
+
+    pin_project! {
+        #[project = EnumProj]
+        #[project_ref = EnumProjRef]
+        enum Enum<T, U> {
+            V {
+                #[pin]
+                pinned: T,
+                unpinned: U,
+            },
+        }
+    }
+
+    impl<T, U> Struct1<T, U> {
+        fn get_pin_ref<'a>(self: Pin<&'a Self>) -> Pin<&'a T> {
+            self.project_ref().pinned
+        }
+        fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut T> {
+            self.project().pinned
+        }
+        fn get_pin_ref_elided(self: Pin<&Self>) -> Pin<&T> {
+            self.project_ref().pinned
+        }
+        fn get_pin_mut_elided(self: Pin<&mut Self>) -> Pin<&mut T> {
+            self.project().pinned
+        }
+    }
+
+    impl<'b, T, U> Struct2<'b, T, U> {
+        fn get_pin_ref<'a>(self: Pin<&'a Self>) -> Pin<&'a &'b T> {
+            self.project_ref().pinned
+        }
+        fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut &'b T> {
+            self.project().pinned
+        }
+        fn get_pin_ref_elided(self: Pin<&Self>) -> Pin<&&'b T> {
+            self.project_ref().pinned
+        }
+        fn get_pin_mut_elided(self: Pin<&mut Self>) -> Pin<&mut &'b T> {
+            self.project().pinned
+        }
+    }
+
+    impl<T, U> Enum<T, U> {
+        fn get_pin_ref<'a>(self: Pin<&'a Self>) -> Pin<&'a T> {
+            match self.project_ref() {
+                EnumProjRef::V { pinned, .. } => pinned,
+            }
+        }
+        fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut T> {
+            match self.project() {
+                EnumProj::V { pinned, .. } => pinned,
+            }
+        }
+        fn get_pin_ref_elided(self: Pin<&Self>) -> Pin<&T> {
+            match self.project_ref() {
+                EnumProjRef::V { pinned, .. } => pinned,
+            }
+        }
+        fn get_pin_mut_elided(self: Pin<&mut Self>) -> Pin<&mut T> {
+            match self.project() {
+                EnumProj::V { pinned, .. } => pinned,
+            }
+        }
+    }
+}
+
+mod visibility {
+    use pin_project_lite::pin_project;
+
+    pin_project! {
+        pub(crate) struct S {
+            pub f: u8,
+        }
+    }
+}
+
+#[test]
+fn visibility() {
+    let mut x = visibility::S { f: 0 };
+    let x = Pin::new(&mut x);
+    let y = x.as_ref().project_ref();
+    let _: &u8 = y.f;
+    let y = x.project();
+    let _: &mut u8 = y.f;
+}
+
+#[test]
+fn trivial_bounds() {
+    pin_project! {
+        pub struct NoGenerics {
+            #[pin]
+            f: PhantomPinned,
+        }
+    }
+
+    assert_not_unpin!(NoGenerics);
+}
+
+#[test]
+fn dst() {
+    pin_project! {
+        pub struct Struct1<T: ?Sized> {
+            f: T,
+        }
+    }
+
+    let mut x = Struct1 { f: 0_u8 };
+    let x: Pin<&mut Struct1<dyn core::fmt::Debug>> = Pin::new(&mut x as _);
+    let _: &mut (dyn core::fmt::Debug) = x.project().f;
+
+    pin_project! {
+        pub struct Struct2<T: ?Sized> {
+            #[pin]
+            f: T,
+        }
+    }
+
+    let mut x = Struct2 { f: 0_u8 };
+    let x: Pin<&mut Struct2<dyn core::fmt::Debug + Unpin>> = Pin::new(&mut x as _);
+    let _: Pin<&mut (dyn core::fmt::Debug + Unpin)> = x.project().f;
+
+    pin_project! {
+        struct Struct3<T>
+        where
+            T: ?Sized,
+        {
+            f: T,
+        }
+    }
+
+    pin_project! {
+        struct Struct4<T>
+        where
+            T: ?Sized,
+        {
+            #[pin]
+            f: T,
+        }
+    }
+
+    pin_project! {
+        struct Struct11<'a, T: ?Sized, U: ?Sized> {
+            f1: &'a mut T,
+            f2: U,
+        }
+    }
+}
+
+#[test]
+fn dyn_type() {
+    pin_project! {
+        struct Struct1 {
+            f: dyn core::fmt::Debug,
+        }
+    }
+
+    pin_project! {
+        struct Struct2 {
+            #[pin]
+            f: dyn core::fmt::Debug,
+        }
+    }
+
+    pin_project! {
+        struct Struct3 {
+            f: dyn core::fmt::Debug + Send,
+        }
+    }
+
+    pin_project! {
+        struct Struct4 {
+            #[pin]
+            f: dyn core::fmt::Debug + Send,
+        }
+    }
+}
+
+#[test]
+fn no_infer_outlives() {
+    trait Trait<X> {
+        type Y;
+    }
+
+    struct Struct1<A>(A);
+
+    impl<X, T> Trait<X> for Struct1<T> {
+        type Y = Option<T>;
+    }
+
+    pin_project! {
+        struct Struct2<A, B> {
+            _f: <Struct1<A> as Trait<B>>::Y,
+        }
+    }
+}
+
+// https://github.com/taiki-e/pin-project-lite/issues/31
+#[test]
+fn trailing_comma() {
+    pub trait T {}
+
+    pin_project! {
+        pub struct S1<
+            A: T,
+            B: T,
+        > {
+            f: (A, B),
+        }
+    }
+
+    pin_project! {
+        pub struct S2<
+            A,
+            B,
+        >
+        where
+            A: T,
+            B: T,
+        {
+            f: (A, B),
+        }
+    }
+
+    pin_project! {
+        #[allow(explicit_outlives_requirements)]
+        pub struct S3<
+            'a,
+            A: 'a,
+            B: 'a,
+        > {
+            f: &'a (A, B),
+        }
+    }
+
+    // pin_project! {
+    //     pub struct S4<
+    //         'a,
+    //         'b: 'a, // <-----
+    //     > {
+    //         f: &'a &'b (),
+    //     }
+    // }
+}
+
+#[test]
+fn attrs() {
+    pin_project! {
+        /// dox1
+        #[derive(Clone)]
+        #[project = StructProj]
+        #[project_ref = StructProjRef]
+        /// dox2
+        #[derive(Debug)]
+        /// dox3
+        struct Struct {
+            // TODO
+            // /// dox4
+            f: ()
+        }
+    }
+
+    pin_project! {
+        #[project = Enum1Proj]
+        #[project_ref = Enum1ProjRef]
+        enum Enum1 {
+            #[cfg(not(any()))]
+            V {
+                f: ()
+            },
+        }
+    }
+
+    pin_project! {
+        /// dox1
+        #[derive(Clone)]
+        #[project(!Unpin)]
+        #[project = Enum2Proj]
+        #[project_ref = Enum2ProjRef]
+        /// dox2
+        #[derive(Debug)]
+        /// dox3
+        enum Enum2 {
+            /// dox4
+            V1 {
+                // TODO
+                // /// dox5
+                f: ()
+            },
+            /// dox6
+            V2,
+        }
+    }
+}
+
+#[test]
+fn pinned_drop() {
+    pin_project! {
+        pub struct Struct1<'a> {
+            was_dropped: &'a mut bool,
+            #[pin]
+            field: u8,
+        }
+        impl PinnedDrop for Struct1<'_> {
+            fn drop(this: Pin<&mut Self>) {
+                **this.project().was_dropped = true;
+            }
+        }
+    }
+
+    let mut was_dropped = false;
+    drop(Struct1 { was_dropped: &mut was_dropped, field: 42 });
+    assert!(was_dropped);
+
+    pin_project! {
+        pub struct Struct2<'a> {
+            was_dropped: &'a mut bool,
+            #[pin]
+            field: u8,
+        }
+        impl PinnedDrop for Struct2<'_> {
+            fn drop(mut this: Pin<&mut Self>) {
+                **this.as_mut().project().was_dropped = true;
+            }
+        }
+    }
+
+    trait Service<Request> {
+        type Error;
+    }
+
+    pin_project! {
+        struct Struct3<'a, T, Request>
+        where
+            T: Service<Request>,
+            T::Error: std::error::Error,
+        {
+            was_dropped: &'a mut bool,
+            #[pin]
+            field: T,
+            req: Request,
+        }
+
+        /// dox1
+        impl<T, Request> PinnedDrop for Struct3<'_, T, Request>
+        where
+            T: Service<Request>,
+            T::Error: std::error::Error,
+        {
+            /// dox2
+            fn drop(mut this: Pin<&mut Self>) {
+                **this.as_mut().project().was_dropped = true;
+            }
+        }
+    }
+}
diff --git a/crates/pin-project-lite/tests/ui/pin_project/conflict-drop.rs b/crates/pin-project-lite/tests/ui/pin_project/conflict-drop.rs
new file mode 100644
index 0000000..870059d
--- /dev/null
+++ b/crates/pin-project-lite/tests/ui/pin_project/conflict-drop.rs
@@ -0,0 +1,15 @@
+use pin_project_lite::pin_project;
+
+pin_project! { //~ ERROR E0119
+    struct Foo<T, U> {
+        #[pin]
+        future: T,
+        field: U,
+    }
+}
+
+impl<T, U> Drop for Foo<T, U> {
+    fn drop(&mut self) {}
+}
+
+fn main() {}
diff --git a/crates/pin-project-lite/tests/ui/pin_project/conflict-drop.stderr b/crates/pin-project-lite/tests/ui/pin_project/conflict-drop.stderr
new file mode 100644
index 0000000..8c870d7
--- /dev/null
+++ b/crates/pin-project-lite/tests/ui/pin_project/conflict-drop.stderr
@@ -0,0 +1,16 @@
+error[E0119]: conflicting implementations of trait `MustNotImplDrop` for type `Foo<_, _>`
+ --> tests/ui/pin_project/conflict-drop.rs:3:1
+  |
+3 | / pin_project! { //~ ERROR E0119
+4 | |     struct Foo<T, U> {
+5 | |         #[pin]
+6 | |         future: T,
+7 | |         field: U,
+8 | |     }
+9 | | }
+  | | ^
+  | | |
+  | |_first implementation here
+  |   conflicting implementation for `Foo<_, _>`
+  |
+  = note: this error originates in the macro `$crate::__pin_project_make_drop_impl` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/crates/pin-project-lite/tests/ui/pin_project/conflict-unpin.rs b/crates/pin-project-lite/tests/ui/pin_project/conflict-unpin.rs
new file mode 100644
index 0000000..bdab20f
--- /dev/null
+++ b/crates/pin-project-lite/tests/ui/pin_project/conflict-unpin.rs
@@ -0,0 +1,64 @@
+use pin_project_lite::pin_project;
+
+// The same implementation.
+
+pin_project! { //~ ERROR E0119
+    struct Foo<T, U> {
+        #[pin]
+        future: T,
+        field: U,
+    }
+}
+
+// conflicting implementations
+impl<T, U> Unpin for Foo<T, U> where T: Unpin {} // Conditional Unpin impl
+
+// The implementation that under different conditions.
+
+pin_project! { //~ ERROR E0119
+    struct Bar<T, U> {
+        #[pin]
+        future: T,
+        field: U,
+    }
+}
+
+// conflicting implementations
+impl<T, U> Unpin for Bar<T, U> {} // Non-conditional Unpin impl
+
+pin_project! { //~ ERROR E0119
+    struct Baz<T, U> {
+        #[pin]
+        future: T,
+        field: U,
+    }
+}
+
+// conflicting implementations
+impl<T: Unpin, U: Unpin> Unpin for Baz<T, U> {} // Conditional Unpin impl
+
+pin_project! { //~ ERROR E0119
+    #[project(!Unpin)]
+    struct Qux<T, U> {
+        #[pin]
+        future: T,
+        field: U,
+    }
+}
+
+// conflicting implementations
+impl<T, U> Unpin for Qux<T, U> {} // Non-conditional Unpin impl
+
+pin_project! { //~ ERROR E0119
+    #[project(!Unpin)]
+    struct Fred<T, U> {
+        #[pin]
+        future: T,
+        field: U,
+    }
+}
+
+// conflicting implementations
+impl<T: Unpin, U: Unpin> Unpin for Fred<T, U> {} // Conditional Unpin impl
+
+fn main() {}
diff --git a/crates/pin-project-lite/tests/ui/pin_project/conflict-unpin.stderr b/crates/pin-project-lite/tests/ui/pin_project/conflict-unpin.stderr
new file mode 100644
index 0000000..cf9818e
--- /dev/null
+++ b/crates/pin-project-lite/tests/ui/pin_project/conflict-unpin.stderr
@@ -0,0 +1,84 @@
+error[E0119]: conflicting implementations of trait `Unpin` for type `Foo<_, _>`
+  --> tests/ui/pin_project/conflict-unpin.rs:5:1
+   |
+5  | / pin_project! { //~ ERROR E0119
+6  | |     struct Foo<T, U> {
+7  | |         #[pin]
+8  | |         future: T,
+9  | |         field: U,
+10 | |     }
+11 | | }
+   | |_^ conflicting implementation for `Foo<_, _>`
+...
+14 |   impl<T, U> Unpin for Foo<T, U> where T: Unpin {} // Conditional Unpin impl
+   |   ------------------------------ first implementation here
+   |
+   = note: this error originates in the macro `$crate::__pin_project_make_unpin_impl` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0119]: conflicting implementations of trait `Unpin` for type `Bar<_, _>`
+  --> tests/ui/pin_project/conflict-unpin.rs:18:1
+   |
+18 | / pin_project! { //~ ERROR E0119
+19 | |     struct Bar<T, U> {
+20 | |         #[pin]
+21 | |         future: T,
+22 | |         field: U,
+23 | |     }
+24 | | }
+   | |_^ conflicting implementation for `Bar<_, _>`
+...
+27 |   impl<T, U> Unpin for Bar<T, U> {} // Non-conditional Unpin impl
+   |   ------------------------------ first implementation here
+   |
+   = note: this error originates in the macro `$crate::__pin_project_make_unpin_impl` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0119]: conflicting implementations of trait `Unpin` for type `Baz<_, _>`
+  --> tests/ui/pin_project/conflict-unpin.rs:29:1
+   |
+29 | / pin_project! { //~ ERROR E0119
+30 | |     struct Baz<T, U> {
+31 | |         #[pin]
+32 | |         future: T,
+33 | |         field: U,
+34 | |     }
+35 | | }
+   | |_^ conflicting implementation for `Baz<_, _>`
+...
+38 |   impl<T: Unpin, U: Unpin> Unpin for Baz<T, U> {} // Conditional Unpin impl
+   |   -------------------------------------------- first implementation here
+   |
+   = note: this error originates in the macro `$crate::__pin_project_make_unpin_impl` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0119]: conflicting implementations of trait `Unpin` for type `Qux<_, _>`
+  --> tests/ui/pin_project/conflict-unpin.rs:40:1
+   |
+40 | / pin_project! { //~ ERROR E0119
+41 | |     #[project(!Unpin)]
+42 | |     struct Qux<T, U> {
+43 | |         #[pin]
+...  |
+46 | |     }
+47 | | }
+   | |_^ conflicting implementation for `Qux<_, _>`
+...
+50 |   impl<T, U> Unpin for Qux<T, U> {} // Non-conditional Unpin impl
+   |   ------------------------------ first implementation here
+   |
+   = note: this error originates in the macro `$crate::__pin_project_make_unpin_impl` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0119]: conflicting implementations of trait `Unpin` for type `Fred<_, _>`
+  --> tests/ui/pin_project/conflict-unpin.rs:52:1
+   |
+52 | / pin_project! { //~ ERROR E0119
+53 | |     #[project(!Unpin)]
+54 | |     struct Fred<T, U> {
+55 | |         #[pin]
+...  |
+58 | |     }
+59 | | }
+   | |_^ conflicting implementation for `Fred<_, _>`
+...
+62 |   impl<T: Unpin, U: Unpin> Unpin for Fred<T, U> {} // Conditional Unpin impl
+   |   --------------------------------------------- first implementation here
+   |
+   = note: this error originates in the macro `$crate::__pin_project_make_unpin_impl` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/crates/pin-project-lite/tests/ui/pin_project/invalid-bounds.rs b/crates/pin-project-lite/tests/ui/pin_project/invalid-bounds.rs
new file mode 100644
index 0000000..64b397a
--- /dev/null
+++ b/crates/pin-project-lite/tests/ui/pin_project/invalid-bounds.rs
@@ -0,0 +1,93 @@
+use pin_project_lite::pin_project;
+
+pin_project! {
+    struct Generics1<T: 'static : Sized> { //~ ERROR no rules expected the token `:`
+        field: T,
+    }
+}
+
+pin_project! {
+    struct Generics2<T: 'static : ?Sized> { //~ ERROR no rules expected the token `:`
+        field: T,
+    }
+}
+
+pin_project! {
+    struct Generics3<T: Sized : 'static> { //~ ERROR expected one of `+`, `,`, `=`, or `>`, found `:`
+        field: T,
+    }
+}
+
+pin_project! {
+    struct Generics4<T: ?Sized : 'static> { //~ ERROR expected one of `+`, `,`, `=`, or `>`, found `:`
+        field: T,
+    }
+}
+
+pin_project! {
+    struct Generics5<T: Sized : ?Sized> { //~ ERROR expected one of `+`, `,`, `=`, or `>`, found `:`
+        field: T,
+    }
+}
+
+pin_project! {
+    struct Generics6<T: ?Sized : Sized> { //~ ERROR no rules expected the token `Sized`
+        field: T,
+    }
+}
+
+pin_project! {
+    struct WhereClause1<T>
+    where
+        T: 'static : Sized //~ ERROR no rules expected the token `:`
+    {
+        field: T,
+    }
+}
+
+pin_project! {
+    struct WhereClause2<T>
+    where
+        T: 'static : ?Sized //~ ERROR no rules expected the token `:`
+    {
+        field: T,
+    }
+}
+
+pin_project! {
+    struct WhereClause3<T>
+    where
+        T: Sized : 'static //~ ERROR expected `where`, or `{` after struct name, found `:`
+    {
+        field: T,
+    }
+}
+
+pin_project! {
+    struct WhereClause4<T>
+    where
+        T: ?Sized : 'static //~ ERROR expected `where`, or `{` after struct name, found `:`
+    {
+        field: T,
+    }
+}
+
+pin_project! {
+    struct WhereClause5<T>
+    where
+        T: Sized : ?Sized //~ ERROR expected `where`, or `{` after struct name, found `:`
+    {
+        field: T,
+    }
+}
+
+pin_project! {
+    struct WhereClause6<T>
+    where
+        T: ?Sized : Sized //~ ERROR no rules expected the token `Sized`
+    {
+        field: T,
+    }
+}
+
+fn main() {}
diff --git a/crates/pin-project-lite/tests/ui/pin_project/invalid-bounds.stderr b/crates/pin-project-lite/tests/ui/pin_project/invalid-bounds.stderr
new file mode 100644
index 0000000..ae15b7a
--- /dev/null
+++ b/crates/pin-project-lite/tests/ui/pin_project/invalid-bounds.stderr
@@ -0,0 +1,470 @@
+error: no rules expected the token `:`
+ --> tests/ui/pin_project/invalid-bounds.rs:4:33
+  |
+4 |     struct Generics1<T: 'static : Sized> { //~ ERROR no rules expected the token `:`
+  |                                 ^ no rules expected this token in macro call
+  |
+note: while trying to match `>`
+ --> src/lib.rs
+  |
+  |         >)?
+  |         ^
+
+error: no rules expected the token `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:10:33
+   |
+10 |     struct Generics2<T: 'static : ?Sized> { //~ ERROR no rules expected the token `:`
+   |                                 ^ no rules expected this token in macro call
+   |
+note: while trying to match `>`
+  --> src/lib.rs
+   |
+   |         >)?
+   |         ^
+
+error: expected one of `+`, `,`, `=`, or `>`, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:15:1
+   |
+15 | / pin_project! {
+16 | |     struct Generics3<T: Sized : 'static> { //~ ERROR expected one of `+`, `,`, `=`, or `>`, found `:`
+17 | |         field: T,
+18 | |     }
+19 | | }
+   | | ^
+   | | |
+   | | expected one of `+`, `,`, `=`, or `>`
+   | |_unexpected token
+   |   in this macro invocation
+   |
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected one of `+`, `,`, `=`, or `>`, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:15:1
+   |
+15 | / pin_project! {
+16 | |     struct Generics3<T: Sized : 'static> { //~ ERROR expected one of `+`, `,`, `=`, or `>`, found `:`
+17 | |         field: T,
+18 | |     }
+19 | | }
+   | | ^
+   | | |
+   | |_expected one of `+`, `,`, `=`, or `>`
+   |   unexpected token
+   |
+   = note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected one of `+`, `,`, `=`, or `>`, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:15:1
+   |
+15 | / pin_project! {
+16 | |     struct Generics3<T: Sized : 'static> { //~ ERROR expected one of `+`, `,`, `=`, or `>`, found `:`
+17 | |         field: T,
+18 | |     }
+19 | | }
+   | | ^
+   | | |
+   | | expected one of `+`, `,`, `=`, or `>`
+   | |_unexpected token
+   |   in this macro invocation
+   |
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected one of `+`, `,`, `=`, or `>`, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:15:1
+   |
+15 | / pin_project! {
+16 | |     struct Generics3<T: Sized : 'static> { //~ ERROR expected one of `+`, `,`, `=`, or `>`, found `:`
+17 | |         field: T,
+18 | |     }
+19 | | }
+   | | ^
+   | | |
+   | | expected one of `+`, `,`, `=`, or `>`
+   | |_unexpected token
+   |   in this macro invocation
+   |
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected one of `+`, `,`, `=`, or `>`, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:21:1
+   |
+21 | / pin_project! {
+22 | |     struct Generics4<T: ?Sized : 'static> { //~ ERROR expected one of `+`, `,`, `=`, or `>`, found `:`
+23 | |         field: T,
+24 | |     }
+25 | | }
+   | | ^
+   | | |
+   | | expected one of `+`, `,`, `=`, or `>`
+   | |_unexpected token
+   |   in this macro invocation
+   |
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected one of `+`, `,`, `=`, or `>`, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:21:1
+   |
+21 | / pin_project! {
+22 | |     struct Generics4<T: ?Sized : 'static> { //~ ERROR expected one of `+`, `,`, `=`, or `>`, found `:`
+23 | |         field: T,
+24 | |     }
+25 | | }
+   | | ^
+   | | |
+   | |_expected one of `+`, `,`, `=`, or `>`
+   |   unexpected token
+   |
+   = note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected one of `+`, `,`, `=`, or `>`, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:21:1
+   |
+21 | / pin_project! {
+22 | |     struct Generics4<T: ?Sized : 'static> { //~ ERROR expected one of `+`, `,`, `=`, or `>`, found `:`
+23 | |         field: T,
+24 | |     }
+25 | | }
+   | | ^
+   | | |
+   | | expected one of `+`, `,`, `=`, or `>`
+   | |_unexpected token
+   |   in this macro invocation
+   |
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected one of `+`, `,`, `=`, or `>`, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:21:1
+   |
+21 | / pin_project! {
+22 | |     struct Generics4<T: ?Sized : 'static> { //~ ERROR expected one of `+`, `,`, `=`, or `>`, found `:`
+23 | |         field: T,
+24 | |     }
+25 | | }
+   | | ^
+   | | |
+   | | expected one of `+`, `,`, `=`, or `>`
+   | |_unexpected token
+   |   in this macro invocation
+   |
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected one of `+`, `,`, `=`, or `>`, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:27:1
+   |
+27 | / pin_project! {
+28 | |     struct Generics5<T: Sized : ?Sized> { //~ ERROR expected one of `+`, `,`, `=`, or `>`, found `:`
+29 | |         field: T,
+30 | |     }
+31 | | }
+   | | ^
+   | | |
+   | | expected one of `+`, `,`, `=`, or `>`
+   | |_unexpected token
+   |   in this macro invocation
+   |
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected one of `+`, `,`, `=`, or `>`, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:27:1
+   |
+27 | / pin_project! {
+28 | |     struct Generics5<T: Sized : ?Sized> { //~ ERROR expected one of `+`, `,`, `=`, or `>`, found `:`
+29 | |         field: T,
+30 | |     }
+31 | | }
+   | | ^
+   | | |
+   | |_expected one of `+`, `,`, `=`, or `>`
+   |   unexpected token
+   |
+   = note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected one of `+`, `,`, `=`, or `>`, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:27:1
+   |
+27 | / pin_project! {
+28 | |     struct Generics5<T: Sized : ?Sized> { //~ ERROR expected one of `+`, `,`, `=`, or `>`, found `:`
+29 | |         field: T,
+30 | |     }
+31 | | }
+   | | ^
+   | | |
+   | | expected one of `+`, `,`, `=`, or `>`
+   | |_unexpected token
+   |   in this macro invocation
+   |
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected one of `+`, `,`, `=`, or `>`, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:27:1
+   |
+27 | / pin_project! {
+28 | |     struct Generics5<T: Sized : ?Sized> { //~ ERROR expected one of `+`, `,`, `=`, or `>`, found `:`
+29 | |         field: T,
+30 | |     }
+31 | | }
+   | | ^
+   | | |
+   | | expected one of `+`, `,`, `=`, or `>`
+   | |_unexpected token
+   |   in this macro invocation
+   |
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: no rules expected the token `Sized`
+  --> tests/ui/pin_project/invalid-bounds.rs:34:34
+   |
+34 |     struct Generics6<T: ?Sized : Sized> { //~ ERROR no rules expected the token `Sized`
+   |                                  ^^^^^ no rules expected this token in macro call
+   |
+note: while trying to match meta-variable `$generics_lifetime_bound:lifetime`
+  --> src/lib.rs
+   |
+   |                 $(: $generics_lifetime_bound:lifetime)?
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: no rules expected the token `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:42:20
+   |
+42 |         T: 'static : Sized //~ ERROR no rules expected the token `:`
+   |                    ^ no rules expected this token in macro call
+   |
+note: while trying to match `{`
+  --> src/lib.rs
+   |
+   |         {
+   |         ^
+
+error: no rules expected the token `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:51:20
+   |
+51 |         T: 'static : ?Sized //~ ERROR no rules expected the token `:`
+   |                    ^ no rules expected this token in macro call
+   |
+note: while trying to match `{`
+  --> src/lib.rs
+   |
+   |         {
+   |         ^
+
+error: expected `{` after struct name, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:57:1
+   |
+57 | / pin_project! {
+58 | |     struct WhereClause3<T>
+59 | |     where
+60 | |         T: Sized : 'static //~ ERROR expected `where`, or `{` after struct name, found `:`
+...  |
+63 | |     }
+64 | | }
+   | | ^
+   | | |
+   | |_expected `{` after struct name
+   |   in this macro invocation
+   |
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected one of `+`, `,`, or `{`, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:57:1
+   |
+57 | / pin_project! {
+58 | |     struct WhereClause3<T>
+59 | |     where
+60 | |         T: Sized : 'static //~ ERROR expected `where`, or `{` after struct name, found `:`
+...  |
+63 | |     }
+64 | | }
+   | | ^
+   | | |
+   | |_expected one of `+`, `,`, or `{`
+   |   unexpected token
+   |
+   = note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected `{` after struct name, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:57:1
+   |
+57 | / pin_project! {
+58 | |     struct WhereClause3<T>
+59 | |     where
+60 | |         T: Sized : 'static //~ ERROR expected `where`, or `{` after struct name, found `:`
+...  |
+63 | |     }
+64 | | }
+   | | ^
+   | | |
+   | |_expected `{` after struct name
+   |   in this macro invocation
+   |
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected `{` after struct name, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:57:1
+   |
+57 | / pin_project! {
+58 | |     struct WhereClause3<T>
+59 | |     where
+60 | |         T: Sized : 'static //~ ERROR expected `where`, or `{` after struct name, found `:`
+...  |
+63 | |     }
+64 | | }
+   | | ^
+   | | |
+   | |_expected `{` after struct name
+   |   in this macro invocation
+   |
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected `{` after struct name, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:66:1
+   |
+66 | / pin_project! {
+67 | |     struct WhereClause4<T>
+68 | |     where
+69 | |         T: ?Sized : 'static //~ ERROR expected `where`, or `{` after struct name, found `:`
+...  |
+72 | |     }
+73 | | }
+   | | ^
+   | | |
+   | |_expected `{` after struct name
+   |   in this macro invocation
+   |
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected one of `+`, `,`, or `{`, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:66:1
+   |
+66 | / pin_project! {
+67 | |     struct WhereClause4<T>
+68 | |     where
+69 | |         T: ?Sized : 'static //~ ERROR expected `where`, or `{` after struct name, found `:`
+...  |
+72 | |     }
+73 | | }
+   | | ^
+   | | |
+   | |_expected one of `+`, `,`, or `{`
+   |   unexpected token
+   |
+   = note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected `{` after struct name, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:66:1
+   |
+66 | / pin_project! {
+67 | |     struct WhereClause4<T>
+68 | |     where
+69 | |         T: ?Sized : 'static //~ ERROR expected `where`, or `{` after struct name, found `:`
+...  |
+72 | |     }
+73 | | }
+   | | ^
+   | | |
+   | |_expected `{` after struct name
+   |   in this macro invocation
+   |
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected `{` after struct name, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:66:1
+   |
+66 | / pin_project! {
+67 | |     struct WhereClause4<T>
+68 | |     where
+69 | |         T: ?Sized : 'static //~ ERROR expected `where`, or `{` after struct name, found `:`
+...  |
+72 | |     }
+73 | | }
+   | | ^
+   | | |
+   | |_expected `{` after struct name
+   |   in this macro invocation
+   |
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected `{` after struct name, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:75:1
+   |
+75 | / pin_project! {
+76 | |     struct WhereClause5<T>
+77 | |     where
+78 | |         T: Sized : ?Sized //~ ERROR expected `where`, or `{` after struct name, found `:`
+...  |
+81 | |     }
+82 | | }
+   | | ^
+   | | |
+   | |_expected `{` after struct name
+   |   in this macro invocation
+   |
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected one of `+`, `,`, or `{`, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:75:1
+   |
+75 | / pin_project! {
+76 | |     struct WhereClause5<T>
+77 | |     where
+78 | |         T: Sized : ?Sized //~ ERROR expected `where`, or `{` after struct name, found `:`
+...  |
+81 | |     }
+82 | | }
+   | | ^
+   | | |
+   | |_expected one of `+`, `,`, or `{`
+   |   unexpected token
+   |
+   = note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected `{` after struct name, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:75:1
+   |
+75 | / pin_project! {
+76 | |     struct WhereClause5<T>
+77 | |     where
+78 | |         T: Sized : ?Sized //~ ERROR expected `where`, or `{` after struct name, found `:`
+...  |
+81 | |     }
+82 | | }
+   | | ^
+   | | |
+   | |_expected `{` after struct name
+   |   in this macro invocation
+   |
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected `{` after struct name, found `:`
+  --> tests/ui/pin_project/invalid-bounds.rs:75:1
+   |
+75 | / pin_project! {
+76 | |     struct WhereClause5<T>
+77 | |     where
+78 | |         T: Sized : ?Sized //~ ERROR expected `where`, or `{` after struct name, found `:`
+...  |
+81 | |     }
+82 | | }
+   | | ^
+   | | |
+   | |_expected `{` after struct name
+   |   in this macro invocation
+   |
+   = note: this error originates in the macro `$crate::__pin_project_parse_generics` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: no rules expected the token `Sized`
+  --> tests/ui/pin_project/invalid-bounds.rs:87:21
+   |
+87 |         T: ?Sized : Sized //~ ERROR no rules expected the token `Sized`
+   |                     ^^^^^ no rules expected this token in macro call
+   |
+note: while trying to match meta-variable `$where_clause_lifetime_bound:lifetime`
+  --> src/lib.rs
+   |
+   |                 $(: $where_clause_lifetime_bound:lifetime)?
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/crates/pin-project-lite/tests/ui/pin_project/invalid.rs b/crates/pin-project-lite/tests/ui/pin_project/invalid.rs
new file mode 100644
index 0000000..e0ea61d
--- /dev/null
+++ b/crates/pin-project-lite/tests/ui/pin_project/invalid.rs
@@ -0,0 +1,25 @@
+use pin_project_lite::pin_project;
+
+pin_project! {
+    struct A<T> {
+        #[pin()] //~ ERROR no rules expected the token `(`
+        pinned: T,
+    }
+}
+
+pin_project! {
+    #[pin] //~ ERROR cannot find attribute `pin` in this scope
+    struct B<T> {
+        pinned: T,
+    }
+}
+
+pin_project! {
+    struct C<T> {
+        #[pin]
+        #[pin] //~ ERROR no rules expected the token `#`
+        pinned: T,
+    }
+}
+
+fn main() {}
diff --git a/crates/pin-project-lite/tests/ui/pin_project/invalid.stderr b/crates/pin-project-lite/tests/ui/pin_project/invalid.stderr
new file mode 100644
index 0000000..5d2e305
--- /dev/null
+++ b/crates/pin-project-lite/tests/ui/pin_project/invalid.stderr
@@ -0,0 +1,53 @@
+error: no rules expected the token `(`
+ --> tests/ui/pin_project/invalid.rs:5:14
+  |
+5 |         #[pin()] //~ ERROR no rules expected the token `(`
+  |              ^ no rules expected this token in macro call
+  |
+note: while trying to match `]`
+ --> src/lib.rs
+  |
+  |                 $(#[$pin:ident])?
+  |                               ^
+
+error: no rules expected the token `(`
+ --> tests/ui/pin_project/invalid.rs:5:14
+  |
+5 |         #[pin()] //~ ERROR no rules expected the token `(`
+  |              ^ no rules expected this token in macro call
+  |
+note: while trying to match `]`
+ --> src/lib.rs
+  |
+  |                 $(#[$pin:ident])?
+  |                               ^
+
+error: no rules expected the token `#`
+  --> tests/ui/pin_project/invalid.rs:20:9
+   |
+20 |         #[pin] //~ ERROR no rules expected the token `#`
+   |         ^ no rules expected this token in macro call
+   |
+note: while trying to match meta-variable `$field_vis:vis`
+  --> src/lib.rs
+   |
+   |                 $field_vis:vis $field:ident: $field_ty:ty
+   |                 ^^^^^^^^^^^^^^
+
+error: no rules expected the token `#`
+  --> tests/ui/pin_project/invalid.rs:20:9
+   |
+20 |         #[pin] //~ ERROR no rules expected the token `#`
+   |         ^ no rules expected this token in macro call
+   |
+note: while trying to match meta-variable `$field_vis:vis`
+  --> src/lib.rs
+   |
+   |                 $field_vis:vis $field:ident: $field_ty:ty
+   |                 ^^^^^^^^^^^^^^
+
+error: cannot find attribute `pin` in this scope
+  --> tests/ui/pin_project/invalid.rs:11:7
+   |
+11 |     #[pin] //~ ERROR cannot find attribute `pin` in this scope
+   |       ^^^
diff --git a/crates/pin-project-lite/tests/ui/pin_project/overlapping_lifetime_names.rs b/crates/pin-project-lite/tests/ui/pin_project/overlapping_lifetime_names.rs
new file mode 100644
index 0000000..117c18d
--- /dev/null
+++ b/crates/pin-project-lite/tests/ui/pin_project/overlapping_lifetime_names.rs
@@ -0,0 +1,10 @@
+use pin_project_lite::pin_project;
+
+pin_project! { //~ ERROR E0263,E0496
+    pub struct Foo<'__pin, T> {
+        #[pin]
+        field: &'__pin mut T,
+    }
+}
+
+fn main() {}
diff --git a/crates/pin-project-lite/tests/ui/pin_project/overlapping_lifetime_names.stderr b/crates/pin-project-lite/tests/ui/pin_project/overlapping_lifetime_names.stderr
new file mode 100644
index 0000000..cfdffb2
--- /dev/null
+++ b/crates/pin-project-lite/tests/ui/pin_project/overlapping_lifetime_names.stderr
@@ -0,0 +1,75 @@
+error[E0403]: the name `'__pin` is already used for a generic parameter in this item's generic parameters
+ --> tests/ui/pin_project/overlapping_lifetime_names.rs:4:20
+  |
+3 | / pin_project! { //~ ERROR E0263,E0496
+4 | |     pub struct Foo<'__pin, T> {
+  | |                    ^^^^^^ already used
+5 | |         #[pin]
+6 | |         field: &'__pin mut T,
+7 | |     }
+8 | | }
+  | |_- first use of `'__pin`
+
+error[E0403]: the name `'__pin` is already used for a generic parameter in this item's generic parameters
+ --> tests/ui/pin_project/overlapping_lifetime_names.rs:4:20
+  |
+3 | / pin_project! { //~ ERROR E0263,E0496
+4 | |     pub struct Foo<'__pin, T> {
+  | |                    ^^^^^^ already used
+5 | |         #[pin]
+6 | |         field: &'__pin mut T,
+7 | |     }
+8 | | }
+  | |_- first use of `'__pin`
+
+error[E0496]: lifetime name `'__pin` shadows a lifetime name that is already in scope
+ --> tests/ui/pin_project/overlapping_lifetime_names.rs:3:1
+  |
+3 | / pin_project! { //~ ERROR E0263,E0496
+4 | |     pub struct Foo<'__pin, T> {
+  | |                    ------ first declared here
+5 | |         #[pin]
+6 | |         field: &'__pin mut T,
+7 | |     }
+8 | | }
+  | |_^ lifetime `'__pin` already in scope
+  |
+  = note: this error originates in the macro `$crate::__pin_project_struct_make_proj_method` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0496]: lifetime name `'__pin` shadows a lifetime name that is already in scope
+ --> tests/ui/pin_project/overlapping_lifetime_names.rs:3:1
+  |
+3 | / pin_project! { //~ ERROR E0263,E0496
+4 | |     pub struct Foo<'__pin, T> {
+  | |                    ------ first declared here
+5 | |         #[pin]
+6 | |         field: &'__pin mut T,
+7 | |     }
+8 | | }
+  | |_^ lifetime `'__pin` already in scope
+  |
+  = note: this error originates in the macro `$crate::__pin_project_struct_make_proj_method` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0403]: the name `'__pin` is already used for a generic parameter in this item's generic parameters
+ --> tests/ui/pin_project/overlapping_lifetime_names.rs:4:20
+  |
+3 | / pin_project! { //~ ERROR E0263,E0496
+4 | |     pub struct Foo<'__pin, T> {
+  | |                    ^^^^^^ already used
+5 | |         #[pin]
+6 | |         field: &'__pin mut T,
+7 | |     }
+8 | | }
+  | |_- first use of `'__pin`
+
+error[E0403]: the name `'__pin` is already used for a generic parameter in this item's generic parameters
+ --> tests/ui/pin_project/overlapping_lifetime_names.rs:4:20
+  |
+3 | / pin_project! { //~ ERROR E0263,E0496
+4 | |     pub struct Foo<'__pin, T> {
+  | |                    ^^^^^^ already used
+5 | |         #[pin]
+6 | |         field: &'__pin mut T,
+7 | |     }
+8 | | }
+  | |_- first use of `'__pin`
diff --git a/crates/pin-project-lite/tests/ui/pin_project/overlapping_unpin_struct.rs b/crates/pin-project-lite/tests/ui/pin_project/overlapping_unpin_struct.rs
new file mode 100644
index 0000000..25131d1
--- /dev/null
+++ b/crates/pin-project-lite/tests/ui/pin_project/overlapping_unpin_struct.rs
@@ -0,0 +1,20 @@
+use std::marker::PhantomPinned;
+
+use pin_project_lite::pin_project;
+
+pin_project! {
+    struct Foo<T> {
+        #[pin]
+        inner: T,
+    }
+}
+
+struct __Origin {}
+
+impl Unpin for __Origin {}
+
+fn is_unpin<T: Unpin>() {}
+
+fn main() {
+    is_unpin::<Foo<PhantomPinned>>(); //~ ERROR E0277
+}
diff --git a/crates/pin-project-lite/tests/ui/pin_project/overlapping_unpin_struct.stderr b/crates/pin-project-lite/tests/ui/pin_project/overlapping_unpin_struct.stderr
new file mode 100644
index 0000000..fd7d64f
--- /dev/null
+++ b/crates/pin-project-lite/tests/ui/pin_project/overlapping_unpin_struct.stderr
@@ -0,0 +1,34 @@
+error[E0277]: `PhantomPinned` cannot be unpinned
+  --> tests/ui/pin_project/overlapping_unpin_struct.rs:19:16
+   |
+19 |     is_unpin::<Foo<PhantomPinned>>(); //~ ERROR E0277
+   |                ^^^^^^^^^^^^^^^^^^ within `_::__Origin<'_, PhantomPinned>`, the trait `Unpin` is not implemented for `PhantomPinned`
+   |
+   = note: consider using the `pin!` macro
+           consider using `Box::pin` if you need to access the pinned value outside of the current scope
+note: required because it appears within the type `__Origin<'_, PhantomPinned>`
+  --> tests/ui/pin_project/overlapping_unpin_struct.rs:5:1
+   |
+5  | / pin_project! {
+6  | |     struct Foo<T> {
+7  | |         #[pin]
+8  | |         inner: T,
+9  | |     }
+10 | | }
+   | |_^
+note: required for `Foo<PhantomPinned>` to implement `Unpin`
+  --> tests/ui/pin_project/overlapping_unpin_struct.rs:5:1
+   |
+5  | / pin_project! {
+6  | |     struct Foo<T> {
+7  | |         #[pin]
+8  | |         inner: T,
+9  | |     }
+10 | | }
+   | |_^ unsatisfied trait bound introduced here
+note: required by a bound in `is_unpin`
+  --> tests/ui/pin_project/overlapping_unpin_struct.rs:16:16
+   |
+16 | fn is_unpin<T: Unpin>() {}
+   |                ^^^^^ required by this bound in `is_unpin`
+   = note: this error originates in the macro `$crate::__pin_project_make_unpin_impl` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/crates/pin-project-lite/tests/ui/pin_project/packed.rs b/crates/pin-project-lite/tests/ui/pin_project/packed.rs
new file mode 100644
index 0000000..507a038
--- /dev/null
+++ b/crates/pin-project-lite/tests/ui/pin_project/packed.rs
@@ -0,0 +1,19 @@
+use pin_project_lite::pin_project;
+
+pin_project! { //~ ERROR reference to packed field is unaligned
+    #[repr(packed, C)]
+    struct Packed {
+        #[pin]
+        field: u16,
+    }
+}
+
+pin_project! { //~ ERROR reference to packed field is unaligned
+    #[repr(packed(2))]
+    struct PackedN {
+        #[pin]
+        field: u32,
+    }
+}
+
+fn main() {}
diff --git a/crates/pin-project-lite/tests/ui/pin_project/packed.stderr b/crates/pin-project-lite/tests/ui/pin_project/packed.stderr
new file mode 100644
index 0000000..710ec08
--- /dev/null
+++ b/crates/pin-project-lite/tests/ui/pin_project/packed.stderr
@@ -0,0 +1,101 @@
+error[E0793]: reference to packed field is unaligned
+ --> tests/ui/pin_project/packed.rs:3:1
+  |
+3 | / pin_project! { //~ ERROR reference to packed field is unaligned
+4 | |     #[repr(packed, C)]
+5 | |     struct Packed {
+6 | |         #[pin]
+7 | |         field: u16,
+8 | |     }
+9 | | }
+  | |_^
+  |
+  = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
+  = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
+  = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
+  = note: this error originates in the macro `$crate::__pin_project_struct_make_proj_method` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0793]: reference to packed field is unaligned
+ --> tests/ui/pin_project/packed.rs:3:1
+  |
+3 | / pin_project! { //~ ERROR reference to packed field is unaligned
+4 | |     #[repr(packed, C)]
+5 | |     struct Packed {
+6 | |         #[pin]
+7 | |         field: u16,
+8 | |     }
+9 | | }
+  | |_^
+  |
+  = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
+  = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
+  = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
+  = note: this error originates in the macro `$crate::__pin_project_struct_make_proj_method` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0793]: reference to packed field is unaligned
+ --> tests/ui/pin_project/packed.rs:3:1
+  |
+3 | / pin_project! { //~ ERROR reference to packed field is unaligned
+4 | |     #[repr(packed, C)]
+5 | |     struct Packed {
+6 | |         #[pin]
+7 | |         field: u16,
+8 | |     }
+9 | | }
+  | |_^
+  |
+  = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
+  = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
+  = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
+  = note: this error originates in the macro `$crate::__pin_project_constant` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0793]: reference to packed field is unaligned
+  --> tests/ui/pin_project/packed.rs:11:1
+   |
+11 | / pin_project! { //~ ERROR reference to packed field is unaligned
+12 | |     #[repr(packed(2))]
+13 | |     struct PackedN {
+14 | |         #[pin]
+15 | |         field: u32,
+16 | |     }
+17 | | }
+   | |_^
+   |
+   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
+   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
+   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
+   = note: this error originates in the macro `$crate::__pin_project_struct_make_proj_method` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0793]: reference to packed field is unaligned
+  --> tests/ui/pin_project/packed.rs:11:1
+   |
+11 | / pin_project! { //~ ERROR reference to packed field is unaligned
+12 | |     #[repr(packed(2))]
+13 | |     struct PackedN {
+14 | |         #[pin]
+15 | |         field: u32,
+16 | |     }
+17 | | }
+   | |_^
+   |
+   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
+   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
+   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
+   = note: this error originates in the macro `$crate::__pin_project_struct_make_proj_method` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0793]: reference to packed field is unaligned
+  --> tests/ui/pin_project/packed.rs:11:1
+   |
+11 | / pin_project! { //~ ERROR reference to packed field is unaligned
+12 | |     #[repr(packed(2))]
+13 | |     struct PackedN {
+14 | |         #[pin]
+15 | |         field: u32,
+16 | |     }
+17 | | }
+   | |_^
+   |
+   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
+   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
+   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
+   = note: this error originates in the macro `$crate::__pin_project_constant` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/crates/pin-project-lite/tests/ui/pin_project/unpin_sneaky.rs b/crates/pin-project-lite/tests/ui/pin_project/unpin_sneaky.rs
new file mode 100644
index 0000000..984cc2a
--- /dev/null
+++ b/crates/pin-project-lite/tests/ui/pin_project/unpin_sneaky.rs
@@ -0,0 +1,12 @@
+use pin_project_lite::pin_project;
+
+pin_project! {
+    struct Foo {
+        #[pin]
+        inner: u8,
+    }
+}
+
+impl Unpin for __Origin {} //~ ERROR E0412,E0321
+
+fn main() {}
diff --git a/crates/pin-project-lite/tests/ui/pin_project/unpin_sneaky.stderr b/crates/pin-project-lite/tests/ui/pin_project/unpin_sneaky.stderr
new file mode 100644
index 0000000..aadd1f9
--- /dev/null
+++ b/crates/pin-project-lite/tests/ui/pin_project/unpin_sneaky.stderr
@@ -0,0 +1,5 @@
+error[E0412]: cannot find type `__Origin` in this scope
+  --> tests/ui/pin_project/unpin_sneaky.rs:10:16
+   |
+10 | impl Unpin for __Origin {} //~ ERROR E0412,E0321
+   |                ^^^^^^^^ not found in this scope
diff --git a/crates/pin-project-lite/tests/ui/pin_project/unsupported.rs b/crates/pin-project-lite/tests/ui/pin_project/unsupported.rs
new file mode 100644
index 0000000..2f80836
--- /dev/null
+++ b/crates/pin-project-lite/tests/ui/pin_project/unsupported.rs
@@ -0,0 +1,27 @@
+use pin_project_lite::pin_project;
+
+pin_project! {
+    struct Struct1 {} //~ ERROR no rules expected the token `}`
+}
+
+pin_project! {
+    struct Struct2(); //~ ERROR no rules expected the token `(`
+}
+
+pin_project! {
+    struct Struct3; //~ ERROR no rules expected the token `;`
+}
+
+pin_project! {
+    enum Enum { //~ ERROR no rules expected the token `enum`
+        A(u8)
+    }
+}
+
+pin_project! {
+    union Union { //~ ERROR no rules expected the token `union`
+        x: u8,
+    }
+}
+
+fn main() {}
diff --git a/crates/pin-project-lite/tests/ui/pin_project/unsupported.stderr b/crates/pin-project-lite/tests/ui/pin_project/unsupported.stderr
new file mode 100644
index 0000000..f1d3b9c
--- /dev/null
+++ b/crates/pin-project-lite/tests/ui/pin_project/unsupported.stderr
@@ -0,0 +1,115 @@
+error: no rules expected the token `}`
+ --> tests/ui/pin_project/unsupported.rs:3:1
+  |
+3 | / pin_project! {
+4 | |     struct Struct1 {} //~ ERROR no rules expected the token `}`
+5 | | }
+  | |_^ no rules expected this token in macro call
+  |
+note: while trying to match meta-variable `$field_vis:vis`
+ --> src/lib.rs
+  |
+  |                 $field_vis:vis $field:ident: $field_ty:ty
+  |                 ^^^^^^^^^^^^^^
+  = note: this error originates in the macro `$crate::__pin_project_expand` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: no rules expected the token `}`
+ --> tests/ui/pin_project/unsupported.rs:3:1
+  |
+3 | / pin_project! {
+4 | |     struct Struct1 {} //~ ERROR no rules expected the token `}`
+5 | | }
+  | |_^ no rules expected this token in macro call
+  |
+note: while trying to match meta-variable `$field_vis:vis`
+ --> src/lib.rs
+  |
+  |                 $field_vis:vis $field:ident: $field_ty:ty
+  |                 ^^^^^^^^^^^^^^
+  = note: this error originates in the macro `$crate::__pin_project_expand` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: no rules expected the token `(`
+ --> tests/ui/pin_project/unsupported.rs:8:19
+  |
+8 |     struct Struct2(); //~ ERROR no rules expected the token `(`
+  |                   ^ no rules expected this token in macro call
+  |
+note: while trying to match `{`
+ --> src/lib.rs
+  |
+  |         {
+  |         ^
+
+error: no rules expected the token `;`
+  --> tests/ui/pin_project/unsupported.rs:12:19
+   |
+12 |     struct Struct3; //~ ERROR no rules expected the token `;`
+   |                   ^ no rules expected this token in macro call
+   |
+note: while trying to match `{`
+  --> src/lib.rs
+   |
+   |         {
+   |         ^
+
+error: no rules expected the token `(`
+  --> tests/ui/pin_project/unsupported.rs:17:10
+   |
+17 |         A(u8)
+   |          ^ no rules expected this token in macro call
+   |
+note: while trying to match `}`
+  --> src/lib.rs
+   |
+   |         }
+   |         ^
+
+error: no rules expected the token `(`
+  --> tests/ui/pin_project/unsupported.rs:17:10
+   |
+17 |         A(u8)
+   |          ^ no rules expected this token in macro call
+   |
+note: while trying to match `}`
+  --> src/lib.rs
+   |
+   |         }
+   |         ^
+
+error: no rules expected the token `union`
+  --> tests/ui/pin_project/unsupported.rs:21:1
+   |
+21 | / pin_project! {
+22 | |     union Union { //~ ERROR no rules expected the token `union`
+23 | |         x: u8,
+24 | |     }
+25 | | }
+   | |_^ no rules expected this token in macro call
+   |
+note: while trying to match `struct`
+  --> src/lib.rs
+   |
+   |         [$(#[$attrs:meta])* $vis:vis struct $ident:ident]
+   |                                      ^^^^^^
+   = note: captured metavariables except for `:tt`, `:ident` and `:lifetime` cannot be compared to other tokens
+   = note: see <https://doc.rust-lang.org/nightly/reference/macros-by-example.html#forwarding-a-matched-fragment> for more information
+   = note: this error originates in the macro `$crate::__pin_project_expand` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: no rules expected the token `union`
+  --> tests/ui/pin_project/unsupported.rs:21:1
+   |
+21 | / pin_project! {
+22 | |     union Union { //~ ERROR no rules expected the token `union`
+23 | |         x: u8,
+24 | |     }
+25 | | }
+   | |_^ no rules expected this token in macro call
+   |
+note: while trying to match `struct`
+  --> src/lib.rs
+   |
+   |         [$(#[$attrs:meta])* $vis:vis struct $ident:ident]
+   |                                      ^^^^^^
+   = note: captured metavariables except for `:tt`, `:ident` and `:lifetime` cannot be compared to other tokens
+   = note: see <https://doc.rust-lang.org/nightly/reference/macros-by-example.html#forwarding-a-matched-fragment> for more information
+   = note: this error originates in the macro `$crate::__pin_project_expand` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/crates/pin-project-lite/tests/ui/pinned_drop/call-drop-inner.rs b/crates/pin-project-lite/tests/ui/pinned_drop/call-drop-inner.rs
new file mode 100644
index 0000000..609b3be
--- /dev/null
+++ b/crates/pin-project-lite/tests/ui/pinned_drop/call-drop-inner.rs
@@ -0,0 +1,17 @@
+use pin_project_lite::pin_project;
+
+pin_project! {
+    pub struct S {
+        #[pin]
+        field: u8,
+    }
+    impl PinnedDrop for S {
+        fn drop(this: Pin<&mut Self>) {
+            __drop_inner(this);
+        }
+    }
+}
+
+fn main() {
+    let _x = S { field: 0 };
+}
diff --git a/crates/pin-project-lite/tests/ui/pinned_drop/call-drop-inner.stderr b/crates/pin-project-lite/tests/ui/pinned_drop/call-drop-inner.stderr
new file mode 100644
index 0000000..a622621
--- /dev/null
+++ b/crates/pin-project-lite/tests/ui/pinned_drop/call-drop-inner.stderr
@@ -0,0 +1,21 @@
+error[E0061]: this function takes 0 arguments but 1 argument was supplied
+  --> tests/ui/pinned_drop/call-drop-inner.rs:10:13
+   |
+10 |             __drop_inner(this);
+   |             ^^^^^^^^^^^^ ----
+   |                          |
+   |                          unexpected argument of type `Pin<&mut S>`
+   |                          help: remove the extra argument
+   |
+note: function defined here
+  --> tests/ui/pinned_drop/call-drop-inner.rs:3:1
+   |
+3  | / pin_project! {
+4  | |     pub struct S {
+5  | |         #[pin]
+6  | |         field: u8,
+...  |
+12 | |     }
+13 | | }
+   | |_^
+   = note: this error originates in the macro `$crate::__pin_project_make_drop_impl` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/crates/pin-project-lite/tests/ui/pinned_drop/conditional-drop-impl.rs b/crates/pin-project-lite/tests/ui/pinned_drop/conditional-drop-impl.rs
new file mode 100644
index 0000000..68b01b2
--- /dev/null
+++ b/crates/pin-project-lite/tests/ui/pinned_drop/conditional-drop-impl.rs
@@ -0,0 +1,26 @@
+use pin_project_lite::pin_project;
+
+// In `Drop` impl, the implementor must specify the same requirement as type definition.
+
+struct DropImpl<T> {
+    f: T,
+}
+
+impl<T: Unpin> Drop for DropImpl<T> {
+    //~^ ERROR E0367
+    fn drop(&mut self) {}
+}
+
+pin_project! {
+    //~^ ERROR E0367
+    struct PinnedDropImpl<T> {
+        #[pin]
+        f: T,
+    }
+
+    impl<T: Unpin> PinnedDrop for PinnedDropImpl<T> {
+        fn drop(_this: Pin<&mut Self>) {}
+    }
+}
+
+fn main() {}
diff --git a/crates/pin-project-lite/tests/ui/pinned_drop/conditional-drop-impl.stderr b/crates/pin-project-lite/tests/ui/pinned_drop/conditional-drop-impl.stderr
new file mode 100644
index 0000000..fe0ee79
--- /dev/null
+++ b/crates/pin-project-lite/tests/ui/pinned_drop/conditional-drop-impl.stderr
@@ -0,0 +1,36 @@
+error[E0367]: `Drop` impl requires `T: Unpin` but the struct it is implemented for does not
+ --> tests/ui/pinned_drop/conditional-drop-impl.rs:9:9
+  |
+9 | impl<T: Unpin> Drop for DropImpl<T> {
+  |         ^^^^^
+  |
+note: the implementor must specify the same requirement
+ --> tests/ui/pinned_drop/conditional-drop-impl.rs:5:1
+  |
+5 | struct DropImpl<T> {
+  | ^^^^^^^^^^^^^^^^^^
+
+error[E0367]: `Drop` impl requires `T: Unpin` but the struct it is implemented for does not
+  --> tests/ui/pinned_drop/conditional-drop-impl.rs:14:1
+   |
+14 | / pin_project! {
+15 | |     //~^ ERROR E0367
+16 | |     struct PinnedDropImpl<T> {
+17 | |         #[pin]
+...  |
+23 | |     }
+24 | | }
+   | |_^
+   |
+note: the implementor must specify the same requirement
+  --> tests/ui/pinned_drop/conditional-drop-impl.rs:14:1
+   |
+14 | / pin_project! {
+15 | |     //~^ ERROR E0367
+16 | |     struct PinnedDropImpl<T> {
+17 | |         #[pin]
+...  |
+23 | |     }
+24 | | }
+   | |_^
+   = note: this error originates in the macro `$crate::__pin_project_make_drop_impl` which comes from the expansion of the macro `pin_project` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/crates/pin-project/.cargo-checksum.json b/crates/pin-project/.cargo-checksum.json
new file mode 100644
index 0000000..e4fb1ec
--- /dev/null
+++ b/crates/pin-project/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"CHANGELOG.md":"01d47269fdc1c641ff4311ed92d7358741dadf80bb39f2ba89db27f5d641d2f9","Cargo.lock":"e49130f610bf3de0c8498a2e6aef6fc40cb4b8b914d618d9fe27e3368fd20514","Cargo.toml":"37234c90c423f08c93dcfdf1df92461a0158655e8e3a022664e4668396465df3","LICENSE-APACHE":"0d542e0c8804e39aa7f37eb00da5a762149dc682d7829451287e11b938e94594","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","README.md":"881afdc0098d23c7f4959d31a1f48177bb81d74625a03e8decfa57451629d54c","examples/README.md":"e04e4ad8c5518aaa839b1255f9aee47877ae223053f32d83db797f607b9422b6","examples/enum-default-expanded.rs":"92414c9b48f3e280ba10994a426629da799d125d764d1b3857676b21cb42dbbd","examples/enum-default.rs":"01e1d285ffbb87aa70950c0ec184b395f7faf0667a1fc874b4de509e3e3c8d5c","examples/not_unpin-expanded.rs":"19e944c6159b6a57a19a653adb7a30d27ddc098351bd311a91ada586eb8e6ee7","examples/not_unpin.rs":"3e43439c521089f7f58a411fb823827433c7476a0b41aecd26a6ce5f0c99e405","examples/pinned_drop-expanded.rs":"6b2bb25bcb3404d1b03276be4ae3f6c768a98b5e6675a33b24bf57bff9a9cfaa","examples/pinned_drop.rs":"8913e9b0b7851d470c3f15e40930af16c79f5ee8b4a947cac8235361b427db30","examples/project_replace-expanded.rs":"0b5adc4f83b3b56febc1a721f334b5bea26ec4aea407f35f4cce5cdde76ddd30","examples/project_replace.rs":"352d10d7a2db3de0101faedd04d69c24b9bb5021c768199a379c233886a3881c","examples/struct-default-expanded.rs":"2e290064aa48e001625f3badce5fda7e2fa7a8ce613cbe1788892b1230885895","examples/struct-default.rs":"eb60ea5412e83ac9eba96794b31772afe0798bef304b26bff65b6845638bb729","examples/unsafe_unpin-expanded.rs":"71d13e6bb284642d81520fce7adf5c1e9510451295c1806a3703dae481e64ee3","examples/unsafe_unpin.rs":"7da585f423999dcbe03289a72b14a29fed41a45a774de1af2fe93cb20aa8d426","src/lib.rs":"72c7bba16532193142134e4307bf63bfbb3b9e76c76c26424cbe2b58605257c3","tests/auxiliary/mod.rs":"7e263e987e09b77e384f734384a00a71c5b70230bb1b5376446ef003a8da9372","tests/cfg.rs":"de3ad3baf0715163d7b941bc988d67219e9c4dfb4c9068f1c60f5214649fa6ee","tests/compiletest.rs":"cd3977f3adc05369f825306218d8511289ef1398351c89f0f6aef96b3c128203","tests/drop_order.rs":"c099c11d236851eb4f27d4c14c1c19d61b32a236e5b2ce032a65265fccc25ba1","tests/expand/default/enum.expanded.rs":"e1ed1186d973286860ebc6898e46a2cd97166a13ad17c68a8a50ddfd4702f3ae","tests/expand/default/enum.rs":"e23fac8939fd21c96afaf4b10613a1b8fbfff655f76128902c2cbe8577c13d08","tests/expand/default/struct.expanded.rs":"a3577d962a10325dcaaf2eccb5e589013266553260cd8bd923264c022ddcfe41","tests/expand/default/struct.rs":"a0c95b1441b93b3ef346a47dc1e3d8113a6e1df90e577464d3f12a4e50654c4f","tests/expand/default/tuple_struct.expanded.rs":"c7f915c09ba8d268745618e68097a2040d46228f2b05c1740354805a9f6b455d","tests/expand/default/tuple_struct.rs":"1132f9700ef58079666f25173076a009c23c4f5e0ad80af80687a2e5958db6e9","tests/expand/multifields/enum.expanded.rs":"76ffa1ca4213228c43a2625e080d07aa04a992f6789052b646c7b9c639879f50","tests/expand/multifields/enum.rs":"a909ee4c44aef0d6959d46343a2927033acb665f6051f37e088367778af90c78","tests/expand/multifields/struct.expanded.rs":"3a57d0b3573841e914fbfe8ffedc600c57dccc8bc8f1d42daa8e341313adbe06","tests/expand/multifields/struct.rs":"9f99e89352d212e3d4ed9cd6be2741ea13658267de6b557bdc8302c4902c72a9","tests/expand/multifields/tuple_struct.expanded.rs":"7a65d27d0083168a7aa392463d2ea472fbc933a764ef93368edb304c5dbd486d","tests/expand/multifields/tuple_struct.rs":"9ec0b313d829717bf7d3484428136a3012a996dbd97d3ecc8a7b0ba682e5db0b","tests/expand/naming/enum-all.expanded.rs":"84932097a0c023a65337f57dbd18e5fda50a01cf213ed2f7dd2336e65e9c22d0","tests/expand/naming/enum-all.rs":"c46d8ff27879a26afb31d71df8ab69a871b2fd509ba90668cffaadafb7a54940","tests/expand/naming/enum-mut.expanded.rs":"5ff87796fbe96d12ddd13667796dc40f720147a27af0995c337810d25dcc0da7","tests/expand/naming/enum-mut.rs":"9df4e0e1fd8bec8ab471ef419be312c8e15158c7017e964a8337c3108f6c601b","tests/expand/naming/enum-none.expanded.rs":"28c0667e91a8c65fdc4fe1d80fb67398f95f47af19066e7a34ea8eb799497200","tests/expand/naming/enum-none.rs":"487f9469127b9375f53d6242062455eac38ccdaa30c168ed2ea755ad7287f02f","tests/expand/naming/enum-own.expanded.rs":"11668391ec68656d1c3a3316a0ad93853a0e8ea64d5ce0f2de205c66d51c14c4","tests/expand/naming/enum-own.rs":"5bb51375842f2956cceb685511cc34a099665439310f01a5cc02a1d4264897a6","tests/expand/naming/enum-ref.expanded.rs":"fc9527bcbb7707cf699d1721306bfd92a0c8c4f158b1ec5f5ef1618c6f5e0fc8","tests/expand/naming/enum-ref.rs":"3764e8471702f968e79f633a1a471974b7a726bcc09ce4443e0bce65194f8930","tests/expand/naming/struct-all.expanded.rs":"7f65e644aaf801570c8fac54595275d102391f4007eccb4c248721970b2b8d5a","tests/expand/naming/struct-all.rs":"a8d70a576ff5325b848d14dc8083d0967e1b3b4486fd061281484b95adade136","tests/expand/naming/struct-mut.expanded.rs":"1bd55f7e1b0218b4094db6ecbed0abfff7937281cebc0f2cad620abaa291b7a1","tests/expand/naming/struct-mut.rs":"e793dc13594ba2836881ab2580a73d73c40299af94e24a442f704e76552ce7fb","tests/expand/naming/struct-none.expanded.rs":"a3577d962a10325dcaaf2eccb5e589013266553260cd8bd923264c022ddcfe41","tests/expand/naming/struct-none.rs":"a0c95b1441b93b3ef346a47dc1e3d8113a6e1df90e577464d3f12a4e50654c4f","tests/expand/naming/struct-own.expanded.rs":"6e4c8a222fcc9d3dc10991c8033158c8a7f2a399146b9e6a1e0de7f15106b965","tests/expand/naming/struct-own.rs":"caa714f00757980ef60640a90cba289886293320524395a753b876e3050018e1","tests/expand/naming/struct-ref.expanded.rs":"96f39a4cfdedc85c8d43c9700bdc1ff6880024754215b513741071edd30ef0a0","tests/expand/naming/struct-ref.rs":"f0ce9bb2ebb0c501cce8eaa24c2657a87e58109d5bde8319e7b5d3c0bae4ad86","tests/expand/naming/tuple_struct-all.expanded.rs":"6bb2d8e8239d849836031bc7d8c6005e4f9c5deccadabb9bf872f7bdd9d814ae","tests/expand/naming/tuple_struct-all.rs":"a77e3d5d2409f9016bb8df7ca0387fa512d3383833c9591e64435b689d3710c7","tests/expand/naming/tuple_struct-mut.expanded.rs":"088257a925b4318237680f3fe4b5f1e259cbe29e8080aa856b3ba6de204eca2b","tests/expand/naming/tuple_struct-mut.rs":"06b87b86b6bed07ddfb96067772e9aaf9c1db2d3f871e248658593bd22c4a17c","tests/expand/naming/tuple_struct-none.expanded.rs":"c7f915c09ba8d268745618e68097a2040d46228f2b05c1740354805a9f6b455d","tests/expand/naming/tuple_struct-none.rs":"1132f9700ef58079666f25173076a009c23c4f5e0ad80af80687a2e5958db6e9","tests/expand/naming/tuple_struct-own.expanded.rs":"855271137c5a3d218eb466b3619a2216b4e54eacf2fba46dd530fbd3c07a462c","tests/expand/naming/tuple_struct-own.rs":"89ccd509482a95e74733c767b34f5d6bc8d4128cedc911834aa28aef08e7dc8e","tests/expand/naming/tuple_struct-ref.expanded.rs":"da280916ff79c15ab8173f723f89f494fad161f06e1ef0cede45bdecc1279385","tests/expand/naming/tuple_struct-ref.rs":"2718b96b3e2e6cdef7f8293719d8914e3fd81e92d272b90f019863fa19584a29","tests/expand/not_unpin/enum.expanded.rs":"4145ee18ebbd535d0e4d2b39d8b2f2a3ffcf9d45505aba6ff8d5819f61fca6ac","tests/expand/not_unpin/enum.rs":"60134857b6c3c2aca42e9eb2b4c6dbb9149701f115d0de30a2477395ce54fdfa","tests/expand/not_unpin/struct.expanded.rs":"ccd00941a0b0c83e39a3ea762f99d6471a06625ceecff0d3c3b5b44719a1a312","tests/expand/not_unpin/struct.rs":"bf7468f2b42284897648e2545cf0da92a576a748cd5b75893b85f03eb2a52ba4","tests/expand/not_unpin/tuple_struct.expanded.rs":"7c02f6e799f50fe63911c90302d2e4158c6e24f8f6a2fa113f467fac272bf727","tests/expand/not_unpin/tuple_struct.rs":"a3e2c2c484699087a570b1b247ce21bc40203fad889e7c0e9737d03c7ca4bd4e","tests/expand/pinned_drop/enum.expanded.rs":"ad060ff23ddff563859664e7b6b5073fc641b2925c7af1ccd5fdd4a4cc873c83","tests/expand/pinned_drop/enum.rs":"66f98ea8a567dcdeb58838df68fcba3594aea8a959826ff54fb4493fe06c4086","tests/expand/pinned_drop/struct.expanded.rs":"cacdc72e8905e29d8e75ac83771fa3834e0db4b075103f9675849bdc5a9f093e","tests/expand/pinned_drop/struct.rs":"44321ea6b494149e416d413185c2d23ed9d96982d1c4f378381b18e969abc16b","tests/expand/pinned_drop/tuple_struct.expanded.rs":"57d4e23e39c844501ceb77c66ac900f0aeb93b9002a8db565a95060152aceae8","tests/expand/pinned_drop/tuple_struct.rs":"e0532400f0bf77be198928c120e9efd9fd1b5d34f5fc9c902eb3b778c412a83d","tests/expand/project_replace/enum.expanded.rs":"1101df9623f1e39ee18c5680b1984782cbece4057b22a04240913a3a188a34b5","tests/expand/project_replace/enum.rs":"ce2f5ddff8efd37b1b0028172fde7ee7fba4eff7622c8747cd61591d81c0f503","tests/expand/project_replace/struct.expanded.rs":"553434b0f98d837d2eda601cb4dd625a8542051e9dd315ffa326daf668d2c01b","tests/expand/project_replace/struct.rs":"f8c2915e03b557b9f11a6ea63c971cfb19b09e3a9916ab304f0ce62626e35895","tests/expand/project_replace/tuple_struct.expanded.rs":"926022463a98ab6b15d6db0cf700944b91b18334c893257a4e8a8b3f4bc7ea71","tests/expand/project_replace/tuple_struct.rs":"8ca1cd1d5feadb23999d8f4e7307f91d1932fff7e8d38889d3889d6ba4d43430","tests/expand/pub/enum.expanded.rs":"3e806cc3d1425838145cddd2ea1eaca5bf9c681a48927fa05cf78775e866a94a","tests/expand/pub/enum.rs":"64ca05d529227157ba4cdce1c526d67d15f06108fd71f5955749d236c002471f","tests/expand/pub/struct.expanded.rs":"d3bf3689402229b59e4a68f87b2264773a5b2c2b13acddfe4d000781d571a052","tests/expand/pub/struct.rs":"379b8c4c01a3fc2aa3f020578a6dd836d455f4c48604e1dad91f631146b9e6ec","tests/expand/pub/tuple_struct.expanded.rs":"89f22d0407f72c0c80984c89b6fae023db6725dac7a733342246c899fb923877","tests/expand/pub/tuple_struct.rs":"77cc812220e956a2255ef129dec3b16d6973b7e8b1bc02a6f65bd9fa56040564","tests/expand/unsafe_unpin/enum.expanded.rs":"501c6b1ce279f90e305bffbca262c2912f6b112326e0a913df2c31530340310f","tests/expand/unsafe_unpin/enum.rs":"00fad3fed0f7d2d0eae56020726818ab91895d6eaed7c4c7cc5d497b5efa7cfd","tests/expand/unsafe_unpin/struct.expanded.rs":"9f1b3757695b80cda7a8c812dc546ebfa60a253251b474f7c209d034e248fcc4","tests/expand/unsafe_unpin/struct.rs":"a41bed68966abb874f31ad02a860e15a2714e2e459ef73475a908e71141e96f0","tests/expand/unsafe_unpin/tuple_struct.expanded.rs":"734051c9dbaec8e4ccdc37dd8922eb3223dc30d04c58fb4f6ae4514a8a26081d","tests/expand/unsafe_unpin/tuple_struct.rs":"bddd36be1795be2f445d7baec269ad8a5a2647b95af7f0b130331ab7a3c64baf","tests/expandtest.rs":"66bd80992a1696994ec2d14c3edc36350a0cb896d8081f1c0f8893ebeed72d03","tests/include/basic-safe-part.rs":"6fb5accb7476f85233ef919eedaff83c30015e186414589db6e44d614016ad3e","tests/include/basic.rs":"e030edc2573d8b365e9542e431f0c0af6d5ecf6fe9d84f13c7a8401f4c922895","tests/lint.rs":"ce200abc2b1dff5d72eacdabacd49b6ffe8ddfa8796eec82e69b464b1e449484","tests/pin_project.rs":"b795fef5a8f997505979a5c13be8b0be4b934a821c282d344b589efe55ab10d9","tests/pinned_drop.rs":"4061cb2ead2191ec6cf8acde51c4e6758762170bc59e58afa7731c721bf910f8","tests/proper_unpin.rs":"435b9c7243ab896c2546c1e402276e93ef38cd93de50cc7369f486fe22698a02","tests/repr_packed.rs":"f54a553a579dbce7f80f666f0228ec2dd2a80282ac5da5f715bb122e7e17712e","tests/ui/cfg/cfg_attr-resolve.rs":"bb924ea9ceb6579e80774ef7fee1bb99ae08efc7d909e8d1edff40c3c1adaa7f","tests/ui/cfg/cfg_attr-resolve.stderr":"720f806ac06d598753a6a90c95b942410413d8860f60a7251fbde3e1fa575934","tests/ui/cfg/cfg_attr-type-mismatch.rs":"25e8337f9fd5533799dd990df6e016d18e2a00468de3386aa7d45aa98e39a0f9","tests/ui/cfg/cfg_attr-type-mismatch.stderr":"5cde5c01d5c602c4200a1add15642d72946c5dcc0046535c207bc7a475e74913","tests/ui/cfg/packed_sneaky-span-issue-1.rs":"768762cf1831b9b09868404d9d7fd394ed30fb4495bd8388034ee9bf3823d11b","tests/ui/cfg/packed_sneaky-span-issue-1.stderr":"235ad4c1c784e9116c480502e813a0f0254f3b0e624c89712bafa56d43eaa2c4","tests/ui/cfg/packed_sneaky-span-issue-2.rs":"229d91b2531ace7c1d644125b77ee044fc639e9b981aaede5fda6f5e38154a4d","tests/ui/cfg/packed_sneaky-span-issue-2.stderr":"dae8adcb5b6ac12be55da9f4d6d04c1a790907dc5ee23a16d86a2a370daf596a","tests/ui/cfg/packed_sneaky.rs":"785e77f597bfc0cdb7bebc040cf11b17b1e2aa727b0fc369b7fe073f8441cad0","tests/ui/cfg/packed_sneaky.stderr":"1674d0f108f91cc21f9009338bde1b343b65a68d81d6bb3b6aecd919846cc6e0","tests/ui/cfg/unsupported.rs":"45d6eddef59e67dfca3733450249632dd8135283cedafa663e7bfa2b232ca13e","tests/ui/cfg/unsupported.stderr":"72421d6c14eb7d4f7af7eea1e0701343df691985d1d58325e91412e749705d3f","tests/ui/not_unpin/conflict-unpin.rs":"5709b68bbf26c0b2b87ee7a0bbf83ae9e4f1bacd2266114114b4dcb8706d0080","tests/ui/not_unpin/conflict-unpin.stderr":"b2357ec463ea18ae82474218b2281e539890a74ed1e4263a2f1fa98098e217fc","tests/ui/not_unpin/impl-unsafe-unpin.rs":"088374540354c4052a2daf2e97cdf49fc54287e0d943bf34bbb70298d62e8c9b","tests/ui/not_unpin/impl-unsafe-unpin.stderr":"3bb3f4b6b1ff747309f5ea494a18f1b9eb7610b89b051750282e1fba1633310c","tests/ui/pin_project/add-attr-to-struct.rs":"640b49214c7f3f2eae027165bad32c12cb63b00735b6ca3eb2037a4b69a8ad19","tests/ui/pin_project/add-attr-to-struct.stderr":"4f5eba0ddf8f6c20e76a0624095233ced75b9a713c6451fba0c7a37e80028dee","tests/ui/pin_project/add-pinned-field.rs":"791df5b427ba412fb25836569963e6a03ccacea9fcefa4bf3f789ee4de90762d","tests/ui/pin_project/add-pinned-field.stderr":"6af54b6a15b5d6c7cfd23d93cd514477d33f7775cb7dffadb45d249d343025ad","tests/ui/pin_project/conflict-drop.rs":"c97bedbed751436994fec33003dca06761cc2cbf9fcc832c120321aa8fc0be7b","tests/ui/pin_project/conflict-drop.stderr":"965dc2be7b88493b3df0fb61f9d9e65d0480ded5ab76dffe30dc517877547095","tests/ui/pin_project/conflict-unpin.rs":"9e3b06ce53d97ebd79620d729b525fac1c87c67ed44b91d05dd4c3d48be455e3","tests/ui/pin_project/conflict-unpin.stderr":"77ae4396ceb42548f52a84fb0e08f4d66eff81a2e9bbcfe11d59aa4ffff73c04","tests/ui/pin_project/impl-unsafe-unpin.rs":"d24d630abd82e08aea529d358bf998011ead0e939c82dca410160764fc24e06b","tests/ui/pin_project/impl-unsafe-unpin.stderr":"d96230802cc11ec32b6c31c86023972fa7038390da1e93e81bae4770dfd1cfd2","tests/ui/pin_project/import_unnamed.rs":"09fb23d22c044321f9bf3a526d16d694916adb7b5defeb6a353cdaff46df7efb","tests/ui/pin_project/import_unnamed.stderr":"2358b70ea4b4c797816cf3b47920f72e0eb7ad0ff11d9d7e8f9f0faed27cbd93","tests/ui/pin_project/invalid.rs":"ac237cc99cff8a273d84e87d26e4640a53afdfb7a7961b6dc8bfa53dd5d88aa5","tests/ui/pin_project/invalid.stderr":"46a9c8a8469c0be53b09d24062f06aff4d21c23541be2d8055a0c76f2180b277","tests/ui/pin_project/overlapping_unpin_struct.rs":"3f459dda0c01e36f989a1413b2a43f4d95f9ae2524653b61f0561acff28ad9a6","tests/ui/pin_project/overlapping_unpin_struct.stderr":"e89b9cfcdb9a8cf0e1042bf8d3d4a98d2cdecfe2a966f14ef62c61b0c82a5403","tests/ui/pin_project/override-priv-mod.rs":"b9f163f5ab76735bbd8406b46f7407929845a34a23e2892a935a178612ec5875","tests/ui/pin_project/override-priv-mod.stderr":"effec97131efb6628e8bbaf74c37fe5d7f9a735b4468e1d6e585bdd693ae98ed","tests/ui/pin_project/packed-enum.rs":"7784ff49119daa5ae562f0fa84fdf4e65fe8abaf62ecff7d2ead184748e16b9b","tests/ui/pin_project/packed-enum.stderr":"3c710e899c68e5db4707405546c9c81b819ba6d3bdb83d3578e34c1254fbf1e3","tests/ui/pin_project/packed-name-value.rs":"64cbf4ef3c01709d302f91d98e92c980f2858b14ddaf047646c4de57707541b1","tests/ui/pin_project/packed-name-value.stderr":"f8beabf2de5cdd913903eed642d886841ad14a719f562769f525c79a5df2fc76","tests/ui/pin_project/packed.rs":"7a66b7c2ca8253cfd6774a339d74400966e85c73ef59f54ad66d9f1b02ea5db7","tests/ui/pin_project/packed.stderr":"2b9e7a0818e21f958536738035452d760b9fbd3784d2034b1732d2c8d4b85812","tests/ui/pin_project/packed_sneaky-1.rs":"390dd0ad59668f80a6e86baed1015c02a429cecc92388f18c8deffb500508415","tests/ui/pin_project/packed_sneaky-1.stderr":"f01979f02e3a0956fc191550cfe364ea11a14afb15cc252e63127ab72f99f640","tests/ui/pin_project/packed_sneaky-2.rs":"f1601aa4f642ed4aaaab2dd2e0328b7af145be9a3a7460ad36339b47b4d7ce14","tests/ui/pin_project/packed_sneaky-2.stderr":"5df9f0c90032016856c4797f07c8e8c172ed0ded2c7078c404f80b5be675d33a","tests/ui/pin_project/packed_sneaky-3.rs":"d9ee3366b5e3849f3ec0d0bd62d365cff0c6e8f0eb3434d70fb84e62a1976eb2","tests/ui/pin_project/packed_sneaky-3.stderr":"596b17b96189fd8f38bf5c7f5ef5e01e54c1d4cc459a15a519687e61e4edca34","tests/ui/pin_project/packed_sneaky-4.rs":"5636ae9a7fc54ea6981897adc1e31afb5eaa1c1db6244f8357e79cf922e6f7a8","tests/ui/pin_project/packed_sneaky-4.stderr":"3aee1184b5fa175a6b5cdb1084bf170c27d0bfc8c564ae2847c3f23b9de09a6f","tests/ui/pin_project/private_in_public-enum.rs":"bb79b1bf0328bf652e561b4006c31f6a2d0cbe598912f264c4024a1b381d5400","tests/ui/pin_project/private_in_public-enum.stderr":"d951fb2b9b80ff07848723439da190cb91f776fbef0e27db025dcd24186f80aa","tests/ui/pin_project/project_replace_unsized.rs":"7c35e6c8ebf8337b6abf6a7fa7106bd519cebbe32d3f33b8865fa251820e0e5a","tests/ui/pin_project/project_replace_unsized.stderr":"7d3be0208cbec2d86833192579b8d51d876cd9461dc5e20e988767e9696d4e28","tests/ui/pin_project/project_replace_unsized_fn_params.rs":"db7c72e96119f245535627b887c1289b064dd657fbb524c0f6635287033b85e2","tests/ui/pin_project/project_replace_unsized_fn_params.stderr":"17095141eb2647a8484c429a5d3348ed7a42b35ff965e6dd73eb662ae8e6d868","tests/ui/pin_project/remove-attr-from-field.rs":"9faac7ca8220c7069b1a7b2f43420efd3d73377f0ac0558ef67cd5664a9c54c1","tests/ui/pin_project/remove-attr-from-field.stderr":"424cd345a7b4a0ec328c58f36eb3b31a88e6c1789a0226bd8d6c4c50fecc39a2","tests/ui/pin_project/remove-attr-from-struct.rs":"f47a6cfbb5a4fa5bb233c0427be255110749621bed7cfa7a8f45e80451aa8615","tests/ui/pin_project/remove-attr-from-struct.stderr":"2c1d7d214096afe2140921f56cb16e54110bec7ae77ee81726de94ec1bdf50a0","tests/ui/pin_project/safe_packed_borrows.rs":"2f398fe1f16a3fe5a5123f49705f7eb6157d47b8adabb8b80fad88bd61efc37c","tests/ui/pin_project/safe_packed_borrows.stderr":"c508f901bb9f1cc4055edb9aa6bbd5f333297f611d9df18acbc22076cd2f8abf","tests/ui/pin_project/unaligned_references.rs":"a01c34657405c717b0e2999460bd3332e39e6f8f715465f5fb9d517c0900f172","tests/ui/pin_project/unaligned_references.stderr":"cfa0f3500b7edb75eff2c6a87164c61531ed117aca61912bdecc45ba0eeff23c","tests/ui/pin_project/unpin_sneaky.rs":"8d49b2dcb1695b4ae26669de58dd6dc73bd836f3cd836078d6be2a0ac2cc56f3","tests/ui/pin_project/unpin_sneaky.stderr":"b31b54cb2be5a9cecd50c4489847ec83bb401daa63c2f5b6ebd4080efc95bd67","tests/ui/pin_project/visibility.rs":"4345aa1fd270a99e631510097ab7fea51aa7cbe15e155cf19f406c63735e3daa","tests/ui/pin_project/visibility.stderr":"9d56584accaad71c65e38823b0200b8ee229c027558f4461168c869ac53655b2","tests/ui/pinned_drop/call-drop-inner.rs":"a155a5b4cf7434ad6c2c4f217beb37b57edae74c5ae809627a50ea8d6ab5da50","tests/ui/pinned_drop/call-drop-inner.stderr":"ab9eb3a1924782a2e4c37e379fc5075aae1262ddd3fab7ebff18ac8d267be645","tests/ui/pinned_drop/conditional-drop-impl.rs":"5d4c147d48d87a306fa875e033c4962ecd9d7666e6859da5b22a34fd552f0fc6","tests/ui/pinned_drop/conditional-drop-impl.stderr":"f0d05bf22ae2016a186c6d5fa0ae940e0e2b8fce822f06344b73a7390cd047bd","tests/ui/pinned_drop/forget-pinned-drop-impl.rs":"9a6d08c98f1214d11aac8bbf67586130ad62d07d03f4ba6aae474fe30695b536","tests/ui/pinned_drop/forget-pinned-drop-impl.stderr":"d45a218e8107ad11a59a75f30bbb2a018e153ecdead28880b09cf63f3d64f98f","tests/ui/pinned_drop/invalid-self.rs":"9c7e431b0808204d6a3bf3541668655cb72c76e8ebe8f4a04518d0c6dcdd1bd5","tests/ui/pinned_drop/invalid-self.stderr":"a2004c3f04e13bbc17446e751acb1b3985f5a6bfeb846e1b8a661951e40adb12","tests/ui/pinned_drop/invalid.rs":"1c0a596320d62adf3c138e67efa3236f2cfd598d5f249ed7b1d51d5b40d31587","tests/ui/pinned_drop/invalid.stderr":"a91c479bbc41a708f1ac19eb2b788dac8e204db4fe92f9c1e4be898d8a69bdcc","tests/ui/pinned_drop/pinned-drop-no-attr-arg.rs":"cc406f6ffa1998896931d33cfdab79466a1494750b55519f5a8ad7fe13e08657","tests/ui/pinned_drop/pinned-drop-no-attr-arg.stderr":"0766091c9b7e88aa5b6b22a6a0ea04c3521681408dd7241aba762234f57021cd","tests/ui/pinned_drop/self.rs":"db7da7c136a16c34b0492dbaeed680cdf0a1bdeb186b2d4a1324dd11b43bbe2b","tests/ui/pinned_drop/self.stderr":"e0c56bcdcc4009311ef8a8fc0e214a56770c544b0dbd9867a578013ccc0c6873","tests/ui/pinned_drop/unsafe-call.rs":"2ecdfd7b658c0aeb85ff0feed8d6c1776a06166c287d3b8925f7fc4c699ee74a","tests/ui/pinned_drop/unsafe-call.stderr":"f7c304194f2517651571a9d1c94fc19b8e917bc772295f7b3c1758e1fe7386db","tests/ui/unsafe_unpin/conflict-unpin.rs":"a22831379eb1f2d597d5f8088130f7c91add5ec69bade962d555d1b49145f56a","tests/ui/unsafe_unpin/conflict-unpin.stderr":"069830217d50c954b6b0af8891386d2069ffbe7b0b72069cc1b92ee0c5bf9a54","tests/ui/unstable-features/README.md":"f9dcf95e9c68fe15345f493a3fb4f54726d36c76d1a5a1e2c9dfa25540d4b642","tests/ui/unstable-features/marker_trait_attr-feature-gate.rs":"35596063ddbc8a289182c3a18d98d595583e6a0b2b3324d3eec4f416de06ea4b","tests/ui/unstable-features/marker_trait_attr-feature-gate.stderr":"cb4afbee9d7a3f4598a926efd2d30b26146e9766cba145d31e4ef6223539ece7","tests/ui/unstable-features/marker_trait_attr.rs":"f2a5275a5b80249d2a0e7a4e9e7d3f573ffd5f2a183dfced314e91a7d7945007","tests/ui/unstable-features/marker_trait_attr.stderr":"0b4b5faa7405a58a2ebc6faaa4cd697f913b99882c45d4d7d729bb0cb4f7d0be","tests/ui/unstable-features/negative_impls.rs":"b913f3d818cc4d91efe4b82dd08b72acff89b97d7e56a33d8106c93f1de6a81d","tests/ui/unstable-features/negative_impls.stderr":"aacad57752e05b1e5a8b09c9486bc9fb6f1875d1f061931197dd4352f1ff2898","tests/ui/unstable-features/overlapping_marker_traits-feature-gate.rs":"dc6b854cc60ea03344f8ca3fa518a2bdc0b9aa69f2368162f4b6ad24d31bc4f0","tests/ui/unstable-features/overlapping_marker_traits-feature-gate.stderr":"14d39aeb6acbe06173240a7252adf97fefff519b0e65179bdfcd3c8b6f5e58a0","tests/ui/unstable-features/overlapping_marker_traits.rs":"8af0d8a5afe9dcaa02fa67b394d376f9933cc99361d68f64185769326700bf7c","tests/ui/unstable-features/overlapping_marker_traits.stderr":"a271b507c86b733430c2fe5973029d99128c908422b6161a9b7c7c2fccae3236","tests/ui/unstable-features/trivial_bounds-feature-gate.rs":"658aab9de2e52a54b9e4731faae6a87172b1b4b78f3853c9fd4b565066b74e64","tests/ui/unstable-features/trivial_bounds-feature-gate.stderr":"2c31748846c992c8a68f586ec24fc89b1c630728d0f263ad4b200018ce3cd871","tests/ui/unstable-features/trivial_bounds.rs":"2bc3e4e17645c42b70c023caa3c5bb428addd2a8664465131e32864d31d3691d","tests/ui/unstable-features/trivial_bounds.stderr":"85ed625ee167cc7d7faffbfb006da5591f3d81a9df763d2cbc68523ea602f2fd","tests/unsafe_unpin.rs":"0367781e5109fa9a27347aebe45e633461e396bf883a06c5f809416030c79514"},"package":"fda4ed1c6c173e3fc7a83629421152e01d7b1f9b7f65fb301e490e8cfc656422"}
\ No newline at end of file
diff --git a/crates/pin-project/Android.bp b/crates/pin-project/Android.bp
new file mode 100644
index 0000000..f56c89e
--- /dev/null
+++ b/crates/pin-project/Android.bp
@@ -0,0 +1,32 @@
+// This file is generated by cargo_embargo.
+// Do not modify this file because the changes will be overridden on upgrade.
+
+package {
+    default_applicable_licenses: ["external_rust_crates_pin-project_license"],
+    default_team: "trendy_team_android_rust",
+}
+
+license {
+    name: "external_rust_crates_pin-project_license",
+    visibility: [":__subpackages__"],
+    license_kinds: ["SPDX-license-identifier-Apache-2.0"],
+    license_text: ["LICENSE"],
+}
+
+rust_library {
+    name: "libpin_project",
+    host_supported: true,
+    crate_name: "pin_project",
+    cargo_env_compat: true,
+    cargo_pkg_version: "1.1.3",
+    crate_root: "src/lib.rs",
+    edition: "2021",
+    proc_macros: ["libpin_project_internal"],
+    apex_available: [
+        "//apex_available:platform",
+        "com.android.virt",
+        "com.sdv.*",
+    ],
+    product_available: true,
+    vendor_available: true,
+}
diff --git a/crates/pin-project/CHANGELOG.md b/crates/pin-project/CHANGELOG.md
new file mode 100644
index 0000000..ed5637e
--- /dev/null
+++ b/crates/pin-project/CHANGELOG.md
@@ -0,0 +1,778 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+This project adheres to [Semantic Versioning](https://semver.org).
+
+<!--
+Note: In this file, do not use the hard wrap in the middle of a sentence for compatibility with GitHub comment style markdown rendering.
+-->
+
+## [Unreleased]
+
+## [1.1.3] - 2023-08-06
+
+- Hide documentation of the `Unpin` implementation for `!Unpin` option to work around [rustdoc issue](https://github.com/rust-lang/rust/issues/80481). ([#355](https://github.com/taiki-e/pin-project/pull/355), thanks @matheus-consoli)
+
+## [1.1.2] - 2023-07-02
+
+- Inline project methods.
+
+## [1.1.1] - 2023-06-29
+
+- Fix build error from dependency when built with `-Z minimal-versions`.
+
+## [1.1.0] - 2023-05-13
+
+- Update `syn` dependency to 2. This increase the minimum supported Rust version from Rust 1.37 to Rust 1.56. ([#352](https://github.com/taiki-e/pin-project/pull/352), [#354](https://github.com/taiki-e/pin-project/pull/354), thanks @maurer and @daxpedda)
+
+## [1.0.12] - 2022-08-15
+
+- Suppress `unused_tuple_struct_fields` lint in generated code.
+
+## [1.0.11] - 2022-07-02
+
+- [Suppress `dead_code` lint in generated code.](https://github.com/taiki-e/pin-project/pull/346)
+
+## [1.0.10] - 2021-12-31
+
+- Revert the increase of the minimal version of `syn` that was done in 1.0.9.
+
+## [1.0.9] - 2021-12-26
+
+- [Prevent abuse of private module.](https://github.com/taiki-e/pin-project/pull/336)
+
+- Update minimal version of `syn` to 1.0.84.
+
+## [1.0.8] - 2021-07-21
+
+- [Suppress `clippy::use_self` and `clippy::type_repetition_in_bounds` lints in generated code.](https://github.com/taiki-e/pin-project/pull/331)
+
+## [1.0.7] - 2021-04-16
+
+- [Fix compile error when using `self::` as prefix of path inside `#[pinned_drop]` impl.](https://github.com/taiki-e/pin-project/pull/326)
+
+## [1.0.6] - 2021-03-25
+
+- [Suppress `clippy::semicolon_if_nothing_returned` lint in generated code.](https://github.com/taiki-e/pin-project/pull/318)
+
+## [1.0.5] - 2021-02-03
+
+- [Suppress `deprecated` lint in generated code.](https://github.com/taiki-e/pin-project/pull/313)
+
+## [1.0.4] - 2021-01-09
+
+- [Suppress `clippy::ref_option_ref` lint in generated code.](https://github.com/taiki-e/pin-project/pull/308)
+
+## [1.0.3] - 2021-01-05
+
+- Exclude unneeded files from crates.io.
+
+## [1.0.2] - 2020-11-18
+
+- [Suppress `clippy::unknown_clippy_lints` lint in generated code.](https://github.com/taiki-e/pin-project/pull/303)
+
+## [1.0.1] - 2020-10-15
+
+**Note:** This release has been yanked because it [failed to compile with syn 1.0.84 and later](https://github.com/taiki-e/pin-project/commit/ddcd88079ba2d82857c365f2a3543ad146ade54c).
+
+- [Fix warnings when `#[pin_project]` attribute used within `macro_rules!` macros.](https://github.com/taiki-e/pin-project/pull/298)
+
+## [1.0.0] - 2020-10-13
+
+**Note:** This release has been yanked because it [failed to compile with syn 1.0.84 and later](https://github.com/taiki-e/pin-project/commit/ddcd88079ba2d82857c365f2a3543ad146ade54c).
+
+- [Remove deprecated `#[project]`, `#[project_ref]`, and `#[project_replace]` attributes.](https://github.com/taiki-e/pin-project/pull/265)
+
+  Name the projected type by passing an argument with the same name as the method to the `#[pin_project]` attribute instead:
+
+  ```diff
+  - #[pin_project]
+  + #[pin_project(project = EnumProj)]
+    enum Enum<T> {
+        Variant(#[pin] T),
+    }
+
+  - #[project]
+    fn func<T>(x: Pin<&mut Enum<T>>) {
+  -     #[project]
+        match x.project() {
+  -         Enum::Variant(_) => { /* ... */ }
+  +         EnumProj::Variant(_) => { /* ... */ }
+        }
+    }
+  ```
+
+- [Remove deprecated `Replace` argument from `#[pin_project]` attribute.](https://github.com/taiki-e/pin-project/pull/266) Use `project_replace` argument instead.
+
+- [Optimize code generation when used on enums.](https://github.com/taiki-e/pin-project/pull/270)
+
+- [Raise the minimum supported Rust version of this crate from Rust 1.34 to Rust 1.37.](https://github.com/taiki-e/pin-project/pull/292)
+
+- Suppress `explicit_outlives_requirements`, `box_pointers`, `clippy::large_enum_variant`, `clippy::pattern_type_mismatch`, `clippy::implicit_return`, and `clippy::redundant_pub_crate` lints in generated code. ([#276](https://github.com/taiki-e/pin-project/pull/276), [#277](https://github.com/taiki-e/pin-project/pull/277), [#284](https://github.com/taiki-e/pin-project/pull/284))
+
+- Diagnostic improvements.
+
+Changes since the 1.0.0-alpha.1 release:
+
+- [Fix drop order of pinned fields in `project_replace`.](https://github.com/taiki-e/pin-project/pull/287)
+
+- Update minimal version of `syn` to 1.0.44.
+
+## [1.0.0-alpha.1] - 2020-09-22
+
+- [Remove deprecated `#[project]`, `#[project_ref]`, and `#[project_replace]` attributes.](https://github.com/taiki-e/pin-project/pull/265)
+
+  Name the projected type by passing an argument with the same name as the method to the `#[pin_project]` attribute instead:
+
+  ```diff
+  - #[pin_project]
+  + #[pin_project(project = EnumProj)]
+    enum Enum<T> {
+        Variant(#[pin] T),
+    }
+
+  - #[project]
+    fn func<T>(x: Pin<&mut Enum<T>>) {
+  -     #[project]
+        match x.project() {
+  -         Enum::Variant(_) => { /* ... */ }
+  +         EnumProj::Variant(_) => { /* ... */ }
+        }
+    }
+  ```
+
+- [Remove deprecated `Replace` argument from `#[pin_project]` attribute.](https://github.com/taiki-e/pin-project/pull/266) Use `project_replace` argument instead.
+
+- [Optimize code generation when used on enums.](https://github.com/taiki-e/pin-project/pull/270)
+
+- Suppress `explicit_outlives_requirements`, `box_pointers`, `clippy::large_enum_variant`, `clippy::pattern_type_mismatch`, and `clippy::implicit_return` lints in generated code. ([#276](https://github.com/taiki-e/pin-project/pull/276), [#277](https://github.com/taiki-e/pin-project/pull/277))
+
+- Diagnostic improvements.
+
+See also [tracking issue for 1.0 release](https://github.com/taiki-e/pin-project/issues/264).
+
+## [0.4.30] - 2022-07-02
+
+- [Suppress `dead_code` lint in generated code.](https://github.com/taiki-e/pin-project/pull/347)
+
+## [0.4.29] - 2021-12-26
+
+- [Fix compile error with `syn` 1.0.84 and later.](https://github.com/taiki-e/pin-project/pull/335)
+
+## [0.4.28] - 2021-03-28
+
+**Note:** This release has been yanked because it [failed to compile with syn 1.0.84 and later](https://github.com/taiki-e/pin-project/pull/335).
+
+- [Fix `unused_must_use` warning on unused borrows, which will be added to rustc in the future.](https://github.com/taiki-e/pin-project/pull/322) See [#322](https://github.com/taiki-e/pin-project/pull/322) for more details.
+
+  (Note: 1.0 does not have this problem.)
+
+## [0.4.27] - 2020-10-11
+
+**Note:** This release has been yanked because it [failed to compile with syn 1.0.84 and later](https://github.com/taiki-e/pin-project/pull/335).
+
+- Update minimal version of `syn` to 1.0.44.
+
+## [0.4.26] - 2020-10-04
+
+**Note:** This release has been yanked because it [failed to compile with syn 1.0.84 and later](https://github.com/taiki-e/pin-project/pull/335).
+
+- [Fix drop order of pinned fields in `project_replace`.](https://github.com/taiki-e/pin-project/pull/287)
+
+## [0.4.25] - 2020-10-01
+
+**Note:** This release has been yanked because it [failed to compile with syn 1.0.84 and later](https://github.com/taiki-e/pin-project/pull/335).
+
+- [Suppress `drop_bounds` lint, which will be added to rustc in the future.](https://github.com/taiki-e/pin-project/pull/273) See [#272](https://github.com/taiki-e/pin-project/issues/272) for more details.
+
+  (Note: 1.0.0-alpha.1 already contains this change.)
+
+## [0.4.24] - 2020-09-26
+
+**Note:** This release has been yanked because it [failed to compile with syn 1.0.84 and later](https://github.com/taiki-e/pin-project/pull/335).
+
+- [Fix compatibility of generated code with `forbid(future_incompatible)`.](https://github.com/taiki-e/pin-project/pull/282)
+
+  Note: This does not guarantee compatibility with `forbid(future_incompatible)` in the future.
+  If rustc adds a new lint, we may not be able to keep this.
+
+## [0.4.23] - 2020-07-27
+
+**Note:** This release has been yanked because it [failed to compile with syn 1.0.84 and later](https://github.com/taiki-e/pin-project/pull/335).
+
+- [Fix compile error with `?Sized` type parameters.](https://github.com/taiki-e/pin-project/pull/263)
+
+## [0.4.22] - 2020-06-14
+
+**Note:** This release has been yanked because it [failed to compile with syn 1.0.84 and later](https://github.com/taiki-e/pin-project/pull/335).
+
+- Documentation improvements.
+
+## [0.4.21] - 2020-06-13
+
+**Note:** This release has been yanked because it [failed to compile with syn 1.0.84 and later](https://github.com/taiki-e/pin-project/pull/335).
+
+- [Deprecated `#[project]`, `#[project_ref]`, and `#[project_replace]` attributes due to some unfixable limitations.](https://github.com/taiki-e/pin-project/pull/244)
+
+  Consider naming the projected type by passing an argument with the same name as the method to the `#[pin_project]` attribute instead.
+
+  ```rust
+  #[pin_project(project = EnumProj)]
+  enum Enum<T> {
+      Variant(#[pin] T),
+  }
+
+  fn func<T>(x: Pin<&mut Enum<T>>) {
+      match x.project() {
+          EnumProj::Variant(y) => {
+              let _: Pin<&mut T> = y;
+          }
+      }
+  }
+  ```
+
+  See [#225](https://github.com/taiki-e/pin-project/pull/225) for more details.
+
+- [Support `Self` in fields and generics in type definitions.](https://github.com/taiki-e/pin-project/pull/245)
+
+- [Fix errors involving *"`self` value is a keyword only available in methods with `self` parameter"* in apparently correct code.](https://github.com/taiki-e/pin-project/pull/250)
+
+- Diagnostic improvements.
+
+## [0.4.20] - 2020-06-07
+
+**Note:** This release has been yanked because it [failed to compile with syn 1.0.84 and later](https://github.com/taiki-e/pin-project/pull/335).
+
+- [You can now use `project_replace` argument without Replace argument.](https://github.com/taiki-e/pin-project/pull/243)
+  This used to require you to specify both.
+
+  ```diff
+  - #[pin_project(Replace, project_replace = EnumProjOwn)]
+  + #[pin_project(project_replace = EnumProjOwn)]
+    enum Enum<T> {
+        Variant(#[pin] T)
+    }
+  ```
+
+- [Make `project_replace` argument an alias for `Replace` argument so that it can be used without a value.](https://github.com/taiki-e/pin-project/pull/243)
+
+  ```rust
+  #[pin_project(project_replace)]
+  enum Enum<T> {
+      Variant(#[pin] T)
+  }
+  ```
+
+  *The `Replace` argument will be deprecated in the future.*
+
+- [Suppress `unreachable_pub` lint in generated code.](https://github.com/taiki-e/pin-project/pull/240)
+
+## [0.4.19] - 2020-06-04
+
+**Note:** This release has been yanked because it [failed to compile with syn 1.0.84 and later](https://github.com/taiki-e/pin-project/pull/335).
+
+- [Suppress `unused_results` lint in generated code.](https://github.com/taiki-e/pin-project/pull/239)
+
+## [0.4.18] - 2020-06-04
+
+**Note:** This release has been yanked because it [failed to compile with syn 1.0.84 and later](https://github.com/taiki-e/pin-project/pull/335).
+
+- [Support `Self` in more syntax positions inside `#[pinned_drop]` impl.](https://github.com/taiki-e/pin-project/pull/230)
+
+- [Suppress `clippy::type_repetition_in_bounds` and `clippy::used_underscore_binding` lints in generated code.](https://github.com/taiki-e/pin-project/pull/233)
+
+- Documentation improvements.
+
+- Diagnostic improvements.
+
+## [0.4.17] - 2020-05-18
+
+**Note:** This release has been yanked because it [failed to compile with syn 1.0.84 and later](https://github.com/taiki-e/pin-project/pull/335).
+
+- [Support naming the projection types.](https://github.com/taiki-e/pin-project/pull/202)
+
+  By passing an argument with the same name as the method to the attribute, you can name the projection type returned from the method:
+
+  ```rust
+  #[pin_project(project = EnumProj)]
+  enum Enum<T> {
+      Variant(#[pin] T),
+  }
+
+  fn func<T>(x: Pin<&mut Enum<T>>) {
+      match x.project() {
+          EnumProj::Variant(y) => {
+              let _: Pin<&mut T> = y;
+          }
+      }
+  }
+  ```
+
+## [0.4.16] - 2020-05-11
+
+**Note:** This release has been yanked because it [failed to compile with syn 1.0.84 and later](https://github.com/taiki-e/pin-project/pull/335).
+
+- [Fix an issue that users can call internal function generated by `#[pinned_drop]`.](https://github.com/taiki-e/pin-project/pull/223)
+
+## [0.4.15] - 2020-05-10
+
+**Note:** This release has been yanked because it [failed to compile with syn 1.0.84 and later](https://github.com/taiki-e/pin-project/pull/335).
+
+- [`#[project]` attribute can now handle all `project*` attributes in that scope with one wrapper attribute.](https://github.com/taiki-e/pin-project/pull/220)
+
+## [0.4.14] - 2020-05-09
+
+**Note:** This release has been yanked because it [failed to compile with syn 1.0.84 and later](https://github.com/taiki-e/pin-project/pull/335).
+
+- [Add `!Unpin` option to `#[pin_project]` attribute for guarantee the type is `!Unpin`.](https://github.com/taiki-e/pin-project/pull/219)
+
+  ```rust
+  #[pin_project(!Unpin)]
+  struct Struct<T, U> {
+      field: T,
+  }
+  ```
+
+  This is equivalent to use `#[pin]` attribute for `PhantomPinned` field.
+
+  ```rust
+  #[pin_project]
+  struct Struct<T, U> {
+      field: T,
+      #[pin] // Note that using `PhantomPinned` without `#[pin]` attribute has no effect.
+      _pin: PhantomPinned,
+  }
+  ```
+
+  *[Note: This raises the minimum supported Rust version of this crate from Rust 1.33 to Rust 1.34.](https://github.com/taiki-e/pin-project/pull/219#pullrequestreview-408644187)*
+
+- [Fix an issue where duplicate `#[project]` attributes were ignored.](https://github.com/taiki-e/pin-project/pull/218)
+
+- [Suppress `single_use_lifetimes` lint in generated code.](https://github.com/taiki-e/pin-project/pull/217)
+
+- [Support overlapping lifetime names in HRTB.](https://github.com/taiki-e/pin-project/pull/217)
+
+- [Hide generated items from --document-private-items.](https://github.com/taiki-e/pin-project/pull/211) See [#211](https://github.com/taiki-e/pin-project/pull/211) for details.
+
+- Documentation improvements.
+
+## [0.4.13] - 2020-05-07
+
+**Note:** This release has been yanked because it [failed to compile with syn 1.0.84 and later](https://github.com/taiki-e/pin-project/pull/335).
+
+- [Fix a regression in 0.4.11.](https://github.com/taiki-e/pin-project/pull/207)
+
+  Changes from [0.4.10](https://github.com/taiki-e/pin-project/releases/tag/v0.4.10) and [0.4.12](https://github.com/taiki-e/pin-project/releases/tag/v0.4.12):
+
+  - [Fix an issue that `#[project]` on non-statement expression does not work without unstable features.](https://github.com/taiki-e/pin-project/pull/197)
+
+  - [Support overwriting the name of core crate.](https://github.com/taiki-e/pin-project/pull/199)
+
+  - [Suppress `clippy::needless_pass_by_value` lint in generated code of `#[pinned_drop]`.](https://github.com/taiki-e/pin-project/pull/200)
+
+  - Documentation improvements.
+
+  - Diagnostic improvements.
+
+## [0.4.12] - 2020-05-07
+
+**Note:** This release has been yanked because it [failed to compile with syn 1.0.84 and later](https://github.com/taiki-e/pin-project/pull/335).
+
+- A release to avoid [a regression in 0.4.11](https://github.com/taiki-e/pin-project/issues/206). No code changes from [0.4.10](https://github.com/taiki-e/pin-project/releases/tag/v0.4.10).
+
+## [0.4.11] - 2020-05-07
+
+**Note:** This release has been yanked. See [#206](https://github.com/taiki-e/pin-project/issues/206) for details.
+
+- [Fix an issue that `#[project]` on non-statement expression does not work without unstable features.](https://github.com/taiki-e/pin-project/pull/197)
+
+- [Support overwriting the name of core crate.](https://github.com/taiki-e/pin-project/pull/199)
+
+- [Suppress `clippy::needless_pass_by_value` lint in generated code of `#[pinned_drop]`.](https://github.com/taiki-e/pin-project/pull/200)
+
+- Documentation improvements.
+
+- Diagnostic improvements.
+
+## [0.4.10] - 2020-05-04
+
+**Note:** This release has been yanked because it [failed to compile with syn 1.0.84 and later](https://github.com/taiki-e/pin-project/pull/335).
+
+- [Add `project_replace` method and `#[project_replace]` attribute.](https://github.com/taiki-e/pin-project/pull/194)
+  `project_replace` method is optional and can be enabled by passing the `Replace` argument to `#[pin_project]` attribute.
+  See [the documentation](https://docs.rs/pin-project/0.4/pin_project/attr.pin_project.html#project_replace) for more details.
+
+- [Support `Self` and `self` in more syntax positions inside `#[pinned_drop]` impl.](https://github.com/taiki-e/pin-project/pull/190)
+
+- [Hide all generated items except for projected types from calling code.](https://github.com/taiki-e/pin-project/pull/192) See [#192](https://github.com/taiki-e/pin-project/pull/192) for details.
+
+## [0.4.9] - 2020-04-14
+
+**Note:** This release has been yanked because it [failed to compile with syn 1.0.84 and later](https://github.com/taiki-e/pin-project/pull/335).
+
+- [Fix lifetime inference error when associated types are used in fields.](https://github.com/taiki-e/pin-project/pull/188)
+
+- [Fix compile error with tuple structs with `where` clauses.](https://github.com/taiki-e/pin-project/pull/186)
+
+- [`#[project]` attribute can now be used for `if let` expressions.](https://github.com/taiki-e/pin-project/pull/181)
+
+## [0.4.8] - 2020-01-27
+
+**Note:** This release has been yanked because it [failed to compile with syn 1.0.84 and later](https://github.com/taiki-e/pin-project/pull/335).
+
+- [Ensure that users cannot implement `PinnedDrop` without proper attribute argument.](https://github.com/taiki-e/pin-project/pull/180)
+
+- [Fix use of `Self` in expression position inside `#[pinned_drop]` impl.](https://github.com/taiki-e/pin-project/pull/177)
+
+## [0.4.7] - 2020-01-20
+
+**Note:** This release has been yanked because it [failed to compile with syn 1.0.84 and later](https://github.com/taiki-e/pin-project/pull/335).
+
+- [Fix support for lifetime bounds.](https://github.com/taiki-e/pin-project/pull/176)
+
+## [0.4.6] - 2019-11-20
+
+**Note:** This release has been yanked because it [failed to compile with syn 1.0.84 and later](https://github.com/taiki-e/pin-project/pull/335).
+
+- [Fix compile error when there is `Self` in the where clause.](https://github.com/taiki-e/pin-project/pull/169)
+
+## [0.4.5] - 2019-10-21
+
+**Note:** This release has been yanked because it [failed to compile with syn 1.0.84 and later](https://github.com/taiki-e/pin-project/pull/335).
+
+- [Fix compile error with `dyn` types.](https://github.com/taiki-e/pin-project/pull/158)
+
+## [0.4.4] - 2019-10-17
+
+**Note:** This release has been yanked because it [failed to compile with syn 1.0.84 and later](https://github.com/taiki-e/pin-project/pull/335).
+
+- [Fix an issue where `PinnedDrop` implementations can call unsafe code without an unsafe block.](https://github.com/taiki-e/pin-project/pull/149)
+
+## [0.4.3] - 2019-10-15
+
+**Note:** This release has been yanked. See [#148](https://github.com/taiki-e/pin-project/pull/148) for details.
+
+- [`#[pin_project]` can now interoperate with `#[cfg_attr()]`.](https://github.com/taiki-e/pin-project/pull/135)
+
+- [`#[pin_project]` can now interoperate with `#[cfg()]` on tuple structs and tuple variants.](https://github.com/taiki-e/pin-project/pull/135)
+
+- [Fix support for DSTs(Dynamically Sized Types) on `#[pin_project(UnsafeUnpin)]`](https://github.com/taiki-e/pin-project/pull/120)
+
+- Diagnostic improvements.
+
+## [0.4.2] - 2019-09-29
+
+**Note:** This release has been yanked. See [#148](https://github.com/taiki-e/pin-project/pull/148) for details.
+
+- [Fix support for DSTs(Dynamically Sized Types).](https://github.com/taiki-e/pin-project/pull/113)
+
+## [0.4.1] - 2019-09-26
+
+**Note:** This release has been yanked. See [#148](https://github.com/taiki-e/pin-project/pull/148) for details.
+
+- [Fix an issue that caused an error when using `#[pin_project]` on a type that has `#[pin]` + `!Unpin` field with no generics or lifetime.](https://github.com/taiki-e/pin-project/pull/111)
+
+## [0.4.0] - 2019-09-25
+
+**Note:** This release has been yanked. See [#148](https://github.com/taiki-e/pin-project/pull/148) for details.
+
+- [**Pin projection has become a safe operation.**](https://github.com/taiki-e/pin-project/pull/18) In the absence of other unsafe code that you write, it is impossible to cause undefined behavior.
+
+- `#[unsafe_project]` attribute has been replaced with `#[pin_project]` attribute. ([#18](https://github.com/taiki-e/pin-project/pull/18), [#33](https://github.com/taiki-e/pin-project/pull/33))
+
+- [The `Unpin` argument has been removed - an `Unpin` impl is now generated by default.](https://github.com/taiki-e/pin-project/pull/18)
+
+- Drop impls must be specified with `#[pinned_drop]` instead of via a normal `Drop` impl. ([#18](https://github.com/taiki-e/pin-project/pull/18), [#33](https://github.com/taiki-e/pin-project/pull/33), [#86](https://github.com/taiki-e/pin-project/pull/86))
+
+- [`Unpin` impls must be specified with an impl of `UnsafeUnpin`, instead of implementing the normal `Unpin` trait.](https://github.com/taiki-e/pin-project/pull/18)
+
+- [`#[pin_project]` attribute now determines the visibility of the projection type/method is based on the original type.](https://github.com/taiki-e/pin-project/pull/96)
+
+- [`#[pin_project]` can now be used for public type with private field types.](https://github.com/taiki-e/pin-project/pull/53)
+
+- [`#[pin_project]` can now interoperate with `#[cfg()]`.](https://github.com/taiki-e/pin-project/pull/77)
+
+- [Add `project_ref` method to `#[pin_project]` types.](https://github.com/taiki-e/pin-project/pull/93)
+
+- [Add `#[project_ref]` attribute.](https://github.com/taiki-e/pin-project/pull/93)
+
+- [Remove "project_attr" feature and always enable `#[project]` attribute.](https://github.com/taiki-e/pin-project/pull/94)
+
+- [`#[project]` attribute can now be used for `impl` blocks.](https://github.com/taiki-e/pin-project/pull/46)
+
+- [`#[project]` attribute can now be used for `use` statements.](https://github.com/taiki-e/pin-project/pull/85)
+
+- [`#[project]` attribute now supports `match` expressions at the position of the initializer expression of `let` expressions.](https://github.com/taiki-e/pin-project/pull/51)
+
+Changes since the 0.4.0-beta.1 release:
+
+- [Fix an issue that caused an error when using `#[pin_project(UnsafeUnpin)]` and not providing a manual `UnsafeUnpin` implementation on a type with no generics or lifetime.](https://github.com/taiki-e/pin-project/pull/107)
+
+## [0.4.0-beta.1] - 2019-09-21
+
+- [Change the argument type of project method back to `self: Pin<&mut Self>`.](https://github.com/taiki-e/pin-project/pull/90)
+
+- [Remove "project_attr" feature and always enable `#[project]` attribute.](https://github.com/taiki-e/pin-project/pull/94)
+
+- [Remove "renamed" feature.](https://github.com/taiki-e/pin-project/pull/100)
+
+- [`#[project]` attribute can now be used for `use` statements.](https://github.com/taiki-e/pin-project/pull/85)
+
+- [Add `project_ref` method and `#[project_ref]` attribute.](https://github.com/taiki-e/pin-project/pull/93)
+
+- [`#[pin_project]` attribute now determines the visibility of the projection type/method is based on the original type.](https://github.com/taiki-e/pin-project/pull/96)
+
+## [0.4.0-alpha.11] - 2019-09-11
+
+- [Change #[pinned_drop] to trait implementation.](https://github.com/taiki-e/pin-project/pull/86)
+
+  ```rust
+  #[pinned_drop]
+  impl<T> PinnedDrop for Foo<'_, T> {
+      fn drop(mut self: Pin<&mut Self>) {
+          **self.project().was_dropped = true;
+      }
+  }
+  ```
+
+- Add some examples and generated code.
+
+- Diagnostic improvements.
+
+## [0.4.0-alpha.10] - 2019-09-07
+
+- [`#[pin_project]` can now interoperate with `#[cfg()]`.](https://github.com/taiki-e/pin-project/pull/77)
+
+- Documentation improvements.
+
+## [0.4.0-alpha.9] - 2019-09-05
+
+- [Add `project_into` method to `#[pin_project]` types](https://github.com/taiki-e/pin-project/pull/69). This can be useful when returning a pin projection from a method.
+
+  ```rust
+  fn get_pin_mut(self: Pin<&mut Self>) -> Pin<&mut T> {
+      self.project_into().pinned
+  }
+  ```
+
+- [Prevent `UnpinStruct` from appearing in the document by default.](https://github.com/taiki-e/pin-project/pull/71) See [#71](https://github.com/taiki-e/pin-project/pull/71) for more details.
+
+## [0.4.0-alpha.8] - 2019-09-03
+
+- [Improve document of generated code.](https://github.com/taiki-e/pin-project/pull/62). Also added an option to control the document of generated code. See [#62](https://github.com/taiki-e/pin-project/pull/62) for more details.
+
+- [Diagnostic improvements.](https://github.com/taiki-e/pin-project/pull/61)
+
+## [0.4.0-alpha.7] - 2019-09-02
+
+- [Suppress `dead_code` lint in generated types.](https://github.com/taiki-e/pin-project/pull/57)
+
+## [0.4.0-alpha.6] - 2019-09-01
+
+- [Allow using `#[pin_project]` type with private field types](https://github.com/taiki-e/pin-project/pull/53)
+
+## [0.4.0-alpha.5] - 2019-08-24
+
+- [`#[project]` attribute now supports `match` expressions at the position of the initializer expression of `let` expressions.](https://github.com/taiki-e/pin-project/pull/51)
+
+## [0.4.0-alpha.4] - 2019-08-23
+
+- Suppress `clippy::drop_bounds` lint in generated code.
+
+## [0.4.0-alpha.3] - 2019-08-23
+
+- [Change `project` method generated by `#[pin_project]` attribute to take an `&mut Pin<&mut Self>` argument.](https://github.com/taiki-e/pin-project/pull/47)
+
+- [`#[project]` attribute can now be used for impl blocks.](https://github.com/taiki-e/pin-project/pull/46)
+
+- [`#[pin_project]` attribute can now detect that the type used does not have its own drop implementation without actually implementing drop.](https://github.com/taiki-e/pin-project/pull/48) This removed some restrictions.
+
+## [0.4.0-alpha.2] - 2019-08-13
+
+- Update `proc-macro2`, `syn`, and `quote` to 1.0.
+
+## [0.4.0-alpha.1] - 2019-08-11
+
+- **Pin projection has become a safe operation.**
+
+- `#[unsafe_project]` has been replaced with `#[pin_project]`.
+
+- The `Unpin` argument has been removed - an `Unpin` impl is now generated by default.
+
+- Drop impls must be specified with `#[pinned_drop]` instead of via a normal `Drop` impl.
+
+- `Unpin` impls must be specified with an impl of `UnsafeUnpin`, instead of implementing the normal `Unpin` trait.
+
+- Make `#[project]` attribute disabled by default.
+
+See also [tracking issue for 0.4 release](https://github.com/taiki-e/pin-project/issues/21).
+
+## [0.3.5] - 2019-08-14
+
+- Update `proc-macro2`, `syn`, and `quote` to 1.0.
+
+## [0.3.4] - 2019-07-21
+
+- Diagnostic improvements.
+
+## [0.3.3] - 2019-07-15
+
+**Note:** This release has been yanked. See [#16](https://github.com/taiki-e/pin-project/issues/16) for details.
+
+- Diagnostic improvements.
+
+## [0.3.2] - 2019-03-30
+
+- Avoid suffixes on tuple index.
+
+## [0.3.1] - 2019-03-02
+
+- Documentation improvements.
+
+- Update minimum `syn` version to 0.15.22.
+
+## [0.3.0] - 2019-02-20
+
+- Remove `unsafe_fields` attribute.
+
+- Remove `unsafe_variants` attribute.
+
+## [0.2.2] - 2019-02-20
+
+- Fix a bug that generates incorrect code for the some structures with trait bounds on type generics.
+
+## [0.2.1] - 2019-02-20
+
+- Fix a bug that generates incorrect code for the structures with where clause and associated type fields.
+
+## [0.2.0] - 2019-02-11
+
+- Make `unsafe_fields` optional.
+
+- Documentation improvements.
+
+## [0.1.8] - 2019-02-02
+
+- Add the feature to create projected enums to `unsafe_project`.
+
+- Add `project` attribute to support pattern matching.
+
+## [0.1.7] - 2019-01-19
+
+- Fix documentation.
+
+## [0.1.6] - 2019-01-19
+
+- `unsafe_fields` can now opt-out.
+
+- Add `unsafe_variants` attribute. This attribute is available if pin-project is built with the "unsafe_variants" feature.
+
+## [0.1.5] - 2019-01-17
+
+- Add support for tuple struct to `unsafe_project`.
+
+## [0.1.4] - 2019-01-12
+
+- Add options for automatically implementing `Unpin` to both `unsafe_project` and `unsafe_fields`.
+
+## [0.1.3] - 2019-01-11
+
+- Fix dependencies.
+
+- Add `unsafe_fields` attribute.
+
+## [0.1.2] - 2019-01-09
+
+- Documentation improvements.
+
+## [0.1.1] - 2019-01-08
+
+- Rename from `unsafe_pin_project` to `unsafe_project`.
+
+## [0.1.0] - 2019-01-08
+
+**Note:** This release has been yanked.
+
+Initial release
+
+[Unreleased]: https://github.com/taiki-e/pin-project/compare/v1.1.3...HEAD
+[1.1.3]: https://github.com/taiki-e/pin-project/compare/v1.1.2...v1.1.3
+[1.1.2]: https://github.com/taiki-e/pin-project/compare/v1.1.1...v1.1.2
+[1.1.1]: https://github.com/taiki-e/pin-project/compare/v1.1.0...v1.1.1
+[1.1.0]: https://github.com/taiki-e/pin-project/compare/v1.0.12...v1.1.0
+[1.0.12]: https://github.com/taiki-e/pin-project/compare/v1.0.11...v1.0.12
+[1.0.11]: https://github.com/taiki-e/pin-project/compare/v1.0.10...v1.0.11
+[1.0.10]: https://github.com/taiki-e/pin-project/compare/v1.0.9...v1.0.10
+[1.0.9]: https://github.com/taiki-e/pin-project/compare/v1.0.8...v1.0.9
+[1.0.8]: https://github.com/taiki-e/pin-project/compare/v1.0.7...v1.0.8
+[1.0.7]: https://github.com/taiki-e/pin-project/compare/v1.0.6...v1.0.7
+[1.0.6]: https://github.com/taiki-e/pin-project/compare/v1.0.5...v1.0.6
+[1.0.5]: https://github.com/taiki-e/pin-project/compare/v1.0.4...v1.0.5
+[1.0.4]: https://github.com/taiki-e/pin-project/compare/v1.0.3...v1.0.4
+[1.0.3]: https://github.com/taiki-e/pin-project/compare/v1.0.2...v1.0.3
+[1.0.2]: https://github.com/taiki-e/pin-project/compare/v1.0.1...v1.0.2
+[1.0.1]: https://github.com/taiki-e/pin-project/compare/v1.0.0...v1.0.1
+[1.0.0]: https://github.com/taiki-e/pin-project/compare/v1.0.0-alpha.1...v1.0.0
+[1.0.0-alpha.1]: https://github.com/taiki-e/pin-project/compare/v0.4.23...v1.0.0-alpha.1
+[0.4.30]: https://github.com/taiki-e/pin-project/compare/v0.4.29...v0.4.30
+[0.4.29]: https://github.com/taiki-e/pin-project/compare/v0.4.28...v0.4.29
+[0.4.28]: https://github.com/taiki-e/pin-project/compare/v0.4.27...v0.4.28
+[0.4.27]: https://github.com/taiki-e/pin-project/compare/v0.4.26...v0.4.27
+[0.4.26]: https://github.com/taiki-e/pin-project/compare/v0.4.25...v0.4.26
+[0.4.25]: https://github.com/taiki-e/pin-project/compare/v0.4.24...v0.4.25
+[0.4.24]: https://github.com/taiki-e/pin-project/compare/v0.4.23...v0.4.24
+[0.4.23]: https://github.com/taiki-e/pin-project/compare/v0.4.22...v0.4.23
+[0.4.22]: https://github.com/taiki-e/pin-project/compare/v0.4.21...v0.4.22
+[0.4.21]: https://github.com/taiki-e/pin-project/compare/v0.4.20...v0.4.21
+[0.4.20]: https://github.com/taiki-e/pin-project/compare/v0.4.19...v0.4.20
+[0.4.19]: https://github.com/taiki-e/pin-project/compare/v0.4.18...v0.4.19
+[0.4.18]: https://github.com/taiki-e/pin-project/compare/v0.4.17...v0.4.18
+[0.4.17]: https://github.com/taiki-e/pin-project/compare/v0.4.16...v0.4.17
+[0.4.16]: https://github.com/taiki-e/pin-project/compare/v0.4.15...v0.4.16
+[0.4.15]: https://github.com/taiki-e/pin-project/compare/v0.4.14...v0.4.15
+[0.4.14]: https://github.com/taiki-e/pin-project/compare/v0.4.13...v0.4.14
+[0.4.13]: https://github.com/taiki-e/pin-project/compare/v0.4.11...v0.4.13
+[0.4.12]: https://github.com/taiki-e/pin-project/compare/v0.4.10...v0.4.12
+[0.4.11]: https://github.com/taiki-e/pin-project/compare/v0.4.10...v0.4.11
+[0.4.10]: https://github.com/taiki-e/pin-project/compare/v0.4.9...v0.4.10
+[0.4.9]: https://github.com/taiki-e/pin-project/compare/v0.4.8...v0.4.9
+[0.4.8]: https://github.com/taiki-e/pin-project/compare/v0.4.7...v0.4.8
+[0.4.7]: https://github.com/taiki-e/pin-project/compare/v0.4.6...v0.4.7
+[0.4.6]: https://github.com/taiki-e/pin-project/compare/v0.4.5...v0.4.6
+[0.4.5]: https://github.com/taiki-e/pin-project/compare/v0.4.4...v0.4.5
+[0.4.4]: https://github.com/taiki-e/pin-project/compare/v0.4.3...v0.4.4
+[0.4.3]: https://github.com/taiki-e/pin-project/compare/v0.4.2...v0.4.3
+[0.4.2]: https://github.com/taiki-e/pin-project/compare/v0.4.1...v0.4.2
+[0.4.1]: https://github.com/taiki-e/pin-project/compare/v0.4.0...v0.4.1
+[0.4.0]: https://github.com/taiki-e/pin-project/compare/v0.4.0-beta.1...v0.4.0
+[0.4.0-beta.1]: https://github.com/taiki-e/pin-project/compare/v0.4.0-alpha.11...v0.4.0-beta.1
+[0.4.0-alpha.11]: https://github.com/taiki-e/pin-project/compare/v0.4.0-alpha.10...v0.4.0-alpha.11
+[0.4.0-alpha.10]: https://github.com/taiki-e/pin-project/compare/v0.4.0-alpha.9...v0.4.0-alpha.10
+[0.4.0-alpha.9]: https://github.com/taiki-e/pin-project/compare/v0.4.0-alpha.8...v0.4.0-alpha.9
+[0.4.0-alpha.8]: https://github.com/taiki-e/pin-project/compare/v0.4.0-alpha.7...v0.4.0-alpha.8
+[0.4.0-alpha.7]: https://github.com/taiki-e/pin-project/compare/v0.4.0-alpha.6...v0.4.0-alpha.7
+[0.4.0-alpha.6]: https://github.com/taiki-e/pin-project/compare/v0.4.0-alpha.5...v0.4.0-alpha.6
+[0.4.0-alpha.5]: https://github.com/taiki-e/pin-project/compare/v0.4.0-alpha.4...v0.4.0-alpha.5
+[0.4.0-alpha.4]: https://github.com/taiki-e/pin-project/compare/v0.4.0-alpha.3...v0.4.0-alpha.4
+[0.4.0-alpha.3]: https://github.com/taiki-e/pin-project/compare/v0.4.0-alpha.2...v0.4.0-alpha.3
+[0.4.0-alpha.2]: https://github.com/taiki-e/pin-project/compare/v0.4.0-alpha.1...v0.4.0-alpha.2
+[0.4.0-alpha.1]: https://github.com/taiki-e/pin-project/compare/v0.3.5...v0.4.0-alpha.1
+[0.3.5]: https://github.com/taiki-e/pin-project/compare/v0.3.4...v0.3.5
+[0.3.4]: https://github.com/taiki-e/pin-project/compare/v0.3.3...v0.3.4
+[0.3.3]: https://github.com/taiki-e/pin-project/compare/v0.3.2...v0.3.3
+[0.3.2]: https://github.com/taiki-e/pin-project/compare/v0.3.1...v0.3.2
+[0.3.1]: https://github.com/taiki-e/pin-project/compare/v0.3.0...v0.3.1
+[0.3.0]: https://github.com/taiki-e/pin-project/compare/v0.2.2...v0.3.0
+[0.2.2]: https://github.com/taiki-e/pin-project/compare/v0.2.1...v0.2.2
+[0.2.1]: https://github.com/taiki-e/pin-project/compare/v0.2.0...v0.2.1
+[0.2.0]: https://github.com/taiki-e/pin-project/compare/v0.1.8...v0.2.0
+[0.1.8]: https://github.com/taiki-e/pin-project/compare/v0.1.7...v0.1.8
+[0.1.7]: https://github.com/taiki-e/pin-project/compare/v0.1.6...v0.1.7
+[0.1.6]: https://github.com/taiki-e/pin-project/compare/v0.1.5...v0.1.6
+[0.1.5]: https://github.com/taiki-e/pin-project/compare/v0.1.4...v0.1.5
+[0.1.4]: https://github.com/taiki-e/pin-project/compare/v0.1.3...v0.1.4
+[0.1.3]: https://github.com/taiki-e/pin-project/compare/v0.1.2...v0.1.3
+[0.1.2]: https://github.com/taiki-e/pin-project/compare/v0.1.1...v0.1.2
+[0.1.1]: https://github.com/taiki-e/pin-project/compare/v0.1.0...v0.1.1
+[0.1.0]: https://github.com/taiki-e/pin-project/releases/tag/v0.1.0
diff --git a/crates/pin-project/Cargo.lock b/crates/pin-project/Cargo.lock
new file mode 100644
index 0000000..b56bca1
--- /dev/null
+++ b/crates/pin-project/Cargo.lock
@@ -0,0 +1,242 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "basic-toml"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7bfc506e7a2370ec239e1d072507b2a80c833083699d3c6fa176fbb4de8448c6"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "diff"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8"
+
+[[package]]
+name = "glob"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"
+
+[[package]]
+name = "itoa"
+version = "1.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af150ab688ff2122fcef229be89cb50dd66af9e01a4ff320cc137eecc9bacc38"
+
+[[package]]
+name = "macrotest"
+version = "1.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7489ae0986ce45414b7b3122c2e316661343ecf396b206e3e15f07c846616f10"
+dependencies = [
+ "diff",
+ "glob",
+ "prettyplease",
+ "serde",
+ "serde_json",
+ "syn 1.0.109",
+ "toml",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd8b5dd2ae5ed71462c540258bedcb51965123ad7e7ccf4b9a8cafaa4a63576d"
+
+[[package]]
+name = "pin-project"
+version = "1.1.3"
+dependencies = [
+ "macrotest",
+ "pin-project-internal",
+ "rustversion",
+ "static_assertions",
+ "trybuild",
+]
+
+[[package]]
+name = "pin-project-internal"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4359fd9c9171ec6e8c62926d6faaf553a8dc3f64e1507e76da7911b4f6a04405"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.28",
+]
+
+[[package]]
+name = "prettyplease"
+version = "0.1.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c8646e95016a7a6c4adea95bafa8a16baab64b583356217f2c85db4a39d9a86"
+dependencies = [
+ "proc-macro2",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.66"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18fb31db3f9bddb2ea821cde30a9f70117e3f119938b5ee630b7403aa6e2ead9"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50f3b39ccfb720540debaa0164757101c08ecb8d326b15358ce76a62c7e85965"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ffc183a10b4478d04cbbbfc96d0873219d962dd5accaff2ffbd4ceb7df837f4"
+
+[[package]]
+name = "ryu"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ad4cc8da4ef723ed60bced201181d83791ad433213d8c24efffda1eec85d741"
+
+[[package]]
+name = "serde"
+version = "1.0.181"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d3e73c93c3240c0bda063c239298e633114c69a888c3e37ca8bb33f343e9890"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.181"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be02f6cb0cd3a5ec20bbcfbcbd749f57daddb1a0882dc2e46a6c236c90b977ed"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.28",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.104"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "076066c5f1078eac5b722a31827a8832fe108bed65dfa75e233c89f8206e976c"
+dependencies = [
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "static_assertions"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
+
+[[package]]
+name = "syn"
+version = "1.0.109"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04361975b3f5e348b2189d8dc55bc942f278b2d482a6a0365de5bdd62d351567"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "termcolor"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be55cf8942feac5c765c2c993422806843c9a9a45d4d5c407ad6dd2ea95eb9b6"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "toml"
+version = "0.5.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f4f7f0dd8d50a853a531c426359045b1998f04219d88799810762cd4ad314234"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "trybuild"
+version = "1.0.82"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a84e0202ea606ba5ebee8507ab2bfbe89b98551ed9b8f0be198109275cff284b"
+dependencies = [
+ "basic-toml",
+ "glob",
+ "once_cell",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "termcolor",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "301abaae475aa91687eb82514b328ab47a211a533026cb25fc3e519b86adfc3c"
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
diff --git a/crates/pin-project/Cargo.toml b/crates/pin-project/Cargo.toml
new file mode 100644
index 0000000..5a34ad6
--- /dev/null
+++ b/crates/pin-project/Cargo.toml
@@ -0,0 +1,58 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2021"
+rust-version = "1.56"
+name = "pin-project"
+version = "1.1.3"
+exclude = [
+    "/.*",
+    "/tools",
+    "/DEVELOPMENT.md",
+]
+description = """
+A crate for safe and ergonomic pin-projection.
+"""
+readme = "README.md"
+keywords = [
+    "pin",
+    "macros",
+    "attribute",
+]
+categories = [
+    "no-std",
+    "no-std::no-alloc",
+    "rust-patterns",
+]
+license = "Apache-2.0 OR MIT"
+repository = "https://github.com/taiki-e/pin-project"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[lib]
+doc-scrape-examples = false
+
+[dependencies.pin-project-internal]
+version = "=1.1.3"
+
+[dev-dependencies.macrotest]
+version = "1.0.9"
+
+[dev-dependencies.rustversion]
+version = "1"
+
+[dev-dependencies.static_assertions]
+version = "1"
+
+[dev-dependencies.trybuild]
+version = "1.0.67"
diff --git a/crates/pin-project/LICENSE b/crates/pin-project/LICENSE
new file mode 120000
index 0000000..6b579aa
--- /dev/null
+++ b/crates/pin-project/LICENSE
@@ -0,0 +1 @@
+LICENSE-APACHE
\ No newline at end of file
diff --git a/crates/pin-project/LICENSE-APACHE b/crates/pin-project/LICENSE-APACHE
new file mode 100644
index 0000000..f433b1a
--- /dev/null
+++ b/crates/pin-project/LICENSE-APACHE
@@ -0,0 +1,177 @@
+
+                                 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
diff --git a/crates/pin-project/LICENSE-MIT b/crates/pin-project/LICENSE-MIT
new file mode 100644
index 0000000..31aa793
--- /dev/null
+++ b/crates/pin-project/LICENSE-MIT
@@ -0,0 +1,23 @@
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/crates/pin-project/METADATA b/crates/pin-project/METADATA
new file mode 100644
index 0000000..95dfea0
--- /dev/null
+++ b/crates/pin-project/METADATA
@@ -0,0 +1,23 @@
+# This project was upgraded with external_updater.
+# Usage: tools/external_updater/updater.sh update rust/crates/pin-project
+# For more info, check https://cs.android.com/android/platform/superproject/+/main:tools/external_updater/README.md
+
+name: "pin-project"
+description: "A crate for safe and ergonomic pin-projection."
+third_party {
+  url {
+    type: HOMEPAGE
+    value: "https://crates.io/crates/pin-project"
+  }
+  url {
+    type: ARCHIVE
+    value: "https://static.crates.io/crates/pin-project/pin-project-1.1.3.crate"
+  }
+  version: "1.1.3"
+  license_type: NOTICE
+  last_upgrade_date {
+    year: 2023
+    month: 11
+    day: 14
+  }
+}
diff --git a/crates/pin-project/MODULE_LICENSE_APACHE2 b/crates/pin-project/MODULE_LICENSE_APACHE2
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/crates/pin-project/MODULE_LICENSE_APACHE2
diff --git a/crates/pin-project/NOTICE b/crates/pin-project/NOTICE
new file mode 120000
index 0000000..7a694c9
--- /dev/null
+++ b/crates/pin-project/NOTICE
@@ -0,0 +1 @@
+LICENSE
\ No newline at end of file
diff --git a/crates/pin-project/README.md b/crates/pin-project/README.md
new file mode 100644
index 0000000..8a98e04
--- /dev/null
+++ b/crates/pin-project/README.md
@@ -0,0 +1,105 @@
+# pin-project
+
+[![crates.io](https://img.shields.io/crates/v/pin-project?style=flat-square&logo=rust)](https://crates.io/crates/pin-project)
+[![docs.rs](https://img.shields.io/badge/docs.rs-pin--project-blue?style=flat-square&logo=docs.rs)](https://docs.rs/pin-project)
+[![license](https://img.shields.io/badge/license-Apache--2.0_OR_MIT-blue?style=flat-square)](#license)
+[![rustc](https://img.shields.io/badge/rustc-1.56+-blue?style=flat-square&logo=rust)](https://www.rust-lang.org)
+[![build status](https://img.shields.io/github/actions/workflow/status/taiki-e/pin-project/ci.yml?branch=main&style=flat-square&logo=github)](https://github.com/taiki-e/pin-project/actions)
+
+<!-- tidy:crate-doc:start -->
+A crate for safe and ergonomic [pin-projection].
+
+## Usage
+
+Add this to your `Cargo.toml`:
+
+```toml
+[dependencies]
+pin-project = "1"
+```
+
+*Compiler support: requires rustc 1.56+*
+
+## Examples
+
+[`#[pin_project]`][`pin_project`] attribute creates projection types
+covering all the fields of struct or enum.
+
+```rust
+use std::pin::Pin;
+
+use pin_project::pin_project;
+
+#[pin_project]
+struct Struct<T, U> {
+    #[pin]
+    pinned: T,
+    unpinned: U,
+}
+
+impl<T, U> Struct<T, U> {
+    fn method(self: Pin<&mut Self>) {
+        let this = self.project();
+        let _: Pin<&mut T> = this.pinned; // Pinned reference to the field
+        let _: &mut U = this.unpinned; // Normal reference to the field
+    }
+}
+```
+
+[*code like this will be generated*][struct-default-expanded]
+
+To use `#[pin_project]` on enums, you need to name the projection type
+returned from the method.
+
+```rust
+use std::pin::Pin;
+
+use pin_project::pin_project;
+
+#[pin_project(project = EnumProj)]
+enum Enum<T, U> {
+    Pinned(#[pin] T),
+    Unpinned(U),
+}
+
+impl<T, U> Enum<T, U> {
+    fn method(self: Pin<&mut Self>) {
+        match self.project() {
+            EnumProj::Pinned(x) => {
+                let _: Pin<&mut T> = x;
+            }
+            EnumProj::Unpinned(y) => {
+                let _: &mut U = y;
+            }
+        }
+    }
+}
+```
+
+[*code like this will be generated*][enum-default-expanded]
+
+See [`#[pin_project]`][`pin_project`] attribute for more details, and
+see [examples] directory for more examples and generated code.
+
+## Related Projects
+
+- [pin-project-lite]: A lightweight version of pin-project written with declarative macros.
+
+[enum-default-expanded]: https://github.com/taiki-e/pin-project/blob/HEAD/examples/enum-default-expanded.rs
+[examples]: https://github.com/taiki-e/pin-project/blob/HEAD/examples/README.md
+[pin-project-lite]: https://github.com/taiki-e/pin-project-lite
+[pin-projection]: https://doc.rust-lang.org/std/pin/index.html#projections-and-structural-pinning
+[struct-default-expanded]: https://github.com/taiki-e/pin-project/blob/HEAD/examples/struct-default-expanded.rs
+
+<!-- tidy:crate-doc:end -->
+
+[`pin_project`]: https://docs.rs/pin-project/1/pin_project/attr.pin_project.html
+
+## License
+
+Licensed under either of [Apache License, Version 2.0](LICENSE-APACHE) or
+[MIT license](LICENSE-MIT) at your option.
+
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in the work by you, as defined in the Apache-2.0 license, shall
+be dual licensed as above, without any additional terms or conditions.
diff --git a/crates/pin-project/TEST_MAPPING b/crates/pin-project/TEST_MAPPING
new file mode 100644
index 0000000..664c4df
--- /dev/null
+++ b/crates/pin-project/TEST_MAPPING
@@ -0,0 +1,11 @@
+// Generated by update_crate_tests.py for tests that depend on this crate.
+{
+  "imports": [
+    {
+      "path": "external/rust/crates/futures-channel"
+    },
+    {
+      "path": "external/rust/crates/futures-test"
+    }
+  ]
+}
diff --git a/crates/pin-project/cargo_embargo.json b/crates/pin-project/cargo_embargo.json
new file mode 100644
index 0000000..802f2c5
--- /dev/null
+++ b/crates/pin-project/cargo_embargo.json
@@ -0,0 +1,8 @@
+{
+  "apex_available": [
+    "//apex_available:platform",
+    "com.android.virt",
+    "com.sdv.*"
+  ],
+  "run_cargo": false
+}
diff --git a/crates/pin-project/examples/README.md b/crates/pin-project/examples/README.md
new file mode 100644
index 0000000..0f30a7f
--- /dev/null
+++ b/crates/pin-project/examples/README.md
@@ -0,0 +1,39 @@
+# Examples and generated code of each feature of pin-project
+
+### Basic usage of `#[pin_project]` on structs
+
+- [example](struct-default.rs)
+- [generated code](struct-default-expanded.rs)
+
+### Basic usage of `#[pin_project]` on enums
+
+- [example](enum-default.rs)
+- [generated code](enum-default-expanded.rs)
+
+### Manual implementation of `Unpin` by `UnsafeUnpin`
+
+- [example](unsafe_unpin.rs)
+- [generated code](unsafe_unpin-expanded.rs)
+- [`UnsafeUnpin` documentation](https://docs.rs/pin-project/1/pin_project/trait.UnsafeUnpin.html)
+
+### Manual implementation of `Drop` by `#[pinned_drop]`
+
+- [example](pinned_drop.rs)
+- [generated code](pinned_drop-expanded.rs)
+- [`#[pinned_drop]` documentation](https://docs.rs/pin-project/1/pin_project/attr.pinned_drop.html)
+
+### `project_replace()` method
+
+- [example](project_replace.rs)
+- [generated code](project_replace-expanded.rs)
+- [`project_replace()` documentation](https://docs.rs/pin-project/1/pin_project/attr.pin_project.html#project_replace-method)
+
+### Ensure `!Unpin` by `#[pin_project(!Unpin)]`
+
+- [example](not_unpin.rs)
+- [generated code](not_unpin-expanded.rs)
+- [`!Unpin` documentation](https://docs.rs/pin-project/1/pin_project/attr.pin_project.html#unpin)
+
+Note: These generated code examples are the little simplified version of the
+actual generated code. See [expansion tests](../tests#expansion-tests-expand-expandtestrs) if you
+want to see the exact version of the actual generated code.
diff --git a/crates/pin-project/examples/enum-default-expanded.rs b/crates/pin-project/examples/enum-default-expanded.rs
new file mode 100644
index 0000000..459ca39
--- /dev/null
+++ b/crates/pin-project/examples/enum-default-expanded.rs
@@ -0,0 +1,101 @@
+// Original code (./enum-default.rs):
+//
+// ```rust
+// #![allow(dead_code)]
+//
+// use pin_project::pin_project;
+//
+// #[pin_project(project = EnumProj)]
+// enum Enum<T, U> {
+//     Pinned(#[pin] T),
+//     Unpinned(U),
+// }
+//
+// fn main() {}
+// ```
+
+#![allow(dead_code, unused_imports, unused_parens, unknown_lints, renamed_and_removed_lints)]
+#![allow(
+    clippy::needless_lifetimes,
+    clippy::just_underscores_and_digits,
+    clippy::used_underscore_binding
+)]
+
+use pin_project::pin_project;
+
+// #[pin_project(project = EnumProj)]
+enum Enum<T, U> {
+    Pinned(/* #[pin] */ T),
+    Unpinned(U),
+}
+
+enum EnumProj<'pin, T, U>
+where
+    Enum<T, U>: 'pin,
+{
+    Pinned(::pin_project::__private::Pin<&'pin mut (T)>),
+    Unpinned(&'pin mut (U)),
+}
+
+const _: () = {
+    // When `#[pin_project]` is used on enums, only named projection types and
+    // methods are generated because there is no way to access variants of
+    // projected types without naming it.
+    // (When `#[pin_project]` is used on structs, both methods are always generated.)
+
+    impl<T, U> Enum<T, U> {
+        fn project<'pin>(
+            self: ::pin_project::__private::Pin<&'pin mut Self>,
+        ) -> EnumProj<'pin, T, U> {
+            unsafe {
+                match self.get_unchecked_mut() {
+                    Self::Pinned(_0) => {
+                        EnumProj::Pinned(::pin_project::__private::Pin::new_unchecked(_0))
+                    }
+                    Self::Unpinned(_0) => EnumProj::Unpinned(_0),
+                }
+            }
+        }
+    }
+
+    // Automatically create the appropriate conditional `Unpin` implementation.
+    //
+    // See ./struct-default-expanded.rs and https://github.com/taiki-e/pin-project/pull/53.
+    // for details.
+    struct __Enum<'pin, T, U> {
+        __pin_project_use_generics: ::pin_project::__private::AlwaysUnpin<
+            'pin,
+            (::pin_project::__private::PhantomData<T>, ::pin_project::__private::PhantomData<U>),
+        >,
+        __field0: T,
+    }
+    impl<'pin, T, U> ::pin_project::__private::Unpin for Enum<T, U> where
+        __Enum<'pin, T, U>: ::pin_project::__private::Unpin
+    {
+    }
+    // A dummy impl of `UnsafeUnpin`, to ensure that the user cannot implement it.
+    #[doc(hidden)]
+    unsafe impl<'pin, T, U> ::pin_project::UnsafeUnpin for Enum<T, U> where
+        __Enum<'pin, T, U>: ::pin_project::__private::Unpin
+    {
+    }
+
+    // Ensure that enum does not implement `Drop`.
+    //
+    // See ./struct-default-expanded.rs for details.
+    trait EnumMustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: ::pin_project::__private::Drop> EnumMustNotImplDrop for T {}
+    impl<T, U> EnumMustNotImplDrop for Enum<T, U> {}
+    // A dummy impl of `PinnedDrop`, to ensure that users don't accidentally
+    // write a non-functional `PinnedDrop` impls.
+    #[doc(hidden)]
+    impl<T, U> ::pin_project::__private::PinnedDrop for Enum<T, U> {
+        unsafe fn drop(self: ::pin_project::__private::Pin<&mut Self>) {}
+    }
+
+    // We don't need to check for `#[repr(packed)]`,
+    // since it does not apply to enums.
+};
+
+fn main() {}
diff --git a/crates/pin-project/examples/enum-default.rs b/crates/pin-project/examples/enum-default.rs
new file mode 100644
index 0000000..bd3f2e6
--- /dev/null
+++ b/crates/pin-project/examples/enum-default.rs
@@ -0,0 +1,13 @@
+// See ./enum-default-expanded.rs for generated code.
+
+#![allow(dead_code)]
+
+use pin_project::pin_project;
+
+#[pin_project(project = EnumProj)]
+enum Enum<T, U> {
+    Pinned(#[pin] T),
+    Unpinned(U),
+}
+
+fn main() {}
diff --git a/crates/pin-project/examples/not_unpin-expanded.rs b/crates/pin-project/examples/not_unpin-expanded.rs
new file mode 100644
index 0000000..5700c12
--- /dev/null
+++ b/crates/pin-project/examples/not_unpin-expanded.rs
@@ -0,0 +1,125 @@
+// Original code (./not_unpin.rs):
+//
+// ```rust
+// #![allow(dead_code)]
+//
+// use pin_project::pin_project;
+//
+// #[pin_project(!Unpin)]
+// pub struct Struct<T, U> {
+//     #[pin]
+//     pinned: T,
+//     unpinned: U,
+// }
+//
+// fn main() {
+//     fn _is_unpin<T: Unpin>() {}
+//     // _is_unpin::<Struct<(), ()>>(); //~ ERROR `std::marker::PhantomPinned` cannot be unpinned
+// }
+// ```
+
+#![allow(dead_code, unused_imports, unused_parens, unknown_lints, renamed_and_removed_lints)]
+#![allow(clippy::needless_lifetimes)]
+
+use pin_project::pin_project;
+
+// #[pin_project(!Unpin)]
+pub struct Struct<T, U> {
+    // #[pin]
+    pinned: T,
+    unpinned: U,
+}
+
+const _: () = {
+    pub(crate) struct __StructProjection<'pin, T, U>
+    where
+        Struct<T, U>: 'pin,
+    {
+        pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
+        unpinned: &'pin mut (U),
+    }
+    pub(crate) struct __StructProjectionRef<'pin, T, U>
+    where
+        Struct<T, U>: 'pin,
+    {
+        pinned: ::pin_project::__private::Pin<&'pin (T)>,
+        unpinned: &'pin (U),
+    }
+
+    impl<T, U> Struct<T, U> {
+        pub(crate) fn project<'pin>(
+            self: ::pin_project::__private::Pin<&'pin mut Self>,
+        ) -> __StructProjection<'pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_unchecked_mut();
+                __StructProjection {
+                    pinned: ::pin_project::__private::Pin::new_unchecked(pinned),
+                    unpinned,
+                }
+            }
+        }
+        pub(crate) fn project_ref<'pin>(
+            self: ::pin_project::__private::Pin<&'pin Self>,
+        ) -> __StructProjectionRef<'pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_ref();
+                __StructProjectionRef {
+                    pinned: ::pin_project::__private::Pin::new_unchecked(pinned),
+                    unpinned,
+                }
+            }
+        }
+    }
+
+    // Ensure that it's impossible to use pin projections on a #[repr(packed)]
+    // struct.
+    //
+    // See ./struct-default-expanded.rs and https://github.com/taiki-e/pin-project/pull/34
+    // for details.
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+        let _ = &this.pinned;
+        let _ = &this.unpinned;
+    }
+
+    // Create `Unpin` impl that has trivial `Unpin` bounds.
+    //
+    // See https://github.com/taiki-e/pin-project/issues/102#issuecomment-540472282
+    // for details.
+    impl<'pin, T, U> ::pin_project::__private::Unpin for Struct<T, U> where
+        ::pin_project::__private::Wrapper<'pin, ::pin_project::__private::PhantomPinned>:
+            ::pin_project::__private::Unpin
+    {
+    }
+    // A dummy impl of `UnsafeUnpin`, to ensure that the user cannot implement it.
+    //
+    // To ensure that users don't accidentally write a non-functional `UnsafeUnpin`
+    // impls, we emit one ourselves. If the user ends up writing an `UnsafeUnpin`
+    // impl, they'll get a "conflicting implementations of trait" error when
+    // coherence checks are run.
+    #[doc(hidden)]
+    unsafe impl<'pin, T, U> ::pin_project::UnsafeUnpin for Struct<T, U> where
+        ::pin_project::__private::Wrapper<'pin, ::pin_project::__private::PhantomPinned>:
+            ::pin_project::__private::Unpin
+    {
+    }
+
+    // Ensure that struct does not implement `Drop`.
+    //
+    // See ./struct-default-expanded.rs for details.
+    trait StructMustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: ::pin_project::__private::Drop> StructMustNotImplDrop for T {}
+    impl<T, U> StructMustNotImplDrop for Struct<T, U> {}
+    // A dummy impl of `PinnedDrop`, to ensure that users don't accidentally
+    // write a non-functional `PinnedDrop` impls.
+    #[doc(hidden)]
+    impl<T, U> ::pin_project::__private::PinnedDrop for Struct<T, U> {
+        unsafe fn drop(self: ::pin_project::__private::Pin<&mut Self>) {}
+    }
+};
+
+fn main() {
+    fn _is_unpin<T: Unpin>() {}
+    // _is_unpin::<Struct<(), ()>>(); //~ ERROR `std::marker::PhantomPinned` cannot be unpinned
+}
diff --git a/crates/pin-project/examples/not_unpin.rs b/crates/pin-project/examples/not_unpin.rs
new file mode 100644
index 0000000..2ad72a8
--- /dev/null
+++ b/crates/pin-project/examples/not_unpin.rs
@@ -0,0 +1,17 @@
+// See ./not_unpin-expanded.rs for generated code.
+
+#![allow(dead_code)]
+
+use pin_project::pin_project;
+
+#[pin_project(!Unpin)]
+pub struct Struct<T, U> {
+    #[pin]
+    pinned: T,
+    unpinned: U,
+}
+
+fn main() {
+    fn _is_unpin<T: Unpin>() {}
+    // _is_unpin::<Struct<(), ()>>(); //~ ERROR `std::marker::PhantomPinned` cannot be unpinned
+}
diff --git a/crates/pin-project/examples/pinned_drop-expanded.rs b/crates/pin-project/examples/pinned_drop-expanded.rs
new file mode 100644
index 0000000..82207b6
--- /dev/null
+++ b/crates/pin-project/examples/pinned_drop-expanded.rs
@@ -0,0 +1,154 @@
+// Original code (./pinned_drop.rs):
+//
+// ```rust
+// #![allow(dead_code)]
+//
+// use std::pin::Pin;
+//
+// use pin_project::{pin_project, pinned_drop};
+//
+// #[pin_project(PinnedDrop)]
+// pub struct Struct<'a, T> {
+//     was_dropped: &'a mut bool,
+//     #[pin]
+//     field: T,
+// }
+//
+// #[pinned_drop]
+// fn drop_Struct<T>(mut this: Pin<&mut Struct<'_, T>>) {
+//     **this.project().was_dropped = true;
+// }
+//
+// fn main() {}
+// ```
+
+#![allow(dead_code, unused_imports, unused_parens, unknown_lints, renamed_and_removed_lints)]
+#![allow(clippy::needless_lifetimes, clippy::mut_mut)]
+
+use std::pin::Pin;
+
+use pin_project::{pin_project, pinned_drop};
+
+// #[pin_project(PinnedDrop)]
+pub struct Struct<'a, T> {
+    was_dropped: &'a mut bool,
+    // #[pin]
+    field: T,
+}
+
+const _: () = {
+    pub(crate) struct __StructProjection<'pin, 'a, T>
+    where
+        Struct<'a, T>: 'pin,
+    {
+        was_dropped: &'pin mut (&'a mut bool),
+        field: ::pin_project::__private::Pin<&'pin mut (T)>,
+    }
+    pub(crate) struct __StructProjectionRef<'pin, 'a, T>
+    where
+        Struct<'a, T>: 'pin,
+    {
+        was_dropped: &'pin (&'a mut bool),
+        field: ::pin_project::__private::Pin<&'pin (T)>,
+    }
+
+    impl<'a, T> Struct<'a, T> {
+        pub(crate) fn project<'pin>(
+            self: ::pin_project::__private::Pin<&'pin mut Self>,
+        ) -> __StructProjection<'pin, 'a, T> {
+            unsafe {
+                let Self { was_dropped, field } = self.get_unchecked_mut();
+                __StructProjection {
+                    was_dropped,
+                    field: ::pin_project::__private::Pin::new_unchecked(field),
+                }
+            }
+        }
+        pub(crate) fn project_ref<'pin>(
+            self: ::pin_project::__private::Pin<&'pin Self>,
+        ) -> __StructProjectionRef<'pin, 'a, T> {
+            unsafe {
+                let Self { was_dropped, field } = self.get_ref();
+                __StructProjectionRef {
+                    was_dropped,
+                    field: ::pin_project::__private::Pin::new_unchecked(field),
+                }
+            }
+        }
+    }
+
+    // Ensure that it's impossible to use pin projections on a #[repr(packed)]
+    // struct.
+    //
+    // See ./struct-default-expanded.rs and https://github.com/taiki-e/pin-project/pull/34
+    // for details.
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<'a, T>(this: &Struct<'a, T>) {
+        let _ = &this.was_dropped;
+        let _ = &this.field;
+    }
+
+    impl<'a, T> ::pin_project::__private::Drop for Struct<'a, T> {
+        fn drop(&mut self) {
+            // Safety - we're in 'drop', so we know that 'self' will
+            // never move again.
+            let pinned_self = unsafe { ::pin_project::__private::Pin::new_unchecked(self) };
+            // We call `pinned_drop` only once. Since `PinnedDrop::drop`
+            // is an unsafe method and a private API, it is never called again in safe
+            // code *unless the user uses a maliciously crafted macro*.
+            unsafe {
+                ::pin_project::__private::PinnedDrop::drop(pinned_self);
+            }
+        }
+    }
+
+    // Automatically create the appropriate conditional `Unpin` implementation.
+    //
+    // See ./struct-default-expanded.rs and https://github.com/taiki-e/pin-project/pull/53.
+    // for details.
+    pub struct __Struct<'pin, 'a, T> {
+        __pin_project_use_generics: ::pin_project::__private::AlwaysUnpin<'pin, (T)>,
+        __field0: T,
+        __lifetime0: &'a (),
+    }
+    impl<'pin, 'a, T> ::pin_project::__private::Unpin for Struct<'a, T> where
+        __Struct<'pin, 'a, T>: ::pin_project::__private::Unpin
+    {
+    }
+    // A dummy impl of `UnsafeUnpin`, to ensure that the user cannot implement it.
+    #[doc(hidden)]
+    unsafe impl<'pin, 'a, T> ::pin_project::UnsafeUnpin for Struct<'a, T> where
+        __Struct<'pin, 'a, T>: ::pin_project::__private::Unpin
+    {
+    }
+};
+
+// Implementing `PinnedDrop::drop` is safe, but calling it is not safe.
+// This is because destructors can be called multiple times in safe code and
+// [double dropping is unsound](https://github.com/rust-lang/rust/pull/62360).
+//
+// Ideally, it would be desirable to be able to forbid manual calls in
+// the same way as `Drop::drop`, but the library cannot do it. So, by using
+// macros and replacing them with private traits, we prevent users from
+// calling `PinnedDrop::drop`.
+//
+// Users can implement [`Drop`] safely using `#[pinned_drop]` and can drop a
+// type that implements `PinnedDrop` using the [`drop`] function safely.
+// **Do not call or implement this trait directly.**
+#[doc(hidden)]
+impl<T> ::pin_project::__private::PinnedDrop for Struct<'_, T> {
+    // Since calling it twice on the same object would be UB,
+    // this method is unsafe.
+    unsafe fn drop(self: Pin<&mut Self>) {
+        #[allow(clippy::needless_pass_by_value)]
+        fn __drop_inner<T>(__self: Pin<&mut Struct<'_, T>>) {
+            // A dummy `__drop_inner` function to prevent users call outer `__drop_inner`.
+            fn __drop_inner() {}
+
+            **__self.project().was_dropped = true;
+        }
+        __drop_inner(self);
+    }
+}
+
+fn main() {}
diff --git a/crates/pin-project/examples/pinned_drop.rs b/crates/pin-project/examples/pinned_drop.rs
new file mode 100644
index 0000000..6fb8719
--- /dev/null
+++ b/crates/pin-project/examples/pinned_drop.rs
@@ -0,0 +1,23 @@
+// See ./pinned_drop-expanded.rs for generated code.
+
+#![allow(dead_code)]
+
+use std::pin::Pin;
+
+use pin_project::{pin_project, pinned_drop};
+
+#[pin_project(PinnedDrop)]
+pub struct Struct<'a, T> {
+    was_dropped: &'a mut bool,
+    #[pin]
+    field: T,
+}
+
+#[pinned_drop]
+impl<T> PinnedDrop for Struct<'_, T> {
+    fn drop(self: Pin<&mut Self>) {
+        **self.project().was_dropped = true;
+    }
+}
+
+fn main() {}
diff --git a/crates/pin-project/examples/project_replace-expanded.rs b/crates/pin-project/examples/project_replace-expanded.rs
new file mode 100644
index 0000000..445e570
--- /dev/null
+++ b/crates/pin-project/examples/project_replace-expanded.rs
@@ -0,0 +1,156 @@
+// Original code (./struct-default.rs):
+//
+// ```rust
+// #![allow(dead_code)]
+//
+// use pin_project::pin_project;
+//
+// #[pin_project(project_replace)]
+// struct Struct<T, U> {
+//     #[pin]
+//     pinned: T,
+//     unpinned: U,
+// }
+//
+// fn main() {}
+// ```
+
+#![allow(dead_code, unused_imports, unused_parens, unknown_lints, renamed_and_removed_lints)]
+#![allow(clippy::needless_lifetimes)]
+
+use pin_project::pin_project;
+
+// #[pin_project(project_replace)]
+struct Struct<T, U> {
+    // #[pin]
+    pinned: T,
+    unpinned: U,
+}
+
+const _: () = {
+    struct __StructProjection<'pin, T, U>
+    where
+        Struct<T, U>: 'pin,
+    {
+        pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
+        unpinned: &'pin mut (U),
+    }
+    struct __StructProjectionRef<'pin, T, U>
+    where
+        Struct<T, U>: 'pin,
+    {
+        pinned: ::pin_project::__private::Pin<&'pin (T)>,
+        unpinned: &'pin (U),
+    }
+    struct __StructProjectionOwned<T, U> {
+        pinned: ::pin_project::__private::PhantomData<T>,
+        unpinned: U,
+    }
+
+    impl<T, U> Struct<T, U> {
+        fn project<'pin>(
+            self: ::pin_project::__private::Pin<&'pin mut Self>,
+        ) -> __StructProjection<'pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_unchecked_mut();
+                __StructProjection {
+                    pinned: ::pin_project::__private::Pin::new_unchecked(pinned),
+                    unpinned,
+                }
+            }
+        }
+        fn project_ref<'pin>(
+            self: ::pin_project::__private::Pin<&'pin Self>,
+        ) -> __StructProjectionRef<'pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_ref();
+                __StructProjectionRef {
+                    pinned: ::pin_project::__private::Pin::new_unchecked(pinned),
+                    unpinned,
+                }
+            }
+        }
+        fn project_replace(
+            self: ::pin_project::__private::Pin<&mut Self>,
+            __replacement: Self,
+        ) -> __StructProjectionOwned<T, U> {
+            unsafe {
+                let __self_ptr: *mut Self = self.get_unchecked_mut();
+
+                // Destructors will run in reverse order, so next create a guard to overwrite
+                // `self` with the replacement value without calling destructors.
+                let __guard =
+                    ::pin_project::__private::UnsafeOverwriteGuard::new(__self_ptr, __replacement);
+
+                let Self { pinned, unpinned } = &mut *__self_ptr;
+
+                // First, extract all the unpinned fields
+                let __result = __StructProjectionOwned {
+                    pinned: ::pin_project::__private::PhantomData,
+                    unpinned: ::pin_project::__private::ptr::read(unpinned),
+                };
+
+                // Now create guards to drop all the pinned fields
+                //
+                // Due to a compiler bug (https://github.com/rust-lang/rust/issues/47949)
+                // this must be in its own scope, or else `__result` will not be dropped
+                // if any of the destructors panic.
+                {
+                    let __guard = ::pin_project::__private::UnsafeDropInPlaceGuard::new(pinned);
+                }
+
+                // Finally, return the result
+                __result
+            }
+        }
+    }
+
+    // Ensure that it's impossible to use pin projections on a #[repr(packed)]
+    // struct.
+    //
+    // See ./struct-default-expanded.rs and https://github.com/taiki-e/pin-project/pull/34
+    // for details.
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+        let _ = &this.pinned;
+        let _ = &this.unpinned;
+    }
+
+    // Automatically create the appropriate conditional `Unpin` implementation.
+    //
+    // See ./struct-default-expanded.rs and https://github.com/taiki-e/pin-project/pull/53.
+    // for details.
+    struct __Struct<'pin, T, U> {
+        __pin_project_use_generics: ::pin_project::__private::AlwaysUnpin<
+            'pin,
+            (::pin_project::__private::PhantomData<T>, ::pin_project::__private::PhantomData<U>),
+        >,
+        __field0: T,
+    }
+    impl<'pin, T, U> ::pin_project::__private::Unpin for Struct<T, U> where
+        __Struct<'pin, T, U>: ::pin_project::__private::Unpin
+    {
+    }
+    // A dummy impl of `UnsafeUnpin`, to ensure that the user cannot implement it.
+    #[doc(hidden)]
+    unsafe impl<'pin, T, U> ::pin_project::UnsafeUnpin for Struct<T, U> where
+        __Struct<'pin, T, U>: ::pin_project::__private::Unpin
+    {
+    }
+
+    // Ensure that struct does not implement `Drop`.
+    //
+    // See ./struct-default-expanded.rs for details.
+    trait StructMustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: ::pin_project::__private::Drop> StructMustNotImplDrop for T {}
+    impl<T, U> StructMustNotImplDrop for Struct<T, U> {}
+    // A dummy impl of `PinnedDrop`, to ensure that users don't accidentally
+    // write a non-functional `PinnedDrop` impls.
+    #[doc(hidden)]
+    impl<T, U> ::pin_project::__private::PinnedDrop for Struct<T, U> {
+        unsafe fn drop(self: ::pin_project::__private::Pin<&mut Self>) {}
+    }
+};
+
+fn main() {}
diff --git a/crates/pin-project/examples/project_replace.rs b/crates/pin-project/examples/project_replace.rs
new file mode 100644
index 0000000..99cec18
--- /dev/null
+++ b/crates/pin-project/examples/project_replace.rs
@@ -0,0 +1,14 @@
+// See ./struct-default-expanded.rs for generated code.
+
+#![allow(dead_code)]
+
+use pin_project::pin_project;
+
+#[pin_project(project_replace)]
+struct Struct<T, U> {
+    #[pin]
+    pinned: T,
+    unpinned: U,
+}
+
+fn main() {}
diff --git a/crates/pin-project/examples/struct-default-expanded.rs b/crates/pin-project/examples/struct-default-expanded.rs
new file mode 100644
index 0000000..d661099
--- /dev/null
+++ b/crates/pin-project/examples/struct-default-expanded.rs
@@ -0,0 +1,155 @@
+// Original code (./struct-default.rs):
+//
+// ```rust
+// #![allow(dead_code)]
+//
+// use pin_project::pin_project;
+//
+// #[pin_project]
+// struct Struct<T, U> {
+//     #[pin]
+//     pinned: T,
+//     unpinned: U,
+// }
+//
+// fn main() {}
+// ```
+
+#![allow(dead_code, unused_imports, unused_parens, unknown_lints, renamed_and_removed_lints)]
+#![allow(clippy::needless_lifetimes)]
+
+use pin_project::pin_project;
+
+// #[pin_project]
+struct Struct<T, U> {
+    // #[pin]
+    pinned: T,
+    unpinned: U,
+}
+
+const _: () = {
+    struct __StructProjection<'pin, T, U>
+    where
+        Struct<T, U>: 'pin,
+    {
+        pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
+        unpinned: &'pin mut (U),
+    }
+    struct __StructProjectionRef<'pin, T, U>
+    where
+        Struct<T, U>: 'pin,
+    {
+        pinned: ::pin_project::__private::Pin<&'pin (T)>,
+        unpinned: &'pin (U),
+    }
+
+    impl<T, U> Struct<T, U> {
+        fn project<'pin>(
+            self: ::pin_project::__private::Pin<&'pin mut Self>,
+        ) -> __StructProjection<'pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_unchecked_mut();
+                __StructProjection {
+                    pinned: ::pin_project::__private::Pin::new_unchecked(pinned),
+                    unpinned,
+                }
+            }
+        }
+        fn project_ref<'pin>(
+            self: ::pin_project::__private::Pin<&'pin Self>,
+        ) -> __StructProjectionRef<'pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_ref();
+                __StructProjectionRef {
+                    pinned: ::pin_project::__private::Pin::new_unchecked(pinned),
+                    unpinned,
+                }
+            }
+        }
+    }
+
+    // Ensure that it's impossible to use pin projections on a #[repr(packed)]
+    // struct.
+    //
+    // Taking a reference to a packed field is UB, and applying
+    // `#[forbid(unaligned_references)]` makes sure that doing this is a hard error.
+    //
+    // If the struct ends up having #[repr(packed)] applied somehow,
+    // this will generate an (unfriendly) error message. Under all reasonable
+    // circumstances, we'll detect the #[repr(packed)] attribute, and generate
+    // a much nicer error above.
+    //
+    // See https://github.com/taiki-e/pin-project/pull/34 for more details.
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+        let _ = &this.pinned;
+        let _ = &this.unpinned;
+    }
+
+    // Automatically create the appropriate conditional `Unpin` implementation.
+    //
+    // Basically this is equivalent to the following code:
+    //
+    // ```rust
+    // impl<T, U> Unpin for Struct<T, U> where T: Unpin {}
+    // ```
+    //
+    // However, if struct is public and there is a private type field,
+    // this would cause an E0446 (private type in public interface).
+    //
+    // When RFC 2145 is implemented (rust-lang/rust#48054),
+    // this will become a lint, rather then a hard error.
+    //
+    // As a workaround for this, we generate a new struct, containing all of
+    // the pinned fields from our #[pin_project] type. This struct is declared
+    // within a function, which makes it impossible to be named by user code.
+    // This guarantees that it will use the default auto-trait impl for Unpin -
+    // that is, it will implement Unpin iff all of its fields implement Unpin.
+    // This type can be safely declared as 'public', satisfying the privacy
+    // checker without actually allowing user code to access it.
+    //
+    // This allows users to apply the #[pin_project] attribute to types
+    // regardless of the privacy of the types of their fields.
+    //
+    // See also https://github.com/taiki-e/pin-project/pull/53.
+    struct __Struct<'pin, T, U> {
+        __pin_project_use_generics: ::pin_project::__private::AlwaysUnpin<
+            'pin,
+            (::pin_project::__private::PhantomData<T>, ::pin_project::__private::PhantomData<U>),
+        >,
+        __field0: T,
+    }
+    impl<'pin, T, U> ::pin_project::__private::Unpin for Struct<T, U> where
+        __Struct<'pin, T, U>: ::pin_project::__private::Unpin
+    {
+    }
+    // A dummy impl of `UnsafeUnpin`, to ensure that the user cannot implement it.
+    //
+    // To ensure that users don't accidentally write a non-functional `UnsafeUnpin`
+    // impls, we emit one ourselves. If the user ends up writing an `UnsafeUnpin`
+    // impl, they'll get a "conflicting implementations of trait" error when
+    // coherence checks are run.
+    #[doc(hidden)]
+    unsafe impl<'pin, T, U> ::pin_project::UnsafeUnpin for Struct<T, U> where
+        __Struct<'pin, T, U>: ::pin_project::__private::Unpin
+    {
+    }
+
+    // Ensure that struct does not implement `Drop`.
+    //
+    // If you attempt to provide an Drop impl, the blanket impl will
+    // then apply to your type, causing a compile-time error due to
+    // the conflict with the second impl.
+    trait StructMustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: ::pin_project::__private::Drop> StructMustNotImplDrop for T {}
+    impl<T, U> StructMustNotImplDrop for Struct<T, U> {}
+    // A dummy impl of `PinnedDrop`, to ensure that users don't accidentally
+    // write a non-functional `PinnedDrop` impls.
+    #[doc(hidden)]
+    impl<T, U> ::pin_project::__private::PinnedDrop for Struct<T, U> {
+        unsafe fn drop(self: ::pin_project::__private::Pin<&mut Self>) {}
+    }
+};
+
+fn main() {}
diff --git a/crates/pin-project/examples/struct-default.rs b/crates/pin-project/examples/struct-default.rs
new file mode 100644
index 0000000..46808a5
--- /dev/null
+++ b/crates/pin-project/examples/struct-default.rs
@@ -0,0 +1,14 @@
+// See ./struct-default-expanded.rs for generated code.
+
+#![allow(dead_code)]
+
+use pin_project::pin_project;
+
+#[pin_project]
+struct Struct<T, U> {
+    #[pin]
+    pinned: T,
+    unpinned: U,
+}
+
+fn main() {}
diff --git a/crates/pin-project/examples/unsafe_unpin-expanded.rs b/crates/pin-project/examples/unsafe_unpin-expanded.rs
new file mode 100644
index 0000000..e9c7abc
--- /dev/null
+++ b/crates/pin-project/examples/unsafe_unpin-expanded.rs
@@ -0,0 +1,107 @@
+// Original code (./unsafe_unpin.rs):
+//
+// ```rust
+// #![allow(dead_code)]
+//
+// use pin_project::{pin_project, UnsafeUnpin};
+//
+// #[pin_project(UnsafeUnpin)]
+// pub struct Struct<T, U> {
+//     #[pin]
+//     pinned: T,
+//     unpinned: U,
+// }
+//
+// unsafe impl<T: Unpin, U> UnsafeUnpin for Struct<T, U> {}
+//
+// fn main() {}
+// ```
+
+#![allow(dead_code, unused_imports, unused_parens, unknown_lints, renamed_and_removed_lints)]
+#![allow(clippy::needless_lifetimes)]
+
+use pin_project::{pin_project, UnsafeUnpin};
+
+// #[pin_project(UnsafeUnpin)]
+pub struct Struct<T, U> {
+    // #[pin]
+    pinned: T,
+    unpinned: U,
+}
+
+const _: () = {
+    pub(crate) struct __StructProjection<'pin, T, U>
+    where
+        Struct<T, U>: 'pin,
+    {
+        pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
+        unpinned: &'pin mut (U),
+    }
+    pub(crate) struct __StructProjectionRef<'pin, T, U>
+    where
+        Struct<T, U>: 'pin,
+    {
+        pinned: ::pin_project::__private::Pin<&'pin (T)>,
+        unpinned: &'pin (U),
+    }
+
+    impl<T, U> Struct<T, U> {
+        pub(crate) fn project<'pin>(
+            self: ::pin_project::__private::Pin<&'pin mut Self>,
+        ) -> __StructProjection<'pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_unchecked_mut();
+                __StructProjection {
+                    pinned: ::pin_project::__private::Pin::new_unchecked(pinned),
+                    unpinned,
+                }
+            }
+        }
+        pub(crate) fn project_ref<'pin>(
+            self: ::pin_project::__private::Pin<&'pin Self>,
+        ) -> __StructProjectionRef<'pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_ref();
+                __StructProjectionRef {
+                    pinned: ::pin_project::__private::Pin::new_unchecked(pinned),
+                    unpinned,
+                }
+            }
+        }
+    }
+
+    // Ensure that it's impossible to use pin projections on a #[repr(packed)]
+    // struct.
+    //
+    // See ./struct-default-expanded.rs and https://github.com/taiki-e/pin-project/pull/34
+    // for details.
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+        let _ = &this.pinned;
+        let _ = &this.unpinned;
+    }
+
+    // Implement `Unpin` via `UnsafeUnpin`.
+    impl<'pin, T, U> ::pin_project::__private::Unpin for Struct<T, U> where
+        ::pin_project::__private::Wrapper<'pin, Self>: ::pin_project::UnsafeUnpin
+    {
+    }
+
+    // Ensure that struct does not implement `Drop`.
+    //
+    // See ./struct-default-expanded.rs for details.
+    trait StructMustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: ::pin_project::__private::Drop> StructMustNotImplDrop for T {}
+    impl<T, U> StructMustNotImplDrop for Struct<T, U> {}
+    // A dummy impl of `PinnedDrop`, to ensure that users don't accidentally
+    // write a non-functional `PinnedDrop` impls.
+    #[doc(hidden)]
+    impl<T, U> ::pin_project::__private::PinnedDrop for Struct<T, U> {
+        unsafe fn drop(self: ::pin_project::__private::Pin<&mut Self>) {}
+    }
+};
+
+unsafe impl<T: Unpin, U> UnsafeUnpin for Struct<T, U> {}
+
+fn main() {}
diff --git a/crates/pin-project/examples/unsafe_unpin.rs b/crates/pin-project/examples/unsafe_unpin.rs
new file mode 100644
index 0000000..5ec0cd2
--- /dev/null
+++ b/crates/pin-project/examples/unsafe_unpin.rs
@@ -0,0 +1,16 @@
+// See ./unsafe_unpin-expanded.rs for generated code.
+
+#![allow(dead_code)]
+
+use pin_project::{pin_project, UnsafeUnpin};
+
+#[pin_project(UnsafeUnpin)]
+pub struct Struct<T, U> {
+    #[pin]
+    pinned: T,
+    unpinned: U,
+}
+
+unsafe impl<T: Unpin, U> UnsafeUnpin for Struct<T, U> {}
+
+fn main() {}
diff --git a/crates/pin-project/patches/std.diff b/crates/pin-project/patches/std.diff
new file mode 100644
index 0000000..562ddd1
--- /dev/null
+++ b/crates/pin-project/patches/std.diff
@@ -0,0 +1,14 @@
+diff --git a/src/lib.rs b/src/lib.rs
+index aaa561f..016a0c7 100644
+--- a/src/lib.rs
++++ b/src/lib.rs
+@@ -81,6 +81,9 @@
+ )]
+ #![allow(clippy::needless_doctest_main)]
+ 
++// ANDROID: Use std to allow building as a dylib.
++extern crate std;
++
+ #[doc(inline)]
+ pub use pin_project_internal::pin_project;
+ 
diff --git a/crates/pin-project/src/lib.rs b/crates/pin-project/src/lib.rs
new file mode 100644
index 0000000..41080ab
--- /dev/null
+++ b/crates/pin-project/src/lib.rs
@@ -0,0 +1,346 @@
+/*!
+<!-- tidy:crate-doc:start -->
+A crate for safe and ergonomic [pin-projection].
+
+## Usage
+
+Add this to your `Cargo.toml`:
+
+```toml
+[dependencies]
+pin-project = "1"
+```
+
+*Compiler support: requires rustc 1.56+*
+
+## Examples
+
+[`#[pin_project]`][`pin_project`] attribute creates projection types
+covering all the fields of struct or enum.
+
+```rust
+use std::pin::Pin;
+
+use pin_project::pin_project;
+
+#[pin_project]
+struct Struct<T, U> {
+    #[pin]
+    pinned: T,
+    unpinned: U,
+}
+
+impl<T, U> Struct<T, U> {
+    fn method(self: Pin<&mut Self>) {
+        let this = self.project();
+        let _: Pin<&mut T> = this.pinned; // Pinned reference to the field
+        let _: &mut U = this.unpinned; // Normal reference to the field
+    }
+}
+```
+
+[*code like this will be generated*][struct-default-expanded]
+
+To use `#[pin_project]` on enums, you need to name the projection type
+returned from the method.
+
+```rust
+use std::pin::Pin;
+
+use pin_project::pin_project;
+
+#[pin_project(project = EnumProj)]
+enum Enum<T, U> {
+    Pinned(#[pin] T),
+    Unpinned(U),
+}
+
+impl<T, U> Enum<T, U> {
+    fn method(self: Pin<&mut Self>) {
+        match self.project() {
+            EnumProj::Pinned(x) => {
+                let _: Pin<&mut T> = x;
+            }
+            EnumProj::Unpinned(y) => {
+                let _: &mut U = y;
+            }
+        }
+    }
+}
+```
+
+[*code like this will be generated*][enum-default-expanded]
+
+See [`#[pin_project]`][`pin_project`] attribute for more details, and
+see [examples] directory for more examples and generated code.
+
+## Related Projects
+
+- [pin-project-lite]: A lightweight version of pin-project written with declarative macros.
+
+[enum-default-expanded]: https://github.com/taiki-e/pin-project/blob/HEAD/examples/enum-default-expanded.rs
+[examples]: https://github.com/taiki-e/pin-project/blob/HEAD/examples/README.md
+[pin-project-lite]: https://github.com/taiki-e/pin-project-lite
+[pin-projection]: https://doc.rust-lang.org/std/pin/index.html#projections-and-structural-pinning
+[struct-default-expanded]: https://github.com/taiki-e/pin-project/blob/HEAD/examples/struct-default-expanded.rs
+
+<!-- tidy:crate-doc:end -->
+*/
+
+#![no_std]
+#![doc(test(
+    no_crate_inject,
+    attr(
+        deny(warnings, rust_2018_idioms, single_use_lifetimes),
+        allow(dead_code, unused_variables)
+    )
+))]
+#![warn(
+    missing_docs,
+    rust_2018_idioms,
+    single_use_lifetimes,
+    unreachable_pub,
+    unsafe_op_in_unsafe_fn
+)]
+#![warn(
+    clippy::pedantic,
+    // lints for public library
+    clippy::alloc_instead_of_core,
+    clippy::exhaustive_enums,
+    clippy::exhaustive_structs,
+    clippy::std_instead_of_alloc,
+    clippy::std_instead_of_core,
+    // lints that help writing unsafe code
+    clippy::as_ptr_cast_mut,
+    clippy::default_union_representation,
+    clippy::trailing_empty_array,
+    clippy::transmute_undefined_repr,
+    clippy::undocumented_unsafe_blocks,
+)]
+#![allow(clippy::needless_doctest_main)]
+
+// ANDROID: Use std to allow building as a dylib.
+extern crate std;
+
+#[doc(inline)]
+pub use pin_project_internal::pin_project;
+#[doc(inline)]
+pub use pin_project_internal::pinned_drop;
+
+/// A trait used for custom implementations of [`Unpin`].
+///
+/// This trait is used in conjunction with the `UnsafeUnpin` argument to
+/// the [`#[pin_project]`][macro@pin_project] attribute.
+///
+/// # Safety
+///
+/// The Rust [`Unpin`] trait is safe to implement - by itself,
+/// implementing it cannot lead to [undefined behavior][undefined-behavior].
+/// Undefined behavior can only occur when other unsafe code is used.
+///
+/// It turns out that using pin projections, which requires unsafe code,
+/// imposes additional requirements on an [`Unpin`] impl. Normally, all of this
+/// unsafety is contained within this crate, ensuring that it's impossible for
+/// you to violate any of the guarantees required by pin projection.
+///
+/// However, things change if you want to provide a custom [`Unpin`] impl
+/// for your `#[pin_project]` type. As stated in [the Rust
+/// documentation][pin-projection], you must be sure to only implement [`Unpin`]
+/// when all of your `#[pin]` fields (i.e. structurally pinned fields) are also
+/// [`Unpin`].
+///
+/// To help highlight this unsafety, the `UnsafeUnpin` trait is provided.
+/// Implementing this trait is logically equivalent to implementing [`Unpin`] -
+/// this crate will generate an [`Unpin`] impl for your type that 'forwards' to
+/// your `UnsafeUnpin` impl. However, this trait is `unsafe` - since your type
+/// uses structural pinning (otherwise, you wouldn't be using this crate!),
+/// you must be sure that your `UnsafeUnpin` impls follows all of
+/// the requirements for an [`Unpin`] impl of a structurally-pinned type.
+///
+/// Note that if you specify `#[pin_project(UnsafeUnpin)]`, but do *not*
+/// provide an impl of `UnsafeUnpin`, your type will never implement [`Unpin`].
+/// This is effectively the same thing as adding a [`PhantomPinned`] to your
+/// type.
+///
+/// Since this trait is `unsafe`, impls of it will be detected by the
+/// `unsafe_code` lint, and by tools like [`cargo geiger`][cargo-geiger].
+///
+/// # Examples
+///
+/// An `UnsafeUnpin` impl which, in addition to requiring that structurally
+/// pinned fields be [`Unpin`], imposes an additional requirement:
+///
+/// ```rust
+/// use pin_project::{pin_project, UnsafeUnpin};
+///
+/// #[pin_project(UnsafeUnpin)]
+/// struct Struct<K, V> {
+///     #[pin]
+///     field_1: K,
+///     field_2: V,
+/// }
+///
+/// unsafe impl<K, V> UnsafeUnpin for Struct<K, V> where K: Unpin + Clone {}
+/// ```
+///
+/// [`PhantomPinned`]: core::marker::PhantomPinned
+/// [cargo-geiger]: https://github.com/rust-secure-code/cargo-geiger
+/// [pin-projection]: core::pin#projections-and-structural-pinning
+/// [undefined-behavior]: https://doc.rust-lang.org/reference/behavior-considered-undefined.html
+pub unsafe trait UnsafeUnpin {}
+
+// Not public API.
+#[doc(hidden)]
+pub mod __private {
+    use core::mem::ManuallyDrop;
+    #[doc(hidden)]
+    pub use core::{
+        marker::{PhantomData, PhantomPinned, Unpin},
+        ops::Drop,
+        pin::Pin,
+        ptr,
+    };
+
+    #[doc(hidden)]
+    pub use pin_project_internal::__PinProjectInternalDerive;
+
+    use super::UnsafeUnpin;
+
+    // An internal trait used for custom implementations of [`Drop`].
+    //
+    // **Do not call or implement this trait directly.**
+    //
+    // # Why this trait is private and `#[pinned_drop]` attribute is needed?
+    //
+    // Implementing `PinnedDrop::drop` is safe, but calling it is not safe.
+    // This is because destructors can be called multiple times in safe code and
+    // [double dropping is unsound][rust-lang/rust#62360].
+    //
+    // Ideally, it would be desirable to be able to forbid manual calls in
+    // the same way as [`Drop::drop`], but the library cannot do it. So, by using
+    // macros and replacing them with private traits,
+    // this crate prevent users from calling `PinnedDrop::drop` in safe code.
+    //
+    // This allows implementing [`Drop`] safely using `#[pinned_drop]`.
+    // Also by using the [`drop`] function just like dropping a type that directly
+    // implements [`Drop`], can drop safely a type that implements `PinnedDrop`.
+    //
+    // [rust-lang/rust#62360]: https://github.com/rust-lang/rust/pull/62360
+    #[doc(hidden)]
+    pub trait PinnedDrop {
+        #[doc(hidden)]
+        unsafe fn drop(self: Pin<&mut Self>);
+    }
+
+    // This is an internal helper struct used by `pin-project-internal`.
+    // This allows us to force an error if the user tries to provide
+    // a regular `Unpin` impl when they specify the `UnsafeUnpin` argument.
+    // This is why we need Wrapper:
+    //
+    // Supposed we have the following code:
+    //
+    // ```rust
+    // #[pin_project(UnsafeUnpin)]
+    // struct MyStruct<T> {
+    //     #[pin] field: T
+    // }
+    //
+    // impl<T> Unpin for MyStruct<T> where MyStruct<T>: UnsafeUnpin {} // generated by pin-project-internal
+    // impl<T> Unpin for MyStruct<T> where T: Copy // written by the user
+    // ```
+    //
+    // We want this code to be rejected - the user is completely bypassing
+    // `UnsafeUnpin`, and providing an unsound Unpin impl in safe code!
+    //
+    // Unfortunately, the Rust compiler will accept the above code.
+    // Because MyStruct is declared in the same crate as the user-provided impl,
+    // the compiler will notice that `MyStruct<T>: UnsafeUnpin` never holds.
+    //
+    // The solution is to introduce the `Wrapper` struct, which is defined
+    // in the `pin-project` crate.
+    //
+    // We now have code that looks like this:
+    //
+    // ```rust
+    // impl<T> Unpin for MyStruct<T> where Wrapper<MyStruct<T>>: UnsafeUnpin {} // generated by pin-project-internal
+    // impl<T> Unpin for MyStruct<T> where T: Copy // written by the user
+    // ```
+    //
+    // We also have `unsafe impl<T> UnsafeUnpin for Wrapper<T> where T: UnsafeUnpin {}`
+    // in the `pin-project` crate.
+    //
+    // Now, our generated impl has a bound involving a type defined in another
+    // crate - Wrapper. This will cause rust to conservatively assume that
+    // `Wrapper<MyStruct<T>>: UnsafeUnpin` holds, in the interest of preserving
+    // forwards compatibility (in case such an impl is added for Wrapper<T> in
+    // a new version of the crate).
+    //
+    // This will cause rust to reject any other `Unpin` impls for MyStruct<T>,
+    // since it will assume that our generated impl could potentially apply in
+    // any situation.
+    //
+    // This achieves the desired effect - when the user writes
+    // `#[pin_project(UnsafeUnpin)]`, the user must either provide no impl of
+    // `UnsafeUnpin` (which is equivalent to making the type never implement
+    // Unpin), or provide an impl of `UnsafeUnpin`. It is impossible for them to
+    // provide an impl of `Unpin`
+    #[doc(hidden)]
+    pub struct Wrapper<'a, T: ?Sized>(PhantomData<&'a ()>, T);
+
+    // SAFETY: `T` implements UnsafeUnpin.
+    unsafe impl<T: ?Sized + UnsafeUnpin> UnsafeUnpin for Wrapper<'_, T> {}
+
+    // This is an internal helper struct used by `pin-project-internal`.
+    //
+    // See https://github.com/taiki-e/pin-project/pull/53 for more details.
+    #[doc(hidden)]
+    pub struct AlwaysUnpin<'a, T>(PhantomData<&'a ()>, PhantomData<T>);
+
+    impl<T> Unpin for AlwaysUnpin<'_, T> {}
+
+    // This is an internal helper used to ensure a value is dropped.
+    #[doc(hidden)]
+    pub struct UnsafeDropInPlaceGuard<T: ?Sized>(*mut T);
+
+    impl<T: ?Sized> UnsafeDropInPlaceGuard<T> {
+        #[doc(hidden)]
+        pub unsafe fn new(ptr: *mut T) -> Self {
+            Self(ptr)
+        }
+    }
+
+    impl<T: ?Sized> Drop for UnsafeDropInPlaceGuard<T> {
+        fn drop(&mut self) {
+            // SAFETY: the caller of `UnsafeDropInPlaceGuard::new` must guarantee
+            // that `ptr` is valid for drop when this guard is destructed.
+            unsafe {
+                ptr::drop_in_place(self.0);
+            }
+        }
+    }
+
+    // This is an internal helper used to ensure a value is overwritten without
+    // its destructor being called.
+    #[doc(hidden)]
+    pub struct UnsafeOverwriteGuard<T> {
+        target: *mut T,
+        value: ManuallyDrop<T>,
+    }
+
+    impl<T> UnsafeOverwriteGuard<T> {
+        #[doc(hidden)]
+        pub unsafe fn new(target: *mut T, value: T) -> Self {
+            Self { target, value: ManuallyDrop::new(value) }
+        }
+    }
+
+    impl<T> Drop for UnsafeOverwriteGuard<T> {
+        fn drop(&mut self) {
+            // SAFETY: the caller of `UnsafeOverwriteGuard::new` must guarantee
+            // that `target` is valid for writes when this guard is destructed.
+            unsafe {
+                ptr::write(self.target, ptr::read(&*self.value));
+            }
+        }
+    }
+}
diff --git a/crates/pin-project/tests/auxiliary/mod.rs b/crates/pin-project/tests/auxiliary/mod.rs
new file mode 100644
index 0000000..1457099
--- /dev/null
+++ b/crates/pin-project/tests/auxiliary/mod.rs
@@ -0,0 +1,12 @@
+#![allow(dead_code, unused_macros)]
+
+macro_rules! assert_unpin {
+    ($ty:ty) => {
+        static_assertions::assert_impl_all!($ty: Unpin);
+    };
+}
+macro_rules! assert_not_unpin {
+    ($ty:ty) => {
+        static_assertions::assert_not_impl_all!($ty: Unpin);
+    };
+}
diff --git a/crates/pin-project/tests/cfg.rs b/crates/pin-project/tests/cfg.rs
new file mode 100644
index 0000000..2f5387b
--- /dev/null
+++ b/crates/pin-project/tests/cfg.rs
@@ -0,0 +1,184 @@
+#![warn(rust_2018_idioms, single_use_lifetimes)]
+#![allow(dead_code)]
+
+// Refs: https://doc.rust-lang.org/reference/attributes.html
+
+#[macro_use]
+mod auxiliary;
+
+use std::{marker::PhantomPinned, pin::Pin};
+
+use pin_project::pin_project;
+
+struct Always;
+
+// Use this type to check that `cfg(any())` is working properly.
+struct Never(PhantomPinned);
+
+#[test]
+fn cfg() {
+    // structs
+
+    #[pin_project(project_replace)]
+    struct SameName {
+        #[cfg(not(any()))]
+        #[pin]
+        inner: Always,
+        #[cfg(any())]
+        #[pin]
+        inner: Never,
+    }
+
+    assert_unpin!(SameName);
+
+    let _ = SameName { inner: Always };
+
+    #[pin_project(project_replace)]
+    struct DifferentName {
+        #[cfg(not(any()))]
+        #[pin]
+        a: Always,
+        #[cfg(any())]
+        #[pin]
+        n: Never,
+    }
+
+    assert_unpin!(DifferentName);
+
+    let _ = DifferentName { a: Always };
+
+    #[pin_project(project_replace)]
+    struct TupleStruct(
+        #[cfg(not(any()))]
+        #[pin]
+        Always,
+        #[cfg(any())]
+        #[pin]
+        Never,
+    );
+
+    assert_unpin!(TupleStruct);
+
+    let _ = TupleStruct(Always);
+
+    // enums
+
+    #[pin_project(
+        project = VariantProj,
+        project_ref = VariantProjRef,
+        project_replace = VariantProjOwn,
+    )]
+    enum Variant {
+        #[cfg(not(any()))]
+        Inner(#[pin] Always),
+        #[cfg(any())]
+        Inner(#[pin] Never),
+
+        #[cfg(not(any()))]
+        A(#[pin] Always),
+        #[cfg(any())]
+        N(#[pin] Never),
+    }
+
+    assert_unpin!(Variant);
+
+    let _ = Variant::Inner(Always);
+    let _ = Variant::A(Always);
+
+    #[pin_project(
+        project = FieldProj,
+        project_ref = FieldProjRef,
+        project_replace = FieldProjOwn,
+    )]
+    enum Field {
+        SameName {
+            #[cfg(not(any()))]
+            #[pin]
+            inner: Always,
+            #[cfg(any())]
+            #[pin]
+            inner: Never,
+        },
+        DifferentName {
+            #[cfg(not(any()))]
+            #[pin]
+            a: Always,
+            #[cfg(any())]
+            #[pin]
+            n: Never,
+        },
+        TupleVariant(
+            #[cfg(not(any()))]
+            #[pin]
+            Always,
+            #[cfg(any())]
+            #[pin]
+            Never,
+        ),
+    }
+
+    assert_unpin!(Field);
+
+    let _ = Field::SameName { inner: Always };
+    let _ = Field::DifferentName { a: Always };
+    let _ = Field::TupleVariant(Always);
+}
+
+#[test]
+fn cfg_attr() {
+    #[pin_project(project_replace)]
+    struct SameCfg {
+        #[cfg(not(any()))]
+        #[cfg_attr(not(any()), pin)]
+        inner: Always,
+        #[cfg(any())]
+        #[cfg_attr(any(), pin)]
+        inner: Never,
+    }
+
+    assert_unpin!(SameCfg);
+
+    let mut x = SameCfg { inner: Always };
+    let x = Pin::new(&mut x).project();
+    let _: Pin<&mut Always> = x.inner;
+
+    #[pin_project(project_replace)]
+    struct DifferentCfg {
+        #[cfg(not(any()))]
+        #[cfg_attr(any(), pin)]
+        inner: Always,
+        #[cfg(any())]
+        #[cfg_attr(not(any()), pin)]
+        inner: Never,
+    }
+
+    assert_unpin!(DifferentCfg);
+
+    let mut x = DifferentCfg { inner: Always };
+    let x = Pin::new(&mut x).project();
+    let _: &mut Always = x.inner;
+
+    #[cfg_attr(not(any()), pin_project)]
+    struct Foo<T> {
+        #[cfg_attr(not(any()), pin)]
+        inner: T,
+    }
+
+    assert_unpin!(Foo<()>);
+    assert_not_unpin!(Foo<PhantomPinned>);
+
+    let mut x = Foo { inner: 0_u8 };
+    let x = Pin::new(&mut x).project();
+    let _: Pin<&mut u8> = x.inner;
+}
+
+#[test]
+fn cfg_attr_any_packed() {
+    // Since `cfg(any())` can never be true, it is okay for this to pass.
+    #[pin_project(project_replace)]
+    #[cfg_attr(any(), repr(packed))]
+    struct Struct {
+        #[pin]
+        f: u32,
+    }
+}
diff --git a/crates/pin-project/tests/compiletest.rs b/crates/pin-project/tests/compiletest.rs
new file mode 100644
index 0000000..cb30f60
--- /dev/null
+++ b/crates/pin-project/tests/compiletest.rs
@@ -0,0 +1,17 @@
+#![cfg(not(miri))]
+#![cfg(not(careful))]
+#![warn(rust_2018_idioms, single_use_lifetimes)]
+
+use std::env;
+
+#[rustversion::attr(not(nightly), ignore)]
+#[test]
+fn ui() {
+    if env::var_os("CI").is_none() {
+        env::set_var("TRYBUILD", "overwrite");
+    }
+
+    let t = trybuild::TestCases::new();
+    t.compile_fail("tests/ui/**/*.rs");
+    t.pass("tests/run-pass/**/*.rs");
+}
diff --git a/crates/pin-project/tests/drop_order.rs b/crates/pin-project/tests/drop_order.rs
new file mode 100644
index 0000000..f1e01fd
--- /dev/null
+++ b/crates/pin-project/tests/drop_order.rs
@@ -0,0 +1,160 @@
+#![warn(rust_2018_idioms, single_use_lifetimes)]
+
+// Refs: https://doc.rust-lang.org/reference/destructors.html
+
+use std::{cell::Cell, pin::Pin, thread};
+
+use pin_project::pin_project;
+
+struct D<'a>(&'a Cell<usize>, usize);
+
+impl Drop for D<'_> {
+    fn drop(&mut self) {
+        if !thread::panicking() {
+            let old = self.0.replace(self.1);
+            assert_eq!(old, self.1 - 1);
+        }
+    }
+}
+
+#[pin_project(project_replace)]
+struct StructPinned<'a> {
+    #[pin]
+    f1: D<'a>,
+    #[pin]
+    f2: D<'a>,
+}
+
+#[pin_project(project_replace)]
+struct StructUnpinned<'a> {
+    f1: D<'a>,
+    f2: D<'a>,
+}
+
+#[pin_project(project_replace)]
+struct TuplePinned<'a>(#[pin] D<'a>, #[pin] D<'a>);
+
+#[pin_project(project_replace)]
+struct TupleUnpinned<'a>(D<'a>, D<'a>);
+
+#[pin_project(project_replace = EnumProj)]
+enum Enum<'a> {
+    StructPinned {
+        #[pin]
+        f1: D<'a>,
+        #[pin]
+        f2: D<'a>,
+    },
+    StructUnpinned {
+        f1: D<'a>,
+        f2: D<'a>,
+    },
+    TuplePinned(#[pin] D<'a>, #[pin] D<'a>),
+    TupleUnpinned(D<'a>, D<'a>),
+}
+
+#[test]
+fn struct_pinned() {
+    {
+        let c = Cell::new(0);
+        let _x = StructPinned { f1: D(&c, 1), f2: D(&c, 2) };
+    }
+    {
+        let c = Cell::new(0);
+        let mut x = StructPinned { f1: D(&c, 1), f2: D(&c, 2) };
+        let y = Pin::new(&mut x);
+        let _z = y.project_replace(StructPinned { f1: D(&c, 3), f2: D(&c, 4) });
+    }
+}
+
+#[test]
+fn struct_unpinned() {
+    {
+        let c = Cell::new(0);
+        let _x = StructUnpinned { f1: D(&c, 1), f2: D(&c, 2) };
+    }
+    {
+        let c = Cell::new(0);
+        let mut x = StructUnpinned { f1: D(&c, 1), f2: D(&c, 2) };
+        let y = Pin::new(&mut x);
+        let _z = y.project_replace(StructUnpinned { f1: D(&c, 3), f2: D(&c, 4) });
+    }
+}
+
+#[test]
+fn tuple_pinned() {
+    {
+        let c = Cell::new(0);
+        let _x = TuplePinned(D(&c, 1), D(&c, 2));
+    }
+    {
+        let c = Cell::new(0);
+        let mut x = TuplePinned(D(&c, 1), D(&c, 2));
+        let y = Pin::new(&mut x);
+        let _z = y.project_replace(TuplePinned(D(&c, 3), D(&c, 4)));
+    }
+}
+
+#[test]
+fn tuple_unpinned() {
+    {
+        let c = Cell::new(0);
+        let _x = TupleUnpinned(D(&c, 1), D(&c, 2));
+    }
+    {
+        let c = Cell::new(0);
+        let mut x = TupleUnpinned(D(&c, 1), D(&c, 2));
+        let y = Pin::new(&mut x);
+        let _z = y.project_replace(TupleUnpinned(D(&c, 3), D(&c, 4)));
+    }
+}
+
+#[test]
+fn enum_struct() {
+    {
+        let c = Cell::new(0);
+        let _x = Enum::StructPinned { f1: D(&c, 1), f2: D(&c, 2) };
+    }
+    {
+        let c = Cell::new(0);
+        let mut x = Enum::StructPinned { f1: D(&c, 1), f2: D(&c, 2) };
+        let y = Pin::new(&mut x);
+        let _z = y.project_replace(Enum::StructPinned { f1: D(&c, 3), f2: D(&c, 4) });
+    }
+
+    {
+        let c = Cell::new(0);
+        let _x = Enum::StructUnpinned { f1: D(&c, 1), f2: D(&c, 2) };
+    }
+    {
+        let c = Cell::new(0);
+        let mut x = Enum::StructUnpinned { f1: D(&c, 1), f2: D(&c, 2) };
+        let y = Pin::new(&mut x);
+        let _z = y.project_replace(Enum::StructUnpinned { f1: D(&c, 3), f2: D(&c, 4) });
+    }
+}
+
+#[test]
+fn enum_tuple() {
+    {
+        let c = Cell::new(0);
+        let _x = Enum::TuplePinned(D(&c, 1), D(&c, 2));
+    }
+    {
+        let c = Cell::new(0);
+        let mut x = Enum::TuplePinned(D(&c, 1), D(&c, 2));
+        let y = Pin::new(&mut x);
+        let _z = y.project_replace(Enum::TuplePinned(D(&c, 3), D(&c, 4)));
+    }
+
+    {
+        let c = Cell::new(0);
+        let _x = Enum::TupleUnpinned(D(&c, 1), D(&c, 2));
+    }
+    {
+        let c = Cell::new(0);
+        let mut x = Enum::TupleUnpinned(D(&c, 1), D(&c, 2));
+        let y = Pin::new(&mut x);
+        let _z = y.project_replace(Enum::TupleUnpinned(D(&c, 3), D(&c, 4)));
+    }
+}
diff --git a/crates/pin-project/tests/expand/default/enum.expanded.rs b/crates/pin-project/tests/expand/default/enum.expanded.rs
new file mode 100644
index 0000000..599a5f9
--- /dev/null
+++ b/crates/pin-project/tests/expand/default/enum.expanded.rs
@@ -0,0 +1,147 @@
+use pin_project::pin_project;
+#[pin(__private(project = EnumProj, project_ref = EnumProjRef))]
+enum Enum<T, U> {
+    Struct { #[pin] pinned: T, unpinned: U },
+    Tuple(#[pin] T, U),
+    Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::mut_mut)]
+enum EnumProj<'pin, T, U>
+where
+    Enum<T, U>: 'pin,
+{
+    Struct {
+        pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
+        unpinned: &'pin mut (U),
+    },
+    Tuple(::pin_project::__private::Pin<&'pin mut (T)>, &'pin mut (U)),
+    Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::ref_option_ref)]
+enum EnumProjRef<'pin, T, U>
+where
+    Enum<T, U>: 'pin,
+{
+    Struct { pinned: ::pin_project::__private::Pin<&'pin (T)>, unpinned: &'pin (U) },
+    Tuple(::pin_project::__private::Pin<&'pin (T)>, &'pin (U)),
+    Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(unused_extern_crates)]
+    extern crate pin_project as _pin_project;
+    impl<T, U> Enum<T, U> {
+        #[allow(dead_code)]
+        #[inline]
+        fn project<'pin>(
+            self: _pin_project::__private::Pin<&'pin mut Self>,
+        ) -> EnumProj<'pin, T, U> {
+            unsafe {
+                match self.get_unchecked_mut() {
+                    Self::Struct { pinned, unpinned } => {
+                        EnumProj::Struct {
+                            pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+                            unpinned,
+                        }
+                    }
+                    Self::Tuple(_0, _1) => {
+                        EnumProj::Tuple(
+                            _pin_project::__private::Pin::new_unchecked(_0),
+                            _1,
+                        )
+                    }
+                    Self::Unit => EnumProj::Unit,
+                }
+            }
+        }
+        #[allow(dead_code)]
+        #[allow(clippy::missing_const_for_fn)]
+        #[inline]
+        fn project_ref<'pin>(
+            self: _pin_project::__private::Pin<&'pin Self>,
+        ) -> EnumProjRef<'pin, T, U> {
+            unsafe {
+                match self.get_ref() {
+                    Self::Struct { pinned, unpinned } => {
+                        EnumProjRef::Struct {
+                            pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+                            unpinned,
+                        }
+                    }
+                    Self::Tuple(_0, _1) => {
+                        EnumProjRef::Tuple(
+                            _pin_project::__private::Pin::new_unchecked(_0),
+                            _1,
+                        )
+                    }
+                    Self::Unit => EnumProjRef::Unit,
+                }
+            }
+        }
+    }
+    #[allow(missing_debug_implementations)]
+    struct __Enum<'pin, T, U> {
+        __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+            'pin,
+            (
+                _pin_project::__private::PhantomData<T>,
+                _pin_project::__private::PhantomData<U>,
+            ),
+        >,
+        __field0: T,
+        __field1: T,
+    }
+    impl<'pin, T, U> _pin_project::__private::Unpin for Enum<T, U>
+    where
+        __Enum<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    #[doc(hidden)]
+    unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Enum<T, U>
+    where
+        __Enum<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    trait EnumMustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: _pin_project::__private::Drop> EnumMustNotImplDrop for T {}
+    impl<T, U> EnumMustNotImplDrop for Enum<T, U> {}
+    #[doc(hidden)]
+    impl<T, U> _pin_project::__private::PinnedDrop for Enum<T, U> {
+        unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+    }
+};
+fn main() {}
diff --git a/crates/pin-project/tests/expand/default/enum.rs b/crates/pin-project/tests/expand/default/enum.rs
new file mode 100644
index 0000000..ff05615
--- /dev/null
+++ b/crates/pin-project/tests/expand/default/enum.rs
@@ -0,0 +1,14 @@
+use pin_project::pin_project;
+
+#[pin_project(project = EnumProj, project_ref = EnumProjRef)]
+enum Enum<T, U> {
+    Struct {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    },
+    Tuple(#[pin] T, U),
+    Unit,
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/expand/default/struct.expanded.rs b/crates/pin-project/tests/expand/default/struct.expanded.rs
new file mode 100644
index 0000000..db3c948
--- /dev/null
+++ b/crates/pin-project/tests/expand/default/struct.expanded.rs
@@ -0,0 +1,106 @@
+use pin_project::pin_project;
+#[pin(__private())]
+struct Struct<T, U> {
+    #[pin]
+    pinned: T,
+    unpinned: U,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(unused_extern_crates)]
+    extern crate pin_project as _pin_project;
+    #[allow(dead_code)]
+    #[allow(clippy::mut_mut)]
+    struct __StructProjection<'pin, T, U>
+    where
+        Struct<T, U>: 'pin,
+    {
+        pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
+        unpinned: &'pin mut (U),
+    }
+    #[allow(dead_code)]
+    #[allow(clippy::ref_option_ref)]
+    struct __StructProjectionRef<'pin, T, U>
+    where
+        Struct<T, U>: 'pin,
+    {
+        pinned: ::pin_project::__private::Pin<&'pin (T)>,
+        unpinned: &'pin (U),
+    }
+    impl<T, U> Struct<T, U> {
+        #[allow(dead_code)]
+        #[inline]
+        fn project<'pin>(
+            self: _pin_project::__private::Pin<&'pin mut Self>,
+        ) -> __StructProjection<'pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_unchecked_mut();
+                __StructProjection {
+                    pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+                    unpinned,
+                }
+            }
+        }
+        #[allow(dead_code)]
+        #[allow(clippy::missing_const_for_fn)]
+        #[inline]
+        fn project_ref<'pin>(
+            self: _pin_project::__private::Pin<&'pin Self>,
+        ) -> __StructProjectionRef<'pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_ref();
+                __StructProjectionRef {
+                    pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+                    unpinned,
+                }
+            }
+        }
+    }
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+        let _ = &this.pinned;
+        let _ = &this.unpinned;
+    }
+    #[allow(missing_debug_implementations)]
+    struct __Struct<'pin, T, U> {
+        __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+            'pin,
+            (
+                _pin_project::__private::PhantomData<T>,
+                _pin_project::__private::PhantomData<U>,
+            ),
+        >,
+        __field0: T,
+    }
+    impl<'pin, T, U> _pin_project::__private::Unpin for Struct<T, U>
+    where
+        __Struct<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    #[doc(hidden)]
+    unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Struct<T, U>
+    where
+        __Struct<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    trait StructMustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: _pin_project::__private::Drop> StructMustNotImplDrop for T {}
+    impl<T, U> StructMustNotImplDrop for Struct<T, U> {}
+    #[doc(hidden)]
+    impl<T, U> _pin_project::__private::PinnedDrop for Struct<T, U> {
+        unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+    }
+};
+fn main() {}
diff --git a/crates/pin-project/tests/expand/default/struct.rs b/crates/pin-project/tests/expand/default/struct.rs
new file mode 100644
index 0000000..474f0a1
--- /dev/null
+++ b/crates/pin-project/tests/expand/default/struct.rs
@@ -0,0 +1,10 @@
+use pin_project::pin_project;
+
+#[pin_project]
+struct Struct<T, U> {
+    #[pin]
+    pinned: T,
+    unpinned: U,
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/expand/default/tuple_struct.expanded.rs b/crates/pin-project/tests/expand/default/tuple_struct.expanded.rs
new file mode 100644
index 0000000..6b962d6
--- /dev/null
+++ b/crates/pin-project/tests/expand/default/tuple_struct.expanded.rs
@@ -0,0 +1,100 @@
+use pin_project::pin_project;
+#[pin(__private())]
+struct TupleStruct<T, U>(#[pin] T, U);
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(unused_extern_crates)]
+    extern crate pin_project as _pin_project;
+    #[allow(dead_code)]
+    #[allow(clippy::mut_mut)]
+    struct __TupleStructProjection<'pin, T, U>(
+        ::pin_project::__private::Pin<&'pin mut (T)>,
+        &'pin mut (U),
+    )
+    where
+        TupleStruct<T, U>: 'pin;
+    #[allow(dead_code)]
+    #[allow(clippy::ref_option_ref)]
+    struct __TupleStructProjectionRef<'pin, T, U>(
+        ::pin_project::__private::Pin<&'pin (T)>,
+        &'pin (U),
+    )
+    where
+        TupleStruct<T, U>: 'pin;
+    impl<T, U> TupleStruct<T, U> {
+        #[allow(dead_code)]
+        #[inline]
+        fn project<'pin>(
+            self: _pin_project::__private::Pin<&'pin mut Self>,
+        ) -> __TupleStructProjection<'pin, T, U> {
+            unsafe {
+                let Self(_0, _1) = self.get_unchecked_mut();
+                __TupleStructProjection(
+                    _pin_project::__private::Pin::new_unchecked(_0),
+                    _1,
+                )
+            }
+        }
+        #[allow(dead_code)]
+        #[allow(clippy::missing_const_for_fn)]
+        #[inline]
+        fn project_ref<'pin>(
+            self: _pin_project::__private::Pin<&'pin Self>,
+        ) -> __TupleStructProjectionRef<'pin, T, U> {
+            unsafe {
+                let Self(_0, _1) = self.get_ref();
+                __TupleStructProjectionRef(
+                    _pin_project::__private::Pin::new_unchecked(_0),
+                    _1,
+                )
+            }
+        }
+    }
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &TupleStruct<T, U>) {
+        let _ = &this.0;
+        let _ = &this.1;
+    }
+    #[allow(missing_debug_implementations)]
+    struct __TupleStruct<'pin, T, U> {
+        __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+            'pin,
+            (
+                _pin_project::__private::PhantomData<T>,
+                _pin_project::__private::PhantomData<U>,
+            ),
+        >,
+        __field0: T,
+    }
+    impl<'pin, T, U> _pin_project::__private::Unpin for TupleStruct<T, U>
+    where
+        __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    #[doc(hidden)]
+    unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for TupleStruct<T, U>
+    where
+        __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    trait TupleStructMustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: _pin_project::__private::Drop> TupleStructMustNotImplDrop for T {}
+    impl<T, U> TupleStructMustNotImplDrop for TupleStruct<T, U> {}
+    #[doc(hidden)]
+    impl<T, U> _pin_project::__private::PinnedDrop for TupleStruct<T, U> {
+        unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+    }
+};
+fn main() {}
diff --git a/crates/pin-project/tests/expand/default/tuple_struct.rs b/crates/pin-project/tests/expand/default/tuple_struct.rs
new file mode 100644
index 0000000..398b14f
--- /dev/null
+++ b/crates/pin-project/tests/expand/default/tuple_struct.rs
@@ -0,0 +1,6 @@
+use pin_project::pin_project;
+
+#[pin_project]
+struct TupleStruct<T, U>(#[pin] T, U);
+
+fn main() {}
diff --git a/crates/pin-project/tests/expand/multifields/enum.expanded.rs b/crates/pin-project/tests/expand/multifields/enum.expanded.rs
new file mode 100644
index 0000000..003f1c7
--- /dev/null
+++ b/crates/pin-project/tests/expand/multifields/enum.expanded.rs
@@ -0,0 +1,271 @@
+use pin_project::pin_project;
+#[pin(
+    __private(
+        project = EnumProj,
+        project_ref = EnumProjRef,
+        project_replace = EnumProjOwn
+    )
+)]
+enum Enum<T, U> {
+    Struct { #[pin] pinned1: T, #[pin] pinned2: T, unpinned1: U, unpinned2: U },
+    Tuple(#[pin] T, #[pin] T, U, U),
+    Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::mut_mut)]
+enum EnumProj<'pin, T, U>
+where
+    Enum<T, U>: 'pin,
+{
+    Struct {
+        pinned1: ::pin_project::__private::Pin<&'pin mut (T)>,
+        pinned2: ::pin_project::__private::Pin<&'pin mut (T)>,
+        unpinned1: &'pin mut (U),
+        unpinned2: &'pin mut (U),
+    },
+    Tuple(
+        ::pin_project::__private::Pin<&'pin mut (T)>,
+        ::pin_project::__private::Pin<&'pin mut (T)>,
+        &'pin mut (U),
+        &'pin mut (U),
+    ),
+    Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::ref_option_ref)]
+enum EnumProjRef<'pin, T, U>
+where
+    Enum<T, U>: 'pin,
+{
+    Struct {
+        pinned1: ::pin_project::__private::Pin<&'pin (T)>,
+        pinned2: ::pin_project::__private::Pin<&'pin (T)>,
+        unpinned1: &'pin (U),
+        unpinned2: &'pin (U),
+    },
+    Tuple(
+        ::pin_project::__private::Pin<&'pin (T)>,
+        ::pin_project::__private::Pin<&'pin (T)>,
+        &'pin (U),
+        &'pin (U),
+    ),
+    Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(variant_size_differences)]
+#[allow(clippy::large_enum_variant)]
+enum EnumProjOwn<T, U> {
+    Struct {
+        pinned1: ::pin_project::__private::PhantomData<T>,
+        pinned2: ::pin_project::__private::PhantomData<T>,
+        unpinned1: U,
+        unpinned2: U,
+    },
+    Tuple(
+        ::pin_project::__private::PhantomData<T>,
+        ::pin_project::__private::PhantomData<T>,
+        U,
+        U,
+    ),
+    Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(unused_extern_crates)]
+    extern crate pin_project as _pin_project;
+    impl<T, U> Enum<T, U> {
+        #[allow(dead_code)]
+        #[inline]
+        fn project<'pin>(
+            self: _pin_project::__private::Pin<&'pin mut Self>,
+        ) -> EnumProj<'pin, T, U> {
+            unsafe {
+                match self.get_unchecked_mut() {
+                    Self::Struct { pinned1, pinned2, unpinned1, unpinned2 } => {
+                        EnumProj::Struct {
+                            pinned1: _pin_project::__private::Pin::new_unchecked(
+                                pinned1,
+                            ),
+                            pinned2: _pin_project::__private::Pin::new_unchecked(
+                                pinned2,
+                            ),
+                            unpinned1,
+                            unpinned2,
+                        }
+                    }
+                    Self::Tuple(_0, _1, _2, _3) => {
+                        EnumProj::Tuple(
+                            _pin_project::__private::Pin::new_unchecked(_0),
+                            _pin_project::__private::Pin::new_unchecked(_1),
+                            _2,
+                            _3,
+                        )
+                    }
+                    Self::Unit => EnumProj::Unit,
+                }
+            }
+        }
+        #[allow(dead_code)]
+        #[allow(clippy::missing_const_for_fn)]
+        #[inline]
+        fn project_ref<'pin>(
+            self: _pin_project::__private::Pin<&'pin Self>,
+        ) -> EnumProjRef<'pin, T, U> {
+            unsafe {
+                match self.get_ref() {
+                    Self::Struct { pinned1, pinned2, unpinned1, unpinned2 } => {
+                        EnumProjRef::Struct {
+                            pinned1: _pin_project::__private::Pin::new_unchecked(
+                                pinned1,
+                            ),
+                            pinned2: _pin_project::__private::Pin::new_unchecked(
+                                pinned2,
+                            ),
+                            unpinned1,
+                            unpinned2,
+                        }
+                    }
+                    Self::Tuple(_0, _1, _2, _3) => {
+                        EnumProjRef::Tuple(
+                            _pin_project::__private::Pin::new_unchecked(_0),
+                            _pin_project::__private::Pin::new_unchecked(_1),
+                            _2,
+                            _3,
+                        )
+                    }
+                    Self::Unit => EnumProjRef::Unit,
+                }
+            }
+        }
+        #[allow(dead_code)]
+        #[inline]
+        fn project_replace(
+            self: _pin_project::__private::Pin<&mut Self>,
+            __replacement: Self,
+        ) -> EnumProjOwn<T, U> {
+            unsafe {
+                let __self_ptr: *mut Self = self.get_unchecked_mut();
+                let __guard = _pin_project::__private::UnsafeOverwriteGuard::new(
+                    __self_ptr,
+                    __replacement,
+                );
+                match &mut *__self_ptr {
+                    Self::Struct { pinned1, pinned2, unpinned1, unpinned2 } => {
+                        let __result = EnumProjOwn::Struct {
+                            pinned1: _pin_project::__private::PhantomData,
+                            pinned2: _pin_project::__private::PhantomData,
+                            unpinned1: _pin_project::__private::ptr::read(unpinned1),
+                            unpinned2: _pin_project::__private::ptr::read(unpinned2),
+                        };
+                        {
+                            let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
+                                pinned2,
+                            );
+                            let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
+                                pinned1,
+                            );
+                        }
+                        __result
+                    }
+                    Self::Tuple(_0, _1, _2, _3) => {
+                        let __result = EnumProjOwn::Tuple(
+                            _pin_project::__private::PhantomData,
+                            _pin_project::__private::PhantomData,
+                            _pin_project::__private::ptr::read(_2),
+                            _pin_project::__private::ptr::read(_3),
+                        );
+                        {
+                            let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
+                                _1,
+                            );
+                            let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
+                                _0,
+                            );
+                        }
+                        __result
+                    }
+                    Self::Unit => {
+                        let __result = EnumProjOwn::Unit;
+                        {}
+                        __result
+                    }
+                }
+            }
+        }
+    }
+    #[allow(missing_debug_implementations)]
+    struct __Enum<'pin, T, U> {
+        __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+            'pin,
+            (
+                _pin_project::__private::PhantomData<T>,
+                _pin_project::__private::PhantomData<U>,
+            ),
+        >,
+        __field0: T,
+        __field1: T,
+        __field2: T,
+        __field3: T,
+    }
+    impl<'pin, T, U> _pin_project::__private::Unpin for Enum<T, U>
+    where
+        __Enum<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    #[doc(hidden)]
+    unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Enum<T, U>
+    where
+        __Enum<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    trait EnumMustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: _pin_project::__private::Drop> EnumMustNotImplDrop for T {}
+    impl<T, U> EnumMustNotImplDrop for Enum<T, U> {}
+    #[doc(hidden)]
+    impl<T, U> _pin_project::__private::PinnedDrop for Enum<T, U> {
+        unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+    }
+};
+fn main() {}
diff --git a/crates/pin-project/tests/expand/multifields/enum.rs b/crates/pin-project/tests/expand/multifields/enum.rs
new file mode 100644
index 0000000..754d48c
--- /dev/null
+++ b/crates/pin-project/tests/expand/multifields/enum.rs
@@ -0,0 +1,17 @@
+use pin_project::pin_project;
+
+#[pin_project(project = EnumProj, project_ref = EnumProjRef, project_replace = EnumProjOwn)]
+enum Enum<T, U> {
+    Struct {
+        #[pin]
+        pinned1: T,
+        #[pin]
+        pinned2: T,
+        unpinned1: U,
+        unpinned2: U,
+    },
+    Tuple(#[pin] T, #[pin] T, U, U),
+    Unit,
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/expand/multifields/struct.expanded.rs b/crates/pin-project/tests/expand/multifields/struct.expanded.rs
new file mode 100644
index 0000000..c3e7a02
--- /dev/null
+++ b/crates/pin-project/tests/expand/multifields/struct.expanded.rs
@@ -0,0 +1,158 @@
+use pin_project::pin_project;
+#[pin(__private(project_replace))]
+struct Struct<T, U> {
+    #[pin]
+    pinned1: T,
+    #[pin]
+    pinned2: T,
+    unpinned1: U,
+    unpinned2: U,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(unused_extern_crates)]
+    extern crate pin_project as _pin_project;
+    #[allow(dead_code)]
+    #[allow(clippy::mut_mut)]
+    struct __StructProjection<'pin, T, U>
+    where
+        Struct<T, U>: 'pin,
+    {
+        pinned1: ::pin_project::__private::Pin<&'pin mut (T)>,
+        pinned2: ::pin_project::__private::Pin<&'pin mut (T)>,
+        unpinned1: &'pin mut (U),
+        unpinned2: &'pin mut (U),
+    }
+    #[allow(dead_code)]
+    #[allow(clippy::ref_option_ref)]
+    struct __StructProjectionRef<'pin, T, U>
+    where
+        Struct<T, U>: 'pin,
+    {
+        pinned1: ::pin_project::__private::Pin<&'pin (T)>,
+        pinned2: ::pin_project::__private::Pin<&'pin (T)>,
+        unpinned1: &'pin (U),
+        unpinned2: &'pin (U),
+    }
+    #[allow(dead_code)]
+    struct __StructProjectionOwned<T, U> {
+        pinned1: ::pin_project::__private::PhantomData<T>,
+        pinned2: ::pin_project::__private::PhantomData<T>,
+        unpinned1: U,
+        unpinned2: U,
+    }
+    impl<T, U> Struct<T, U> {
+        #[allow(dead_code)]
+        #[inline]
+        fn project<'pin>(
+            self: _pin_project::__private::Pin<&'pin mut Self>,
+        ) -> __StructProjection<'pin, T, U> {
+            unsafe {
+                let Self { pinned1, pinned2, unpinned1, unpinned2 } = self
+                    .get_unchecked_mut();
+                __StructProjection {
+                    pinned1: _pin_project::__private::Pin::new_unchecked(pinned1),
+                    pinned2: _pin_project::__private::Pin::new_unchecked(pinned2),
+                    unpinned1,
+                    unpinned2,
+                }
+            }
+        }
+        #[allow(dead_code)]
+        #[allow(clippy::missing_const_for_fn)]
+        #[inline]
+        fn project_ref<'pin>(
+            self: _pin_project::__private::Pin<&'pin Self>,
+        ) -> __StructProjectionRef<'pin, T, U> {
+            unsafe {
+                let Self { pinned1, pinned2, unpinned1, unpinned2 } = self.get_ref();
+                __StructProjectionRef {
+                    pinned1: _pin_project::__private::Pin::new_unchecked(pinned1),
+                    pinned2: _pin_project::__private::Pin::new_unchecked(pinned2),
+                    unpinned1,
+                    unpinned2,
+                }
+            }
+        }
+        #[allow(dead_code)]
+        #[inline]
+        fn project_replace(
+            self: _pin_project::__private::Pin<&mut Self>,
+            __replacement: Self,
+        ) -> __StructProjectionOwned<T, U> {
+            unsafe {
+                let __self_ptr: *mut Self = self.get_unchecked_mut();
+                let __guard = _pin_project::__private::UnsafeOverwriteGuard::new(
+                    __self_ptr,
+                    __replacement,
+                );
+                let Self { pinned1, pinned2, unpinned1, unpinned2 } = &mut *__self_ptr;
+                let __result = __StructProjectionOwned {
+                    pinned1: _pin_project::__private::PhantomData,
+                    pinned2: _pin_project::__private::PhantomData,
+                    unpinned1: _pin_project::__private::ptr::read(unpinned1),
+                    unpinned2: _pin_project::__private::ptr::read(unpinned2),
+                };
+                {
+                    let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
+                        pinned2,
+                    );
+                    let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
+                        pinned1,
+                    );
+                }
+                __result
+            }
+        }
+    }
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+        let _ = &this.pinned1;
+        let _ = &this.pinned2;
+        let _ = &this.unpinned1;
+        let _ = &this.unpinned2;
+    }
+    #[allow(missing_debug_implementations)]
+    struct __Struct<'pin, T, U> {
+        __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+            'pin,
+            (
+                _pin_project::__private::PhantomData<T>,
+                _pin_project::__private::PhantomData<U>,
+            ),
+        >,
+        __field0: T,
+        __field1: T,
+    }
+    impl<'pin, T, U> _pin_project::__private::Unpin for Struct<T, U>
+    where
+        __Struct<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    #[doc(hidden)]
+    unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Struct<T, U>
+    where
+        __Struct<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    trait StructMustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: _pin_project::__private::Drop> StructMustNotImplDrop for T {}
+    impl<T, U> StructMustNotImplDrop for Struct<T, U> {}
+    #[doc(hidden)]
+    impl<T, U> _pin_project::__private::PinnedDrop for Struct<T, U> {
+        unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+    }
+};
+fn main() {}
diff --git a/crates/pin-project/tests/expand/multifields/struct.rs b/crates/pin-project/tests/expand/multifields/struct.rs
new file mode 100644
index 0000000..3b319bf
--- /dev/null
+++ b/crates/pin-project/tests/expand/multifields/struct.rs
@@ -0,0 +1,13 @@
+use pin_project::pin_project;
+
+#[pin_project(project_replace)]
+struct Struct<T, U> {
+    #[pin]
+    pinned1: T,
+    #[pin]
+    pinned2: T,
+    unpinned1: U,
+    unpinned2: U,
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/expand/multifields/tuple_struct.expanded.rs b/crates/pin-project/tests/expand/multifields/tuple_struct.expanded.rs
new file mode 100644
index 0000000..3931e09
--- /dev/null
+++ b/crates/pin-project/tests/expand/multifields/tuple_struct.expanded.rs
@@ -0,0 +1,148 @@
+use pin_project::pin_project;
+#[pin(__private(project_replace))]
+struct TupleStruct<T, U>(#[pin] T, #[pin] T, U, U);
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(unused_extern_crates)]
+    extern crate pin_project as _pin_project;
+    #[allow(dead_code)]
+    #[allow(clippy::mut_mut)]
+    struct __TupleStructProjection<'pin, T, U>(
+        ::pin_project::__private::Pin<&'pin mut (T)>,
+        ::pin_project::__private::Pin<&'pin mut (T)>,
+        &'pin mut (U),
+        &'pin mut (U),
+    )
+    where
+        TupleStruct<T, U>: 'pin;
+    #[allow(dead_code)]
+    #[allow(clippy::ref_option_ref)]
+    struct __TupleStructProjectionRef<'pin, T, U>(
+        ::pin_project::__private::Pin<&'pin (T)>,
+        ::pin_project::__private::Pin<&'pin (T)>,
+        &'pin (U),
+        &'pin (U),
+    )
+    where
+        TupleStruct<T, U>: 'pin;
+    #[allow(dead_code)]
+    struct __TupleStructProjectionOwned<T, U>(
+        ::pin_project::__private::PhantomData<T>,
+        ::pin_project::__private::PhantomData<T>,
+        U,
+        U,
+    );
+    impl<T, U> TupleStruct<T, U> {
+        #[allow(dead_code)]
+        #[inline]
+        fn project<'pin>(
+            self: _pin_project::__private::Pin<&'pin mut Self>,
+        ) -> __TupleStructProjection<'pin, T, U> {
+            unsafe {
+                let Self(_0, _1, _2, _3) = self.get_unchecked_mut();
+                __TupleStructProjection(
+                    _pin_project::__private::Pin::new_unchecked(_0),
+                    _pin_project::__private::Pin::new_unchecked(_1),
+                    _2,
+                    _3,
+                )
+            }
+        }
+        #[allow(dead_code)]
+        #[allow(clippy::missing_const_for_fn)]
+        #[inline]
+        fn project_ref<'pin>(
+            self: _pin_project::__private::Pin<&'pin Self>,
+        ) -> __TupleStructProjectionRef<'pin, T, U> {
+            unsafe {
+                let Self(_0, _1, _2, _3) = self.get_ref();
+                __TupleStructProjectionRef(
+                    _pin_project::__private::Pin::new_unchecked(_0),
+                    _pin_project::__private::Pin::new_unchecked(_1),
+                    _2,
+                    _3,
+                )
+            }
+        }
+        #[allow(dead_code)]
+        #[inline]
+        fn project_replace(
+            self: _pin_project::__private::Pin<&mut Self>,
+            __replacement: Self,
+        ) -> __TupleStructProjectionOwned<T, U> {
+            unsafe {
+                let __self_ptr: *mut Self = self.get_unchecked_mut();
+                let __guard = _pin_project::__private::UnsafeOverwriteGuard::new(
+                    __self_ptr,
+                    __replacement,
+                );
+                let Self(_0, _1, _2, _3) = &mut *__self_ptr;
+                let __result = __TupleStructProjectionOwned(
+                    _pin_project::__private::PhantomData,
+                    _pin_project::__private::PhantomData,
+                    _pin_project::__private::ptr::read(_2),
+                    _pin_project::__private::ptr::read(_3),
+                );
+                {
+                    let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
+                        _1,
+                    );
+                    let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
+                        _0,
+                    );
+                }
+                __result
+            }
+        }
+    }
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &TupleStruct<T, U>) {
+        let _ = &this.0;
+        let _ = &this.1;
+        let _ = &this.2;
+        let _ = &this.3;
+    }
+    #[allow(missing_debug_implementations)]
+    struct __TupleStruct<'pin, T, U> {
+        __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+            'pin,
+            (
+                _pin_project::__private::PhantomData<T>,
+                _pin_project::__private::PhantomData<U>,
+            ),
+        >,
+        __field0: T,
+        __field1: T,
+    }
+    impl<'pin, T, U> _pin_project::__private::Unpin for TupleStruct<T, U>
+    where
+        __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    #[doc(hidden)]
+    unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for TupleStruct<T, U>
+    where
+        __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    trait TupleStructMustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: _pin_project::__private::Drop> TupleStructMustNotImplDrop for T {}
+    impl<T, U> TupleStructMustNotImplDrop for TupleStruct<T, U> {}
+    #[doc(hidden)]
+    impl<T, U> _pin_project::__private::PinnedDrop for TupleStruct<T, U> {
+        unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+    }
+};
+fn main() {}
diff --git a/crates/pin-project/tests/expand/multifields/tuple_struct.rs b/crates/pin-project/tests/expand/multifields/tuple_struct.rs
new file mode 100644
index 0000000..bc92eee
--- /dev/null
+++ b/crates/pin-project/tests/expand/multifields/tuple_struct.rs
@@ -0,0 +1,6 @@
+use pin_project::pin_project;
+
+#[pin_project(project_replace)]
+struct TupleStruct<T, U>(#[pin] T, #[pin] T, U, U);
+
+fn main() {}
diff --git a/crates/pin-project/tests/expand/naming/enum-all.expanded.rs b/crates/pin-project/tests/expand/naming/enum-all.expanded.rs
new file mode 100644
index 0000000..8f7c8af
--- /dev/null
+++ b/crates/pin-project/tests/expand/naming/enum-all.expanded.rs
@@ -0,0 +1,207 @@
+use pin_project::pin_project;
+#[pin(__private(project = Proj, project_ref = ProjRef, project_replace = ProjOwn))]
+enum Enum<T, U> {
+    Struct { #[pin] pinned: T, unpinned: U },
+    Tuple(#[pin] T, U),
+    Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::mut_mut)]
+enum Proj<'pin, T, U>
+where
+    Enum<T, U>: 'pin,
+{
+    Struct {
+        pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
+        unpinned: &'pin mut (U),
+    },
+    Tuple(::pin_project::__private::Pin<&'pin mut (T)>, &'pin mut (U)),
+    Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::ref_option_ref)]
+enum ProjRef<'pin, T, U>
+where
+    Enum<T, U>: 'pin,
+{
+    Struct { pinned: ::pin_project::__private::Pin<&'pin (T)>, unpinned: &'pin (U) },
+    Tuple(::pin_project::__private::Pin<&'pin (T)>, &'pin (U)),
+    Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(variant_size_differences)]
+#[allow(clippy::large_enum_variant)]
+enum ProjOwn<T, U> {
+    Struct { pinned: ::pin_project::__private::PhantomData<T>, unpinned: U },
+    Tuple(::pin_project::__private::PhantomData<T>, U),
+    Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(unused_extern_crates)]
+    extern crate pin_project as _pin_project;
+    impl<T, U> Enum<T, U> {
+        #[allow(dead_code)]
+        #[inline]
+        fn project<'pin>(
+            self: _pin_project::__private::Pin<&'pin mut Self>,
+        ) -> Proj<'pin, T, U> {
+            unsafe {
+                match self.get_unchecked_mut() {
+                    Self::Struct { pinned, unpinned } => {
+                        Proj::Struct {
+                            pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+                            unpinned,
+                        }
+                    }
+                    Self::Tuple(_0, _1) => {
+                        Proj::Tuple(_pin_project::__private::Pin::new_unchecked(_0), _1)
+                    }
+                    Self::Unit => Proj::Unit,
+                }
+            }
+        }
+        #[allow(dead_code)]
+        #[allow(clippy::missing_const_for_fn)]
+        #[inline]
+        fn project_ref<'pin>(
+            self: _pin_project::__private::Pin<&'pin Self>,
+        ) -> ProjRef<'pin, T, U> {
+            unsafe {
+                match self.get_ref() {
+                    Self::Struct { pinned, unpinned } => {
+                        ProjRef::Struct {
+                            pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+                            unpinned,
+                        }
+                    }
+                    Self::Tuple(_0, _1) => {
+                        ProjRef::Tuple(
+                            _pin_project::__private::Pin::new_unchecked(_0),
+                            _1,
+                        )
+                    }
+                    Self::Unit => ProjRef::Unit,
+                }
+            }
+        }
+        #[allow(dead_code)]
+        #[inline]
+        fn project_replace(
+            self: _pin_project::__private::Pin<&mut Self>,
+            __replacement: Self,
+        ) -> ProjOwn<T, U> {
+            unsafe {
+                let __self_ptr: *mut Self = self.get_unchecked_mut();
+                let __guard = _pin_project::__private::UnsafeOverwriteGuard::new(
+                    __self_ptr,
+                    __replacement,
+                );
+                match &mut *__self_ptr {
+                    Self::Struct { pinned, unpinned } => {
+                        let __result = ProjOwn::Struct {
+                            pinned: _pin_project::__private::PhantomData,
+                            unpinned: _pin_project::__private::ptr::read(unpinned),
+                        };
+                        {
+                            let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
+                                pinned,
+                            );
+                        }
+                        __result
+                    }
+                    Self::Tuple(_0, _1) => {
+                        let __result = ProjOwn::Tuple(
+                            _pin_project::__private::PhantomData,
+                            _pin_project::__private::ptr::read(_1),
+                        );
+                        {
+                            let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
+                                _0,
+                            );
+                        }
+                        __result
+                    }
+                    Self::Unit => {
+                        let __result = ProjOwn::Unit;
+                        {}
+                        __result
+                    }
+                }
+            }
+        }
+    }
+    #[allow(missing_debug_implementations)]
+    struct __Enum<'pin, T, U> {
+        __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+            'pin,
+            (
+                _pin_project::__private::PhantomData<T>,
+                _pin_project::__private::PhantomData<U>,
+            ),
+        >,
+        __field0: T,
+        __field1: T,
+    }
+    impl<'pin, T, U> _pin_project::__private::Unpin for Enum<T, U>
+    where
+        __Enum<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    #[doc(hidden)]
+    unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Enum<T, U>
+    where
+        __Enum<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    trait EnumMustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: _pin_project::__private::Drop> EnumMustNotImplDrop for T {}
+    impl<T, U> EnumMustNotImplDrop for Enum<T, U> {}
+    #[doc(hidden)]
+    impl<T, U> _pin_project::__private::PinnedDrop for Enum<T, U> {
+        unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+    }
+};
+fn main() {}
diff --git a/crates/pin-project/tests/expand/naming/enum-all.rs b/crates/pin-project/tests/expand/naming/enum-all.rs
new file mode 100644
index 0000000..dd513e6
--- /dev/null
+++ b/crates/pin-project/tests/expand/naming/enum-all.rs
@@ -0,0 +1,14 @@
+use pin_project::pin_project;
+
+#[pin_project(project = Proj, project_ref = ProjRef, project_replace = ProjOwn)]
+enum Enum<T, U> {
+    Struct {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    },
+    Tuple(#[pin] T, U),
+    Unit,
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/expand/naming/enum-mut.expanded.rs b/crates/pin-project/tests/expand/naming/enum-mut.expanded.rs
new file mode 100644
index 0000000..d489e82
--- /dev/null
+++ b/crates/pin-project/tests/expand/naming/enum-mut.expanded.rs
@@ -0,0 +1,100 @@
+use pin_project::pin_project;
+#[pin(__private(project = Proj))]
+enum Enum<T, U> {
+    Struct { #[pin] pinned: T, unpinned: U },
+    Tuple(#[pin] T, U),
+    Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::mut_mut)]
+enum Proj<'pin, T, U>
+where
+    Enum<T, U>: 'pin,
+{
+    Struct {
+        pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
+        unpinned: &'pin mut (U),
+    },
+    Tuple(::pin_project::__private::Pin<&'pin mut (T)>, &'pin mut (U)),
+    Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(unused_extern_crates)]
+    extern crate pin_project as _pin_project;
+    impl<T, U> Enum<T, U> {
+        #[allow(dead_code)]
+        #[inline]
+        fn project<'pin>(
+            self: _pin_project::__private::Pin<&'pin mut Self>,
+        ) -> Proj<'pin, T, U> {
+            unsafe {
+                match self.get_unchecked_mut() {
+                    Self::Struct { pinned, unpinned } => {
+                        Proj::Struct {
+                            pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+                            unpinned,
+                        }
+                    }
+                    Self::Tuple(_0, _1) => {
+                        Proj::Tuple(_pin_project::__private::Pin::new_unchecked(_0), _1)
+                    }
+                    Self::Unit => Proj::Unit,
+                }
+            }
+        }
+    }
+    #[allow(missing_debug_implementations)]
+    struct __Enum<'pin, T, U> {
+        __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+            'pin,
+            (
+                _pin_project::__private::PhantomData<T>,
+                _pin_project::__private::PhantomData<U>,
+            ),
+        >,
+        __field0: T,
+        __field1: T,
+    }
+    impl<'pin, T, U> _pin_project::__private::Unpin for Enum<T, U>
+    where
+        __Enum<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    #[doc(hidden)]
+    unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Enum<T, U>
+    where
+        __Enum<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    trait EnumMustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: _pin_project::__private::Drop> EnumMustNotImplDrop for T {}
+    impl<T, U> EnumMustNotImplDrop for Enum<T, U> {}
+    #[doc(hidden)]
+    impl<T, U> _pin_project::__private::PinnedDrop for Enum<T, U> {
+        unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+    }
+};
+fn main() {}
diff --git a/crates/pin-project/tests/expand/naming/enum-mut.rs b/crates/pin-project/tests/expand/naming/enum-mut.rs
new file mode 100644
index 0000000..818276f
--- /dev/null
+++ b/crates/pin-project/tests/expand/naming/enum-mut.rs
@@ -0,0 +1,14 @@
+use pin_project::pin_project;
+
+#[pin_project(project = Proj)]
+enum Enum<T, U> {
+    Struct {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    },
+    Tuple(#[pin] T, U),
+    Unit,
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/expand/naming/enum-none.expanded.rs b/crates/pin-project/tests/expand/naming/enum-none.expanded.rs
new file mode 100644
index 0000000..46477d1
--- /dev/null
+++ b/crates/pin-project/tests/expand/naming/enum-none.expanded.rs
@@ -0,0 +1,56 @@
+use pin_project::pin_project;
+#[pin(__private())]
+enum Enum<T, U> {
+    Struct { #[pin] pinned: T, unpinned: U },
+    Tuple(#[pin] T, U),
+    Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(unused_extern_crates)]
+    extern crate pin_project as _pin_project;
+    impl<T, U> Enum<T, U> {}
+    #[allow(missing_debug_implementations)]
+    struct __Enum<'pin, T, U> {
+        __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+            'pin,
+            (
+                _pin_project::__private::PhantomData<T>,
+                _pin_project::__private::PhantomData<U>,
+            ),
+        >,
+        __field0: T,
+        __field1: T,
+    }
+    impl<'pin, T, U> _pin_project::__private::Unpin for Enum<T, U>
+    where
+        __Enum<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    #[doc(hidden)]
+    unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Enum<T, U>
+    where
+        __Enum<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    trait EnumMustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: _pin_project::__private::Drop> EnumMustNotImplDrop for T {}
+    impl<T, U> EnumMustNotImplDrop for Enum<T, U> {}
+    #[doc(hidden)]
+    impl<T, U> _pin_project::__private::PinnedDrop for Enum<T, U> {
+        unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+    }
+};
+fn main() {}
diff --git a/crates/pin-project/tests/expand/naming/enum-none.rs b/crates/pin-project/tests/expand/naming/enum-none.rs
new file mode 100644
index 0000000..a87438d
--- /dev/null
+++ b/crates/pin-project/tests/expand/naming/enum-none.rs
@@ -0,0 +1,14 @@
+use pin_project::pin_project;
+
+#[pin_project]
+enum Enum<T, U> {
+    Struct {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    },
+    Tuple(#[pin] T, U),
+    Unit,
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/expand/naming/enum-own.expanded.rs b/crates/pin-project/tests/expand/naming/enum-own.expanded.rs
new file mode 100644
index 0000000..5fc0430
--- /dev/null
+++ b/crates/pin-project/tests/expand/naming/enum-own.expanded.rs
@@ -0,0 +1,120 @@
+use pin_project::pin_project;
+#[pin(__private(project_replace = ProjOwn))]
+enum Enum<T, U> {
+    Struct { #[pin] pinned: T, unpinned: U },
+    Tuple(#[pin] T, U),
+    Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(variant_size_differences)]
+#[allow(clippy::large_enum_variant)]
+enum ProjOwn<T, U> {
+    Struct { pinned: ::pin_project::__private::PhantomData<T>, unpinned: U },
+    Tuple(::pin_project::__private::PhantomData<T>, U),
+    Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(unused_extern_crates)]
+    extern crate pin_project as _pin_project;
+    impl<T, U> Enum<T, U> {
+        #[allow(dead_code)]
+        #[inline]
+        fn project_replace(
+            self: _pin_project::__private::Pin<&mut Self>,
+            __replacement: Self,
+        ) -> ProjOwn<T, U> {
+            unsafe {
+                let __self_ptr: *mut Self = self.get_unchecked_mut();
+                let __guard = _pin_project::__private::UnsafeOverwriteGuard::new(
+                    __self_ptr,
+                    __replacement,
+                );
+                match &mut *__self_ptr {
+                    Self::Struct { pinned, unpinned } => {
+                        let __result = ProjOwn::Struct {
+                            pinned: _pin_project::__private::PhantomData,
+                            unpinned: _pin_project::__private::ptr::read(unpinned),
+                        };
+                        {
+                            let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
+                                pinned,
+                            );
+                        }
+                        __result
+                    }
+                    Self::Tuple(_0, _1) => {
+                        let __result = ProjOwn::Tuple(
+                            _pin_project::__private::PhantomData,
+                            _pin_project::__private::ptr::read(_1),
+                        );
+                        {
+                            let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
+                                _0,
+                            );
+                        }
+                        __result
+                    }
+                    Self::Unit => {
+                        let __result = ProjOwn::Unit;
+                        {}
+                        __result
+                    }
+                }
+            }
+        }
+    }
+    #[allow(missing_debug_implementations)]
+    struct __Enum<'pin, T, U> {
+        __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+            'pin,
+            (
+                _pin_project::__private::PhantomData<T>,
+                _pin_project::__private::PhantomData<U>,
+            ),
+        >,
+        __field0: T,
+        __field1: T,
+    }
+    impl<'pin, T, U> _pin_project::__private::Unpin for Enum<T, U>
+    where
+        __Enum<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    #[doc(hidden)]
+    unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Enum<T, U>
+    where
+        __Enum<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    trait EnumMustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: _pin_project::__private::Drop> EnumMustNotImplDrop for T {}
+    impl<T, U> EnumMustNotImplDrop for Enum<T, U> {}
+    #[doc(hidden)]
+    impl<T, U> _pin_project::__private::PinnedDrop for Enum<T, U> {
+        unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+    }
+};
+fn main() {}
diff --git a/crates/pin-project/tests/expand/naming/enum-own.rs b/crates/pin-project/tests/expand/naming/enum-own.rs
new file mode 100644
index 0000000..cf88697
--- /dev/null
+++ b/crates/pin-project/tests/expand/naming/enum-own.rs
@@ -0,0 +1,14 @@
+use pin_project::pin_project;
+
+#[pin_project(project_replace = ProjOwn)]
+enum Enum<T, U> {
+    Struct {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    },
+    Tuple(#[pin] T, U),
+    Unit,
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/expand/naming/enum-ref.expanded.rs b/crates/pin-project/tests/expand/naming/enum-ref.expanded.rs
new file mode 100644
index 0000000..7a141c9
--- /dev/null
+++ b/crates/pin-project/tests/expand/naming/enum-ref.expanded.rs
@@ -0,0 +1,101 @@
+use pin_project::pin_project;
+#[pin(__private(project_ref = ProjRef))]
+enum Enum<T, U> {
+    Struct { #[pin] pinned: T, unpinned: U },
+    Tuple(#[pin] T, U),
+    Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::ref_option_ref)]
+enum ProjRef<'pin, T, U>
+where
+    Enum<T, U>: 'pin,
+{
+    Struct { pinned: ::pin_project::__private::Pin<&'pin (T)>, unpinned: &'pin (U) },
+    Tuple(::pin_project::__private::Pin<&'pin (T)>, &'pin (U)),
+    Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(unused_extern_crates)]
+    extern crate pin_project as _pin_project;
+    impl<T, U> Enum<T, U> {
+        #[allow(dead_code)]
+        #[allow(clippy::missing_const_for_fn)]
+        #[inline]
+        fn project_ref<'pin>(
+            self: _pin_project::__private::Pin<&'pin Self>,
+        ) -> ProjRef<'pin, T, U> {
+            unsafe {
+                match self.get_ref() {
+                    Self::Struct { pinned, unpinned } => {
+                        ProjRef::Struct {
+                            pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+                            unpinned,
+                        }
+                    }
+                    Self::Tuple(_0, _1) => {
+                        ProjRef::Tuple(
+                            _pin_project::__private::Pin::new_unchecked(_0),
+                            _1,
+                        )
+                    }
+                    Self::Unit => ProjRef::Unit,
+                }
+            }
+        }
+    }
+    #[allow(missing_debug_implementations)]
+    struct __Enum<'pin, T, U> {
+        __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+            'pin,
+            (
+                _pin_project::__private::PhantomData<T>,
+                _pin_project::__private::PhantomData<U>,
+            ),
+        >,
+        __field0: T,
+        __field1: T,
+    }
+    impl<'pin, T, U> _pin_project::__private::Unpin for Enum<T, U>
+    where
+        __Enum<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    #[doc(hidden)]
+    unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Enum<T, U>
+    where
+        __Enum<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    trait EnumMustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: _pin_project::__private::Drop> EnumMustNotImplDrop for T {}
+    impl<T, U> EnumMustNotImplDrop for Enum<T, U> {}
+    #[doc(hidden)]
+    impl<T, U> _pin_project::__private::PinnedDrop for Enum<T, U> {
+        unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+    }
+};
+fn main() {}
diff --git a/crates/pin-project/tests/expand/naming/enum-ref.rs b/crates/pin-project/tests/expand/naming/enum-ref.rs
new file mode 100644
index 0000000..b1ff805
--- /dev/null
+++ b/crates/pin-project/tests/expand/naming/enum-ref.rs
@@ -0,0 +1,14 @@
+use pin_project::pin_project;
+
+#[pin_project(project_ref = ProjRef)]
+enum Enum<T, U> {
+    Struct {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    },
+    Tuple(#[pin] T, U),
+    Unit,
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/expand/naming/struct-all.expanded.rs b/crates/pin-project/tests/expand/naming/struct-all.expanded.rs
new file mode 100644
index 0000000..36c1230
--- /dev/null
+++ b/crates/pin-project/tests/expand/naming/struct-all.expanded.rs
@@ -0,0 +1,166 @@
+use pin_project::pin_project;
+#[pin(__private(project = Proj, project_ref = ProjRef, project_replace = ProjOwn))]
+struct Struct<T, U> {
+    #[pin]
+    pinned: T,
+    unpinned: U,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::mut_mut)]
+struct Proj<'pin, T, U>
+where
+    Struct<T, U>: 'pin,
+{
+    pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
+    unpinned: &'pin mut (U),
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::ref_option_ref)]
+struct ProjRef<'pin, T, U>
+where
+    Struct<T, U>: 'pin,
+{
+    pinned: ::pin_project::__private::Pin<&'pin (T)>,
+    unpinned: &'pin (U),
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+struct ProjOwn<T, U> {
+    pinned: ::pin_project::__private::PhantomData<T>,
+    unpinned: U,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(unused_extern_crates)]
+    extern crate pin_project as _pin_project;
+    impl<T, U> Struct<T, U> {
+        #[allow(dead_code)]
+        #[inline]
+        fn project<'pin>(
+            self: _pin_project::__private::Pin<&'pin mut Self>,
+        ) -> Proj<'pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_unchecked_mut();
+                Proj {
+                    pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+                    unpinned,
+                }
+            }
+        }
+        #[allow(dead_code)]
+        #[allow(clippy::missing_const_for_fn)]
+        #[inline]
+        fn project_ref<'pin>(
+            self: _pin_project::__private::Pin<&'pin Self>,
+        ) -> ProjRef<'pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_ref();
+                ProjRef {
+                    pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+                    unpinned,
+                }
+            }
+        }
+        #[allow(dead_code)]
+        #[inline]
+        fn project_replace(
+            self: _pin_project::__private::Pin<&mut Self>,
+            __replacement: Self,
+        ) -> ProjOwn<T, U> {
+            unsafe {
+                let __self_ptr: *mut Self = self.get_unchecked_mut();
+                let __guard = _pin_project::__private::UnsafeOverwriteGuard::new(
+                    __self_ptr,
+                    __replacement,
+                );
+                let Self { pinned, unpinned } = &mut *__self_ptr;
+                let __result = ProjOwn {
+                    pinned: _pin_project::__private::PhantomData,
+                    unpinned: _pin_project::__private::ptr::read(unpinned),
+                };
+                {
+                    let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
+                        pinned,
+                    );
+                }
+                __result
+            }
+        }
+    }
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+        let _ = &this.pinned;
+        let _ = &this.unpinned;
+    }
+    #[allow(missing_debug_implementations)]
+    struct __Struct<'pin, T, U> {
+        __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+            'pin,
+            (
+                _pin_project::__private::PhantomData<T>,
+                _pin_project::__private::PhantomData<U>,
+            ),
+        >,
+        __field0: T,
+    }
+    impl<'pin, T, U> _pin_project::__private::Unpin for Struct<T, U>
+    where
+        __Struct<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    #[doc(hidden)]
+    unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Struct<T, U>
+    where
+        __Struct<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    trait StructMustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: _pin_project::__private::Drop> StructMustNotImplDrop for T {}
+    impl<T, U> StructMustNotImplDrop for Struct<T, U> {}
+    #[doc(hidden)]
+    impl<T, U> _pin_project::__private::PinnedDrop for Struct<T, U> {
+        unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+    }
+};
+fn main() {}
diff --git a/crates/pin-project/tests/expand/naming/struct-all.rs b/crates/pin-project/tests/expand/naming/struct-all.rs
new file mode 100644
index 0000000..c229ba4
--- /dev/null
+++ b/crates/pin-project/tests/expand/naming/struct-all.rs
@@ -0,0 +1,10 @@
+use pin_project::pin_project;
+
+#[pin_project(project = Proj, project_ref = ProjRef, project_replace = ProjOwn)]
+struct Struct<T, U> {
+    #[pin]
+    pinned: T,
+    unpinned: U,
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/expand/naming/struct-mut.expanded.rs b/crates/pin-project/tests/expand/naming/struct-mut.expanded.rs
new file mode 100644
index 0000000..7164072
--- /dev/null
+++ b/crates/pin-project/tests/expand/naming/struct-mut.expanded.rs
@@ -0,0 +1,116 @@
+use pin_project::pin_project;
+#[pin(__private(project = Proj))]
+struct Struct<T, U> {
+    #[pin]
+    pinned: T,
+    unpinned: U,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::mut_mut)]
+struct Proj<'pin, T, U>
+where
+    Struct<T, U>: 'pin,
+{
+    pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
+    unpinned: &'pin mut (U),
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(unused_extern_crates)]
+    extern crate pin_project as _pin_project;
+    #[allow(dead_code)]
+    #[allow(clippy::ref_option_ref)]
+    struct __StructProjectionRef<'pin, T, U>
+    where
+        Struct<T, U>: 'pin,
+    {
+        pinned: ::pin_project::__private::Pin<&'pin (T)>,
+        unpinned: &'pin (U),
+    }
+    impl<T, U> Struct<T, U> {
+        #[allow(dead_code)]
+        #[inline]
+        fn project<'pin>(
+            self: _pin_project::__private::Pin<&'pin mut Self>,
+        ) -> Proj<'pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_unchecked_mut();
+                Proj {
+                    pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+                    unpinned,
+                }
+            }
+        }
+        #[allow(dead_code)]
+        #[allow(clippy::missing_const_for_fn)]
+        #[inline]
+        fn project_ref<'pin>(
+            self: _pin_project::__private::Pin<&'pin Self>,
+        ) -> __StructProjectionRef<'pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_ref();
+                __StructProjectionRef {
+                    pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+                    unpinned,
+                }
+            }
+        }
+    }
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+        let _ = &this.pinned;
+        let _ = &this.unpinned;
+    }
+    #[allow(missing_debug_implementations)]
+    struct __Struct<'pin, T, U> {
+        __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+            'pin,
+            (
+                _pin_project::__private::PhantomData<T>,
+                _pin_project::__private::PhantomData<U>,
+            ),
+        >,
+        __field0: T,
+    }
+    impl<'pin, T, U> _pin_project::__private::Unpin for Struct<T, U>
+    where
+        __Struct<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    #[doc(hidden)]
+    unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Struct<T, U>
+    where
+        __Struct<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    trait StructMustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: _pin_project::__private::Drop> StructMustNotImplDrop for T {}
+    impl<T, U> StructMustNotImplDrop for Struct<T, U> {}
+    #[doc(hidden)]
+    impl<T, U> _pin_project::__private::PinnedDrop for Struct<T, U> {
+        unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+    }
+};
+fn main() {}
diff --git a/crates/pin-project/tests/expand/naming/struct-mut.rs b/crates/pin-project/tests/expand/naming/struct-mut.rs
new file mode 100644
index 0000000..2f554d3
--- /dev/null
+++ b/crates/pin-project/tests/expand/naming/struct-mut.rs
@@ -0,0 +1,10 @@
+use pin_project::pin_project;
+
+#[pin_project(project = Proj)]
+struct Struct<T, U> {
+    #[pin]
+    pinned: T,
+    unpinned: U,
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/expand/naming/struct-none.expanded.rs b/crates/pin-project/tests/expand/naming/struct-none.expanded.rs
new file mode 100644
index 0000000..db3c948
--- /dev/null
+++ b/crates/pin-project/tests/expand/naming/struct-none.expanded.rs
@@ -0,0 +1,106 @@
+use pin_project::pin_project;
+#[pin(__private())]
+struct Struct<T, U> {
+    #[pin]
+    pinned: T,
+    unpinned: U,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(unused_extern_crates)]
+    extern crate pin_project as _pin_project;
+    #[allow(dead_code)]
+    #[allow(clippy::mut_mut)]
+    struct __StructProjection<'pin, T, U>
+    where
+        Struct<T, U>: 'pin,
+    {
+        pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
+        unpinned: &'pin mut (U),
+    }
+    #[allow(dead_code)]
+    #[allow(clippy::ref_option_ref)]
+    struct __StructProjectionRef<'pin, T, U>
+    where
+        Struct<T, U>: 'pin,
+    {
+        pinned: ::pin_project::__private::Pin<&'pin (T)>,
+        unpinned: &'pin (U),
+    }
+    impl<T, U> Struct<T, U> {
+        #[allow(dead_code)]
+        #[inline]
+        fn project<'pin>(
+            self: _pin_project::__private::Pin<&'pin mut Self>,
+        ) -> __StructProjection<'pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_unchecked_mut();
+                __StructProjection {
+                    pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+                    unpinned,
+                }
+            }
+        }
+        #[allow(dead_code)]
+        #[allow(clippy::missing_const_for_fn)]
+        #[inline]
+        fn project_ref<'pin>(
+            self: _pin_project::__private::Pin<&'pin Self>,
+        ) -> __StructProjectionRef<'pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_ref();
+                __StructProjectionRef {
+                    pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+                    unpinned,
+                }
+            }
+        }
+    }
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+        let _ = &this.pinned;
+        let _ = &this.unpinned;
+    }
+    #[allow(missing_debug_implementations)]
+    struct __Struct<'pin, T, U> {
+        __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+            'pin,
+            (
+                _pin_project::__private::PhantomData<T>,
+                _pin_project::__private::PhantomData<U>,
+            ),
+        >,
+        __field0: T,
+    }
+    impl<'pin, T, U> _pin_project::__private::Unpin for Struct<T, U>
+    where
+        __Struct<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    #[doc(hidden)]
+    unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Struct<T, U>
+    where
+        __Struct<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    trait StructMustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: _pin_project::__private::Drop> StructMustNotImplDrop for T {}
+    impl<T, U> StructMustNotImplDrop for Struct<T, U> {}
+    #[doc(hidden)]
+    impl<T, U> _pin_project::__private::PinnedDrop for Struct<T, U> {
+        unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+    }
+};
+fn main() {}
diff --git a/crates/pin-project/tests/expand/naming/struct-none.rs b/crates/pin-project/tests/expand/naming/struct-none.rs
new file mode 100644
index 0000000..474f0a1
--- /dev/null
+++ b/crates/pin-project/tests/expand/naming/struct-none.rs
@@ -0,0 +1,10 @@
+use pin_project::pin_project;
+
+#[pin_project]
+struct Struct<T, U> {
+    #[pin]
+    pinned: T,
+    unpinned: U,
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/expand/naming/struct-own.expanded.rs b/crates/pin-project/tests/expand/naming/struct-own.expanded.rs
new file mode 100644
index 0000000..b2f6079
--- /dev/null
+++ b/crates/pin-project/tests/expand/naming/struct-own.expanded.rs
@@ -0,0 +1,146 @@
+use pin_project::pin_project;
+#[pin(__private(project_replace = ProjOwn))]
+struct Struct<T, U> {
+    #[pin]
+    pinned: T,
+    unpinned: U,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+struct ProjOwn<T, U> {
+    pinned: ::pin_project::__private::PhantomData<T>,
+    unpinned: U,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(unused_extern_crates)]
+    extern crate pin_project as _pin_project;
+    #[allow(dead_code)]
+    #[allow(clippy::mut_mut)]
+    struct __StructProjection<'pin, T, U>
+    where
+        Struct<T, U>: 'pin,
+    {
+        pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
+        unpinned: &'pin mut (U),
+    }
+    #[allow(dead_code)]
+    #[allow(clippy::ref_option_ref)]
+    struct __StructProjectionRef<'pin, T, U>
+    where
+        Struct<T, U>: 'pin,
+    {
+        pinned: ::pin_project::__private::Pin<&'pin (T)>,
+        unpinned: &'pin (U),
+    }
+    impl<T, U> Struct<T, U> {
+        #[allow(dead_code)]
+        #[inline]
+        fn project<'pin>(
+            self: _pin_project::__private::Pin<&'pin mut Self>,
+        ) -> __StructProjection<'pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_unchecked_mut();
+                __StructProjection {
+                    pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+                    unpinned,
+                }
+            }
+        }
+        #[allow(dead_code)]
+        #[allow(clippy::missing_const_for_fn)]
+        #[inline]
+        fn project_ref<'pin>(
+            self: _pin_project::__private::Pin<&'pin Self>,
+        ) -> __StructProjectionRef<'pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_ref();
+                __StructProjectionRef {
+                    pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+                    unpinned,
+                }
+            }
+        }
+        #[allow(dead_code)]
+        #[inline]
+        fn project_replace(
+            self: _pin_project::__private::Pin<&mut Self>,
+            __replacement: Self,
+        ) -> ProjOwn<T, U> {
+            unsafe {
+                let __self_ptr: *mut Self = self.get_unchecked_mut();
+                let __guard = _pin_project::__private::UnsafeOverwriteGuard::new(
+                    __self_ptr,
+                    __replacement,
+                );
+                let Self { pinned, unpinned } = &mut *__self_ptr;
+                let __result = ProjOwn {
+                    pinned: _pin_project::__private::PhantomData,
+                    unpinned: _pin_project::__private::ptr::read(unpinned),
+                };
+                {
+                    let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
+                        pinned,
+                    );
+                }
+                __result
+            }
+        }
+    }
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+        let _ = &this.pinned;
+        let _ = &this.unpinned;
+    }
+    #[allow(missing_debug_implementations)]
+    struct __Struct<'pin, T, U> {
+        __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+            'pin,
+            (
+                _pin_project::__private::PhantomData<T>,
+                _pin_project::__private::PhantomData<U>,
+            ),
+        >,
+        __field0: T,
+    }
+    impl<'pin, T, U> _pin_project::__private::Unpin for Struct<T, U>
+    where
+        __Struct<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    #[doc(hidden)]
+    unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Struct<T, U>
+    where
+        __Struct<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    trait StructMustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: _pin_project::__private::Drop> StructMustNotImplDrop for T {}
+    impl<T, U> StructMustNotImplDrop for Struct<T, U> {}
+    #[doc(hidden)]
+    impl<T, U> _pin_project::__private::PinnedDrop for Struct<T, U> {
+        unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+    }
+};
+fn main() {}
diff --git a/crates/pin-project/tests/expand/naming/struct-own.rs b/crates/pin-project/tests/expand/naming/struct-own.rs
new file mode 100644
index 0000000..4924362
--- /dev/null
+++ b/crates/pin-project/tests/expand/naming/struct-own.rs
@@ -0,0 +1,10 @@
+use pin_project::pin_project;
+
+#[pin_project(project_replace = ProjOwn)]
+struct Struct<T, U> {
+    #[pin]
+    pinned: T,
+    unpinned: U,
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/expand/naming/struct-ref.expanded.rs b/crates/pin-project/tests/expand/naming/struct-ref.expanded.rs
new file mode 100644
index 0000000..dea8383
--- /dev/null
+++ b/crates/pin-project/tests/expand/naming/struct-ref.expanded.rs
@@ -0,0 +1,116 @@
+use pin_project::pin_project;
+#[pin(__private(project_ref = ProjRef))]
+struct Struct<T, U> {
+    #[pin]
+    pinned: T,
+    unpinned: U,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::ref_option_ref)]
+struct ProjRef<'pin, T, U>
+where
+    Struct<T, U>: 'pin,
+{
+    pinned: ::pin_project::__private::Pin<&'pin (T)>,
+    unpinned: &'pin (U),
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(unused_extern_crates)]
+    extern crate pin_project as _pin_project;
+    #[allow(dead_code)]
+    #[allow(clippy::mut_mut)]
+    struct __StructProjection<'pin, T, U>
+    where
+        Struct<T, U>: 'pin,
+    {
+        pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
+        unpinned: &'pin mut (U),
+    }
+    impl<T, U> Struct<T, U> {
+        #[allow(dead_code)]
+        #[inline]
+        fn project<'pin>(
+            self: _pin_project::__private::Pin<&'pin mut Self>,
+        ) -> __StructProjection<'pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_unchecked_mut();
+                __StructProjection {
+                    pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+                    unpinned,
+                }
+            }
+        }
+        #[allow(dead_code)]
+        #[allow(clippy::missing_const_for_fn)]
+        #[inline]
+        fn project_ref<'pin>(
+            self: _pin_project::__private::Pin<&'pin Self>,
+        ) -> ProjRef<'pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_ref();
+                ProjRef {
+                    pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+                    unpinned,
+                }
+            }
+        }
+    }
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+        let _ = &this.pinned;
+        let _ = &this.unpinned;
+    }
+    #[allow(missing_debug_implementations)]
+    struct __Struct<'pin, T, U> {
+        __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+            'pin,
+            (
+                _pin_project::__private::PhantomData<T>,
+                _pin_project::__private::PhantomData<U>,
+            ),
+        >,
+        __field0: T,
+    }
+    impl<'pin, T, U> _pin_project::__private::Unpin for Struct<T, U>
+    where
+        __Struct<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    #[doc(hidden)]
+    unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Struct<T, U>
+    where
+        __Struct<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    trait StructMustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: _pin_project::__private::Drop> StructMustNotImplDrop for T {}
+    impl<T, U> StructMustNotImplDrop for Struct<T, U> {}
+    #[doc(hidden)]
+    impl<T, U> _pin_project::__private::PinnedDrop for Struct<T, U> {
+        unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+    }
+};
+fn main() {}
diff --git a/crates/pin-project/tests/expand/naming/struct-ref.rs b/crates/pin-project/tests/expand/naming/struct-ref.rs
new file mode 100644
index 0000000..4e29a16
--- /dev/null
+++ b/crates/pin-project/tests/expand/naming/struct-ref.rs
@@ -0,0 +1,10 @@
+use pin_project::pin_project;
+
+#[pin_project(project_ref = ProjRef)]
+struct Struct<T, U> {
+    #[pin]
+    pinned: T,
+    unpinned: U,
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/expand/naming/tuple_struct-all.expanded.rs b/crates/pin-project/tests/expand/naming/tuple_struct-all.expanded.rs
new file mode 100644
index 0000000..441da9c
--- /dev/null
+++ b/crates/pin-project/tests/expand/naming/tuple_struct-all.expanded.rs
@@ -0,0 +1,151 @@
+use pin_project::pin_project;
+#[pin(__private(project = Proj, project_ref = ProjRef, project_replace = ProjOwn))]
+struct TupleStruct<T, U>(#[pin] T, U);
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::mut_mut)]
+struct Proj<'pin, T, U>(
+    ::pin_project::__private::Pin<&'pin mut (T)>,
+    &'pin mut (U),
+)
+where
+    TupleStruct<T, U>: 'pin;
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::ref_option_ref)]
+struct ProjRef<'pin, T, U>(
+    ::pin_project::__private::Pin<&'pin (T)>,
+    &'pin (U),
+)
+where
+    TupleStruct<T, U>: 'pin;
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+struct ProjOwn<T, U>(::pin_project::__private::PhantomData<T>, U);
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(unused_extern_crates)]
+    extern crate pin_project as _pin_project;
+    impl<T, U> TupleStruct<T, U> {
+        #[allow(dead_code)]
+        #[inline]
+        fn project<'pin>(
+            self: _pin_project::__private::Pin<&'pin mut Self>,
+        ) -> Proj<'pin, T, U> {
+            unsafe {
+                let Self(_0, _1) = self.get_unchecked_mut();
+                Proj(_pin_project::__private::Pin::new_unchecked(_0), _1)
+            }
+        }
+        #[allow(dead_code)]
+        #[allow(clippy::missing_const_for_fn)]
+        #[inline]
+        fn project_ref<'pin>(
+            self: _pin_project::__private::Pin<&'pin Self>,
+        ) -> ProjRef<'pin, T, U> {
+            unsafe {
+                let Self(_0, _1) = self.get_ref();
+                ProjRef(_pin_project::__private::Pin::new_unchecked(_0), _1)
+            }
+        }
+        #[allow(dead_code)]
+        #[inline]
+        fn project_replace(
+            self: _pin_project::__private::Pin<&mut Self>,
+            __replacement: Self,
+        ) -> ProjOwn<T, U> {
+            unsafe {
+                let __self_ptr: *mut Self = self.get_unchecked_mut();
+                let __guard = _pin_project::__private::UnsafeOverwriteGuard::new(
+                    __self_ptr,
+                    __replacement,
+                );
+                let Self(_0, _1) = &mut *__self_ptr;
+                let __result = ProjOwn(
+                    _pin_project::__private::PhantomData,
+                    _pin_project::__private::ptr::read(_1),
+                );
+                {
+                    let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
+                        _0,
+                    );
+                }
+                __result
+            }
+        }
+    }
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &TupleStruct<T, U>) {
+        let _ = &this.0;
+        let _ = &this.1;
+    }
+    #[allow(missing_debug_implementations)]
+    struct __TupleStruct<'pin, T, U> {
+        __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+            'pin,
+            (
+                _pin_project::__private::PhantomData<T>,
+                _pin_project::__private::PhantomData<U>,
+            ),
+        >,
+        __field0: T,
+    }
+    impl<'pin, T, U> _pin_project::__private::Unpin for TupleStruct<T, U>
+    where
+        __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    #[doc(hidden)]
+    unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for TupleStruct<T, U>
+    where
+        __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    trait TupleStructMustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: _pin_project::__private::Drop> TupleStructMustNotImplDrop for T {}
+    impl<T, U> TupleStructMustNotImplDrop for TupleStruct<T, U> {}
+    #[doc(hidden)]
+    impl<T, U> _pin_project::__private::PinnedDrop for TupleStruct<T, U> {
+        unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+    }
+};
+fn main() {}
diff --git a/crates/pin-project/tests/expand/naming/tuple_struct-all.rs b/crates/pin-project/tests/expand/naming/tuple_struct-all.rs
new file mode 100644
index 0000000..0d95cb0
--- /dev/null
+++ b/crates/pin-project/tests/expand/naming/tuple_struct-all.rs
@@ -0,0 +1,6 @@
+use pin_project::pin_project;
+
+#[pin_project(project = Proj, project_ref = ProjRef, project_replace = ProjOwn)]
+struct TupleStruct<T, U>(#[pin] T, U);
+
+fn main() {}
diff --git a/crates/pin-project/tests/expand/naming/tuple_struct-mut.expanded.rs b/crates/pin-project/tests/expand/naming/tuple_struct-mut.expanded.rs
new file mode 100644
index 0000000..615019b
--- /dev/null
+++ b/crates/pin-project/tests/expand/naming/tuple_struct-mut.expanded.rs
@@ -0,0 +1,107 @@
+use pin_project::pin_project;
+#[pin(__private(project = Proj))]
+struct TupleStruct<T, U>(#[pin] T, U);
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::mut_mut)]
+struct Proj<'pin, T, U>(
+    ::pin_project::__private::Pin<&'pin mut (T)>,
+    &'pin mut (U),
+)
+where
+    TupleStruct<T, U>: 'pin;
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(unused_extern_crates)]
+    extern crate pin_project as _pin_project;
+    #[allow(dead_code)]
+    #[allow(clippy::ref_option_ref)]
+    struct __TupleStructProjectionRef<'pin, T, U>(
+        ::pin_project::__private::Pin<&'pin (T)>,
+        &'pin (U),
+    )
+    where
+        TupleStruct<T, U>: 'pin;
+    impl<T, U> TupleStruct<T, U> {
+        #[allow(dead_code)]
+        #[inline]
+        fn project<'pin>(
+            self: _pin_project::__private::Pin<&'pin mut Self>,
+        ) -> Proj<'pin, T, U> {
+            unsafe {
+                let Self(_0, _1) = self.get_unchecked_mut();
+                Proj(_pin_project::__private::Pin::new_unchecked(_0), _1)
+            }
+        }
+        #[allow(dead_code)]
+        #[allow(clippy::missing_const_for_fn)]
+        #[inline]
+        fn project_ref<'pin>(
+            self: _pin_project::__private::Pin<&'pin Self>,
+        ) -> __TupleStructProjectionRef<'pin, T, U> {
+            unsafe {
+                let Self(_0, _1) = self.get_ref();
+                __TupleStructProjectionRef(
+                    _pin_project::__private::Pin::new_unchecked(_0),
+                    _1,
+                )
+            }
+        }
+    }
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &TupleStruct<T, U>) {
+        let _ = &this.0;
+        let _ = &this.1;
+    }
+    #[allow(missing_debug_implementations)]
+    struct __TupleStruct<'pin, T, U> {
+        __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+            'pin,
+            (
+                _pin_project::__private::PhantomData<T>,
+                _pin_project::__private::PhantomData<U>,
+            ),
+        >,
+        __field0: T,
+    }
+    impl<'pin, T, U> _pin_project::__private::Unpin for TupleStruct<T, U>
+    where
+        __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    #[doc(hidden)]
+    unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for TupleStruct<T, U>
+    where
+        __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    trait TupleStructMustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: _pin_project::__private::Drop> TupleStructMustNotImplDrop for T {}
+    impl<T, U> TupleStructMustNotImplDrop for TupleStruct<T, U> {}
+    #[doc(hidden)]
+    impl<T, U> _pin_project::__private::PinnedDrop for TupleStruct<T, U> {
+        unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+    }
+};
+fn main() {}
diff --git a/crates/pin-project/tests/expand/naming/tuple_struct-mut.rs b/crates/pin-project/tests/expand/naming/tuple_struct-mut.rs
new file mode 100644
index 0000000..e9779a6
--- /dev/null
+++ b/crates/pin-project/tests/expand/naming/tuple_struct-mut.rs
@@ -0,0 +1,6 @@
+use pin_project::pin_project;
+
+#[pin_project(project = Proj)]
+struct TupleStruct<T, U>(#[pin] T, U);
+
+fn main() {}
diff --git a/crates/pin-project/tests/expand/naming/tuple_struct-none.expanded.rs b/crates/pin-project/tests/expand/naming/tuple_struct-none.expanded.rs
new file mode 100644
index 0000000..6b962d6
--- /dev/null
+++ b/crates/pin-project/tests/expand/naming/tuple_struct-none.expanded.rs
@@ -0,0 +1,100 @@
+use pin_project::pin_project;
+#[pin(__private())]
+struct TupleStruct<T, U>(#[pin] T, U);
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(unused_extern_crates)]
+    extern crate pin_project as _pin_project;
+    #[allow(dead_code)]
+    #[allow(clippy::mut_mut)]
+    struct __TupleStructProjection<'pin, T, U>(
+        ::pin_project::__private::Pin<&'pin mut (T)>,
+        &'pin mut (U),
+    )
+    where
+        TupleStruct<T, U>: 'pin;
+    #[allow(dead_code)]
+    #[allow(clippy::ref_option_ref)]
+    struct __TupleStructProjectionRef<'pin, T, U>(
+        ::pin_project::__private::Pin<&'pin (T)>,
+        &'pin (U),
+    )
+    where
+        TupleStruct<T, U>: 'pin;
+    impl<T, U> TupleStruct<T, U> {
+        #[allow(dead_code)]
+        #[inline]
+        fn project<'pin>(
+            self: _pin_project::__private::Pin<&'pin mut Self>,
+        ) -> __TupleStructProjection<'pin, T, U> {
+            unsafe {
+                let Self(_0, _1) = self.get_unchecked_mut();
+                __TupleStructProjection(
+                    _pin_project::__private::Pin::new_unchecked(_0),
+                    _1,
+                )
+            }
+        }
+        #[allow(dead_code)]
+        #[allow(clippy::missing_const_for_fn)]
+        #[inline]
+        fn project_ref<'pin>(
+            self: _pin_project::__private::Pin<&'pin Self>,
+        ) -> __TupleStructProjectionRef<'pin, T, U> {
+            unsafe {
+                let Self(_0, _1) = self.get_ref();
+                __TupleStructProjectionRef(
+                    _pin_project::__private::Pin::new_unchecked(_0),
+                    _1,
+                )
+            }
+        }
+    }
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &TupleStruct<T, U>) {
+        let _ = &this.0;
+        let _ = &this.1;
+    }
+    #[allow(missing_debug_implementations)]
+    struct __TupleStruct<'pin, T, U> {
+        __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+            'pin,
+            (
+                _pin_project::__private::PhantomData<T>,
+                _pin_project::__private::PhantomData<U>,
+            ),
+        >,
+        __field0: T,
+    }
+    impl<'pin, T, U> _pin_project::__private::Unpin for TupleStruct<T, U>
+    where
+        __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    #[doc(hidden)]
+    unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for TupleStruct<T, U>
+    where
+        __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    trait TupleStructMustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: _pin_project::__private::Drop> TupleStructMustNotImplDrop for T {}
+    impl<T, U> TupleStructMustNotImplDrop for TupleStruct<T, U> {}
+    #[doc(hidden)]
+    impl<T, U> _pin_project::__private::PinnedDrop for TupleStruct<T, U> {
+        unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+    }
+};
+fn main() {}
diff --git a/crates/pin-project/tests/expand/naming/tuple_struct-none.rs b/crates/pin-project/tests/expand/naming/tuple_struct-none.rs
new file mode 100644
index 0000000..398b14f
--- /dev/null
+++ b/crates/pin-project/tests/expand/naming/tuple_struct-none.rs
@@ -0,0 +1,6 @@
+use pin_project::pin_project;
+
+#[pin_project]
+struct TupleStruct<T, U>(#[pin] T, U);
+
+fn main() {}
diff --git a/crates/pin-project/tests/expand/naming/tuple_struct-own.expanded.rs b/crates/pin-project/tests/expand/naming/tuple_struct-own.expanded.rs
new file mode 100644
index 0000000..c85f05d
--- /dev/null
+++ b/crates/pin-project/tests/expand/naming/tuple_struct-own.expanded.rs
@@ -0,0 +1,137 @@
+use pin_project::pin_project;
+#[pin(__private(project_replace = ProjOwn))]
+struct TupleStruct<T, U>(#[pin] T, U);
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+struct ProjOwn<T, U>(::pin_project::__private::PhantomData<T>, U);
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(unused_extern_crates)]
+    extern crate pin_project as _pin_project;
+    #[allow(dead_code)]
+    #[allow(clippy::mut_mut)]
+    struct __TupleStructProjection<'pin, T, U>(
+        ::pin_project::__private::Pin<&'pin mut (T)>,
+        &'pin mut (U),
+    )
+    where
+        TupleStruct<T, U>: 'pin;
+    #[allow(dead_code)]
+    #[allow(clippy::ref_option_ref)]
+    struct __TupleStructProjectionRef<'pin, T, U>(
+        ::pin_project::__private::Pin<&'pin (T)>,
+        &'pin (U),
+    )
+    where
+        TupleStruct<T, U>: 'pin;
+    impl<T, U> TupleStruct<T, U> {
+        #[allow(dead_code)]
+        #[inline]
+        fn project<'pin>(
+            self: _pin_project::__private::Pin<&'pin mut Self>,
+        ) -> __TupleStructProjection<'pin, T, U> {
+            unsafe {
+                let Self(_0, _1) = self.get_unchecked_mut();
+                __TupleStructProjection(
+                    _pin_project::__private::Pin::new_unchecked(_0),
+                    _1,
+                )
+            }
+        }
+        #[allow(dead_code)]
+        #[allow(clippy::missing_const_for_fn)]
+        #[inline]
+        fn project_ref<'pin>(
+            self: _pin_project::__private::Pin<&'pin Self>,
+        ) -> __TupleStructProjectionRef<'pin, T, U> {
+            unsafe {
+                let Self(_0, _1) = self.get_ref();
+                __TupleStructProjectionRef(
+                    _pin_project::__private::Pin::new_unchecked(_0),
+                    _1,
+                )
+            }
+        }
+        #[allow(dead_code)]
+        #[inline]
+        fn project_replace(
+            self: _pin_project::__private::Pin<&mut Self>,
+            __replacement: Self,
+        ) -> ProjOwn<T, U> {
+            unsafe {
+                let __self_ptr: *mut Self = self.get_unchecked_mut();
+                let __guard = _pin_project::__private::UnsafeOverwriteGuard::new(
+                    __self_ptr,
+                    __replacement,
+                );
+                let Self(_0, _1) = &mut *__self_ptr;
+                let __result = ProjOwn(
+                    _pin_project::__private::PhantomData,
+                    _pin_project::__private::ptr::read(_1),
+                );
+                {
+                    let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
+                        _0,
+                    );
+                }
+                __result
+            }
+        }
+    }
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &TupleStruct<T, U>) {
+        let _ = &this.0;
+        let _ = &this.1;
+    }
+    #[allow(missing_debug_implementations)]
+    struct __TupleStruct<'pin, T, U> {
+        __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+            'pin,
+            (
+                _pin_project::__private::PhantomData<T>,
+                _pin_project::__private::PhantomData<U>,
+            ),
+        >,
+        __field0: T,
+    }
+    impl<'pin, T, U> _pin_project::__private::Unpin for TupleStruct<T, U>
+    where
+        __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    #[doc(hidden)]
+    unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for TupleStruct<T, U>
+    where
+        __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    trait TupleStructMustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: _pin_project::__private::Drop> TupleStructMustNotImplDrop for T {}
+    impl<T, U> TupleStructMustNotImplDrop for TupleStruct<T, U> {}
+    #[doc(hidden)]
+    impl<T, U> _pin_project::__private::PinnedDrop for TupleStruct<T, U> {
+        unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+    }
+};
+fn main() {}
diff --git a/crates/pin-project/tests/expand/naming/tuple_struct-own.rs b/crates/pin-project/tests/expand/naming/tuple_struct-own.rs
new file mode 100644
index 0000000..a15ad40
--- /dev/null
+++ b/crates/pin-project/tests/expand/naming/tuple_struct-own.rs
@@ -0,0 +1,6 @@
+use pin_project::pin_project;
+
+#[pin_project(project_replace = ProjOwn)]
+struct TupleStruct<T, U>(#[pin] T, U);
+
+fn main() {}
diff --git a/crates/pin-project/tests/expand/naming/tuple_struct-ref.expanded.rs b/crates/pin-project/tests/expand/naming/tuple_struct-ref.expanded.rs
new file mode 100644
index 0000000..88c5550
--- /dev/null
+++ b/crates/pin-project/tests/expand/naming/tuple_struct-ref.expanded.rs
@@ -0,0 +1,107 @@
+use pin_project::pin_project;
+#[pin(__private(project_ref = ProjRef))]
+struct TupleStruct<T, U>(#[pin] T, U);
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::ref_option_ref)]
+struct ProjRef<'pin, T, U>(
+    ::pin_project::__private::Pin<&'pin (T)>,
+    &'pin (U),
+)
+where
+    TupleStruct<T, U>: 'pin;
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(unused_extern_crates)]
+    extern crate pin_project as _pin_project;
+    #[allow(dead_code)]
+    #[allow(clippy::mut_mut)]
+    struct __TupleStructProjection<'pin, T, U>(
+        ::pin_project::__private::Pin<&'pin mut (T)>,
+        &'pin mut (U),
+    )
+    where
+        TupleStruct<T, U>: 'pin;
+    impl<T, U> TupleStruct<T, U> {
+        #[allow(dead_code)]
+        #[inline]
+        fn project<'pin>(
+            self: _pin_project::__private::Pin<&'pin mut Self>,
+        ) -> __TupleStructProjection<'pin, T, U> {
+            unsafe {
+                let Self(_0, _1) = self.get_unchecked_mut();
+                __TupleStructProjection(
+                    _pin_project::__private::Pin::new_unchecked(_0),
+                    _1,
+                )
+            }
+        }
+        #[allow(dead_code)]
+        #[allow(clippy::missing_const_for_fn)]
+        #[inline]
+        fn project_ref<'pin>(
+            self: _pin_project::__private::Pin<&'pin Self>,
+        ) -> ProjRef<'pin, T, U> {
+            unsafe {
+                let Self(_0, _1) = self.get_ref();
+                ProjRef(_pin_project::__private::Pin::new_unchecked(_0), _1)
+            }
+        }
+    }
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &TupleStruct<T, U>) {
+        let _ = &this.0;
+        let _ = &this.1;
+    }
+    #[allow(missing_debug_implementations)]
+    struct __TupleStruct<'pin, T, U> {
+        __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+            'pin,
+            (
+                _pin_project::__private::PhantomData<T>,
+                _pin_project::__private::PhantomData<U>,
+            ),
+        >,
+        __field0: T,
+    }
+    impl<'pin, T, U> _pin_project::__private::Unpin for TupleStruct<T, U>
+    where
+        __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    #[doc(hidden)]
+    unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for TupleStruct<T, U>
+    where
+        __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    trait TupleStructMustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: _pin_project::__private::Drop> TupleStructMustNotImplDrop for T {}
+    impl<T, U> TupleStructMustNotImplDrop for TupleStruct<T, U> {}
+    #[doc(hidden)]
+    impl<T, U> _pin_project::__private::PinnedDrop for TupleStruct<T, U> {
+        unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+    }
+};
+fn main() {}
diff --git a/crates/pin-project/tests/expand/naming/tuple_struct-ref.rs b/crates/pin-project/tests/expand/naming/tuple_struct-ref.rs
new file mode 100644
index 0000000..cc61edf
--- /dev/null
+++ b/crates/pin-project/tests/expand/naming/tuple_struct-ref.rs
@@ -0,0 +1,6 @@
+use pin_project::pin_project;
+
+#[pin_project(project_ref = ProjRef)]
+struct TupleStruct<T, U>(#[pin] T, U);
+
+fn main() {}
diff --git a/crates/pin-project/tests/expand/not_unpin/enum.expanded.rs b/crates/pin-project/tests/expand/not_unpin/enum.expanded.rs
new file mode 100644
index 0000000..e60896c
--- /dev/null
+++ b/crates/pin-project/tests/expand/not_unpin/enum.expanded.rs
@@ -0,0 +1,142 @@
+use pin_project::pin_project;
+#[pin(__private(!Unpin, project = EnumProj, project_ref = EnumProjRef))]
+enum Enum<T, U> {
+    Struct { #[pin] pinned: T, unpinned: U },
+    Tuple(#[pin] T, U),
+    Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::mut_mut)]
+enum EnumProj<'pin, T, U>
+where
+    Enum<T, U>: 'pin,
+{
+    Struct {
+        pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
+        unpinned: &'pin mut (U),
+    },
+    Tuple(::pin_project::__private::Pin<&'pin mut (T)>, &'pin mut (U)),
+    Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::ref_option_ref)]
+enum EnumProjRef<'pin, T, U>
+where
+    Enum<T, U>: 'pin,
+{
+    Struct { pinned: ::pin_project::__private::Pin<&'pin (T)>, unpinned: &'pin (U) },
+    Tuple(::pin_project::__private::Pin<&'pin (T)>, &'pin (U)),
+    Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(unused_extern_crates)]
+    extern crate pin_project as _pin_project;
+    impl<T, U> Enum<T, U> {
+        #[allow(dead_code)]
+        #[inline]
+        fn project<'pin>(
+            self: _pin_project::__private::Pin<&'pin mut Self>,
+        ) -> EnumProj<'pin, T, U> {
+            unsafe {
+                match self.get_unchecked_mut() {
+                    Self::Struct { pinned, unpinned } => {
+                        EnumProj::Struct {
+                            pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+                            unpinned,
+                        }
+                    }
+                    Self::Tuple(_0, _1) => {
+                        EnumProj::Tuple(
+                            _pin_project::__private::Pin::new_unchecked(_0),
+                            _1,
+                        )
+                    }
+                    Self::Unit => EnumProj::Unit,
+                }
+            }
+        }
+        #[allow(dead_code)]
+        #[allow(clippy::missing_const_for_fn)]
+        #[inline]
+        fn project_ref<'pin>(
+            self: _pin_project::__private::Pin<&'pin Self>,
+        ) -> EnumProjRef<'pin, T, U> {
+            unsafe {
+                match self.get_ref() {
+                    Self::Struct { pinned, unpinned } => {
+                        EnumProjRef::Struct {
+                            pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+                            unpinned,
+                        }
+                    }
+                    Self::Tuple(_0, _1) => {
+                        EnumProjRef::Tuple(
+                            _pin_project::__private::Pin::new_unchecked(_0),
+                            _1,
+                        )
+                    }
+                    Self::Unit => EnumProjRef::Unit,
+                }
+            }
+        }
+    }
+    #[doc(hidden)]
+    impl<'pin, T, U> _pin_project::__private::Unpin for Enum<T, U>
+    where
+        _pin_project::__private::Wrapper<
+            'pin,
+            _pin_project::__private::PhantomPinned,
+        >: _pin_project::__private::Unpin,
+    {}
+    #[doc(hidden)]
+    unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Enum<T, U>
+    where
+        _pin_project::__private::Wrapper<
+            'pin,
+            _pin_project::__private::PhantomPinned,
+        >: _pin_project::__private::Unpin,
+    {}
+    trait EnumMustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: _pin_project::__private::Drop> EnumMustNotImplDrop for T {}
+    impl<T, U> EnumMustNotImplDrop for Enum<T, U> {}
+    #[doc(hidden)]
+    impl<T, U> _pin_project::__private::PinnedDrop for Enum<T, U> {
+        unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+    }
+};
+fn main() {}
diff --git a/crates/pin-project/tests/expand/not_unpin/enum.rs b/crates/pin-project/tests/expand/not_unpin/enum.rs
new file mode 100644
index 0000000..ac0b3b8
--- /dev/null
+++ b/crates/pin-project/tests/expand/not_unpin/enum.rs
@@ -0,0 +1,14 @@
+use pin_project::pin_project;
+
+#[pin_project(!Unpin, project = EnumProj, project_ref = EnumProjRef)]
+enum Enum<T, U> {
+    Struct {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    },
+    Tuple(#[pin] T, U),
+    Unit,
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/expand/not_unpin/struct.expanded.rs b/crates/pin-project/tests/expand/not_unpin/struct.expanded.rs
new file mode 100644
index 0000000..8d8bb1f
--- /dev/null
+++ b/crates/pin-project/tests/expand/not_unpin/struct.expanded.rs
@@ -0,0 +1,102 @@
+use pin_project::pin_project;
+#[pin(__private(!Unpin))]
+struct Struct<T, U> {
+    #[pin]
+    pinned: T,
+    unpinned: U,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(unused_extern_crates)]
+    extern crate pin_project as _pin_project;
+    #[allow(dead_code)]
+    #[allow(clippy::mut_mut)]
+    struct __StructProjection<'pin, T, U>
+    where
+        Struct<T, U>: 'pin,
+    {
+        pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
+        unpinned: &'pin mut (U),
+    }
+    #[allow(dead_code)]
+    #[allow(clippy::ref_option_ref)]
+    struct __StructProjectionRef<'pin, T, U>
+    where
+        Struct<T, U>: 'pin,
+    {
+        pinned: ::pin_project::__private::Pin<&'pin (T)>,
+        unpinned: &'pin (U),
+    }
+    impl<T, U> Struct<T, U> {
+        #[allow(dead_code)]
+        #[inline]
+        fn project<'pin>(
+            self: _pin_project::__private::Pin<&'pin mut Self>,
+        ) -> __StructProjection<'pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_unchecked_mut();
+                __StructProjection {
+                    pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+                    unpinned,
+                }
+            }
+        }
+        #[allow(dead_code)]
+        #[allow(clippy::missing_const_for_fn)]
+        #[inline]
+        fn project_ref<'pin>(
+            self: _pin_project::__private::Pin<&'pin Self>,
+        ) -> __StructProjectionRef<'pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_ref();
+                __StructProjectionRef {
+                    pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+                    unpinned,
+                }
+            }
+        }
+    }
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+        let _ = &this.pinned;
+        let _ = &this.unpinned;
+    }
+    #[doc(hidden)]
+    impl<'pin, T, U> _pin_project::__private::Unpin for Struct<T, U>
+    where
+        _pin_project::__private::Wrapper<
+            'pin,
+            _pin_project::__private::PhantomPinned,
+        >: _pin_project::__private::Unpin,
+    {}
+    #[doc(hidden)]
+    unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Struct<T, U>
+    where
+        _pin_project::__private::Wrapper<
+            'pin,
+            _pin_project::__private::PhantomPinned,
+        >: _pin_project::__private::Unpin,
+    {}
+    trait StructMustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: _pin_project::__private::Drop> StructMustNotImplDrop for T {}
+    impl<T, U> StructMustNotImplDrop for Struct<T, U> {}
+    #[doc(hidden)]
+    impl<T, U> _pin_project::__private::PinnedDrop for Struct<T, U> {
+        unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+    }
+};
+fn main() {}
diff --git a/crates/pin-project/tests/expand/not_unpin/struct.rs b/crates/pin-project/tests/expand/not_unpin/struct.rs
new file mode 100644
index 0000000..233e6d4
--- /dev/null
+++ b/crates/pin-project/tests/expand/not_unpin/struct.rs
@@ -0,0 +1,10 @@
+use pin_project::pin_project;
+
+#[pin_project(!Unpin)]
+struct Struct<T, U> {
+    #[pin]
+    pinned: T,
+    unpinned: U,
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/expand/not_unpin/tuple_struct.expanded.rs b/crates/pin-project/tests/expand/not_unpin/tuple_struct.expanded.rs
new file mode 100644
index 0000000..0b4b5d9
--- /dev/null
+++ b/crates/pin-project/tests/expand/not_unpin/tuple_struct.expanded.rs
@@ -0,0 +1,96 @@
+use pin_project::pin_project;
+#[pin(__private(!Unpin))]
+struct TupleStruct<T, U>(#[pin] T, U);
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(unused_extern_crates)]
+    extern crate pin_project as _pin_project;
+    #[allow(dead_code)]
+    #[allow(clippy::mut_mut)]
+    struct __TupleStructProjection<'pin, T, U>(
+        ::pin_project::__private::Pin<&'pin mut (T)>,
+        &'pin mut (U),
+    )
+    where
+        TupleStruct<T, U>: 'pin;
+    #[allow(dead_code)]
+    #[allow(clippy::ref_option_ref)]
+    struct __TupleStructProjectionRef<'pin, T, U>(
+        ::pin_project::__private::Pin<&'pin (T)>,
+        &'pin (U),
+    )
+    where
+        TupleStruct<T, U>: 'pin;
+    impl<T, U> TupleStruct<T, U> {
+        #[allow(dead_code)]
+        #[inline]
+        fn project<'pin>(
+            self: _pin_project::__private::Pin<&'pin mut Self>,
+        ) -> __TupleStructProjection<'pin, T, U> {
+            unsafe {
+                let Self(_0, _1) = self.get_unchecked_mut();
+                __TupleStructProjection(
+                    _pin_project::__private::Pin::new_unchecked(_0),
+                    _1,
+                )
+            }
+        }
+        #[allow(dead_code)]
+        #[allow(clippy::missing_const_for_fn)]
+        #[inline]
+        fn project_ref<'pin>(
+            self: _pin_project::__private::Pin<&'pin Self>,
+        ) -> __TupleStructProjectionRef<'pin, T, U> {
+            unsafe {
+                let Self(_0, _1) = self.get_ref();
+                __TupleStructProjectionRef(
+                    _pin_project::__private::Pin::new_unchecked(_0),
+                    _1,
+                )
+            }
+        }
+    }
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &TupleStruct<T, U>) {
+        let _ = &this.0;
+        let _ = &this.1;
+    }
+    #[doc(hidden)]
+    impl<'pin, T, U> _pin_project::__private::Unpin for TupleStruct<T, U>
+    where
+        _pin_project::__private::Wrapper<
+            'pin,
+            _pin_project::__private::PhantomPinned,
+        >: _pin_project::__private::Unpin,
+    {}
+    #[doc(hidden)]
+    unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for TupleStruct<T, U>
+    where
+        _pin_project::__private::Wrapper<
+            'pin,
+            _pin_project::__private::PhantomPinned,
+        >: _pin_project::__private::Unpin,
+    {}
+    trait TupleStructMustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: _pin_project::__private::Drop> TupleStructMustNotImplDrop for T {}
+    impl<T, U> TupleStructMustNotImplDrop for TupleStruct<T, U> {}
+    #[doc(hidden)]
+    impl<T, U> _pin_project::__private::PinnedDrop for TupleStruct<T, U> {
+        unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+    }
+};
+fn main() {}
diff --git a/crates/pin-project/tests/expand/not_unpin/tuple_struct.rs b/crates/pin-project/tests/expand/not_unpin/tuple_struct.rs
new file mode 100644
index 0000000..c8065db
--- /dev/null
+++ b/crates/pin-project/tests/expand/not_unpin/tuple_struct.rs
@@ -0,0 +1,6 @@
+use pin_project::pin_project;
+
+#[pin_project(!Unpin)]
+struct TupleStruct<T, U>(#[pin] T, U);
+
+fn main() {}
diff --git a/crates/pin-project/tests/expand/pinned_drop/enum.expanded.rs b/crates/pin-project/tests/expand/pinned_drop/enum.expanded.rs
new file mode 100644
index 0000000..b1ed73c
--- /dev/null
+++ b/crates/pin-project/tests/expand/pinned_drop/enum.expanded.rs
@@ -0,0 +1,159 @@
+use std::pin::Pin;
+use pin_project::{pin_project, pinned_drop};
+#[pin(__private(PinnedDrop, project = EnumProj, project_ref = EnumProjRef))]
+enum Enum<T, U> {
+    Struct { #[pin] pinned: T, unpinned: U },
+    Tuple(#[pin] T, U),
+    Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::mut_mut)]
+enum EnumProj<'pin, T, U>
+where
+    Enum<T, U>: 'pin,
+{
+    Struct {
+        pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
+        unpinned: &'pin mut (U),
+    },
+    Tuple(::pin_project::__private::Pin<&'pin mut (T)>, &'pin mut (U)),
+    Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::ref_option_ref)]
+enum EnumProjRef<'pin, T, U>
+where
+    Enum<T, U>: 'pin,
+{
+    Struct { pinned: ::pin_project::__private::Pin<&'pin (T)>, unpinned: &'pin (U) },
+    Tuple(::pin_project::__private::Pin<&'pin (T)>, &'pin (U)),
+    Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(unused_extern_crates)]
+    extern crate pin_project as _pin_project;
+    impl<T, U> Enum<T, U> {
+        #[allow(dead_code)]
+        #[inline]
+        fn project<'pin>(
+            self: _pin_project::__private::Pin<&'pin mut Self>,
+        ) -> EnumProj<'pin, T, U> {
+            unsafe {
+                match self.get_unchecked_mut() {
+                    Self::Struct { pinned, unpinned } => {
+                        EnumProj::Struct {
+                            pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+                            unpinned,
+                        }
+                    }
+                    Self::Tuple(_0, _1) => {
+                        EnumProj::Tuple(
+                            _pin_project::__private::Pin::new_unchecked(_0),
+                            _1,
+                        )
+                    }
+                    Self::Unit => EnumProj::Unit,
+                }
+            }
+        }
+        #[allow(dead_code)]
+        #[allow(clippy::missing_const_for_fn)]
+        #[inline]
+        fn project_ref<'pin>(
+            self: _pin_project::__private::Pin<&'pin Self>,
+        ) -> EnumProjRef<'pin, T, U> {
+            unsafe {
+                match self.get_ref() {
+                    Self::Struct { pinned, unpinned } => {
+                        EnumProjRef::Struct {
+                            pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+                            unpinned,
+                        }
+                    }
+                    Self::Tuple(_0, _1) => {
+                        EnumProjRef::Tuple(
+                            _pin_project::__private::Pin::new_unchecked(_0),
+                            _1,
+                        )
+                    }
+                    Self::Unit => EnumProjRef::Unit,
+                }
+            }
+        }
+    }
+    #[allow(missing_debug_implementations)]
+    struct __Enum<'pin, T, U> {
+        __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+            'pin,
+            (
+                _pin_project::__private::PhantomData<T>,
+                _pin_project::__private::PhantomData<U>,
+            ),
+        >,
+        __field0: T,
+        __field1: T,
+    }
+    impl<'pin, T, U> _pin_project::__private::Unpin for Enum<T, U>
+    where
+        __Enum<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    #[doc(hidden)]
+    unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Enum<T, U>
+    where
+        __Enum<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    impl<T, U> _pin_project::__private::Drop for Enum<T, U> {
+        fn drop(&mut self) {
+            unsafe {
+                let __pinned_self = _pin_project::__private::Pin::new_unchecked(self);
+                _pin_project::__private::PinnedDrop::drop(__pinned_self);
+            }
+        }
+    }
+};
+#[doc(hidden)]
+impl<T, U> ::pin_project::__private::PinnedDrop for Enum<T, U> {
+    unsafe fn drop(self: Pin<&mut Self>) {
+        #[allow(clippy::needless_pass_by_value)]
+        fn __drop_inner<T, U>(__self: Pin<&mut Enum<T, U>>) {
+            fn __drop_inner() {}
+            let _ = __self;
+        }
+        __drop_inner(self);
+    }
+}
+fn main() {}
diff --git a/crates/pin-project/tests/expand/pinned_drop/enum.rs b/crates/pin-project/tests/expand/pinned_drop/enum.rs
new file mode 100644
index 0000000..c162ef6
--- /dev/null
+++ b/crates/pin-project/tests/expand/pinned_drop/enum.rs
@@ -0,0 +1,23 @@
+use std::pin::Pin;
+
+use pin_project::{pin_project, pinned_drop};
+
+#[pin_project(PinnedDrop, project = EnumProj, project_ref = EnumProjRef)]
+enum Enum<T, U> {
+    Struct {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    },
+    Tuple(#[pin] T, U),
+    Unit,
+}
+
+#[pinned_drop]
+impl<T, U> PinnedDrop for Enum<T, U> {
+    fn drop(self: Pin<&mut Self>) {
+        let _ = self;
+    }
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/expand/pinned_drop/struct.expanded.rs b/crates/pin-project/tests/expand/pinned_drop/struct.expanded.rs
new file mode 100644
index 0000000..27ee41b
--- /dev/null
+++ b/crates/pin-project/tests/expand/pinned_drop/struct.expanded.rs
@@ -0,0 +1,118 @@
+use std::pin::Pin;
+use pin_project::{pin_project, pinned_drop};
+#[pin(__private(PinnedDrop))]
+struct Struct<T, U> {
+    #[pin]
+    pinned: T,
+    unpinned: U,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(unused_extern_crates)]
+    extern crate pin_project as _pin_project;
+    #[allow(dead_code)]
+    #[allow(clippy::mut_mut)]
+    struct __StructProjection<'pin, T, U>
+    where
+        Struct<T, U>: 'pin,
+    {
+        pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
+        unpinned: &'pin mut (U),
+    }
+    #[allow(dead_code)]
+    #[allow(clippy::ref_option_ref)]
+    struct __StructProjectionRef<'pin, T, U>
+    where
+        Struct<T, U>: 'pin,
+    {
+        pinned: ::pin_project::__private::Pin<&'pin (T)>,
+        unpinned: &'pin (U),
+    }
+    impl<T, U> Struct<T, U> {
+        #[allow(dead_code)]
+        #[inline]
+        fn project<'pin>(
+            self: _pin_project::__private::Pin<&'pin mut Self>,
+        ) -> __StructProjection<'pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_unchecked_mut();
+                __StructProjection {
+                    pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+                    unpinned,
+                }
+            }
+        }
+        #[allow(dead_code)]
+        #[allow(clippy::missing_const_for_fn)]
+        #[inline]
+        fn project_ref<'pin>(
+            self: _pin_project::__private::Pin<&'pin Self>,
+        ) -> __StructProjectionRef<'pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_ref();
+                __StructProjectionRef {
+                    pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+                    unpinned,
+                }
+            }
+        }
+    }
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+        let _ = &this.pinned;
+        let _ = &this.unpinned;
+    }
+    #[allow(missing_debug_implementations)]
+    struct __Struct<'pin, T, U> {
+        __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+            'pin,
+            (
+                _pin_project::__private::PhantomData<T>,
+                _pin_project::__private::PhantomData<U>,
+            ),
+        >,
+        __field0: T,
+    }
+    impl<'pin, T, U> _pin_project::__private::Unpin for Struct<T, U>
+    where
+        __Struct<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    #[doc(hidden)]
+    unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Struct<T, U>
+    where
+        __Struct<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    impl<T, U> _pin_project::__private::Drop for Struct<T, U> {
+        fn drop(&mut self) {
+            unsafe {
+                let __pinned_self = _pin_project::__private::Pin::new_unchecked(self);
+                _pin_project::__private::PinnedDrop::drop(__pinned_self);
+            }
+        }
+    }
+};
+#[doc(hidden)]
+impl<T, U> ::pin_project::__private::PinnedDrop for Struct<T, U> {
+    unsafe fn drop(self: Pin<&mut Self>) {
+        #[allow(clippy::needless_pass_by_value)]
+        fn __drop_inner<T, U>(__self: Pin<&mut Struct<T, U>>) {
+            fn __drop_inner() {}
+            let _ = __self;
+        }
+        __drop_inner(self);
+    }
+}
+fn main() {}
diff --git a/crates/pin-project/tests/expand/pinned_drop/struct.rs b/crates/pin-project/tests/expand/pinned_drop/struct.rs
new file mode 100644
index 0000000..691d3cb
--- /dev/null
+++ b/crates/pin-project/tests/expand/pinned_drop/struct.rs
@@ -0,0 +1,19 @@
+use std::pin::Pin;
+
+use pin_project::{pin_project, pinned_drop};
+
+#[pin_project(PinnedDrop)]
+struct Struct<T, U> {
+    #[pin]
+    pinned: T,
+    unpinned: U,
+}
+
+#[pinned_drop]
+impl<T, U> PinnedDrop for Struct<T, U> {
+    fn drop(self: Pin<&mut Self>) {
+        let _ = self;
+    }
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/expand/pinned_drop/tuple_struct.expanded.rs b/crates/pin-project/tests/expand/pinned_drop/tuple_struct.expanded.rs
new file mode 100644
index 0000000..83cd3b1
--- /dev/null
+++ b/crates/pin-project/tests/expand/pinned_drop/tuple_struct.expanded.rs
@@ -0,0 +1,112 @@
+use std::pin::Pin;
+use pin_project::{pin_project, pinned_drop};
+#[pin(__private(PinnedDrop))]
+struct TupleStruct<T, U>(#[pin] T, U);
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(unused_extern_crates)]
+    extern crate pin_project as _pin_project;
+    #[allow(dead_code)]
+    #[allow(clippy::mut_mut)]
+    struct __TupleStructProjection<'pin, T, U>(
+        ::pin_project::__private::Pin<&'pin mut (T)>,
+        &'pin mut (U),
+    )
+    where
+        TupleStruct<T, U>: 'pin;
+    #[allow(dead_code)]
+    #[allow(clippy::ref_option_ref)]
+    struct __TupleStructProjectionRef<'pin, T, U>(
+        ::pin_project::__private::Pin<&'pin (T)>,
+        &'pin (U),
+    )
+    where
+        TupleStruct<T, U>: 'pin;
+    impl<T, U> TupleStruct<T, U> {
+        #[allow(dead_code)]
+        #[inline]
+        fn project<'pin>(
+            self: _pin_project::__private::Pin<&'pin mut Self>,
+        ) -> __TupleStructProjection<'pin, T, U> {
+            unsafe {
+                let Self(_0, _1) = self.get_unchecked_mut();
+                __TupleStructProjection(
+                    _pin_project::__private::Pin::new_unchecked(_0),
+                    _1,
+                )
+            }
+        }
+        #[allow(dead_code)]
+        #[allow(clippy::missing_const_for_fn)]
+        #[inline]
+        fn project_ref<'pin>(
+            self: _pin_project::__private::Pin<&'pin Self>,
+        ) -> __TupleStructProjectionRef<'pin, T, U> {
+            unsafe {
+                let Self(_0, _1) = self.get_ref();
+                __TupleStructProjectionRef(
+                    _pin_project::__private::Pin::new_unchecked(_0),
+                    _1,
+                )
+            }
+        }
+    }
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &TupleStruct<T, U>) {
+        let _ = &this.0;
+        let _ = &this.1;
+    }
+    #[allow(missing_debug_implementations)]
+    struct __TupleStruct<'pin, T, U> {
+        __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+            'pin,
+            (
+                _pin_project::__private::PhantomData<T>,
+                _pin_project::__private::PhantomData<U>,
+            ),
+        >,
+        __field0: T,
+    }
+    impl<'pin, T, U> _pin_project::__private::Unpin for TupleStruct<T, U>
+    where
+        __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    #[doc(hidden)]
+    unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for TupleStruct<T, U>
+    where
+        __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    impl<T, U> _pin_project::__private::Drop for TupleStruct<T, U> {
+        fn drop(&mut self) {
+            unsafe {
+                let __pinned_self = _pin_project::__private::Pin::new_unchecked(self);
+                _pin_project::__private::PinnedDrop::drop(__pinned_self);
+            }
+        }
+    }
+};
+#[doc(hidden)]
+impl<T, U> ::pin_project::__private::PinnedDrop for TupleStruct<T, U> {
+    unsafe fn drop(self: Pin<&mut Self>) {
+        #[allow(clippy::needless_pass_by_value)]
+        fn __drop_inner<T, U>(__self: Pin<&mut TupleStruct<T, U>>) {
+            fn __drop_inner() {}
+            let _ = __self;
+        }
+        __drop_inner(self);
+    }
+}
+fn main() {}
diff --git a/crates/pin-project/tests/expand/pinned_drop/tuple_struct.rs b/crates/pin-project/tests/expand/pinned_drop/tuple_struct.rs
new file mode 100644
index 0000000..1f4917c
--- /dev/null
+++ b/crates/pin-project/tests/expand/pinned_drop/tuple_struct.rs
@@ -0,0 +1,15 @@
+use std::pin::Pin;
+
+use pin_project::{pin_project, pinned_drop};
+
+#[pin_project(PinnedDrop)]
+struct TupleStruct<T, U>(#[pin] T, U);
+
+#[pinned_drop]
+impl<T, U> PinnedDrop for TupleStruct<T, U> {
+    fn drop(self: Pin<&mut Self>) {
+        let _ = self;
+    }
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/expand/project_replace/enum.expanded.rs b/crates/pin-project/tests/expand/project_replace/enum.expanded.rs
new file mode 100644
index 0000000..230f6a9
--- /dev/null
+++ b/crates/pin-project/tests/expand/project_replace/enum.expanded.rs
@@ -0,0 +1,120 @@
+use pin_project::pin_project;
+#[pin(__private(project_replace = EnumProjOwn))]
+enum Enum<T, U> {
+    Struct { #[pin] pinned: T, unpinned: U },
+    Tuple(#[pin] T, U),
+    Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(variant_size_differences)]
+#[allow(clippy::large_enum_variant)]
+enum EnumProjOwn<T, U> {
+    Struct { pinned: ::pin_project::__private::PhantomData<T>, unpinned: U },
+    Tuple(::pin_project::__private::PhantomData<T>, U),
+    Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(unused_extern_crates)]
+    extern crate pin_project as _pin_project;
+    impl<T, U> Enum<T, U> {
+        #[allow(dead_code)]
+        #[inline]
+        fn project_replace(
+            self: _pin_project::__private::Pin<&mut Self>,
+            __replacement: Self,
+        ) -> EnumProjOwn<T, U> {
+            unsafe {
+                let __self_ptr: *mut Self = self.get_unchecked_mut();
+                let __guard = _pin_project::__private::UnsafeOverwriteGuard::new(
+                    __self_ptr,
+                    __replacement,
+                );
+                match &mut *__self_ptr {
+                    Self::Struct { pinned, unpinned } => {
+                        let __result = EnumProjOwn::Struct {
+                            pinned: _pin_project::__private::PhantomData,
+                            unpinned: _pin_project::__private::ptr::read(unpinned),
+                        };
+                        {
+                            let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
+                                pinned,
+                            );
+                        }
+                        __result
+                    }
+                    Self::Tuple(_0, _1) => {
+                        let __result = EnumProjOwn::Tuple(
+                            _pin_project::__private::PhantomData,
+                            _pin_project::__private::ptr::read(_1),
+                        );
+                        {
+                            let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
+                                _0,
+                            );
+                        }
+                        __result
+                    }
+                    Self::Unit => {
+                        let __result = EnumProjOwn::Unit;
+                        {}
+                        __result
+                    }
+                }
+            }
+        }
+    }
+    #[allow(missing_debug_implementations)]
+    struct __Enum<'pin, T, U> {
+        __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+            'pin,
+            (
+                _pin_project::__private::PhantomData<T>,
+                _pin_project::__private::PhantomData<U>,
+            ),
+        >,
+        __field0: T,
+        __field1: T,
+    }
+    impl<'pin, T, U> _pin_project::__private::Unpin for Enum<T, U>
+    where
+        __Enum<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    #[doc(hidden)]
+    unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Enum<T, U>
+    where
+        __Enum<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    trait EnumMustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: _pin_project::__private::Drop> EnumMustNotImplDrop for T {}
+    impl<T, U> EnumMustNotImplDrop for Enum<T, U> {}
+    #[doc(hidden)]
+    impl<T, U> _pin_project::__private::PinnedDrop for Enum<T, U> {
+        unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+    }
+};
+fn main() {}
diff --git a/crates/pin-project/tests/expand/project_replace/enum.rs b/crates/pin-project/tests/expand/project_replace/enum.rs
new file mode 100644
index 0000000..d737f64
--- /dev/null
+++ b/crates/pin-project/tests/expand/project_replace/enum.rs
@@ -0,0 +1,14 @@
+use pin_project::pin_project;
+
+#[pin_project(project_replace = EnumProjOwn)]
+enum Enum<T, U> {
+    Struct {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    },
+    Tuple(#[pin] T, U),
+    Unit,
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/expand/project_replace/struct.expanded.rs b/crates/pin-project/tests/expand/project_replace/struct.expanded.rs
new file mode 100644
index 0000000..126640a
--- /dev/null
+++ b/crates/pin-project/tests/expand/project_replace/struct.expanded.rs
@@ -0,0 +1,136 @@
+use pin_project::pin_project;
+#[pin(__private(project_replace))]
+struct Struct<T, U> {
+    #[pin]
+    pinned: T,
+    unpinned: U,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(unused_extern_crates)]
+    extern crate pin_project as _pin_project;
+    #[allow(dead_code)]
+    #[allow(clippy::mut_mut)]
+    struct __StructProjection<'pin, T, U>
+    where
+        Struct<T, U>: 'pin,
+    {
+        pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
+        unpinned: &'pin mut (U),
+    }
+    #[allow(dead_code)]
+    #[allow(clippy::ref_option_ref)]
+    struct __StructProjectionRef<'pin, T, U>
+    where
+        Struct<T, U>: 'pin,
+    {
+        pinned: ::pin_project::__private::Pin<&'pin (T)>,
+        unpinned: &'pin (U),
+    }
+    #[allow(dead_code)]
+    struct __StructProjectionOwned<T, U> {
+        pinned: ::pin_project::__private::PhantomData<T>,
+        unpinned: U,
+    }
+    impl<T, U> Struct<T, U> {
+        #[allow(dead_code)]
+        #[inline]
+        fn project<'pin>(
+            self: _pin_project::__private::Pin<&'pin mut Self>,
+        ) -> __StructProjection<'pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_unchecked_mut();
+                __StructProjection {
+                    pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+                    unpinned,
+                }
+            }
+        }
+        #[allow(dead_code)]
+        #[allow(clippy::missing_const_for_fn)]
+        #[inline]
+        fn project_ref<'pin>(
+            self: _pin_project::__private::Pin<&'pin Self>,
+        ) -> __StructProjectionRef<'pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_ref();
+                __StructProjectionRef {
+                    pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+                    unpinned,
+                }
+            }
+        }
+        #[allow(dead_code)]
+        #[inline]
+        fn project_replace(
+            self: _pin_project::__private::Pin<&mut Self>,
+            __replacement: Self,
+        ) -> __StructProjectionOwned<T, U> {
+            unsafe {
+                let __self_ptr: *mut Self = self.get_unchecked_mut();
+                let __guard = _pin_project::__private::UnsafeOverwriteGuard::new(
+                    __self_ptr,
+                    __replacement,
+                );
+                let Self { pinned, unpinned } = &mut *__self_ptr;
+                let __result = __StructProjectionOwned {
+                    pinned: _pin_project::__private::PhantomData,
+                    unpinned: _pin_project::__private::ptr::read(unpinned),
+                };
+                {
+                    let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
+                        pinned,
+                    );
+                }
+                __result
+            }
+        }
+    }
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+        let _ = &this.pinned;
+        let _ = &this.unpinned;
+    }
+    #[allow(missing_debug_implementations)]
+    struct __Struct<'pin, T, U> {
+        __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+            'pin,
+            (
+                _pin_project::__private::PhantomData<T>,
+                _pin_project::__private::PhantomData<U>,
+            ),
+        >,
+        __field0: T,
+    }
+    impl<'pin, T, U> _pin_project::__private::Unpin for Struct<T, U>
+    where
+        __Struct<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    #[doc(hidden)]
+    unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Struct<T, U>
+    where
+        __Struct<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    trait StructMustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: _pin_project::__private::Drop> StructMustNotImplDrop for T {}
+    impl<T, U> StructMustNotImplDrop for Struct<T, U> {}
+    #[doc(hidden)]
+    impl<T, U> _pin_project::__private::PinnedDrop for Struct<T, U> {
+        unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+    }
+};
+fn main() {}
diff --git a/crates/pin-project/tests/expand/project_replace/struct.rs b/crates/pin-project/tests/expand/project_replace/struct.rs
new file mode 100644
index 0000000..5865526
--- /dev/null
+++ b/crates/pin-project/tests/expand/project_replace/struct.rs
@@ -0,0 +1,10 @@
+use pin_project::pin_project;
+
+#[pin_project(project_replace)]
+struct Struct<T, U> {
+    #[pin]
+    pinned: T,
+    unpinned: U,
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/expand/project_replace/tuple_struct.expanded.rs b/crates/pin-project/tests/expand/project_replace/tuple_struct.expanded.rs
new file mode 100644
index 0000000..fced02c
--- /dev/null
+++ b/crates/pin-project/tests/expand/project_replace/tuple_struct.expanded.rs
@@ -0,0 +1,130 @@
+use pin_project::pin_project;
+#[pin(__private(project_replace))]
+struct TupleStruct<T, U>(#[pin] T, U);
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(unused_extern_crates)]
+    extern crate pin_project as _pin_project;
+    #[allow(dead_code)]
+    #[allow(clippy::mut_mut)]
+    struct __TupleStructProjection<'pin, T, U>(
+        ::pin_project::__private::Pin<&'pin mut (T)>,
+        &'pin mut (U),
+    )
+    where
+        TupleStruct<T, U>: 'pin;
+    #[allow(dead_code)]
+    #[allow(clippy::ref_option_ref)]
+    struct __TupleStructProjectionRef<'pin, T, U>(
+        ::pin_project::__private::Pin<&'pin (T)>,
+        &'pin (U),
+    )
+    where
+        TupleStruct<T, U>: 'pin;
+    #[allow(dead_code)]
+    struct __TupleStructProjectionOwned<T, U>(
+        ::pin_project::__private::PhantomData<T>,
+        U,
+    );
+    impl<T, U> TupleStruct<T, U> {
+        #[allow(dead_code)]
+        #[inline]
+        fn project<'pin>(
+            self: _pin_project::__private::Pin<&'pin mut Self>,
+        ) -> __TupleStructProjection<'pin, T, U> {
+            unsafe {
+                let Self(_0, _1) = self.get_unchecked_mut();
+                __TupleStructProjection(
+                    _pin_project::__private::Pin::new_unchecked(_0),
+                    _1,
+                )
+            }
+        }
+        #[allow(dead_code)]
+        #[allow(clippy::missing_const_for_fn)]
+        #[inline]
+        fn project_ref<'pin>(
+            self: _pin_project::__private::Pin<&'pin Self>,
+        ) -> __TupleStructProjectionRef<'pin, T, U> {
+            unsafe {
+                let Self(_0, _1) = self.get_ref();
+                __TupleStructProjectionRef(
+                    _pin_project::__private::Pin::new_unchecked(_0),
+                    _1,
+                )
+            }
+        }
+        #[allow(dead_code)]
+        #[inline]
+        fn project_replace(
+            self: _pin_project::__private::Pin<&mut Self>,
+            __replacement: Self,
+        ) -> __TupleStructProjectionOwned<T, U> {
+            unsafe {
+                let __self_ptr: *mut Self = self.get_unchecked_mut();
+                let __guard = _pin_project::__private::UnsafeOverwriteGuard::new(
+                    __self_ptr,
+                    __replacement,
+                );
+                let Self(_0, _1) = &mut *__self_ptr;
+                let __result = __TupleStructProjectionOwned(
+                    _pin_project::__private::PhantomData,
+                    _pin_project::__private::ptr::read(_1),
+                );
+                {
+                    let __guard = _pin_project::__private::UnsafeDropInPlaceGuard::new(
+                        _0,
+                    );
+                }
+                __result
+            }
+        }
+    }
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &TupleStruct<T, U>) {
+        let _ = &this.0;
+        let _ = &this.1;
+    }
+    #[allow(missing_debug_implementations)]
+    struct __TupleStruct<'pin, T, U> {
+        __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+            'pin,
+            (
+                _pin_project::__private::PhantomData<T>,
+                _pin_project::__private::PhantomData<U>,
+            ),
+        >,
+        __field0: T,
+    }
+    impl<'pin, T, U> _pin_project::__private::Unpin for TupleStruct<T, U>
+    where
+        __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    #[doc(hidden)]
+    unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for TupleStruct<T, U>
+    where
+        __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    trait TupleStructMustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: _pin_project::__private::Drop> TupleStructMustNotImplDrop for T {}
+    impl<T, U> TupleStructMustNotImplDrop for TupleStruct<T, U> {}
+    #[doc(hidden)]
+    impl<T, U> _pin_project::__private::PinnedDrop for TupleStruct<T, U> {
+        unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+    }
+};
+fn main() {}
diff --git a/crates/pin-project/tests/expand/project_replace/tuple_struct.rs b/crates/pin-project/tests/expand/project_replace/tuple_struct.rs
new file mode 100644
index 0000000..c4d05f5
--- /dev/null
+++ b/crates/pin-project/tests/expand/project_replace/tuple_struct.rs
@@ -0,0 +1,6 @@
+use pin_project::pin_project;
+
+#[pin_project(project_replace)]
+struct TupleStruct<T, U>(#[pin] T, U);
+
+fn main() {}
diff --git a/crates/pin-project/tests/expand/pub/enum.expanded.rs b/crates/pin-project/tests/expand/pub/enum.expanded.rs
new file mode 100644
index 0000000..8c9eaec
--- /dev/null
+++ b/crates/pin-project/tests/expand/pub/enum.expanded.rs
@@ -0,0 +1,147 @@
+use pin_project::pin_project;
+#[pin(__private(project = EnumProj, project_ref = EnumProjRef))]
+pub enum Enum<T, U> {
+    Struct { #[pin] pinned: T, unpinned: U },
+    Tuple(#[pin] T, U),
+    Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::mut_mut)]
+pub(crate) enum EnumProj<'pin, T, U>
+where
+    Enum<T, U>: 'pin,
+{
+    Struct {
+        pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
+        unpinned: &'pin mut (U),
+    },
+    Tuple(::pin_project::__private::Pin<&'pin mut (T)>, &'pin mut (U)),
+    Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::ref_option_ref)]
+pub(crate) enum EnumProjRef<'pin, T, U>
+where
+    Enum<T, U>: 'pin,
+{
+    Struct { pinned: ::pin_project::__private::Pin<&'pin (T)>, unpinned: &'pin (U) },
+    Tuple(::pin_project::__private::Pin<&'pin (T)>, &'pin (U)),
+    Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(unused_extern_crates)]
+    extern crate pin_project as _pin_project;
+    impl<T, U> Enum<T, U> {
+        #[allow(dead_code)]
+        #[inline]
+        pub(crate) fn project<'pin>(
+            self: _pin_project::__private::Pin<&'pin mut Self>,
+        ) -> EnumProj<'pin, T, U> {
+            unsafe {
+                match self.get_unchecked_mut() {
+                    Self::Struct { pinned, unpinned } => {
+                        EnumProj::Struct {
+                            pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+                            unpinned,
+                        }
+                    }
+                    Self::Tuple(_0, _1) => {
+                        EnumProj::Tuple(
+                            _pin_project::__private::Pin::new_unchecked(_0),
+                            _1,
+                        )
+                    }
+                    Self::Unit => EnumProj::Unit,
+                }
+            }
+        }
+        #[allow(dead_code)]
+        #[allow(clippy::missing_const_for_fn)]
+        #[inline]
+        pub(crate) fn project_ref<'pin>(
+            self: _pin_project::__private::Pin<&'pin Self>,
+        ) -> EnumProjRef<'pin, T, U> {
+            unsafe {
+                match self.get_ref() {
+                    Self::Struct { pinned, unpinned } => {
+                        EnumProjRef::Struct {
+                            pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+                            unpinned,
+                        }
+                    }
+                    Self::Tuple(_0, _1) => {
+                        EnumProjRef::Tuple(
+                            _pin_project::__private::Pin::new_unchecked(_0),
+                            _1,
+                        )
+                    }
+                    Self::Unit => EnumProjRef::Unit,
+                }
+            }
+        }
+    }
+    #[allow(missing_debug_implementations)]
+    pub struct __Enum<'pin, T, U> {
+        __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+            'pin,
+            (
+                _pin_project::__private::PhantomData<T>,
+                _pin_project::__private::PhantomData<U>,
+            ),
+        >,
+        __field0: T,
+        __field1: T,
+    }
+    impl<'pin, T, U> _pin_project::__private::Unpin for Enum<T, U>
+    where
+        __Enum<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    #[doc(hidden)]
+    unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Enum<T, U>
+    where
+        __Enum<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    trait EnumMustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: _pin_project::__private::Drop> EnumMustNotImplDrop for T {}
+    impl<T, U> EnumMustNotImplDrop for Enum<T, U> {}
+    #[doc(hidden)]
+    impl<T, U> _pin_project::__private::PinnedDrop for Enum<T, U> {
+        unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+    }
+};
+fn main() {}
diff --git a/crates/pin-project/tests/expand/pub/enum.rs b/crates/pin-project/tests/expand/pub/enum.rs
new file mode 100644
index 0000000..7c8577f
--- /dev/null
+++ b/crates/pin-project/tests/expand/pub/enum.rs
@@ -0,0 +1,14 @@
+use pin_project::pin_project;
+
+#[pin_project(project = EnumProj, project_ref = EnumProjRef)]
+pub enum Enum<T, U> {
+    Struct {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    },
+    Tuple(#[pin] T, U),
+    Unit,
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/expand/pub/struct.expanded.rs b/crates/pin-project/tests/expand/pub/struct.expanded.rs
new file mode 100644
index 0000000..cfa93b6
--- /dev/null
+++ b/crates/pin-project/tests/expand/pub/struct.expanded.rs
@@ -0,0 +1,106 @@
+use pin_project::pin_project;
+#[pin(__private())]
+pub struct Struct<T, U> {
+    #[pin]
+    pub pinned: T,
+    pub unpinned: U,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(unused_extern_crates)]
+    extern crate pin_project as _pin_project;
+    #[allow(dead_code)]
+    #[allow(clippy::mut_mut)]
+    pub(crate) struct __StructProjection<'pin, T, U>
+    where
+        Struct<T, U>: 'pin,
+    {
+        pub pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
+        pub unpinned: &'pin mut (U),
+    }
+    #[allow(dead_code)]
+    #[allow(clippy::ref_option_ref)]
+    pub(crate) struct __StructProjectionRef<'pin, T, U>
+    where
+        Struct<T, U>: 'pin,
+    {
+        pub pinned: ::pin_project::__private::Pin<&'pin (T)>,
+        pub unpinned: &'pin (U),
+    }
+    impl<T, U> Struct<T, U> {
+        #[allow(dead_code)]
+        #[inline]
+        pub(crate) fn project<'pin>(
+            self: _pin_project::__private::Pin<&'pin mut Self>,
+        ) -> __StructProjection<'pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_unchecked_mut();
+                __StructProjection {
+                    pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+                    unpinned,
+                }
+            }
+        }
+        #[allow(dead_code)]
+        #[allow(clippy::missing_const_for_fn)]
+        #[inline]
+        pub(crate) fn project_ref<'pin>(
+            self: _pin_project::__private::Pin<&'pin Self>,
+        ) -> __StructProjectionRef<'pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_ref();
+                __StructProjectionRef {
+                    pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+                    unpinned,
+                }
+            }
+        }
+    }
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+        let _ = &this.pinned;
+        let _ = &this.unpinned;
+    }
+    #[allow(missing_debug_implementations)]
+    pub struct __Struct<'pin, T, U> {
+        __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+            'pin,
+            (
+                _pin_project::__private::PhantomData<T>,
+                _pin_project::__private::PhantomData<U>,
+            ),
+        >,
+        __field0: T,
+    }
+    impl<'pin, T, U> _pin_project::__private::Unpin for Struct<T, U>
+    where
+        __Struct<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    #[doc(hidden)]
+    unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for Struct<T, U>
+    where
+        __Struct<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    trait StructMustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: _pin_project::__private::Drop> StructMustNotImplDrop for T {}
+    impl<T, U> StructMustNotImplDrop for Struct<T, U> {}
+    #[doc(hidden)]
+    impl<T, U> _pin_project::__private::PinnedDrop for Struct<T, U> {
+        unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+    }
+};
+fn main() {}
diff --git a/crates/pin-project/tests/expand/pub/struct.rs b/crates/pin-project/tests/expand/pub/struct.rs
new file mode 100644
index 0000000..f50d1e9
--- /dev/null
+++ b/crates/pin-project/tests/expand/pub/struct.rs
@@ -0,0 +1,10 @@
+use pin_project::pin_project;
+
+#[pin_project]
+pub struct Struct<T, U> {
+    #[pin]
+    pub pinned: T,
+    pub unpinned: U,
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/expand/pub/tuple_struct.expanded.rs b/crates/pin-project/tests/expand/pub/tuple_struct.expanded.rs
new file mode 100644
index 0000000..cf495a2
--- /dev/null
+++ b/crates/pin-project/tests/expand/pub/tuple_struct.expanded.rs
@@ -0,0 +1,100 @@
+use pin_project::pin_project;
+#[pin(__private())]
+pub struct TupleStruct<T, U>(#[pin] pub T, pub U);
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(unused_extern_crates)]
+    extern crate pin_project as _pin_project;
+    #[allow(dead_code)]
+    #[allow(clippy::mut_mut)]
+    pub(crate) struct __TupleStructProjection<'pin, T, U>(
+        pub ::pin_project::__private::Pin<&'pin mut (T)>,
+        pub &'pin mut (U),
+    )
+    where
+        TupleStruct<T, U>: 'pin;
+    #[allow(dead_code)]
+    #[allow(clippy::ref_option_ref)]
+    pub(crate) struct __TupleStructProjectionRef<'pin, T, U>(
+        pub ::pin_project::__private::Pin<&'pin (T)>,
+        pub &'pin (U),
+    )
+    where
+        TupleStruct<T, U>: 'pin;
+    impl<T, U> TupleStruct<T, U> {
+        #[allow(dead_code)]
+        #[inline]
+        pub(crate) fn project<'pin>(
+            self: _pin_project::__private::Pin<&'pin mut Self>,
+        ) -> __TupleStructProjection<'pin, T, U> {
+            unsafe {
+                let Self(_0, _1) = self.get_unchecked_mut();
+                __TupleStructProjection(
+                    _pin_project::__private::Pin::new_unchecked(_0),
+                    _1,
+                )
+            }
+        }
+        #[allow(dead_code)]
+        #[allow(clippy::missing_const_for_fn)]
+        #[inline]
+        pub(crate) fn project_ref<'pin>(
+            self: _pin_project::__private::Pin<&'pin Self>,
+        ) -> __TupleStructProjectionRef<'pin, T, U> {
+            unsafe {
+                let Self(_0, _1) = self.get_ref();
+                __TupleStructProjectionRef(
+                    _pin_project::__private::Pin::new_unchecked(_0),
+                    _1,
+                )
+            }
+        }
+    }
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &TupleStruct<T, U>) {
+        let _ = &this.0;
+        let _ = &this.1;
+    }
+    #[allow(missing_debug_implementations)]
+    pub struct __TupleStruct<'pin, T, U> {
+        __pin_project_use_generics: _pin_project::__private::AlwaysUnpin<
+            'pin,
+            (
+                _pin_project::__private::PhantomData<T>,
+                _pin_project::__private::PhantomData<U>,
+            ),
+        >,
+        __field0: T,
+    }
+    impl<'pin, T, U> _pin_project::__private::Unpin for TupleStruct<T, U>
+    where
+        __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    #[doc(hidden)]
+    unsafe impl<'pin, T, U> _pin_project::UnsafeUnpin for TupleStruct<T, U>
+    where
+        __TupleStruct<'pin, T, U>: _pin_project::__private::Unpin,
+    {}
+    trait TupleStructMustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: _pin_project::__private::Drop> TupleStructMustNotImplDrop for T {}
+    impl<T, U> TupleStructMustNotImplDrop for TupleStruct<T, U> {}
+    #[doc(hidden)]
+    impl<T, U> _pin_project::__private::PinnedDrop for TupleStruct<T, U> {
+        unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+    }
+};
+fn main() {}
diff --git a/crates/pin-project/tests/expand/pub/tuple_struct.rs b/crates/pin-project/tests/expand/pub/tuple_struct.rs
new file mode 100644
index 0000000..5756aaf
--- /dev/null
+++ b/crates/pin-project/tests/expand/pub/tuple_struct.rs
@@ -0,0 +1,6 @@
+use pin_project::pin_project;
+
+#[pin_project]
+pub struct TupleStruct<T, U>(#[pin] pub T, pub U);
+
+fn main() {}
diff --git a/crates/pin-project/tests/expand/unsafe_unpin/enum.expanded.rs b/crates/pin-project/tests/expand/unsafe_unpin/enum.expanded.rs
new file mode 100644
index 0000000..2df2635
--- /dev/null
+++ b/crates/pin-project/tests/expand/unsafe_unpin/enum.expanded.rs
@@ -0,0 +1,131 @@
+use pin_project::{pin_project, UnsafeUnpin};
+#[pin(__private(UnsafeUnpin, project = EnumProj, project_ref = EnumProjRef))]
+enum Enum<T, U> {
+    Struct { #[pin] pinned: T, unpinned: U },
+    Tuple(#[pin] T, U),
+    Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::mut_mut)]
+enum EnumProj<'pin, T, U>
+where
+    Enum<T, U>: 'pin,
+{
+    Struct {
+        pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
+        unpinned: &'pin mut (U),
+    },
+    Tuple(::pin_project::__private::Pin<&'pin mut (T)>, &'pin mut (U)),
+    Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(dead_code)]
+#[allow(clippy::ref_option_ref)]
+enum EnumProjRef<'pin, T, U>
+where
+    Enum<T, U>: 'pin,
+{
+    Struct { pinned: ::pin_project::__private::Pin<&'pin (T)>, unpinned: &'pin (U) },
+    Tuple(::pin_project::__private::Pin<&'pin (T)>, &'pin (U)),
+    Unit,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(unused_extern_crates)]
+    extern crate pin_project as _pin_project;
+    impl<T, U> Enum<T, U> {
+        #[allow(dead_code)]
+        #[inline]
+        fn project<'pin>(
+            self: _pin_project::__private::Pin<&'pin mut Self>,
+        ) -> EnumProj<'pin, T, U> {
+            unsafe {
+                match self.get_unchecked_mut() {
+                    Self::Struct { pinned, unpinned } => {
+                        EnumProj::Struct {
+                            pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+                            unpinned,
+                        }
+                    }
+                    Self::Tuple(_0, _1) => {
+                        EnumProj::Tuple(
+                            _pin_project::__private::Pin::new_unchecked(_0),
+                            _1,
+                        )
+                    }
+                    Self::Unit => EnumProj::Unit,
+                }
+            }
+        }
+        #[allow(dead_code)]
+        #[allow(clippy::missing_const_for_fn)]
+        #[inline]
+        fn project_ref<'pin>(
+            self: _pin_project::__private::Pin<&'pin Self>,
+        ) -> EnumProjRef<'pin, T, U> {
+            unsafe {
+                match self.get_ref() {
+                    Self::Struct { pinned, unpinned } => {
+                        EnumProjRef::Struct {
+                            pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+                            unpinned,
+                        }
+                    }
+                    Self::Tuple(_0, _1) => {
+                        EnumProjRef::Tuple(
+                            _pin_project::__private::Pin::new_unchecked(_0),
+                            _1,
+                        )
+                    }
+                    Self::Unit => EnumProjRef::Unit,
+                }
+            }
+        }
+    }
+    impl<'pin, T, U> _pin_project::__private::Unpin for Enum<T, U>
+    where
+        _pin_project::__private::Wrapper<'pin, Self>: _pin_project::UnsafeUnpin,
+    {}
+    trait EnumMustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: _pin_project::__private::Drop> EnumMustNotImplDrop for T {}
+    impl<T, U> EnumMustNotImplDrop for Enum<T, U> {}
+    #[doc(hidden)]
+    impl<T, U> _pin_project::__private::PinnedDrop for Enum<T, U> {
+        unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+    }
+};
+unsafe impl<T: Unpin, U> UnsafeUnpin for Enum<T, U> {}
+fn main() {}
diff --git a/crates/pin-project/tests/expand/unsafe_unpin/enum.rs b/crates/pin-project/tests/expand/unsafe_unpin/enum.rs
new file mode 100644
index 0000000..d368d71
--- /dev/null
+++ b/crates/pin-project/tests/expand/unsafe_unpin/enum.rs
@@ -0,0 +1,16 @@
+use pin_project::{pin_project, UnsafeUnpin};
+
+#[pin_project(UnsafeUnpin, project = EnumProj, project_ref = EnumProjRef)]
+enum Enum<T, U> {
+    Struct {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    },
+    Tuple(#[pin] T, U),
+    Unit,
+}
+
+unsafe impl<T: Unpin, U> UnsafeUnpin for Enum<T, U> {}
+
+fn main() {}
diff --git a/crates/pin-project/tests/expand/unsafe_unpin/struct.expanded.rs b/crates/pin-project/tests/expand/unsafe_unpin/struct.expanded.rs
new file mode 100644
index 0000000..838d0d3
--- /dev/null
+++ b/crates/pin-project/tests/expand/unsafe_unpin/struct.expanded.rs
@@ -0,0 +1,91 @@
+use pin_project::{pin_project, UnsafeUnpin};
+#[pin(__private(UnsafeUnpin))]
+struct Struct<T, U> {
+    #[pin]
+    pinned: T,
+    unpinned: U,
+}
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(unused_extern_crates)]
+    extern crate pin_project as _pin_project;
+    #[allow(dead_code)]
+    #[allow(clippy::mut_mut)]
+    struct __StructProjection<'pin, T, U>
+    where
+        Struct<T, U>: 'pin,
+    {
+        pinned: ::pin_project::__private::Pin<&'pin mut (T)>,
+        unpinned: &'pin mut (U),
+    }
+    #[allow(dead_code)]
+    #[allow(clippy::ref_option_ref)]
+    struct __StructProjectionRef<'pin, T, U>
+    where
+        Struct<T, U>: 'pin,
+    {
+        pinned: ::pin_project::__private::Pin<&'pin (T)>,
+        unpinned: &'pin (U),
+    }
+    impl<T, U> Struct<T, U> {
+        #[allow(dead_code)]
+        #[inline]
+        fn project<'pin>(
+            self: _pin_project::__private::Pin<&'pin mut Self>,
+        ) -> __StructProjection<'pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_unchecked_mut();
+                __StructProjection {
+                    pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+                    unpinned,
+                }
+            }
+        }
+        #[allow(dead_code)]
+        #[allow(clippy::missing_const_for_fn)]
+        #[inline]
+        fn project_ref<'pin>(
+            self: _pin_project::__private::Pin<&'pin Self>,
+        ) -> __StructProjectionRef<'pin, T, U> {
+            unsafe {
+                let Self { pinned, unpinned } = self.get_ref();
+                __StructProjectionRef {
+                    pinned: _pin_project::__private::Pin::new_unchecked(pinned),
+                    unpinned,
+                }
+            }
+        }
+    }
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &Struct<T, U>) {
+        let _ = &this.pinned;
+        let _ = &this.unpinned;
+    }
+    impl<'pin, T, U> _pin_project::__private::Unpin for Struct<T, U>
+    where
+        _pin_project::__private::Wrapper<'pin, Self>: _pin_project::UnsafeUnpin,
+    {}
+    trait StructMustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: _pin_project::__private::Drop> StructMustNotImplDrop for T {}
+    impl<T, U> StructMustNotImplDrop for Struct<T, U> {}
+    #[doc(hidden)]
+    impl<T, U> _pin_project::__private::PinnedDrop for Struct<T, U> {
+        unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+    }
+};
+unsafe impl<T: Unpin, U> UnsafeUnpin for Struct<T, U> {}
+fn main() {}
diff --git a/crates/pin-project/tests/expand/unsafe_unpin/struct.rs b/crates/pin-project/tests/expand/unsafe_unpin/struct.rs
new file mode 100644
index 0000000..b0851b1
--- /dev/null
+++ b/crates/pin-project/tests/expand/unsafe_unpin/struct.rs
@@ -0,0 +1,12 @@
+use pin_project::{pin_project, UnsafeUnpin};
+
+#[pin_project(UnsafeUnpin)]
+struct Struct<T, U> {
+    #[pin]
+    pinned: T,
+    unpinned: U,
+}
+
+unsafe impl<T: Unpin, U> UnsafeUnpin for Struct<T, U> {}
+
+fn main() {}
diff --git a/crates/pin-project/tests/expand/unsafe_unpin/tuple_struct.expanded.rs b/crates/pin-project/tests/expand/unsafe_unpin/tuple_struct.expanded.rs
new file mode 100644
index 0000000..af8ac00
--- /dev/null
+++ b/crates/pin-project/tests/expand/unsafe_unpin/tuple_struct.expanded.rs
@@ -0,0 +1,85 @@
+use pin_project::{pin_project, UnsafeUnpin};
+#[pin(__private(UnsafeUnpin))]
+struct TupleStruct<T, U>(#[pin] T, U);
+#[allow(box_pointers)]
+#[allow(deprecated)]
+#[allow(explicit_outlives_requirements)]
+#[allow(single_use_lifetimes)]
+#[allow(unreachable_pub)]
+#[allow(unused_tuple_struct_fields)]
+#[allow(clippy::unknown_clippy_lints)]
+#[allow(clippy::pattern_type_mismatch)]
+#[allow(clippy::redundant_pub_crate)]
+#[allow(clippy::type_repetition_in_bounds)]
+#[allow(unused_qualifications)]
+#[allow(clippy::semicolon_if_nothing_returned)]
+#[allow(clippy::use_self)]
+#[allow(clippy::used_underscore_binding)]
+const _: () = {
+    #[allow(unused_extern_crates)]
+    extern crate pin_project as _pin_project;
+    #[allow(dead_code)]
+    #[allow(clippy::mut_mut)]
+    struct __TupleStructProjection<'pin, T, U>(
+        ::pin_project::__private::Pin<&'pin mut (T)>,
+        &'pin mut (U),
+    )
+    where
+        TupleStruct<T, U>: 'pin;
+    #[allow(dead_code)]
+    #[allow(clippy::ref_option_ref)]
+    struct __TupleStructProjectionRef<'pin, T, U>(
+        ::pin_project::__private::Pin<&'pin (T)>,
+        &'pin (U),
+    )
+    where
+        TupleStruct<T, U>: 'pin;
+    impl<T, U> TupleStruct<T, U> {
+        #[allow(dead_code)]
+        #[inline]
+        fn project<'pin>(
+            self: _pin_project::__private::Pin<&'pin mut Self>,
+        ) -> __TupleStructProjection<'pin, T, U> {
+            unsafe {
+                let Self(_0, _1) = self.get_unchecked_mut();
+                __TupleStructProjection(
+                    _pin_project::__private::Pin::new_unchecked(_0),
+                    _1,
+                )
+            }
+        }
+        #[allow(dead_code)]
+        #[allow(clippy::missing_const_for_fn)]
+        #[inline]
+        fn project_ref<'pin>(
+            self: _pin_project::__private::Pin<&'pin Self>,
+        ) -> __TupleStructProjectionRef<'pin, T, U> {
+            unsafe {
+                let Self(_0, _1) = self.get_ref();
+                __TupleStructProjectionRef(
+                    _pin_project::__private::Pin::new_unchecked(_0),
+                    _1,
+                )
+            }
+        }
+    }
+    #[forbid(unaligned_references, safe_packed_borrows)]
+    fn __assert_not_repr_packed<T, U>(this: &TupleStruct<T, U>) {
+        let _ = &this.0;
+        let _ = &this.1;
+    }
+    impl<'pin, T, U> _pin_project::__private::Unpin for TupleStruct<T, U>
+    where
+        _pin_project::__private::Wrapper<'pin, Self>: _pin_project::UnsafeUnpin,
+    {}
+    trait TupleStructMustNotImplDrop {}
+    #[allow(clippy::drop_bounds, drop_bounds)]
+    impl<T: _pin_project::__private::Drop> TupleStructMustNotImplDrop for T {}
+    impl<T, U> TupleStructMustNotImplDrop for TupleStruct<T, U> {}
+    #[doc(hidden)]
+    impl<T, U> _pin_project::__private::PinnedDrop for TupleStruct<T, U> {
+        unsafe fn drop(self: _pin_project::__private::Pin<&mut Self>) {}
+    }
+};
+unsafe impl<T: Unpin, U> UnsafeUnpin for Struct<T, U> {}
+fn main() {}
diff --git a/crates/pin-project/tests/expand/unsafe_unpin/tuple_struct.rs b/crates/pin-project/tests/expand/unsafe_unpin/tuple_struct.rs
new file mode 100644
index 0000000..964617a
--- /dev/null
+++ b/crates/pin-project/tests/expand/unsafe_unpin/tuple_struct.rs
@@ -0,0 +1,8 @@
+use pin_project::{pin_project, UnsafeUnpin};
+
+#[pin_project(UnsafeUnpin)]
+struct TupleStruct<T, U>(#[pin] T, U);
+
+unsafe impl<T: Unpin, U> UnsafeUnpin for Struct<T, U> {}
+
+fn main() {}
diff --git a/crates/pin-project/tests/expandtest.rs b/crates/pin-project/tests/expandtest.rs
new file mode 100644
index 0000000..04a0666
--- /dev/null
+++ b/crates/pin-project/tests/expandtest.rs
@@ -0,0 +1,44 @@
+#![cfg(not(miri))]
+#![cfg(not(careful))]
+#![warn(rust_2018_idioms, single_use_lifetimes)]
+
+use std::{
+    env,
+    process::{Command, ExitStatus, Stdio},
+};
+
+const PATH: &str = "tests/expand/**/*.rs";
+
+#[rustversion::attr(not(nightly), ignore)]
+#[test]
+fn expandtest() {
+    let is_ci = env::var_os("CI").is_some();
+    let cargo = &*env::var("CARGO").unwrap_or_else(|_| "cargo".into());
+    if !has_command(&[cargo, "expand"]) {
+        if is_ci {
+            panic!("expandtest requires cargo-expand");
+        }
+        return;
+    }
+
+    let args = &["--all-features"];
+    if is_ci {
+        macrotest::expand_without_refresh_args(PATH, args);
+    } else {
+        env::set_var("MACROTEST", "overwrite");
+        macrotest::expand_args(PATH, args);
+    }
+}
+
+fn has_command(command: &[&str]) -> bool {
+    Command::new(command[0])
+        .args(&command[1..])
+        .arg("--version")
+        .stdin(Stdio::null())
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .status()
+        .as_ref()
+        .map(ExitStatus::success)
+        .unwrap_or(false)
+}
diff --git a/crates/pin-project/tests/include/basic-safe-part.rs b/crates/pin-project/tests/include/basic-safe-part.rs
new file mode 100644
index 0000000..0b7c43e
--- /dev/null
+++ b/crates/pin-project/tests/include/basic-safe-part.rs
@@ -0,0 +1,193 @@
+// default #[pin_project], PinnedDrop, project_replace, !Unpin, and UnsafeUnpin without UnsafeUnpin impl are completely safe.
+
+#[::pin_project::pin_project]
+#[derive(Debug)]
+pub struct DefaultStruct<T, U> {
+    #[pin]
+    pub pinned: T,
+    pub unpinned: U,
+}
+
+#[::pin_project::pin_project(
+    project = DefaultStructNamedProj,
+    project_ref = DefaultStructNamedProjRef,
+)]
+#[derive(Debug)]
+pub struct DefaultStructNamed<T, U> {
+    #[pin]
+    pub pinned: T,
+    pub unpinned: U,
+}
+
+#[::pin_project::pin_project]
+#[derive(Debug)]
+pub struct DefaultTupleStruct<T, U>(#[pin] pub T, pub U);
+
+#[::pin_project::pin_project(
+    project = DefaultTupleStructNamedProj,
+    project_ref = DefaultTupleStructNamedProjRef,
+)]
+#[derive(Debug)]
+pub struct DefaultTupleStructNamed<T, U>(#[pin] pub T, pub U);
+
+#[::pin_project::pin_project(
+    project = DefaultEnumProj,
+    project_ref = DefaultEnumProjRef,
+)]
+#[derive(Debug)]
+pub enum DefaultEnum<T, U> {
+    Struct {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    },
+    Tuple(#[pin] T, U),
+    Unit,
+}
+
+#[::pin_project::pin_project(PinnedDrop)]
+#[derive(Debug)]
+pub struct PinnedDropStruct<T, U> {
+    #[pin]
+    pub pinned: T,
+    pub unpinned: U,
+}
+
+#[::pin_project::pinned_drop]
+impl<T, U> PinnedDrop for PinnedDropStruct<T, U> {
+    fn drop(self: ::pin_project::__private::Pin<&mut Self>) {}
+}
+
+#[::pin_project::pin_project(PinnedDrop)]
+#[derive(Debug)]
+pub struct PinnedDropTupleStruct<T, U>(#[pin] pub T, pub U);
+
+#[::pin_project::pinned_drop]
+impl<T, U> PinnedDrop for PinnedDropTupleStruct<T, U> {
+    fn drop(self: ::pin_project::__private::Pin<&mut Self>) {}
+}
+
+#[::pin_project::pin_project(
+    PinnedDrop,
+    project = PinnedDropEnumProj,
+    project_ref = PinnedDropEnumProjRef,
+)]
+#[derive(Debug)]
+pub enum PinnedDropEnum<T, U> {
+    Struct {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    },
+    Tuple(#[pin] T, U),
+    Unit,
+}
+
+#[::pin_project::pinned_drop]
+impl<T, U> PinnedDrop for PinnedDropEnum<T, U> {
+    fn drop(self: ::pin_project::__private::Pin<&mut Self>) {}
+}
+
+#[::pin_project::pin_project(project_replace)]
+#[derive(Debug)]
+pub struct ReplaceStruct<T, U> {
+    #[pin]
+    pub pinned: T,
+    pub unpinned: U,
+}
+
+#[::pin_project::pin_project(
+    project = ReplaceStructNamedProj,
+    project_ref = ReplaceStructNamedProjRef,
+    project_replace = ReplaceStructNamedProjOwn,
+)]
+#[derive(Debug)]
+pub struct ReplaceStructNamed<T, U> {
+    #[pin]
+    pub pinned: T,
+    pub unpinned: U,
+}
+
+#[::pin_project::pin_project(project_replace)]
+#[derive(Debug)]
+pub struct ReplaceTupleStruct<T, U>(#[pin] pub T, pub U);
+
+#[::pin_project::pin_project(
+    project = ReplaceTupleStructNamedProj,
+    project_ref = ReplaceTupleStructNamedProjRef,
+    project_replace = ReplaceTupleStructNamedProjOwn,
+)]
+#[derive(Debug)]
+pub struct ReplaceTupleStructNamed<T, U>(#[pin] pub T, pub U);
+
+#[::pin_project::pin_project(
+    project = ReplaceEnumProj,
+    project_ref = ReplaceEnumProjRef,
+    project_replace = ReplaceEnumProjOwn,
+)]
+#[derive(Debug)]
+pub enum ReplaceEnum<T, U> {
+    Struct {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    },
+    Tuple(#[pin] T, U),
+    Unit,
+}
+
+#[::pin_project::pin_project(UnsafeUnpin)]
+#[derive(Debug)]
+pub struct UnsafeUnpinStruct<T, U> {
+    #[pin]
+    pub pinned: T,
+    pub unpinned: U,
+}
+
+#[::pin_project::pin_project(UnsafeUnpin)]
+#[derive(Debug)]
+pub struct UnsafeUnpinTupleStruct<T, U>(#[pin] pub T, pub U);
+
+#[::pin_project::pin_project(
+    UnsafeUnpin,
+    project = UnsafeUnpinEnumProj,
+    project_ref = UnsafeUnpinEnumProjRef,
+)]
+#[derive(Debug)]
+pub enum UnsafeUnpinEnum<T, U> {
+    Struct {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    },
+    Tuple(#[pin] T, U),
+    Unit,
+}
+
+#[::pin_project::pin_project(!Unpin)]
+#[derive(Debug)]
+pub struct NotUnpinStruct<T, U> {
+    #[pin]
+    pub pinned: T,
+    pub unpinned: U,
+}
+
+#[::pin_project::pin_project(!Unpin)]
+#[derive(Debug)]
+pub struct NotUnpinTupleStruct<T, U>(#[pin] pub T, pub U);
+
+#[::pin_project::pin_project(
+    !Unpin,
+    project = NotUnpinEnumProj,
+    project_ref = NotUnpinEnumProjRef,
+)]
+#[derive(Debug)]
+pub enum NotUnpinEnum<T, U> {
+    Struct {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    },
+    Tuple(#[pin] T, U),
+    Unit,
+}
diff --git a/crates/pin-project/tests/include/basic.rs b/crates/pin-project/tests/include/basic.rs
new file mode 100644
index 0000000..57cbaeb
--- /dev/null
+++ b/crates/pin-project/tests/include/basic.rs
@@ -0,0 +1,17 @@
+include!("basic-safe-part.rs");
+
+#[allow(clippy::undocumented_unsafe_blocks)]
+unsafe impl<T: ::pin_project::__private::Unpin, U: ::pin_project::__private::Unpin>
+    ::pin_project::UnsafeUnpin for UnsafeUnpinStruct<T, U>
+{
+}
+#[allow(clippy::undocumented_unsafe_blocks)]
+unsafe impl<T: ::pin_project::__private::Unpin, U: ::pin_project::__private::Unpin>
+    ::pin_project::UnsafeUnpin for UnsafeUnpinTupleStruct<T, U>
+{
+}
+#[allow(clippy::undocumented_unsafe_blocks)]
+unsafe impl<T: ::pin_project::__private::Unpin, U: ::pin_project::__private::Unpin>
+    ::pin_project::UnsafeUnpin for UnsafeUnpinEnum<T, U>
+{
+}
diff --git a/crates/pin-project/tests/lint.rs b/crates/pin-project/tests/lint.rs
new file mode 100644
index 0000000..d12cdd7
--- /dev/null
+++ b/crates/pin-project/tests/lint.rs
@@ -0,0 +1,1203 @@
+// Check interoperability with rustc and clippy lints.
+
+// for old compilers
+#![allow(unknown_lints)]
+#![warn(nonstandard_style, rust_2018_idioms, unused)]
+// Note: This does not guarantee compatibility with forbidding these lints in the future.
+// If rustc adds a new lint, we may not be able to keep this.
+#![forbid(future_incompatible, rust_2018_compatibility, rust_2021_compatibility)]
+// lints forbidden as a part of future_incompatible, rust_2018_compatibility, and rust_2021_compatibility are not included in the list below.
+// elided_lifetimes_in_paths, explicit_outlives_requirements, unused_extern_crates:  as a part of rust_2018_idioms
+// unsafe_op_in_unsafe_fn: requires Rust 1.52. and, we don't generate unsafe fn.
+// non_exhaustive_omitted_patterns, multiple_supertrait_upcastable: unstable
+// unstable_features: no way to generate #![feature(..)] by macros, expect for unstable inner attribute. and this lint is deprecated: https://doc.rust-lang.org/rustc/lints/listing/allowed-by-default.html#unstable-features
+// unused_crate_dependencies, must_not_suspend: unrelated
+// unsafe_code: checked in forbid_unsafe module
+#![warn(
+    box_pointers,
+    deprecated_in_future,
+    fuzzy_provenance_casts,
+    invalid_reference_casting,
+    let_underscore_drop,
+    lossy_provenance_casts,
+    macro_use_extern_crate,
+    meta_variable_misuse,
+    missing_abi,
+    missing_copy_implementations,
+    missing_debug_implementations,
+    missing_docs,
+    non_ascii_idents,
+    noop_method_call,
+    private_bounds,
+    private_interfaces,
+    single_use_lifetimes,
+    trivial_casts,
+    trivial_numeric_casts,
+    // unnameable_types, // TODO
+    unreachable_pub,
+    unused_import_braces,
+    unused_lifetimes,
+    unused_qualifications,
+    unused_results,
+    unused_tuple_struct_fields,
+    variant_size_differences
+)]
+#![warn(clippy::all, clippy::pedantic, clippy::nursery, clippy::restriction)]
+#![allow(clippy::blanket_clippy_restriction_lints)] // this is a test, so enable all restriction lints intentionally.
+#![allow(
+    clippy::absolute_paths,
+    clippy::exhaustive_enums,
+    clippy::exhaustive_structs,
+    clippy::min_ident_chars,
+    clippy::pub_with_shorthand,
+    clippy::single_call_fn,
+    clippy::single_char_lifetime_names
+)] // TODO
+
+pub mod basic {
+    include!("include/basic.rs");
+
+    pub mod inside_macro {
+        #[rustfmt::skip]
+        macro_rules! mac {
+            () => {
+                #[::pin_project::pin_project]
+                #[derive(Debug)]
+                pub struct DefaultStruct<T, U> {
+                    #[pin]
+                    pub pinned: T,
+                    pub unpinned: U,
+                }
+
+                #[::pin_project::pin_project(
+                    project = DefaultStructNamedProj,
+                    project_ref = DefaultStructNamedProjRef,
+                )]
+                #[derive(Debug)]
+                pub struct DefaultStructNamed<T, U> {
+                    #[pin]
+                    pub pinned: T,
+                    pub unpinned: U,
+                }
+
+                #[::pin_project::pin_project]
+                #[derive(Debug)]
+                pub struct DefaultTupleStruct<T, U>(#[pin] pub T, pub U);
+
+                #[::pin_project::pin_project(
+                    project = DefaultTupleStructNamedProj,
+                    project_ref = DefaultTupleStructNamedProjRef,
+                )]
+                #[derive(Debug)]
+                pub struct DefaultTupleStructNamed<T, U>(#[pin] pub T, pub U);
+
+                #[::pin_project::pin_project(
+                    project = DefaultEnumProj,
+                    project_ref = DefaultEnumProjRef,
+                )]
+                #[derive(Debug)]
+                pub enum DefaultEnum<T, U> {
+                    Struct {
+                        #[pin]
+                        pinned: T,
+                        unpinned: U,
+                    },
+                    Tuple(#[pin] T, U),
+                    Unit,
+                }
+
+                #[::pin_project::pin_project(PinnedDrop)]
+                #[derive(Debug)]
+                pub struct PinnedDropStruct<T, U> {
+                    #[pin]
+                    pub pinned: T,
+                    pub unpinned: U,
+                }
+
+                #[::pin_project::pinned_drop]
+                impl<T, U> PinnedDrop for PinnedDropStruct<T, U> {
+                    fn drop(self: ::pin_project::__private::Pin<&mut Self>) {}
+                }
+
+                #[::pin_project::pin_project(PinnedDrop)]
+                #[derive(Debug)]
+                pub struct PinnedDropTupleStruct<T, U>(#[pin] pub T, pub U);
+
+                #[::pin_project::pinned_drop]
+                impl<T, U> PinnedDrop for PinnedDropTupleStruct<T, U> {
+                    fn drop(self: ::pin_project::__private::Pin<&mut Self>) {}
+                }
+
+                #[::pin_project::pin_project(
+                    PinnedDrop,
+                    project = PinnedDropEnumProj,
+                    project_ref = PinnedDropEnumProjRef,
+                )]
+                #[derive(Debug)]
+                pub enum PinnedDropEnum<T, U> {
+                    Struct {
+                        #[pin]
+                        pinned: T,
+                        unpinned: U,
+                    },
+                    Tuple(#[pin] T, U),
+                    Unit,
+                }
+
+                #[::pin_project::pinned_drop]
+                impl<T, U> PinnedDrop for PinnedDropEnum<T, U> {
+                    fn drop(self: ::pin_project::__private::Pin<&mut Self>) {}
+                }
+
+                #[::pin_project::pin_project(project_replace)]
+                #[derive(Debug)]
+                pub struct ReplaceStruct<T, U> {
+                    #[pin]
+                    pub pinned: T,
+                    pub unpinned: U,
+                }
+
+                #[::pin_project::pin_project(
+                    project = ReplaceStructNamedProj,
+                    project_ref = ReplaceStructNamedProjRef,
+                    project_replace = ReplaceStructNamedProjOwn,
+                )]
+                #[derive(Debug)]
+                pub struct ReplaceStructNamed<T, U> {
+                    #[pin]
+                    pub pinned: T,
+                    pub unpinned: U,
+                }
+
+                #[::pin_project::pin_project(project_replace)]
+                #[derive(Debug)]
+                pub struct ReplaceTupleStruct<T, U>(#[pin] pub T, pub U);
+
+                #[::pin_project::pin_project(
+                    project = ReplaceTupleStructNamedProj,
+                    project_ref = ReplaceTupleStructNamedProjRef,
+                    project_replace = ReplaceTupleStructNamedProjOwn,
+                )]
+                #[derive(Debug)]
+                pub struct ReplaceTupleStructNamed<T, U>(#[pin] pub T, pub U);
+
+                #[::pin_project::pin_project(
+                    project = ReplaceEnumProj,
+                    project_ref = ReplaceEnumProjRef,
+                    project_replace = ReplaceEnumProjOwn,
+                )]
+                #[derive(Debug)]
+                pub enum ReplaceEnum<T, U> {
+                    Struct {
+                        #[pin]
+                        pinned: T,
+                        unpinned: U,
+                    },
+                    Tuple(#[pin] T, U),
+                    Unit,
+                }
+
+                #[::pin_project::pin_project(UnsafeUnpin)]
+                #[derive(Debug)]
+                pub struct UnsafeUnpinStruct<T, U> {
+                    #[pin]
+                    pub pinned: T,
+                    pub unpinned: U,
+                }
+
+                #[::pin_project::pin_project(UnsafeUnpin)]
+                #[derive(Debug)]
+                pub struct UnsafeUnpinTupleStruct<T, U>(#[pin] pub T, pub U);
+
+                #[::pin_project::pin_project(
+                    UnsafeUnpin,
+                    project = UnsafeUnpinEnumProj,
+                    project_ref = UnsafeUnpinEnumProjRef,
+                )]
+                #[derive(Debug)]
+                pub enum UnsafeUnpinEnum<T, U> {
+                    Struct {
+                        #[pin]
+                        pinned: T,
+                        unpinned: U,
+                    },
+                    Tuple(#[pin] T, U),
+                    Unit,
+                }
+
+                #[::pin_project::pin_project(!Unpin)]
+                #[derive(Debug)]
+                pub struct NotUnpinStruct<T, U> {
+                    #[pin]
+                    pub pinned: T,
+                    pub unpinned: U,
+                }
+
+                #[::pin_project::pin_project(!Unpin)]
+                #[derive(Debug)]
+                pub struct NotUnpinTupleStruct<T, U>(#[pin] pub T, pub U);
+
+                #[::pin_project::pin_project(
+                    !Unpin,
+                    project = NotUnpinEnumProj,
+                    project_ref = NotUnpinEnumProjRef,
+                )]
+                #[derive(Debug)]
+                pub enum NotUnpinEnum<T, U> {
+                    Struct {
+                        #[pin]
+                        pinned: T,
+                        unpinned: U,
+                    },
+                    Tuple(#[pin] T, U),
+                    Unit,
+                }
+
+                #[allow(clippy::undocumented_unsafe_blocks)]
+                unsafe impl<T: ::pin_project::__private::Unpin, U: ::pin_project::__private::Unpin>
+                    ::pin_project::UnsafeUnpin for UnsafeUnpinStruct<T, U>
+                {
+                }
+                #[allow(clippy::undocumented_unsafe_blocks)]
+                unsafe impl<T: ::pin_project::__private::Unpin, U: ::pin_project::__private::Unpin>
+                    ::pin_project::UnsafeUnpin for UnsafeUnpinTupleStruct<T, U>
+                {
+                }
+                #[allow(clippy::undocumented_unsafe_blocks)]
+                unsafe impl<T: ::pin_project::__private::Unpin, U: ::pin_project::__private::Unpin>
+                    ::pin_project::UnsafeUnpin for UnsafeUnpinEnum<T, U>
+                {
+                }
+            };
+        }
+
+        mac!();
+    }
+}
+
+pub mod forbid_unsafe {
+    #![forbid(unsafe_code)]
+
+    include!("include/basic-safe-part.rs");
+
+    pub mod inside_macro {
+        #[rustfmt::skip]
+        macro_rules! mac {
+            () => {
+                #[::pin_project::pin_project]
+                #[derive(Debug)]
+                pub struct DefaultStruct<T, U> {
+                    #[pin]
+                    pub pinned: T,
+                    pub unpinned: U,
+                }
+
+                #[::pin_project::pin_project(
+                    project = DefaultStructNamedProj,
+                    project_ref = DefaultStructNamedProjRef,
+                )]
+                #[derive(Debug)]
+                pub struct DefaultStructNamed<T, U> {
+                    #[pin]
+                    pub pinned: T,
+                    pub unpinned: U,
+                }
+
+                #[::pin_project::pin_project]
+                #[derive(Debug)]
+                pub struct DefaultTupleStruct<T, U>(#[pin] pub T, pub U);
+
+                #[::pin_project::pin_project(
+                    project = DefaultTupleStructNamedProj,
+                    project_ref = DefaultTupleStructNamedProjRef,
+                )]
+                #[derive(Debug)]
+                pub struct DefaultTupleStructNamed<T, U>(#[pin] pub T, pub U);
+
+                #[::pin_project::pin_project(
+                    project = DefaultEnumProj,
+                    project_ref = DefaultEnumProjRef,
+                )]
+                #[derive(Debug)]
+                pub enum DefaultEnum<T, U> {
+                    Struct {
+                        #[pin]
+                        pinned: T,
+                        unpinned: U,
+                    },
+                    Tuple(#[pin] T, U),
+                    Unit,
+                }
+
+                #[::pin_project::pin_project(PinnedDrop)]
+                #[derive(Debug)]
+                pub struct PinnedDropStruct<T, U> {
+                    #[pin]
+                    pub pinned: T,
+                    pub unpinned: U,
+                }
+
+                #[::pin_project::pinned_drop]
+                impl<T, U> PinnedDrop for PinnedDropStruct<T, U> {
+                    fn drop(self: ::pin_project::__private::Pin<&mut Self>) {}
+                }
+
+                #[::pin_project::pin_project(PinnedDrop)]
+                #[derive(Debug)]
+                pub struct PinnedDropTupleStruct<T, U>(#[pin] pub T, pub U);
+
+                #[::pin_project::pinned_drop]
+                impl<T, U> PinnedDrop for PinnedDropTupleStruct<T, U> {
+                    fn drop(self: ::pin_project::__private::Pin<&mut Self>) {}
+                }
+
+                #[::pin_project::pin_project(
+                    PinnedDrop,
+                    project = PinnedDropEnumProj,
+                    project_ref = PinnedDropEnumProjRef,
+                )]
+                #[derive(Debug)]
+                pub enum PinnedDropEnum<T, U> {
+                    Struct {
+                        #[pin]
+                        pinned: T,
+                        unpinned: U,
+                    },
+                    Tuple(#[pin] T, U),
+                    Unit,
+                }
+
+                #[::pin_project::pinned_drop]
+                impl<T, U> PinnedDrop for PinnedDropEnum<T, U> {
+                    fn drop(self: ::pin_project::__private::Pin<&mut Self>) {}
+                }
+
+                #[::pin_project::pin_project(project_replace)]
+                #[derive(Debug)]
+                pub struct ReplaceStruct<T, U> {
+                    #[pin]
+                    pub pinned: T,
+                    pub unpinned: U,
+                }
+
+                #[::pin_project::pin_project(
+                    project = ReplaceStructNamedProj,
+                    project_ref = ReplaceStructNamedProjRef,
+                    project_replace = ReplaceStructNamedProjOwn,
+                )]
+                #[derive(Debug)]
+                pub struct ReplaceStructNamed<T, U> {
+                    #[pin]
+                    pub pinned: T,
+                    pub unpinned: U,
+                }
+
+                #[::pin_project::pin_project(project_replace)]
+                #[derive(Debug)]
+                pub struct ReplaceTupleStruct<T, U>(#[pin] pub T, pub U);
+
+                #[::pin_project::pin_project(
+                    project = ReplaceTupleStructNamedProj,
+                    project_ref = ReplaceTupleStructNamedProjRef,
+                    project_replace = ReplaceTupleStructNamedProjOwn,
+                )]
+                #[derive(Debug)]
+                pub struct ReplaceTupleStructNamed<T, U>(#[pin] pub T, pub U);
+
+                #[::pin_project::pin_project(
+                    project = ReplaceEnumProj,
+                    project_ref = ReplaceEnumProjRef,
+                    project_replace = ReplaceEnumProjOwn,
+                )]
+                #[derive(Debug)]
+                pub enum ReplaceEnum<T, U> {
+                    Struct {
+                        #[pin]
+                        pinned: T,
+                        unpinned: U,
+                    },
+                    Tuple(#[pin] T, U),
+                    Unit,
+                }
+
+                #[::pin_project::pin_project(UnsafeUnpin)]
+                #[derive(Debug)]
+                pub struct UnsafeUnpinStruct<T, U> {
+                    #[pin]
+                    pub pinned: T,
+                    pub unpinned: U,
+                }
+
+                #[::pin_project::pin_project(UnsafeUnpin)]
+                #[derive(Debug)]
+                pub struct UnsafeUnpinTupleStruct<T, U>(#[pin] pub T, pub U);
+
+                #[::pin_project::pin_project(
+                    UnsafeUnpin,
+                    project = UnsafeUnpinEnumProj,
+                    project_ref = UnsafeUnpinEnumProjRef,
+                )]
+                #[derive(Debug)]
+                pub enum UnsafeUnpinEnum<T, U> {
+                    Struct {
+                        #[pin]
+                        pinned: T,
+                        unpinned: U,
+                    },
+                    Tuple(#[pin] T, U),
+                    Unit,
+                }
+
+                #[::pin_project::pin_project(!Unpin)]
+                #[derive(Debug)]
+                pub struct NotUnpinStruct<T, U> {
+                    #[pin]
+                    pub pinned: T,
+                    pub unpinned: U,
+                }
+
+                #[::pin_project::pin_project(!Unpin)]
+                #[derive(Debug)]
+                pub struct NotUnpinTupleStruct<T, U>(#[pin] pub T, pub U);
+
+                #[::pin_project::pin_project(
+                    !Unpin,
+                    project = NotUnpinEnumProj,
+                    project_ref = NotUnpinEnumProjRef,
+                )]
+                #[derive(Debug)]
+                pub enum NotUnpinEnum<T, U> {
+                    Struct {
+                        #[pin]
+                        pinned: T,
+                        unpinned: U,
+                    },
+                    Tuple(#[pin] T, U),
+                    Unit,
+                }
+            };
+        }
+
+        mac!();
+    }
+}
+
+pub mod box_pointers {
+    use pin_project::pin_project;
+
+    #[allow(box_pointers)] // for the type itself
+    #[pin_project(project_replace)]
+    #[derive(Debug)]
+    pub struct Struct {
+        #[pin]
+        pub p: Box<isize>,
+        pub u: Box<isize>,
+    }
+
+    #[allow(box_pointers)] // for the type itself
+    #[pin_project(project_replace)]
+    #[derive(Debug)]
+    pub struct TupleStruct(#[pin] pub Box<isize>, pub Box<isize>);
+
+    #[allow(box_pointers)] // for the type itself
+    #[pin_project(
+        project = EnumProj,
+        project_ref = EnumProjRef,
+        project_replace = EnumProjOwn,
+    )]
+    #[derive(Debug)]
+    pub enum Enum {
+        Struct {
+            #[pin]
+            p: Box<isize>,
+            u: Box<isize>,
+        },
+        Tuple(#[pin] Box<isize>, Box<isize>),
+        Unit,
+    }
+
+    pub mod inside_macro {
+        use pin_project::pin_project;
+
+        #[rustfmt::skip]
+        macro_rules! mac {
+            () => {
+                #[allow(box_pointers)] // for the type itself
+                #[pin_project(project_replace)]
+                #[derive(Debug)]
+                pub struct Struct {
+                    #[pin]
+                    pub p: Box<isize>,
+                    pub u: Box<isize>,
+                }
+
+                #[allow(box_pointers)] // for the type itself
+                #[pin_project(project_replace)]
+                #[derive(Debug)]
+                pub struct TupleStruct(#[pin] pub Box<isize>, pub Box<isize>);
+
+                #[allow(box_pointers)] // for the type itself
+                #[pin_project(
+                    project = EnumProj,
+                    project_ref = EnumProjRef,
+                    project_replace = EnumProjOwn,
+                )]
+                #[derive(Debug)]
+                pub enum Enum {
+                    Struct {
+                        #[pin]
+                        p: Box<isize>,
+                        u: Box<isize>,
+                    },
+                    Tuple(#[pin] Box<isize>, Box<isize>),
+                    Unit,
+                }
+            };
+        }
+
+        mac!();
+    }
+}
+
+pub mod deprecated {
+    use pin_project::pin_project;
+
+    #[allow(deprecated)] // for the type itself
+    #[pin_project(project_replace)]
+    #[derive(Debug, Clone, Copy)]
+    #[deprecated]
+    pub struct Struct {
+        #[deprecated]
+        #[pin]
+        pub p: (),
+        #[deprecated]
+        pub u: (),
+    }
+
+    #[allow(deprecated)] // for the type itself
+    #[pin_project(project_replace)]
+    #[derive(Debug, Clone, Copy)]
+    #[deprecated]
+    pub struct TupleStruct(
+        #[deprecated]
+        #[pin]
+        pub (),
+        #[deprecated] pub (),
+    );
+
+    #[allow(deprecated)] // for the type itself
+    #[pin_project(
+        project = EnumProj,
+        project_ref = EnumProjRef,
+        project_replace = EnumProjOwn,
+    )]
+    #[derive(Debug, Clone, Copy)]
+    #[deprecated]
+    pub enum Enum {
+        #[deprecated]
+        Struct {
+            #[deprecated]
+            #[pin]
+            p: (),
+            #[deprecated]
+            u: (),
+        },
+        #[deprecated]
+        Tuple(
+            #[deprecated]
+            #[pin]
+            (),
+            #[deprecated] (),
+        ),
+        #[deprecated]
+        Unit,
+    }
+
+    pub mod inside_macro {
+        use pin_project::pin_project;
+
+        #[rustfmt::skip]
+        macro_rules! mac {
+            () => {
+                #[allow(deprecated)] // for the type itself
+                #[pin_project(project_replace)]
+                #[derive(Debug, Clone, Copy)]
+                #[deprecated]
+                pub struct Struct {
+                    #[deprecated]
+                    #[pin]
+                    pub p: (),
+                    #[deprecated]
+                    pub u: (),
+                }
+
+                #[allow(deprecated)] // for the type itself
+                #[pin_project(project_replace)]
+                #[derive(Debug, Clone, Copy)]
+                #[deprecated]
+                pub struct TupleStruct(
+                    #[deprecated]
+                    #[pin]
+                    pub (),
+                    #[deprecated] pub (),
+                );
+
+                #[allow(deprecated)] // for the type itself
+                #[pin_project(
+                    project = EnumProj,
+                    project_ref = EnumProjRef,
+                    project_replace = EnumProjOwn,
+                )]
+                #[derive(Debug, Clone, Copy)]
+                #[deprecated]
+                pub enum Enum {
+                    #[deprecated]
+                    Struct {
+                        #[deprecated]
+                        #[pin]
+                        p: (),
+                        #[deprecated]
+                        u: (),
+                    },
+                    #[deprecated]
+                    Tuple(
+                        #[deprecated]
+                        #[pin]
+                        (),
+                        #[deprecated] (),
+                    ),
+                    #[deprecated]
+                    Unit,
+                }
+            };
+        }
+
+        mac!();
+    }
+}
+
+pub mod explicit_outlives_requirements {
+    use pin_project::pin_project;
+
+    #[allow(explicit_outlives_requirements)] // for the type itself: https://github.com/rust-lang/rust/issues/60993
+    #[pin_project(project_replace)]
+    #[derive(Debug)]
+    pub struct Struct<'a, T, U>
+    where
+        T: ?Sized,
+        U: ?Sized,
+    {
+        #[pin]
+        pub pinned: &'a mut T,
+        pub unpinned: &'a mut U,
+    }
+
+    #[allow(explicit_outlives_requirements)] // for the type itself: https://github.com/rust-lang/rust/issues/60993
+    #[pin_project(project_replace)]
+    #[derive(Debug)]
+    pub struct TupleStruct<'a, T, U>(#[pin] pub &'a mut T, pub &'a mut U)
+    where
+        T: ?Sized,
+        U: ?Sized;
+
+    #[allow(explicit_outlives_requirements)] // for the type itself: https://github.com/rust-lang/rust/issues/60993
+    #[pin_project(
+        project = EnumProj,
+        project_ref = EnumProjRef,
+        project_replace = EnumProjOwn,
+    )]
+    #[derive(Debug)]
+    pub enum Enum<'a, T, U>
+    where
+        T: ?Sized,
+        U: ?Sized,
+    {
+        Struct {
+            #[pin]
+            pinned: &'a mut T,
+            unpinned: &'a mut U,
+        },
+        Tuple(#[pin] &'a mut T, &'a mut U),
+        Unit,
+    }
+
+    pub mod inside_macro {
+        use pin_project::pin_project;
+
+        #[rustfmt::skip]
+        macro_rules! mac {
+            () => {
+                #[allow(explicit_outlives_requirements)] // for the type itself: https://github.com/rust-lang/rust/issues/60993
+                #[pin_project(project_replace)]
+                #[derive(Debug)]
+                pub struct Struct<'a, T, U>
+                where
+                    T: ?Sized,
+                    U: ?Sized,
+                {
+                    #[pin]
+                    pub pinned: &'a mut T,
+                    pub unpinned: &'a mut U,
+                }
+
+                #[allow(explicit_outlives_requirements)] // for the type itself: https://github.com/rust-lang/rust/issues/60993
+                #[pin_project(project_replace)]
+                #[derive(Debug)]
+                pub struct TupleStruct<'a, T, U>(#[pin] pub &'a mut T, pub &'a mut U)
+                where
+                    T: ?Sized,
+                    U: ?Sized;
+
+                #[allow(explicit_outlives_requirements)] // for the type itself: https://github.com/rust-lang/rust/issues/60993
+                #[pin_project(
+                    project = EnumProj,
+                    project_ref = EnumProjRef,
+                    project_replace = EnumProjOwn,
+                )]
+                #[derive(Debug)]
+                pub enum Enum<'a, T, U>
+                where
+                    T: ?Sized,
+                    U: ?Sized,
+                {
+                    Struct {
+                        #[pin]
+                        pinned: &'a mut T,
+                        unpinned: &'a mut U,
+                    },
+                    Tuple(#[pin] &'a mut T, &'a mut U),
+                    Unit,
+                }
+            };
+        }
+
+        mac!();
+    }
+}
+
+#[allow(missing_debug_implementations)]
+pub mod single_use_lifetimes {
+    use pin_project::pin_project;
+
+    #[allow(unused_lifetimes)]
+    pub trait Trait<'a> {}
+
+    #[allow(unused_lifetimes)] // for the type itself
+    #[allow(single_use_lifetimes)] // for the type itself: https://github.com/rust-lang/rust/issues/55058
+    #[pin_project(project_replace)]
+    pub struct Hrtb<'pin___, T>
+    where
+        for<'pin> &'pin T: Unpin,
+        T: for<'pin> Trait<'pin>,
+        for<'pin, 'pin_, 'pin__> &'pin &'pin_ &'pin__ T: Unpin,
+    {
+        #[pin]
+        _f: &'pin___ mut T,
+    }
+
+    pub mod inside_macro {
+        use pin_project::pin_project;
+
+        #[rustfmt::skip]
+        macro_rules! mac {
+            () => {
+                #[allow(unused_lifetimes)]
+                pub trait Trait<'a> {}
+
+                #[allow(unused_lifetimes)] // for the type itself
+                #[allow(single_use_lifetimes)] // for the type itself: https://github.com/rust-lang/rust/issues/55058
+                #[pin_project(project_replace)]
+                pub struct Hrtb<'pin___, T>
+                where
+                    for<'pin> &'pin T: Unpin,
+                    T: for<'pin> Trait<'pin>,
+                    for<'pin, 'pin_, 'pin__> &'pin &'pin_ &'pin__ T: Unpin,
+                {
+                    #[pin]
+                    _f: &'pin___ mut T,
+                }
+            };
+        }
+
+        mac!();
+    }
+}
+
+pub mod variant_size_differences {
+    use pin_project::pin_project;
+
+    #[allow(missing_debug_implementations, missing_copy_implementations)] // https://github.com/rust-lang/rust/pull/74060
+    #[allow(variant_size_differences)] // for the type itself
+    #[allow(clippy::large_enum_variant)] // for the type itself
+    #[pin_project(
+        project = EnumProj,
+        project_ref = EnumProjRef,
+        project_replace = EnumProjOwn,
+    )]
+    pub enum Enum {
+        V1(u8),
+        V2([u8; 1024]),
+    }
+
+    pub mod inside_macro {
+        use pin_project::pin_project;
+
+        #[rustfmt::skip]
+        macro_rules! mac {
+            () => {
+                #[allow(missing_debug_implementations, missing_copy_implementations)] // https://github.com/rust-lang/rust/pull/74060
+                #[allow(variant_size_differences)] // for the type itself
+                #[allow(clippy::large_enum_variant)] // for the type itself
+                #[pin_project(
+                    project = EnumProj,
+                    project_ref = EnumProjRef,
+                    project_replace = EnumProjOwn,
+                )]
+                pub enum Enum {
+                    V1(u8),
+                    V2([u8; 1024]),
+                }
+            };
+        }
+
+        mac!();
+    }
+}
+
+pub mod clippy_mut_mut {
+    use pin_project::pin_project;
+
+    #[pin_project(project_replace)]
+    #[derive(Debug)]
+    pub struct Struct<'a, T, U> {
+        #[pin]
+        pub pinned: &'a mut T,
+        pub unpinned: &'a mut U,
+    }
+
+    #[pin_project(project_replace)]
+    #[derive(Debug)]
+    pub struct TupleStruct<'a, T, U>(#[pin] &'a mut T, &'a mut U);
+
+    #[pin_project(
+        project = EnumProj,
+        project_ref = EnumProjRef,
+        project_replace = EnumProjOwn,
+    )]
+    #[derive(Debug)]
+    pub enum Enum<'a, T, U> {
+        Struct {
+            #[pin]
+            pinned: &'a mut T,
+            unpinned: &'a mut U,
+        },
+        Tuple(#[pin] &'a mut T, &'a mut U),
+        Unit,
+    }
+
+    pub mod inside_macro {
+        use pin_project::pin_project;
+
+        #[rustfmt::skip]
+        macro_rules! mac {
+            () => {
+                #[pin_project(project_replace)]
+                #[derive(Debug)]
+                pub struct Struct<'a, T, U> {
+                    #[pin]
+                    pub pinned: &'a mut T,
+                    pub unpinned: &'a mut U,
+                }
+
+                #[pin_project(project_replace)]
+                #[derive(Debug)]
+                pub struct TupleStruct<'a, T, U>(#[pin] &'a mut T, &'a mut U);
+
+                #[pin_project(
+                    project = EnumProj,
+                    project_ref = EnumProjRef,
+                    project_replace = EnumProjOwn,
+                )]
+                #[derive(Debug)]
+                pub enum Enum<'a, T, U> {
+                    Struct {
+                        #[pin]
+                        pinned: &'a mut T,
+                        unpinned: &'a mut U,
+                    },
+                    Tuple(#[pin] &'a mut T, &'a mut U),
+                    Unit,
+                }
+            };
+        }
+
+        mac!();
+    }
+}
+
+#[allow(missing_debug_implementations)]
+#[allow(unreachable_pub)]
+mod clippy_redundant_pub_crate {
+    use pin_project::pin_project;
+
+    #[pin_project(project_replace)]
+    pub struct Struct<T, U> {
+        #[pin]
+        pub pinned: T,
+        pub unpinned: U,
+    }
+
+    #[pin_project(project_replace)]
+    pub struct TupleStruct<T, U>(#[pin] pub T, pub U);
+
+    #[allow(dead_code)]
+    #[pin_project(
+        project = EnumProj,
+        project_ref = EnumProjRef,
+        project_replace = EnumProjOwn,
+    )]
+    pub enum Enum<T, U> {
+        Struct {
+            #[pin]
+            pinned: T,
+            unpinned: U,
+        },
+        Tuple(#[pin] T, U),
+        Unit,
+    }
+
+    pub mod inside_macro {
+        use pin_project::pin_project;
+
+        #[allow(clippy::redundant_pub_crate)]
+        #[rustfmt::skip]
+        macro_rules! mac {
+            () => {
+                #[pin_project(project_replace)]
+                pub struct Struct<T, U> {
+                    #[pin]
+                    pub pinned: T,
+                    pub unpinned: U,
+                }
+
+                #[pin_project(project_replace)]
+                pub struct TupleStruct<T, U>(#[pin] pub T, pub U);
+
+                #[allow(dead_code)]
+                #[pin_project(
+                    project = EnumProj,
+                    project_ref = EnumProjRef,
+                    project_replace = EnumProjOwn,
+                )]
+                pub enum Enum<T, U> {
+                    Struct {
+                        #[pin]
+                        pinned: T,
+                        unpinned: U,
+                    },
+                    Tuple(#[pin] T, U),
+                    Unit,
+                }
+            };
+        }
+
+        mac!();
+    }
+}
+
+#[allow(missing_debug_implementations)]
+pub mod clippy_type_repetition_in_bounds {
+    use pin_project::pin_project;
+
+    #[pin_project(project_replace)]
+    pub struct Struct<T, U>
+    where
+        Self: Sized,
+    {
+        #[pin]
+        pub pinned: T,
+        pub unpinned: U,
+    }
+
+    #[pin_project(project_replace)]
+    pub struct TupleStruct<T, U>(#[pin] T, U)
+    where
+        Self: Sized;
+
+    #[pin_project(
+        project = EnumProj,
+        project_ref = EnumProjRef,
+        project_replace = EnumProjOwn,
+    )]
+    pub enum Enum<T, U>
+    where
+        Self: Sized,
+    {
+        Struct {
+            #[pin]
+            pinned: T,
+            unpinned: U,
+        },
+        Tuple(#[pin] T, U),
+        Unit,
+    }
+
+    pub mod inside_macro {
+        use pin_project::pin_project;
+
+        #[rustfmt::skip]
+        macro_rules! mac {
+            () => {
+                #[pin_project(project_replace)]
+                pub struct Struct<T, U>
+                where
+                    Self: Sized,
+                {
+                    #[pin]
+                    pub pinned: T,
+                    pub unpinned: U,
+                }
+
+                #[pin_project(project_replace)]
+                pub struct TupleStruct<T, U>(#[pin] T, U)
+                where
+                    Self: Sized;
+
+                #[pin_project(
+                    project = EnumProj,
+                    project_ref = EnumProjRef,
+                    project_replace = EnumProjOwn,
+                )]
+                pub enum Enum<T, U>
+                where
+                    Self: Sized,
+                {
+                    Struct {
+                        #[pin]
+                        pinned: T,
+                        unpinned: U,
+                    },
+                    Tuple(#[pin] T, U),
+                    Unit,
+                }
+            };
+        }
+
+        mac!();
+    }
+}
+
+#[allow(missing_debug_implementations)]
+pub mod clippy_use_self {
+    use pin_project::pin_project;
+
+    pub trait Trait {
+        type Assoc;
+    }
+
+    #[pin_project(project_replace)]
+    pub struct Generics<T: Trait<Assoc = Self>>
+    where
+        Self: Trait<Assoc = Self>,
+    {
+        _f: T,
+    }
+
+    pub mod inside_macro {
+        use pin_project::pin_project;
+
+        use super::Trait;
+
+        #[rustfmt::skip]
+        macro_rules! mac {
+            () => {
+                #[pin_project(project_replace)]
+                pub struct Generics<T: Trait<Assoc = Self>>
+                where
+                    Self: Trait<Assoc = Self>,
+                {
+                    _f: T,
+                }
+            };
+        }
+
+        mac!();
+    }
+}
+
+#[allow(missing_debug_implementations)]
+pub mod clippy_used_underscore_binding {
+    use pin_project::pin_project;
+
+    #[pin_project(project_replace)]
+    pub struct Struct<T, U> {
+        #[pin]
+        pub _pinned: T,
+        pub _unpinned: U,
+    }
+
+    #[pin_project(
+        project = EnumProj,
+        project_ref = EnumProjRef,
+        project_replace = EnumProjOwn,
+    )]
+    pub enum Enum<T, U> {
+        Struct {
+            #[pin]
+            _pinned: T,
+            _unpinned: U,
+        },
+    }
+
+    pub mod inside_macro {
+        use pin_project::pin_project;
+
+        #[rustfmt::skip]
+        macro_rules! mac {
+            () => {
+                #[pin_project(project_replace)]
+                pub struct Struct<T, U> {
+                    #[pin]
+                    pub _pinned: T,
+                    pub _unpinned: U,
+                }
+
+                #[pin_project(
+                    project = EnumProj,
+                    project_ref = EnumProjRef,
+                    project_replace = EnumProjOwn,
+                )]
+                pub enum Enum<T, U> {
+                    Struct {
+                        #[pin]
+                        _pinned: T,
+                        _unpinned: U,
+                    },
+                }
+            };
+        }
+
+        mac!();
+    }
+}
+
+#[allow(missing_debug_implementations)]
+pub mod clippy_ref_option_ref {
+    use pin_project::pin_project;
+
+    #[pin_project]
+    pub struct Struct<'a> {
+        #[pin]
+        pub _pinned: Option<&'a ()>,
+        pub _unpinned: Option<&'a ()>,
+    }
+
+    #[pin_project(project = EnumProj, project_ref = EnumProjRef)]
+    pub enum Enum<'a> {
+        Struct {
+            #[pin]
+            _pinned: Option<&'a ()>,
+            _unpinned: Option<&'a ()>,
+        },
+    }
+}
diff --git a/crates/pin-project/tests/pin_project.rs b/crates/pin-project/tests/pin_project.rs
new file mode 100644
index 0000000..cbc67ce
--- /dev/null
+++ b/crates/pin-project/tests/pin_project.rs
@@ -0,0 +1,888 @@
+#![warn(rust_2018_idioms, single_use_lifetimes)]
+#![allow(dead_code)]
+
+#[macro_use]
+mod auxiliary;
+
+use std::{
+    marker::{PhantomData, PhantomPinned},
+    panic,
+    pin::Pin,
+};
+
+use pin_project::{pin_project, pinned_drop, UnsafeUnpin};
+
+#[test]
+fn projection() {
+    #[pin_project(
+        project = StructProj,
+        project_ref = StructProjRef,
+        project_replace = StructProjOwn,
+    )]
+    struct Struct<T, U> {
+        #[pin]
+        f1: T,
+        f2: U,
+    }
+
+    let mut s = Struct { f1: 1, f2: 2 };
+    let mut s_orig = Pin::new(&mut s);
+    let s = s_orig.as_mut().project();
+
+    let _: Pin<&mut i32> = s.f1;
+    assert_eq!(*s.f1, 1);
+    let _: &mut i32 = s.f2;
+    assert_eq!(*s.f2, 2);
+
+    assert_eq!(s_orig.as_ref().f1, 1);
+    assert_eq!(s_orig.as_ref().f2, 2);
+
+    let mut s = Struct { f1: 1, f2: 2 };
+    let mut s = Pin::new(&mut s);
+    {
+        let StructProj { f1, f2 } = s.as_mut().project();
+        let _: Pin<&mut i32> = f1;
+        let _: &mut i32 = f2;
+    }
+    {
+        let StructProjRef { f1, f2 } = s.as_ref().project_ref();
+        let _: Pin<&i32> = f1;
+        let _: &i32 = f2;
+    }
+    {
+        let StructProjOwn { f1, f2 } = s.as_mut().project_replace(Struct { f1: 3, f2: 4 });
+        let _: PhantomData<i32> = f1;
+        let _: i32 = f2;
+        assert_eq!(f2, 2);
+        assert_eq!(s.f1, 3);
+        assert_eq!(s.f2, 4);
+    }
+
+    #[pin_project(project_replace)]
+    struct TupleStruct<T, U>(#[pin] T, U);
+
+    let mut s = TupleStruct(1, 2);
+    let s = Pin::new(&mut s).project();
+
+    let _: Pin<&mut i32> = s.0;
+    assert_eq!(*s.0, 1);
+    let _: &mut i32 = s.1;
+    assert_eq!(*s.1, 2);
+
+    #[pin_project(project = EnumProj, project_ref = EnumProjRef, project_replace = EnumProjOwn)]
+    #[derive(Eq, PartialEq, Debug)]
+    enum Enum<A, B, C, D> {
+        Tuple(#[pin] A, B),
+        Struct {
+            #[pin]
+            f1: C,
+            f2: D,
+        },
+        Unit,
+    }
+
+    let mut e = Enum::Tuple(1, 2);
+    let mut e = Pin::new(&mut e);
+
+    match e.as_mut().project() {
+        EnumProj::Tuple(x, y) => {
+            let x: Pin<&mut i32> = x;
+            assert_eq!(*x, 1);
+            let y: &mut i32 = y;
+            assert_eq!(*y, 2);
+        }
+        EnumProj::Struct { f1, f2 } => {
+            let _: Pin<&mut i32> = f1;
+            let _: &mut i32 = f2;
+            unreachable!();
+        }
+        EnumProj::Unit => unreachable!(),
+    }
+
+    assert_eq!(&*e, &Enum::Tuple(1, 2));
+
+    let mut e = Enum::Struct { f1: 3, f2: 4 };
+    let mut e = Pin::new(&mut e);
+
+    match e.as_mut().project() {
+        EnumProj::Tuple(x, y) => {
+            let _: Pin<&mut i32> = x;
+            let _: &mut i32 = y;
+            unreachable!();
+        }
+        EnumProj::Struct { f1, f2 } => {
+            let _: Pin<&mut i32> = f1;
+            assert_eq!(*f1, 3);
+            let _: &mut i32 = f2;
+            assert_eq!(*f2, 4);
+        }
+        EnumProj::Unit => unreachable!(),
+    }
+
+    if let EnumProj::Struct { f1, f2 } = e.as_mut().project() {
+        let _: Pin<&mut i32> = f1;
+        assert_eq!(*f1, 3);
+        let _: &mut i32 = f2;
+        assert_eq!(*f2, 4);
+    }
+}
+
+#[test]
+fn enum_project_set() {
+    #[pin_project(project = EnumProj, project_ref = EnumProjRef, project_replace = EnumProjOwn)]
+    #[derive(Eq, PartialEq, Debug)]
+    enum Enum {
+        V1(#[pin] u8),
+        V2(bool),
+    }
+
+    let mut e = Enum::V1(25);
+    let mut e_orig = Pin::new(&mut e);
+    let e_proj = e_orig.as_mut().project();
+
+    match e_proj {
+        EnumProj::V1(val) => {
+            let new_e = Enum::V2(val.as_ref().get_ref() == &25);
+            e_orig.set(new_e);
+        }
+        EnumProj::V2(_) => unreachable!(),
+    }
+
+    assert_eq!(e, Enum::V2(true));
+}
+
+#[test]
+fn where_clause() {
+    #[pin_project]
+    struct Struct<T>
+    where
+        T: Copy,
+    {
+        f: T,
+    }
+
+    #[pin_project]
+    struct TupleStruct<T>(T)
+    where
+        T: Copy;
+
+    #[pin_project(project = EnumProj, project_ref = EnumProjRef, project_replace = EnumProjOwn)]
+    enum Enum<T>
+    where
+        T: Copy,
+    {
+        V(T),
+    }
+}
+
+#[test]
+fn where_clause_and_associated_type_field() {
+    #[pin_project(project_replace)]
+    struct Struct1<I>
+    where
+        I: Iterator,
+    {
+        #[pin]
+        f1: I,
+        f2: I::Item,
+    }
+
+    #[pin_project(project_replace)]
+    struct Struct2<I, J>
+    where
+        I: Iterator<Item = J>,
+    {
+        #[pin]
+        f1: I,
+        f2: J,
+    }
+
+    #[pin_project(project_replace)]
+    struct Struct3<T>
+    where
+        T: 'static,
+    {
+        f: T,
+    }
+
+    trait Static: 'static {}
+
+    impl<T> Static for Struct3<T> {}
+
+    #[pin_project(project_replace)]
+    struct TupleStruct<I>(#[pin] I, I::Item)
+    where
+        I: Iterator;
+
+    #[pin_project(project = EnumProj, project_ref = EnumProjRef, project_replace = EnumProjOwn)]
+    enum Enum<I>
+    where
+        I: Iterator,
+    {
+        V1(#[pin] I),
+        V2(I::Item),
+    }
+}
+
+#[test]
+fn derive_copy() {
+    #[pin_project(project_replace)]
+    #[derive(Clone, Copy)]
+    struct Struct<T> {
+        f: T,
+    }
+
+    fn is_copy<T: Copy>() {}
+
+    is_copy::<Struct<u8>>();
+}
+
+#[test]
+fn move_out() {
+    struct NotCopy;
+
+    #[pin_project(project_replace)]
+    struct Struct {
+        f: NotCopy,
+    }
+
+    let x = Struct { f: NotCopy };
+    let _val: NotCopy = x.f;
+
+    #[pin_project(project = EnumProj, project_ref = EnumProjRef, project_replace = EnumProjOwn)]
+    enum Enum {
+        V(NotCopy),
+    }
+
+    let x = Enum::V(NotCopy);
+    #[allow(clippy::infallible_destructuring_match)]
+    let _val: NotCopy = match x {
+        Enum::V(val) => val,
+    };
+}
+
+#[test]
+fn trait_bounds_on_type_generics() {
+    #[pin_project(project_replace)]
+    pub struct Struct1<'a, T: ?Sized> {
+        f: &'a mut T,
+    }
+
+    #[pin_project(project_replace)]
+    pub struct Struct2<'a, T: ::core::fmt::Debug> {
+        f: &'a mut T,
+    }
+
+    #[pin_project(project_replace)]
+    pub struct Struct3<'a, T: core::fmt::Debug> {
+        f: &'a mut T,
+    }
+
+    #[pin_project(project_replace)]
+    pub struct Struct4<'a, T: core::fmt::Debug + core::fmt::Display> {
+        f: &'a mut T,
+    }
+
+    #[pin_project(project_replace)]
+    pub struct Struct5<'a, T: core::fmt::Debug + ?Sized> {
+        f: &'a mut T,
+    }
+
+    #[pin_project(project_replace)]
+    pub struct Struct6<'a, T: core::fmt::Debug = [u8; 16]> {
+        f: &'a mut T,
+    }
+
+    let _: Struct6<'_> = Struct6 { f: &mut [0_u8; 16] };
+
+    #[pin_project(project_replace)]
+    pub struct Struct7<T: 'static> {
+        f: T,
+    }
+
+    trait Static: 'static {}
+
+    impl<T> Static for Struct7<T> {}
+
+    #[pin_project(project_replace)]
+    pub struct Struct8<'a, 'b: 'a> {
+        f1: &'a u8,
+        f2: &'b u8,
+    }
+
+    #[pin_project(project_replace)]
+    pub struct TupleStruct<'a, T: ?Sized>(&'a mut T);
+
+    #[pin_project(project = EnumProj, project_ref = EnumProjRef, project_replace = EnumProjOwn)]
+    enum Enum<'a, T: ?Sized> {
+        V(&'a mut T),
+    }
+}
+
+#[test]
+fn overlapping_lifetime_names() {
+    #[pin_project(project_replace)]
+    pub struct Struct1<'pin, T> {
+        #[pin]
+        f: &'pin mut T,
+    }
+
+    #[pin_project(project_replace)]
+    pub struct Struct2<'pin, 'pin_, 'pin__> {
+        #[pin]
+        f: &'pin &'pin_ &'pin__ (),
+    }
+
+    pub trait Trait<'a> {}
+
+    #[allow(single_use_lifetimes)] // https://github.com/rust-lang/rust/issues/55058
+    #[pin_project(project_replace)]
+    pub struct Hrtb<'pin___, T>
+    where
+        for<'pin> &'pin T: Unpin,
+        T: for<'pin> Trait<'pin>,
+        for<'pin, 'pin_, 'pin__> &'pin &'pin_ &'pin__ T: Unpin,
+    {
+        #[pin]
+        f: &'pin___ mut T,
+    }
+
+    #[pin_project(PinnedDrop)]
+    pub struct PinnedDropStruct<'pin> {
+        #[pin]
+        f: &'pin (),
+    }
+
+    #[pinned_drop]
+    impl PinnedDrop for PinnedDropStruct<'_> {
+        fn drop(self: Pin<&mut Self>) {}
+    }
+
+    #[pin_project(UnsafeUnpin)]
+    pub struct UnsafeUnpinStruct<'pin> {
+        #[pin]
+        f: &'pin (),
+    }
+
+    unsafe impl UnsafeUnpin for UnsafeUnpinStruct<'_> {}
+
+    #[pin_project(!Unpin)]
+    pub struct NotUnpinStruct<'pin> {
+        #[pin]
+        f: &'pin (),
+    }
+}
+
+#[test]
+fn combine() {
+    #[pin_project(PinnedDrop, UnsafeUnpin)]
+    pub struct PinnedDropWithUnsafeUnpin<T> {
+        #[pin]
+        f: T,
+    }
+
+    #[pinned_drop]
+    impl<T> PinnedDrop for PinnedDropWithUnsafeUnpin<T> {
+        fn drop(self: Pin<&mut Self>) {}
+    }
+
+    unsafe impl<T: Unpin> UnsafeUnpin for PinnedDropWithUnsafeUnpin<T> {}
+
+    #[pin_project(PinnedDrop, !Unpin)]
+    pub struct PinnedDropWithNotUnpin<T> {
+        #[pin]
+        f: T,
+    }
+
+    #[pinned_drop]
+    impl<T> PinnedDrop for PinnedDropWithNotUnpin<T> {
+        fn drop(self: Pin<&mut Self>) {}
+    }
+
+    #[pin_project(UnsafeUnpin, project_replace)]
+    pub struct UnsafeUnpinWithReplace<T> {
+        #[pin]
+        f: T,
+    }
+
+    unsafe impl<T: Unpin> UnsafeUnpin for UnsafeUnpinWithReplace<T> {}
+
+    #[pin_project(!Unpin, project_replace)]
+    pub struct NotUnpinWithReplace<T> {
+        #[pin]
+        f: T,
+    }
+}
+
+#[test]
+fn private_type_in_public_type() {
+    #[pin_project(project_replace)]
+    pub struct PublicStruct<T> {
+        #[pin]
+        inner: PrivateStruct<T>,
+    }
+
+    struct PrivateStruct<T>(T);
+}
+
+#[allow(clippy::needless_lifetimes)]
+#[test]
+fn lifetime_project() {
+    #[pin_project(project_replace)]
+    struct Struct1<T, U> {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    }
+
+    #[pin_project(project_replace)]
+    struct Struct2<'a, T, U> {
+        #[pin]
+        pinned: &'a T,
+        unpinned: U,
+    }
+
+    #[pin_project(project = EnumProj, project_ref = EnumProjRef, project_replace = EnumProjOwn)]
+    enum Enum<T, U> {
+        V {
+            #[pin]
+            pinned: T,
+            unpinned: U,
+        },
+    }
+
+    impl<T, U> Struct1<T, U> {
+        fn get_pin_ref<'a>(self: Pin<&'a Self>) -> Pin<&'a T> {
+            self.project_ref().pinned
+        }
+        fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut T> {
+            self.project().pinned
+        }
+        fn get_pin_ref_elided(self: Pin<&Self>) -> Pin<&T> {
+            self.project_ref().pinned
+        }
+        fn get_pin_mut_elided(self: Pin<&mut Self>) -> Pin<&mut T> {
+            self.project().pinned
+        }
+    }
+
+    impl<'b, T, U> Struct2<'b, T, U> {
+        fn get_pin_ref<'a>(self: Pin<&'a Self>) -> Pin<&'a &'b T> {
+            self.project_ref().pinned
+        }
+        fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut &'b T> {
+            self.project().pinned
+        }
+        fn get_pin_ref_elided(self: Pin<&Self>) -> Pin<&&'b T> {
+            self.project_ref().pinned
+        }
+        fn get_pin_mut_elided(self: Pin<&mut Self>) -> Pin<&mut &'b T> {
+            self.project().pinned
+        }
+    }
+
+    impl<T, U> Enum<T, U> {
+        fn get_pin_ref<'a>(self: Pin<&'a Self>) -> Pin<&'a T> {
+            match self.project_ref() {
+                EnumProjRef::V { pinned, .. } => pinned,
+            }
+        }
+        fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut T> {
+            match self.project() {
+                EnumProj::V { pinned, .. } => pinned,
+            }
+        }
+        fn get_pin_ref_elided(self: Pin<&Self>) -> Pin<&T> {
+            match self.project_ref() {
+                EnumProjRef::V { pinned, .. } => pinned,
+            }
+        }
+        fn get_pin_mut_elided(self: Pin<&mut Self>) -> Pin<&mut T> {
+            match self.project() {
+                EnumProj::V { pinned, .. } => pinned,
+            }
+        }
+    }
+}
+
+mod visibility {
+    use pin_project::pin_project;
+
+    #[pin_project(project_replace)]
+    pub(crate) struct S {
+        pub f: u8,
+    }
+}
+
+#[test]
+fn visibility() {
+    let mut x = visibility::S { f: 0 };
+    let x = Pin::new(&mut x);
+    let y = x.as_ref().project_ref();
+    let _: &u8 = y.f;
+    let y = x.project();
+    let _: &mut u8 = y.f;
+}
+
+#[test]
+fn trivial_bounds() {
+    #[pin_project(project_replace)]
+    pub struct NoGenerics {
+        #[pin]
+        f: PhantomPinned,
+    }
+
+    assert_not_unpin!(NoGenerics);
+}
+
+#[test]
+fn dst() {
+    #[pin_project]
+    struct Struct1<T: ?Sized> {
+        f: T,
+    }
+
+    let mut x = Struct1 { f: 0_u8 };
+    let x: Pin<&mut Struct1<dyn core::fmt::Debug>> = Pin::new(&mut x as _);
+    let _: &mut (dyn core::fmt::Debug) = x.project().f;
+
+    #[pin_project]
+    struct Struct2<T: ?Sized> {
+        #[pin]
+        f: T,
+    }
+
+    let mut x = Struct2 { f: 0_u8 };
+    let x: Pin<&mut Struct2<dyn core::fmt::Debug + Unpin>> = Pin::new(&mut x as _);
+    let _: Pin<&mut (dyn core::fmt::Debug + Unpin)> = x.project().f;
+
+    #[allow(explicit_outlives_requirements)] // https://github.com/rust-lang/rust/issues/60993
+    #[pin_project]
+    struct Struct3<T>
+    where
+        T: ?Sized,
+    {
+        f: T,
+    }
+
+    #[allow(explicit_outlives_requirements)] // https://github.com/rust-lang/rust/issues/60993
+    #[pin_project]
+    struct Struct4<T>
+    where
+        T: ?Sized,
+    {
+        #[pin]
+        f: T,
+    }
+
+    #[pin_project(UnsafeUnpin)]
+    struct Struct5<T: ?Sized> {
+        f: T,
+    }
+
+    #[pin_project(UnsafeUnpin)]
+    struct Struct6<T: ?Sized> {
+        #[pin]
+        f: T,
+    }
+
+    #[pin_project(PinnedDrop)]
+    struct Struct7<T: ?Sized> {
+        f: T,
+    }
+
+    #[pinned_drop]
+    impl<T: ?Sized> PinnedDrop for Struct7<T> {
+        fn drop(self: Pin<&mut Self>) {}
+    }
+
+    #[pin_project(PinnedDrop)]
+    struct Struct8<T: ?Sized> {
+        #[pin]
+        f: T,
+    }
+
+    #[pinned_drop]
+    impl<T: ?Sized> PinnedDrop for Struct8<T> {
+        fn drop(self: Pin<&mut Self>) {}
+    }
+
+    #[pin_project(!Unpin)]
+    struct Struct9<T: ?Sized> {
+        f: T,
+    }
+
+    #[pin_project(!Unpin)]
+    struct Struct10<T: ?Sized> {
+        #[pin]
+        f: T,
+    }
+
+    #[pin_project]
+    struct Struct11<'a, T: ?Sized, U: ?Sized> {
+        f1: &'a mut T,
+        f2: U,
+    }
+
+    #[pin_project]
+    struct TupleStruct1<T: ?Sized>(T);
+
+    #[pin_project]
+    struct TupleStruct2<T: ?Sized>(#[pin] T);
+
+    #[allow(explicit_outlives_requirements)] // https://github.com/rust-lang/rust/issues/60993
+    #[pin_project]
+    struct TupleStruct3<T>(T)
+    where
+        T: ?Sized;
+
+    #[allow(explicit_outlives_requirements)] // https://github.com/rust-lang/rust/issues/60993
+    #[pin_project]
+    struct TupleStruct4<T>(#[pin] T)
+    where
+        T: ?Sized;
+
+    #[pin_project(UnsafeUnpin)]
+    struct TupleStruct5<T: ?Sized>(T);
+
+    #[pin_project(UnsafeUnpin)]
+    struct TupleStruct6<T: ?Sized>(#[pin] T);
+
+    #[pin_project(PinnedDrop)]
+    struct TupleStruct7<T: ?Sized>(T);
+
+    #[pinned_drop]
+    impl<T: ?Sized> PinnedDrop for TupleStruct7<T> {
+        fn drop(self: Pin<&mut Self>) {}
+    }
+
+    #[pin_project(PinnedDrop)]
+    struct TupleStruct8<T: ?Sized>(#[pin] T);
+
+    #[pinned_drop]
+    impl<T: ?Sized> PinnedDrop for TupleStruct8<T> {
+        fn drop(self: Pin<&mut Self>) {}
+    }
+
+    #[pin_project(!Unpin)]
+    struct TupleStruct9<T: ?Sized>(T);
+
+    #[pin_project(!Unpin)]
+    struct TupleStruct10<T: ?Sized>(#[pin] T);
+
+    #[pin_project]
+    struct TupleStruct11<'a, T: ?Sized, U: ?Sized>(&'a mut T, U);
+}
+
+#[test]
+fn dyn_type() {
+    #[pin_project]
+    struct Struct1 {
+        f: dyn core::fmt::Debug,
+    }
+
+    #[pin_project]
+    struct Struct2 {
+        #[pin]
+        f: dyn core::fmt::Debug,
+    }
+
+    #[pin_project]
+    struct Struct3 {
+        f: dyn core::fmt::Debug + Send,
+    }
+
+    #[pin_project]
+    struct Struct4 {
+        #[pin]
+        f: dyn core::fmt::Debug + Send,
+    }
+
+    #[pin_project]
+    struct TupleStruct1(dyn core::fmt::Debug);
+
+    #[pin_project]
+    struct TupleStruct2(#[pin] dyn core::fmt::Debug);
+
+    #[pin_project]
+    struct TupleStruct3(dyn core::fmt::Debug + Send);
+
+    #[pin_project]
+    struct TupleStruct4(#[pin] dyn core::fmt::Debug + Send);
+}
+
+#[allow(clippy::trailing_empty_array)] // TODO: how do we handle this? Should propagate #[repr(...)] to ProjectionOwned?
+#[test]
+fn parse_self() {
+    macro_rules! mac {
+        ($($tt:tt)*) => {
+            $($tt)*
+        };
+    }
+
+    pub trait Trait {
+        type Assoc;
+    }
+
+    #[allow(clippy::type_repetition_in_bounds)]
+    #[pin_project(project_replace)]
+    pub struct Generics<T: Trait<Assoc = Self>>
+    where
+        Self: Trait<Assoc = Self>,
+        <Self as Trait>::Assoc: Sized,
+        mac!(Self): Trait<Assoc = mac!(Self)>,
+    {
+        _f: T,
+    }
+
+    impl<T: Trait<Assoc = Self>> Trait for Generics<T> {
+        type Assoc = Self;
+    }
+
+    #[pin_project(project_replace)]
+    pub struct Struct {
+        _f1: Box<Self>,
+        _f2: Box<<Self as Trait>::Assoc>,
+        _f3: Box<mac!(Self)>,
+        _f4: [(); Self::ASSOC],
+        _f5: [(); Self::assoc()],
+        _f6: [(); mac!(Self::assoc())],
+    }
+
+    impl Struct {
+        const ASSOC: usize = 1;
+        const fn assoc() -> usize {
+            0
+        }
+    }
+
+    impl Trait for Struct {
+        type Assoc = Self;
+    }
+
+    #[pin_project(project_replace)]
+    struct Tuple(
+        Box<Self>,
+        Box<<Self as Trait>::Assoc>,
+        Box<mac!(Self)>,
+        [(); Self::ASSOC],
+        [(); Self::assoc()],
+        [(); mac!(Self::assoc())],
+    );
+
+    impl Tuple {
+        const ASSOC: usize = 1;
+        const fn assoc() -> usize {
+            0
+        }
+    }
+
+    impl Trait for Tuple {
+        type Assoc = Self;
+    }
+
+    #[pin_project(project = EnumProj, project_ref = EnumProjRef, project_replace = EnumProjOwn)]
+    enum Enum {
+        Struct {
+            _f1: Box<Self>,
+            _f2: Box<<Self as Trait>::Assoc>,
+            _f3: Box<mac!(Self)>,
+            _f4: [(); Self::ASSOC],
+            _f5: [(); Self::assoc()],
+            _f6: [(); mac!(Self::assoc())],
+        },
+        Tuple(
+            Box<Self>,
+            Box<<Self as Trait>::Assoc>,
+            Box<mac!(Self)>,
+            [(); Self::ASSOC],
+            [(); Self::assoc()],
+            [(); mac!(Self::assoc())],
+        ),
+    }
+
+    impl Enum {
+        const ASSOC: usize = 1;
+        const fn assoc() -> usize {
+            0
+        }
+    }
+
+    impl Trait for Enum {
+        type Assoc = Self;
+    }
+}
+
+#[test]
+fn no_infer_outlives() {
+    trait Trait<X> {
+        type Y;
+    }
+
+    struct Struct1<A>(A);
+
+    impl<X, T> Trait<X> for Struct1<T> {
+        type Y = Option<T>;
+    }
+
+    #[pin_project(project_replace)]
+    struct Struct2<A, B> {
+        _f: <Struct1<A> as Trait<B>>::Y,
+    }
+}
+
+// https://github.com/rust-lang/rust/issues/47949
+// https://github.com/taiki-e/pin-project/pull/194#discussion_r419098111
+#[allow(clippy::many_single_char_names)]
+#[test]
+fn project_replace_panic() {
+    #[pin_project(project_replace)]
+    struct S<T, U> {
+        #[pin]
+        pinned: T,
+        unpinned: U,
+    }
+
+    struct D<'a>(&'a mut bool, bool);
+    impl Drop for D<'_> {
+        fn drop(&mut self) {
+            *self.0 = true;
+            if self.1 {
+                panic!();
+            }
+        }
+    }
+
+    let (mut a, mut b, mut c, mut d) = (false, false, false, false);
+    let res = panic::catch_unwind(panic::AssertUnwindSafe(|| {
+        let mut x = S { pinned: D(&mut a, true), unpinned: D(&mut b, false) };
+        let _y = Pin::new(&mut x)
+            .project_replace(S { pinned: D(&mut c, false), unpinned: D(&mut d, false) });
+        // Previous `x.pinned` was dropped and panicked when `project_replace` is
+        // called, so this is unreachable.
+        unreachable!();
+    }));
+    assert!(res.is_err());
+    assert!(a);
+    assert!(b);
+    assert!(c);
+    assert!(d);
+
+    let (mut a, mut b, mut c, mut d) = (false, false, false, false);
+    let res = panic::catch_unwind(panic::AssertUnwindSafe(|| {
+        let mut x = S { pinned: D(&mut a, false), unpinned: D(&mut b, true) };
+        {
+            let _y = Pin::new(&mut x)
+                .project_replace(S { pinned: D(&mut c, false), unpinned: D(&mut d, false) });
+            // `_y` (previous `x.unpinned`) live to the end of this scope, so
+            // this is not unreachable.
+            // unreachable!();
+        }
+        unreachable!();
+    }));
+    assert!(res.is_err());
+    assert!(a);
+    assert!(b);
+    assert!(c);
+    assert!(d);
+}
diff --git a/crates/pin-project/tests/pinned_drop.rs b/crates/pin-project/tests/pinned_drop.rs
new file mode 100644
index 0000000..c907cc2
--- /dev/null
+++ b/crates/pin-project/tests/pinned_drop.rs
@@ -0,0 +1,283 @@
+#![warn(rust_2018_idioms, single_use_lifetimes)]
+
+use std::pin::Pin;
+
+use pin_project::{pin_project, pinned_drop};
+
+#[test]
+fn safe_project() {
+    #[pin_project(PinnedDrop)]
+    pub struct Struct<'a> {
+        was_dropped: &'a mut bool,
+        #[pin]
+        field: u8,
+    }
+
+    #[pinned_drop]
+    impl PinnedDrop for Struct<'_> {
+        fn drop(self: Pin<&mut Self>) {
+            **self.project().was_dropped = true;
+        }
+    }
+
+    let mut was_dropped = false;
+    drop(Struct { was_dropped: &mut was_dropped, field: 42 });
+    assert!(was_dropped);
+}
+
+#[test]
+fn self_call() {
+    #[pin_project(PinnedDrop)]
+    pub struct S<T>(T);
+
+    trait Trait {
+        fn self_ref(&self) {}
+        fn self_pin_ref(self: Pin<&Self>) {}
+        fn self_mut(&mut self) {}
+        fn self_pin_mut(self: Pin<&mut Self>) {}
+        fn assoc_fn(_this: Pin<&mut Self>) {}
+    }
+
+    impl<T> Trait for S<T> {}
+
+    #[pinned_drop]
+    impl<T> PinnedDrop for S<T> {
+        fn drop(mut self: Pin<&mut Self>) {
+            self.self_ref();
+            self.as_ref().self_pin_ref();
+            self.self_mut();
+            self.as_mut().self_pin_mut();
+            Self::assoc_fn(self.as_mut());
+            <Self>::assoc_fn(self.as_mut());
+        }
+    }
+}
+
+#[test]
+fn self_ty() {
+    #[pin_project(PinnedDrop)]
+    pub struct Struct {
+        pub f: (),
+    }
+
+    #[pinned_drop]
+    impl PinnedDrop for Struct {
+        #[allow(irrefutable_let_patterns)]
+        #[allow(clippy::match_single_binding)]
+        fn drop(mut self: Pin<&mut Self>) {
+            // expr
+            let _: Self = Self { f: () };
+
+            // pat
+            match *self {
+                Self { f: () } => {}
+            }
+            if let Self { f: () } = *self {}
+            let Self { f: () } = *self;
+        }
+    }
+
+    #[pin_project(PinnedDrop)]
+    pub struct TupleStruct(());
+
+    #[pinned_drop]
+    impl PinnedDrop for TupleStruct {
+        #[allow(irrefutable_let_patterns)]
+        fn drop(mut self: Pin<&mut Self>) {
+            // expr
+            let _: Self = Self(());
+
+            // pat
+            match *self {
+                Self(_) => {}
+            }
+            if let Self(_) = *self {}
+            let Self(_) = *self;
+        }
+    }
+
+    #[pin_project(PinnedDrop, project = EnumProj, project_ref = EnumProjRef)]
+    pub enum Enum {
+        Struct { f: () },
+        Tuple(()),
+        Unit,
+    }
+
+    #[pinned_drop]
+    impl PinnedDrop for Enum {
+        fn drop(mut self: Pin<&mut Self>) {
+            // expr
+            let _: Self = Self::Struct { f: () };
+            let _: Self = Self::Tuple(());
+            let _: Self = Self::Unit;
+
+            // pat
+            match *self {
+                Self::Struct { f: () } => {}
+                Self::Tuple(_) => {}
+                Self::Unit => {}
+            }
+            if let Self::Struct { f: () } = *self {}
+            if let Self::Tuple(_) = *self {}
+            if let Self::Unit = *self {}
+        }
+    }
+}
+
+#[test]
+fn self_inside_macro_containing_fn() {
+    macro_rules! mac {
+        ($($tt:tt)*) => {
+            $($tt)*
+        };
+    }
+
+    #[pin_project(PinnedDrop)]
+    pub struct S(());
+
+    #[pinned_drop]
+    impl PinnedDrop for S {
+        fn drop(self: Pin<&mut Self>) {
+            mac!({
+                impl S {
+                    pub fn _f(self) -> Self {
+                        self
+                    }
+                }
+            });
+        }
+    }
+}
+
+// See also `ui/pinned_drop/self.rs`.
+#[test]
+fn self_inside_macro_def() {
+    #[pin_project(PinnedDrop)]
+    pub struct S(());
+
+    #[pinned_drop]
+    impl PinnedDrop for S {
+        fn drop(self: Pin<&mut Self>) {
+            macro_rules! mac {
+                () => {{
+                    let _ = self;
+                    let _ = Self(());
+                }};
+            }
+            mac!();
+        }
+    }
+}
+
+#[test]
+fn self_arg_inside_macro_call() {
+    #[pin_project(PinnedDrop)]
+    struct Struct {
+        f: (),
+    }
+
+    #[pinned_drop]
+    impl PinnedDrop for Struct {
+        fn drop(self: Pin<&mut Self>) {
+            let _: Vec<_> = vec![self.f];
+        }
+    }
+}
+
+#[test]
+fn self_ty_inside_macro_call() {
+    macro_rules! mac {
+        ($($tt:tt)*) => {
+            $($tt)*
+        };
+    }
+
+    #[pin_project(PinnedDrop)]
+    pub struct Struct<T: Send>
+    where
+        mac!(Self): Send,
+    {
+        _f: T,
+    }
+
+    impl<T: Send> Struct<T> {
+        const ASSOC1: usize = 1;
+        fn assoc1() {}
+    }
+
+    trait Trait {
+        type Assoc2;
+        const ASSOC2: usize;
+        fn assoc2();
+    }
+
+    impl<T: Send> Trait for Struct<T> {
+        type Assoc2 = u8;
+        const ASSOC2: usize = 2;
+        fn assoc2() {}
+    }
+
+    #[pinned_drop]
+    impl<T: Send> PinnedDrop for Struct<T>
+    where
+        mac!(Self): Send,
+    {
+        #[allow(path_statements)]
+        #[allow(clippy::no_effect)]
+        fn drop(self: Pin<&mut Self>) {
+            // inherent items
+            mac!(Self::ASSOC1;);
+            mac!(<Self>::ASSOC1;);
+            mac!(Self::assoc1(););
+            mac!(<Self>::assoc1(););
+
+            // trait items
+            mac!(let _: <Self as Trait>::Assoc2;);
+            mac!(Self::ASSOC2;);
+            mac!(<Self>::ASSOC2;);
+            mac!(<Self as Trait>::ASSOC2;);
+            mac!(Self::assoc2(););
+            mac!(<Self>::assoc2(););
+            mac!(<Self as Trait>::assoc2(););
+        }
+    }
+}
+
+#[test]
+fn inside_macro() {
+    #[pin_project(PinnedDrop)]
+    struct S(());
+
+    macro_rules! mac {
+        ($expr:expr) => {
+            #[pinned_drop]
+            impl PinnedDrop for S {
+                fn drop(self: Pin<&mut Self>) {
+                    let _ = $expr;
+                }
+            }
+        };
+    }
+
+    mac!(1);
+}
+
+pub mod self_path {
+    use super::*;
+
+    #[pin_project(PinnedDrop)]
+    pub struct S<T: Unpin>(T);
+
+    fn f() {}
+
+    #[pinned_drop]
+    impl<T: Unpin> PinnedDrop for self::S<T> {
+        fn drop(mut self: Pin<&mut Self>) {
+            self::f();
+            let _: self::S<()> = self::S(());
+            let _: self::S<Pin<&mut Self>> = self::S(self.as_mut());
+            let self::S(()) = self::S(());
+            let self::S(&mut Self(_)) = self::S(&mut *self);
+        }
+    }
+}
diff --git a/crates/pin-project/tests/proper_unpin.rs b/crates/pin-project/tests/proper_unpin.rs
new file mode 100644
index 0000000..0ba3ce3
--- /dev/null
+++ b/crates/pin-project/tests/proper_unpin.rs
@@ -0,0 +1,153 @@
+#![warn(rust_2018_idioms, single_use_lifetimes)]
+#![allow(dead_code)]
+
+#[macro_use]
+mod auxiliary;
+
+pub mod default {
+    use std::marker::PhantomPinned;
+
+    use pin_project::pin_project;
+
+    struct Inner<T> {
+        f: T,
+    }
+
+    assert_unpin!(Inner<()>);
+    assert_not_unpin!(Inner<PhantomPinned>);
+
+    #[pin_project]
+    struct Struct<T, U> {
+        #[pin]
+        f1: Inner<T>,
+        f2: U,
+    }
+
+    assert_unpin!(Struct<(), ()>);
+    assert_unpin!(Struct<(), PhantomPinned>);
+    assert_not_unpin!(Struct<PhantomPinned, ()>);
+    assert_not_unpin!(Struct<PhantomPinned, PhantomPinned>);
+
+    #[pin_project(project = EnumProj, project_ref = EnumProjRef)]
+    enum Enum<T, U> {
+        V1 {
+            #[pin]
+            f1: Inner<T>,
+            f2: U,
+        },
+    }
+
+    assert_unpin!(Enum<(), ()>);
+    assert_unpin!(Enum<(), PhantomPinned>);
+    assert_not_unpin!(Enum<PhantomPinned, ()>);
+    assert_not_unpin!(Enum<PhantomPinned, PhantomPinned>);
+
+    #[pin_project]
+    struct TrivialBounds {
+        #[pin]
+        f: PhantomPinned,
+    }
+
+    assert_not_unpin!(TrivialBounds);
+
+    #[pin_project]
+    struct PinRef<'a, T, U> {
+        #[pin]
+        f1: &'a mut Inner<T>,
+        f2: U,
+    }
+
+    assert_unpin!(PinRef<'_, PhantomPinned, PhantomPinned>);
+}
+
+pub mod cfg {
+    use std::marker::PhantomPinned;
+
+    use pin_project::pin_project;
+
+    #[pin_project]
+    struct Foo<T> {
+        #[cfg(any())]
+        #[pin]
+        f: T,
+        #[cfg(not(any()))]
+        f: T,
+    }
+
+    assert_unpin!(Foo<PhantomPinned>);
+
+    #[pin_project]
+    struct Bar<T> {
+        #[cfg(any())]
+        f: T,
+        #[cfg(not(any()))]
+        #[pin]
+        f: T,
+    }
+
+    assert_unpin!(Bar<()>);
+    assert_not_unpin!(Bar<PhantomPinned>);
+}
+
+pub mod cfg_attr {
+    use std::marker::PhantomPinned;
+
+    use pin_project::pin_project;
+
+    #[cfg_attr(any(), pin_project)]
+    struct Foo<T> {
+        f: T,
+    }
+
+    assert_unpin!(Foo<()>);
+    assert_not_unpin!(Foo<PhantomPinned>);
+
+    #[cfg_attr(not(any()), pin_project)]
+    struct Bar<T> {
+        #[cfg_attr(not(any()), pin)]
+        f: T,
+    }
+
+    assert_unpin!(Bar<()>);
+    assert_not_unpin!(Bar<PhantomPinned>);
+}
+
+// pin_project(!Unpin)
+pub mod not_unpin {
+    use std::marker::PhantomPinned;
+
+    use pin_project::pin_project;
+
+    struct Inner<T> {
+        f: T,
+    }
+
+    #[pin_project(!Unpin)]
+    struct Struct<T, U> {
+        #[pin]
+        inner: Inner<T>,
+        other: U,
+    }
+
+    assert_not_unpin!(Struct<(), ()>);
+    assert_not_unpin!(Struct<(), PhantomPinned>);
+    assert_not_unpin!(Struct<PhantomPinned, ()>);
+    assert_not_unpin!(Struct<PhantomPinned, PhantomPinned>);
+
+    #[pin_project(!Unpin)]
+    struct TrivialBounds {
+        #[pin]
+        f: PhantomPinned,
+    }
+
+    assert_not_unpin!(TrivialBounds);
+
+    #[pin_project(!Unpin)]
+    struct PinRef<'a, T, U> {
+        #[pin]
+        inner: &'a mut Inner<T>,
+        other: U,
+    }
+
+    assert_not_unpin!(PinRef<'_, (), ()>);
+}
diff --git a/crates/pin-project/tests/repr_packed.rs b/crates/pin-project/tests/repr_packed.rs
new file mode 100644
index 0000000..be7cab9
--- /dev/null
+++ b/crates/pin-project/tests/repr_packed.rs
@@ -0,0 +1,52 @@
+#![warn(rust_2018_idioms, single_use_lifetimes)]
+// unaligned_references did not exist in older compilers and safe_packed_borrows was removed in the latest compilers.
+// https://github.com/rust-lang/rust/pull/82525
+#![allow(unknown_lints, renamed_and_removed_lints)]
+#![forbid(unaligned_references, safe_packed_borrows)]
+
+use std::cell::Cell;
+
+// Ensure that the compiler doesn't copy the fields
+// of #[repr(packed)] types during drop, if the field has alignment 1
+// (that is, any reference to the field is guaranteed to have proper alignment)
+// We are currently unable to statically prevent the usage of #[pin_project]
+// on #[repr(packed)] types composed entirely of fields of alignment 1.
+// This shouldn't lead to undefined behavior, as long as the compiler doesn't
+// try to move the field anyway during drop.
+//
+// This tests validates that the compiler is doing what we expect.
+#[test]
+fn weird_repr_packed() {
+    // We keep track of the field address during
+    // drop using a thread local, to avoid changing
+    // the layout of our #[repr(packed)] type.
+    thread_local! {
+        static FIELD_ADDR: Cell<usize> = Cell::new(0);
+    }
+
+    #[repr(packed)]
+    struct Struct {
+        field: u8,
+    }
+
+    impl Drop for Struct {
+        fn drop(&mut self) {
+            FIELD_ADDR.with(|f| {
+                f.set(&self.field as *const u8 as usize);
+            });
+        }
+    }
+
+    #[allow(clippy::let_and_return)]
+    let field_addr = {
+        // We let this field drop by going out of scope,
+        // rather than explicitly calling drop(foo).
+        // Calling drop(foo) causes 'foo' to be moved
+        // into the 'drop' function, resulting in a different
+        // address.
+        let x = Struct { field: 27 };
+        let field_addr = &x.field as *const u8 as usize;
+        field_addr
+    };
+    assert_eq!(field_addr, FIELD_ADDR.with(Cell::get));
+}
diff --git a/crates/pin-project/tests/ui/cfg/cfg_attr-resolve.rs b/crates/pin-project/tests/ui/cfg/cfg_attr-resolve.rs
new file mode 100644
index 0000000..e36cc95
--- /dev/null
+++ b/crates/pin-project/tests/ui/cfg/cfg_attr-resolve.rs
@@ -0,0 +1,11 @@
+use std::pin::Pin;
+
+#[cfg_attr(any(), pin_project::pin_project)]
+struct Foo<T> {
+    f: T,
+}
+
+fn main() {
+    let mut x = Foo { f: 0_u8 };
+    let _ = Pin::new(&mut x).project(); //~ ERROR E0599
+}
diff --git a/crates/pin-project/tests/ui/cfg/cfg_attr-resolve.stderr b/crates/pin-project/tests/ui/cfg/cfg_attr-resolve.stderr
new file mode 100644
index 0000000..0393c14
--- /dev/null
+++ b/crates/pin-project/tests/ui/cfg/cfg_attr-resolve.stderr
@@ -0,0 +1,5 @@
+error[E0599]: no method named `project` found for struct `Pin<&mut Foo<u8>>` in the current scope
+  --> tests/ui/cfg/cfg_attr-resolve.rs:10:30
+   |
+10 |     let _ = Pin::new(&mut x).project(); //~ ERROR E0599
+   |                              ^^^^^^^ method not found in `Pin<&mut Foo<u8>>`
diff --git a/crates/pin-project/tests/ui/cfg/cfg_attr-type-mismatch.rs b/crates/pin-project/tests/ui/cfg/cfg_attr-type-mismatch.rs
new file mode 100644
index 0000000..1b9664b
--- /dev/null
+++ b/crates/pin-project/tests/ui/cfg/cfg_attr-type-mismatch.rs
@@ -0,0 +1,25 @@
+use std::pin::Pin;
+
+use pin_project::pin_project;
+
+#[cfg_attr(not(any()), pin_project)]
+struct Foo<T> {
+    #[cfg_attr(any(), pin)]
+    f: T,
+}
+
+#[cfg_attr(not(any()), pin_project)]
+struct Bar<T> {
+    #[cfg_attr(not(any()), pin)]
+    f: T,
+}
+
+fn main() {
+    let mut x = Foo { f: 0_u8 };
+    let x = Pin::new(&mut x).project();
+    let _: Pin<&mut u8> = x.f; //~ ERROR E0308
+
+    let mut x = Bar { f: 0_u8 };
+    let x = Pin::new(&mut x).project();
+    let _: &mut u8 = x.f; //~ ERROR E0308
+}
diff --git a/crates/pin-project/tests/ui/cfg/cfg_attr-type-mismatch.stderr b/crates/pin-project/tests/ui/cfg/cfg_attr-type-mismatch.stderr
new file mode 100644
index 0000000..081504c
--- /dev/null
+++ b/crates/pin-project/tests/ui/cfg/cfg_attr-type-mismatch.stderr
@@ -0,0 +1,25 @@
+error[E0308]: mismatched types
+  --> tests/ui/cfg/cfg_attr-type-mismatch.rs:20:27
+   |
+20 |     let _: Pin<&mut u8> = x.f; //~ ERROR E0308
+   |            ------------   ^^^ expected `Pin<&mut u8>`, found `&mut u8`
+   |            |
+   |            expected due to this
+   |
+   = note:         expected struct `Pin<&mut u8>`
+           found mutable reference `&mut u8`
+
+error[E0308]: mismatched types
+  --> tests/ui/cfg/cfg_attr-type-mismatch.rs:24:22
+   |
+24 |     let _: &mut u8 = x.f; //~ ERROR E0308
+   |            -------   ^^^ expected `&mut u8`, found `Pin<&mut u8>`
+   |            |
+   |            expected due to this
+   |
+   = note: expected mutable reference `&mut u8`
+                         found struct `Pin<&mut u8>`
+help: consider mutably borrowing here
+   |
+24 |     let _: &mut u8 = &mut x.f; //~ ERROR E0308
+   |                      ++++
diff --git a/crates/pin-project/tests/ui/cfg/packed_sneaky-span-issue-1.rs b/crates/pin-project/tests/ui/cfg/packed_sneaky-span-issue-1.rs
new file mode 100644
index 0000000..7e19952
--- /dev/null
+++ b/crates/pin-project/tests/ui/cfg/packed_sneaky-span-issue-1.rs
@@ -0,0 +1,15 @@
+use auxiliary_macro::hidden_repr;
+use pin_project::pin_project;
+
+#[pin_project]
+#[hidden_repr(packed)] //~ ERROR may not be used on #[repr(packed)] types
+struct S {
+    #[cfg(not(any()))]
+    #[pin]
+    f: u32,
+    #[cfg(any())]
+    #[pin]
+    f: u8,
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/ui/cfg/packed_sneaky-span-issue-1.stderr b/crates/pin-project/tests/ui/cfg/packed_sneaky-span-issue-1.stderr
new file mode 100644
index 0000000..4f3acc3
--- /dev/null
+++ b/crates/pin-project/tests/ui/cfg/packed_sneaky-span-issue-1.stderr
@@ -0,0 +1,5 @@
+error: #[pin_project] attribute may not be used on #[repr(packed)] types
+ --> tests/ui/cfg/packed_sneaky-span-issue-1.rs:5:15
+  |
+5 | #[hidden_repr(packed)] //~ ERROR may not be used on #[repr(packed)] types
+  |               ^^^^^^
diff --git a/crates/pin-project/tests/ui/cfg/packed_sneaky-span-issue-2.rs b/crates/pin-project/tests/ui/cfg/packed_sneaky-span-issue-2.rs
new file mode 100644
index 0000000..fcea76b
--- /dev/null
+++ b/crates/pin-project/tests/ui/cfg/packed_sneaky-span-issue-2.rs
@@ -0,0 +1,15 @@
+use auxiliary_macro::hidden_repr;
+use pin_project::pin_project;
+
+#[pin_project]
+#[hidden_repr(packed)] //~ ERROR may not be used on #[repr(packed)] types
+struct S {
+    #[cfg(any())]
+    #[pin]
+    f: u32,
+    #[cfg(not(any()))]
+    #[pin]
+    f: u8,
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/ui/cfg/packed_sneaky-span-issue-2.stderr b/crates/pin-project/tests/ui/cfg/packed_sneaky-span-issue-2.stderr
new file mode 100644
index 0000000..cc2795a
--- /dev/null
+++ b/crates/pin-project/tests/ui/cfg/packed_sneaky-span-issue-2.stderr
@@ -0,0 +1,5 @@
+error: #[pin_project] attribute may not be used on #[repr(packed)] types
+ --> tests/ui/cfg/packed_sneaky-span-issue-2.rs:5:15
+  |
+5 | #[hidden_repr(packed)] //~ ERROR may not be used on #[repr(packed)] types
+  |               ^^^^^^
diff --git a/crates/pin-project/tests/ui/cfg/packed_sneaky.rs b/crates/pin-project/tests/ui/cfg/packed_sneaky.rs
new file mode 100644
index 0000000..0b01dc9
--- /dev/null
+++ b/crates/pin-project/tests/ui/cfg/packed_sneaky.rs
@@ -0,0 +1,12 @@
+use auxiliary_macro::hidden_repr_cfg_not_any;
+use pin_project::pin_project;
+
+// `#[hidden_repr_cfg_not_any(packed)]` generates `#[cfg_attr(not(any()), repr(packed))]`.
+#[pin_project]
+#[hidden_repr_cfg_not_any(packed)] //~ ERROR may not be used on #[repr(packed)] types
+struct S {
+    #[pin]
+    f: u32,
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/ui/cfg/packed_sneaky.stderr b/crates/pin-project/tests/ui/cfg/packed_sneaky.stderr
new file mode 100644
index 0000000..a54c2ec
--- /dev/null
+++ b/crates/pin-project/tests/ui/cfg/packed_sneaky.stderr
@@ -0,0 +1,5 @@
+error: #[pin_project] attribute may not be used on #[repr(packed)] types
+ --> tests/ui/cfg/packed_sneaky.rs:6:27
+  |
+6 | #[hidden_repr_cfg_not_any(packed)] //~ ERROR may not be used on #[repr(packed)] types
+  |                           ^^^^^^
diff --git a/crates/pin-project/tests/ui/cfg/unsupported.rs b/crates/pin-project/tests/ui/cfg/unsupported.rs
new file mode 100644
index 0000000..b950d4b
--- /dev/null
+++ b/crates/pin-project/tests/ui/cfg/unsupported.rs
@@ -0,0 +1,11 @@
+use pin_project::pin_project;
+
+#[pin_project]
+struct S {
+    //~^ ERROR may not be used on structs with zero fields
+    #[cfg(any())]
+    #[pin]
+    f: u8,
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/ui/cfg/unsupported.stderr b/crates/pin-project/tests/ui/cfg/unsupported.stderr
new file mode 100644
index 0000000..e1c871c
--- /dev/null
+++ b/crates/pin-project/tests/ui/cfg/unsupported.stderr
@@ -0,0 +1,11 @@
+error: #[pin_project] attribute may not be used on structs with zero fields
+ --> tests/ui/cfg/unsupported.rs:4:10
+  |
+4 |   struct S {
+  |  __________^
+5 | |     //~^ ERROR may not be used on structs with zero fields
+6 | |     #[cfg(any())]
+7 | |     #[pin]
+8 | |     f: u8,
+9 | | }
+  | |_^
diff --git a/crates/pin-project/tests/ui/not_unpin/conflict-unpin.rs b/crates/pin-project/tests/ui/not_unpin/conflict-unpin.rs
new file mode 100644
index 0000000..8985f37
--- /dev/null
+++ b/crates/pin-project/tests/ui/not_unpin/conflict-unpin.rs
@@ -0,0 +1,30 @@
+use pin_project::pin_project;
+
+#[pin_project(!Unpin)] //~ ERROR E0119
+struct Foo<T, U> {
+    #[pin]
+    f1: T,
+    f2: U,
+}
+
+impl<T, U> Unpin for Foo<T, U> where T: Unpin {}
+
+#[pin_project(!Unpin)] //~ ERROR E0119
+struct Bar<T, U> {
+    #[pin]
+    f1: T,
+    f2: U,
+}
+
+impl<T, U> Unpin for Bar<T, U> {}
+
+#[pin_project(!Unpin)] //~ ERROR E0119
+struct Baz<T, U> {
+    #[pin]
+    f1: T,
+    f2: U,
+}
+
+impl<T: Unpin, U: Unpin> Unpin for Baz<T, U> {}
+
+fn main() {}
diff --git a/crates/pin-project/tests/ui/not_unpin/conflict-unpin.stderr b/crates/pin-project/tests/ui/not_unpin/conflict-unpin.stderr
new file mode 100644
index 0000000..4bd72bb
--- /dev/null
+++ b/crates/pin-project/tests/ui/not_unpin/conflict-unpin.stderr
@@ -0,0 +1,26 @@
+error[E0119]: conflicting implementations of trait `Unpin` for type `Foo<_, _>`
+  --> tests/ui/not_unpin/conflict-unpin.rs:3:15
+   |
+3  | #[pin_project(!Unpin)] //~ ERROR E0119
+   |               ^^^^^^ conflicting implementation for `Foo<_, _>`
+...
+10 | impl<T, U> Unpin for Foo<T, U> where T: Unpin {}
+   | ------------------------------ first implementation here
+
+error[E0119]: conflicting implementations of trait `Unpin` for type `Bar<_, _>`
+  --> tests/ui/not_unpin/conflict-unpin.rs:12:15
+   |
+12 | #[pin_project(!Unpin)] //~ ERROR E0119
+   |               ^^^^^^ conflicting implementation for `Bar<_, _>`
+...
+19 | impl<T, U> Unpin for Bar<T, U> {}
+   | ------------------------------ first implementation here
+
+error[E0119]: conflicting implementations of trait `Unpin` for type `Baz<_, _>`
+  --> tests/ui/not_unpin/conflict-unpin.rs:21:15
+   |
+21 | #[pin_project(!Unpin)] //~ ERROR E0119
+   |               ^^^^^^ conflicting implementation for `Baz<_, _>`
+...
+28 | impl<T: Unpin, U: Unpin> Unpin for Baz<T, U> {}
+   | -------------------------------------------- first implementation here
diff --git a/crates/pin-project/tests/ui/not_unpin/impl-unsafe-unpin.rs b/crates/pin-project/tests/ui/not_unpin/impl-unsafe-unpin.rs
new file mode 100644
index 0000000..2c078c7
--- /dev/null
+++ b/crates/pin-project/tests/ui/not_unpin/impl-unsafe-unpin.rs
@@ -0,0 +1,30 @@
+use pin_project::{pin_project, UnsafeUnpin};
+
+#[pin_project(!Unpin)] //~ ERROR E0119
+struct Foo<T, U> {
+    #[pin]
+    f1: T,
+    f2: U,
+}
+
+unsafe impl<T, U> UnsafeUnpin for Foo<T, U> where T: Unpin {}
+
+#[pin_project(!Unpin)] //~ ERROR E0119
+struct Bar<T, U> {
+    #[pin]
+    f1: T,
+    f2: U,
+}
+
+unsafe impl<T, U> UnsafeUnpin for Bar<T, U> {}
+
+#[pin_project(!Unpin)] //~ ERROR E0119
+struct Baz<T, U> {
+    #[pin]
+    f1: T,
+    f2: U,
+}
+
+unsafe impl<T: Unpin, U: Unpin> UnsafeUnpin for Baz<T, U> {}
+
+fn main() {}
diff --git a/crates/pin-project/tests/ui/not_unpin/impl-unsafe-unpin.stderr b/crates/pin-project/tests/ui/not_unpin/impl-unsafe-unpin.stderr
new file mode 100644
index 0000000..f116eac
--- /dev/null
+++ b/crates/pin-project/tests/ui/not_unpin/impl-unsafe-unpin.stderr
@@ -0,0 +1,32 @@
+error[E0119]: conflicting implementations of trait `UnsafeUnpin` for type `Foo<_, _>`
+  --> tests/ui/not_unpin/impl-unsafe-unpin.rs:3:1
+   |
+3  | #[pin_project(!Unpin)] //~ ERROR E0119
+   | ^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `Foo<_, _>`
+...
+10 | unsafe impl<T, U> UnsafeUnpin for Foo<T, U> where T: Unpin {}
+   | ------------------------------------------- first implementation here
+   |
+   = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0119]: conflicting implementations of trait `UnsafeUnpin` for type `Bar<_, _>`
+  --> tests/ui/not_unpin/impl-unsafe-unpin.rs:12:1
+   |
+12 | #[pin_project(!Unpin)] //~ ERROR E0119
+   | ^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `Bar<_, _>`
+...
+19 | unsafe impl<T, U> UnsafeUnpin for Bar<T, U> {}
+   | ------------------------------------------- first implementation here
+   |
+   = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0119]: conflicting implementations of trait `UnsafeUnpin` for type `Baz<_, _>`
+  --> tests/ui/not_unpin/impl-unsafe-unpin.rs:21:1
+   |
+21 | #[pin_project(!Unpin)] //~ ERROR E0119
+   | ^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `Baz<_, _>`
+...
+28 | unsafe impl<T: Unpin, U: Unpin> UnsafeUnpin for Baz<T, U> {}
+   | --------------------------------------------------------- first implementation here
+   |
+   = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/crates/pin-project/tests/ui/pin_project/add-attr-to-struct.rs b/crates/pin-project/tests/ui/pin_project/add-attr-to-struct.rs
new file mode 100644
index 0000000..32253d7
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/add-attr-to-struct.rs
@@ -0,0 +1,20 @@
+use std::marker::PhantomPinned;
+
+use auxiliary_macro::add_pin_attr;
+use pin_project::pin_project;
+
+#[pin_project]
+#[add_pin_attr(struct)] //~ ERROR expected attribute arguments in parentheses
+struct Foo {
+    #[pin]
+    f: PhantomPinned,
+}
+
+#[add_pin_attr(struct)] //~ ERROR #[pin] attribute may only be used on fields of structs or variants
+#[pin_project]
+struct Bar {
+    #[pin]
+    f: PhantomPinned,
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/ui/pin_project/add-attr-to-struct.stderr b/crates/pin-project/tests/ui/pin_project/add-attr-to-struct.stderr
new file mode 100644
index 0000000..bb76c62
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/add-attr-to-struct.stderr
@@ -0,0 +1,15 @@
+error: expected attribute arguments in parentheses: `pin(...)`
+ --> tests/ui/pin_project/add-attr-to-struct.rs:7:1
+  |
+7 | #[add_pin_attr(struct)] //~ ERROR expected attribute arguments in parentheses
+  | ^^^^^^^^^^^^^^^^^^^^^^^
+  |
+  = note: this error originates in the attribute macro `add_pin_attr` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: #[pin] attribute may only be used on fields of structs or variants
+  --> tests/ui/pin_project/add-attr-to-struct.rs:13:1
+   |
+13 | #[add_pin_attr(struct)] //~ ERROR #[pin] attribute may only be used on fields of structs or variants
+   | ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: this error originates in the attribute macro `add_pin_attr` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/crates/pin-project/tests/ui/pin_project/add-pinned-field.rs b/crates/pin-project/tests/ui/pin_project/add-pinned-field.rs
new file mode 100644
index 0000000..c415f9c
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/add-pinned-field.rs
@@ -0,0 +1,23 @@
+use auxiliary_macro::add_pinned_field;
+use pin_project::pin_project;
+
+fn is_unpin<T: Unpin>() {}
+
+#[pin_project]
+#[add_pinned_field]
+struct Foo {
+    #[pin]
+    f: u32,
+}
+
+#[add_pinned_field]
+#[pin_project]
+struct Bar {
+    #[pin]
+    f: u32,
+}
+
+fn main() {
+    is_unpin::<Foo>(); //~ ERROR E0277
+    is_unpin::<Bar>(); //~ ERROR E0277
+}
diff --git a/crates/pin-project/tests/ui/pin_project/add-pinned-field.stderr b/crates/pin-project/tests/ui/pin_project/add-pinned-field.stderr
new file mode 100644
index 0000000..a38329d
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/add-pinned-field.stderr
@@ -0,0 +1,54 @@
+error[E0277]: `PhantomPinned` cannot be unpinned
+  --> tests/ui/pin_project/add-pinned-field.rs:21:16
+   |
+21 |     is_unpin::<Foo>(); //~ ERROR E0277
+   |                ^^^ within `__Foo<'_>`, the trait `Unpin` is not implemented for `PhantomPinned`
+   |
+   = note: consider using the `pin!` macro
+           consider using `Box::pin` if you need to access the pinned value outside of the current scope
+note: required because it appears within the type `__Foo<'_>`
+  --> tests/ui/pin_project/add-pinned-field.rs:8:8
+   |
+8  | struct Foo {
+   |        ^^^
+note: required for `Foo` to implement `Unpin`
+  --> tests/ui/pin_project/add-pinned-field.rs:6:1
+   |
+6  | #[pin_project]
+   | ^^^^^^^^^^^^^^ unsatisfied trait bound introduced in this `derive` macro
+7  | #[add_pinned_field]
+8  | struct Foo {
+   |        ^^^
+note: required by a bound in `is_unpin`
+  --> tests/ui/pin_project/add-pinned-field.rs:4:16
+   |
+4  | fn is_unpin<T: Unpin>() {}
+   |                ^^^^^ required by this bound in `is_unpin`
+   = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: `PhantomPinned` cannot be unpinned
+  --> tests/ui/pin_project/add-pinned-field.rs:22:16
+   |
+22 |     is_unpin::<Bar>(); //~ ERROR E0277
+   |                ^^^ within `__Bar<'_>`, the trait `Unpin` is not implemented for `PhantomPinned`
+   |
+   = note: consider using the `pin!` macro
+           consider using `Box::pin` if you need to access the pinned value outside of the current scope
+note: required because it appears within the type `__Bar<'_>`
+  --> tests/ui/pin_project/add-pinned-field.rs:15:8
+   |
+15 | struct Bar {
+   |        ^^^
+note: required for `Bar` to implement `Unpin`
+  --> tests/ui/pin_project/add-pinned-field.rs:14:1
+   |
+14 | #[pin_project]
+   | ^^^^^^^^^^^^^^ unsatisfied trait bound introduced in this `derive` macro
+15 | struct Bar {
+   |        ^^^
+note: required by a bound in `is_unpin`
+  --> tests/ui/pin_project/add-pinned-field.rs:4:16
+   |
+4  | fn is_unpin<T: Unpin>() {}
+   |                ^^^^^ required by this bound in `is_unpin`
+   = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/crates/pin-project/tests/ui/pin_project/conflict-drop.rs b/crates/pin-project/tests/ui/pin_project/conflict-drop.rs
new file mode 100644
index 0000000..4fdb118
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/conflict-drop.rs
@@ -0,0 +1,32 @@
+use std::pin::Pin;
+
+use pin_project::{pin_project, pinned_drop};
+
+#[pin_project] //~ ERROR E0119
+struct Foo<T, U> {
+    #[pin]
+    f1: T,
+    f2: U,
+}
+
+impl<T, U> Drop for Foo<T, U> {
+    fn drop(&mut self) {}
+}
+
+#[pin_project(PinnedDrop)] //~ ERROR E0119
+struct Bar<T, U> {
+    #[pin]
+    f1: T,
+    f2: U,
+}
+
+#[pinned_drop]
+impl<T, U> PinnedDrop for Bar<T, U> {
+    fn drop(self: Pin<&mut Self>) {}
+}
+
+impl<T, U> Drop for Bar<T, U> {
+    fn drop(&mut self) {}
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/ui/pin_project/conflict-drop.stderr b/crates/pin-project/tests/ui/pin_project/conflict-drop.stderr
new file mode 100644
index 0000000..79d4ca7
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/conflict-drop.stderr
@@ -0,0 +1,19 @@
+error[E0119]: conflicting implementations of trait `FooMustNotImplDrop` for type `Foo<_, _>`
+ --> tests/ui/pin_project/conflict-drop.rs:5:1
+  |
+5 | #[pin_project] //~ ERROR E0119
+  | ^^^^^^^^^^^^^^
+  | |
+  | first implementation here
+  | conflicting implementation for `Foo<_, _>`
+  |
+  = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0119]: conflicting implementations of trait `Drop` for type `Bar<_, _>`
+  --> tests/ui/pin_project/conflict-drop.rs:16:15
+   |
+16 | #[pin_project(PinnedDrop)] //~ ERROR E0119
+   |               ^^^^^^^^^^ conflicting implementation for `Bar<_, _>`
+...
+28 | impl<T, U> Drop for Bar<T, U> {
+   | ----------------------------- first implementation here
diff --git a/crates/pin-project/tests/ui/pin_project/conflict-unpin.rs b/crates/pin-project/tests/ui/pin_project/conflict-unpin.rs
new file mode 100644
index 0000000..f58c45e
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/conflict-unpin.rs
@@ -0,0 +1,37 @@
+use pin_project::pin_project;
+
+// The same implementation.
+
+#[pin_project] //~ ERROR E0119
+struct Foo<T, U> {
+    #[pin]
+    f1: T,
+    f2: U,
+}
+
+// conflicting implementations
+impl<T, U> Unpin for Foo<T, U> where T: Unpin {} // Conditional Unpin impl
+
+// The implementation that under different conditions.
+
+#[pin_project] //~ ERROR E0119
+struct Bar<T, U> {
+    #[pin]
+    f1: T,
+    f2: U,
+}
+
+// conflicting implementations
+impl<T, U> Unpin for Bar<T, U> {} // Non-conditional Unpin impl
+
+#[pin_project] //~ ERROR E0119
+struct Baz<T, U> {
+    #[pin]
+    f1: T,
+    f2: U,
+}
+
+// conflicting implementations
+impl<T: Unpin, U: Unpin> Unpin for Baz<T, U> {} // Conditional Unpin impl
+
+fn main() {}
diff --git a/crates/pin-project/tests/ui/pin_project/conflict-unpin.stderr b/crates/pin-project/tests/ui/pin_project/conflict-unpin.stderr
new file mode 100644
index 0000000..0f26b68
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/conflict-unpin.stderr
@@ -0,0 +1,32 @@
+error[E0119]: conflicting implementations of trait `Unpin` for type `Foo<_, _>`
+  --> tests/ui/pin_project/conflict-unpin.rs:5:1
+   |
+5  | #[pin_project] //~ ERROR E0119
+   | ^^^^^^^^^^^^^^ conflicting implementation for `Foo<_, _>`
+...
+13 | impl<T, U> Unpin for Foo<T, U> where T: Unpin {} // Conditional Unpin impl
+   | ------------------------------ first implementation here
+   |
+   = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0119]: conflicting implementations of trait `Unpin` for type `Bar<_, _>`
+  --> tests/ui/pin_project/conflict-unpin.rs:17:1
+   |
+17 | #[pin_project] //~ ERROR E0119
+   | ^^^^^^^^^^^^^^ conflicting implementation for `Bar<_, _>`
+...
+25 | impl<T, U> Unpin for Bar<T, U> {} // Non-conditional Unpin impl
+   | ------------------------------ first implementation here
+   |
+   = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0119]: conflicting implementations of trait `Unpin` for type `Baz<_, _>`
+  --> tests/ui/pin_project/conflict-unpin.rs:27:1
+   |
+27 | #[pin_project] //~ ERROR E0119
+   | ^^^^^^^^^^^^^^ conflicting implementation for `Baz<_, _>`
+...
+35 | impl<T: Unpin, U: Unpin> Unpin for Baz<T, U> {} // Conditional Unpin impl
+   | -------------------------------------------- first implementation here
+   |
+   = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/crates/pin-project/tests/ui/pin_project/impl-unsafe-unpin.rs b/crates/pin-project/tests/ui/pin_project/impl-unsafe-unpin.rs
new file mode 100644
index 0000000..562c9b6
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/impl-unsafe-unpin.rs
@@ -0,0 +1,30 @@
+use pin_project::{pin_project, UnsafeUnpin};
+
+#[pin_project] //~ ERROR E0119
+struct Foo<T, U> {
+    #[pin]
+    f1: T,
+    f2: U,
+}
+
+unsafe impl<T, U> UnsafeUnpin for Foo<T, U> where T: Unpin {}
+
+#[pin_project] //~ ERROR E0119
+struct Bar<T, U> {
+    #[pin]
+    f1: T,
+    f2: U,
+}
+
+unsafe impl<T, U> UnsafeUnpin for Bar<T, U> {}
+
+#[pin_project] //~ ERROR E0119
+struct Baz<T, U> {
+    #[pin]
+    f1: T,
+    f2: U,
+}
+
+unsafe impl<T: Unpin, U: Unpin> UnsafeUnpin for Baz<T, U> {}
+
+fn main() {}
diff --git a/crates/pin-project/tests/ui/pin_project/impl-unsafe-unpin.stderr b/crates/pin-project/tests/ui/pin_project/impl-unsafe-unpin.stderr
new file mode 100644
index 0000000..7e66b9e
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/impl-unsafe-unpin.stderr
@@ -0,0 +1,32 @@
+error[E0119]: conflicting implementations of trait `UnsafeUnpin` for type `Foo<_, _>`
+  --> tests/ui/pin_project/impl-unsafe-unpin.rs:3:1
+   |
+3  | #[pin_project] //~ ERROR E0119
+   | ^^^^^^^^^^^^^^ conflicting implementation for `Foo<_, _>`
+...
+10 | unsafe impl<T, U> UnsafeUnpin for Foo<T, U> where T: Unpin {}
+   | ------------------------------------------- first implementation here
+   |
+   = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0119]: conflicting implementations of trait `UnsafeUnpin` for type `Bar<_, _>`
+  --> tests/ui/pin_project/impl-unsafe-unpin.rs:12:1
+   |
+12 | #[pin_project] //~ ERROR E0119
+   | ^^^^^^^^^^^^^^ conflicting implementation for `Bar<_, _>`
+...
+19 | unsafe impl<T, U> UnsafeUnpin for Bar<T, U> {}
+   | ------------------------------------------- first implementation here
+   |
+   = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0119]: conflicting implementations of trait `UnsafeUnpin` for type `Baz<_, _>`
+  --> tests/ui/pin_project/impl-unsafe-unpin.rs:21:1
+   |
+21 | #[pin_project] //~ ERROR E0119
+   | ^^^^^^^^^^^^^^ conflicting implementation for `Baz<_, _>`
+...
+28 | unsafe impl<T: Unpin, U: Unpin> UnsafeUnpin for Baz<T, U> {}
+   | --------------------------------------------------------- first implementation here
+   |
+   = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/crates/pin-project/tests/ui/pin_project/import_unnamed.rs b/crates/pin-project/tests/ui/pin_project/import_unnamed.rs
new file mode 100644
index 0000000..7926e61
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/import_unnamed.rs
@@ -0,0 +1,30 @@
+/// Only named projected types can be imported.
+/// See visibility.rs for named projected types.
+
+mod pub_ {
+    use pin_project::pin_project;
+
+    #[pin_project]
+    pub struct Default(());
+
+    #[pin_project(project_replace)]
+    pub struct Replace(());
+}
+#[allow(unused_imports)]
+pub mod use_ {
+    #[rustfmt::skip]
+    use crate::pub_::__DefaultProjection; //~ ERROR E0432
+    #[rustfmt::skip]
+    use crate::pub_::__DefaultProjectionRef; //~ ERROR E0432
+    #[rustfmt::skip]
+    use crate::pub_::__ReplaceProjection; //~ ERROR E0432
+    #[rustfmt::skip]
+    use crate::pub_::__ReplaceProjectionOwned; //~ ERROR E0432
+    #[rustfmt::skip]
+    use crate::pub_::__ReplaceProjectionRef; //~ ERROR E0432
+
+    // Confirm that the visibility of the original type is not changed.
+    pub use crate::pub_::{Default, Replace};
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/ui/pin_project/import_unnamed.stderr b/crates/pin-project/tests/ui/pin_project/import_unnamed.stderr
new file mode 100644
index 0000000..260a35a
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/import_unnamed.stderr
@@ -0,0 +1,29 @@
+error[E0432]: unresolved import `crate::pub_::__DefaultProjection`
+  --> tests/ui/pin_project/import_unnamed.rs:16:9
+   |
+16 |     use crate::pub_::__DefaultProjection; //~ ERROR E0432
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `__DefaultProjection` in `pub_`
+
+error[E0432]: unresolved import `crate::pub_::__DefaultProjectionRef`
+  --> tests/ui/pin_project/import_unnamed.rs:18:9
+   |
+18 |     use crate::pub_::__DefaultProjectionRef; //~ ERROR E0432
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `__DefaultProjectionRef` in `pub_`
+
+error[E0432]: unresolved import `crate::pub_::__ReplaceProjection`
+  --> tests/ui/pin_project/import_unnamed.rs:20:9
+   |
+20 |     use crate::pub_::__ReplaceProjection; //~ ERROR E0432
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `__ReplaceProjection` in `pub_`
+
+error[E0432]: unresolved import `crate::pub_::__ReplaceProjectionOwned`
+  --> tests/ui/pin_project/import_unnamed.rs:22:9
+   |
+22 |     use crate::pub_::__ReplaceProjectionOwned; //~ ERROR E0432
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `__ReplaceProjectionOwned` in `pub_`
+
+error[E0432]: unresolved import `crate::pub_::__ReplaceProjectionRef`
+  --> tests/ui/pin_project/import_unnamed.rs:24:9
+   |
+24 |     use crate::pub_::__ReplaceProjectionRef; //~ ERROR E0432
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `__ReplaceProjectionRef` in `pub_`
diff --git a/crates/pin-project/tests/ui/pin_project/invalid.rs b/crates/pin-project/tests/ui/pin_project/invalid.rs
new file mode 100644
index 0000000..a850c57
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/invalid.rs
@@ -0,0 +1,280 @@
+mod pin_argument {
+    use pin_project::pin_project;
+
+    #[pin_project]
+    struct Struct {
+        #[pin()] //~ ERROR unexpected token in attribute
+        f: (),
+    }
+
+    #[pin_project]
+    struct TupleStruct(#[pin(foo)] ()); //~ ERROR unexpected token in attribute
+
+    #[pin_project]
+    enum EnumTuple {
+        V(#[pin(foo)] ()), //~ ERROR unexpected token in attribute
+    }
+
+    #[pin_project]
+    enum EnumStruct {
+        V {
+            #[pin(foo)] //~ ERROR unexpected token in attribute
+            f: (),
+        },
+    }
+}
+
+mod pin_attribute {
+    use pin_project::pin_project;
+
+    #[pin_project]
+    struct DuplicateStruct {
+        #[pin]
+        #[pin] //~ ERROR duplicate #[pin] attribute
+        f: (),
+    }
+
+    #[pin_project]
+    struct DuplicateTupleStruct(
+        #[pin]
+        #[pin]
+        (),
+        //~^^ ERROR duplicate #[pin] attribute
+    );
+
+    #[pin_project]
+    enum DuplicateEnumTuple {
+        V(
+            #[pin]
+            #[pin]
+            (),
+            //~^^ ERROR duplicate #[pin] attribute
+        ),
+    }
+
+    #[pin_project]
+    enum DuplicateEnumStruct {
+        V {
+            #[pin]
+            #[pin] //~ ERROR duplicate #[pin] attribute
+            f: (),
+        },
+    }
+}
+
+mod pin_item {
+    use pin_project::pin_project;
+
+    #[pin_project]
+    #[pin] //~ ERROR may only be used on fields of structs or variants
+    struct Struct {
+        #[pin]
+        f: (),
+    }
+
+    #[pin_project]
+    enum Variant {
+        #[pin] //~ ERROR may only be used on fields of structs or variants
+        V(()),
+    }
+
+    #[pin_project]
+    #[pin] //~ ERROR may only be used on fields of structs or variants
+    enum Enum {
+        V(()),
+    }
+}
+
+mod pin_project_argument {
+    use pin_project::pin_project;
+
+    #[pin_project(Replace)] //~ ERROR `Replace` argument was removed, use `project_replace` argument instead
+    struct RemovedReplace(#[pin] ());
+
+    #[pin_project(UnsafeUnpin,,)] //~ ERROR expected identifier
+    struct Unexpected1(#[pin] ());
+
+    #[pin_project(Foo)] //~ ERROR unexpected argument
+    struct Unexpected2(#[pin] ());
+
+    #[pin_project(,UnsafeUnpin)] //~ ERROR expected identifier
+    struct Unexpected3(#[pin] ());
+
+    #[pin_project()] // Ok
+    struct Unexpected4(#[pin] ());
+
+    #[pin_project(PinnedDrop PinnedDrop)] //~ ERROR expected `,`
+    struct Unexpected5(#[pin] ());
+
+    #[pin_project(PinnedDrop, PinnedDrop)] //~ ERROR duplicate `PinnedDrop` argument
+    struct DuplicatePinnedDrop(#[pin] ());
+
+    #[pin_project(UnsafeUnpin, UnsafeUnpin)] //~ ERROR duplicate `UnsafeUnpin` argument
+    struct DuplicateUnsafeUnpin(#[pin] ());
+
+    #[pin_project(!Unpin, !Unpin)] //~ ERROR duplicate `!Unpin` argument
+    struct DuplicateNotUnpin(#[pin] ());
+
+    #[pin_project(PinnedDrop, UnsafeUnpin, UnsafeUnpin)] //~ ERROR duplicate `UnsafeUnpin` argument
+    struct Duplicate3(#[pin] ());
+
+    #[pin_project(PinnedDrop, UnsafeUnpin, PinnedDrop, UnsafeUnpin)] //~ ERROR duplicate `PinnedDrop` argument
+    struct Duplicate4(#[pin] ());
+
+    #[pin_project(project = A, project = B)] //~ ERROR duplicate `project` argument
+    struct DuplicateProject(#[pin] ());
+
+    #[pin_project(project = A, project_ref = A, project = B)] //~ ERROR duplicate `project` argument
+    struct DuplicateProject2(#[pin] ());
+
+    #[pin_project(project_ref = A, project_ref = B)] //~ ERROR duplicate `project_ref` argument
+    struct DuplicateProjectRef(#[pin] ());
+
+    #[pin_project(project_replace = A, project_replace = B)] //~ ERROR duplicate `project_replace` argument
+    struct DuplicateProjectReplace1(#[pin] ());
+
+    #[pin_project(project_replace, project_replace = B)] //~ ERROR duplicate `project_replace` argument
+    struct DuplicateProjectReplace2(#[pin] ());
+
+    #[pin_project(project_replace = A, project_replace)] //~ ERROR duplicate `project_replace` argument
+    struct DuplicateProjectReplace3(#[pin] ());
+
+    #[pin_project(project_replace = A)] // Ok
+    struct ProjectReplaceWithoutReplace(#[pin] ());
+
+    #[pin_project(PinnedDrop, project_replace)] //~ ERROR arguments `PinnedDrop` and `project_replace` are mutually exclusive
+    struct PinnedDropWithProjectReplace1(#[pin] ());
+
+    #[pin_project(project_replace, UnsafeUnpin, PinnedDrop)] //~ ERROR arguments `PinnedDrop` and `project_replace` are mutually exclusive
+    struct PinnedDropWithProjectReplace2(#[pin] ());
+
+    #[pin_project(UnsafeUnpin, !Unpin)] //~ ERROR arguments `UnsafeUnpin` and `!Unpin` are mutually exclusive
+    struct UnsafeUnpinWithNotUnpin1(#[pin] ());
+
+    #[pin_project(!Unpin, PinnedDrop, UnsafeUnpin)] //~ ERROR arguments `UnsafeUnpin` and `!Unpin` are mutually exclusive
+    struct UnsafeUnpinWithNotUnpin2(#[pin] ());
+
+    #[pin_project(!)] //~ ERROR expected `!Unpin`, found `!`
+    struct NotUnpin1(#[pin] ());
+
+    #[pin_project(Unpin)] //~ ERROR unexpected argument
+    struct NotUnpin2(#[pin] ());
+
+    #[pin_project(project)] //~ ERROR expected `project = <identifier>`, found `project`
+    struct Project1(#[pin] ());
+
+    #[pin_project(project = )] //~ ERROR expected `project = <identifier>`, found `project =`
+    struct Project2(#[pin] ());
+
+    #[pin_project(project = !)] //~ ERROR expected identifier
+    struct Project3(#[pin] ());
+
+    #[pin_project(project_ref)] //~ ERROR expected `project_ref = <identifier>`, found `project_ref`
+    struct ProjectRef1(#[pin] ());
+
+    #[pin_project(project_ref = )] //~ ERROR expected `project_ref = <identifier>`, found `project_ref =`
+    struct ProjectRef2(#[pin] ());
+
+    #[pin_project(project_ref = !)] //~ ERROR expected identifier
+    struct ProjectRef3(#[pin] ());
+
+    #[pin_project(project_replace)] // Ok
+    struct ProjectReplace1(#[pin] ());
+
+    #[pin_project(project_replace = )] //~ ERROR expected `project_replace = <identifier>`, found `project_replace =`
+    struct ProjectReplace2(#[pin] ());
+
+    #[pin_project(project_replace = !)] //~ ERROR expected identifier
+    struct ProjectReplace3(#[pin] ());
+
+    #[pin_project(project_replace)] //~ ERROR `project_replace` argument requires a value when used on enums
+    enum ProjectReplaceEnum {
+        V(#[pin] ()),
+    }
+}
+
+mod pin_project_conflict_naming {
+    use pin_project::pin_project;
+
+    #[pin_project(project = OrigAndProj)] //~ ERROR name `OrigAndProj` is the same as the original type name
+    struct OrigAndProj(#[pin] ());
+
+    #[pin_project(project_ref = OrigAndProjRef)] //~ ERROR name `OrigAndProjRef` is the same as the original type name
+    struct OrigAndProjRef(#[pin] ());
+
+    #[pin_project(project_replace = OrigAndProjOwn)] //~ ERROR name `OrigAndProjOwn` is the same as the original type name
+    struct OrigAndProjOwn(#[pin] ());
+
+    #[pin_project(project = A, project_ref = A)] //~ ERROR name `A` is already specified by `project` argument
+    struct ProjAndProjRef(#[pin] ());
+
+    #[pin_project(project = A, project_replace = A)] //~ ERROR name `A` is already specified by `project` argument
+    struct ProjAndProjOwn(#[pin] ());
+
+    #[pin_project(project_ref = A, project_replace = A)] //~ ERROR name `A` is already specified by `project_ref` argument
+    struct ProjRefAndProjOwn(#[pin] ());
+}
+
+mod pin_project_attribute {
+    use pin_project::pin_project;
+
+    #[pin_project]
+    #[pin_project] //~ ERROR duplicate #[pin_project] attribute
+    struct Duplicate(#[pin] ());
+}
+
+mod pin_project_item {
+    use pin_project::pin_project;
+
+    #[pin_project]
+    struct Struct {} //~ ERROR may not be used on structs with zero fields
+
+    #[pin_project]
+    struct TupleStruct(); //~ ERROR may not be used on structs with zero fields
+
+    #[pin_project]
+    struct UnitStruct; //~ ERROR may not be used on structs with zero fields
+
+    #[pin_project]
+    enum EnumEmpty {} //~ ERROR may not be used on enums without variants
+
+    #[pin_project]
+    enum EnumDiscriminant {
+        V = 2, //~ ERROR may not be used on enums with discriminants
+    }
+
+    #[pin_project]
+    enum EnumZeroFields {
+        Unit, //~ ERROR may not be used on enums with zero fields
+        Tuple(),
+        Struct {},
+    }
+
+    #[pin_project]
+    union Union {
+        //~^ ERROR may only be used on structs or enums
+        f: (),
+    }
+
+    #[pin_project]
+    impl Impl {} //~ ERROR may only be used on structs or enums
+}
+
+// #[repr(packed)] is always detected first, even on unsupported structs.
+mod pin_project_item_packed {
+    use pin_project::pin_project;
+
+    #[pin_project]
+    #[repr(packed)]
+    struct Struct {} //~ ERROR may not be used on #[repr(packed)] types
+
+    #[pin_project]
+    #[repr(packed)]
+    struct TupleStruct(); //~ ERROR may not be used on #[repr(packed)] types
+
+    #[pin_project]
+    #[repr(packed)]
+    struct UnitStruct; //~ ERROR may not be used on #[repr(packed)] types
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/ui/pin_project/invalid.stderr b/crates/pin-project/tests/ui/pin_project/invalid.stderr
new file mode 100644
index 0000000..ec5205f
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/invalid.stderr
@@ -0,0 +1,364 @@
+error: unexpected token in attribute
+ --> tests/ui/pin_project/invalid.rs:6:14
+  |
+6 |         #[pin()] //~ ERROR unexpected token in attribute
+  |              ^
+
+error: unexpected token in attribute
+  --> tests/ui/pin_project/invalid.rs:11:29
+   |
+11 |     struct TupleStruct(#[pin(foo)] ()); //~ ERROR unexpected token in attribute
+   |                             ^
+
+error: unexpected token in attribute
+  --> tests/ui/pin_project/invalid.rs:15:16
+   |
+15 |         V(#[pin(foo)] ()), //~ ERROR unexpected token in attribute
+   |                ^
+
+error: unexpected token in attribute
+  --> tests/ui/pin_project/invalid.rs:21:18
+   |
+21 |             #[pin(foo)] //~ ERROR unexpected token in attribute
+   |                  ^
+
+error: duplicate #[pin] attribute
+  --> tests/ui/pin_project/invalid.rs:33:9
+   |
+33 |         #[pin] //~ ERROR duplicate #[pin] attribute
+   |         ^^^^^^
+
+error: duplicate #[pin] attribute
+  --> tests/ui/pin_project/invalid.rs:40:9
+   |
+40 |         #[pin]
+   |         ^^^^^^
+
+error: duplicate #[pin] attribute
+  --> tests/ui/pin_project/invalid.rs:49:13
+   |
+49 |             #[pin]
+   |             ^^^^^^
+
+error: duplicate #[pin] attribute
+  --> tests/ui/pin_project/invalid.rs:59:13
+   |
+59 |             #[pin] //~ ERROR duplicate #[pin] attribute
+   |             ^^^^^^
+
+error: #[pin] attribute may only be used on fields of structs or variants
+  --> tests/ui/pin_project/invalid.rs:69:5
+   |
+69 |     #[pin] //~ ERROR may only be used on fields of structs or variants
+   |     ^^^^^^
+
+error: #[pin] attribute may only be used on fields of structs or variants
+  --> tests/ui/pin_project/invalid.rs:77:9
+   |
+77 |         #[pin] //~ ERROR may only be used on fields of structs or variants
+   |         ^^^^^^
+
+error: #[pin] attribute may only be used on fields of structs or variants
+  --> tests/ui/pin_project/invalid.rs:82:5
+   |
+82 |     #[pin] //~ ERROR may only be used on fields of structs or variants
+   |     ^^^^^^
+
+error: `Replace` argument was removed, use `project_replace` argument instead
+  --> tests/ui/pin_project/invalid.rs:91:19
+   |
+91 |     #[pin_project(Replace)] //~ ERROR `Replace` argument was removed, use `project_replace` argument instead
+   |                   ^^^^^^^
+
+error: expected identifier
+  --> tests/ui/pin_project/invalid.rs:94:31
+   |
+94 |     #[pin_project(UnsafeUnpin,,)] //~ ERROR expected identifier
+   |                               ^
+
+error: unexpected argument: Foo
+  --> tests/ui/pin_project/invalid.rs:97:19
+   |
+97 |     #[pin_project(Foo)] //~ ERROR unexpected argument
+   |                   ^^^
+
+error: expected identifier
+   --> tests/ui/pin_project/invalid.rs:100:19
+    |
+100 |     #[pin_project(,UnsafeUnpin)] //~ ERROR expected identifier
+    |                   ^
+
+error: expected `,`
+   --> tests/ui/pin_project/invalid.rs:106:30
+    |
+106 |     #[pin_project(PinnedDrop PinnedDrop)] //~ ERROR expected `,`
+    |                              ^^^^^^^^^^
+
+error: duplicate `PinnedDrop` argument
+   --> tests/ui/pin_project/invalid.rs:109:31
+    |
+109 |     #[pin_project(PinnedDrop, PinnedDrop)] //~ ERROR duplicate `PinnedDrop` argument
+    |                               ^^^^^^^^^^
+
+error: duplicate `UnsafeUnpin` argument
+   --> tests/ui/pin_project/invalid.rs:112:32
+    |
+112 |     #[pin_project(UnsafeUnpin, UnsafeUnpin)] //~ ERROR duplicate `UnsafeUnpin` argument
+    |                                ^^^^^^^^^^^
+
+error: duplicate `!Unpin` argument
+   --> tests/ui/pin_project/invalid.rs:115:27
+    |
+115 |     #[pin_project(!Unpin, !Unpin)] //~ ERROR duplicate `!Unpin` argument
+    |                           ^^^^^^
+
+error: duplicate `UnsafeUnpin` argument
+   --> tests/ui/pin_project/invalid.rs:118:44
+    |
+118 |     #[pin_project(PinnedDrop, UnsafeUnpin, UnsafeUnpin)] //~ ERROR duplicate `UnsafeUnpin` argument
+    |                                            ^^^^^^^^^^^
+
+error: duplicate `PinnedDrop` argument
+   --> tests/ui/pin_project/invalid.rs:121:44
+    |
+121 |     #[pin_project(PinnedDrop, UnsafeUnpin, PinnedDrop, UnsafeUnpin)] //~ ERROR duplicate `PinnedDrop` argument
+    |                                            ^^^^^^^^^^
+
+error: duplicate `project` argument
+   --> tests/ui/pin_project/invalid.rs:124:32
+    |
+124 |     #[pin_project(project = A, project = B)] //~ ERROR duplicate `project` argument
+    |                                ^^^^^^^^^^^
+
+error: duplicate `project` argument
+   --> tests/ui/pin_project/invalid.rs:127:49
+    |
+127 |     #[pin_project(project = A, project_ref = A, project = B)] //~ ERROR duplicate `project` argument
+    |                                                 ^^^^^^^^^^^
+
+error: duplicate `project_ref` argument
+   --> tests/ui/pin_project/invalid.rs:130:36
+    |
+130 |     #[pin_project(project_ref = A, project_ref = B)] //~ ERROR duplicate `project_ref` argument
+    |                                    ^^^^^^^^^^^^^^^
+
+error: duplicate `project_replace` argument
+   --> tests/ui/pin_project/invalid.rs:133:40
+    |
+133 |     #[pin_project(project_replace = A, project_replace = B)] //~ ERROR duplicate `project_replace` argument
+    |                                        ^^^^^^^^^^^^^^^^^^^
+
+error: duplicate `project_replace` argument
+   --> tests/ui/pin_project/invalid.rs:136:36
+    |
+136 |     #[pin_project(project_replace, project_replace = B)] //~ ERROR duplicate `project_replace` argument
+    |                                    ^^^^^^^^^^^^^^^^^^^
+
+error: duplicate `project_replace` argument
+   --> tests/ui/pin_project/invalid.rs:139:40
+    |
+139 |     #[pin_project(project_replace = A, project_replace)] //~ ERROR duplicate `project_replace` argument
+    |                                        ^^^^^^^^^^^^^^^
+
+error: arguments `PinnedDrop` and `project_replace` are mutually exclusive
+   --> tests/ui/pin_project/invalid.rs:145:19
+    |
+145 |     #[pin_project(PinnedDrop, project_replace)] //~ ERROR arguments `PinnedDrop` and `project_replace` are mutually exclusive
+    |                   ^^^^^^^^^^
+
+error: arguments `PinnedDrop` and `project_replace` are mutually exclusive
+   --> tests/ui/pin_project/invalid.rs:148:49
+    |
+148 |     #[pin_project(project_replace, UnsafeUnpin, PinnedDrop)] //~ ERROR arguments `PinnedDrop` and `project_replace` are mutually exclusive
+    |                                                 ^^^^^^^^^^
+
+error: arguments `UnsafeUnpin` and `!Unpin` are mutually exclusive
+   --> tests/ui/pin_project/invalid.rs:151:19
+    |
+151 |     #[pin_project(UnsafeUnpin, !Unpin)] //~ ERROR arguments `UnsafeUnpin` and `!Unpin` are mutually exclusive
+    |                   ^^^^^^^^^^^
+
+error: arguments `UnsafeUnpin` and `!Unpin` are mutually exclusive
+   --> tests/ui/pin_project/invalid.rs:154:39
+    |
+154 |     #[pin_project(!Unpin, PinnedDrop, UnsafeUnpin)] //~ ERROR arguments `UnsafeUnpin` and `!Unpin` are mutually exclusive
+    |                                       ^^^^^^^^^^^
+
+error: expected `!Unpin`, found `!`
+   --> tests/ui/pin_project/invalid.rs:157:19
+    |
+157 |     #[pin_project(!)] //~ ERROR expected `!Unpin`, found `!`
+    |                   ^
+
+error: unexpected argument: Unpin
+   --> tests/ui/pin_project/invalid.rs:160:19
+    |
+160 |     #[pin_project(Unpin)] //~ ERROR unexpected argument
+    |                   ^^^^^
+
+error: expected `project = <identifier>`, found `project`
+   --> tests/ui/pin_project/invalid.rs:163:19
+    |
+163 |     #[pin_project(project)] //~ ERROR expected `project = <identifier>`, found `project`
+    |                   ^^^^^^^
+
+error: expected `project = <identifier>`, found `project =`
+   --> tests/ui/pin_project/invalid.rs:166:19
+    |
+166 |     #[pin_project(project = )] //~ ERROR expected `project = <identifier>`, found `project =`
+    |                   ^^^^^^^^^
+
+error: expected identifier
+   --> tests/ui/pin_project/invalid.rs:169:29
+    |
+169 |     #[pin_project(project = !)] //~ ERROR expected identifier
+    |                             ^
+
+error: expected `project_ref = <identifier>`, found `project_ref`
+   --> tests/ui/pin_project/invalid.rs:172:19
+    |
+172 |     #[pin_project(project_ref)] //~ ERROR expected `project_ref = <identifier>`, found `project_ref`
+    |                   ^^^^^^^^^^^
+
+error: expected `project_ref = <identifier>`, found `project_ref =`
+   --> tests/ui/pin_project/invalid.rs:175:19
+    |
+175 |     #[pin_project(project_ref = )] //~ ERROR expected `project_ref = <identifier>`, found `project_ref =`
+    |                   ^^^^^^^^^^^^^
+
+error: expected identifier
+   --> tests/ui/pin_project/invalid.rs:178:33
+    |
+178 |     #[pin_project(project_ref = !)] //~ ERROR expected identifier
+    |                                 ^
+
+error: expected `project_replace = <identifier>`, found `project_replace =`
+   --> tests/ui/pin_project/invalid.rs:184:19
+    |
+184 |     #[pin_project(project_replace = )] //~ ERROR expected `project_replace = <identifier>`, found `project_replace =`
+    |                   ^^^^^^^^^^^^^^^^^
+
+error: expected identifier
+   --> tests/ui/pin_project/invalid.rs:187:37
+    |
+187 |     #[pin_project(project_replace = !)] //~ ERROR expected identifier
+    |                                     ^
+
+error: `project_replace` argument requires a value when used on enums
+   --> tests/ui/pin_project/invalid.rs:190:19
+    |
+190 |     #[pin_project(project_replace)] //~ ERROR `project_replace` argument requires a value when used on enums
+    |                   ^^^^^^^^^^^^^^^
+
+error: name `OrigAndProj` is the same as the original type name
+   --> tests/ui/pin_project/invalid.rs:199:29
+    |
+199 |     #[pin_project(project = OrigAndProj)] //~ ERROR name `OrigAndProj` is the same as the original type name
+    |                             ^^^^^^^^^^^
+
+error: name `OrigAndProjRef` is the same as the original type name
+   --> tests/ui/pin_project/invalid.rs:202:33
+    |
+202 |     #[pin_project(project_ref = OrigAndProjRef)] //~ ERROR name `OrigAndProjRef` is the same as the original type name
+    |                                 ^^^^^^^^^^^^^^
+
+error: name `OrigAndProjOwn` is the same as the original type name
+   --> tests/ui/pin_project/invalid.rs:205:37
+    |
+205 |     #[pin_project(project_replace = OrigAndProjOwn)] //~ ERROR name `OrigAndProjOwn` is the same as the original type name
+    |                                     ^^^^^^^^^^^^^^
+
+error: name `A` is already specified by `project` argument
+   --> tests/ui/pin_project/invalid.rs:208:46
+    |
+208 |     #[pin_project(project = A, project_ref = A)] //~ ERROR name `A` is already specified by `project` argument
+    |                                              ^
+
+error: name `A` is already specified by `project` argument
+   --> tests/ui/pin_project/invalid.rs:211:50
+    |
+211 |     #[pin_project(project = A, project_replace = A)] //~ ERROR name `A` is already specified by `project` argument
+    |                                                  ^
+
+error: name `A` is already specified by `project_ref` argument
+   --> tests/ui/pin_project/invalid.rs:214:54
+    |
+214 |     #[pin_project(project_ref = A, project_replace = A)] //~ ERROR name `A` is already specified by `project_ref` argument
+    |                                                      ^
+
+error: duplicate #[pin_project] attribute
+   --> tests/ui/pin_project/invalid.rs:222:5
+    |
+222 |     #[pin_project] //~ ERROR duplicate #[pin_project] attribute
+    |     ^^^^^^^^^^^^^^
+
+error: #[pin_project] attribute may not be used on structs with zero fields
+   --> tests/ui/pin_project/invalid.rs:230:19
+    |
+230 |     struct Struct {} //~ ERROR may not be used on structs with zero fields
+    |                   ^^
+
+error: #[pin_project] attribute may not be used on structs with zero fields
+   --> tests/ui/pin_project/invalid.rs:233:23
+    |
+233 |     struct TupleStruct(); //~ ERROR may not be used on structs with zero fields
+    |                       ^^
+
+error: #[pin_project] attribute may not be used on structs with zero fields
+   --> tests/ui/pin_project/invalid.rs:236:12
+    |
+236 |     struct UnitStruct; //~ ERROR may not be used on structs with zero fields
+    |            ^^^^^^^^^^
+
+error: #[pin_project] attribute may not be used on enums without variants
+   --> tests/ui/pin_project/invalid.rs:239:20
+    |
+239 |     enum EnumEmpty {} //~ ERROR may not be used on enums without variants
+    |                    ^^
+
+error: #[pin_project] attribute may not be used on enums with discriminants
+   --> tests/ui/pin_project/invalid.rs:243:13
+    |
+243 |         V = 2, //~ ERROR may not be used on enums with discriminants
+    |             ^
+
+error: #[pin_project] attribute may not be used on enums with zero fields
+   --> tests/ui/pin_project/invalid.rs:248:9
+    |
+248 | /         Unit, //~ ERROR may not be used on enums with zero fields
+249 | |         Tuple(),
+250 | |         Struct {},
+    | |__________________^
+
+error: #[pin_project] attribute may only be used on structs or enums
+   --> tests/ui/pin_project/invalid.rs:254:5
+    |
+254 | /     union Union {
+255 | |         //~^ ERROR may only be used on structs or enums
+256 | |         f: (),
+257 | |     }
+    | |_____^
+
+error: #[pin_project] attribute may only be used on structs or enums
+   --> tests/ui/pin_project/invalid.rs:260:5
+    |
+260 |     impl Impl {} //~ ERROR may only be used on structs or enums
+    |     ^^^^^^^^^^^^
+
+error: #[pin_project] attribute may not be used on #[repr(packed)] types
+   --> tests/ui/pin_project/invalid.rs:268:12
+    |
+268 |     #[repr(packed)]
+    |            ^^^^^^
+
+error: #[pin_project] attribute may not be used on #[repr(packed)] types
+   --> tests/ui/pin_project/invalid.rs:272:12
+    |
+272 |     #[repr(packed)]
+    |            ^^^^^^
+
+error: #[pin_project] attribute may not be used on #[repr(packed)] types
+   --> tests/ui/pin_project/invalid.rs:276:12
+    |
+276 |     #[repr(packed)]
+    |            ^^^^^^
diff --git a/crates/pin-project/tests/ui/pin_project/overlapping_unpin_struct.rs b/crates/pin-project/tests/ui/pin_project/overlapping_unpin_struct.rs
new file mode 100644
index 0000000..abfd5d1
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/overlapping_unpin_struct.rs
@@ -0,0 +1,19 @@
+use std::marker::PhantomPinned;
+
+use pin_project::pin_project;
+
+#[pin_project]
+struct S<T> {
+    #[pin]
+    f: T,
+}
+
+struct __S {}
+
+impl Unpin for __S {}
+
+fn is_unpin<T: Unpin>() {}
+
+fn main() {
+    is_unpin::<S<PhantomPinned>>(); //~ ERROR E0277
+}
diff --git a/crates/pin-project/tests/ui/pin_project/overlapping_unpin_struct.stderr b/crates/pin-project/tests/ui/pin_project/overlapping_unpin_struct.stderr
new file mode 100644
index 0000000..b9efd72
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/overlapping_unpin_struct.stderr
@@ -0,0 +1,26 @@
+error[E0277]: `PhantomPinned` cannot be unpinned
+  --> tests/ui/pin_project/overlapping_unpin_struct.rs:18:16
+   |
+18 |     is_unpin::<S<PhantomPinned>>(); //~ ERROR E0277
+   |                ^^^^^^^^^^^^^^^^ within `_::__S<'_, PhantomPinned>`, the trait `Unpin` is not implemented for `PhantomPinned`
+   |
+   = note: consider using the `pin!` macro
+           consider using `Box::pin` if you need to access the pinned value outside of the current scope
+note: required because it appears within the type `__S<'_, PhantomPinned>`
+  --> tests/ui/pin_project/overlapping_unpin_struct.rs:6:8
+   |
+6  | struct S<T> {
+   |        ^
+note: required for `S<PhantomPinned>` to implement `Unpin`
+  --> tests/ui/pin_project/overlapping_unpin_struct.rs:5:1
+   |
+5  | #[pin_project]
+   | ^^^^^^^^^^^^^^ unsatisfied trait bound introduced in this `derive` macro
+6  | struct S<T> {
+   |        ^^^^
+note: required by a bound in `is_unpin`
+  --> tests/ui/pin_project/overlapping_unpin_struct.rs:15:16
+   |
+15 | fn is_unpin<T: Unpin>() {}
+   |                ^^^^^ required by this bound in `is_unpin`
+   = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/crates/pin-project/tests/ui/pin_project/override-priv-mod.rs b/crates/pin-project/tests/ui/pin_project/override-priv-mod.rs
new file mode 100644
index 0000000..68285d3
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/override-priv-mod.rs
@@ -0,0 +1,34 @@
+// https://discord.com/channels/273534239310479360/512792629516173323/870075511009857617
+
+#![allow(hidden_glob_reexports)]
+
+extern crate pin_project as pin_project_orig;
+extern crate self as pin_project;
+
+pub use ::pin_project_orig::*;
+mod __private {
+    pub use ::pin_project_orig::__private::*;
+    pub trait Drop {}
+}
+
+use std::{marker::PhantomPinned, mem};
+
+#[pin_project] //~ ERROR conflicting implementations of trait `_::FooMustNotImplDrop`
+struct S {
+    #[pin]
+    f: (u8, PhantomPinned),
+}
+
+impl Drop for S {
+    fn drop(&mut self) {
+        let prev = &self.f.0 as *const _ as usize;
+        let moved = mem::take(&mut self.f); // move pinned field
+        let moved = &moved.0 as *const _ as usize;
+        assert_eq!(prev, moved); // panic
+    }
+}
+
+fn main() {
+    let mut x = Box::pin(S { f: (1, PhantomPinned) });
+    let _f = x.as_mut().project().f; // first mutable access
+}
diff --git a/crates/pin-project/tests/ui/pin_project/override-priv-mod.stderr b/crates/pin-project/tests/ui/pin_project/override-priv-mod.stderr
new file mode 100644
index 0000000..2e76c0a
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/override-priv-mod.stderr
@@ -0,0 +1,10 @@
+error[E0119]: conflicting implementations of trait `SMustNotImplDrop` for type `S`
+  --> tests/ui/pin_project/override-priv-mod.rs:16:1
+   |
+16 | #[pin_project] //~ ERROR conflicting implementations of trait `_::FooMustNotImplDrop`
+   | ^^^^^^^^^^^^^^
+   | |
+   | first implementation here
+   | conflicting implementation for `S`
+   |
+   = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/crates/pin-project/tests/ui/pin_project/packed-enum.rs b/crates/pin-project/tests/ui/pin_project/packed-enum.rs
new file mode 100644
index 0000000..023c08d
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/packed-enum.rs
@@ -0,0 +1,24 @@
+use pin_project::pin_project;
+
+// #[repr(packed)] cannot be apply on enums and will be rejected by rustc.
+// However, we should not rely on the behavior of rustc that rejects this.
+// https://github.com/taiki-e/pin-project/pull/324#discussion_r612388001
+
+#[repr(packed)] //~ ERROR E0517
+enum E1 {
+    V(()),
+}
+
+#[pin_project]
+#[repr(packed)] //~ ERROR E0517
+enum E2 {
+    V(()),
+}
+
+#[repr(packed)] //~ ERROR E0517
+#[pin_project]
+enum E3 {
+    V(()),
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/ui/pin_project/packed-enum.stderr b/crates/pin-project/tests/ui/pin_project/packed-enum.stderr
new file mode 100644
index 0000000..1872211
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/packed-enum.stderr
@@ -0,0 +1,42 @@
+error: #[repr(packed)] attribute should be applied to a struct or union
+  --> tests/ui/pin_project/packed-enum.rs:13:8
+   |
+13 | #[repr(packed)] //~ ERROR E0517
+   |        ^^^^^^
+
+error: #[repr(packed)] attribute should be applied to a struct or union
+  --> tests/ui/pin_project/packed-enum.rs:18:8
+   |
+18 | #[repr(packed)] //~ ERROR E0517
+   |        ^^^^^^
+
+error[E0517]: attribute should be applied to a struct or union
+  --> tests/ui/pin_project/packed-enum.rs:7:8
+   |
+7  |   #[repr(packed)] //~ ERROR E0517
+   |          ^^^^^^
+8  | / enum E1 {
+9  | |     V(()),
+10 | | }
+   | |_- not a struct or union
+
+error[E0517]: attribute should be applied to a struct or union
+  --> tests/ui/pin_project/packed-enum.rs:13:8
+   |
+13 |   #[repr(packed)] //~ ERROR E0517
+   |          ^^^^^^
+14 | / enum E2 {
+15 | |     V(()),
+16 | | }
+   | |_- not a struct or union
+
+error[E0517]: attribute should be applied to a struct or union
+  --> tests/ui/pin_project/packed-enum.rs:18:8
+   |
+18 |   #[repr(packed)] //~ ERROR E0517
+   |          ^^^^^^
+19 |   #[pin_project]
+20 | / enum E3 {
+21 | |     V(()),
+22 | | }
+   | |_- not a struct or union
diff --git a/crates/pin-project/tests/ui/pin_project/packed-name-value.rs b/crates/pin-project/tests/ui/pin_project/packed-name-value.rs
new file mode 100644
index 0000000..dedc403
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/packed-name-value.rs
@@ -0,0 +1,27 @@
+use pin_project::pin_project;
+
+// #[repr(packed = "")] is not valid format of #[repr(packed)] and will be
+// rejected by rustc.
+// However, we should not rely on the behavior of rustc that rejects this.
+// https://github.com/taiki-e/pin-project/pull/324#discussion_r612388001
+
+// https://github.com/taiki-e/pin-project/pull/324#discussion_r612388001
+// https://github.com/rust-lang/rust/issues/83921
+// #[repr(packed = "")] //~ ERROR E0552
+// struct S1 {
+//     f: (),
+// }
+
+#[pin_project]
+#[repr(packed = "")] //~ ERROR attribute should not be name-value pair
+struct S2 {
+    f: (),
+}
+
+#[repr(packed = "")] //~ ERROR attribute should not be name-value pair
+#[pin_project]
+struct S3 {
+    f: (),
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/ui/pin_project/packed-name-value.stderr b/crates/pin-project/tests/ui/pin_project/packed-name-value.stderr
new file mode 100644
index 0000000..d8b2194
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/packed-name-value.stderr
@@ -0,0 +1,23 @@
+error: #[repr(packed)] attribute should not be name-value pair
+  --> tests/ui/pin_project/packed-name-value.rs:16:8
+   |
+16 | #[repr(packed = "")] //~ ERROR attribute should not be name-value pair
+   |        ^^^^^^^^^^^
+
+error: #[repr(packed)] attribute should not be name-value pair
+  --> tests/ui/pin_project/packed-name-value.rs:21:8
+   |
+21 | #[repr(packed = "")] //~ ERROR attribute should not be name-value pair
+   |        ^^^^^^^^^^^
+
+error[E0693]: incorrect `repr(packed)` attribute format
+  --> tests/ui/pin_project/packed-name-value.rs:16:8
+   |
+16 | #[repr(packed = "")] //~ ERROR attribute should not be name-value pair
+   |        ^^^^^^^^^^^ help: use parentheses instead: `packed()`
+
+error[E0693]: incorrect `repr(packed)` attribute format
+  --> tests/ui/pin_project/packed-name-value.rs:21:8
+   |
+21 | #[repr(packed = "")] //~ ERROR attribute should not be name-value pair
+   |        ^^^^^^^^^^^ help: use parentheses instead: `packed()`
diff --git a/crates/pin-project/tests/ui/pin_project/packed.rs b/crates/pin-project/tests/ui/pin_project/packed.rs
new file mode 100644
index 0000000..dd3ebfd
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/packed.rs
@@ -0,0 +1,33 @@
+use pin_project::pin_project;
+
+#[pin_project]
+#[repr(packed, C)] //~ ERROR may not be used on #[repr(packed)] types
+struct Packed1 {
+    #[pin]
+    f: u8,
+}
+
+// Test putting 'repr' before the 'pin_project' attribute
+#[repr(packed, C)] //~ ERROR may not be used on #[repr(packed)] types
+#[pin_project]
+struct Packed2 {
+    #[pin]
+    f: u8,
+}
+
+#[pin_project]
+#[repr(packed(2))] //~ ERROR may not be used on #[repr(packed)] types
+struct PackedN1 {
+    #[pin]
+    f: u32,
+}
+
+// Test putting 'repr' before the 'pin_project' attribute
+#[repr(packed(2))] //~ ERROR may not be used on #[repr(packed)] types
+#[pin_project]
+struct PackedN2 {
+    #[pin]
+    f: u32,
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/ui/pin_project/packed.stderr b/crates/pin-project/tests/ui/pin_project/packed.stderr
new file mode 100644
index 0000000..25ea5f4
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/packed.stderr
@@ -0,0 +1,23 @@
+error: #[pin_project] attribute may not be used on #[repr(packed)] types
+ --> tests/ui/pin_project/packed.rs:4:8
+  |
+4 | #[repr(packed, C)] //~ ERROR may not be used on #[repr(packed)] types
+  |        ^^^^^^
+
+error: #[pin_project] attribute may not be used on #[repr(packed)] types
+  --> tests/ui/pin_project/packed.rs:11:8
+   |
+11 | #[repr(packed, C)] //~ ERROR may not be used on #[repr(packed)] types
+   |        ^^^^^^
+
+error: #[pin_project] attribute may not be used on #[repr(packed)] types
+  --> tests/ui/pin_project/packed.rs:19:8
+   |
+19 | #[repr(packed(2))] //~ ERROR may not be used on #[repr(packed)] types
+   |        ^^^^^^^^^
+
+error: #[pin_project] attribute may not be used on #[repr(packed)] types
+  --> tests/ui/pin_project/packed.rs:26:8
+   |
+26 | #[repr(packed(2))] //~ ERROR may not be used on #[repr(packed)] types
+   |        ^^^^^^^^^
diff --git a/crates/pin-project/tests/ui/pin_project/packed_sneaky-1.rs b/crates/pin-project/tests/ui/pin_project/packed_sneaky-1.rs
new file mode 100644
index 0000000..83a4612
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/packed_sneaky-1.rs
@@ -0,0 +1,41 @@
+use std::pin::Pin;
+
+use auxiliary_macro::{hidden_repr, hidden_repr2};
+use pin_project::{pin_project, pinned_drop, UnsafeUnpin};
+
+#[pin_project] //~ ERROR may not be used on #[repr(packed)] types
+#[hidden_repr(packed)]
+struct A {
+    #[pin]
+    f: u32,
+}
+
+#[hidden_repr2]
+#[pin_project] //~ ERROR may not be used on #[repr(packed)] types
+struct B {
+    #[pin]
+    f: u32,
+}
+
+#[pin_project(UnsafeUnpin)] //~ ERROR may not be used on #[repr(packed)] types
+#[hidden_repr(packed)]
+struct C {
+    #[pin]
+    f: u32,
+}
+
+unsafe impl UnsafeUnpin for C {}
+
+#[pin_project(PinnedDrop)] //~ ERROR may not be used on #[repr(packed)] types
+#[hidden_repr(packed)]
+struct D {
+    #[pin]
+    f: u32,
+}
+
+#[pinned_drop]
+impl PinnedDrop for D {
+    fn drop(self: Pin<&mut Self>) {}
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/ui/pin_project/packed_sneaky-1.stderr b/crates/pin-project/tests/ui/pin_project/packed_sneaky-1.stderr
new file mode 100644
index 0000000..0746e1a
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/packed_sneaky-1.stderr
@@ -0,0 +1,25 @@
+error: #[pin_project] attribute may not be used on #[repr(packed)] types
+ --> tests/ui/pin_project/packed_sneaky-1.rs:7:15
+  |
+7 | #[hidden_repr(packed)]
+  |               ^^^^^^
+
+error: #[pin_project] attribute may not be used on #[repr(packed)] types
+  --> tests/ui/pin_project/packed_sneaky-1.rs:13:1
+   |
+13 | #[hidden_repr2]
+   | ^^^^^^^^^^^^^^^
+   |
+   = note: this error originates in the attribute macro `hidden_repr2` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: #[pin_project] attribute may not be used on #[repr(packed)] types
+  --> tests/ui/pin_project/packed_sneaky-1.rs:21:15
+   |
+21 | #[hidden_repr(packed)]
+   |               ^^^^^^
+
+error: #[pin_project] attribute may not be used on #[repr(packed)] types
+  --> tests/ui/pin_project/packed_sneaky-1.rs:30:15
+   |
+30 | #[hidden_repr(packed)]
+   |               ^^^^^^
diff --git a/crates/pin-project/tests/ui/pin_project/packed_sneaky-2.rs b/crates/pin-project/tests/ui/pin_project/packed_sneaky-2.rs
new file mode 100644
index 0000000..b098358
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/packed_sneaky-2.rs
@@ -0,0 +1,12 @@
+use auxiliary_macro::hidden_repr_macro;
+use pin_project::pin_project;
+
+hidden_repr_macro! { //~ ERROR may not be used on #[repr(packed)] types
+    #[pin_project]
+    struct B {
+        #[pin]
+        f: u32,
+    }
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/ui/pin_project/packed_sneaky-2.stderr b/crates/pin-project/tests/ui/pin_project/packed_sneaky-2.stderr
new file mode 100644
index 0000000..d643052
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/packed_sneaky-2.stderr
@@ -0,0 +1,13 @@
+error: #[pin_project] attribute may not be used on #[repr(packed)] types
+  --> tests/ui/pin_project/packed_sneaky-2.rs:4:1
+   |
+4  | / hidden_repr_macro! { //~ ERROR may not be used on #[repr(packed)] types
+5  | |     #[pin_project]
+6  | |     struct B {
+7  | |         #[pin]
+8  | |         f: u32,
+9  | |     }
+10 | | }
+   | |_^
+   |
+   = note: this error originates in the macro `hidden_repr_macro` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/crates/pin-project/tests/ui/pin_project/packed_sneaky-3.rs b/crates/pin-project/tests/ui/pin_project/packed_sneaky-3.rs
new file mode 100644
index 0000000..d3f00f3
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/packed_sneaky-3.rs
@@ -0,0 +1,32 @@
+use auxiliary_macro::{hidden_repr_macro, HiddenRepr};
+use pin_project::pin_project;
+
+hidden_repr_macro! {} //~ ERROR expected item after attributes
+#[pin_project]
+struct S1 {
+    #[pin]
+    f: u32,
+}
+
+macro_rules! hidden_repr_macro2 {
+    () => {
+        #[repr(packed)] //~ ERROR expected item after attributes
+    };
+}
+
+hidden_repr_macro2! {}
+#[pin_project]
+struct S2 {
+    #[pin]
+    f: u32,
+}
+
+#[derive(HiddenRepr)] //~ ERROR expected item after attributes
+struct S3 {}
+#[pin_project]
+struct S4 {
+    #[pin]
+    f: u32,
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/ui/pin_project/packed_sneaky-3.stderr b/crates/pin-project/tests/ui/pin_project/packed_sneaky-3.stderr
new file mode 100644
index 0000000..c181bb3
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/packed_sneaky-3.stderr
@@ -0,0 +1,32 @@
+error: expected item after attributes
+ --> tests/ui/pin_project/packed_sneaky-3.rs:4:1
+  |
+4 | hidden_repr_macro! {} //~ ERROR expected item after attributes
+  | ^^^^^^^^^^^^^^^^^^^^^
+  |
+  = note: this error originates in the macro `hidden_repr_macro` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected item after attributes
+  --> tests/ui/pin_project/packed_sneaky-3.rs:13:9
+   |
+13 |         #[repr(packed)] //~ ERROR expected item after attributes
+   |         ^^^^^^^^^^^^^^^
+...
+17 | hidden_repr_macro2! {}
+   | ---------------------- in this macro invocation
+   |
+   = note: this error originates in the macro `hidden_repr_macro2` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected item after attributes
+  --> tests/ui/pin_project/packed_sneaky-3.rs:24:10
+   |
+24 | #[derive(HiddenRepr)] //~ ERROR expected item after attributes
+   |          ^^^^^^^^^^
+   |
+   = note: this error originates in the derive macro `HiddenRepr` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: proc-macro derive produced unparsable tokens
+  --> tests/ui/pin_project/packed_sneaky-3.rs:24:10
+   |
+24 | #[derive(HiddenRepr)] //~ ERROR expected item after attributes
+   |          ^^^^^^^^^^
diff --git a/crates/pin-project/tests/ui/pin_project/packed_sneaky-4.rs b/crates/pin-project/tests/ui/pin_project/packed_sneaky-4.rs
new file mode 100644
index 0000000..4f40907
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/packed_sneaky-4.rs
@@ -0,0 +1,13 @@
+// https://github.com/taiki-e/pin-project/issues/342
+
+use auxiliary_macro::hidden_repr2;
+use pin_project::pin_project;
+
+#[pin_project] //~ ERROR reference to packed field is unaligned
+#[hidden_repr2]
+struct A {
+    #[pin]
+    f: u32,
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/ui/pin_project/packed_sneaky-4.stderr b/crates/pin-project/tests/ui/pin_project/packed_sneaky-4.stderr
new file mode 100644
index 0000000..2c24367
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/packed_sneaky-4.stderr
@@ -0,0 +1,20 @@
+error[E0793]: reference to packed field is unaligned
+  --> tests/ui/pin_project/packed_sneaky-4.rs:10:5
+   |
+10 |     f: u32,
+   |     ^
+   |
+   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
+   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
+   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
+
+error[E0793]: reference to packed field is unaligned
+ --> tests/ui/pin_project/packed_sneaky-4.rs:6:1
+  |
+6 | #[pin_project] //~ ERROR reference to packed field is unaligned
+  | ^^^^^^^^^^^^^^
+  |
+  = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
+  = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
+  = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
+  = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/crates/pin-project/tests/ui/pin_project/private_in_public-enum.rs b/crates/pin-project/tests/ui/pin_project/private_in_public-enum.rs
new file mode 100644
index 0000000..d55baeb
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/private_in_public-enum.rs
@@ -0,0 +1,23 @@
+// Even if allows private_in_public, these are errors.
+
+#![allow(private_in_public, dead_code)]
+
+pub enum PublicEnum {
+    V(PrivateEnum), //~ ERROR E0446
+}
+
+enum PrivateEnum {
+    V(u8),
+}
+
+mod foo {
+    pub(crate) enum CrateEnum {
+        V(PrivateEnum), //~ ERROR E0446
+    }
+
+    enum PrivateEnum {
+        V(u8),
+    }
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/ui/pin_project/private_in_public-enum.stderr b/crates/pin-project/tests/ui/pin_project/private_in_public-enum.stderr
new file mode 100644
index 0000000..c93b265
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/private_in_public-enum.stderr
@@ -0,0 +1,17 @@
+error[E0446]: private type `PrivateEnum` in public interface
+ --> tests/ui/pin_project/private_in_public-enum.rs:6:7
+  |
+6 |     V(PrivateEnum), //~ ERROR E0446
+  |       ^^^^^^^^^^^ can't leak private type
+...
+9 | enum PrivateEnum {
+  | ---------------- `PrivateEnum` declared as private
+
+error[E0446]: private type `foo::PrivateEnum` in public interface
+  --> tests/ui/pin_project/private_in_public-enum.rs:15:11
+   |
+15 |         V(PrivateEnum), //~ ERROR E0446
+   |           ^^^^^^^^^^^ can't leak private type
+...
+18 |     enum PrivateEnum {
+   |     ---------------- `foo::PrivateEnum` declared as private
diff --git a/crates/pin-project/tests/ui/pin_project/project_replace_unsized.rs b/crates/pin-project/tests/ui/pin_project/project_replace_unsized.rs
new file mode 100644
index 0000000..20dde12
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/project_replace_unsized.rs
@@ -0,0 +1,11 @@
+use pin_project::pin_project;
+
+#[pin_project(project_replace)] //~ ERROR E0277
+struct Struct<T: ?Sized> {
+    f: T,
+}
+
+#[pin_project(project_replace)] //~ ERROR E0277
+struct TupleStruct<T: ?Sized>(T);
+
+fn main() {}
diff --git a/crates/pin-project/tests/ui/pin_project/project_replace_unsized.stderr b/crates/pin-project/tests/ui/pin_project/project_replace_unsized.stderr
new file mode 100644
index 0000000..7982dcc
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/project_replace_unsized.stderr
@@ -0,0 +1,124 @@
+error[E0277]: the size for values of type `T` cannot be known at compilation time
+ --> tests/ui/pin_project/project_replace_unsized.rs:3:15
+  |
+3 | #[pin_project(project_replace)] //~ ERROR E0277
+  |               ^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
+4 | struct Struct<T: ?Sized> {
+  |               - this type parameter needs to be `Sized`
+  |
+note: required because it appears within the type `Struct<T>`
+ --> tests/ui/pin_project/project_replace_unsized.rs:4:8
+  |
+4 | struct Struct<T: ?Sized> {
+  |        ^^^^^^
+  = help: unsized fn params are gated as an unstable feature
+help: consider removing the `?Sized` bound to make the type parameter `Sized`
+  |
+4 - struct Struct<T: ?Sized> {
+4 + struct Struct<T> {
+  |
+help: function arguments must have a statically known size, borrowed types always have a known size
+  |
+3 | #[pin_project(&project_replace)] //~ ERROR E0277
+  |               +
+
+error[E0277]: the size for values of type `T` cannot be known at compilation time
+ --> tests/ui/pin_project/project_replace_unsized.rs:3:1
+  |
+3 | #[pin_project(project_replace)] //~ ERROR E0277
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
+4 | struct Struct<T: ?Sized> {
+  |               - this type parameter needs to be `Sized`
+  |
+note: required because it appears within the type `Struct<T>`
+ --> tests/ui/pin_project/project_replace_unsized.rs:4:8
+  |
+4 | struct Struct<T: ?Sized> {
+  |        ^^^^^^
+note: required by a bound in `UnsafeOverwriteGuard::<T>::new`
+ --> src/lib.rs
+  |
+  |     impl<T> UnsafeOverwriteGuard<T> {
+  |          ^ required by this bound in `UnsafeOverwriteGuard::<T>::new`
+  |         #[doc(hidden)]
+  |         pub unsafe fn new(target: *mut T, value: T) -> Self {
+  |                       --- required by a bound in this associated function
+  = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider removing the `?Sized` bound to make the type parameter `Sized`
+    |
+4   - struct Struct<T: ?Sized> {
+4   + struct Struct<T> {
+    |
+
+error[E0277]: the size for values of type `T` cannot be known at compilation time
+ --> tests/ui/pin_project/project_replace_unsized.rs:5:5
+  |
+3 | #[pin_project(project_replace)] //~ ERROR E0277
+  | ------------------------------- required by a bound introduced by this call
+4 | struct Struct<T: ?Sized> {
+  |               - this type parameter needs to be `Sized`
+5 |     f: T,
+  |     ^ doesn't have a size known at compile-time
+  |
+note: required by a bound in `std::ptr::read`
+ --> $RUST/core/src/ptr/mod.rs
+  |
+  | pub const unsafe fn read<T>(src: *const T) -> T {
+  |                          ^ required by this bound in `read`
+help: consider removing the `?Sized` bound to make the type parameter `Sized`
+     |
+4    - struct Struct<T: ?Sized> {
+4    + struct Struct<T> {
+     |
+
+error[E0277]: the size for values of type `T` cannot be known at compilation time
+ --> tests/ui/pin_project/project_replace_unsized.rs:8:15
+  |
+8 | #[pin_project(project_replace)] //~ ERROR E0277
+  |               ^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
+9 | struct TupleStruct<T: ?Sized>(T);
+  |                    - this type parameter needs to be `Sized`
+  |
+note: required because it appears within the type `TupleStruct<T>`
+ --> tests/ui/pin_project/project_replace_unsized.rs:9:8
+  |
+9 | struct TupleStruct<T: ?Sized>(T);
+  |        ^^^^^^^^^^^
+  = help: unsized fn params are gated as an unstable feature
+help: consider removing the `?Sized` bound to make the type parameter `Sized`
+  |
+9 - struct TupleStruct<T: ?Sized>(T);
+9 + struct TupleStruct<T>(T);
+  |
+help: function arguments must have a statically known size, borrowed types always have a known size
+  |
+8 | #[pin_project(&project_replace)] //~ ERROR E0277
+  |               +
+
+error[E0277]: the size for values of type `T` cannot be known at compilation time
+ --> tests/ui/pin_project/project_replace_unsized.rs:8:1
+  |
+8 | #[pin_project(project_replace)] //~ ERROR E0277
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
+9 | struct TupleStruct<T: ?Sized>(T);
+  |                    - this type parameter needs to be `Sized`
+  |
+note: required because it appears within the type `TupleStruct<T>`
+ --> tests/ui/pin_project/project_replace_unsized.rs:9:8
+  |
+9 | struct TupleStruct<T: ?Sized>(T);
+  |        ^^^^^^^^^^^
+note: required by a bound in `UnsafeOverwriteGuard::<T>::new`
+ --> src/lib.rs
+  |
+  |     impl<T> UnsafeOverwriteGuard<T> {
+  |          ^ required by this bound in `UnsafeOverwriteGuard::<T>::new`
+  |         #[doc(hidden)]
+  |         pub unsafe fn new(target: *mut T, value: T) -> Self {
+  |                       --- required by a bound in this associated function
+  = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider removing the `?Sized` bound to make the type parameter `Sized`
+    |
+9   - struct TupleStruct<T: ?Sized>(T);
+9   + struct TupleStruct<T>(T);
+    |
diff --git a/crates/pin-project/tests/ui/pin_project/project_replace_unsized_fn_params.rs b/crates/pin-project/tests/ui/pin_project/project_replace_unsized_fn_params.rs
new file mode 100644
index 0000000..e0fa25b
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/project_replace_unsized_fn_params.rs
@@ -0,0 +1,13 @@
+#![feature(unsized_fn_params)]
+
+use pin_project::pin_project;
+
+#[pin_project(project_replace)] //~ ERROR E0277
+struct Struct<T: ?Sized> {
+    f: T,
+}
+
+#[pin_project(project_replace)] //~ ERROR E0277
+struct TupleStruct<T: ?Sized>(T);
+
+fn main() {}
diff --git a/crates/pin-project/tests/ui/pin_project/project_replace_unsized_fn_params.stderr b/crates/pin-project/tests/ui/pin_project/project_replace_unsized_fn_params.stderr
new file mode 100644
index 0000000..e8e9c8c
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/project_replace_unsized_fn_params.stderr
@@ -0,0 +1,118 @@
+error[E0277]: the size for values of type `T` cannot be known at compilation time
+ --> tests/ui/pin_project/project_replace_unsized_fn_params.rs:6:8
+  |
+6 | struct Struct<T: ?Sized> {
+  |        ^^^^^^^-^^^^^^^^^
+  |        |      |
+  |        |      this type parameter needs to be `Sized`
+  |        doesn't have a size known at compile-time
+  |
+note: required because it appears within the type `__StructProjectionOwned<T>`
+ --> tests/ui/pin_project/project_replace_unsized_fn_params.rs:6:8
+  |
+6 | struct Struct<T: ?Sized> {
+  |        ^^^^^^
+  = note: the return type of a function must have a statically known size
+help: consider removing the `?Sized` bound to make the type parameter `Sized`
+  |
+6 - struct Struct<T: ?Sized> {
+6 + struct Struct<T> {
+  |
+
+error[E0277]: the size for values of type `T` cannot be known at compilation time
+ --> tests/ui/pin_project/project_replace_unsized_fn_params.rs:5:1
+  |
+5 | #[pin_project(project_replace)] //~ ERROR E0277
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
+6 | struct Struct<T: ?Sized> {
+  |               - this type parameter needs to be `Sized`
+  |
+note: required because it appears within the type `Struct<T>`
+ --> tests/ui/pin_project/project_replace_unsized_fn_params.rs:6:8
+  |
+6 | struct Struct<T: ?Sized> {
+  |        ^^^^^^
+note: required by a bound in `UnsafeOverwriteGuard::<T>::new`
+ --> src/lib.rs
+  |
+  |     impl<T> UnsafeOverwriteGuard<T> {
+  |          ^ required by this bound in `UnsafeOverwriteGuard::<T>::new`
+  |         #[doc(hidden)]
+  |         pub unsafe fn new(target: *mut T, value: T) -> Self {
+  |                       --- required by a bound in this associated function
+  = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider removing the `?Sized` bound to make the type parameter `Sized`
+    |
+6   - struct Struct<T: ?Sized> {
+6   + struct Struct<T> {
+    |
+
+error[E0277]: the size for values of type `T` cannot be known at compilation time
+ --> tests/ui/pin_project/project_replace_unsized_fn_params.rs:7:5
+  |
+5 | #[pin_project(project_replace)] //~ ERROR E0277
+  | ------------------------------- required by a bound introduced by this call
+6 | struct Struct<T: ?Sized> {
+  |               - this type parameter needs to be `Sized`
+7 |     f: T,
+  |     ^ doesn't have a size known at compile-time
+  |
+note: required by a bound in `std::ptr::read`
+ --> $RUST/core/src/ptr/mod.rs
+  |
+  | pub const unsafe fn read<T>(src: *const T) -> T {
+  |                          ^ required by this bound in `read`
+help: consider removing the `?Sized` bound to make the type parameter `Sized`
+     |
+6    - struct Struct<T: ?Sized> {
+6    + struct Struct<T> {
+     |
+
+error[E0277]: the size for values of type `T` cannot be known at compilation time
+  --> tests/ui/pin_project/project_replace_unsized_fn_params.rs:11:8
+   |
+11 | struct TupleStruct<T: ?Sized>(T);
+   |        ^^^^^^^^^^^^-^^^^^^^^^
+   |        |           |
+   |        |           this type parameter needs to be `Sized`
+   |        doesn't have a size known at compile-time
+   |
+note: required because it appears within the type `__TupleStructProjectionOwned<T>`
+  --> tests/ui/pin_project/project_replace_unsized_fn_params.rs:11:8
+   |
+11 | struct TupleStruct<T: ?Sized>(T);
+   |        ^^^^^^^^^^^
+   = note: the return type of a function must have a statically known size
+help: consider removing the `?Sized` bound to make the type parameter `Sized`
+   |
+11 - struct TupleStruct<T: ?Sized>(T);
+11 + struct TupleStruct<T>(T);
+   |
+
+error[E0277]: the size for values of type `T` cannot be known at compilation time
+  --> tests/ui/pin_project/project_replace_unsized_fn_params.rs:10:1
+   |
+10 | #[pin_project(project_replace)] //~ ERROR E0277
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
+11 | struct TupleStruct<T: ?Sized>(T);
+   |                    - this type parameter needs to be `Sized`
+   |
+note: required because it appears within the type `TupleStruct<T>`
+  --> tests/ui/pin_project/project_replace_unsized_fn_params.rs:11:8
+   |
+11 | struct TupleStruct<T: ?Sized>(T);
+   |        ^^^^^^^^^^^
+note: required by a bound in `UnsafeOverwriteGuard::<T>::new`
+  --> src/lib.rs
+   |
+   |     impl<T> UnsafeOverwriteGuard<T> {
+   |          ^ required by this bound in `UnsafeOverwriteGuard::<T>::new`
+   |         #[doc(hidden)]
+   |         pub unsafe fn new(target: *mut T, value: T) -> Self {
+   |                       --- required by a bound in this associated function
+   = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider removing the `?Sized` bound to make the type parameter `Sized`
+    |
+11  - struct TupleStruct<T: ?Sized>(T);
+11  + struct TupleStruct<T>(T);
+    |
diff --git a/crates/pin-project/tests/ui/pin_project/remove-attr-from-field.rs b/crates/pin-project/tests/ui/pin_project/remove-attr-from-field.rs
new file mode 100644
index 0000000..fd14da3
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/remove-attr-from-field.rs
@@ -0,0 +1,33 @@
+use std::{marker::PhantomPinned, pin::Pin};
+
+use auxiliary_macro::remove_attr;
+use pin_project::pin_project;
+
+fn is_unpin<T: Unpin>() {}
+
+#[pin_project]
+#[remove_attr(field_all)]
+struct A {
+    #[pin]
+    f: PhantomPinned,
+}
+
+#[remove_attr(field_all)]
+#[pin_project]
+struct B {
+    #[pin]
+    f: PhantomPinned,
+}
+
+fn main() {
+    is_unpin::<A>();
+    is_unpin::<B>();
+
+    let mut x = A { f: PhantomPinned };
+    let x = Pin::new(&mut x).project();
+    let _: Pin<&mut PhantomPinned> = x.f; //~ ERROR E0308
+
+    let mut x = B { f: PhantomPinned };
+    let x = Pin::new(&mut x).project();
+    let _: Pin<&mut PhantomPinned> = x.f; //~ ERROR E0308
+}
diff --git a/crates/pin-project/tests/ui/pin_project/remove-attr-from-field.stderr b/crates/pin-project/tests/ui/pin_project/remove-attr-from-field.stderr
new file mode 100644
index 0000000..f693261
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/remove-attr-from-field.stderr
@@ -0,0 +1,21 @@
+error[E0308]: mismatched types
+  --> tests/ui/pin_project/remove-attr-from-field.rs:28:38
+   |
+28 |     let _: Pin<&mut PhantomPinned> = x.f; //~ ERROR E0308
+   |            -----------------------   ^^^ expected `Pin<&mut PhantomPinned>`, found `&mut PhantomPinned`
+   |            |
+   |            expected due to this
+   |
+   = note:         expected struct `Pin<&mut PhantomPinned>`
+           found mutable reference `&mut PhantomPinned`
+
+error[E0308]: mismatched types
+  --> tests/ui/pin_project/remove-attr-from-field.rs:32:38
+   |
+32 |     let _: Pin<&mut PhantomPinned> = x.f; //~ ERROR E0308
+   |            -----------------------   ^^^ expected `Pin<&mut PhantomPinned>`, found `&mut PhantomPinned`
+   |            |
+   |            expected due to this
+   |
+   = note:         expected struct `Pin<&mut PhantomPinned>`
+           found mutable reference `&mut PhantomPinned`
diff --git a/crates/pin-project/tests/ui/pin_project/remove-attr-from-struct.rs b/crates/pin-project/tests/ui/pin_project/remove-attr-from-struct.rs
new file mode 100644
index 0000000..cbe5aba
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/remove-attr-from-struct.rs
@@ -0,0 +1,47 @@
+use std::{marker::PhantomPinned, pin::Pin};
+
+use auxiliary_macro::remove_attr;
+use pin_project::pin_project;
+
+fn is_unpin<T: Unpin>() {}
+
+#[pin_project]
+#[remove_attr(struct_all)]
+struct A {
+    #[pin] //~ ERROR cannot find attribute `pin` in this scope
+    f: PhantomPinned,
+}
+
+#[remove_attr(struct_all)]
+#[pin_project]
+struct B {
+    #[pin] //~ ERROR cannot find attribute `pin` in this scope
+    f: PhantomPinned,
+}
+
+#[pin_project] //~ ERROR has been removed
+#[remove_attr(struct_pin)]
+struct C {
+    f: PhantomPinned,
+}
+
+#[remove_attr(struct_pin)]
+#[pin_project] // Ok
+struct D {
+    f: PhantomPinned,
+}
+
+fn main() {
+    is_unpin::<A>(); //~ ERROR E0277
+    is_unpin::<B>(); //~ ERROR E0277
+    is_unpin::<D>(); // Ok
+
+    let mut x = A { f: PhantomPinned };
+    let _ = Pin::new(&mut x).project(); //~ ERROR E0277,E0599
+
+    let mut x = B { f: PhantomPinned };
+    let _ = Pin::new(&mut x).project(); //~ ERROR E0277,E0599
+
+    let mut x = D { f: PhantomPinned };
+    let _ = Pin::new(&mut x).project(); //~ Ok
+}
diff --git a/crates/pin-project/tests/ui/pin_project/remove-attr-from-struct.stderr b/crates/pin-project/tests/ui/pin_project/remove-attr-from-struct.stderr
new file mode 100644
index 0000000..0b440dd
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/remove-attr-from-struct.stderr
@@ -0,0 +1,117 @@
+error: #[pin_project] attribute has been removed
+  --> tests/ui/pin_project/remove-attr-from-struct.rs:22:1
+   |
+22 | #[pin_project] //~ ERROR has been removed
+   | ^^^^^^^^^^^^^^
+   |
+   = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: cannot find attribute `pin` in this scope
+  --> tests/ui/pin_project/remove-attr-from-struct.rs:18:7
+   |
+18 |     #[pin] //~ ERROR cannot find attribute `pin` in this scope
+   |       ^^^
+
+error: cannot find attribute `pin` in this scope
+  --> tests/ui/pin_project/remove-attr-from-struct.rs:11:7
+   |
+11 |     #[pin] //~ ERROR cannot find attribute `pin` in this scope
+   |       ^^^
+
+error[E0277]: `PhantomPinned` cannot be unpinned
+  --> tests/ui/pin_project/remove-attr-from-struct.rs:35:16
+   |
+35 |     is_unpin::<A>(); //~ ERROR E0277
+   |                ^ within `A`, the trait `Unpin` is not implemented for `PhantomPinned`
+   |
+   = note: consider using the `pin!` macro
+           consider using `Box::pin` if you need to access the pinned value outside of the current scope
+note: required because it appears within the type `A`
+  --> tests/ui/pin_project/remove-attr-from-struct.rs:10:8
+   |
+10 | struct A {
+   |        ^
+note: required by a bound in `is_unpin`
+  --> tests/ui/pin_project/remove-attr-from-struct.rs:6:16
+   |
+6  | fn is_unpin<T: Unpin>() {}
+   |                ^^^^^ required by this bound in `is_unpin`
+
+error[E0277]: `PhantomPinned` cannot be unpinned
+  --> tests/ui/pin_project/remove-attr-from-struct.rs:36:16
+   |
+36 |     is_unpin::<B>(); //~ ERROR E0277
+   |                ^ within `B`, the trait `Unpin` is not implemented for `PhantomPinned`
+   |
+   = note: consider using the `pin!` macro
+           consider using `Box::pin` if you need to access the pinned value outside of the current scope
+note: required because it appears within the type `B`
+  --> tests/ui/pin_project/remove-attr-from-struct.rs:17:8
+   |
+17 | struct B {
+   |        ^
+note: required by a bound in `is_unpin`
+  --> tests/ui/pin_project/remove-attr-from-struct.rs:6:16
+   |
+6  | fn is_unpin<T: Unpin>() {}
+   |                ^^^^^ required by this bound in `is_unpin`
+
+error[E0277]: `PhantomPinned` cannot be unpinned
+  --> tests/ui/pin_project/remove-attr-from-struct.rs:40:22
+   |
+40 |     let _ = Pin::new(&mut x).project(); //~ ERROR E0277,E0599
+   |             -------- ^^^^^^ within `A`, the trait `Unpin` is not implemented for `PhantomPinned`
+   |             |
+   |             required by a bound introduced by this call
+   |
+   = note: consider using the `pin!` macro
+           consider using `Box::pin` if you need to access the pinned value outside of the current scope
+note: required because it appears within the type `A`
+  --> tests/ui/pin_project/remove-attr-from-struct.rs:10:8
+   |
+10 | struct A {
+   |        ^
+note: required by a bound in `Pin::<P>::new`
+  --> $RUST/core/src/pin.rs
+   |
+   | impl<P: Deref<Target: Unpin>> Pin<P> {
+   |                       ^^^^^ required by this bound in `Pin::<P>::new`
+...
+   |     pub const fn new(pointer: P) -> Pin<P> {
+   |                  --- required by a bound in this associated function
+
+error[E0599]: no method named `project` found for struct `Pin<&mut A>` in the current scope
+  --> tests/ui/pin_project/remove-attr-from-struct.rs:40:30
+   |
+40 |     let _ = Pin::new(&mut x).project(); //~ ERROR E0277,E0599
+   |                              ^^^^^^^ method not found in `Pin<&mut A>`
+
+error[E0277]: `PhantomPinned` cannot be unpinned
+  --> tests/ui/pin_project/remove-attr-from-struct.rs:43:22
+   |
+43 |     let _ = Pin::new(&mut x).project(); //~ ERROR E0277,E0599
+   |             -------- ^^^^^^ within `B`, the trait `Unpin` is not implemented for `PhantomPinned`
+   |             |
+   |             required by a bound introduced by this call
+   |
+   = note: consider using the `pin!` macro
+           consider using `Box::pin` if you need to access the pinned value outside of the current scope
+note: required because it appears within the type `B`
+  --> tests/ui/pin_project/remove-attr-from-struct.rs:17:8
+   |
+17 | struct B {
+   |        ^
+note: required by a bound in `Pin::<P>::new`
+  --> $RUST/core/src/pin.rs
+   |
+   | impl<P: Deref<Target: Unpin>> Pin<P> {
+   |                       ^^^^^ required by this bound in `Pin::<P>::new`
+...
+   |     pub const fn new(pointer: P) -> Pin<P> {
+   |                  --- required by a bound in this associated function
+
+error[E0599]: no method named `project` found for struct `Pin<&mut B>` in the current scope
+  --> tests/ui/pin_project/remove-attr-from-struct.rs:43:30
+   |
+43 |     let _ = Pin::new(&mut x).project(); //~ ERROR E0277,E0599
+   |                              ^^^^^^^ method not found in `Pin<&mut B>`
diff --git a/crates/pin-project/tests/ui/pin_project/safe_packed_borrows.rs b/crates/pin-project/tests/ui/pin_project/safe_packed_borrows.rs
new file mode 100644
index 0000000..8ef144c
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/safe_packed_borrows.rs
@@ -0,0 +1,25 @@
+#![deny(renamed_and_removed_lints)]
+#![deny(safe_packed_borrows)] //~ ERROR has been renamed to `unaligned_references`
+
+// This lint was removed in https://github.com/rust-lang/rust/pull/82525 (nightly-2021-03-28).
+// Refs:
+// - https://github.com/rust-lang/rust/pull/82525
+// - https://github.com/rust-lang/rust/issues/46043
+
+#[repr(packed)]
+struct Packed {
+    f: u32,
+}
+
+#[repr(packed(2))]
+struct PackedN {
+    f: u32,
+}
+
+fn main() {
+    let a = Packed { f: 1 };
+    let _ = &a.f;
+
+    let b = PackedN { f: 1 };
+    let _ = &b.f;
+}
diff --git a/crates/pin-project/tests/ui/pin_project/safe_packed_borrows.stderr b/crates/pin-project/tests/ui/pin_project/safe_packed_borrows.stderr
new file mode 100644
index 0000000..26e6f8d
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/safe_packed_borrows.stderr
@@ -0,0 +1,31 @@
+error: lint `safe_packed_borrows` has been removed: converted into hard error, see issue #82523 <https://github.com/rust-lang/rust/issues/82523> for more information
+ --> tests/ui/pin_project/safe_packed_borrows.rs:2:9
+  |
+2 | #![deny(safe_packed_borrows)] //~ ERROR has been renamed to `unaligned_references`
+  |         ^^^^^^^^^^^^^^^^^^^
+  |
+note: the lint level is defined here
+ --> tests/ui/pin_project/safe_packed_borrows.rs:1:9
+  |
+1 | #![deny(renamed_and_removed_lints)]
+  |         ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0793]: reference to packed field is unaligned
+  --> tests/ui/pin_project/safe_packed_borrows.rs:21:13
+   |
+21 |     let _ = &a.f;
+   |             ^^^^
+   |
+   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
+   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
+   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
+
+error[E0793]: reference to packed field is unaligned
+  --> tests/ui/pin_project/safe_packed_borrows.rs:24:13
+   |
+24 |     let _ = &b.f;
+   |             ^^^^
+   |
+   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
+   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
+   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
diff --git a/crates/pin-project/tests/ui/pin_project/unaligned_references.rs b/crates/pin-project/tests/ui/pin_project/unaligned_references.rs
new file mode 100644
index 0000000..5c7dc43
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/unaligned_references.rs
@@ -0,0 +1,19 @@
+// Refs: https://github.com/rust-lang/rust/issues/82523
+
+#[repr(packed)]
+struct Packed {
+    f: u32,
+}
+
+#[repr(packed(2))]
+struct PackedN {
+    f: u32,
+}
+
+fn main() {
+    let a = Packed { f: 1 };
+    let _ = &a.f; //~ ERROR reference to packed field is unaligned
+
+    let b = PackedN { f: 1 };
+    let _ = &b.f; //~ ERROR reference to packed field is unaligned
+}
diff --git a/crates/pin-project/tests/ui/pin_project/unaligned_references.stderr b/crates/pin-project/tests/ui/pin_project/unaligned_references.stderr
new file mode 100644
index 0000000..617f164
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/unaligned_references.stderr
@@ -0,0 +1,19 @@
+error[E0793]: reference to packed field is unaligned
+  --> tests/ui/pin_project/unaligned_references.rs:15:13
+   |
+15 |     let _ = &a.f; //~ ERROR reference to packed field is unaligned
+   |             ^^^^
+   |
+   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
+   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
+   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
+
+error[E0793]: reference to packed field is unaligned
+  --> tests/ui/pin_project/unaligned_references.rs:18:13
+   |
+18 |     let _ = &b.f; //~ ERROR reference to packed field is unaligned
+   |             ^^^^
+   |
+   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
+   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
+   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
diff --git a/crates/pin-project/tests/ui/pin_project/unpin_sneaky.rs b/crates/pin-project/tests/ui/pin_project/unpin_sneaky.rs
new file mode 100644
index 0000000..3f5f32b
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/unpin_sneaky.rs
@@ -0,0 +1,11 @@
+use pin_project::pin_project;
+
+#[pin_project]
+struct S {
+    #[pin]
+    f: u8,
+}
+
+impl Unpin for __S {} //~ ERROR E0412,E0321
+
+fn main() {}
diff --git a/crates/pin-project/tests/ui/pin_project/unpin_sneaky.stderr b/crates/pin-project/tests/ui/pin_project/unpin_sneaky.stderr
new file mode 100644
index 0000000..82c2aa5
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/unpin_sneaky.stderr
@@ -0,0 +1,5 @@
+error[E0412]: cannot find type `__S` in this scope
+ --> tests/ui/pin_project/unpin_sneaky.rs:9:16
+  |
+9 | impl Unpin for __S {} //~ ERROR E0412,E0321
+  |                ^^^ not found in this scope
diff --git a/crates/pin-project/tests/ui/pin_project/visibility.rs b/crates/pin-project/tests/ui/pin_project/visibility.rs
new file mode 100644
index 0000000..fdff5a6
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/visibility.rs
@@ -0,0 +1,49 @@
+/// Only named projected types can be imported.
+/// See import_unnamed.rs for unnamed projected types.
+
+mod pub_ {
+    use pin_project::pin_project;
+
+    #[pin_project(project = DProj, project_ref = DProjRef)]
+    pub struct Default(());
+
+    #[pin_project(project = RProj, project_ref = RProjRef, project_replace = RProjOwn)]
+    pub struct Replace(());
+}
+pub mod pub_use {
+    #[rustfmt::skip]
+    pub use crate::pub_::DProj; //~ ERROR E0365
+    #[rustfmt::skip]
+    pub use crate::pub_::DProjRef; //~ ERROR E0365
+    #[rustfmt::skip]
+    pub use crate::pub_::RProj; //~ ERROR E0365
+    #[rustfmt::skip]
+    pub use crate::pub_::RProjOwn; //~ ERROR E0365
+    #[rustfmt::skip]
+    pub use crate::pub_::RProjRef; //~ ERROR E0365
+
+    // Confirm that the visibility of the original type is not changed.
+    pub use crate::pub_::{Default, Replace};
+}
+pub mod pub_use2 {
+    // Ok
+    #[allow(unused_imports)]
+    pub(crate) use crate::pub_::{DProj, DProjRef, RProj, RProjOwn, RProjRef};
+}
+
+mod pub_crate {
+    use pin_project::pin_project;
+
+    #[pin_project(project = DProj, project_ref = DProjRef)]
+    pub(crate) struct Default(());
+
+    #[pin_project(project = RProj, project_ref = RProjRef, project_replace = RProjOwn)]
+    pub(crate) struct Replace(());
+}
+pub mod pub_crate_use {
+    // Ok
+    #[allow(unused_imports)]
+    pub(crate) use crate::pub_crate::{DProj, DProjRef, RProj, RProjOwn, RProjRef};
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/ui/pin_project/visibility.stderr b/crates/pin-project/tests/ui/pin_project/visibility.stderr
new file mode 100644
index 0000000..4d1b722
--- /dev/null
+++ b/crates/pin-project/tests/ui/pin_project/visibility.stderr
@@ -0,0 +1,39 @@
+error[E0365]: `DProj` is only public within the crate, and cannot be re-exported outside
+  --> tests/ui/pin_project/visibility.rs:15:13
+   |
+15 |     pub use crate::pub_::DProj; //~ ERROR E0365
+   |             ^^^^^^^^^^^^^^^^^^ re-export of crate public `DProj`
+   |
+   = note: consider declaring type or module `DProj` with `pub`
+
+error[E0365]: `DProjRef` is only public within the crate, and cannot be re-exported outside
+  --> tests/ui/pin_project/visibility.rs:17:13
+   |
+17 |     pub use crate::pub_::DProjRef; //~ ERROR E0365
+   |             ^^^^^^^^^^^^^^^^^^^^^ re-export of crate public `DProjRef`
+   |
+   = note: consider declaring type or module `DProjRef` with `pub`
+
+error[E0365]: `RProj` is only public within the crate, and cannot be re-exported outside
+  --> tests/ui/pin_project/visibility.rs:19:13
+   |
+19 |     pub use crate::pub_::RProj; //~ ERROR E0365
+   |             ^^^^^^^^^^^^^^^^^^ re-export of crate public `RProj`
+   |
+   = note: consider declaring type or module `RProj` with `pub`
+
+error[E0365]: `RProjOwn` is only public within the crate, and cannot be re-exported outside
+  --> tests/ui/pin_project/visibility.rs:21:13
+   |
+21 |     pub use crate::pub_::RProjOwn; //~ ERROR E0365
+   |             ^^^^^^^^^^^^^^^^^^^^^ re-export of crate public `RProjOwn`
+   |
+   = note: consider declaring type or module `RProjOwn` with `pub`
+
+error[E0365]: `RProjRef` is only public within the crate, and cannot be re-exported outside
+  --> tests/ui/pin_project/visibility.rs:23:13
+   |
+23 |     pub use crate::pub_::RProjRef; //~ ERROR E0365
+   |             ^^^^^^^^^^^^^^^^^^^^^ re-export of crate public `RProjRef`
+   |
+   = note: consider declaring type or module `RProjRef` with `pub`
diff --git a/crates/pin-project/tests/ui/pinned_drop/call-drop-inner.rs b/crates/pin-project/tests/ui/pinned_drop/call-drop-inner.rs
new file mode 100644
index 0000000..9f89942
--- /dev/null
+++ b/crates/pin-project/tests/ui/pinned_drop/call-drop-inner.rs
@@ -0,0 +1,17 @@
+use std::pin::Pin;
+
+use pin_project::{pin_project, pinned_drop};
+
+#[pin_project(PinnedDrop)]
+struct Struct {
+    f: bool,
+}
+
+#[pinned_drop]
+impl PinnedDrop for Struct {
+    fn drop(mut self: Pin<&mut Self>) {
+        __drop_inner(__self);
+    }
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/ui/pinned_drop/call-drop-inner.stderr b/crates/pin-project/tests/ui/pinned_drop/call-drop-inner.stderr
new file mode 100644
index 0000000..277d50f
--- /dev/null
+++ b/crates/pin-project/tests/ui/pinned_drop/call-drop-inner.stderr
@@ -0,0 +1,15 @@
+error[E0061]: this function takes 0 arguments but 1 argument was supplied
+  --> tests/ui/pinned_drop/call-drop-inner.rs:13:9
+   |
+13 |         __drop_inner(__self);
+   |         ^^^^^^^^^^^^ ------
+   |                      |
+   |                      unexpected argument of type `Pin<&mut Struct>`
+   |                      help: remove the extra argument
+   |
+note: function defined here
+  --> tests/ui/pinned_drop/call-drop-inner.rs:10:1
+   |
+10 | #[pinned_drop]
+   | ^^^^^^^^^^^^^^
+   = note: this error originates in the attribute macro `pinned_drop` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/crates/pin-project/tests/ui/pinned_drop/conditional-drop-impl.rs b/crates/pin-project/tests/ui/pinned_drop/conditional-drop-impl.rs
new file mode 100644
index 0000000..23d756d
--- /dev/null
+++ b/crates/pin-project/tests/ui/pinned_drop/conditional-drop-impl.rs
@@ -0,0 +1,27 @@
+use std::pin::Pin;
+
+use pin_project::{pin_project, pinned_drop};
+
+// In `Drop` impl, the implementor must specify the same requirement as type definition.
+
+struct DropImpl<T> {
+    f: T,
+}
+
+impl<T: Unpin> Drop for DropImpl<T> {
+    //~^ ERROR E0367
+    fn drop(&mut self) {}
+}
+
+#[pin_project(PinnedDrop)] //~ ERROR E0277
+struct PinnedDropImpl<T> {
+    #[pin]
+    f: T,
+}
+
+#[pinned_drop]
+impl<T: Unpin> PinnedDrop for PinnedDropImpl<T> {
+    fn drop(self: Pin<&mut Self>) {}
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/ui/pinned_drop/conditional-drop-impl.stderr b/crates/pin-project/tests/ui/pinned_drop/conditional-drop-impl.stderr
new file mode 100644
index 0000000..837b1db
--- /dev/null
+++ b/crates/pin-project/tests/ui/pinned_drop/conditional-drop-impl.stderr
@@ -0,0 +1,31 @@
+error[E0367]: `Drop` impl requires `T: Unpin` but the struct it is implemented for does not
+  --> tests/ui/pinned_drop/conditional-drop-impl.rs:11:9
+   |
+11 | impl<T: Unpin> Drop for DropImpl<T> {
+   |         ^^^^^
+   |
+note: the implementor must specify the same requirement
+  --> tests/ui/pinned_drop/conditional-drop-impl.rs:7:1
+   |
+7  | struct DropImpl<T> {
+   | ^^^^^^^^^^^^^^^^^^
+
+error[E0277]: `T` cannot be unpinned
+  --> tests/ui/pinned_drop/conditional-drop-impl.rs:16:15
+   |
+16 | #[pin_project(PinnedDrop)] //~ ERROR E0277
+   |               ^^^^^^^^^^ the trait `Unpin` is not implemented for `T`
+   |
+   = note: consider using the `pin!` macro
+           consider using `Box::pin` if you need to access the pinned value outside of the current scope
+note: required for `PinnedDropImpl<T>` to implement `PinnedDrop`
+  --> tests/ui/pinned_drop/conditional-drop-impl.rs:23:16
+   |
+23 | impl<T: Unpin> PinnedDrop for PinnedDropImpl<T> {
+   |         -----  ^^^^^^^^^^     ^^^^^^^^^^^^^^^^^
+   |         |
+   |         unsatisfied trait bound introduced here
+help: consider restricting type parameter `T`
+   |
+17 | struct PinnedDropImpl<T: std::marker::Unpin> {
+   |                        ++++++++++++++++++++
diff --git a/crates/pin-project/tests/ui/pinned_drop/forget-pinned-drop-impl.rs b/crates/pin-project/tests/ui/pinned_drop/forget-pinned-drop-impl.rs
new file mode 100644
index 0000000..e31f46f
--- /dev/null
+++ b/crates/pin-project/tests/ui/pinned_drop/forget-pinned-drop-impl.rs
@@ -0,0 +1,9 @@
+use pin_project::pin_project;
+
+#[pin_project(PinnedDrop)] //~ ERROR E0277
+struct Struct {
+    #[pin]
+    f: u8,
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/ui/pinned_drop/forget-pinned-drop-impl.stderr b/crates/pin-project/tests/ui/pinned_drop/forget-pinned-drop-impl.stderr
new file mode 100644
index 0000000..ef8a7bf
--- /dev/null
+++ b/crates/pin-project/tests/ui/pinned_drop/forget-pinned-drop-impl.stderr
@@ -0,0 +1,5 @@
+error[E0277]: the trait bound `Struct: PinnedDrop` is not satisfied
+ --> tests/ui/pinned_drop/forget-pinned-drop-impl.rs:3:15
+  |
+3 | #[pin_project(PinnedDrop)] //~ ERROR E0277
+  |               ^^^^^^^^^^ the trait `PinnedDrop` is not implemented for `Struct`
diff --git a/crates/pin-project/tests/ui/pinned_drop/invalid-self.rs b/crates/pin-project/tests/ui/pinned_drop/invalid-self.rs
new file mode 100644
index 0000000..783167f
--- /dev/null
+++ b/crates/pin-project/tests/ui/pinned_drop/invalid-self.rs
@@ -0,0 +1,14 @@
+// by-ref binding `ref (mut) self` and sub-patterns `@` are not allowed in receivers (rejected by rustc).
+
+use std::pin::Pin;
+
+struct S {}
+
+impl S {
+    fn take_ref_self(ref self: Pin<&mut Self>) {} //~ ERROR expected identifier, found keyword `self`
+    fn take_ref_mut_self(ref mut self: Pin<&mut Self>) {} //~ ERROR expected identifier, found keyword `self`
+
+    fn self_subpat(self @ S {}: Self) {} //~ ERROR expected one of `)`, `,`, or `:`, found `@`
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/ui/pinned_drop/invalid-self.stderr b/crates/pin-project/tests/ui/pinned_drop/invalid-self.stderr
new file mode 100644
index 0000000..464be5e
--- /dev/null
+++ b/crates/pin-project/tests/ui/pinned_drop/invalid-self.stderr
@@ -0,0 +1,25 @@
+error: expected identifier, found keyword `self`
+ --> tests/ui/pinned_drop/invalid-self.rs:8:26
+  |
+8 |     fn take_ref_self(ref self: Pin<&mut Self>) {} //~ ERROR expected identifier, found keyword `self`
+  |                          ^^^^ expected identifier, found keyword
+
+error: expected identifier, found keyword `self`
+ --> tests/ui/pinned_drop/invalid-self.rs:9:34
+  |
+9 |     fn take_ref_mut_self(ref mut self: Pin<&mut Self>) {} //~ ERROR expected identifier, found keyword `self`
+  |                                  ^^^^ expected identifier, found keyword
+
+error: expected parameter name, found `@`
+  --> tests/ui/pinned_drop/invalid-self.rs:11:25
+   |
+11 |     fn self_subpat(self @ S {}: Self) {} //~ ERROR expected one of `)`, `,`, or `:`, found `@`
+   |                         ^ expected parameter name
+
+error: expected one of `)`, `,`, or `:`, found `@`
+  --> tests/ui/pinned_drop/invalid-self.rs:11:25
+   |
+11 |     fn self_subpat(self @ S {}: Self) {} //~ ERROR expected one of `)`, `,`, or `:`, found `@`
+   |                        -^ expected one of `)`, `,`, or `:`
+   |                        |
+   |                        help: missing `,`
diff --git a/crates/pin-project/tests/ui/pinned_drop/invalid.rs b/crates/pin-project/tests/ui/pinned_drop/invalid.rs
new file mode 100644
index 0000000..b2c2526
--- /dev/null
+++ b/crates/pin-project/tests/ui/pinned_drop/invalid.rs
@@ -0,0 +1,231 @@
+mod argument {
+    use std::pin::Pin;
+
+    use pin_project::{pin_project, pinned_drop};
+
+    #[pin_project(PinnedDrop)]
+    struct UnexpectedArg1(());
+
+    #[pinned_drop(foo)] //~ ERROR unexpected argument
+    impl PinnedDrop for UnexpectedArg1 {
+        fn drop(self: Pin<&mut Self>) {}
+    }
+
+    #[pin_project(PinnedDrop)]
+    struct UnexpectedArg2(());
+
+    #[pinned_drop()] // Ok
+    impl PinnedDrop for UnexpectedArg2 {
+        fn drop(self: Pin<&mut Self>) {}
+    }
+}
+
+mod attribute {
+    use pin_project::{pin_project, pinned_drop};
+
+    #[pin_project(PinnedDrop)]
+    struct Duplicate(());
+
+    #[pinned_drop]
+    #[pinned_drop] //~ ERROR duplicate #[pinned_drop] attribute
+    impl PinnedDrop for Duplicate {
+        fn drop(self: Pin<&mut Self>) {}
+    }
+}
+
+mod item {
+    use pin_project::{pin_project, pinned_drop};
+
+    #[pin_project(PinnedDrop)]
+    struct TraitImpl(());
+
+    #[pinned_drop]
+    impl Drop for TraitImpl {} //~ ERROR may only be used on implementation for the `PinnedDrop` trait
+
+    #[pin_project(PinnedDrop)]
+    struct InherentImpl(());
+
+    #[pinned_drop]
+    impl InherentImpl {} //~ ERROR may only be used on implementation for the `PinnedDrop` trait
+
+    #[pinned_drop]
+    fn func(_: Pin<&mut ()>) {} //~ ERROR expected `impl`
+}
+
+mod unsafety {
+    use pin_project::{pin_project, pinned_drop};
+
+    #[pin_project(PinnedDrop)]
+    struct Impl(());
+
+    #[pinned_drop]
+    unsafe impl PinnedDrop for Impl {
+        //~^ ERROR implementing the trait `PinnedDrop` is not unsafe
+        fn drop(self: Pin<&mut Self>) {}
+    }
+
+    #[pin_project(PinnedDrop)]
+    struct Method(());
+
+    #[pinned_drop]
+    impl PinnedDrop for Method {
+        unsafe fn drop(self: Pin<&mut Self>) {} //~ ERROR implementing the method `drop` is not unsafe
+    }
+}
+
+mod assoc_item {
+    use pin_project::{pin_project, pinned_drop};
+
+    #[pin_project(PinnedDrop)]
+    struct Empty(());
+
+    #[pinned_drop]
+    impl PinnedDrop for Empty {} //~ ERROR not all trait items implemented, missing: `drop`
+
+    #[pin_project(PinnedDrop)]
+    struct Const1(());
+
+    #[pinned_drop]
+    impl PinnedDrop for Const1 {
+        const A: u8 = 0; //~ ERROR const `A` is not a member of trait `PinnedDrop`
+        fn drop(self: Pin<&mut Self>) {}
+    }
+
+    #[pin_project(PinnedDrop)]
+    struct Const2(());
+
+    #[pinned_drop]
+    impl PinnedDrop for Const2 {
+        fn drop(self: Pin<&mut Self>) {}
+        const A: u8 = 0; //~ ERROR const `A` is not a member of trait `PinnedDrop`
+    }
+
+    #[pin_project(PinnedDrop)]
+    struct Type1(());
+
+    #[pinned_drop]
+    impl PinnedDrop for Type1 {
+        type A = u8; //~ ERROR type `A` is not a member of trait `PinnedDrop`
+        fn drop(self: Pin<&mut Self>) {}
+    }
+
+    #[pin_project(PinnedDrop)]
+    struct Type2(());
+
+    #[pinned_drop]
+    impl PinnedDrop for Type2 {
+        fn drop(self: Pin<&mut Self>) {}
+        type A = u8; //~ ERROR type `A` is not a member of trait `PinnedDrop`
+    }
+
+    #[pin_project(PinnedDrop)]
+    struct Duplicate(());
+
+    #[pinned_drop]
+    impl PinnedDrop for Duplicate {
+        fn drop(self: Pin<&mut Self>) {}
+        fn drop(self: Pin<&mut Self>) {} //~ ERROR duplicate definitions with name `drop`
+    }
+}
+
+mod method {
+    use std::pin::Pin;
+
+    use pin_project::{pin_project, pinned_drop};
+
+    #[pin_project(PinnedDrop)]
+    struct RetUnit(());
+
+    #[pinned_drop]
+    impl PinnedDrop for RetUnit {
+        fn drop(self: Pin<&mut Self>) -> () {} // Ok
+    }
+
+    #[pin_project(PinnedDrop)]
+    struct RetTy(());
+
+    #[pinned_drop]
+    impl PinnedDrop for RetTy {
+        fn drop(self: Pin<&mut Self>) -> Self {} //~ ERROR method `drop` must return the unit type
+    }
+
+    #[pin_project(PinnedDrop)]
+    struct NoArg(());
+
+    #[pinned_drop]
+    impl PinnedDrop for NoArg {
+        fn drop() {} //~ ERROR method `drop` must take an argument `self: Pin<&mut Self>`
+    }
+
+    #[pin_project(PinnedDrop)]
+    struct MultiArg(());
+
+    #[pinned_drop]
+    impl PinnedDrop for MultiArg {
+        fn drop(self: Pin<&mut Self>, _: ()) {} //~ ERROR method `drop` must take an argument `self: Pin<&mut Self>`
+    }
+
+    #[pin_project(PinnedDrop)]
+    struct InvalidArg1(());
+
+    #[pinned_drop]
+    impl PinnedDrop for InvalidArg1 {
+        fn drop(&mut self) {} //~ ERROR method `drop` must take an argument `self: Pin<&mut Self>`
+    }
+
+    #[pin_project(PinnedDrop)]
+    struct InvalidArg2(());
+
+    #[pinned_drop]
+    impl PinnedDrop for InvalidArg2 {
+        fn drop(_: Pin<&mut Self>) {} //~ ERROR method `drop` must take an argument `self: Pin<&mut Self>`
+    }
+
+    #[pin_project(PinnedDrop)]
+    struct InvalidArg3(());
+
+    #[pinned_drop]
+    impl PinnedDrop for InvalidArg3 {
+        fn drop(self: Pin<&Self>) {} //~ ERROR method `drop` must take an argument `self: Pin<&mut Self>`
+    }
+
+    #[pin_project(PinnedDrop)]
+    struct InvalidArg4(());
+
+    #[pinned_drop]
+    impl PinnedDrop for InvalidArg4 {
+        fn drop(self: Pin<&mut ()>) {} //~ ERROR method `drop` must take an argument `self: Pin<&mut Self>`
+    }
+
+    #[pin_project(PinnedDrop)]
+    struct InvalidName(());
+
+    #[pinned_drop]
+    impl PinnedDrop for InvalidName {
+        fn pinned_drop(self: Pin<&mut Self>) {} //~ ERROR method `pinned_drop` is not a member of trait `PinnedDrop
+    }
+}
+
+mod self_ty {
+    use pin_project::pinned_drop;
+
+    #[pinned_drop]
+    impl PinnedDrop for () {
+        //~^ ERROR implementing the trait `PinnedDrop` on this type is unsupported
+        fn drop(self: Pin<&mut Self>) {}
+    }
+
+    #[pinned_drop]
+    impl PinnedDrop for &mut A {
+        //~^ ERROR implementing the trait `PinnedDrop` on this type is unsupported
+        fn drop(self: Pin<&mut Self>) {}
+    }
+
+    #[pinned_drop]
+    impl PinnedDrop for [A] {
+        //~^ ERROR implementing the trait `PinnedDrop` on this type is unsupported
+        fn drop(self: Pin<&mut Self>) {}
+    }
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/ui/pinned_drop/invalid.stderr b/crates/pin-project/tests/ui/pinned_drop/invalid.stderr
new file mode 100644
index 0000000..264def0
--- /dev/null
+++ b/crates/pin-project/tests/ui/pinned_drop/invalid.stderr
@@ -0,0 +1,143 @@
+error: unexpected argument: `foo`
+ --> tests/ui/pinned_drop/invalid.rs:9:19
+  |
+9 |     #[pinned_drop(foo)] //~ ERROR unexpected argument
+  |                   ^^^
+
+error: duplicate #[pinned_drop] attribute
+  --> tests/ui/pinned_drop/invalid.rs:30:5
+   |
+30 |     #[pinned_drop] //~ ERROR duplicate #[pinned_drop] attribute
+   |     ^^^^^^^^^^^^^^
+
+error: #[pinned_drop] may only be used on implementation for the `PinnedDrop` trait
+  --> tests/ui/pinned_drop/invalid.rs:43:10
+   |
+43 |     impl Drop for TraitImpl {} //~ ERROR may only be used on implementation for the `PinnedDrop` trait
+   |          ^^^^
+
+error: #[pinned_drop] may only be used on implementation for the `PinnedDrop` trait
+  --> tests/ui/pinned_drop/invalid.rs:49:10
+   |
+49 |     impl InherentImpl {} //~ ERROR may only be used on implementation for the `PinnedDrop` trait
+   |          ^^^^^^^^^^^^
+
+error: expected `impl`
+  --> tests/ui/pinned_drop/invalid.rs:52:5
+   |
+52 |     fn func(_: Pin<&mut ()>) {} //~ ERROR expected `impl`
+   |     ^^
+
+error: implementing the trait `PinnedDrop` is not unsafe
+  --> tests/ui/pinned_drop/invalid.rs:62:5
+   |
+62 |     unsafe impl PinnedDrop for Impl {
+   |     ^^^^^^
+
+error: implementing the method `drop` is not unsafe
+  --> tests/ui/pinned_drop/invalid.rs:72:9
+   |
+72 |         unsafe fn drop(self: Pin<&mut Self>) {} //~ ERROR implementing the method `drop` is not unsafe
+   |         ^^^^^^
+
+error: not all trait items implemented, missing: `drop`
+  --> tests/ui/pinned_drop/invalid.rs:83:5
+   |
+83 |     impl PinnedDrop for Empty {} //~ ERROR not all trait items implemented, missing: `drop`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: const `A` is not a member of trait `PinnedDrop`
+  --> tests/ui/pinned_drop/invalid.rs:90:9
+   |
+90 |         const A: u8 = 0; //~ ERROR const `A` is not a member of trait `PinnedDrop`
+   |         ^^^^^^^^^^^^^^^^
+
+error: const `A` is not a member of trait `PinnedDrop`
+   --> tests/ui/pinned_drop/invalid.rs:100:9
+    |
+100 |         const A: u8 = 0; //~ ERROR const `A` is not a member of trait `PinnedDrop`
+    |         ^^^^^^^^^^^^^^^^
+
+error: type `A` is not a member of trait `PinnedDrop`
+   --> tests/ui/pinned_drop/invalid.rs:108:9
+    |
+108 |         type A = u8; //~ ERROR type `A` is not a member of trait `PinnedDrop`
+    |         ^^^^^^^^^^^^
+
+error: type `A` is not a member of trait `PinnedDrop`
+   --> tests/ui/pinned_drop/invalid.rs:118:9
+    |
+118 |         type A = u8; //~ ERROR type `A` is not a member of trait `PinnedDrop`
+    |         ^^^^^^^^^^^^
+
+error: duplicate definitions with name `drop`
+   --> tests/ui/pinned_drop/invalid.rs:127:9
+    |
+127 |         fn drop(self: Pin<&mut Self>) {} //~ ERROR duplicate definitions with name `drop`
+    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: method `drop` must return the unit type
+   --> tests/ui/pinned_drop/invalid.rs:149:42
+    |
+149 |         fn drop(self: Pin<&mut Self>) -> Self {} //~ ERROR method `drop` must return the unit type
+    |                                          ^^^^
+
+error: method `drop` must take an argument `self: Pin<&mut Self>`
+   --> tests/ui/pinned_drop/invalid.rs:157:16
+    |
+157 |         fn drop() {} //~ ERROR method `drop` must take an argument `self: Pin<&mut Self>`
+    |                ^^
+
+error: method `drop` must take an argument `self: Pin<&mut Self>`
+   --> tests/ui/pinned_drop/invalid.rs:165:17
+    |
+165 |         fn drop(self: Pin<&mut Self>, _: ()) {} //~ ERROR method `drop` must take an argument `self: Pin<&mut Self>`
+    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: method `drop` must take an argument `self: Pin<&mut Self>`
+   --> tests/ui/pinned_drop/invalid.rs:173:17
+    |
+173 |         fn drop(&mut self) {} //~ ERROR method `drop` must take an argument `self: Pin<&mut Self>`
+    |                 ^^^^^^^^^
+
+error: method `drop` must take an argument `self: Pin<&mut Self>`
+   --> tests/ui/pinned_drop/invalid.rs:181:17
+    |
+181 |         fn drop(_: Pin<&mut Self>) {} //~ ERROR method `drop` must take an argument `self: Pin<&mut Self>`
+    |                 ^^^^^^^^^^^^^^^^^
+
+error: method `drop` must take an argument `self: Pin<&mut Self>`
+   --> tests/ui/pinned_drop/invalid.rs:189:17
+    |
+189 |         fn drop(self: Pin<&Self>) {} //~ ERROR method `drop` must take an argument `self: Pin<&mut Self>`
+    |                 ^^^^^^^^^^^^^^^^
+
+error: method `drop` must take an argument `self: Pin<&mut Self>`
+   --> tests/ui/pinned_drop/invalid.rs:197:17
+    |
+197 |         fn drop(self: Pin<&mut ()>) {} //~ ERROR method `drop` must take an argument `self: Pin<&mut Self>`
+    |                 ^^^^^^^^^^^^^^^^^^
+
+error: method `pinned_drop` is not a member of trait `PinnedDrop
+   --> tests/ui/pinned_drop/invalid.rs:205:12
+    |
+205 |         fn pinned_drop(self: Pin<&mut Self>) {} //~ ERROR method `pinned_drop` is not a member of trait `PinnedDrop
+    |            ^^^^^^^^^^^
+
+error: implementing the trait `PinnedDrop` on this type is unsupported
+   --> tests/ui/pinned_drop/invalid.rs:213:25
+    |
+213 |     impl PinnedDrop for () {
+    |                         ^^
+
+error: implementing the trait `PinnedDrop` on this type is unsupported
+   --> tests/ui/pinned_drop/invalid.rs:219:25
+    |
+219 |     impl PinnedDrop for &mut A {
+    |                         ^^^^^^
+
+error: implementing the trait `PinnedDrop` on this type is unsupported
+   --> tests/ui/pinned_drop/invalid.rs:225:25
+    |
+225 |     impl PinnedDrop for [A] {
+    |                         ^^^
diff --git a/crates/pin-project/tests/ui/pinned_drop/pinned-drop-no-attr-arg.rs b/crates/pin-project/tests/ui/pinned_drop/pinned-drop-no-attr-arg.rs
new file mode 100644
index 0000000..391f290
--- /dev/null
+++ b/crates/pin-project/tests/ui/pinned_drop/pinned-drop-no-attr-arg.rs
@@ -0,0 +1,17 @@
+use std::pin::Pin;
+
+use pin_project::{pin_project, pinned_drop};
+
+#[pin_project]
+struct S {
+    #[pin]
+    f: u8,
+}
+
+#[pinned_drop]
+impl PinnedDrop for S {
+    //~^ ERROR E0119
+    fn drop(self: Pin<&mut Self>) {}
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/ui/pinned_drop/pinned-drop-no-attr-arg.stderr b/crates/pin-project/tests/ui/pinned_drop/pinned-drop-no-attr-arg.stderr
new file mode 100644
index 0000000..a07ba99
--- /dev/null
+++ b/crates/pin-project/tests/ui/pinned_drop/pinned-drop-no-attr-arg.stderr
@@ -0,0 +1,8 @@
+error[E0119]: conflicting implementations of trait `PinnedDrop` for type `S`
+  --> tests/ui/pinned_drop/pinned-drop-no-attr-arg.rs:12:1
+   |
+5  | #[pin_project]
+   | -------------- first implementation here
+...
+12 | impl PinnedDrop for S {
+   | ^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `S`
diff --git a/crates/pin-project/tests/ui/pinned_drop/self.rs b/crates/pin-project/tests/ui/pinned_drop/self.rs
new file mode 100644
index 0000000..ff63402
--- /dev/null
+++ b/crates/pin-project/tests/ui/pinned_drop/self.rs
@@ -0,0 +1,58 @@
+pub mod self_in_macro_def {
+    use std::pin::Pin;
+
+    use pin_project::{pin_project, pinned_drop};
+
+    #[pin_project(PinnedDrop)]
+    pub struct S {
+        f: (),
+    }
+
+    #[pinned_drop]
+    impl PinnedDrop for S {
+        fn drop(self: Pin<&mut Self>) {
+            macro_rules! t {
+                () => {{
+                    let _ = self; //~ ERROR E0434
+
+                    fn f(self: ()) {} //~ ERROR `self` parameter is only allowed in associated functions
+                }};
+            }
+            t!();
+        }
+    }
+}
+
+pub mod self_span {
+    use std::pin::Pin;
+
+    use pin_project::{pin_project, pinned_drop};
+
+    #[pin_project(PinnedDrop)]
+    pub struct S {
+        f: (),
+    }
+
+    #[pinned_drop]
+    impl PinnedDrop for S {
+        fn drop(self: Pin<&mut Self>) {
+            let _: () = self; //~ ERROR E0308
+            let _: Self = Self; //~ ERROR E0423
+        }
+    }
+
+    #[pin_project(PinnedDrop)]
+    pub enum E {
+        V { f: () },
+    }
+
+    #[pinned_drop]
+    impl PinnedDrop for E {
+        fn drop(self: Pin<&mut Self>) {
+            let _: () = self; //~ ERROR E0308
+            let _: Self = Self::V; //~ ERROR E0533
+        }
+    }
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/ui/pinned_drop/self.stderr b/crates/pin-project/tests/ui/pinned_drop/self.stderr
new file mode 100644
index 0000000..ad506a5
--- /dev/null
+++ b/crates/pin-project/tests/ui/pinned_drop/self.stderr
@@ -0,0 +1,62 @@
+error: `self` parameter is only allowed in associated functions
+  --> tests/ui/pinned_drop/self.rs:18:26
+   |
+18 |                     fn f(self: ()) {} //~ ERROR `self` parameter is only allowed in associated functions
+   |                          ^^^^ not semantically valid as function parameter
+...
+21 |             t!();
+   |             ---- in this macro invocation
+   |
+   = note: associated functions are those in `impl` or `trait` definitions
+   = note: this error originates in the macro `t` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0434]: can't capture dynamic environment in a fn item
+  --> tests/ui/pinned_drop/self.rs:16:29
+   |
+16 |                     let _ = self; //~ ERROR E0434
+   |                             ^^^^
+...
+21 |             t!();
+   |             ---- in this macro invocation
+   |
+   = help: use the `|| { ... }` closure form instead
+   = note: this error originates in the macro `t` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0423]: expected value, found struct `S`
+  --> tests/ui/pinned_drop/self.rs:40:27
+   |
+32 | /     pub struct S {
+33 | |         f: (),
+34 | |     }
+   | |_____- `S` defined here
+...
+40 |               let _: Self = Self; //~ ERROR E0423
+   |                             ^^^^ help: use struct literal syntax instead: `S { f: val }`
+
+error[E0308]: mismatched types
+  --> tests/ui/pinned_drop/self.rs:39:25
+   |
+39 |             let _: () = self; //~ ERROR E0308
+   |                    --   ^^^^ expected `()`, found `Pin<&mut S>`
+   |                    |
+   |                    expected due to this
+   |
+   = note: expected unit type `()`
+                 found struct `Pin<&mut self_span::S>`
+
+error[E0308]: mismatched types
+  --> tests/ui/pinned_drop/self.rs:52:25
+   |
+52 |             let _: () = self; //~ ERROR E0308
+   |                    --   ^^^^ expected `()`, found `Pin<&mut E>`
+   |                    |
+   |                    expected due to this
+   |
+   = note: expected unit type `()`
+                 found struct `Pin<&mut E>`
+
+error[E0533]: expected value, found struct variant `E::V`
+  --> tests/ui/pinned_drop/self.rs:53:27
+   |
+53 |             let _: Self = Self::V; //~ ERROR E0533
+   |                           ^^^^^^^ not a value
diff --git a/crates/pin-project/tests/ui/pinned_drop/unsafe-call.rs b/crates/pin-project/tests/ui/pinned_drop/unsafe-call.rs
new file mode 100644
index 0000000..3ee2b56
--- /dev/null
+++ b/crates/pin-project/tests/ui/pinned_drop/unsafe-call.rs
@@ -0,0 +1,18 @@
+use std::pin::Pin;
+
+use pin_project::{pin_project, pinned_drop};
+
+#[pin_project(PinnedDrop)]
+struct S {
+    #[pin]
+    f: u8,
+}
+
+#[pinned_drop]
+impl PinnedDrop for S {
+    fn drop(self: Pin<&mut Self>) {
+        self.project().f.get_unchecked_mut(); //~ ERROR call to unsafe function is unsafe and requires unsafe function or block [E0133]
+    }
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/ui/pinned_drop/unsafe-call.stderr b/crates/pin-project/tests/ui/pinned_drop/unsafe-call.stderr
new file mode 100644
index 0000000..911a58e
--- /dev/null
+++ b/crates/pin-project/tests/ui/pinned_drop/unsafe-call.stderr
@@ -0,0 +1,10 @@
+error[E0133]: call to unsafe function is unsafe and requires unsafe function or block
+  --> tests/ui/pinned_drop/unsafe-call.rs:14:9
+   |
+11 | #[pinned_drop]
+   | -------------- items do not inherit unsafety from separate enclosing items
+...
+14 |         self.project().f.get_unchecked_mut(); //~ ERROR call to unsafe function is unsafe and requires unsafe function or block [E0133]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
+   |
+   = note: consult the function's documentation for information on how to avoid undefined behavior
diff --git a/crates/pin-project/tests/ui/unsafe_unpin/conflict-unpin.rs b/crates/pin-project/tests/ui/unsafe_unpin/conflict-unpin.rs
new file mode 100644
index 0000000..ac9d1f8
--- /dev/null
+++ b/crates/pin-project/tests/ui/unsafe_unpin/conflict-unpin.rs
@@ -0,0 +1,30 @@
+use pin_project::pin_project;
+
+#[pin_project(UnsafeUnpin)] //~ ERROR E0119
+struct Foo<T, U> {
+    #[pin]
+    f1: T,
+    f2: U,
+}
+
+impl<T, U> Unpin for Foo<T, U> where T: Unpin {}
+
+#[pin_project(UnsafeUnpin)] //~ ERROR E0119
+struct Bar<T, U> {
+    #[pin]
+    f1: T,
+    f2: U,
+}
+
+impl<T, U> Unpin for Bar<T, U> {}
+
+#[pin_project(UnsafeUnpin)] //~ ERROR E0119
+struct Baz<T, U> {
+    #[pin]
+    f1: T,
+    f2: U,
+}
+
+impl<T: Unpin, U: Unpin> Unpin for Baz<T, U> {}
+
+fn main() {}
diff --git a/crates/pin-project/tests/ui/unsafe_unpin/conflict-unpin.stderr b/crates/pin-project/tests/ui/unsafe_unpin/conflict-unpin.stderr
new file mode 100644
index 0000000..cdf0d50
--- /dev/null
+++ b/crates/pin-project/tests/ui/unsafe_unpin/conflict-unpin.stderr
@@ -0,0 +1,32 @@
+error[E0119]: conflicting implementations of trait `Unpin` for type `Foo<_, _>`
+  --> tests/ui/unsafe_unpin/conflict-unpin.rs:3:15
+   |
+3  | #[pin_project(UnsafeUnpin)] //~ ERROR E0119
+   |               ^^^^^^^^^^^ conflicting implementation for `Foo<_, _>`
+...
+10 | impl<T, U> Unpin for Foo<T, U> where T: Unpin {}
+   | ------------------------------ first implementation here
+   |
+   = note: upstream crates may add a new impl of trait `_::_pin_project::UnsafeUnpin` for type `_::_pin_project::__private::Wrapper<'_, Foo<_, _>>` in future versions
+
+error[E0119]: conflicting implementations of trait `Unpin` for type `Bar<_, _>`
+  --> tests/ui/unsafe_unpin/conflict-unpin.rs:12:15
+   |
+12 | #[pin_project(UnsafeUnpin)] //~ ERROR E0119
+   |               ^^^^^^^^^^^ conflicting implementation for `Bar<_, _>`
+...
+19 | impl<T, U> Unpin for Bar<T, U> {}
+   | ------------------------------ first implementation here
+   |
+   = note: upstream crates may add a new impl of trait `_::_pin_project::UnsafeUnpin` for type `_::_pin_project::__private::Wrapper<'_, Bar<_, _>>` in future versions
+
+error[E0119]: conflicting implementations of trait `Unpin` for type `Baz<_, _>`
+  --> tests/ui/unsafe_unpin/conflict-unpin.rs:21:15
+   |
+21 | #[pin_project(UnsafeUnpin)] //~ ERROR E0119
+   |               ^^^^^^^^^^^ conflicting implementation for `Baz<_, _>`
+...
+28 | impl<T: Unpin, U: Unpin> Unpin for Baz<T, U> {}
+   | -------------------------------------------- first implementation here
+   |
+   = note: upstream crates may add a new impl of trait `_::_pin_project::UnsafeUnpin` for type `_::_pin_project::__private::Wrapper<'_, Baz<_, _>>` in future versions
diff --git a/crates/pin-project/tests/ui/unstable-features/README.md b/crates/pin-project/tests/ui/unstable-features/README.md
new file mode 100644
index 0000000..96f370c
--- /dev/null
+++ b/crates/pin-project/tests/ui/unstable-features/README.md
@@ -0,0 +1,7 @@
+# UI tests for unstable features
+
+These tests check how the guarantees and features provided by pin-project
+interact with unstable language features.
+
+The names of the files contained in this directory need to begin with the name
+of the feature.
diff --git a/crates/pin-project/tests/ui/unstable-features/marker_trait_attr-feature-gate.rs b/crates/pin-project/tests/ui/unstable-features/marker_trait_attr-feature-gate.rs
new file mode 100644
index 0000000..542250b
--- /dev/null
+++ b/crates/pin-project/tests/ui/unstable-features/marker_trait_attr-feature-gate.rs
@@ -0,0 +1,20 @@
+// Note: If you change this test, change 'marker_trait_attr.rs' at the same time.
+
+use std::marker::PhantomPinned;
+
+use pin_project::pin_project;
+
+#[pin_project] //~ ERROR E0119
+struct Struct<T> {
+    #[pin]
+    f: T,
+}
+
+// unsound Unpin impl
+impl<T> Unpin for Struct<T> {}
+
+fn is_unpin<T: Unpin>() {}
+
+fn main() {
+    is_unpin::<Struct<PhantomPinned>>()
+}
diff --git a/crates/pin-project/tests/ui/unstable-features/marker_trait_attr-feature-gate.stderr b/crates/pin-project/tests/ui/unstable-features/marker_trait_attr-feature-gate.stderr
new file mode 100644
index 0000000..fcb9185
--- /dev/null
+++ b/crates/pin-project/tests/ui/unstable-features/marker_trait_attr-feature-gate.stderr
@@ -0,0 +1,10 @@
+error[E0119]: conflicting implementations of trait `Unpin` for type `Struct<_>`
+  --> tests/ui/unstable-features/marker_trait_attr-feature-gate.rs:7:1
+   |
+7  | #[pin_project] //~ ERROR E0119
+   | ^^^^^^^^^^^^^^ conflicting implementation for `Struct<_>`
+...
+14 | impl<T> Unpin for Struct<T> {}
+   | --------------------------- first implementation here
+   |
+   = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/crates/pin-project/tests/ui/unstable-features/marker_trait_attr.rs b/crates/pin-project/tests/ui/unstable-features/marker_trait_attr.rs
new file mode 100644
index 0000000..9c8e664
--- /dev/null
+++ b/crates/pin-project/tests/ui/unstable-features/marker_trait_attr.rs
@@ -0,0 +1,26 @@
+// Note: If you change this test, change 'marker_trait_attr-feature-gate.rs' at the same time.
+
+// marker_trait_attr
+// Tracking issue: https://github.com/rust-lang/rust/issues/29864
+#![feature(marker_trait_attr)]
+
+// See https://github.com/taiki-e/pin-project/issues/105#issuecomment-535355974
+
+use std::marker::PhantomPinned;
+
+use pin_project::pin_project;
+
+#[pin_project] //~ ERROR E0119
+struct Struct<T> {
+    #[pin]
+    f: T,
+}
+
+// unsound Unpin impl
+impl<T> Unpin for Struct<T> {}
+
+fn is_unpin<T: Unpin>() {}
+
+fn main() {
+    is_unpin::<Struct<PhantomPinned>>()
+}
diff --git a/crates/pin-project/tests/ui/unstable-features/marker_trait_attr.stderr b/crates/pin-project/tests/ui/unstable-features/marker_trait_attr.stderr
new file mode 100644
index 0000000..85949d5
--- /dev/null
+++ b/crates/pin-project/tests/ui/unstable-features/marker_trait_attr.stderr
@@ -0,0 +1,10 @@
+error[E0119]: conflicting implementations of trait `Unpin` for type `Struct<_>`
+  --> tests/ui/unstable-features/marker_trait_attr.rs:13:1
+   |
+13 | #[pin_project] //~ ERROR E0119
+   | ^^^^^^^^^^^^^^ conflicting implementation for `Struct<_>`
+...
+20 | impl<T> Unpin for Struct<T> {}
+   | --------------------------- first implementation here
+   |
+   = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/crates/pin-project/tests/ui/unstable-features/negative_impls.rs b/crates/pin-project/tests/ui/unstable-features/negative_impls.rs
new file mode 100644
index 0000000..9605642
--- /dev/null
+++ b/crates/pin-project/tests/ui/unstable-features/negative_impls.rs
@@ -0,0 +1,23 @@
+#![feature(negative_impls)]
+#![deny(suspicious_auto_trait_impls)]
+
+// https://rust-lang.zulipchat.com/#narrow/stream/213817-t-lang/topic/design.20meeting.3A.20backlog.20bonanza/near/269471299
+// https://github.com/taiki-e/pin-project/issues/340
+
+#[pin_project::pin_project]
+struct Foo<Pinned, Unpinned> {
+    #[pin]
+    pinned: Pinned,
+
+    unpinned: Unpinned,
+}
+
+struct MyPhantomPinned {}
+impl !Unpin for MyPhantomPinned {}
+impl Unpin for Foo<MyPhantomPinned, ()> {}
+
+fn is_unpin<T: Unpin>() {}
+
+fn main() {
+    is_unpin::<Foo<MyPhantomPinned, ()>>()
+}
diff --git a/crates/pin-project/tests/ui/unstable-features/negative_impls.stderr b/crates/pin-project/tests/ui/unstable-features/negative_impls.stderr
new file mode 100644
index 0000000..145716d
--- /dev/null
+++ b/crates/pin-project/tests/ui/unstable-features/negative_impls.stderr
@@ -0,0 +1,19 @@
+error: cross-crate traits with a default impl, like `Unpin`, should not be specialized
+  --> tests/ui/unstable-features/negative_impls.rs:17:1
+   |
+17 | impl Unpin for Foo<MyPhantomPinned, ()> {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = warning: this will change its meaning in a future release!
+   = note: for more information, see issue #93367 <https://github.com/rust-lang/rust/issues/93367>
+   = note: `MyPhantomPinned` is not a generic parameter
+note: try using the same sequence of generic parameters as the struct definition
+  --> tests/ui/unstable-features/negative_impls.rs:8:1
+   |
+8  | struct Foo<Pinned, Unpinned> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+note: the lint level is defined here
+  --> tests/ui/unstable-features/negative_impls.rs:2:9
+   |
+2  | #![deny(suspicious_auto_trait_impls)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/crates/pin-project/tests/ui/unstable-features/overlapping_marker_traits-feature-gate.rs b/crates/pin-project/tests/ui/unstable-features/overlapping_marker_traits-feature-gate.rs
new file mode 100644
index 0000000..012c870
--- /dev/null
+++ b/crates/pin-project/tests/ui/unstable-features/overlapping_marker_traits-feature-gate.rs
@@ -0,0 +1,20 @@
+// Note: If you change this test, change 'overlapping_marker_traits.rs' at the same time.
+
+use std::marker::PhantomPinned;
+
+use pin_project::pin_project;
+
+#[pin_project] //~ ERROR E0119
+struct Struct<T> {
+    #[pin]
+    f: T,
+}
+
+// unsound Unpin impl
+impl<T> Unpin for Struct<T> {}
+
+fn is_unpin<T: Unpin>() {}
+
+fn main() {
+    is_unpin::<Struct<PhantomPinned>>()
+}
diff --git a/crates/pin-project/tests/ui/unstable-features/overlapping_marker_traits-feature-gate.stderr b/crates/pin-project/tests/ui/unstable-features/overlapping_marker_traits-feature-gate.stderr
new file mode 100644
index 0000000..0783be0
--- /dev/null
+++ b/crates/pin-project/tests/ui/unstable-features/overlapping_marker_traits-feature-gate.stderr
@@ -0,0 +1,10 @@
+error[E0119]: conflicting implementations of trait `Unpin` for type `Struct<_>`
+  --> tests/ui/unstable-features/overlapping_marker_traits-feature-gate.rs:7:1
+   |
+7  | #[pin_project] //~ ERROR E0119
+   | ^^^^^^^^^^^^^^ conflicting implementation for `Struct<_>`
+...
+14 | impl<T> Unpin for Struct<T> {}
+   | --------------------------- first implementation here
+   |
+   = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/crates/pin-project/tests/ui/unstable-features/overlapping_marker_traits.rs b/crates/pin-project/tests/ui/unstable-features/overlapping_marker_traits.rs
new file mode 100644
index 0000000..8dc27c1
--- /dev/null
+++ b/crates/pin-project/tests/ui/unstable-features/overlapping_marker_traits.rs
@@ -0,0 +1,30 @@
+// Note: If you change this test, change 'overlapping_marker_traits-feature-gate.rs' at the same time.
+
+// This feature could break the guarantee for Unpin provided by pin-project,
+// but was removed in https://github.com/rust-lang/rust/pull/68544 (nightly-2020-02-06).
+// Refs:
+// - https://github.com/rust-lang/rust/issues/29864#issuecomment-515780867
+// - https://github.com/taiki-e/pin-project/issues/105
+
+// overlapping_marker_traits
+// Tracking issue: https://github.com/rust-lang/rust/issues/29864
+#![feature(overlapping_marker_traits)]
+
+use std::marker::PhantomPinned;
+
+use pin_project::pin_project;
+
+#[pin_project]
+struct Struct<T> {
+    #[pin]
+    f: T,
+}
+
+// unsound Unpin impl
+impl<T> Unpin for Struct<T> {}
+
+fn is_unpin<T: Unpin>() {}
+
+fn main() {
+    is_unpin::<Struct<PhantomPinned>>()
+}
diff --git a/crates/pin-project/tests/ui/unstable-features/overlapping_marker_traits.stderr b/crates/pin-project/tests/ui/unstable-features/overlapping_marker_traits.stderr
new file mode 100644
index 0000000..1c8e7e7
--- /dev/null
+++ b/crates/pin-project/tests/ui/unstable-features/overlapping_marker_traits.stderr
@@ -0,0 +1,18 @@
+error[E0557]: feature has been removed
+  --> tests/ui/unstable-features/overlapping_marker_traits.rs:11:12
+   |
+11 | #![feature(overlapping_marker_traits)]
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^ feature has been removed
+   |
+   = note: removed in favor of `#![feature(marker_trait_attr)]`
+
+error[E0119]: conflicting implementations of trait `Unpin` for type `Struct<_>`
+  --> tests/ui/unstable-features/overlapping_marker_traits.rs:17:1
+   |
+17 | #[pin_project]
+   | ^^^^^^^^^^^^^^ conflicting implementation for `Struct<_>`
+...
+24 | impl<T> Unpin for Struct<T> {}
+   | --------------------------- first implementation here
+   |
+   = note: this error originates in the derive macro `::pin_project::__private::__PinProjectInternalDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/crates/pin-project/tests/ui/unstable-features/trivial_bounds-feature-gate.rs b/crates/pin-project/tests/ui/unstable-features/trivial_bounds-feature-gate.rs
new file mode 100644
index 0000000..f8467b0
--- /dev/null
+++ b/crates/pin-project/tests/ui/unstable-features/trivial_bounds-feature-gate.rs
@@ -0,0 +1,53 @@
+// Note: If you change this test, change 'trivial_bounds.rs' at the same time.
+
+mod phantom_pinned {
+    use std::marker::{PhantomData, PhantomPinned};
+
+    struct A(PhantomPinned);
+
+    impl Unpin for A where PhantomPinned: Unpin {} //~ ERROR E0277
+
+    struct Wrapper<T>(T);
+
+    impl<T> Unpin for Wrapper<T> where T: Unpin {}
+
+    struct B(PhantomPinned);
+
+    impl Unpin for B where Wrapper<PhantomPinned>: Unpin {} //~ ERROR E0277
+
+    struct WrapperWithLifetime<'a, T>(PhantomData<&'a ()>, T);
+
+    impl<T> Unpin for WrapperWithLifetime<'_, T> where T: Unpin {}
+
+    struct C(PhantomPinned);
+
+    impl<'a> Unpin for C where WrapperWithLifetime<'a, PhantomPinned>: Unpin {} // Ok
+}
+
+mod inner {
+    use std::marker::{PhantomData, PhantomPinned};
+
+    struct Inner(PhantomPinned);
+
+    struct A(Inner);
+
+    impl Unpin for A where Inner: Unpin {} //~ ERROR E0277
+
+    struct Wrapper<T>(T);
+
+    impl<T> Unpin for Wrapper<T> where T: Unpin {}
+
+    struct B(Inner);
+
+    impl Unpin for B where Wrapper<Inner>: Unpin {} //~ ERROR E0277
+
+    struct WrapperWithLifetime<'a, T>(PhantomData<&'a ()>, T);
+
+    impl<T> Unpin for WrapperWithLifetime<'_, T> where T: Unpin {}
+
+    struct C(Inner);
+
+    impl<'a> Unpin for C where WrapperWithLifetime<'a, Inner>: Unpin {} // Ok
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/ui/unstable-features/trivial_bounds-feature-gate.stderr b/crates/pin-project/tests/ui/unstable-features/trivial_bounds-feature-gate.stderr
new file mode 100644
index 0000000..ccf1ae8
--- /dev/null
+++ b/crates/pin-project/tests/ui/unstable-features/trivial_bounds-feature-gate.stderr
@@ -0,0 +1,63 @@
+error[E0277]: `PhantomPinned` cannot be unpinned
+ --> tests/ui/unstable-features/trivial_bounds-feature-gate.rs:8:28
+  |
+8 |     impl Unpin for A where PhantomPinned: Unpin {} //~ ERROR E0277
+  |                            ^^^^^^^^^^^^^^^^^^^^ the trait `Unpin` is not implemented for `PhantomPinned`
+  |
+  = note: consider using the `pin!` macro
+          consider using `Box::pin` if you need to access the pinned value outside of the current scope
+  = help: see issue #48214
+  = help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
+
+error[E0277]: `PhantomPinned` cannot be unpinned
+  --> tests/ui/unstable-features/trivial_bounds-feature-gate.rs:16:28
+   |
+16 |     impl Unpin for B where Wrapper<PhantomPinned>: Unpin {} //~ ERROR E0277
+   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Unpin` is not implemented for `PhantomPinned`
+   |
+   = note: consider using the `pin!` macro
+           consider using `Box::pin` if you need to access the pinned value outside of the current scope
+note: required for `phantom_pinned::Wrapper<PhantomPinned>` to implement `Unpin`
+  --> tests/ui/unstable-features/trivial_bounds-feature-gate.rs:12:13
+   |
+12 |     impl<T> Unpin for Wrapper<T> where T: Unpin {}
+   |             ^^^^^     ^^^^^^^^^^          ----- unsatisfied trait bound introduced here
+   = help: see issue #48214
+   = help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
+
+error[E0277]: `PhantomPinned` cannot be unpinned
+  --> tests/ui/unstable-features/trivial_bounds-feature-gate.rs:34:28
+   |
+34 |     impl Unpin for A where Inner: Unpin {} //~ ERROR E0277
+   |                            ^^^^^^^^^^^^ within `Inner`, the trait `Unpin` is not implemented for `PhantomPinned`
+   |
+   = note: consider using the `pin!` macro
+           consider using `Box::pin` if you need to access the pinned value outside of the current scope
+note: required because it appears within the type `Inner`
+  --> tests/ui/unstable-features/trivial_bounds-feature-gate.rs:30:12
+   |
+30 |     struct Inner(PhantomPinned);
+   |            ^^^^^
+   = help: see issue #48214
+   = help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
+
+error[E0277]: `PhantomPinned` cannot be unpinned
+  --> tests/ui/unstable-features/trivial_bounds-feature-gate.rs:42:28
+   |
+42 |     impl Unpin for B where Wrapper<Inner>: Unpin {} //~ ERROR E0277
+   |                            ^^^^^^^^^^^^^^^^^^^^^ within `Inner`, the trait `Unpin` is not implemented for `PhantomPinned`
+   |
+   = note: consider using the `pin!` macro
+           consider using `Box::pin` if you need to access the pinned value outside of the current scope
+note: required because it appears within the type `Inner`
+  --> tests/ui/unstable-features/trivial_bounds-feature-gate.rs:30:12
+   |
+30 |     struct Inner(PhantomPinned);
+   |            ^^^^^
+note: required for `inner::Wrapper<Inner>` to implement `Unpin`
+  --> tests/ui/unstable-features/trivial_bounds-feature-gate.rs:38:13
+   |
+38 |     impl<T> Unpin for Wrapper<T> where T: Unpin {}
+   |             ^^^^^     ^^^^^^^^^^          ----- unsatisfied trait bound introduced here
+   = help: see issue #48214
+   = help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
diff --git a/crates/pin-project/tests/ui/unstable-features/trivial_bounds.rs b/crates/pin-project/tests/ui/unstable-features/trivial_bounds.rs
new file mode 100644
index 0000000..d98ef60
--- /dev/null
+++ b/crates/pin-project/tests/ui/unstable-features/trivial_bounds.rs
@@ -0,0 +1,39 @@
+// Note: If you change this test, change 'trivial_bounds-feature-gate.rs' at the same time.
+
+// trivial_bounds
+// Tracking issue: https://github.com/rust-lang/rust/issues/48214
+#![feature(trivial_bounds)]
+#![deny(trivial_bounds)]
+#![allow(dead_code)]
+
+use std::marker::{PhantomData, PhantomPinned};
+
+fn inner() {
+    struct Inner(PhantomPinned);
+
+    struct A(PhantomPinned);
+
+    impl Unpin for A where PhantomPinned: Unpin {} //~ ERROR Unpin does not depend on any type or lifetime parameters
+
+    struct B(Inner);
+
+    impl Unpin for B where Inner: Unpin {} //~ ERROR Unpin does not depend on any type or lifetime parameters
+
+    struct Wrapper<T>(T);
+
+    impl<T> Unpin for Wrapper<T> where T: Unpin {}
+
+    struct C(Inner);
+
+    impl Unpin for C where Wrapper<Inner>: Unpin {} //~ ERROR Unpin does not depend on any type or lifetime parameters
+
+    struct WrapperWithLifetime<'a, T>(PhantomData<&'a ()>, T);
+
+    impl<T> Unpin for WrapperWithLifetime<'_, T> where T: Unpin {}
+
+    struct D(Inner);
+
+    impl<'a> Unpin for D where WrapperWithLifetime<'a, Inner>: Unpin {} // Ok
+}
+
+fn main() {}
diff --git a/crates/pin-project/tests/ui/unstable-features/trivial_bounds.stderr b/crates/pin-project/tests/ui/unstable-features/trivial_bounds.stderr
new file mode 100644
index 0000000..ab07a10
--- /dev/null
+++ b/crates/pin-project/tests/ui/unstable-features/trivial_bounds.stderr
@@ -0,0 +1,23 @@
+error: trait bound PhantomPinned: Unpin does not depend on any type or lifetime parameters
+  --> tests/ui/unstable-features/trivial_bounds.rs:16:43
+   |
+16 |     impl Unpin for A where PhantomPinned: Unpin {} //~ ERROR Unpin does not depend on any type or lifetime parameters
+   |                                           ^^^^^
+   |
+note: the lint level is defined here
+  --> tests/ui/unstable-features/trivial_bounds.rs:6:9
+   |
+6  | #![deny(trivial_bounds)]
+   |         ^^^^^^^^^^^^^^
+
+error: trait bound Inner: Unpin does not depend on any type or lifetime parameters
+  --> tests/ui/unstable-features/trivial_bounds.rs:20:35
+   |
+20 |     impl Unpin for B where Inner: Unpin {} //~ ERROR Unpin does not depend on any type or lifetime parameters
+   |                                   ^^^^^
+
+error: trait bound Wrapper<Inner>: Unpin does not depend on any type or lifetime parameters
+  --> tests/ui/unstable-features/trivial_bounds.rs:28:44
+   |
+28 |     impl Unpin for C where Wrapper<Inner>: Unpin {} //~ ERROR Unpin does not depend on any type or lifetime parameters
+   |                                            ^^^^^
diff --git a/crates/pin-project/tests/unsafe_unpin.rs b/crates/pin-project/tests/unsafe_unpin.rs
new file mode 100644
index 0000000..72f40f9
--- /dev/null
+++ b/crates/pin-project/tests/unsafe_unpin.rs
@@ -0,0 +1,50 @@
+#![warn(rust_2018_idioms, single_use_lifetimes)]
+#![allow(dead_code)]
+
+#[macro_use]
+mod auxiliary;
+
+use std::marker::PhantomPinned;
+
+use pin_project::{pin_project, UnsafeUnpin};
+
+#[pin_project(UnsafeUnpin)]
+pub struct Blah<T, U> {
+    f1: U,
+    #[pin]
+    f2: T,
+}
+
+unsafe impl<T: Unpin, U> UnsafeUnpin for Blah<T, U> {}
+
+assert_unpin!(Blah<(), ()>);
+assert_unpin!(Blah<(), PhantomPinned>);
+assert_not_unpin!(Blah<PhantomPinned, ()>);
+assert_not_unpin!(Blah<PhantomPinned, PhantomPinned>);
+
+#[pin_project(UnsafeUnpin)]
+struct OverlappingLifetimeNames<'pin, T, U> {
+    #[pin]
+    f1: U,
+    #[pin]
+    f2: Option<T>,
+    f3: &'pin (),
+}
+
+unsafe impl<T: Unpin, U: Unpin> UnsafeUnpin for OverlappingLifetimeNames<'_, T, U> {}
+
+assert_unpin!(OverlappingLifetimeNames<'_, (), ()>);
+assert_not_unpin!(OverlappingLifetimeNames<'_, PhantomPinned, ()>);
+assert_not_unpin!(OverlappingLifetimeNames<'_, (), PhantomPinned>);
+assert_not_unpin!(OverlappingLifetimeNames<'_, PhantomPinned, PhantomPinned>);
+
+#[test]
+fn trivial_bounds() {
+    #[pin_project(UnsafeUnpin)]
+    pub struct NotImplementUnsafeUnpin {
+        #[pin]
+        f: PhantomPinned,
+    }
+
+    assert_not_unpin!(NotImplementUnsafeUnpin);
+}
diff --git a/crates/pkcs1/.cargo-checksum.json b/crates/pkcs1/.cargo-checksum.json
new file mode 100644
index 0000000..33857b2
--- /dev/null
+++ b/crates/pkcs1/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"CHANGELOG.md":"7b6de36b99e3359f7c55a77ca4d94dec6f25e7b55e522e5559fc6fa028fc0286","Cargo.toml":"f36a724895555cc811c9ad7c098661ff1576d039f75a4755c960a132da9f8f19","LICENSE-APACHE":"a9040321c3712d8fd0b09cf52b17445de04a23a10165049ae187cd39e5c86be5","LICENSE-MIT":"c995204cc6bad2ed67dd41f7d89bb9f1a9d48e0edd745732b30640d7912089a4","README.md":"96072ae2126dbbe8882335864ed80e7530914b265680a7ce7d47bbe832f07378","src/error.rs":"193ee9bcd92c91c7290e07e7c419a192e6306b77b8f9559e88d1e01cf2ffde9f","src/lib.rs":"19c061ff24e546c74db8f1368017508715bfa585aaa37e4fd59a1d2f90979a91","src/params.rs":"3c0582fa3827eae4c5a5d355be098329be366b26caaf5f8d641007c073fd9b0e","src/private_key.rs":"ceec5c850e9ba207b5796ccc62901136400550a018ae39582fd06d26f196dad9","src/private_key/other_prime_info.rs":"be3d73f51d439350956b0a6106f6e8751bc9460e1c98f6ac95240c8b7ad6c523","src/public_key.rs":"a747ab701b392c7c147906eefbf21387fc5b2d9dff958de98bd454bdb991f2c9","src/traits.rs":"7c1d6227aa9298df49e9e22b7e8640adcdaa913bf8a17e25ab9701afd4f0d051","src/version.rs":"f7e00c942fffbfc755427ecebbb93c33648d9517c4758badb3da85ff002aea8a","tests/examples/rsa2048-priv-3prime.der":"1ec54d0f9a3b360e7f4ac3f8f89ad00c0f4e44f2072aa924e2b3b9b739409141","tests/examples/rsa2048-priv-3prime.pem":"1f147cc046c3b7b6e227eb352f7e99b23a0c60c241f11d2ebeaf1cfc1ed1148c","tests/examples/rsa2048-priv.der":"f94b60300e4877e863b2bea8d5c366a90432794454c05e0ec098ddbf96263614","tests/examples/rsa2048-priv.pem":"026c0bc90e1d06dc828a90dc4fcfb29d5b4cd0eeb93123047035804092569086","tests/examples/rsa2048-pub.der":"53ad7f462c0329c639a9cd44e0f57f99713c92abe84d39a70b2cb6e0c4186aab","tests/examples/rsa2048-pub.pem":"f52a1bcae2af19cd7964f8048e32ee1f1103315952d9d98c9a5fedcf91f6812d","tests/examples/rsa4096-priv.der":"739ddd3697b6aa82ae5753663a62c0f21136d8528781261731c932f53a061ffe","tests/examples/rsa4096-priv.pem":"db7cd9d48e60b513cd322dc6fd8b679514d1f725637294fd44a61cd971067f0c","tests/examples/rsa4096-pub.der":"2a1198a8542f615eeb803d6b0a7c6fcc426f8e783ebf0ebb2baf1344996f0782","tests/examples/rsa4096-pub.pem":"4469bbb4747c1036f672078a11d74cda3aafe0c6dd2c454a242c7ae94d7da0d0","tests/params.rs":"543851f1224654fef289e7ae12fbb63337a8c0a6add31bba5648ab06279afb1f","tests/private_key.rs":"ea4a3e2a8bf4ad2e7349d6e095bf034931fc60498f3f2573936275390fdbdd20","tests/public_key.rs":"d8abb3fac083a23dd9b4642ffd48222c57d8ce692ceaa3024a2b24bdcc2f15d5","tests/traits.rs":"53a8e3bf7a6a53ef3ded4d8647eff65c482f5de79ad97c569ab831a99b34879b"},"package":"c8ffb9f10fa047879315e6625af03c164b16962a5368d724ed16323b68ace47f"}
\ No newline at end of file
diff --git a/crates/pkcs1/Android.bp b/crates/pkcs1/Android.bp
new file mode 100644
index 0000000..40bb3ba
--- /dev/null
+++ b/crates/pkcs1/Android.bp
@@ -0,0 +1,77 @@
+// This file is generated by cargo_embargo.
+// Do not modify this file because the changes will be overridden on upgrade.
+
+package {
+    default_applicable_licenses: ["external_rust_crates_pkcs1_license"],
+    default_team: "trendy_team_android_rust",
+}
+
+license {
+    name: "external_rust_crates_pkcs1_license",
+    visibility: [":__subpackages__"],
+    license_kinds: ["SPDX-license-identifier-Apache-2.0"],
+    license_text: ["LICENSE"],
+}
+
+rust_library {
+    name: "libpkcs1",
+    host_supported: true,
+    crate_name: "pkcs1",
+    cargo_env_compat: true,
+    cargo_pkg_version: "0.7.5",
+    crate_root: "src/lib.rs",
+    edition: "2021",
+    features: [
+        "alloc",
+        "zeroize",
+    ],
+    rustlibs: [
+        "libder",
+        "libspki",
+    ],
+    apex_available: [
+        "//apex_available:platform",
+        "com.android.virt",
+    ],
+    product_available: true,
+    vendor_available: true,
+    visibility: [
+        "//packages/modules/Virtualization:__subpackages__",
+        "//system/keymint:__subpackages__",
+    ],
+
+}
+
+rust_library_rlib {
+    name: "libpkcs1_nostd",
+    crate_name: "pkcs1",
+    cargo_env_compat: true,
+    cargo_pkg_version: "0.7.5",
+    crate_root: "src/lib.rs",
+    edition: "2021",
+    features: [
+        "alloc",
+        "zeroize",
+    ],
+    rustlibs: [
+        "libder_nostd",
+        "libspki_nostd",
+    ],
+    apex_available: [
+        "//apex_available:platform",
+        "com.android.virt",
+    ],
+    prefer_rlib: true,
+    no_stdlibs: true,
+    stdlibs: [
+        "libcompiler_builtins.rust_sysroot",
+        "libcore.rust_sysroot",
+    ],
+    product_available: true,
+    vendor_available: true,
+    visibility: [
+        "//packages/modules/Virtualization:__subpackages__",
+        "//system/keymint:__subpackages__",
+    ],
+
+}
diff --git a/crates/pkcs1/CHANGELOG.md b/crates/pkcs1/CHANGELOG.md
new file mode 100644
index 0000000..e6b79c1
--- /dev/null
+++ b/crates/pkcs1/CHANGELOG.md
@@ -0,0 +1,160 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## 0.7.5 (2023-04-24)
+### Fixed
+- Import failure ([#1021])
+
+[#1021]: https://github.com/RustCrypto/formats/pull/1021
+
+## 0.7.4 (2023-04-21)
+### Changed
+- Have `alloc` feature only weakly activate `pkcs8?/alloc` ([#1013])
+- Have `pem` feature only weakly activate `pkcs8?/pem` ([#1013])
+
+[#1013]: https://github.com/RustCrypto/formats/pull/1013
+
+## 0.7.3 (2023-04-18)
+### Added
+- Provide functions to construct `RsaPss` and `RsaOaepParams` ([#1010])
+
+### Changed
+- Use `NULL` parameters for SHA `AlgorithmIdentifier`s ([#1010])
+
+[#1010]: https://github.com/RustCrypto/formats/pull/1010
+
+## 0.7.2 (2023-04-04)
+### Added
+- `RsaPssParams::SALT_LEN_DEFAULT` ([#953])
+
+[#953]: https://github.com/RustCrypto/formats/pull/953
+
+## 0.7.1 (2023-03-05)
+### Fixed
+- `DecodeRsaPublicKey` blanket impl ([#916])
+
+[#916]: https://github.com/RustCrypto/formats/pull/916
+
+## 0.7.0 (2023-02-26) [YANKED]
+### Changed
+- Make PSS/OAEP params use generic `AlgorithmIdentifier` ([#799])
+- Bump `der` dependency to v0.7 ([#899])
+- Bump `spki` dependency to v0.7 ([#900])
+- Bump `pkcs8` to v0.10 ([#902])
+
+[#799]: https://github.com/RustCrypto/formats/pull/799
+[#899]: https://github.com/RustCrypto/formats/pull/899
+[#900]: https://github.com/RustCrypto/formats/pull/900
+[#902]: https://github.com/RustCrypto/formats/pull/902
+
+## 0.6.0 (Skipped)
+- Skipped to synchronize version number with `der` and `spki`
+
+## 0.5.0 (Skipped)
+- Skipped to synchronize version number with `der` and `spki`
+
+## 0.4.1 (2022-10-10)
+### Added
+- `RsaPssParams` support ([#698])
+- `RsaOaepParams` support ([#733])
+
+[#698]: https://github.com/RustCrypto/formats/pull/698
+[#733]: https://github.com/RustCrypto/formats/pull/733
+
+## 0.4.0 (2022-05-08)
+### Changed
+- Replace document types with `doc::{Document, SecretDocument}` types ([#571])
+- Bump `der` to v0.6 ([#653])
+- Bump `pkcs8` to v0.9 ([#656])
+
+[#571]: https://github.com/RustCrypto/formats/pull/571
+[#653]: https://github.com/RustCrypto/formats/pull/653
+[#656]: https://github.com/RustCrypto/formats/pull/656
+
+## 0.3.3 (2022-01-16)
+### Added
+- Error conversion support to `pkcs8::spki::Error` ([#333])
+
+[#333]: https://github.com/RustCrypto/formats/pull/331
+
+## 0.3.2 (2022-01-16)
+### Added
+- Error conversion support to `pkcs8::Error` ([#331])
+
+[#331]: https://github.com/RustCrypto/formats/pull/331
+
+## 0.3.1 (2021-11-29)
+### Changed
+- Use `finish_non_exhaustive` in Debug impls ([#245])
+
+[#245]: https://github.com/RustCrypto/formats/pull/245
+
+## 0.3.0 (2021-11-17)
+### Added
+- Support for multi-prime RSA keys ([#115])
+- `pkcs8` feature ([#227], [#233])
+
+### Changed
+- Rename `From/ToRsa*Key` => `DecodeRsa*Key`/`EncodeRsa*Key` ([#120])
+- Use `der::Document` to impl `RsaPrivateKeyDocument` ([#131])
+- Rust 2021 edition upgrade; MSRV 1.56 ([#136])
+- Make `RsaPrivateKey::version` implicit ([#188])
+- Bump `der` crate dependency to v0.5 ([#222])
+- Activate `pkcs8/pem` when `pem` feature is enabled ([#232])
+
+### Removed
+- `*_with_le` PEM encoding methods ([#109])
+- I/O related errors ([#158])
+
+[#109]: https://github.com/RustCrypto/formats/pull/109
+[#115]: https://github.com/RustCrypto/formats/pull/115
+[#120]: https://github.com/RustCrypto/formats/pull/120
+[#131]: https://github.com/RustCrypto/formats/pull/131
+[#136]: https://github.com/RustCrypto/formats/pull/136
+[#158]: https://github.com/RustCrypto/formats/pull/158
+[#188]: https://github.com/RustCrypto/formats/pull/188
+[#222]: https://github.com/RustCrypto/formats/pull/222
+[#227]: https://github.com/RustCrypto/formats/pull/227
+[#232]: https://github.com/RustCrypto/formats/pull/232
+[#233]: https://github.com/RustCrypto/formats/pull/233
+
+## 0.2.4 (2021-09-14)
+### Changed
+- Moved to `formats` repo ([#2])
+
+[#2]: https://github.com/RustCrypto/formats/pull/2
+
+## 0.2.3 (2021-07-26)
+### Added
+- Support for customizing PEM `LineEnding`
+
+### Changed
+- Bump `pem-rfc7468` dependency to v0.2
+
+## 0.2.2 (2021-07-25)
+### Fixed
+- `Version` encoder
+
+## 0.2.1 (2021-07-25)
+### Added
+- `Error::Crypto` variant
+
+## 0.2.0 (2021-07-25)
+### Added
+- `From*`/`To*` traits for `RsaPrivateKey`/`RsaPublicKey`
+
+### Changed
+- Use `FromRsa*`/`ToRsa*` traits with `*Document` types
+
+## 0.1.1 (2021-07-24)
+### Added
+- Re-export `der` crate and `der::UIntBytes`
+
+### Changed
+- Replace `Error::{Decode, Encode}` with `Error::Asn1`
+
+## 0.1.0 (2021-07-24) [YANKED]
+- Initial release
diff --git a/crates/pkcs1/Cargo.lock b/crates/pkcs1/Cargo.lock
new file mode 100644
index 0000000..f0878d6
--- /dev/null
+++ b/crates/pkcs1/Cargo.lock
@@ -0,0 +1,233 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "base64ct"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
+
+[[package]]
+name = "bitflags"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "const-oid"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
+
+[[package]]
+name = "der"
+version = "0.7.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f55bf8e7b65898637379c1b74eb1551107c8294ed26d855ceb9fd1a09cfc9bc0"
+dependencies = [
+ "const-oid",
+ "pem-rfc7468",
+ "zeroize",
+]
+
+[[package]]
+name = "errno"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "534c5cf6194dfab3db3242765c03bbe257cf92f22b38f6bc0c58d59108a820ba"
+dependencies = [
+ "libc",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "fastrand"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e8c02a5121d4ea3eb16a80748c74f5549a5665e4c21333c6098f283870fbdea6"
+
+[[package]]
+name = "hex-literal"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6fe2267d4ed49bc07b63801559be28c718ea06c4738b7a03c94df7386d2cde46"
+
+[[package]]
+name = "libc"
+version = "0.2.158"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439"
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89"
+
+[[package]]
+name = "once_cell"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
+
+[[package]]
+name = "pem-rfc7468"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88b39c9bfcfc231068454382784bb460aae594343fb030d46e9f50a645418412"
+dependencies = [
+ "base64ct",
+]
+
+[[package]]
+name = "pkcs1"
+version = "0.7.5"
+dependencies = [
+ "const-oid",
+ "der",
+ "hex-literal",
+ "pkcs8",
+ "spki",
+ "tempfile",
+]
+
+[[package]]
+name = "pkcs8"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
+dependencies = [
+ "der",
+ "spki",
+]
+
+[[package]]
+name = "rustix"
+version = "0.38.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a85d50532239da68e9addb745ba38ff4612a242c1c7ceea689c4bc7c2f43c36f"
+dependencies = [
+ "bitflags",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "spki"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
+dependencies = [
+ "base64ct",
+ "der",
+]
+
+[[package]]
+name = "tempfile"
+version = "3.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04cbcdd0c794ebb0d4cf35e88edd2f7d2c4c3e9a5a6dab322839b321c6a87a64"
+dependencies = [
+ "cfg-if",
+ "fastrand",
+ "once_cell",
+ "rustix",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+dependencies = [
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+
+[[package]]
+name = "zeroize"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde"
diff --git a/crates/pkcs1/Cargo.toml b/crates/pkcs1/Cargo.toml
new file mode 100644
index 0000000..4365648
--- /dev/null
+++ b/crates/pkcs1/Cargo.toml
@@ -0,0 +1,84 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2021"
+rust-version = "1.60"
+name = "pkcs1"
+version = "0.7.5"
+authors = ["RustCrypto Developers"]
+description = """
+Pure Rust implementation of Public-Key Cryptography Standards (PKCS) #1:
+RSA Cryptography Specifications Version 2.2 (RFC 8017)
+"""
+readme = "README.md"
+keywords = [
+    "crypto",
+    "key",
+    "pem",
+    "pkcs",
+    "rsa",
+]
+categories = [
+    "cryptography",
+    "data-structures",
+    "encoding",
+    "no-std",
+    "parser-implementations",
+]
+license = "Apache-2.0 OR MIT"
+repository = "https://github.com/RustCrypto/formats/tree/master/pkcs1"
+
+[package.metadata.docs.rs]
+all-features = true
+rustdoc-args = [
+    "--cfg",
+    "docsrs",
+]
+
+[dependencies.der]
+version = "0.7"
+features = ["oid"]
+
+[dependencies.pkcs8]
+version = "0.10"
+optional = true
+default-features = false
+
+[dependencies.spki]
+version = "0.7"
+
+[dev-dependencies.const-oid]
+version = "0.9"
+features = ["db"]
+
+[dev-dependencies.hex-literal]
+version = "0.4"
+
+[dev-dependencies.tempfile]
+version = "3"
+
+[features]
+alloc = [
+    "der/alloc",
+    "zeroize",
+    "pkcs8?/alloc",
+]
+pem = [
+    "alloc",
+    "der/pem",
+    "pkcs8?/pem",
+]
+std = [
+    "der/std",
+    "alloc",
+]
+zeroize = ["der/zeroize"]
diff --git a/crates/pkcs1/LICENSE b/crates/pkcs1/LICENSE
new file mode 120000
index 0000000..6b579aa
--- /dev/null
+++ b/crates/pkcs1/LICENSE
@@ -0,0 +1 @@
+LICENSE-APACHE
\ No newline at end of file
diff --git a/crates/pkcs1/LICENSE-APACHE b/crates/pkcs1/LICENSE-APACHE
new file mode 100644
index 0000000..78173fa
--- /dev/null
+++ b/crates/pkcs1/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/crates/pkcs1/LICENSE-MIT b/crates/pkcs1/LICENSE-MIT
new file mode 100644
index 0000000..3294d74
--- /dev/null
+++ b/crates/pkcs1/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2021-2023 The RustCrypto Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/crates/pkcs1/METADATA b/crates/pkcs1/METADATA
new file mode 100644
index 0000000..434f1c5
--- /dev/null
+++ b/crates/pkcs1/METADATA
@@ -0,0 +1,20 @@
+# This project was upgraded with external_updater.
+# Usage: tools/external_updater/updater.sh update rust/crates/pkcs1
+# For more info, check https://cs.android.com/android/platform/superproject/+/main:tools/external_updater/README.md
+
+name: "pkcs1"
+description: "Pure Rust implementation of Public-Key Cryptography Standards (PKCS) #1: RSA Cryptography Specifications Version 2.2 (RFC 8017)."
+third_party {
+  license_type: NOTICE
+  last_upgrade_date {
+    year: 2023
+    month: 12
+    day: 15
+  }
+  homepage: "https://crates.io/crates/pkcs1"
+  identifier {
+    type: "Archive"
+    value: "https://static.crates.io/crates/pkcs1/pkcs1-0.7.5.crate"
+    version: "0.7.5"
+  }
+}
diff --git a/crates/pkcs1/MODULE_LICENSE_APACHE2 b/crates/pkcs1/MODULE_LICENSE_APACHE2
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/crates/pkcs1/MODULE_LICENSE_APACHE2
diff --git a/crates/pkcs1/README.md b/crates/pkcs1/README.md
new file mode 100644
index 0000000..597a1b2
--- /dev/null
+++ b/crates/pkcs1/README.md
@@ -0,0 +1,70 @@
+# [RustCrypto]: PKCS#1 (RSA)
+
+[![crate][crate-image]][crate-link]
+[![Docs][docs-image]][docs-link]
+[![Build Status][build-image]][build-link]
+![Apache2/MIT licensed][license-image]
+![Rust Version][rustc-image]
+[![Project Chat][chat-image]][chat-link]
+
+Pure Rust implementation of Public-Key Cryptography Standards (PKCS) #1:
+RSA Cryptography Specifications Version 2.2 ([RFC 8017]).
+
+[Documentation][docs-link]
+
+## About
+
+This crate supports encoding and decoding RSA private and public keys
+in either PKCS#1 DER (binary) or PEM (text) formats.
+
+PEM encoded RSA private keys begin with:
+
+```text
+-----BEGIN RSA PRIVATE KEY-----
+```
+
+PEM encoded RSA public keys begin with:
+
+```text
+-----BEGIN RSA PUBLIC KEY-----
+```
+
+## Minimum Supported Rust Version
+
+This crate requires **Rust 1.65** at a minimum.
+
+We may change the MSRV in the future, but it will be accompanied by a minor
+version bump.
+
+## License
+
+Licensed under either of:
+
+ * [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0)
+ * [MIT license](http://opensource.org/licenses/MIT)
+
+at your option.
+
+### Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in the work by you, as defined in the Apache-2.0 license, shall be
+dual licensed as above, without any additional terms or conditions.
+
+[//]: # (badges)
+
+[crate-image]: https://buildstats.info/crate/pkcs1
+[crate-link]: https://crates.io/crates/pkcs1
+[docs-image]: https://docs.rs/pkcs1/badge.svg
+[docs-link]: https://docs.rs/pkcs1/
+[license-image]: https://img.shields.io/badge/license-Apache2.0/MIT-blue.svg
+[rustc-image]: https://img.shields.io/badge/rustc-1.65+-blue.svg
+[chat-image]: https://img.shields.io/badge/zulip-join_chat-blue.svg
+[chat-link]: https://rustcrypto.zulipchat.com/#narrow/stream/300570-formats
+[build-image]: https://github.com/RustCrypto/formats/workflows/pkcs1/badge.svg?branch=master&event=push
+[build-link]: https://github.com/RustCrypto/formats/actions
+
+[//]: # (links)
+
+[RustCrypto]: https://github.com/rustcrypto
+[RFC 8017]: https://datatracker.ietf.org/doc/html/rfc8017
diff --git a/crates/pkcs1/cargo2android_viz.bp b/crates/pkcs1/cargo2android_viz.bp
new file mode 100644
index 0000000..8ce03b7
--- /dev/null
+++ b/crates/pkcs1/cargo2android_viz.bp
@@ -0,0 +1,4 @@
+visibility: [
+     "//packages/modules/Virtualization:__subpackages__",
+     "//system/keymint:__subpackages__",
+]
diff --git a/crates/pkcs1/cargo_embargo.json b/crates/pkcs1/cargo_embargo.json
new file mode 100644
index 0000000..2b1d241
--- /dev/null
+++ b/crates/pkcs1/cargo_embargo.json
@@ -0,0 +1,36 @@
+{
+  "apex_available": [
+    "//apex_available:platform",
+    "com.android.virt"
+  ],
+  "features": [
+    "alloc"
+  ],
+  "run_cargo": false,
+  "variants": [
+    {
+      "package": {
+        "pkcs1": {
+          "add_module_block": "cargo2android_viz.bp"
+        }
+      }
+    },
+    {
+      "module_name_overrides": {
+        "libder": "libder_nostd",
+        "libpkcs1": "libpkcs1_nostd",
+        "libpkcs8": "libpkcs8_nostd",
+        "libspki": "libspki_nostd",
+        "libzeroize": "libzeroize_nostd"
+      },
+      "package": {
+        "pkcs1": {
+          "add_module_block": "cargo2android_viz.bp",
+          "force_rlib": true,
+          "host_supported": false,
+          "no_std": true
+        }
+      }
+    }
+  ]
+}
diff --git a/crates/pkcs1/patches/rules.mk.diff b/crates/pkcs1/patches/rules.mk.diff
new file mode 100644
index 0000000..5e7ca8a
--- /dev/null
+++ b/crates/pkcs1/patches/rules.mk.diff
@@ -0,0 +1,13 @@
+diff --git a/rules.mk b/rules.mk
+index b31c531..6b9ef75 100644
+--- a/rules.mk
++++ b/rules.mk
+@@ -15,6 +15,8 @@ MODULE_RUSTFLAGS += \
+ 
+ MODULE_LIBRARY_DEPS := \
+ 	external/rust/crates/der \
++	external/rust/crates/pkcs8 \
+ 	external/rust/crates/spki \
++	external/rust/crates/zeroize \
+ 
+ include make/library.mk
diff --git a/crates/pkcs1/patches/std.diff b/crates/pkcs1/patches/std.diff
new file mode 100644
index 0000000..abd6960
--- /dev/null
+++ b/crates/pkcs1/patches/std.diff
@@ -0,0 +1,15 @@
+diff --git a/src/lib.rs b/src/lib.rs
+index 8b51d17..edbb128 100644
+--- a/src/lib.rs
++++ b/src/lib.rs
+@@ -9,6 +9,10 @@
+ #![forbid(unsafe_code, clippy::unwrap_used)]
+ #![warn(missing_docs, rust_2018_idioms, unused_qualifications)]
+ 
++/// Local Android change: Use std to allow building as a dylib.
++#[cfg(android_dylib)]
++extern crate std;
++
+ #[cfg(feature = "alloc")]
+ extern crate alloc;
+ #[cfg(feature = "std")]
diff --git a/crates/pkcs1/src/error.rs b/crates/pkcs1/src/error.rs
new file mode 100644
index 0000000..135bcd7
--- /dev/null
+++ b/crates/pkcs1/src/error.rs
@@ -0,0 +1,95 @@
+//! Error types
+
+use core::fmt;
+
+#[cfg(feature = "pem")]
+use der::pem;
+
+/// Result type
+pub type Result<T> = core::result::Result<T, Error>;
+
+/// Error type
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[non_exhaustive]
+pub enum Error {
+    /// ASN.1 DER-related errors.
+    Asn1(der::Error),
+
+    /// Cryptographic errors.
+    ///
+    /// These can be used by RSA implementations to signal that a key is
+    /// invalid for cryptographic reasons. This means the document parsed
+    /// correctly, but one of the values contained within was invalid, e.g.
+    /// a number expected to be a prime was not a prime.
+    Crypto,
+
+    /// PKCS#8 errors.
+    #[cfg(feature = "pkcs8")]
+    Pkcs8(pkcs8::Error),
+
+    /// Version errors
+    Version,
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Error::Asn1(err) => write!(f, "PKCS#1 ASN.1 error: {}", err),
+            Error::Crypto => f.write_str("PKCS#1 cryptographic error"),
+            #[cfg(feature = "pkcs8")]
+            Error::Pkcs8(err) => write!(f, "{}", err),
+            Error::Version => f.write_str("PKCS#1 version error"),
+        }
+    }
+}
+
+impl From<der::Error> for Error {
+    fn from(err: der::Error) -> Error {
+        Error::Asn1(err)
+    }
+}
+
+#[cfg(feature = "pem")]
+impl From<pem::Error> for Error {
+    fn from(err: pem::Error) -> Error {
+        der::Error::from(err).into()
+    }
+}
+
+#[cfg(feature = "pkcs8")]
+impl From<Error> for pkcs8::Error {
+    fn from(err: Error) -> pkcs8::Error {
+        match err {
+            Error::Asn1(e) => pkcs8::Error::Asn1(e),
+            Error::Crypto | Error::Version => pkcs8::Error::KeyMalformed,
+            Error::Pkcs8(e) => e,
+        }
+    }
+}
+
+#[cfg(feature = "pkcs8")]
+impl From<pkcs8::Error> for Error {
+    fn from(err: pkcs8::Error) -> Error {
+        Error::Pkcs8(err)
+    }
+}
+
+#[cfg(feature = "pkcs8")]
+impl From<Error> for pkcs8::spki::Error {
+    fn from(err: Error) -> pkcs8::spki::Error {
+        match err {
+            Error::Asn1(e) => pkcs8::spki::Error::Asn1(e),
+            _ => pkcs8::spki::Error::KeyMalformed,
+        }
+    }
+}
+
+#[cfg(feature = "pkcs8")]
+impl From<pkcs8::spki::Error> for Error {
+    fn from(err: pkcs8::spki::Error) -> Error {
+        Error::Pkcs8(pkcs8::Error::PublicKey(err))
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for Error {}
diff --git a/crates/pkcs1/src/lib.rs b/crates/pkcs1/src/lib.rs
new file mode 100644
index 0000000..e389cab
--- /dev/null
+++ b/crates/pkcs1/src/lib.rs
@@ -0,0 +1,66 @@
+#![no_std]
+#![cfg_attr(docsrs, feature(doc_auto_cfg))]
+#![doc = include_str!("../README.md")]
+#![doc(
+    html_logo_url = "https://raw.githubusercontent.com/RustCrypto/media/6ee8e381/logo.svg",
+    html_favicon_url = "https://raw.githubusercontent.com/RustCrypto/media/6ee8e381/logo.svg"
+)]
+#![forbid(unsafe_code)]
+#![warn(
+    clippy::mod_module_files,
+    clippy::unwrap_used,
+    missing_docs,
+    rust_2018_idioms,
+    unused_lifetimes,
+    unused_qualifications
+)]
+
+/// Local Android change: Use std to allow building as a dylib.
+#[cfg(android_dylib)]
+extern crate std;
+
+#[cfg(feature = "alloc")]
+extern crate alloc;
+#[cfg(feature = "std")]
+extern crate std;
+
+mod error;
+mod params;
+mod private_key;
+mod public_key;
+mod traits;
+mod version;
+
+pub use der::{
+    self,
+    asn1::{ObjectIdentifier, UintRef},
+};
+
+pub use crate::{
+    error::{Error, Result},
+    params::{RsaOaepParams, RsaPssParams, TrailerField},
+    private_key::RsaPrivateKey,
+    public_key::RsaPublicKey,
+    traits::{DecodeRsaPrivateKey, DecodeRsaPublicKey},
+    version::Version,
+};
+
+#[cfg(feature = "alloc")]
+pub use crate::{
+    private_key::{other_prime_info::OtherPrimeInfo, OtherPrimeInfos},
+    traits::{EncodeRsaPrivateKey, EncodeRsaPublicKey},
+};
+
+#[cfg(feature = "pem")]
+pub use der::pem::{self, LineEnding};
+
+/// `rsaEncryption` Object Identifier (OID)
+#[cfg(feature = "pkcs8")]
+pub const ALGORITHM_OID: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.2.840.113549.1.1.1");
+
+/// `AlgorithmIdentifier` for RSA.
+#[cfg(feature = "pkcs8")]
+pub const ALGORITHM_ID: pkcs8::AlgorithmIdentifierRef<'static> = pkcs8::AlgorithmIdentifierRef {
+    oid: ALGORITHM_OID,
+    parameters: Some(der::asn1::AnyRef::NULL),
+};
diff --git a/crates/pkcs1/src/params.rs b/crates/pkcs1/src/params.rs
new file mode 100644
index 0000000..74a1ee4
--- /dev/null
+++ b/crates/pkcs1/src/params.rs
@@ -0,0 +1,399 @@
+//! PKCS#1 RSA parameters.
+
+use crate::{Error, Result};
+use der::{
+    asn1::{AnyRef, ContextSpecificRef, ObjectIdentifier},
+    oid::AssociatedOid,
+    Decode, DecodeValue, Encode, EncodeValue, FixedTag, Length, Reader, Sequence, Tag, TagMode,
+    TagNumber, Writer,
+};
+use spki::{AlgorithmIdentifier, AlgorithmIdentifierRef};
+
+const OID_SHA_1: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.3.14.3.2.26");
+const OID_MGF_1: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.2.840.113549.1.1.8");
+const OID_PSPECIFIED: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.2.840.113549.1.1.9");
+
+const SHA_1_AI: AlgorithmIdentifierRef<'_> = AlgorithmIdentifierRef {
+    oid: OID_SHA_1,
+    parameters: Some(AnyRef::NULL),
+};
+
+/// `TrailerField` as defined in [RFC 8017 Appendix 2.3].
+/// ```text
+/// TrailerField ::= INTEGER { trailerFieldBC(1) }
+/// ```
+/// [RFC 8017 Appendix 2.3]: https://datatracker.ietf.org/doc/html/rfc8017#appendix-A.2.3
+#[derive(Clone, Debug, Copy, PartialEq, Eq)]
+#[repr(u8)]
+pub enum TrailerField {
+    /// the only supported value (0xbc, default)
+    BC = 1,
+}
+
+impl Default for TrailerField {
+    fn default() -> Self {
+        Self::BC
+    }
+}
+
+impl<'a> DecodeValue<'a> for TrailerField {
+    fn decode_value<R: Reader<'a>>(decoder: &mut R, header: der::Header) -> der::Result<Self> {
+        match u8::decode_value(decoder, header)? {
+            1 => Ok(TrailerField::BC),
+            _ => Err(Self::TAG.value_error()),
+        }
+    }
+}
+
+impl EncodeValue for TrailerField {
+    fn value_len(&self) -> der::Result<Length> {
+        Ok(Length::ONE)
+    }
+
+    fn encode_value(&self, writer: &mut impl Writer) -> der::Result<()> {
+        (*self as u8).encode_value(writer)
+    }
+}
+
+impl FixedTag for TrailerField {
+    const TAG: Tag = Tag::Integer;
+}
+
+/// PKCS#1 RSASSA-PSS parameters as defined in [RFC 8017 Appendix 2.3]
+///
+/// ASN.1 structure containing a serialized RSASSA-PSS parameters:
+/// ```text
+/// RSASSA-PSS-params ::= SEQUENCE {
+///     hashAlgorithm      [0] HashAlgorithm      DEFAULT sha1,
+///     maskGenAlgorithm   [1] MaskGenAlgorithm   DEFAULT mgf1SHA1,
+///     saltLength         [2] INTEGER            DEFAULT 20,
+///     trailerField       [3] TrailerField       DEFAULT trailerFieldBC
+/// }
+/// HashAlgorithm ::= AlgorithmIdentifier
+/// MaskGenAlgorithm ::= AlgorithmIdentifier
+/// ```
+///
+/// [RFC 8017 Appendix 2.3]: https://datatracker.ietf.org/doc/html/rfc8017#appendix-A.2.3
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct RsaPssParams<'a> {
+    /// Hash Algorithm
+    pub hash: AlgorithmIdentifierRef<'a>,
+
+    /// Mask Generation Function (MGF)
+    pub mask_gen: AlgorithmIdentifier<AlgorithmIdentifierRef<'a>>,
+
+    /// Salt length
+    pub salt_len: u8,
+
+    /// Trailer field (i.e. [`TrailerField::BC`])
+    pub trailer_field: TrailerField,
+}
+
+impl<'a> RsaPssParams<'a> {
+    /// Default RSA PSS Salt length in RsaPssParams
+    pub const SALT_LEN_DEFAULT: u8 = 20;
+
+    /// Create new RsaPssParams for the provided digest and salt len
+    pub fn new<D>(salt_len: u8) -> Self
+    where
+        D: AssociatedOid,
+    {
+        Self {
+            hash: AlgorithmIdentifierRef {
+                oid: D::OID,
+                parameters: Some(AnyRef::NULL),
+            },
+            mask_gen: AlgorithmIdentifier {
+                oid: OID_MGF_1,
+                parameters: Some(AlgorithmIdentifierRef {
+                    oid: D::OID,
+                    parameters: Some(AnyRef::NULL),
+                }),
+            },
+            salt_len,
+            trailer_field: Default::default(),
+        }
+    }
+
+    fn context_specific_hash(&self) -> Option<ContextSpecificRef<'_, AlgorithmIdentifierRef<'a>>> {
+        if self.hash == SHA_1_AI {
+            None
+        } else {
+            Some(ContextSpecificRef {
+                tag_number: TagNumber::N0,
+                tag_mode: TagMode::Explicit,
+                value: &self.hash,
+            })
+        }
+    }
+
+    fn context_specific_mask_gen(
+        &self,
+    ) -> Option<ContextSpecificRef<'_, AlgorithmIdentifier<AlgorithmIdentifierRef<'a>>>> {
+        if self.mask_gen == default_mgf1_sha1() {
+            None
+        } else {
+            Some(ContextSpecificRef {
+                tag_number: TagNumber::N1,
+                tag_mode: TagMode::Explicit,
+                value: &self.mask_gen,
+            })
+        }
+    }
+
+    fn context_specific_salt_len(&self) -> Option<ContextSpecificRef<'_, u8>> {
+        if self.salt_len == RsaPssParams::SALT_LEN_DEFAULT {
+            None
+        } else {
+            Some(ContextSpecificRef {
+                tag_number: TagNumber::N2,
+                tag_mode: TagMode::Explicit,
+                value: &self.salt_len,
+            })
+        }
+    }
+
+    fn context_specific_trailer_field(&self) -> Option<ContextSpecificRef<'_, TrailerField>> {
+        if self.trailer_field == TrailerField::default() {
+            None
+        } else {
+            Some(ContextSpecificRef {
+                tag_number: TagNumber::N3,
+                tag_mode: TagMode::Explicit,
+                value: &self.trailer_field,
+            })
+        }
+    }
+}
+
+impl<'a> Default for RsaPssParams<'a> {
+    fn default() -> Self {
+        Self {
+            hash: SHA_1_AI,
+            mask_gen: default_mgf1_sha1(),
+            salt_len: RsaPssParams::SALT_LEN_DEFAULT,
+            trailer_field: Default::default(),
+        }
+    }
+}
+
+impl<'a> DecodeValue<'a> for RsaPssParams<'a> {
+    fn decode_value<R: Reader<'a>>(reader: &mut R, header: der::Header) -> der::Result<Self> {
+        reader.read_nested(header.length, |reader| {
+            Ok(Self {
+                hash: reader
+                    .context_specific(TagNumber::N0, TagMode::Explicit)?
+                    .unwrap_or(SHA_1_AI),
+                mask_gen: reader
+                    .context_specific(TagNumber::N1, TagMode::Explicit)?
+                    .unwrap_or_else(default_mgf1_sha1),
+                salt_len: reader
+                    .context_specific(TagNumber::N2, TagMode::Explicit)?
+                    .unwrap_or(RsaPssParams::SALT_LEN_DEFAULT),
+                trailer_field: reader
+                    .context_specific(TagNumber::N3, TagMode::Explicit)?
+                    .unwrap_or_default(),
+            })
+        })
+    }
+}
+
+impl EncodeValue for RsaPssParams<'_> {
+    fn value_len(&self) -> der::Result<Length> {
+        self.context_specific_hash().encoded_len()?
+            + self.context_specific_mask_gen().encoded_len()?
+            + self.context_specific_salt_len().encoded_len()?
+            + self.context_specific_trailer_field().encoded_len()?
+    }
+
+    fn encode_value(&self, writer: &mut impl Writer) -> der::Result<()> {
+        self.context_specific_hash().encode(writer)?;
+        self.context_specific_mask_gen().encode(writer)?;
+        self.context_specific_salt_len().encode(writer)?;
+        self.context_specific_trailer_field().encode(writer)?;
+        Ok(())
+    }
+}
+
+impl<'a> Sequence<'a> for RsaPssParams<'a> {}
+
+impl<'a> TryFrom<&'a [u8]> for RsaPssParams<'a> {
+    type Error = Error;
+
+    fn try_from(bytes: &'a [u8]) -> Result<Self> {
+        Ok(Self::from_der(bytes)?)
+    }
+}
+
+/// Default Mask Generation Function (MGF): SHA-1.
+fn default_mgf1_sha1<'a>() -> AlgorithmIdentifier<AlgorithmIdentifierRef<'a>> {
+    AlgorithmIdentifier::<AlgorithmIdentifierRef<'a>> {
+        oid: OID_MGF_1,
+        parameters: Some(SHA_1_AI),
+    }
+}
+
+/// PKCS#1 RSAES-OAEP parameters as defined in [RFC 8017 Appendix 2.1]
+///
+/// ASN.1 structure containing a serialized RSAES-OAEP parameters:
+/// ```text
+/// RSAES-OAEP-params ::= SEQUENCE {
+///     hashAlgorithm      [0] HashAlgorithm     DEFAULT sha1,
+///     maskGenAlgorithm   [1] MaskGenAlgorithm  DEFAULT mgf1SHA1,
+///     pSourceAlgorithm   [2] PSourceAlgorithm  DEFAULT pSpecifiedEmpty
+/// }
+/// HashAlgorithm ::= AlgorithmIdentifier
+/// MaskGenAlgorithm ::= AlgorithmIdentifier
+/// PSourceAlgorithm ::= AlgorithmIdentifier
+/// ```
+///
+/// [RFC 8017 Appendix 2.1]: https://datatracker.ietf.org/doc/html/rfc8017#appendix-A.2.1
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct RsaOaepParams<'a> {
+    /// Hash Algorithm
+    pub hash: AlgorithmIdentifierRef<'a>,
+
+    /// Mask Generation Function (MGF)
+    pub mask_gen: AlgorithmIdentifier<AlgorithmIdentifierRef<'a>>,
+
+    /// The source (and possibly the value) of the label L
+    pub p_source: AlgorithmIdentifierRef<'a>,
+}
+
+impl<'a> RsaOaepParams<'a> {
+    /// Create new RsaPssParams for the provided digest and default (empty) label
+    pub fn new<D>() -> Self
+    where
+        D: AssociatedOid,
+    {
+        Self::new_with_label::<D>(&[])
+    }
+
+    /// Create new RsaPssParams for the provided digest and specified label
+    pub fn new_with_label<D>(label: &'a impl AsRef<[u8]>) -> Self
+    where
+        D: AssociatedOid,
+    {
+        Self {
+            hash: AlgorithmIdentifierRef {
+                oid: D::OID,
+                parameters: Some(AnyRef::NULL),
+            },
+            mask_gen: AlgorithmIdentifier {
+                oid: OID_MGF_1,
+                parameters: Some(AlgorithmIdentifierRef {
+                    oid: D::OID,
+                    parameters: Some(AnyRef::NULL),
+                }),
+            },
+            p_source: pspecicied_algorithm_identifier(label),
+        }
+    }
+
+    fn context_specific_hash(&self) -> Option<ContextSpecificRef<'_, AlgorithmIdentifierRef<'a>>> {
+        if self.hash == SHA_1_AI {
+            None
+        } else {
+            Some(ContextSpecificRef {
+                tag_number: TagNumber::N0,
+                tag_mode: TagMode::Explicit,
+                value: &self.hash,
+            })
+        }
+    }
+
+    fn context_specific_mask_gen(
+        &self,
+    ) -> Option<ContextSpecificRef<'_, AlgorithmIdentifier<AlgorithmIdentifierRef<'a>>>> {
+        if self.mask_gen == default_mgf1_sha1() {
+            None
+        } else {
+            Some(ContextSpecificRef {
+                tag_number: TagNumber::N1,
+                tag_mode: TagMode::Explicit,
+                value: &self.mask_gen,
+            })
+        }
+    }
+
+    fn context_specific_p_source(
+        &self,
+    ) -> Option<ContextSpecificRef<'_, AlgorithmIdentifierRef<'a>>> {
+        if self.p_source == default_pempty_string() {
+            None
+        } else {
+            Some(ContextSpecificRef {
+                tag_number: TagNumber::N2,
+                tag_mode: TagMode::Explicit,
+                value: &self.p_source,
+            })
+        }
+    }
+}
+
+impl<'a> Default for RsaOaepParams<'a> {
+    fn default() -> Self {
+        Self {
+            hash: SHA_1_AI,
+            mask_gen: default_mgf1_sha1(),
+            p_source: default_pempty_string(),
+        }
+    }
+}
+
+impl<'a> DecodeValue<'a> for RsaOaepParams<'a> {
+    fn decode_value<R: Reader<'a>>(reader: &mut R, header: der::Header) -> der::Result<Self> {
+        reader.read_nested(header.length, |reader| {
+            Ok(Self {
+                hash: reader
+                    .context_specific(TagNumber::N0, TagMode::Explicit)?
+                    .unwrap_or(SHA_1_AI),
+                mask_gen: reader
+                    .context_specific(TagNumber::N1, TagMode::Explicit)?
+                    .unwrap_or_else(default_mgf1_sha1),
+                p_source: reader
+                    .context_specific(TagNumber::N2, TagMode::Explicit)?
+                    .unwrap_or_else(default_pempty_string),
+            })
+        })
+    }
+}
+
+impl EncodeValue for RsaOaepParams<'_> {
+    fn value_len(&self) -> der::Result<Length> {
+        self.context_specific_hash().encoded_len()?
+            + self.context_specific_mask_gen().encoded_len()?
+            + self.context_specific_p_source().encoded_len()?
+    }
+
+    fn encode_value(&self, writer: &mut impl Writer) -> der::Result<()> {
+        self.context_specific_hash().encode(writer)?;
+        self.context_specific_mask_gen().encode(writer)?;
+        self.context_specific_p_source().encode(writer)?;
+        Ok(())
+    }
+}
+
+impl<'a> Sequence<'a> for RsaOaepParams<'a> {}
+
+impl<'a> TryFrom<&'a [u8]> for RsaOaepParams<'a> {
+    type Error = Error;
+
+    fn try_from(bytes: &'a [u8]) -> Result<Self> {
+        Ok(Self::from_der(bytes)?)
+    }
+}
+
+fn pspecicied_algorithm_identifier(label: &impl AsRef<[u8]>) -> AlgorithmIdentifierRef<'_> {
+    AlgorithmIdentifierRef {
+        oid: OID_PSPECIFIED,
+        parameters: Some(
+            AnyRef::new(Tag::OctetString, label.as_ref()).expect("error creating OAEP params"),
+        ),
+    }
+}
+
+/// Default Source Algorithm, empty string
+fn default_pempty_string<'a>() -> AlgorithmIdentifierRef<'a> {
+    pspecicied_algorithm_identifier(&[])
+}
diff --git a/crates/pkcs1/src/private_key.rs b/crates/pkcs1/src/private_key.rs
new file mode 100644
index 0000000..b913c47
--- /dev/null
+++ b/crates/pkcs1/src/private_key.rs
@@ -0,0 +1,247 @@
+//! PKCS#1 RSA Private Keys.
+
+#[cfg(feature = "alloc")]
+pub(crate) mod other_prime_info;
+
+use crate::{Error, Result, RsaPublicKey, Version};
+use core::fmt;
+use der::{
+    asn1::UintRef, Decode, DecodeValue, Encode, EncodeValue, Header, Length, Reader, Sequence, Tag,
+    Writer,
+};
+
+#[cfg(feature = "alloc")]
+use {self::other_prime_info::OtherPrimeInfo, alloc::vec::Vec, der::SecretDocument};
+
+#[cfg(feature = "pem")]
+use der::pem::PemLabel;
+
+/// PKCS#1 RSA Private Keys as defined in [RFC 8017 Appendix 1.2].
+///
+/// ASN.1 structure containing a serialized RSA private key:
+///
+/// ```text
+/// RSAPrivateKey ::= SEQUENCE {
+///     version           Version,
+///     modulus           INTEGER,  -- n
+///     publicExponent    INTEGER,  -- e
+///     privateExponent   INTEGER,  -- d
+///     prime1            INTEGER,  -- p
+///     prime2            INTEGER,  -- q
+///     exponent1         INTEGER,  -- d mod (p-1)
+///     exponent2         INTEGER,  -- d mod (q-1)
+///     coefficient       INTEGER,  -- (inverse of q) mod p
+///     otherPrimeInfos   OtherPrimeInfos OPTIONAL
+/// }
+/// ```
+///
+/// Note: the `version` field is selected automatically based on the absence or
+/// presence of the `other_prime_infos` field.
+///
+/// [RFC 8017 Appendix 1.2]: https://datatracker.ietf.org/doc/html/rfc8017#appendix-A.1.2
+#[derive(Clone)]
+pub struct RsaPrivateKey<'a> {
+    /// `n`: RSA modulus.
+    pub modulus: UintRef<'a>,
+
+    /// `e`: RSA public exponent.
+    pub public_exponent: UintRef<'a>,
+
+    /// `d`: RSA private exponent.
+    pub private_exponent: UintRef<'a>,
+
+    /// `p`: first prime factor of `n`.
+    pub prime1: UintRef<'a>,
+
+    /// `q`: Second prime factor of `n`.
+    pub prime2: UintRef<'a>,
+
+    /// First exponent: `d mod (p-1)`.
+    pub exponent1: UintRef<'a>,
+
+    /// Second exponent: `d mod (q-1)`.
+    pub exponent2: UintRef<'a>,
+
+    /// CRT coefficient: `(inverse of q) mod p`.
+    pub coefficient: UintRef<'a>,
+
+    /// Additional primes `r_3`, ..., `r_u`, in order, if this is a multi-prime
+    /// RSA key (i.e. `version` is `multi`).
+    pub other_prime_infos: Option<OtherPrimeInfos<'a>>,
+}
+
+impl<'a> RsaPrivateKey<'a> {
+    /// Get the public key that corresponds to this [`RsaPrivateKey`].
+    pub fn public_key(&self) -> RsaPublicKey<'a> {
+        RsaPublicKey {
+            modulus: self.modulus,
+            public_exponent: self.public_exponent,
+        }
+    }
+
+    /// Get the [`Version`] for this key.
+    ///
+    /// Determined by the presence or absence of the
+    /// [`RsaPrivateKey::other_prime_infos`] field.
+    pub fn version(&self) -> Version {
+        if self.other_prime_infos.is_some() {
+            Version::Multi
+        } else {
+            Version::TwoPrime
+        }
+    }
+}
+
+impl<'a> DecodeValue<'a> for RsaPrivateKey<'a> {
+    fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> der::Result<Self> {
+        reader.read_nested(header.length, |reader| {
+            let version = Version::decode(reader)?;
+
+            let result = Self {
+                modulus: reader.decode()?,
+                public_exponent: reader.decode()?,
+                private_exponent: reader.decode()?,
+                prime1: reader.decode()?,
+                prime2: reader.decode()?,
+                exponent1: reader.decode()?,
+                exponent2: reader.decode()?,
+                coefficient: reader.decode()?,
+                other_prime_infos: reader.decode()?,
+            };
+
+            // Ensure version is set correctly for two-prime vs multi-prime key.
+            if version.is_multi() != result.other_prime_infos.is_some() {
+                return Err(reader.error(der::ErrorKind::Value { tag: Tag::Integer }));
+            }
+
+            Ok(result)
+        })
+    }
+}
+
+impl EncodeValue for RsaPrivateKey<'_> {
+    fn value_len(&self) -> der::Result<Length> {
+        self.version().encoded_len()?
+            + self.modulus.encoded_len()?
+            + self.public_exponent.encoded_len()?
+            + self.private_exponent.encoded_len()?
+            + self.prime1.encoded_len()?
+            + self.prime2.encoded_len()?
+            + self.exponent1.encoded_len()?
+            + self.exponent2.encoded_len()?
+            + self.coefficient.encoded_len()?
+            + self.other_prime_infos.encoded_len()?
+    }
+
+    fn encode_value(&self, writer: &mut impl Writer) -> der::Result<()> {
+        self.version().encode(writer)?;
+        self.modulus.encode(writer)?;
+        self.public_exponent.encode(writer)?;
+        self.private_exponent.encode(writer)?;
+        self.prime1.encode(writer)?;
+        self.prime2.encode(writer)?;
+        self.exponent1.encode(writer)?;
+        self.exponent2.encode(writer)?;
+        self.coefficient.encode(writer)?;
+        self.other_prime_infos.encode(writer)?;
+        Ok(())
+    }
+}
+
+impl<'a> Sequence<'a> for RsaPrivateKey<'a> {}
+
+impl<'a> From<RsaPrivateKey<'a>> for RsaPublicKey<'a> {
+    fn from(private_key: RsaPrivateKey<'a>) -> RsaPublicKey<'a> {
+        private_key.public_key()
+    }
+}
+
+impl<'a> From<&RsaPrivateKey<'a>> for RsaPublicKey<'a> {
+    fn from(private_key: &RsaPrivateKey<'a>) -> RsaPublicKey<'a> {
+        private_key.public_key()
+    }
+}
+
+impl<'a> TryFrom<&'a [u8]> for RsaPrivateKey<'a> {
+    type Error = Error;
+
+    fn try_from(bytes: &'a [u8]) -> Result<Self> {
+        Ok(Self::from_der(bytes)?)
+    }
+}
+
+impl fmt::Debug for RsaPrivateKey<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("RsaPrivateKey")
+            .field("version", &self.version())
+            .field("modulus", &self.modulus)
+            .field("public_exponent", &self.public_exponent)
+            .finish_non_exhaustive()
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl TryFrom<RsaPrivateKey<'_>> for SecretDocument {
+    type Error = Error;
+
+    fn try_from(private_key: RsaPrivateKey<'_>) -> Result<SecretDocument> {
+        SecretDocument::try_from(&private_key)
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl TryFrom<&RsaPrivateKey<'_>> for SecretDocument {
+    type Error = Error;
+
+    fn try_from(private_key: &RsaPrivateKey<'_>) -> Result<SecretDocument> {
+        Ok(Self::encode_msg(private_key)?)
+    }
+}
+
+#[cfg(feature = "pem")]
+impl PemLabel for RsaPrivateKey<'_> {
+    const PEM_LABEL: &'static str = "RSA PRIVATE KEY";
+}
+
+/// Placeholder struct for `OtherPrimeInfos` in the no-`alloc` case.
+///
+/// This type is unconstructable by design, but supports the same traits.
+#[cfg(not(feature = "alloc"))]
+#[derive(Clone)]
+#[non_exhaustive]
+pub struct OtherPrimeInfos<'a> {
+    _lifetime: core::marker::PhantomData<&'a ()>,
+}
+
+#[cfg(not(feature = "alloc"))]
+impl<'a> DecodeValue<'a> for OtherPrimeInfos<'a> {
+    fn decode_value<R: Reader<'a>>(reader: &mut R, _header: Header) -> der::Result<Self> {
+        // Placeholder decoder that always returns an error.
+        // Uses `Tag::Integer` to signal an unsupported version.
+        Err(reader.error(der::ErrorKind::Value { tag: Tag::Integer }))
+    }
+}
+
+#[cfg(not(feature = "alloc"))]
+impl EncodeValue for OtherPrimeInfos<'_> {
+    fn value_len(&self) -> der::Result<Length> {
+        // Placeholder decoder that always returns an error.
+        // Uses `Tag::Integer` to signal an unsupported version.
+        Err(der::ErrorKind::Value { tag: Tag::Integer }.into())
+    }
+
+    fn encode_value(&self, _writer: &mut impl Writer) -> der::Result<()> {
+        // Placeholder decoder that always returns an error.
+        // Uses `Tag::Integer` to signal an unsupported version.
+        Err(der::ErrorKind::Value { tag: Tag::Integer }.into())
+    }
+}
+
+#[cfg(not(feature = "alloc"))]
+impl<'a> der::FixedTag for OtherPrimeInfos<'a> {
+    const TAG: Tag = Tag::Sequence;
+}
+
+/// Additional RSA prime info in a multi-prime RSA key.
+#[cfg(feature = "alloc")]
+pub type OtherPrimeInfos<'a> = Vec<OtherPrimeInfo<'a>>;
diff --git a/crates/pkcs1/src/private_key/other_prime_info.rs b/crates/pkcs1/src/private_key/other_prime_info.rs
new file mode 100644
index 0000000..35194a5
--- /dev/null
+++ b/crates/pkcs1/src/private_key/other_prime_info.rs
@@ -0,0 +1,57 @@
+//! PKCS#1 OtherPrimeInfo support.
+
+use der::{
+    asn1::UintRef, DecodeValue, Encode, EncodeValue, Header, Length, Reader, Sequence, Writer,
+};
+
+/// PKCS#1 OtherPrimeInfo as defined in [RFC 8017 Appendix 1.2].
+///
+/// ASN.1 structure containing an additional prime in a multi-prime RSA key.
+///
+/// ```text
+/// OtherPrimeInfo ::= SEQUENCE {
+///     prime             INTEGER,  -- ri
+///     exponent          INTEGER,  -- di
+///     coefficient       INTEGER   -- ti
+/// }
+/// ```
+///
+/// [RFC 8017 Appendix 1.2]: https://datatracker.ietf.org/doc/html/rfc8017#appendix-A.1.2
+#[derive(Clone)]
+pub struct OtherPrimeInfo<'a> {
+    /// Prime factor `r_i` of `n`, where `i` >= 3.
+    pub prime: UintRef<'a>,
+
+    /// Exponent: `d_i = d mod (r_i - 1)`.
+    pub exponent: UintRef<'a>,
+
+    /// CRT coefficient: `t_i = (r_1 * r_2 * ... * r_(i-1))^(-1) mod r_i`.
+    pub coefficient: UintRef<'a>,
+}
+
+impl<'a> DecodeValue<'a> for OtherPrimeInfo<'a> {
+    fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> der::Result<Self> {
+        reader.read_nested(header.length, |reader| {
+            Ok(Self {
+                prime: reader.decode()?,
+                exponent: reader.decode()?,
+                coefficient: reader.decode()?,
+            })
+        })
+    }
+}
+
+impl EncodeValue for OtherPrimeInfo<'_> {
+    fn value_len(&self) -> der::Result<Length> {
+        self.prime.encoded_len()? + self.exponent.encoded_len()? + self.coefficient.encoded_len()?
+    }
+
+    fn encode_value(&self, writer: &mut impl Writer) -> der::Result<()> {
+        self.prime.encode(writer)?;
+        self.exponent.encode(writer)?;
+        self.coefficient.encode(writer)?;
+        Ok(())
+    }
+}
+
+impl<'a> Sequence<'a> for OtherPrimeInfo<'a> {}
diff --git a/crates/pkcs1/src/public_key.rs b/crates/pkcs1/src/public_key.rs
new file mode 100644
index 0000000..3281744
--- /dev/null
+++ b/crates/pkcs1/src/public_key.rs
@@ -0,0 +1,90 @@
+//! PKCS#1 RSA Public Keys.
+
+use crate::{Error, Result};
+use der::{
+    asn1::UintRef, Decode, DecodeValue, Encode, EncodeValue, Header, Length, Reader, Sequence,
+    Writer,
+};
+
+#[cfg(feature = "alloc")]
+use der::Document;
+
+#[cfg(feature = "pem")]
+use der::pem::PemLabel;
+
+/// PKCS#1 RSA Public Keys as defined in [RFC 8017 Appendix 1.1].
+///
+/// ASN.1 structure containing a serialized RSA public key:
+///
+/// ```text
+/// RSAPublicKey ::= SEQUENCE {
+///     modulus           INTEGER,  -- n
+///     publicExponent    INTEGER   -- e
+/// }
+/// ```
+///
+/// [RFC 8017 Appendix 1.1]: https://datatracker.ietf.org/doc/html/rfc8017#appendix-A.1.1
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub struct RsaPublicKey<'a> {
+    /// `n`: RSA modulus
+    pub modulus: UintRef<'a>,
+
+    /// `e`: RSA public exponent
+    pub public_exponent: UintRef<'a>,
+}
+
+impl<'a> DecodeValue<'a> for RsaPublicKey<'a> {
+    fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> der::Result<Self> {
+        reader.read_nested(header.length, |reader| {
+            Ok(Self {
+                modulus: reader.decode()?,
+                public_exponent: reader.decode()?,
+            })
+        })
+    }
+}
+
+impl EncodeValue for RsaPublicKey<'_> {
+    fn value_len(&self) -> der::Result<Length> {
+        self.modulus.encoded_len()? + self.public_exponent.encoded_len()?
+    }
+
+    fn encode_value(&self, writer: &mut impl Writer) -> der::Result<()> {
+        self.modulus.encode(writer)?;
+        self.public_exponent.encode(writer)?;
+        Ok(())
+    }
+}
+
+impl<'a> Sequence<'a> for RsaPublicKey<'a> {}
+
+impl<'a> TryFrom<&'a [u8]> for RsaPublicKey<'a> {
+    type Error = Error;
+
+    fn try_from(bytes: &'a [u8]) -> Result<Self> {
+        Ok(Self::from_der(bytes)?)
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl TryFrom<RsaPublicKey<'_>> for Document {
+    type Error = Error;
+
+    fn try_from(spki: RsaPublicKey<'_>) -> Result<Document> {
+        Self::try_from(&spki)
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl TryFrom<&RsaPublicKey<'_>> for Document {
+    type Error = Error;
+
+    fn try_from(spki: &RsaPublicKey<'_>) -> Result<Document> {
+        Ok(Self::encode_msg(spki)?)
+    }
+}
+
+#[cfg(feature = "pem")]
+impl PemLabel for RsaPublicKey<'_> {
+    const PEM_LABEL: &'static str = "RSA PUBLIC KEY";
+}
diff --git a/crates/pkcs1/src/traits.rs b/crates/pkcs1/src/traits.rs
new file mode 100644
index 0000000..cd3d04e
--- /dev/null
+++ b/crates/pkcs1/src/traits.rs
@@ -0,0 +1,202 @@
+//! Traits for parsing objects from PKCS#1 encoded documents
+
+use crate::Result;
+
+#[cfg(feature = "alloc")]
+use der::{Document, SecretDocument};
+
+#[cfg(feature = "pem")]
+use {
+    crate::LineEnding,
+    alloc::string::String,
+    der::{pem::PemLabel, zeroize::Zeroizing},
+};
+
+#[cfg(feature = "pkcs8")]
+use {
+    crate::{ALGORITHM_ID, ALGORITHM_OID},
+    der::asn1::BitStringRef,
+};
+
+#[cfg(feature = "std")]
+use std::path::Path;
+
+#[cfg(all(feature = "alloc", feature = "pkcs8"))]
+use der::Decode;
+
+#[cfg(all(feature = "alloc", any(feature = "pem", feature = "pkcs8")))]
+use crate::{RsaPrivateKey, RsaPublicKey};
+
+/// Parse an [`RsaPrivateKey`] from a PKCS#1-encoded document.
+pub trait DecodeRsaPrivateKey: Sized {
+    /// Deserialize PKCS#1 private key from ASN.1 DER-encoded data
+    /// (binary format).
+    fn from_pkcs1_der(bytes: &[u8]) -> Result<Self>;
+
+    /// Deserialize PKCS#1-encoded private key from PEM.
+    ///
+    /// Keys in this format begin with the following:
+    ///
+    /// ```text
+    /// -----BEGIN RSA PRIVATE KEY-----
+    /// ```
+    #[cfg(feature = "pem")]
+    fn from_pkcs1_pem(s: &str) -> Result<Self> {
+        let (label, doc) = SecretDocument::from_pem(s)?;
+        RsaPrivateKey::validate_pem_label(label)?;
+        Self::from_pkcs1_der(doc.as_bytes())
+    }
+
+    /// Load PKCS#1 private key from an ASN.1 DER-encoded file on the local
+    /// filesystem (binary format).
+    #[cfg(feature = "std")]
+    fn read_pkcs1_der_file(path: impl AsRef<Path>) -> Result<Self> {
+        Self::from_pkcs1_der(SecretDocument::read_der_file(path)?.as_bytes())
+    }
+
+    /// Load PKCS#1 private key from a PEM-encoded file on the local filesystem.
+    #[cfg(all(feature = "pem", feature = "std"))]
+    fn read_pkcs1_pem_file(path: impl AsRef<Path>) -> Result<Self> {
+        let (label, doc) = SecretDocument::read_pem_file(path)?;
+        RsaPrivateKey::validate_pem_label(&label)?;
+        Self::from_pkcs1_der(doc.as_bytes())
+    }
+}
+
+/// Parse a [`RsaPublicKey`] from a PKCS#1-encoded document.
+pub trait DecodeRsaPublicKey: Sized {
+    /// Deserialize object from ASN.1 DER-encoded [`RsaPublicKey`]
+    /// (binary format).
+    fn from_pkcs1_der(bytes: &[u8]) -> Result<Self>;
+
+    /// Deserialize PEM-encoded [`RsaPublicKey`].
+    ///
+    /// Keys in this format begin with the following:
+    ///
+    /// ```text
+    /// -----BEGIN RSA PUBLIC KEY-----
+    /// ```
+    #[cfg(feature = "pem")]
+    fn from_pkcs1_pem(s: &str) -> Result<Self> {
+        let (label, doc) = Document::from_pem(s)?;
+        RsaPublicKey::validate_pem_label(label)?;
+        Self::from_pkcs1_der(doc.as_bytes())
+    }
+
+    /// Load [`RsaPublicKey`] from an ASN.1 DER-encoded file on the local
+    /// filesystem (binary format).
+    #[cfg(feature = "std")]
+    fn read_pkcs1_der_file(path: impl AsRef<Path>) -> Result<Self> {
+        let doc = Document::read_der_file(path)?;
+        Self::from_pkcs1_der(doc.as_bytes())
+    }
+
+    /// Load [`RsaPublicKey`] from a PEM-encoded file on the local filesystem.
+    #[cfg(all(feature = "pem", feature = "std"))]
+    fn read_pkcs1_pem_file(path: impl AsRef<Path>) -> Result<Self> {
+        let (label, doc) = Document::read_pem_file(path)?;
+        RsaPublicKey::validate_pem_label(&label)?;
+        Self::from_pkcs1_der(doc.as_bytes())
+    }
+}
+
+/// Serialize a [`RsaPrivateKey`] to a PKCS#1 encoded document.
+#[cfg(feature = "alloc")]
+pub trait EncodeRsaPrivateKey {
+    /// Serialize a [`SecretDocument`] containing a PKCS#1-encoded private key.
+    fn to_pkcs1_der(&self) -> Result<SecretDocument>;
+
+    /// Serialize this private key as PEM-encoded PKCS#1 with the given [`LineEnding`].
+    #[cfg(feature = "pem")]
+    fn to_pkcs1_pem(&self, line_ending: LineEnding) -> Result<Zeroizing<String>> {
+        let doc = self.to_pkcs1_der()?;
+        Ok(doc.to_pem(RsaPrivateKey::PEM_LABEL, line_ending)?)
+    }
+
+    /// Write ASN.1 DER-encoded PKCS#1 private key to the given path.
+    #[cfg(feature = "std")]
+    fn write_pkcs1_der_file(&self, path: impl AsRef<Path>) -> Result<()> {
+        Ok(self.to_pkcs1_der()?.write_der_file(path)?)
+    }
+
+    /// Write ASN.1 DER-encoded PKCS#1 private key to the given path.
+    #[cfg(all(feature = "pem", feature = "std"))]
+    fn write_pkcs1_pem_file(&self, path: impl AsRef<Path>, line_ending: LineEnding) -> Result<()> {
+        let doc = self.to_pkcs1_der()?;
+        Ok(doc.write_pem_file(path, RsaPrivateKey::PEM_LABEL, line_ending)?)
+    }
+}
+
+/// Serialize a [`RsaPublicKey`] to a PKCS#1-encoded document.
+#[cfg(feature = "alloc")]
+pub trait EncodeRsaPublicKey {
+    /// Serialize a [`Document`] containing a PKCS#1-encoded public key.
+    fn to_pkcs1_der(&self) -> Result<Document>;
+
+    /// Serialize this public key as PEM-encoded PKCS#1 with the given line ending.
+    #[cfg(feature = "pem")]
+    fn to_pkcs1_pem(&self, line_ending: LineEnding) -> Result<String> {
+        let doc = self.to_pkcs1_der()?;
+        Ok(doc.to_pem(RsaPublicKey::PEM_LABEL, line_ending)?)
+    }
+
+    /// Write ASN.1 DER-encoded public key to the given path.
+    #[cfg(feature = "std")]
+    fn write_pkcs1_der_file(&self, path: impl AsRef<Path>) -> Result<()> {
+        Ok(self.to_pkcs1_der()?.write_der_file(path)?)
+    }
+
+    /// Write ASN.1 DER-encoded public key to the given path.
+    #[cfg(all(feature = "pem", feature = "std"))]
+    fn write_pkcs1_pem_file(&self, path: impl AsRef<Path>, line_ending: LineEnding) -> Result<()> {
+        let doc = self.to_pkcs1_der()?;
+        Ok(doc.write_pem_file(path, RsaPublicKey::PEM_LABEL, line_ending)?)
+    }
+}
+
+#[cfg(feature = "pkcs8")]
+impl<T> DecodeRsaPrivateKey for T
+where
+    T: for<'a> TryFrom<pkcs8::PrivateKeyInfo<'a>, Error = pkcs8::Error>,
+{
+    fn from_pkcs1_der(private_key: &[u8]) -> Result<Self> {
+        Ok(Self::try_from(pkcs8::PrivateKeyInfo {
+            algorithm: ALGORITHM_ID,
+            private_key,
+            public_key: None,
+        })?)
+    }
+}
+
+#[cfg(feature = "pkcs8")]
+impl<T> DecodeRsaPublicKey for T
+where
+    T: for<'a> TryFrom<pkcs8::SubjectPublicKeyInfoRef<'a>, Error = pkcs8::spki::Error>,
+{
+    fn from_pkcs1_der(public_key: &[u8]) -> Result<Self> {
+        Ok(Self::try_from(pkcs8::SubjectPublicKeyInfoRef {
+            algorithm: ALGORITHM_ID,
+            subject_public_key: BitStringRef::from_bytes(public_key)?,
+        })?)
+    }
+}
+
+#[cfg(all(feature = "alloc", feature = "pkcs8"))]
+impl<T: pkcs8::EncodePrivateKey> EncodeRsaPrivateKey for T {
+    fn to_pkcs1_der(&self) -> Result<SecretDocument> {
+        let pkcs8_doc = self.to_pkcs8_der()?;
+        let pkcs8_key = pkcs8::PrivateKeyInfo::from_der(pkcs8_doc.as_bytes())?;
+        pkcs8_key.algorithm.assert_algorithm_oid(ALGORITHM_OID)?;
+        RsaPrivateKey::from_der(pkcs8_key.private_key)?.try_into()
+    }
+}
+
+#[cfg(all(feature = "alloc", feature = "pkcs8"))]
+impl<T: pkcs8::EncodePublicKey> EncodeRsaPublicKey for T {
+    fn to_pkcs1_der(&self) -> Result<Document> {
+        let doc = self.to_public_key_der()?;
+        let spki = pkcs8::SubjectPublicKeyInfoRef::from_der(doc.as_bytes())?;
+        spki.algorithm.assert_algorithm_oid(ALGORITHM_OID)?;
+        RsaPublicKey::from_der(spki.subject_public_key.raw_bytes())?.try_into()
+    }
+}
diff --git a/crates/pkcs1/src/version.rs b/crates/pkcs1/src/version.rs
new file mode 100644
index 0000000..2fdb198
--- /dev/null
+++ b/crates/pkcs1/src/version.rs
@@ -0,0 +1,72 @@
+//! PKCS#1 version identifier.
+
+use crate::Error;
+use der::{Decode, Encode, FixedTag, Reader, Tag, Writer};
+
+/// Version identifier for PKCS#1 documents as defined in
+/// [RFC 8017 Appendix 1.2].
+///
+/// > version is the version number, for compatibility with future
+/// > revisions of this document.  It SHALL be 0 for this version of the
+/// > document, unless multi-prime is used; in which case, it SHALL be 1.
+///
+/// ```text
+/// Version ::= INTEGER { two-prime(0), multi(1) }
+///    (CONSTRAINED BY
+///    {-- version must be multi if otherPrimeInfos present --})
+/// ```
+///
+/// [RFC 8017 Appendix 1.2]: https://datatracker.ietf.org/doc/html/rfc8017#appendix-A.1.2
+#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
+#[repr(u8)]
+pub enum Version {
+    /// Denotes a `two-prime` key
+    TwoPrime = 0,
+
+    /// Denotes a `multi` (i.e. multi-prime) key
+    Multi = 1,
+}
+
+impl Version {
+    /// Is this a multi-prime RSA key?
+    pub fn is_multi(self) -> bool {
+        self == Self::Multi
+    }
+}
+
+impl From<Version> for u8 {
+    fn from(version: Version) -> Self {
+        version as u8
+    }
+}
+
+impl TryFrom<u8> for Version {
+    type Error = Error;
+    fn try_from(byte: u8) -> Result<Version, Error> {
+        match byte {
+            0 => Ok(Version::TwoPrime),
+            1 => Ok(Version::Multi),
+            _ => Err(Error::Version),
+        }
+    }
+}
+
+impl<'a> Decode<'a> for Version {
+    fn decode<R: Reader<'a>>(decoder: &mut R) -> der::Result<Self> {
+        Version::try_from(u8::decode(decoder)?).map_err(|_| Self::TAG.value_error())
+    }
+}
+
+impl Encode for Version {
+    fn encoded_len(&self) -> der::Result<der::Length> {
+        der::Length::ONE.for_tlv()
+    }
+
+    fn encode(&self, writer: &mut impl Writer) -> der::Result<()> {
+        u8::from(*self).encode(writer)
+    }
+}
+
+impl FixedTag for Version {
+    const TAG: Tag = Tag::Integer;
+}
diff --git a/crates/pkcs1/tests/examples/rsa2048-priv-3prime.der b/crates/pkcs1/tests/examples/rsa2048-priv-3prime.der
new file mode 100644
index 0000000..eaff675
--- /dev/null
+++ b/crates/pkcs1/tests/examples/rsa2048-priv-3prime.der
Binary files differ
diff --git a/crates/pkcs1/tests/examples/rsa2048-priv-3prime.pem b/crates/pkcs1/tests/examples/rsa2048-priv-3prime.pem
new file mode 100644
index 0000000..4a932b7
--- /dev/null
+++ b/crates/pkcs1/tests/examples/rsa2048-priv-3prime.pem
@@ -0,0 +1,28 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIE2AIBAQKCAQEA6L9GSA2RROk9DnlxVU9+9F+yW4OhBpQW247HxlTrSJxpWjJ0
+7ktfOgjjW6bR/y7Eh85URkHqDAmUzFVNIgEwjjrGSRMmGD9HfTDxZQAYALOHcb+W
+9p3m1GGm4viAVxBPzdbGobaef5WifawMuuOcwfkmTAnf7qaEd0gsKBYTMBK6KaDW
+F/psa3D6w77csCDLH26jN1FjmI5/jJR0tUYsJNK1a8A/ntAC5Dx2Sx57BcMex9jp
+FYLOwJQvOW2rlPMWLRqqBB2pnO6QuB/0CLt1t7IzsZ005QTiWMHXdHBuTF/CsR+X
+yeTO6sNF+MV8PTcC9z/Jj37taIgSvptWBhjCRQIDAQABAoIBAFGtpmVs1XkgfPvS
+ZJJytnPeDYKOG/lqCOd+IN+aN4Og2Fv97wkdTEraiadFUNbDu9aI8wxA33jf9+cJ
+XGs9jaOsPp+wZ6MEufrWLTCrqsC8QCEMAldZo3QDSGQwivbkRMa+6k/qEtt4qXBa
+DwyLcys/1zPFh3qHHsxY+rJdQjbQyR8gfW/HntVWhlhiOYTvmSyF6nv/x/jBg2jm
+RCiRmLZM82jA/e/6fiS2XYlbcB+K9wrqsLt9LhTENU4Vvkcj7Ihd8UbXsMbShEwU
+32Od2px5M//71a4jCLKpzn5sUuN2YQa4/vjVk7iEkbztaGMgReDi+4iaWO0v8otu
+XiCCuwECVgfqQeOwtvpjN9jSVLIfBsI3/apkQrOydWpHmycnPOzPu19HKqXZQeEd
+oarrF2RQ/AROpjnvbmt3tTDZikOs8tOVcXFO7VFrv0OnB55kDKRq5kDMrka1AlYH
+fpIQOZRT8fnWrYYrTYPuhlH5I1S8TyKxpTdu02/oDc/d9zzusyaXImW1ysIeL1/y
+Lwnm6grzWFQABNbR7zqCviFNIGsl+Y8PO6+M1PJdcWmsyZgJqQJWAjYimMJ8LXNh
+XDRQM8BVfBh2yI/gzyJyifJd2E+vRx83ZASXVuVf8cz8qaurynySHYX4DcHnISG+
+P1rYtdXxtspPevApgJFRTE6z4z5jBeFUWhCWNO0CVgCDD/1VwaE+bX/R2NGKeRHJ
+UT5AwKAgk9Eo5TGH9iQXFXUnV51C1ccLTYFuuXYQbHCB8B47LMZU6WAa9IXg3tFh
+paq8JTWx56j1vddUEL57aemo198JAlYDtUxSGZYE2akgsberlfC0dLpGeWzEbD5j
+xINJkHG/rcDScyHr1T4JJx8oZGt1kMlxAvnkWKk7OgJKA1Zbyv+hX3PAW7+WU74j
+IkoeNVJKmJVkHHb9LjCCAQswggEHAlYD7HVTL7DSyhQmMmGOpphUjYSJ/jCoaNY3
+odU4lcefFqY622DbIX3cDZVpSj2V0CnRqaLfVI7RBbLGqEhVc57bw86CkGUAJB1R
+ijFy+NRw+t1OHf5ZaQJWA6EVCKPlL6RBLO+O806/Of5IaQdYZH3MH1suiQ9pvIpL
+qcc/eJErBH8AA4rrGgaYl9kL0P06uLZHnZ8MgRXYC7i67GO5OH8vKzvi71Cf1/0C
+9H2jxXkCVTnqImyr+zF+QaVZO5Fo0aASSZO0XZzRSiK9FVfNy0PSgCSsJu0shTC1
+PpuTqHj0KIB8UoLruBE5n5EwF83yFJAT2Azfc/YJ1saSR163oSPQ6T5qYPw=
+-----END RSA PRIVATE KEY-----
diff --git a/crates/pkcs1/tests/examples/rsa2048-priv.der b/crates/pkcs1/tests/examples/rsa2048-priv.der
new file mode 100644
index 0000000..bbf1876
--- /dev/null
+++ b/crates/pkcs1/tests/examples/rsa2048-priv.der
Binary files differ
diff --git a/crates/pkcs1/tests/examples/rsa2048-priv.pem b/crates/pkcs1/tests/examples/rsa2048-priv.pem
new file mode 100644
index 0000000..3b924f5
--- /dev/null
+++ b/crates/pkcs1/tests/examples/rsa2048-priv.pem
@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEowIBAAKCAQEAtsQsUV8QpqrygsY+2+JCQ6Fw8/omM71IM2N/R8pPbzbgOl0p
+78MZGsgPOQ2HSznjD0FPzsH8oO2B5Uftws04LHb2HJAYlz25+lN5cqfHAfa3fgmC
+38FfwBkn7l582UtPWZ/wcBOnyCgb3yLcvJrXyrt8QxHJgvWO23ITrUVYszImbXQ6
+7YGS0YhMrbixRzmo2tpm3JcIBtnHrEUMsT0NfFdfsZhTT8YbxBvA8FdODgEwx7u/
+vf3J9qbi4+Kv8cvqyJuleIRSjVXPsIMnoejIn04APPKIjpMyQdnWlby7rNyQtE4+
+CV+jcFjqJbE/Xilcvqxt6DirjFCvYeKYl1uHLwIDAQABAoIBAH7Mg2LA7bB0EWQh
+XiL3SrnZG6BpAHAM9jaQ5RFNjua9z7suP5YUaSpnegg/FopeUuWWjmQHudl8bg5A
+ZPgtoLdYoU8XubfUH19I4o1lUXBPVuaeeqn6Yw/HZCjAbSXkVdz8VbesK092ZD/e
+0/4V/3irsn5lrMSq0L322yfvYKaRDFxKCF7UMnWrGcHZl6Msbv/OffLRk19uYB7t
+4WGhK1zCfKIfgdLJnD0eoI6Q4wU6sJvvpyTe8NDDo8HpdAwNn3YSahSewKp9gHgg
+VIQlTZUdsHxM+R+2RUwJZYj9WSTbq+s1nKICUmjQBPnWbrPW963BE5utQPFt3mOe
+EWRzdsECgYEA3MBhJC1Okq+u5yrFE8plufdwNvm9fg5uYUYafvdlQiXsFTx+XDGm
+FXpuWhP/bheOh1jByzPZ1rvjF57xiZjkIuzcvtePTs/b5fT82K7CydDchkc8qb0W
+2dI40h+13e++sUPKYdC9aqjZHzOgl3kOlkDbyRCF3F8mNDujE49rLWcCgYEA0/MU
+dX5A6VSDb5K+JCNq8vDaBKNGU8GAr2fpYAhtk/3mXLI+/Z0JN0di9ZgeNhhJr2jN
+11OU/2pOButpsgnkIo2y36cOQPf5dQpSgXZke3iNDld3osuLIuPNJn/3C087AtOq
++w4YxZClZLAxiLCqX8SBVrB2IiFCQ70SJ++n8vkCgYEAzmi3rBsNEA1jblVIh1PF
+wJhD/bOQ4nBd92iUV8m9jZdl4wl4YX4u/IBI9MMkIG24YIe2VOl7s9Rk5+4/jNg/
+4QQ2998Y6aljxOZJEdZ+3jQELy4m49OhrTRq2ta5t/Z3CMsJTmLe6f9NXWZpr5iK
+8iVdHOjtMXxqfYaR2jVNEtsCgYAl9uWUQiAoa037v0I1wO5YQ9IZgJGJUSDWynsg
+C4JtPs5zji4ASY+sCipsqWnH8MPKGrC8QClxMr51ONe+30yw78a5jvfbpU9Wqpmq
+vOU0xJwnlH1GeMUcY8eMfOFocjG0yOtYeubvBIDLr0/AFzz9WHp+Z69RX7m53nUR
+GDlyKQKBgDGZVAbUBiB8rerqNbONBAxfipoa4IJ+ntBrFT2DtoIZNbSzaoK+nVbH
+kbWMJycaV5PVOh1lfAiZeWCxQz5RcZh/RS8USnxyMG1j4dP/wLcbdasI8uRaSC6Y
+hFHL5HjhLrIo0HRWySS2b2ztBI2FP1M+MaaGFPHDzm2OyZg85yr3
+-----END RSA PRIVATE KEY-----
diff --git a/crates/pkcs1/tests/examples/rsa2048-pub.der b/crates/pkcs1/tests/examples/rsa2048-pub.der
new file mode 100644
index 0000000..e75261c
--- /dev/null
+++ b/crates/pkcs1/tests/examples/rsa2048-pub.der
Binary files differ
diff --git a/crates/pkcs1/tests/examples/rsa2048-pub.pem b/crates/pkcs1/tests/examples/rsa2048-pub.pem
new file mode 100644
index 0000000..f2f72d7
--- /dev/null
+++ b/crates/pkcs1/tests/examples/rsa2048-pub.pem
@@ -0,0 +1,8 @@
+-----BEGIN RSA PUBLIC KEY-----
+MIIBCgKCAQEAtsQsUV8QpqrygsY+2+JCQ6Fw8/omM71IM2N/R8pPbzbgOl0p78MZ
+GsgPOQ2HSznjD0FPzsH8oO2B5Uftws04LHb2HJAYlz25+lN5cqfHAfa3fgmC38Ff
+wBkn7l582UtPWZ/wcBOnyCgb3yLcvJrXyrt8QxHJgvWO23ITrUVYszImbXQ67YGS
+0YhMrbixRzmo2tpm3JcIBtnHrEUMsT0NfFdfsZhTT8YbxBvA8FdODgEwx7u/vf3J
+9qbi4+Kv8cvqyJuleIRSjVXPsIMnoejIn04APPKIjpMyQdnWlby7rNyQtE4+CV+j
+cFjqJbE/Xilcvqxt6DirjFCvYeKYl1uHLwIDAQAB
+-----END RSA PUBLIC KEY-----
diff --git a/crates/pkcs1/tests/examples/rsa4096-priv.der b/crates/pkcs1/tests/examples/rsa4096-priv.der
new file mode 100644
index 0000000..b154e59
--- /dev/null
+++ b/crates/pkcs1/tests/examples/rsa4096-priv.der
Binary files differ
diff --git a/crates/pkcs1/tests/examples/rsa4096-priv.pem b/crates/pkcs1/tests/examples/rsa4096-priv.pem
new file mode 100644
index 0000000..9156bf0
--- /dev/null
+++ b/crates/pkcs1/tests/examples/rsa4096-priv.pem
@@ -0,0 +1,51 @@
+-----BEGIN RSA PRIVATE KEY-----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-----END RSA PRIVATE KEY-----
diff --git a/crates/pkcs1/tests/examples/rsa4096-pub.der b/crates/pkcs1/tests/examples/rsa4096-pub.der
new file mode 100644
index 0000000..d8b7c7d
--- /dev/null
+++ b/crates/pkcs1/tests/examples/rsa4096-pub.der
Binary files differ
diff --git a/crates/pkcs1/tests/examples/rsa4096-pub.pem b/crates/pkcs1/tests/examples/rsa4096-pub.pem
new file mode 100644
index 0000000..d60e8eb
--- /dev/null
+++ b/crates/pkcs1/tests/examples/rsa4096-pub.pem
@@ -0,0 +1,13 @@
+-----BEGIN RSA PUBLIC KEY-----
+MIICCgKCAgEAp6dFcoEeomF+Sehb1zDd4w8QP32I7j92XlQNPdmTu7C6FAAChZ0L
+QIl0NmN/WLgo6nTfgyFjQHf5nUqi1UyjdYUu9ZdmHTcTzh7ztP1qjiICOORnZoos
+fuOGHSISrmoevd+oi2LfEPa8957/SsKY+yVj3xuHZDga+bH7DM0IXgJrCtn2choj
+UXfQOWtIdUrUp1JCJQqHO/L25+48dd1hPjZbpPMhCmzGa5Ci+j92LKaIQIe2v4Fh
+6xRIGfD1cvIfbI4nPnDUWjZbiygZznNGE8wjsBMpoXkB8XB4QDhh9UxSoFHipYx1
+wtnYAJG7mAihBsH37LQDThUFi+7HJcX5GdYuqiNLYmKNNGxgu5GecIUdqzhXHm8O
+12NBKfmU6jaP7nNz397AREXrykf6IO0VQKhgyUi6vJjaWRyh3i4uJVQO+bfLNT9g
+ITuBSkXTWe+puBHu/wjGWZO/ioXCv+qqftXmtD4YrmBEZM5flhUBNufQn4sk+tQ9
+eHARjPp7wkh1UG67wyG5d+CGGupQEoYgEh8LOUqc3QpCQRoTUMB3DZddcbAKkENi
+QMlnoMOlwgoPbed/Pyyv2pTtAUPB9uNPc+DKwnnu63xjdyOisCbIKALhpK66qIRt
++Y55GUmHc+DU8xmVb03jqtAO+5oUfWazrBoB01ss+0jUALDnqA3JdVECAwEAAQ==
+-----END RSA PUBLIC KEY-----
diff --git a/crates/pkcs1/tests/params.rs b/crates/pkcs1/tests/params.rs
new file mode 100644
index 0000000..d47fbb5
--- /dev/null
+++ b/crates/pkcs1/tests/params.rs
@@ -0,0 +1,223 @@
+//! PKCS#1 algorithm params tests
+
+use const_oid::db;
+use der::{
+    asn1::{AnyRef, ObjectIdentifier, OctetStringRef},
+    oid::AssociatedOid,
+    Encode,
+};
+use hex_literal::hex;
+use pkcs1::{RsaOaepParams, RsaPssParams, TrailerField};
+
+/// Default PSS parameters using all default values (SHA1, MGF1)
+const RSA_PSS_PARAMETERS_DEFAULTS: &[u8] = &hex!("3000");
+/// Example PSS parameters using SHA256 instead of SHA1
+const RSA_PSS_PARAMETERS_SHA2_256: &[u8] = &hex!("3034a00f300d06096086480165030402010500a11c301a06092a864886f70d010108300d06096086480165030402010500a203020120");
+
+/// Default OAEP parameters using all default values (SHA1, MGF1, Empty)
+const RSA_OAEP_PARAMETERS_DEFAULTS: &[u8] = &hex!("3000");
+/// Example OAEP parameters using SHA256 instead of SHA1
+const RSA_OAEP_PARAMETERS_SHA2_256: &[u8] = &hex!("302fa00f300d06096086480165030402010500a11c301a06092a864886f70d010108300d06096086480165030402010500");
+
+struct Sha1Mock {}
+impl AssociatedOid for Sha1Mock {
+    const OID: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.3.14.3.2.26");
+}
+
+struct Sha256Mock {}
+impl AssociatedOid for Sha256Mock {
+    const OID: ObjectIdentifier = ObjectIdentifier::new_unwrap("2.16.840.1.101.3.4.2.1");
+}
+
+#[test]
+fn decode_pss_param() {
+    let param = RsaPssParams::try_from(RSA_PSS_PARAMETERS_SHA2_256).unwrap();
+
+    assert!(param
+        .hash
+        .assert_algorithm_oid(db::rfc5912::ID_SHA_256)
+        .is_ok());
+    assert_eq!(param.hash.parameters, Some(AnyRef::NULL));
+    assert!(param
+        .mask_gen
+        .assert_algorithm_oid(db::rfc5912::ID_MGF_1)
+        .is_ok());
+    assert!(param
+        .mask_gen
+        .parameters
+        .unwrap()
+        .assert_algorithm_oid(db::rfc5912::ID_SHA_256)
+        .is_ok());
+    assert_eq!(param.salt_len, 32);
+    assert_eq!(param.trailer_field, TrailerField::BC);
+}
+
+#[test]
+fn encode_pss_param() {
+    let mut buf = [0_u8; 256];
+    let param = RsaPssParams::try_from(RSA_PSS_PARAMETERS_SHA2_256).unwrap();
+    assert_eq!(
+        param.encode_to_slice(&mut buf).unwrap(),
+        RSA_PSS_PARAMETERS_SHA2_256
+    );
+}
+
+#[test]
+fn decode_pss_param_default() {
+    let param = RsaPssParams::try_from(RSA_PSS_PARAMETERS_DEFAULTS).unwrap();
+
+    assert!(param
+        .hash
+        .assert_algorithm_oid(db::rfc5912::ID_SHA_1)
+        .is_ok());
+    assert_eq!(param.hash.parameters, Some(AnyRef::NULL));
+    assert!(param
+        .mask_gen
+        .assert_algorithm_oid(db::rfc5912::ID_MGF_1)
+        .is_ok());
+    assert!(param
+        .mask_gen
+        .parameters
+        .unwrap()
+        .assert_algorithm_oid(db::rfc5912::ID_SHA_1)
+        .is_ok());
+    assert_eq!(
+        param.mask_gen.parameters.unwrap().parameters,
+        Some(AnyRef::NULL)
+    );
+    assert_eq!(param.salt_len, 20);
+    assert_eq!(param.trailer_field, TrailerField::BC);
+    assert_eq!(param, Default::default())
+}
+
+#[test]
+fn encode_pss_param_default() {
+    let mut buf = [0_u8; 256];
+    assert_eq!(
+        RsaPssParams::default().encode_to_slice(&mut buf).unwrap(),
+        RSA_PSS_PARAMETERS_DEFAULTS
+    );
+}
+
+#[test]
+fn new_pss_param() {
+    let mut buf = [0_u8; 256];
+
+    let param = RsaPssParams::new::<Sha1Mock>(20);
+    assert_eq!(
+        param.encode_to_slice(&mut buf).unwrap(),
+        RSA_PSS_PARAMETERS_DEFAULTS
+    );
+
+    let param = RsaPssParams::new::<Sha256Mock>(32);
+    assert_eq!(
+        param.encode_to_slice(&mut buf).unwrap(),
+        RSA_PSS_PARAMETERS_SHA2_256
+    );
+}
+
+#[test]
+fn decode_oaep_param() {
+    let param = RsaOaepParams::try_from(RSA_OAEP_PARAMETERS_SHA2_256).unwrap();
+
+    assert!(param
+        .hash
+        .assert_algorithm_oid(db::rfc5912::ID_SHA_256)
+        .is_ok());
+    assert_eq!(param.hash.parameters, Some(AnyRef::NULL));
+    assert!(param
+        .mask_gen
+        .assert_algorithm_oid(db::rfc5912::ID_MGF_1)
+        .is_ok());
+    assert!(param
+        .mask_gen
+        .parameters
+        .unwrap()
+        .assert_algorithm_oid(db::rfc5912::ID_SHA_256)
+        .is_ok());
+    assert!(param
+        .p_source
+        .assert_algorithm_oid(db::rfc5912::ID_P_SPECIFIED)
+        .is_ok());
+    assert!(param
+        .p_source
+        .parameters_any()
+        .unwrap()
+        .decode_as::<OctetStringRef<'_>>()
+        .unwrap()
+        .is_empty(),);
+}
+
+#[test]
+fn encode_oaep_param() {
+    let mut buf = [0_u8; 256];
+    let param = RsaOaepParams::try_from(RSA_OAEP_PARAMETERS_SHA2_256).unwrap();
+    assert_eq!(
+        param.encode_to_slice(&mut buf).unwrap(),
+        RSA_OAEP_PARAMETERS_SHA2_256
+    );
+}
+
+#[test]
+fn decode_oaep_param_default() {
+    let param = RsaOaepParams::try_from(RSA_OAEP_PARAMETERS_DEFAULTS).unwrap();
+
+    assert!(param
+        .hash
+        .assert_algorithm_oid(db::rfc5912::ID_SHA_1)
+        .is_ok());
+    assert_eq!(param.hash.parameters, Some(AnyRef::NULL));
+    assert!(param
+        .mask_gen
+        .assert_algorithm_oid(db::rfc5912::ID_MGF_1)
+        .is_ok());
+    assert!(param
+        .mask_gen
+        .parameters
+        .unwrap()
+        .assert_algorithm_oid(db::rfc5912::ID_SHA_1)
+        .is_ok());
+    assert_eq!(
+        param.mask_gen.parameters.unwrap().parameters,
+        Some(AnyRef::NULL)
+    );
+    assert!(param
+        .p_source
+        .assert_algorithm_oid(db::rfc5912::ID_P_SPECIFIED)
+        .is_ok());
+    assert!(param
+        .p_source
+        .parameters_any()
+        .unwrap()
+        .decode_as::<OctetStringRef<'_>>()
+        .unwrap()
+        .is_empty(),);
+    assert_eq!(param, Default::default())
+}
+
+#[test]
+fn encode_oaep_param_default() {
+    let mut buf = [0_u8; 256];
+    assert_eq!(
+        RsaOaepParams::default().encode_to_slice(&mut buf).unwrap(),
+        RSA_OAEP_PARAMETERS_DEFAULTS
+    );
+}
+
+#[test]
+fn new_oaep_param() {
+    let mut buf = [0_u8; 256];
+
+    let param = RsaOaepParams::new::<Sha1Mock>();
+    assert_eq!(
+        param.encode_to_slice(&mut buf).unwrap(),
+        RSA_OAEP_PARAMETERS_DEFAULTS
+    );
+
+    let param = RsaOaepParams::new::<Sha256Mock>();
+    println!("{:02x?}", param.encode_to_slice(&mut buf).unwrap());
+    assert_eq!(
+        param.encode_to_slice(&mut buf).unwrap(),
+        RSA_OAEP_PARAMETERS_SHA2_256
+    );
+}
diff --git a/crates/pkcs1/tests/private_key.rs b/crates/pkcs1/tests/private_key.rs
new file mode 100644
index 0000000..f650534
--- /dev/null
+++ b/crates/pkcs1/tests/private_key.rs
@@ -0,0 +1,94 @@
+//! PKCS#1 private key tests
+
+use hex_literal::hex;
+use pkcs1::{RsaPrivateKey, Version};
+
+/// RSA-2048 PKCS#1 private key encoded as ASN.1 DER.
+///
+/// Note: this key is extracted from the corresponding `rsa2048-priv.der`
+/// example key in the `pkcs8` crate.
+const RSA_2048_DER_EXAMPLE: &[u8] = include_bytes!("examples/rsa2048-priv.der");
+
+/// RSA-4096 PKCS#1 private key encoded as ASN.1 DER
+const RSA_4096_DER_EXAMPLE: &[u8] = include_bytes!("examples/rsa4096-priv.der");
+
+/// RSA-2048 PKCS#1 private key with 3 primes encoded as ASN.1 DER
+const RSA_2048_MULTI_PRIME_DER_EXAMPLE: &[u8] = include_bytes!("examples/rsa2048-priv-3prime.der");
+
+#[test]
+fn decode_rsa2048_der() {
+    let key = RsaPrivateKey::try_from(RSA_2048_DER_EXAMPLE).unwrap();
+    assert_eq!(key.version(), Version::TwoPrime);
+
+    // Extracted using:
+    // $ openssl asn1parse -in tests/examples/rsa2048-priv.pem
+    assert_eq!(key.modulus.as_bytes(), hex!("B6C42C515F10A6AAF282C63EDBE24243A170F3FA2633BD4833637F47CA4F6F36E03A5D29EFC3191AC80F390D874B39E30F414FCEC1FCA0ED81E547EDC2CD382C76F61C9018973DB9FA537972A7C701F6B77E0982DFC15FC01927EE5E7CD94B4F599FF07013A7C8281BDF22DCBC9AD7CABB7C4311C982F58EDB7213AD4558B332266D743AED8192D1884CADB8B14739A8DADA66DC970806D9C7AC450CB13D0D7C575FB198534FC61BC41BC0F0574E0E0130C7BBBFBDFDC9F6A6E2E3E2AFF1CBEAC89BA57884528D55CFB08327A1E8C89F4E003CF2888E933241D9D695BCBBACDC90B44E3E095FA37058EA25B13F5E295CBEAC6DE838AB8C50AF61E298975B872F"));
+    assert_eq!(key.public_exponent.as_bytes(), hex!("010001"));
+    assert_eq!(key.private_exponent.as_bytes(), hex!("7ECC8362C0EDB0741164215E22F74AB9D91BA06900700CF63690E5114D8EE6BDCFBB2E3F9614692A677A083F168A5E52E5968E6407B9D97C6E0E4064F82DA0B758A14F17B9B7D41F5F48E28D6551704F56E69E7AA9FA630FC76428C06D25E455DCFC55B7AC2B4F76643FDED3FE15FF78ABB27E65ACC4AAD0BDF6DB27EF60A6910C5C4A085ED43275AB19C1D997A32C6EFFCE7DF2D1935F6E601EEDE161A12B5CC27CA21F81D2C99C3D1EA08E90E3053AB09BEFA724DEF0D0C3A3C1E9740C0D9F76126A149EC0AA7D8078205484254D951DB07C4CF91FB6454C096588FD5924DBABEB359CA2025268D004F9D66EB3D6F7ADC1139BAD40F16DDE639E11647376C1"));
+    assert_eq!(key.prime1.as_bytes(), hex!("DCC061242D4E92AFAEE72AC513CA65B9F77036F9BD7E0E6E61461A7EF7654225EC153C7E5C31A6157A6E5A13FF6E178E8758C1CB33D9D6BBE3179EF18998E422ECDCBED78F4ECFDBE5F4FCD8AEC2C9D0DC86473CA9BD16D9D238D21FB5DDEFBEB143CA61D0BD6AA8D91F33A097790E9640DBC91085DC5F26343BA3138F6B2D67"));
+    assert_eq!(key.prime2.as_bytes(), hex!("D3F314757E40E954836F92BE24236AF2F0DA04A34653C180AF67E960086D93FDE65CB23EFD9D09374762F5981E361849AF68CDD75394FF6A4E06EB69B209E4228DB2DFA70E40F7F9750A528176647B788D0E5777A2CB8B22E3CD267FF70B4F3B02D3AAFB0E18C590A564B03188B0AA5FC48156B07622214243BD1227EFA7F2F9"));
+    assert_eq!(key.exponent1.as_bytes(), hex!("CE68B7AC1B0D100D636E55488753C5C09843FDB390E2705DF7689457C9BD8D9765E30978617E2EFC8048F4C324206DB86087B654E97BB3D464E7EE3F8CD83FE10436F7DF18E9A963C4E64911D67EDE34042F2E26E3D3A1AD346ADAD6B9B7F67708CB094E62DEE9FF4D5D6669AF988AF2255D1CE8ED317C6A7D8691DA354D12DB"));
+    assert_eq!(key.exponent2.as_bytes(), hex!("25F6E5944220286B4DFBBF4235C0EE5843D2198091895120D6CA7B200B826D3ECE738E2E00498FAC0A2A6CA969C7F0C3CA1AB0BC40297132BE7538D7BEDF4CB0EFC6B98EF7DBA54F56AA99AABCE534C49C27947D4678C51C63C78C7CE1687231B4C8EB587AE6EF0480CBAF4FC0173CFD587A7E67AF515FB9B9DE751118397229"));
+    assert_eq!(key.coefficient.as_bytes(), hex!("31995406D406207CADEAEA35B38D040C5F8A9A1AE0827E9ED06B153D83B6821935B4B36A82BE9D56C791B58C27271A5793D53A1D657C08997960B1433E5171987F452F144A7C72306D63E1D3FFC0B71B75AB08F2E45A482E988451CBE478E12EB228D07456C924B66F6CED048D853F533E31A68614F1C3CE6D8EC9983CE72AF7"));
+    assert!(key.other_prime_infos.is_none());
+}
+
+#[test]
+fn decode_rsa4096_der() {
+    let key = RsaPrivateKey::try_from(RSA_4096_DER_EXAMPLE).unwrap();
+    assert_eq!(key.version(), Version::TwoPrime);
+
+    // Extracted using:
+    // $ openssl asn1parse -in tests/examples/rsa4096-priv.pem
+    assert_eq!(key.modulus.as_bytes(), hex!("A7A74572811EA2617E49E85BD730DDE30F103F7D88EE3F765E540D3DD993BBB0BA140002859D0B40897436637F58B828EA74DF8321634077F99D4AA2D54CA375852EF597661D3713CE1EF3B4FD6A8E220238E467668A2C7EE3861D2212AE6A1EBDDFA88B62DF10F6BCF79EFF4AC298FB2563DF1B8764381AF9B1FB0CCD085E026B0AD9F6721A235177D0396B48754AD4A75242250A873BF2F6E7EE3C75DD613E365BA4F3210A6CC66B90A2FA3F762CA6884087B6BF8161EB144819F0F572F21F6C8E273E70D45A365B8B2819CE734613CC23B01329A17901F17078403861F54C52A051E2A58C75C2D9D80091BB9808A106C1F7ECB4034E15058BEEC725C5F919D62EAA234B62628D346C60BB919E70851DAB38571E6F0ED7634129F994EA368FEE7373DFDEC04445EBCA47FA20ED1540A860C948BABC98DA591CA1DE2E2E25540EF9B7CB353F60213B814A45D359EFA9B811EEFF08C65993BF8A85C2BFEAAA7ED5E6B43E18AE604464CE5F96150136E7D09F8B24FAD43D7870118CFA7BC24875506EBBC321B977E0861AEA50128620121F0B394A9CDD0A42411A1350C0770D975D71B00A90436240C967A0C3A5C20A0F6DE77F3F2CAFDA94ED0143C1F6E34F73E0CAC279EEEB7C637723A2B026C82802E1A4AEBAA8846DF98E7919498773E0D4F319956F4DE3AAD00EFB9A147D66B3AC1A01D35B2CFB48D400B0E7A80DC97551"));
+    assert_eq!(key.public_exponent.as_bytes(), hex!("010001"));
+    assert_eq!(key.private_exponent.as_bytes(), hex!("9FE3097B2322B90FAB6606C017A095EBE640C39C100BCEE02F238FA14DAFF38E9E57568F1127ED4436126B904631B127EC395BB3EE127EB82C88D2562A7FB55FED8D1450B7E4E2D2F37F5742636FCC6F289963522D5B5706082CADFA01C0EE99B4D0E9274D3A992E06974CBE01694686356962AC1959FD9BD447E5B9968C0543DF1BF134742AF345CDB2FA1F9371B0D4CF61C68D16D653D8E999D4FD3A16CF978A35AA40E860CDCE09655DD8B4CF19D4141B1E92AD5E51A8E4A5C27FA745611D90E49D0E9282222AB6F126643E1C77578816FCE3B98F321D2549F294A470DF8453446BF36F985DF25ED8FDE9FDF3073FB27727DF48E9E1FC7056BC78965090B7850126406462C8253051EF84E34EE3C3CEB8F96C658C38BE45558D2F64E29D223350555FC1EFA28EC1F4AFB5BA4080F09A86CDC3538C1AD7C972E6D7A3612E6845BA9AFBDF19F09060D1A779DE9635E2D2F8E0C510BA24C6C44B30C9BDFAF85BE917AEC5D43AFAB1AA3ADD33CC83DA93CAC69218F6A36EB47F199D5424C95FD9ED7B1E8BE2AEAA6433B227241316C20EE792650CEB48BFD634446B19D286B4EA1722498DA1A36973210EC3824751A5808D9AAEF59C449E19A5077CFECA126BD9A8DD4996561D4E27B3609FF82C5B1B21E627845D44961B33B875D5C4FA9FF357EF6BE3364969E1337C91B29A07B9A913CDE40CE2D5530C900E73751685E65431"));
+    assert_eq!(key.prime1.as_bytes(), hex!("D0213A79425B665B719118448893EC3275600F63DBF85B77F4E8E99EF302F6E82596048F6DCA772DE6BBF1124DB84B0AFE61B03A8604AB0079ED53F3304797AD01B38C44FE27A5A45E378483A804B56A4A967F48F01A866E721E67E4C9A1048AF68927FAA43D6A85D93E7BF7074DBA797563FCABE12309B76653C6DB614DC231CC556D9F25AC4841A02D31CDF3015B212307F9D0C79FEB5D3956CE53CC8FA1651BE60761F19F74672489EAF9F215409F39956E77A82183F1F72BB2FEDDF1B9FBFC4AD89EA445809DDBD5BD595277990C0BE9366FBB2ECF7B057CC1C3DC8FB77BF8456D07BBC95B3C1815F48E62B81468C3D4D9D96C0F48DAB04993BE8D91EDE5"));
+    assert_eq!(key.prime2.as_bytes(), hex!("CE36C6810522ABE5D6465F36EB137DA3B9EA4A5F1D27C6614729EB8E5E2E5CB88E3EF1A473A21944B66557B3DC2CE462E4BF3446CB4990037E5672B1705CBAE81B65BAF967A266DC18EFE80F4DBBFE1A59063205CE2943CADF421CCE74AF7063FD1A83AF3C39AF84525F59BDC1FF54815F52AFD1E8D4862B2C3654F6CFA83DC08E2A9D52B9F833C646AF7694467DFC5F7D7AD7B441895FCB7FFBED526324B0154A15823F5107C89548EDDCB61DA5308C6CC834D4A0C16DFA6CA1D67B61A65677EB1719CD125D0EF0DB8802FB76CFC17577BCB2510AE294E1BF8A9173A2B85C16A6B508C98F2D770B7F3DE48D9E720C53E263680B57E7109410015745570652FD"));
+    assert_eq!(key.exponent1.as_bytes(), hex!("748B46CD03E55E69B22C476488FE1BF31D5ACF0361F7AE707B89B8D832C7E42E966D6CDC4BE465DC2429F5920447406E4587BA40EB2ECDFA944BDB08806E7676804F642A760F096803021F88019BB16275A5D45CA9669104638EB72A9BE538400051493BC6A04577F1F055463CA6BFD6A76F77DB5F54596A83384250322A72A5A3FFEA4485B9F5341A57745E18C7179A749D50BC222C60857148347D243D016936B816463820CBF3BDB825061512E57EC3A5F397B9641B187109DD4F6E449F9A84E9FC66C921CA259B2612C363B468D5200E5557377FBCDAEC75B1A2D56CFC97C4AC4BA35AFA23C680CE3A8548AE3F6F72C94BBBBE10C900FC5A170B4B06FE29"));
+    assert_eq!(key.exponent2.as_bytes(), hex!("75CA4E0B069EEE67C3C4C0C082F8C82C8C96EAD277B9EF94436D0B936FF2B59DEA0AC446B6926232A0A934B6954EC34A45F57DEBEE54DFC14F1A1C3B84BE43392FE5252F2F6651B0E941A8618D7A93C4031409E0CD093F2313F214B84D68A51F48452BF11DCAA99A40DF1C48CB1688F3B93A6719D510086F82BAAA3FAD1021EDEA872704491C209EE26379AD6AB2AE44F14D09077AE3F8672A7D01EBAC9C19449FE3B7596974B3BBAA43CC6DEE731C4F2A18162D5A8202CB27E02DBE9E61C0449171C9981D2430D39DE28C298D8D50A943B2F27C5E665CBAB2897959FF19A5E87E632C58CDC31F9BDE9BC100AFFFDF50CF210F1E63A0A6149D2BD6E8D1B3D815"));
+    assert_eq!(key.coefficient.as_bytes(), hex!("8C557C4835E8B4066606A5DC255DBC3EB5F1586C7328988C8E242403F9575EFB0D28012C0634B7241768AD722049382906D635AFCB1D2A05BDFFC805FE670389B7FA90D65F94AFBC2008D9BC0D3CCEE425DFC72402050603C9F579EE8510ECC693AC6DD32836B6E15E3DC520366A1BA4AFC91D3E48A4D6724CA42443F4803E3B12634B0438572D8E13BC72F1A82853B8D9FCA6199D7A90AB64D9E79F793AC287F9A19011082A5268F209332D54D98D6E19030907FD9E6B82EF124677BA08AD6797A442213D097A351C50A08928DD732D6B29A6CF6706DAF5F20F78F87170FB279403C5221B5E5C70C2BAA0E69A72E0D1F3267DBD8C9BDDFF28AFA92F37C98D36"));
+    assert!(key.other_prime_infos.is_none());
+}
+
+#[cfg(not(feature = "alloc"))]
+#[test]
+fn decode_rsa2048_multi_prime_der() {
+    // Multi-prime RSA keys are unsupported when the alloc feature is disabled
+    assert!(RsaPrivateKey::try_from(RSA_2048_MULTI_PRIME_DER_EXAMPLE).is_err());
+}
+
+#[cfg(feature = "alloc")]
+#[test]
+fn decode_rsa2048_multi_prime_der() {
+    let key = RsaPrivateKey::try_from(RSA_2048_MULTI_PRIME_DER_EXAMPLE).unwrap();
+    assert_eq!(key.version(), Version::Multi);
+
+    // Extracted using:
+    // $ openssl asn1parse -in tests/examples/rsa2048-priv-3prime.pem
+    assert_eq!(key.modulus.as_bytes(), hex!("E8BF46480D9144E93D0E7971554F7EF45FB25B83A1069416DB8EC7C654EB489C695A3274EE4B5F3A08E35BA6D1FF2EC487CE544641EA0C0994CC554D2201308E3AC6491326183F477D30F165001800B38771BF96F69DE6D461A6E2F88057104FCDD6C6A1B69E7F95A27DAC0CBAE39CC1F9264C09DFEEA68477482C2816133012BA29A0D617FA6C6B70FAC3BEDCB020CB1F6EA3375163988E7F8C9474B5462C24D2B56BC03F9ED002E43C764B1E7B05C31EC7D8E91582CEC0942F396DAB94F3162D1AAA041DA99CEE90B81FF408BB75B7B233B19D34E504E258C1D774706E4C5FC2B11F97C9E4CEEAC345F8C57C3D3702F73FC98F7EED688812BE9B560618C245"));
+    assert_eq!(key.public_exponent.as_bytes(), hex!("010001"));
+    assert_eq!(key.private_exponent.as_bytes(), hex!("51ADA6656CD579207CFBD2649272B673DE0D828E1BF96A08E77E20DF9A3783A0D85BFDEF091D4C4ADA89A74550D6C3BBD688F30C40DF78DFF7E7095C6B3D8DA3AC3E9FB067A304B9FAD62D30ABAAC0BC40210C025759A374034864308AF6E444C6BEEA4FEA12DB78A9705A0F0C8B732B3FD733C5877A871ECC58FAB25D4236D0C91F207D6FC79ED5568658623984EF992C85EA7BFFC7F8C18368E644289198B64CF368C0FDEFFA7E24B65D895B701F8AF70AEAB0BB7D2E14C4354E15BE4723EC885DF146D7B0C6D2844C14DF639DDA9C7933FFFBD5AE2308B2A9CE7E6C52E3766106B8FEF8D593B88491BCED68632045E0E2FB889A58ED2FF28B6E5E2082BB01"));
+    assert_eq!(key.prime1.as_bytes(), hex!("07EA41E3B0B6FA6337D8D254B21F06C237FDAA6442B3B2756A479B27273CECCFBB5F472AA5D941E11DA1AAEB176450FC044EA639EF6E6B77B530D98A43ACF2D39571714EED516BBF43A7079E640CA46AE640CCAE46B5"));
+    assert_eq!(key.prime2.as_bytes(), hex!("077E9210399453F1F9D6AD862B4D83EE8651F92354BC4F22B1A5376ED36FE80DCFDDF73CEEB326972265B5CAC21E2F5FF22F09E6EA0AF358540004D6D1EF3A82BE214D206B25F98F0F3BAF8CD4F25D7169ACC99809A9"));
+    assert_eq!(key.exponent1.as_bytes(), hex!("02362298C27C2D73615C345033C0557C1876C88FE0CF227289F25DD84FAF471F3764049756E55FF1CCFCA9ABABCA7C921D85F80DC1E72121BE3F5AD8B5D5F1B6CA4F7AF0298091514C4EB3E33E6305E1545A109634ED"));
+    assert_eq!(key.exponent2.as_bytes(), hex!("830FFD55C1A13E6D7FD1D8D18A7911C9513E40C0A02093D128E53187F62417157527579D42D5C70B4D816EB976106C7081F01E3B2CC654E9601AF485E0DED161A5AABC2535B1E7A8F5BDD75410BE7B69E9A8D7DF09"));
+    assert_eq!(key.coefficient.as_bytes(), hex!("03B54C52199604D9A920B1B7AB95F0B474BA46796CC46C3E63C483499071BFADC0D27321EBD53E09271F28646B7590C97102F9E458A93B3A024A03565BCAFFA15F73C05BBF9653BE23224A1E35524A9895641C76FD2E"));
+
+    let other_prime_infos = key.other_prime_infos.unwrap();
+    assert_eq!(other_prime_infos.len(), 1);
+    assert_eq!(other_prime_infos[0].prime.as_bytes(), hex!("03EC75532FB0D2CA142632618EA698548D8489FE30A868D637A1D53895C79F16A63ADB60DB217DDC0D95694A3D95D029D1A9A2DF548ED105B2C6A84855739EDBC3CE82906500241D518A3172F8D470FADD4E1DFE5969"));
+    assert_eq!(other_prime_infos[0].exponent.as_bytes(), hex!("03A11508A3E52FA4412CEF8EF34EBF39FE48690758647DCC1F5B2E890F69BC8A4BA9C73F78912B047F00038AEB1A069897D90BD0FD3AB8B6479D9F0C8115D80BB8BAEC63B9387F2F2B3BE2EF509FD7FD02F47DA3C579"));
+    assert_eq!(other_prime_infos[0].coefficient.as_bytes(), hex!("39EA226CABFB317E41A5593B9168D1A0124993B45D9CD14A22BD1557CDCB43D28024AC26ED2C8530B53E9B93A878F428807C5282EBB811399F913017CDF2149013D80CDF73F609D6C692475EB7A123D0E93E6A60FC"));
+}
+
+#[test]
+fn private_key_to_public_key() {
+    let private_key = RsaPrivateKey::try_from(RSA_2048_DER_EXAMPLE).unwrap();
+    let public_key = private_key.public_key();
+
+    // Extracted using:
+    // $ openssl asn1parse -in tests/examples/rsa2048-pub.pem
+    assert_eq!(public_key.modulus.as_bytes(), hex!("B6C42C515F10A6AAF282C63EDBE24243A170F3FA2633BD4833637F47CA4F6F36E03A5D29EFC3191AC80F390D874B39E30F414FCEC1FCA0ED81E547EDC2CD382C76F61C9018973DB9FA537972A7C701F6B77E0982DFC15FC01927EE5E7CD94B4F599FF07013A7C8281BDF22DCBC9AD7CABB7C4311C982F58EDB7213AD4558B332266D743AED8192D1884CADB8B14739A8DADA66DC970806D9C7AC450CB13D0D7C575FB198534FC61BC41BC0F0574E0E0130C7BBBFBDFDC9F6A6E2E3E2AFF1CBEAC89BA57884528D55CFB08327A1E8C89F4E003CF2888E933241D9D695BCBBACDC90B44E3E095FA37058EA25B13F5E295CBEAC6DE838AB8C50AF61E298975B872F"));
+    assert_eq!(public_key.public_exponent.as_bytes(), hex!("010001"));
+}
diff --git a/crates/pkcs1/tests/public_key.rs b/crates/pkcs1/tests/public_key.rs
new file mode 100644
index 0000000..cde6e41
--- /dev/null
+++ b/crates/pkcs1/tests/public_key.rs
@@ -0,0 +1,64 @@
+//! PKCS#1 public key tests
+
+use hex_literal::hex;
+use pkcs1::RsaPublicKey;
+
+/// RSA-2048 PKCS#1 public key encoded as ASN.1 DER.
+///
+/// Note: this key is extracted from the corresponding `rsa2048-priv.der`
+/// example key in the `pkcs8` crate.
+const RSA_2048_DER_EXAMPLE: &[u8] = include_bytes!("examples/rsa2048-pub.der");
+
+/// RSA-4096 PKCS#1 public key encoded as ASN.1 DER
+const RSA_4096_DER_EXAMPLE: &[u8] = include_bytes!("examples/rsa4096-pub.der");
+
+// /// RSA-2048 PKCS#1 public key encoded as PEM
+// #[cfg(feature = "pem")]
+// const RSA_2048_PEM_EXAMPLE: &str = include_str!("examples/rsa2048-pub.pem");
+//
+// /// RSA-4096 PKCS#1 public key encoded as PEM
+// #[cfg(feature = "pem")]
+// const RSA_4096_PEM_EXAMPLE: &str = include_str!("examples/rsa4096-pub.pem");
+
+#[test]
+fn decode_rsa2048_der() {
+    let key = RsaPublicKey::try_from(RSA_2048_DER_EXAMPLE).unwrap();
+
+    // Extracted using:
+    // $ openssl asn1parse -in tests/examples/rsa2048-pub.pem
+    assert_eq!(key.modulus.as_bytes(), hex!("B6C42C515F10A6AAF282C63EDBE24243A170F3FA2633BD4833637F47CA4F6F36E03A5D29EFC3191AC80F390D874B39E30F414FCEC1FCA0ED81E547EDC2CD382C76F61C9018973DB9FA537972A7C701F6B77E0982DFC15FC01927EE5E7CD94B4F599FF07013A7C8281BDF22DCBC9AD7CABB7C4311C982F58EDB7213AD4558B332266D743AED8192D1884CADB8B14739A8DADA66DC970806D9C7AC450CB13D0D7C575FB198534FC61BC41BC0F0574E0E0130C7BBBFBDFDC9F6A6E2E3E2AFF1CBEAC89BA57884528D55CFB08327A1E8C89F4E003CF2888E933241D9D695BCBBACDC90B44E3E095FA37058EA25B13F5E295CBEAC6DE838AB8C50AF61E298975B872F"));
+    assert_eq!(key.public_exponent.as_bytes(), hex!("010001"));
+}
+
+#[test]
+fn decode_rsa4096_der() {
+    let key = RsaPublicKey::try_from(RSA_4096_DER_EXAMPLE).unwrap();
+
+    // Extracted using:
+    // $ openssl asn1parse -in tests/examples/rsa4096-pub.pem
+    assert_eq!(key.modulus.as_bytes(), hex!("A7A74572811EA2617E49E85BD730DDE30F103F7D88EE3F765E540D3DD993BBB0BA140002859D0B40897436637F58B828EA74DF8321634077F99D4AA2D54CA375852EF597661D3713CE1EF3B4FD6A8E220238E467668A2C7EE3861D2212AE6A1EBDDFA88B62DF10F6BCF79EFF4AC298FB2563DF1B8764381AF9B1FB0CCD085E026B0AD9F6721A235177D0396B48754AD4A75242250A873BF2F6E7EE3C75DD613E365BA4F3210A6CC66B90A2FA3F762CA6884087B6BF8161EB144819F0F572F21F6C8E273E70D45A365B8B2819CE734613CC23B01329A17901F17078403861F54C52A051E2A58C75C2D9D80091BB9808A106C1F7ECB4034E15058BEEC725C5F919D62EAA234B62628D346C60BB919E70851DAB38571E6F0ED7634129F994EA368FEE7373DFDEC04445EBCA47FA20ED1540A860C948BABC98DA591CA1DE2E2E25540EF9B7CB353F60213B814A45D359EFA9B811EEFF08C65993BF8A85C2BFEAAA7ED5E6B43E18AE604464CE5F96150136E7D09F8B24FAD43D7870118CFA7BC24875506EBBC321B977E0861AEA50128620121F0B394A9CDD0A42411A1350C0770D975D71B00A90436240C967A0C3A5C20A0F6DE77F3F2CAFDA94ED0143C1F6E34F73E0CAC279EEEB7C637723A2B026C82802E1A4AEBAA8846DF98E7919498773E0D4F319956F4DE3AAD00EFB9A147D66B3AC1A01D35B2CFB48D400B0E7A80DC97551"));
+    assert_eq!(key.public_exponent.as_bytes(), hex!("010001"));
+}
+
+// TODO(tarcieri): test trait-based PEM decoding
+// #[test]
+// #[cfg(feature = "pem")]
+// fn decode_rsa_2048_pem() {
+//     let pkcs1_doc: Document = RSA_2048_PEM_EXAMPLE.parse().unwrap();
+//     assert_eq!(pkcs1_doc.as_ref(), RSA_2048_DER_EXAMPLE);
+//
+//     // Ensure `Document` parses successfully
+//     let pk = RsaPublicKey::try_from(RSA_2048_DER_EXAMPLE).unwrap();
+//     assert_eq!(pkcs1_doc.decode().modulus.as_bytes(), pk.modulus.as_bytes());
+// }
+//
+// #[test]
+// #[cfg(feature = "pem")]
+// fn decode_rsa_4096_pem() {
+//     let pkcs1_doc: Document = RSA_4096_PEM_EXAMPLE.parse().unwrap();
+//     assert_eq!(pkcs1_doc.as_ref(), RSA_4096_DER_EXAMPLE);
+//
+//     // Ensure `Document` parses successfully
+//     let pk = RsaPublicKey::try_from(RSA_4096_DER_EXAMPLE).unwrap();
+//     assert_eq!(pkcs1_doc.decode().modulus.as_bytes(), pk.modulus.as_bytes());
+// }
diff --git a/crates/pkcs1/tests/traits.rs b/crates/pkcs1/tests/traits.rs
new file mode 100644
index 0000000..65bef26
--- /dev/null
+++ b/crates/pkcs1/tests/traits.rs
@@ -0,0 +1,100 @@
+//! Tests for PKCS#1 encoding/decoding traits.
+
+#![cfg(any(feature = "pem", feature = "std"))]
+
+use der::SecretDocument;
+use pkcs1::{DecodeRsaPrivateKey, EncodeRsaPrivateKey, Result};
+
+#[cfg(feature = "pem")]
+use pkcs1::der::pem::LineEnding;
+
+#[cfg(feature = "std")]
+use tempfile::tempdir;
+
+#[cfg(all(feature = "pem", feature = "std"))]
+use std::fs;
+
+/// PKCS#1 `RsaPrivateKey` encoded as ASN.1 DER
+const RSA_2048_PRIV_DER_EXAMPLE: &[u8] = include_bytes!("examples/rsa2048-priv.der");
+
+/// PKCS#1 `RsaPrivateKey` encoded as PEM
+#[cfg(feature = "pem")]
+const RSA_2048_PRIV_PEM_EXAMPLE: &str = include_str!("examples/rsa2048-priv.pem");
+
+/// Mock RSA private key type for testing trait impls against.
+pub struct MockPrivateKey(Vec<u8>);
+
+impl AsRef<[u8]> for MockPrivateKey {
+    fn as_ref(&self) -> &[u8] {
+        self.0.as_ref()
+    }
+}
+
+impl DecodeRsaPrivateKey for MockPrivateKey {
+    fn from_pkcs1_der(bytes: &[u8]) -> Result<MockPrivateKey> {
+        Ok(MockPrivateKey(bytes.to_vec()))
+    }
+}
+
+impl EncodeRsaPrivateKey for MockPrivateKey {
+    fn to_pkcs1_der(&self) -> Result<SecretDocument> {
+        Ok(SecretDocument::try_from(self.as_ref())?)
+    }
+}
+
+#[cfg(feature = "pem")]
+#[test]
+fn from_pkcs1_pem() {
+    let key = MockPrivateKey::from_pkcs1_pem(RSA_2048_PRIV_PEM_EXAMPLE).unwrap();
+    assert_eq!(key.as_ref(), RSA_2048_PRIV_DER_EXAMPLE);
+}
+
+#[cfg(feature = "std")]
+#[test]
+fn read_pkcs1_der_file() {
+    let key = MockPrivateKey::read_pkcs1_der_file("tests/examples/rsa2048-priv.der").unwrap();
+    assert_eq!(key.as_ref(), RSA_2048_PRIV_DER_EXAMPLE);
+}
+
+#[cfg(all(feature = "pem", feature = "std"))]
+#[test]
+fn read_pkcs1_pem_file() {
+    let key = MockPrivateKey::read_pkcs1_pem_file("tests/examples/rsa2048-priv.pem").unwrap();
+    assert_eq!(key.as_ref(), RSA_2048_PRIV_DER_EXAMPLE);
+}
+
+#[cfg(feature = "pem")]
+#[test]
+fn to_pkcs1_pem() {
+    let pem = MockPrivateKey(RSA_2048_PRIV_DER_EXAMPLE.to_vec())
+        .to_pkcs1_pem(LineEnding::LF)
+        .unwrap();
+
+    assert_eq!(&*pem, RSA_2048_PRIV_PEM_EXAMPLE);
+}
+
+#[cfg(feature = "std")]
+#[test]
+fn write_pkcs1_der_file() {
+    let dir = tempdir().unwrap();
+    let path = dir.path().join("example.der");
+    MockPrivateKey(RSA_2048_PRIV_DER_EXAMPLE.to_vec())
+        .write_pkcs1_der_file(&path)
+        .unwrap();
+
+    let key = MockPrivateKey::read_pkcs1_der_file(&path).unwrap();
+    assert_eq!(key.as_ref(), RSA_2048_PRIV_DER_EXAMPLE);
+}
+
+#[cfg(all(feature = "pem", feature = "std"))]
+#[test]
+fn write_pkcs1_pem_file() {
+    let dir = tempdir().unwrap();
+    let path = dir.path().join("example.pem");
+    MockPrivateKey(RSA_2048_PRIV_DER_EXAMPLE.to_vec())
+        .write_pkcs1_pem_file(&path, LineEnding::LF)
+        .unwrap();
+
+    let pem = fs::read_to_string(path).unwrap();
+    assert_eq!(&pem, RSA_2048_PRIV_PEM_EXAMPLE);
+}
diff --git a/crates/pkcs8/.cargo-checksum.json b/crates/pkcs8/.cargo-checksum.json
new file mode 100644
index 0000000..aa3d749
--- /dev/null
+++ b/crates/pkcs8/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"CHANGELOG.md":"a01855ad0a36a81e3e82f56d3d68a844489c3b17a5cb902e235924be158aee58","Cargo.toml":"440cf271c696da0bcef123a4e005f9f47273d140b9b824f4b7b0d4fa4639cb12","LICENSE-APACHE":"a9040321c3712d8fd0b09cf52b17445de04a23a10165049ae187cd39e5c86be5","LICENSE-MIT":"ad64fcb9589f162720f3cc5010ad76ca6ad3764e11861f9192c489df176bb71d","README.md":"49fdb13fec069473cf11a797d4fe3dc2c3cb2c496652937ae7dab4a7b87cddfc","src/encrypted_private_key_info.rs":"33746a87bce68a79a8ae53951cd020b2145383afce6c5ca4e5bbc5eb642a642e","src/error.rs":"94b661093a3c5beac61ffaabcae36e4d156309eeb78f36154a7422ccda7d2422","src/lib.rs":"b5c2fedbf3cfa31cc56b9cc16c94a5083ee83d7facfa1a34837b5262f60f622a","src/private_key_info.rs":"bd3b7aaa41ddab5fd731e1d0d1d7bf25c81fe6291a9edf51cd792136c4a50556","src/traits.rs":"fe016f54123d8bdcfd728ccba902033eccd546457cdba0d4d51f17c589df108a","src/version.rs":"a1c31cf4c2dc9677637d2616f34300d0117be70b72258a78f47841e457ec983f","tests/encrypted_private_key.rs":"f9e173d9bc76c21db92d05f36852be14e321877896dc46237ce6e6af7026002c","tests/examples/ed25519-encpriv-aes128-pbkdf2-sha1.der":"b41702662d6a645cc81af5be79455509e02efbf6eb5166e91346c19334485e9a","tests/examples/ed25519-encpriv-aes256-pbkdf2-sha256.der":"72ea607c5f0e560f68ee914dca8a5a74bfa22a667333656864f7938960acd302","tests/examples/ed25519-encpriv-aes256-pbkdf2-sha256.pem":"0c8bd6713af3f28392f684c5ba8b1bd842d8b483d00c136cb1fb24976aab447a","tests/examples/ed25519-encpriv-aes256-scrypt.der":"81f29098750ab282fd071692173d4da09b2c81371e7a02da7a8a14d6bed7c8a0","tests/examples/ed25519-encpriv-aes256-scrypt.pem":"e643345b62b43ea255fccbad6efd21453c62a7bbbb4d94dfae151fe04562313d","tests/examples/ed25519-encpriv-des-pbkdf2-sha256.der":"2a2412eac2aebec977563ee503358513c179f0216d93701ecd901f0062df79dd","tests/examples/ed25519-encpriv-des3-pbkdf2-sha256.der":"e064ed2a875be1388a05be89948236c2765d85943ccf093ee3df6e9a16baa619","tests/examples/ed25519-priv-pkcs8v1.der":"c1c3b09c4d18e096209edf25bc8dfc2f11dc29896085e49e5f4e487fbd97dbb6","tests/examples/ed25519-priv-pkcs8v1.pem":"8e39c38052cd63ab3870831a9f6cab76645426ca21ef77e24e2ead445aa4df16","tests/examples/ed25519-priv-pkcs8v2.der":"78f1cd2051065b209431249093f218b0e01a5fd0b9e756db820d4893d9dbbf55","tests/examples/ed25519-priv-pkcs8v2.pem":"a7cc1efd420b972a1b0776cc8b703624c62617eb2be3705876cc145227bd8427","tests/examples/ed25519-pub.der":"55dd4c74b0e48534e2f4e173ceceb50df8f27a7ac2aa8991cc7ae914e030bced","tests/examples/ed25519-pub.pem":"36d717203cbca1812f05f30e0415251c928b659882092e653221a028571c6853","tests/examples/p256-priv.der":"8125ab208d2181ed3ef05ff0ab1906e5898c36a858277e5b987e78e505288769","tests/examples/p256-priv.pem":"f4171f5ea72bf95ee444ceb868872f5c5d2bbc5fca038ae801b06fb9ac6b9429","tests/examples/p256-pub.der":"b9968d56ed8d6aa3fb43b15fa01e355d7a3a0203b1408b3fd2733637c4d1642c","tests/examples/p256-pub.pem":"d1ff198dc495da63f5f909db0254d6e49cff519487fcb26d055a762fc3ca47a1","tests/examples/rsa2048-priv.der":"ea7fe20f854f4fb908c12f1344e6cffbb83f367bbd8bfebca20687402394266f","tests/examples/rsa2048-priv.pem":"4df5e3254935a4f7d71e3b693d1b874091717f8b6075cd33f80ce4338d2ab0f2","tests/examples/rsa2048-pub.der":"efeda9bfead9fd0594f6a5cf6fdf6c163116a3b1fad6d73cea05295b68fd1794","tests/examples/rsa2048-pub.pem":"078c3983093e86784590a2a454547acad1d50992419334be697e442e954f02f8","tests/examples/x25519-priv.der":"bc4561e57bcb0e5b8be9bbdf4fb51e5e34dc46047ce50239c35fe7f119f52f91","tests/examples/x25519-priv.pem":"c618022ab6a2e345b475830c1e0a9332458791df939d116b6e6d4da9c918771b","tests/private_key.rs":"ff7dd659b3bc3a5bfc8789164160a4759838ad58e1233cece020340f6bb45271","tests/traits.rs":"fcd1f1198ce579736862eed872ca55f081533146001fc9ec03ac35728fbd89a8"},"package":"f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"}
\ No newline at end of file
diff --git a/crates/pkcs8/Android.bp b/crates/pkcs8/Android.bp
new file mode 100644
index 0000000..b6227bc
--- /dev/null
+++ b/crates/pkcs8/Android.bp
@@ -0,0 +1,75 @@
+// This file is generated by cargo_embargo.
+// Do not modify this file because the changes will be overridden on upgrade.
+
+package {
+    default_applicable_licenses: ["external_rust_crates_pkcs8_license"],
+    default_team: "trendy_team_android_rust",
+}
+
+license {
+    name: "external_rust_crates_pkcs8_license",
+    visibility: [":__subpackages__"],
+    license_kinds: ["SPDX-license-identifier-Apache-2.0"],
+    license_text: ["LICENSE"],
+}
+
+rust_library {
+    name: "libpkcs8",
+    host_supported: true,
+    crate_name: "pkcs8",
+    cargo_env_compat: true,
+    cargo_pkg_version: "0.10.2",
+    crate_root: "src/lib.rs",
+    edition: "2021",
+    features: ["alloc"],
+    rustlibs: [
+        "libder",
+        "libspki",
+    ],
+    apex_available: [
+        "//apex_available:platform",
+        "com.android.virt",
+    ],
+    product_available: true,
+    vendor_available: true,
+    visibility: [
+        "//external/rust/crates/pkcs1:__subpackages__",
+        "//external/rust/crates/sec1:__subpackages__",
+        "//packages/modules/Virtualization:__subpackages__",
+        "//system/keymint:__subpackages__",
+    ],
+
+}
+
+rust_library_rlib {
+    name: "libpkcs8_nostd",
+    crate_name: "pkcs8",
+    cargo_env_compat: true,
+    cargo_pkg_version: "0.10.2",
+    crate_root: "src/lib.rs",
+    edition: "2021",
+    features: ["alloc"],
+    rustlibs: [
+        "libder_nostd",
+        "libspki_nostd",
+    ],
+    apex_available: [
+        "//apex_available:platform",
+        "com.android.virt",
+    ],
+    prefer_rlib: true,
+    no_stdlibs: true,
+    stdlibs: [
+        "libcompiler_builtins.rust_sysroot",
+        "libcore.rust_sysroot",
+    ],
+    product_available: true,
+    vendor_available: true,
+    visibility: [
+        "//external/rust/crates/pkcs1:__subpackages__",
+        "//external/rust/crates/sec1:__subpackages__",
+        "//packages/modules/Virtualization:__subpackages__",
+        "//system/keymint:__subpackages__",
+    ],
+
+}
diff --git a/crates/pkcs8/CHANGELOG.md b/crates/pkcs8/CHANGELOG.md
new file mode 100644
index 0000000..1f754d5
--- /dev/null
+++ b/crates/pkcs8/CHANGELOG.md
@@ -0,0 +1,234 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## 0.10.2 (2023-04-04)
+### Changed
+- Bump `spki` to v0.7.1 ([#981])
+
+[#981]: https://github.com/RustCrypto/formats/pull/981
+
+## 0.10.1 (2023-03-05)
+### Added
+- `sha1-insecure` feature ([#913])
+
+[#913]: https://github.com/RustCrypto/formats/pull/913
+
+## 0.10.0 (2023-02-26) [YANKED]
+### Changed
+- Use blanket impls for `Decode*` traits ([#785])
+- Bump `der` dependency to v0.7 ([#899])
+- Bump `spki` dependency to v0.7 ([#900])
+- Bump `pkcs5` dependency to v0.7 ([#901])
+
+[#785]: https://github.com/RustCrypto/formats/pull/785
+[#899]: https://github.com/RustCrypto/formats/pull/899
+[#900]: https://github.com/RustCrypto/formats/pull/900
+[#901]: https://github.com/RustCrypto/formats/pull/901
+
+## 0.9.0 (2022-05-08)
+### Added
+- Error conversion support to `pkcs8::spki::Error` ([#335])
+- Re-export `AssociatedOid` ([#645])
+
+### Changed
+- Use `finish_non_exhaustive` in `Debug` impls ([#245])
+- Replace `PrivateKeyDocument` with `der::SecretDocument` ([#571])
+- Bump `der` to v0.6 ([#653])
+- Bump `spki` to v0.6 ([#654])
+- Bump `pkcs5` to v0.5 ([#655])
+
+### Removed
+- `PrivateKeyDocument` ([#571])
+
+[#245]: https://github.com/RustCrypto/formats/pull/245
+[#335]: https://github.com/RustCrypto/formats/pull/335
+[#571]: https://github.com/RustCrypto/formats/pull/571
+[#645]: https://github.com/RustCrypto/formats/pull/645
+[#653]: https://github.com/RustCrypto/formats/pull/653
+[#654]: https://github.com/RustCrypto/formats/pull/654
+[#655]: https://github.com/RustCrypto/formats/pull/655
+
+## 0.8.0 (2021-11-16)
+### Added
+- Re-export `spki` crate ([#210])
+
+### Changed
+- Replace usages of `expect` with fallible methods ([#108])
+- Impl `From*Key`/`To*Key` traits on `Document` types ([#110])
+- Rename `From/ToPrivateKey` => `DecodePrivateKey`/`EncodePrivateKey` ([#121])
+- Rust 2021 edition upgrade; MSRV 1.56 ([#136])
+- Use `der::Document` to impl `*PrivateKeyDocument` ([#140])
+- Rename `Error::Crypto` => `Error::EncryptedPrivateKey` ([#213], [#214])
+- Bump `der` dependency to v0.5 ([#222])
+- Bump `spki` dependency to v0.5 ([#223])
+- Bump `pkcs5` dependency to v0.4 ([#224])
+- Replace `from_pkcs8_private_key_info` with `TryFrom` ([#230])
+
+### Removed
+- `*_with_le` PEM encoding methods ([#109])
+- PKCS#1 support; moved to `pkcs1` crate ([#124])
+- I/O related errors from key format crates ([#158])
+- `der::pem` export ([#211])
+
+[#108]: https://github.com/RustCrypto/formats/pull/108
+[#109]: https://github.com/RustCrypto/formats/pull/109
+[#110]: https://github.com/RustCrypto/formats/pull/110
+[#121]: https://github.com/RustCrypto/formats/pull/121
+[#124]: https://github.com/RustCrypto/formats/pull/124
+[#136]: https://github.com/RustCrypto/formats/pull/136
+[#140]: https://github.com/RustCrypto/formats/pull/140
+[#158]: https://github.com/RustCrypto/formats/pull/158
+[#210]: https://github.com/RustCrypto/formats/pull/210
+[#211]: https://github.com/RustCrypto/formats/pull/211
+[#213]: https://github.com/RustCrypto/formats/pull/213
+[#214]: https://github.com/RustCrypto/formats/pull/214
+[#222]: https://github.com/RustCrypto/formats/pull/222
+[#223]: https://github.com/RustCrypto/formats/pull/223
+[#224]: https://github.com/RustCrypto/formats/pull/224
+[#230]: https://github.com/RustCrypto/formats/pull/230
+
+## 0.7.6 (2021-09-14)
+### Added
+- `3des` and `des-insecure` features
+- `sha1` feature
+- Support for AES-192-CBC
+
+### Changed
+- Moved to `formats` repo ([#2])
+
+[#2]: https://github.com/RustCrypto/formats/pull/2
+
+## 0.7.5 (2021-07-26)
+### Added
+- Support for customizing PEM `LineEnding`
+
+### Changed
+- Bump `pem-rfc7468` dependency to v0.2
+
+## 0.7.4 (2021-07-25)
+### Added
+- PKCS#1 support
+
+## 0.7.3 (2021-07-24)
+### Changed
+- Use `pem-rfc7468` crate
+
+## 0.7.2 (2021-07-20)
+### Added
+- `Error::ParametersMalformed` variant
+
+## 0.7.1 (2021-07-20)
+### Added
+- `Error::KeyMalformed` variant
+
+## 0.7.0 (2021-06-07)
+### Added
+- ASN.1 error improvements
+
+### Changed
+- Merge `OneAsymmetricKey` into `PrivateKeyInfo`
+- Use scrypt as the default PBES2 KDF
+- Return `Result`(s) when encoding 
+- Bump `der` to v0.4
+- Bump `spki` to v0.4
+- Bump `pkcs5` to v0.3
+
+## 0.6.1 (2021-05-24)
+### Added
+- Support for RFC5958's `OneAsymmetricKey`
+
+### Changed
+- Bump `der` to v0.3.5
+
+## 0.6.0 (2021-03-22)
+### Changed
+- Bump `der` dependency to v0.3
+- Bump `spki` dependency to v0.3
+- Bump `pkcs5` dependency to v0.2
+
+## 0.5.5 (2021-03-17)
+### Changed
+- Bump `base64ct` dependency to v1.0
+
+## 0.5.4 (2021-02-24)
+### Added
+- Encryption helper methods for `FromPrivateKey`/`ToPrivateKey`
+
+## 0.5.3 (2021-02-23)
+### Added
+- Support for decrypting/encrypting `EncryptedPrivateKeyInfo`
+- PEM support for `EncryptedPrivateKeyInfo`
+- `Error::Crypto` variant
+
+## 0.5.2 (2021-02-20)
+### Changed
+- Use `pkcs5` crate
+
+## 0.5.1 (2021-02-18) [YANKED]
+### Added
+- `pkcs5` feature
+
+### Changed
+- Bump `spki` dependency to v0.2.0
+
+## 0.5.0 (2021-02-16) [YANKED]
+### Added
+- Initial `EncryptedPrivateKeyInfo` support
+
+### Changed
+- Extract SPKI-related types into the `spki` crate
+
+## 0.4.1 (2021-02-01)
+### Changed
+- Bump `basec4ct` dependency to v0.2
+
+## 0.4.0 (2021-01-26)
+### Changed
+- Bump `der` crate dependency to v0.2
+- Use `base64ct` v0.1 for PEM encoding
+
+## 0.3.3 (2020-12-21)
+### Changed
+- Use `der` crate for decoding/encoding ASN.1 DER
+
+## 0.3.2 (2020-12-16)
+### Added
+- `AlgorithmIdentifier::parameters_oid` method
+
+## 0.3.1 (2020-12-16)
+### Changed
+- Bump `const-oid` dependency to v0.4
+
+## 0.3.0 (2020-12-16) [YANKED]
+### Added
+- `AlgorithmParameters` enum
+
+## 0.2.2 (2020-12-14)
+### Fixed
+- Decoding/encoding support for Ed25519 keys
+
+## 0.2.1 (2020-12-14)
+### Added
+- rustdoc improvements
+
+## 0.2.0 (2020-12-14)
+### Added
+- File writing methods for public/private keys
+- Methods for loading `*Document` types from files
+- DER encoding support
+- PEM encoding support
+- `ToPrivateKey`/`ToPublicKey` traits
+
+### Changed
+- `Error` enum
+- Rename `load_*_file` methods to `read_*_file`
+
+## 0.1.1 (2020-12-06)
+### Added
+- Helper methods to load keys from the local filesystem
+
+## 0.1.0 (2020-12-05)
+- Initial release
diff --git a/crates/pkcs8/Cargo.lock b/crates/pkcs8/Cargo.lock
new file mode 100644
index 0000000..4f956f4
--- /dev/null
+++ b/crates/pkcs8/Cargo.lock
@@ -0,0 +1,453 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "aes"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0"
+dependencies = [
+ "cfg-if",
+ "cipher",
+ "cpufeatures",
+]
+
+[[package]]
+name = "base64ct"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
+
+[[package]]
+name = "bitflags"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "block-padding"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8894febbff9f758034a5b8e12d87918f56dfc64a8e1fe757d65e29041538d93"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "cbc"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26b52a9543ae338f279b96b0b9fed9c8093744685043739079ce85cd58f289a6"
+dependencies = [
+ "cipher",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "cipher"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"
+dependencies = [
+ "crypto-common",
+ "inout",
+]
+
+[[package]]
+name = "const-oid"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51e852e6dc9a5bed1fae92dd2375037bf2b768725bf3be87811edee3249d09ad"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "der"
+version = "0.7.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f55bf8e7b65898637379c1b74eb1551107c8294ed26d855ceb9fd1a09cfc9bc0"
+dependencies = [
+ "const-oid",
+ "pem-rfc7468",
+ "zeroize",
+]
+
+[[package]]
+name = "des"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ffdd80ce8ce993de27e9f063a444a4d53ce8e8db4c1f00cc03af5ad5a9867a1e"
+dependencies = [
+ "cipher",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+ "subtle",
+]
+
+[[package]]
+name = "errno"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "534c5cf6194dfab3db3242765c03bbe257cf92f22b38f6bc0c58d59108a820ba"
+dependencies = [
+ "libc",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "fastrand"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e8c02a5121d4ea3eb16a80748c74f5549a5665e4c21333c6098f283870fbdea6"
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "hex-literal"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ebdb29d2ea9ed0083cd8cece49bbd968021bd99b0849edb4a9a7ee0fdf6a4e0"
+
+[[package]]
+name = "hmac"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
+dependencies = [
+ "digest",
+]
+
+[[package]]
+name = "inout"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a0c10553d664a4d0bcff9f4215d0aac67a639cc68ef660840afe309b807bc9f5"
+dependencies = [
+ "block-padding",
+ "generic-array",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.158"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439"
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89"
+
+[[package]]
+name = "once_cell"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
+
+[[package]]
+name = "pbkdf2"
+version = "0.12.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8ed6a7761f76e3b9f92dfb0a60a6a6477c61024b775147ff0973a02653abaf2"
+dependencies = [
+ "digest",
+ "hmac",
+]
+
+[[package]]
+name = "pem-rfc7468"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88b39c9bfcfc231068454382784bb460aae594343fb030d46e9f50a645418412"
+dependencies = [
+ "base64ct",
+]
+
+[[package]]
+name = "pkcs5"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e847e2c91a18bfa887dd028ec33f2fe6f25db77db3619024764914affe8b69a6"
+dependencies = [
+ "aes",
+ "cbc",
+ "der",
+ "des",
+ "pbkdf2",
+ "scrypt",
+ "sha1",
+ "sha2",
+ "spki",
+]
+
+[[package]]
+name = "pkcs8"
+version = "0.10.2"
+dependencies = [
+ "der",
+ "hex-literal",
+ "pkcs5",
+ "rand_core",
+ "spki",
+ "subtle",
+ "tempfile",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "rustix"
+version = "0.38.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a85d50532239da68e9addb745ba38ff4612a242c1c7ceea689c4bc7c2f43c36f"
+dependencies = [
+ "bitflags",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "salsa20"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97a22f5af31f73a954c10289c93e8a50cc23d971e80ee446f1f6f7137a088213"
+dependencies = [
+ "cipher",
+]
+
+[[package]]
+name = "scrypt"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0516a385866c09368f0b5bcd1caff3366aace790fcd46e2bb032697bb172fd1f"
+dependencies = [
+ "pbkdf2",
+ "salsa20",
+ "sha2",
+]
+
+[[package]]
+name = "sha1"
+version = "0.10.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "spki"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
+dependencies = [
+ "base64ct",
+ "der",
+]
+
+[[package]]
+name = "subtle"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
+
+[[package]]
+name = "tempfile"
+version = "3.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04cbcdd0c794ebb0d4cf35e88edd2f7d2c4c3e9a5a6dab322839b321c6a87a64"
+dependencies = [
+ "cfg-if",
+ "fastrand",
+ "once_cell",
+ "rustix",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "typenum"
+version = "1.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+
+[[package]]
+name = "windows-sys"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+dependencies = [
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+
+[[package]]
+name = "zeroize"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde"
diff --git a/crates/pkcs8/Cargo.toml b/crates/pkcs8/Cargo.toml
new file mode 100644
index 0000000..d836551
--- /dev/null
+++ b/crates/pkcs8/Cargo.toml
@@ -0,0 +1,108 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2021"
+rust-version = "1.65"
+name = "pkcs8"
+version = "0.10.2"
+authors = ["RustCrypto Developers"]
+description = """
+Pure Rust implementation of Public-Key Cryptography Standards (PKCS) #8:
+Private-Key Information Syntax Specification (RFC 5208), with additional
+support for PKCS#8v2 asymmetric key packages (RFC 5958)
+"""
+readme = "README.md"
+keywords = [
+    "crypto",
+    "key",
+    "pkcs",
+    "private",
+]
+categories = [
+    "cryptography",
+    "data-structures",
+    "encoding",
+    "no-std",
+    "parser-implementations",
+]
+license = "Apache-2.0 OR MIT"
+repository = "https://github.com/RustCrypto/formats/tree/master/pkcs8"
+
+[package.metadata.docs.rs]
+all-features = true
+rustdoc-args = [
+    "--cfg",
+    "docsrs",
+]
+
+[dependencies.der]
+version = "0.7"
+features = ["oid"]
+
+[dependencies.pkcs5]
+version = "0.7"
+optional = true
+
+[dependencies.rand_core]
+version = "0.6"
+optional = true
+default-features = false
+
+[dependencies.spki]
+version = "0.7.1"
+
+[dependencies.subtle]
+version = "2"
+optional = true
+default-features = false
+
+[dev-dependencies.hex-literal]
+version = "0.3"
+
+[dev-dependencies.tempfile]
+version = "3"
+
+[features]
+3des = [
+    "encryption",
+    "pkcs5/3des",
+]
+alloc = [
+    "der/alloc",
+    "der/zeroize",
+    "spki/alloc",
+]
+des-insecure = [
+    "encryption",
+    "pkcs5/des-insecure",
+]
+encryption = [
+    "alloc",
+    "pkcs5/alloc",
+    "pkcs5/pbes2",
+    "rand_core",
+]
+getrandom = ["rand_core/getrandom"]
+pem = [
+    "alloc",
+    "der/pem",
+    "spki/pem",
+]
+sha1-insecure = [
+    "encryption",
+    "pkcs5/sha1-insecure",
+]
+std = [
+    "alloc",
+    "der/std",
+    "spki/std",
+]
diff --git a/crates/pkcs8/LICENSE b/crates/pkcs8/LICENSE
new file mode 120000
index 0000000..6b579aa
--- /dev/null
+++ b/crates/pkcs8/LICENSE
@@ -0,0 +1 @@
+LICENSE-APACHE
\ No newline at end of file
diff --git a/crates/pkcs8/LICENSE-APACHE b/crates/pkcs8/LICENSE-APACHE
new file mode 100644
index 0000000..78173fa
--- /dev/null
+++ b/crates/pkcs8/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/crates/pkcs8/LICENSE-MIT b/crates/pkcs8/LICENSE-MIT
new file mode 100644
index 0000000..e0d0827
--- /dev/null
+++ b/crates/pkcs8/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2020-2023 The RustCrypto Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/crates/pkcs8/METADATA b/crates/pkcs8/METADATA
new file mode 100644
index 0000000..3b0922c
--- /dev/null
+++ b/crates/pkcs8/METADATA
@@ -0,0 +1,20 @@
+# This project was upgraded with external_updater.
+# Usage: tools/external_updater/updater.sh update rust/crates/pkcs8
+# For more info, check https://cs.android.com/android/platform/superproject/+/main:tools/external_updater/README.md
+
+name: "pkcs8"
+description: "Pure Rust implementation of Public-Key Cryptography Standards (PKCS) #8: Private-Key Information Syntax Specification (RFC 5208)."
+third_party {
+  license_type: NOTICE
+  last_upgrade_date {
+    year: 2023
+    month: 12
+    day: 15
+  }
+  homepage: "https://crates.io/crates/pkcs8"
+  identifier {
+    type: "Archive"
+    value: "https://static.crates.io/crates/pkcs8/pkcs8-0.10.2.crate"
+    version: "0.10.2"
+  }
+}
diff --git a/crates/pkcs8/MODULE_LICENSE_APACHE2 b/crates/pkcs8/MODULE_LICENSE_APACHE2
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/crates/pkcs8/MODULE_LICENSE_APACHE2
diff --git a/crates/pkcs8/README.md b/crates/pkcs8/README.md
new file mode 100644
index 0000000..c158543
--- /dev/null
+++ b/crates/pkcs8/README.md
@@ -0,0 +1,94 @@
+# [RustCrypto]: PKCS#8 (Private Keys)
+
+[![crate][crate-image]][crate-link]
+[![Docs][docs-image]][docs-link]
+[![Build Status][build-image]][build-link]
+![Apache2/MIT licensed][license-image]
+![Rust Version][rustc-image]
+[![Project Chat][chat-image]][chat-link]
+
+Pure Rust implementation of Public-Key Cryptography Standards (PKCS) #8:
+Private-Key Information Syntax Specification ([RFC 5208]).
+
+[Documentation][docs-link]
+
+## About PKCS#8
+
+PKCS#8 is a format for cryptographic private keys, often containing pairs
+of private and public keys.
+
+You can identify a PKCS#8 private key encoded as PEM (i.e. text) by the
+following:
+
+```text
+-----BEGIN PRIVATE KEY-----
+```
+
+PKCS#8 private keys can optionally be encrypted under a password using
+key derivation algorithms like PBKDF2 and [scrypt], and encrypted with
+ciphers like AES-CBC. When a PKCS#8 private key has been encrypted,
+it starts with the following:
+
+```text
+-----BEGIN ENCRYPTED PRIVATE KEY-----
+```
+
+PKCS#8 private keys can also be serialized in an ASN.1-based binary format.
+The PEM text encoding is a Base64 representation of this format.
+
+## Supported Algorithms
+
+This crate is implemented in an algorithm-agnostic manner with the goal of
+enabling PKCS#8 support for any algorithm.
+
+That said, it has been tested for interoperability against keys generated by
+OpenSSL for the  following algorithms:
+
+- ECC (`id-ecPublicKey`)
+- Ed25519 (`id-Ed25519`)
+- RSA (`id-rsaEncryption`)
+- X25519 (`id-X25519`)
+
+Please open an issue if you encounter trouble using it with a particular
+algorithm, including the ones listed above or other algorithms.
+
+## Minimum Supported Rust Version
+
+This crate requires **Rust 1.65** at a minimum.
+
+We may change the MSRV in the future, but it will be accompanied by a minor
+version bump.
+
+## License
+
+Licensed under either of:
+
+ * [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0)
+ * [MIT license](http://opensource.org/licenses/MIT)
+
+at your option.
+
+### Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in the work by you, as defined in the Apache-2.0 license, shall be
+dual licensed as above, without any additional terms or conditions.
+
+[//]: # (badges)
+
+[crate-image]: https://buildstats.info/crate/pkcs8
+[crate-link]: https://crates.io/crates/pkcs8
+[docs-image]: https://docs.rs/pkcs8/badge.svg
+[docs-link]: https://docs.rs/pkcs8/
+[license-image]: https://img.shields.io/badge/license-Apache2.0/MIT-blue.svg
+[rustc-image]: https://img.shields.io/badge/rustc-1.65+-blue.svg
+[chat-image]: https://img.shields.io/badge/zulip-join_chat-blue.svg
+[chat-link]: https://rustcrypto.zulipchat.com/#narrow/stream/300570-formats
+[build-image]: https://github.com/RustCrypto/formats/workflows/pkcs8/badge.svg?branch=master&event=push
+[build-link]: https://github.com/RustCrypto/formats/actions
+
+[//]: # (links)
+
+[RustCrypto]: https://github.com/rustcrypto
+[RFC 5208]: https://tools.ietf.org/html/rfc5208
+[scrypt]: https://en.wikipedia.org/wiki/Scrypt
diff --git a/crates/pkcs8/cargo2android_viz.bp b/crates/pkcs8/cargo2android_viz.bp
new file mode 100644
index 0000000..b7d85b3
--- /dev/null
+++ b/crates/pkcs8/cargo2android_viz.bp
@@ -0,0 +1,6 @@
+visibility: [
+     "//external/rust/crates/pkcs1:__subpackages__",
+     "//external/rust/crates/sec1:__subpackages__",
+     "//packages/modules/Virtualization:__subpackages__",
+     "//system/keymint:__subpackages__",
+]
diff --git a/crates/pkcs8/cargo_embargo.json b/crates/pkcs8/cargo_embargo.json
new file mode 100644
index 0000000..ca82c51
--- /dev/null
+++ b/crates/pkcs8/cargo_embargo.json
@@ -0,0 +1,34 @@
+{
+  "apex_available": [
+    "//apex_available:platform",
+    "com.android.virt"
+  ],
+  "features": [
+    "alloc"
+  ],
+  "run_cargo": false,
+  "variants": [
+    {
+      "package": {
+        "pkcs8": {
+          "add_module_block": "cargo2android_viz.bp"
+        }
+      }
+    },
+    {
+      "module_name_overrides": {
+        "libder": "libder_nostd",
+        "libpkcs8": "libpkcs8_nostd",
+        "libspki": "libspki_nostd"
+      },
+      "package": {
+        "pkcs8": {
+          "add_module_block": "cargo2android_viz.bp",
+          "force_rlib": true,
+          "host_supported": false,
+          "no_std": true
+        }
+      }
+    }
+  ]
+}
diff --git a/crates/pkcs8/patches/rules.mk.diff b/crates/pkcs8/patches/rules.mk.diff
new file mode 100644
index 0000000..e489493
--- /dev/null
+++ b/crates/pkcs8/patches/rules.mk.diff
@@ -0,0 +1,14 @@
+diff --git b/rules.mk a/rules.mk
+index c7476cb..0257d05 100644
+--- b/rules.mk
++++ a/rules.mk
+@@ -13,9 +13,6 @@ MODULE_RUSTFLAGS += \
+ 
+ MODULE_LIBRARY_DEPS := \
+ 	external/rust/crates/der \
+-	external/rust/crates/pkcs5 \
+-	external/rust/crates/rand_core \
+ 	external/rust/crates/spki \
+-	external/rust/crates/subtle \
+ 
+ include make/library.mk
diff --git a/crates/pkcs8/patches/std.diff b/crates/pkcs8/patches/std.diff
new file mode 100644
index 0000000..6a318cb
--- /dev/null
+++ b/crates/pkcs8/patches/std.diff
@@ -0,0 +1,15 @@
+diff --git a/src/lib.rs b/src/lib.rs
+index 1d2dfa2..9fcae3a 100644
+--- a/src/lib.rs
++++ b/src/lib.rs
+@@ -64,6 +64,10 @@
+ //! [PKCS#5v2 Password Based Encryption Scheme 2 (RFC 8018)]: https://tools.ietf.org/html/rfc8018#section-6.2
+ //! [scrypt]: https://en.wikipedia.org/wiki/Scrypt
+ 
++/// Local Android change: Use std to allow building as a dylib.
++#[cfg(android_dylib)]
++extern crate std;
++
+ #[cfg(feature = "pem")]
+ extern crate alloc;
+ #[cfg(feature = "std")]
diff --git a/crates/pkcs8/src/encrypted_private_key_info.rs b/crates/pkcs8/src/encrypted_private_key_info.rs
new file mode 100644
index 0000000..d55949c
--- /dev/null
+++ b/crates/pkcs8/src/encrypted_private_key_info.rs
@@ -0,0 +1,165 @@
+//! PKCS#8 `EncryptedPrivateKeyInfo`
+
+use crate::{Error, Result};
+use core::fmt;
+use der::{
+    asn1::OctetStringRef, Decode, DecodeValue, Encode, EncodeValue, Header, Length, Reader,
+    Sequence, Writer,
+};
+use pkcs5::EncryptionScheme;
+
+#[cfg(feature = "alloc")]
+use der::SecretDocument;
+
+#[cfg(feature = "encryption")]
+use {
+    pkcs5::pbes2,
+    rand_core::{CryptoRng, RngCore},
+};
+
+#[cfg(feature = "pem")]
+use der::pem::PemLabel;
+
+/// PKCS#8 `EncryptedPrivateKeyInfo`.
+///
+/// ASN.1 structure containing a PKCS#5 [`EncryptionScheme`] identifier for a
+/// password-based symmetric encryption scheme and encrypted private key data.
+///
+/// ## Schema
+/// Structure described in [RFC 5208 Section 6]:
+///
+/// ```text
+/// EncryptedPrivateKeyInfo ::= SEQUENCE {
+///   encryptionAlgorithm  EncryptionAlgorithmIdentifier,
+///   encryptedData        EncryptedData }
+///
+/// EncryptionAlgorithmIdentifier ::= AlgorithmIdentifier
+///
+/// EncryptedData ::= OCTET STRING
+/// ```
+///
+/// [RFC 5208 Section 6]: https://tools.ietf.org/html/rfc5208#section-6
+#[derive(Clone, Eq, PartialEq)]
+pub struct EncryptedPrivateKeyInfo<'a> {
+    /// Algorithm identifier describing a password-based symmetric encryption
+    /// scheme used to encrypt the `encrypted_data` field.
+    pub encryption_algorithm: EncryptionScheme<'a>,
+
+    /// Private key data
+    pub encrypted_data: &'a [u8],
+}
+
+impl<'a> EncryptedPrivateKeyInfo<'a> {
+    /// Attempt to decrypt this encrypted private key using the provided
+    /// password to derive an encryption key.
+    #[cfg(feature = "encryption")]
+    pub fn decrypt(&self, password: impl AsRef<[u8]>) -> Result<SecretDocument> {
+        Ok(self
+            .encryption_algorithm
+            .decrypt(password, self.encrypted_data)?
+            .try_into()?)
+    }
+
+    /// Encrypt the given ASN.1 DER document using a symmetric encryption key
+    /// derived from the provided password.
+    #[cfg(feature = "encryption")]
+    pub(crate) fn encrypt(
+        mut rng: impl CryptoRng + RngCore,
+        password: impl AsRef<[u8]>,
+        doc: &[u8],
+    ) -> Result<SecretDocument> {
+        let mut salt = [0u8; 16];
+        rng.fill_bytes(&mut salt);
+
+        let mut iv = [0u8; 16];
+        rng.fill_bytes(&mut iv);
+
+        let pbes2_params = pbes2::Parameters::scrypt_aes256cbc(Default::default(), &salt, &iv)?;
+        EncryptedPrivateKeyInfo::encrypt_with(pbes2_params, password, doc)
+    }
+
+    /// Encrypt this private key using a symmetric encryption key derived
+    /// from the provided password and [`pbes2::Parameters`].
+    #[cfg(feature = "encryption")]
+    pub(crate) fn encrypt_with(
+        pbes2_params: pbes2::Parameters<'a>,
+        password: impl AsRef<[u8]>,
+        doc: &[u8],
+    ) -> Result<SecretDocument> {
+        let encrypted_data = pbes2_params.encrypt(password, doc)?;
+
+        EncryptedPrivateKeyInfo {
+            encryption_algorithm: pbes2_params.into(),
+            encrypted_data: &encrypted_data,
+        }
+        .try_into()
+    }
+}
+
+impl<'a> DecodeValue<'a> for EncryptedPrivateKeyInfo<'a> {
+    fn decode_value<R: Reader<'a>>(
+        reader: &mut R,
+        header: Header,
+    ) -> der::Result<EncryptedPrivateKeyInfo<'a>> {
+        reader.read_nested(header.length, |reader| {
+            Ok(Self {
+                encryption_algorithm: reader.decode()?,
+                encrypted_data: OctetStringRef::decode(reader)?.as_bytes(),
+            })
+        })
+    }
+}
+
+impl EncodeValue for EncryptedPrivateKeyInfo<'_> {
+    fn value_len(&self) -> der::Result<Length> {
+        self.encryption_algorithm.encoded_len()?
+            + OctetStringRef::new(self.encrypted_data)?.encoded_len()?
+    }
+
+    fn encode_value(&self, writer: &mut impl Writer) -> der::Result<()> {
+        self.encryption_algorithm.encode(writer)?;
+        OctetStringRef::new(self.encrypted_data)?.encode(writer)?;
+        Ok(())
+    }
+}
+
+impl<'a> Sequence<'a> for EncryptedPrivateKeyInfo<'a> {}
+
+impl<'a> TryFrom<&'a [u8]> for EncryptedPrivateKeyInfo<'a> {
+    type Error = Error;
+
+    fn try_from(bytes: &'a [u8]) -> Result<Self> {
+        Ok(Self::from_der(bytes)?)
+    }
+}
+
+impl<'a> fmt::Debug for EncryptedPrivateKeyInfo<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("EncryptedPrivateKeyInfo")
+            .field("encryption_algorithm", &self.encryption_algorithm)
+            .finish_non_exhaustive()
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl TryFrom<EncryptedPrivateKeyInfo<'_>> for SecretDocument {
+    type Error = Error;
+
+    fn try_from(encrypted_private_key: EncryptedPrivateKeyInfo<'_>) -> Result<SecretDocument> {
+        SecretDocument::try_from(&encrypted_private_key)
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl TryFrom<&EncryptedPrivateKeyInfo<'_>> for SecretDocument {
+    type Error = Error;
+
+    fn try_from(encrypted_private_key: &EncryptedPrivateKeyInfo<'_>) -> Result<SecretDocument> {
+        Ok(Self::encode_msg(encrypted_private_key)?)
+    }
+}
+
+#[cfg(feature = "pem")]
+impl PemLabel for EncryptedPrivateKeyInfo<'_> {
+    const PEM_LABEL: &'static str = "ENCRYPTED PRIVATE KEY";
+}
diff --git a/crates/pkcs8/src/error.rs b/crates/pkcs8/src/error.rs
new file mode 100644
index 0000000..70c60ae
--- /dev/null
+++ b/crates/pkcs8/src/error.rs
@@ -0,0 +1,93 @@
+//! Error types
+
+use core::fmt;
+
+#[cfg(feature = "pem")]
+use der::pem;
+
+/// Result type
+pub type Result<T> = core::result::Result<T, Error>;
+
+/// Error type
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[non_exhaustive]
+pub enum Error {
+    /// ASN.1 DER-related errors.
+    Asn1(der::Error),
+
+    /// Errors relating to PKCS#5-encrypted keys.
+    #[cfg(feature = "pkcs5")]
+    EncryptedPrivateKey(pkcs5::Error),
+
+    /// Malformed cryptographic key contained in a PKCS#8 document.
+    ///
+    /// This is intended for relaying errors related to the raw data contained
+    /// within [`PrivateKeyInfo::private_key`][`crate::PrivateKeyInfo::private_key`]
+    /// or [`SubjectPublicKeyInfo::subject_public_key`][`crate::SubjectPublicKeyInfo::subject_public_key`].
+    KeyMalformed,
+
+    /// [`AlgorithmIdentifier::parameters`][`crate::AlgorithmIdentifierRef::parameters`]
+    /// is malformed or otherwise encoded in an unexpected manner.
+    ParametersMalformed,
+
+    /// Public key errors propagated from the [`spki::Error`] type.
+    PublicKey(spki::Error),
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Error::Asn1(err) => write!(f, "PKCS#8 ASN.1 error: {}", err),
+            #[cfg(feature = "pkcs5")]
+            Error::EncryptedPrivateKey(err) => write!(f, "{}", err),
+            Error::KeyMalformed => f.write_str("PKCS#8 cryptographic key data malformed"),
+            Error::ParametersMalformed => f.write_str("PKCS#8 algorithm parameters malformed"),
+            Error::PublicKey(err) => write!(f, "public key error: {}", err),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for Error {}
+
+impl From<der::Error> for Error {
+    fn from(err: der::Error) -> Error {
+        Error::Asn1(err)
+    }
+}
+
+impl From<der::ErrorKind> for Error {
+    fn from(err: der::ErrorKind) -> Error {
+        Error::Asn1(err.into())
+    }
+}
+
+#[cfg(feature = "pem")]
+impl From<pem::Error> for Error {
+    fn from(err: pem::Error) -> Error {
+        der::Error::from(err).into()
+    }
+}
+
+#[cfg(feature = "pkcs5")]
+impl From<pkcs5::Error> for Error {
+    fn from(err: pkcs5::Error) -> Error {
+        Error::EncryptedPrivateKey(err)
+    }
+}
+
+impl From<spki::Error> for Error {
+    fn from(err: spki::Error) -> Error {
+        Error::PublicKey(err)
+    }
+}
+
+impl From<Error> for spki::Error {
+    fn from(err: Error) -> spki::Error {
+        match err {
+            Error::Asn1(e) => spki::Error::Asn1(e),
+            Error::PublicKey(e) => e,
+            _ => spki::Error::KeyMalformed,
+        }
+    }
+}
diff --git a/crates/pkcs8/src/lib.rs b/crates/pkcs8/src/lib.rs
new file mode 100644
index 0000000..53730d4
--- /dev/null
+++ b/crates/pkcs8/src/lib.rs
@@ -0,0 +1,115 @@
+#![no_std]
+#![cfg_attr(docsrs, feature(doc_auto_cfg))]
+#![doc = include_str!("../README.md")]
+#![doc(
+    html_logo_url = "https://raw.githubusercontent.com/RustCrypto/media/6ee8e381/logo.svg",
+    html_favicon_url = "https://raw.githubusercontent.com/RustCrypto/media/6ee8e381/logo.svg"
+)]
+#![forbid(unsafe_code)]
+#![warn(
+    clippy::mod_module_files,
+    clippy::unwrap_used,
+    missing_docs,
+    rust_2018_idioms,
+    unused_lifetimes,
+    unused_qualifications
+)]
+
+//! ## About this crate
+//! This library provides generalized PKCS#8 support designed to work with a
+//! number of different algorithms. It supports `no_std` platforms including
+//! ones without a heap (albeit with reduced functionality).
+//!
+//! It supports decoding/encoding the following types:
+//!
+//! - [`EncryptedPrivateKeyInfo`]: (with `pkcs5` feature) encrypted key.
+//! - [`PrivateKeyInfo`]: algorithm identifier and data representing a private key.
+//!   Optionally also includes public key data for asymmetric keys.
+//! - [`SubjectPublicKeyInfo`]: algorithm identifier and data representing a public key
+//!   (re-exported from the [`spki`] crate)
+//!
+//! When the `pem` feature is enabled, it also supports decoding/encoding
+//! documents from "PEM encoding" format as defined in RFC 7468.
+//!
+//! ## Encrypted Private Key Support
+//! [`EncryptedPrivateKeyInfo`] supports decoding/encoding encrypted PKCS#8
+//! private keys and is gated under the `pkcs5` feature.
+//!
+//! When the `encryption` feature of this crate is enabled, it provides
+//! [`EncryptedPrivateKeyInfo::decrypt`] and [`PrivateKeyInfo::encrypt`]
+//! functions which are able to decrypt/encrypt keys using the following
+//! algorithms:
+//!
+//! - [PKCS#5v2 Password Based Encryption Scheme 2 (RFC 8018)]
+//!   - Key derivation functions:
+//!     - [scrypt] ([RFC 7914])
+//!     - PBKDF2 ([RFC 8018](https://datatracker.ietf.org/doc/html/rfc8018#section-5.2))
+//!       - SHA-2 based PRF with HMAC-SHA224, HMAC-SHA256, HMAC-SHA384, or HMAC-SHA512
+//!       - SHA-1 based PRF with HMAC-SHA1, when the `sha1` feature of this crate is enabled.
+//!   - Symmetric encryption: AES-128-CBC, AES-192-CBC, or AES-256-CBC
+//!     (best available options for PKCS#5v2)
+//!  
+//! ## Legacy DES-CBC and DES-EDE3-CBC (3DES) support (optional)
+//! When the `des-insecure` and/or `3des` features are enabled this crate provides support for
+//! private keys encrypted with with DES-CBC and DES-EDE3-CBC (3DES or Triple DES) symmetric
+//! encryption, respectively.
+//!
+//! ⚠️ WARNING ⚠️
+//!
+//! DES support (gated behind the `des-insecure` feature) is implemented to
+//! allow for decryption of legacy PKCS#8 files only.
+//!
+//! Such PKCS#8 documents should be considered *INSECURE* due to the short
+//! 56-bit key size of DES.
+//!
+//! New keys should use AES instead.
+//!
+//! [RFC 5208]: https://tools.ietf.org/html/rfc5208
+//! [RFC 5958]: https://tools.ietf.org/html/rfc5958
+//! [RFC 7914]: https://datatracker.ietf.org/doc/html/rfc7914
+//! [PKCS#5v2 Password Based Encryption Scheme 2 (RFC 8018)]: https://tools.ietf.org/html/rfc8018#section-6.2
+//! [scrypt]: https://en.wikipedia.org/wiki/Scrypt
+
+/// Local Android change: Use std to allow building as a dylib.
+#[cfg(android_dylib)]
+extern crate std;
+
+#[cfg(feature = "pem")]
+extern crate alloc;
+#[cfg(feature = "std")]
+extern crate std;
+
+mod error;
+mod private_key_info;
+mod traits;
+mod version;
+
+#[cfg(feature = "pkcs5")]
+pub(crate) mod encrypted_private_key_info;
+
+pub use crate::{
+    error::{Error, Result},
+    private_key_info::PrivateKeyInfo,
+    traits::DecodePrivateKey,
+    version::Version,
+};
+pub use der::{self, asn1::ObjectIdentifier, oid::AssociatedOid};
+pub use spki::{
+    self, AlgorithmIdentifierRef, DecodePublicKey, SubjectPublicKeyInfo, SubjectPublicKeyInfoRef,
+};
+
+#[cfg(feature = "alloc")]
+pub use {
+    crate::traits::EncodePrivateKey,
+    der::{Document, SecretDocument},
+    spki::EncodePublicKey,
+};
+
+#[cfg(feature = "pem")]
+pub use der::pem::LineEnding;
+
+#[cfg(feature = "pkcs5")]
+pub use {encrypted_private_key_info::EncryptedPrivateKeyInfo, pkcs5};
+
+#[cfg(feature = "rand_core")]
+pub use rand_core;
diff --git a/crates/pkcs8/src/private_key_info.rs b/crates/pkcs8/src/private_key_info.rs
new file mode 100644
index 0000000..ecae624
--- /dev/null
+++ b/crates/pkcs8/src/private_key_info.rs
@@ -0,0 +1,295 @@
+//! PKCS#8 `PrivateKeyInfo`.
+
+use crate::{AlgorithmIdentifierRef, Error, Result, Version};
+use core::fmt;
+use der::{
+    asn1::{AnyRef, BitStringRef, ContextSpecific, OctetStringRef},
+    Decode, DecodeValue, Encode, EncodeValue, Header, Length, Reader, Sequence, TagMode, TagNumber,
+    Writer,
+};
+
+#[cfg(feature = "alloc")]
+use der::SecretDocument;
+
+#[cfg(feature = "encryption")]
+use {
+    crate::EncryptedPrivateKeyInfo,
+    der::zeroize::Zeroizing,
+    pkcs5::pbes2,
+    rand_core::{CryptoRng, RngCore},
+};
+
+#[cfg(feature = "pem")]
+use der::pem::PemLabel;
+
+#[cfg(feature = "subtle")]
+use subtle::{Choice, ConstantTimeEq};
+
+/// Context-specific tag number for the public key.
+const PUBLIC_KEY_TAG: TagNumber = TagNumber::N1;
+
+/// PKCS#8 `PrivateKeyInfo`.
+///
+/// ASN.1 structure containing an `AlgorithmIdentifier`, private key
+/// data in an algorithm specific format, and optional attributes
+/// (ignored by this implementation).
+///
+/// Supports PKCS#8 v1 as described in [RFC 5208] and PKCS#8 v2 as described
+/// in [RFC 5958]. PKCS#8 v2 keys include an additional public key field.
+///
+/// # PKCS#8 v1 `PrivateKeyInfo`
+///
+/// Described in [RFC 5208 Section 5]:
+///
+/// ```text
+/// PrivateKeyInfo ::= SEQUENCE {
+///         version                   Version,
+///         privateKeyAlgorithm       PrivateKeyAlgorithmIdentifier,
+///         privateKey                PrivateKey,
+///         attributes           [0]  IMPLICIT Attributes OPTIONAL }
+///
+/// Version ::= INTEGER
+///
+/// PrivateKeyAlgorithmIdentifier ::= AlgorithmIdentifier
+///
+/// PrivateKey ::= OCTET STRING
+///
+/// Attributes ::= SET OF Attribute
+/// ```
+///
+/// # PKCS#8 v2 `OneAsymmetricKey`
+///
+/// PKCS#8 `OneAsymmetricKey` as described in [RFC 5958 Section 2]:
+///
+/// ```text
+/// PrivateKeyInfo ::= OneAsymmetricKey
+///
+/// OneAsymmetricKey ::= SEQUENCE {
+///     version                   Version,
+///     privateKeyAlgorithm       PrivateKeyAlgorithmIdentifier,
+///     privateKey                PrivateKey,
+///     attributes            [0] Attributes OPTIONAL,
+///     ...,
+///     [[2: publicKey        [1] PublicKey OPTIONAL ]],
+///     ...
+///   }
+///
+/// Version ::= INTEGER { v1(0), v2(1) } (v1, ..., v2)
+///
+/// PrivateKeyAlgorithmIdentifier ::= AlgorithmIdentifier
+///
+/// PrivateKey ::= OCTET STRING
+///
+/// Attributes ::= SET OF Attribute
+///
+/// PublicKey ::= BIT STRING
+/// ```
+///
+/// [RFC 5208]: https://tools.ietf.org/html/rfc5208
+/// [RFC 5958]: https://datatracker.ietf.org/doc/html/rfc5958
+/// [RFC 5208 Section 5]: https://tools.ietf.org/html/rfc5208#section-5
+/// [RFC 5958 Section 2]: https://datatracker.ietf.org/doc/html/rfc5958#section-2
+#[derive(Clone)]
+pub struct PrivateKeyInfo<'a> {
+    /// X.509 `AlgorithmIdentifier` for the private key type.
+    pub algorithm: AlgorithmIdentifierRef<'a>,
+
+    /// Private key data.
+    pub private_key: &'a [u8],
+
+    /// Public key data, optionally available if version is V2.
+    pub public_key: Option<&'a [u8]>,
+}
+
+impl<'a> PrivateKeyInfo<'a> {
+    /// Create a new PKCS#8 [`PrivateKeyInfo`] message.
+    ///
+    /// This is a helper method which initializes `attributes` and `public_key`
+    /// to `None`, helpful if you aren't using those.
+    pub fn new(algorithm: AlgorithmIdentifierRef<'a>, private_key: &'a [u8]) -> Self {
+        Self {
+            algorithm,
+            private_key,
+            public_key: None,
+        }
+    }
+
+    /// Get the PKCS#8 [`Version`] for this structure.
+    ///
+    /// [`Version::V1`] if `public_key` is `None`, [`Version::V2`] if `Some`.
+    pub fn version(&self) -> Version {
+        if self.public_key.is_some() {
+            Version::V2
+        } else {
+            Version::V1
+        }
+    }
+
+    /// Encrypt this private key using a symmetric encryption key derived
+    /// from the provided password.
+    ///
+    /// Uses the following algorithms for encryption:
+    /// - PBKDF: scrypt with default parameters:
+    ///   - log₂(N): 15
+    ///   - r: 8
+    ///   - p: 1
+    /// - Cipher: AES-256-CBC (best available option for PKCS#5 encryption)
+    #[cfg(feature = "encryption")]
+    pub fn encrypt(
+        &self,
+        rng: impl CryptoRng + RngCore,
+        password: impl AsRef<[u8]>,
+    ) -> Result<SecretDocument> {
+        let der = Zeroizing::new(self.to_der()?);
+        EncryptedPrivateKeyInfo::encrypt(rng, password, der.as_ref())
+    }
+
+    /// Encrypt this private key using a symmetric encryption key derived
+    /// from the provided password and [`pbes2::Parameters`].
+    #[cfg(feature = "encryption")]
+    pub fn encrypt_with_params(
+        &self,
+        pbes2_params: pbes2::Parameters<'_>,
+        password: impl AsRef<[u8]>,
+    ) -> Result<SecretDocument> {
+        let der = Zeroizing::new(self.to_der()?);
+        EncryptedPrivateKeyInfo::encrypt_with(pbes2_params, password, der.as_ref())
+    }
+
+    /// Get a `BIT STRING` representation of the public key, if present.
+    fn public_key_bit_string(&self) -> der::Result<Option<ContextSpecific<BitStringRef<'a>>>> {
+        self.public_key
+            .map(|pk| {
+                BitStringRef::from_bytes(pk).map(|value| ContextSpecific {
+                    tag_number: PUBLIC_KEY_TAG,
+                    tag_mode: TagMode::Implicit,
+                    value,
+                })
+            })
+            .transpose()
+    }
+}
+
+impl<'a> DecodeValue<'a> for PrivateKeyInfo<'a> {
+    fn decode_value<R: Reader<'a>>(
+        reader: &mut R,
+        header: Header,
+    ) -> der::Result<PrivateKeyInfo<'a>> {
+        reader.read_nested(header.length, |reader| {
+            // Parse and validate `version` INTEGER.
+            let version = Version::decode(reader)?;
+            let algorithm = reader.decode()?;
+            let private_key = OctetStringRef::decode(reader)?.into();
+            let public_key = reader
+                .context_specific::<BitStringRef<'_>>(PUBLIC_KEY_TAG, TagMode::Implicit)?
+                .map(|bs| {
+                    bs.as_bytes()
+                        .ok_or_else(|| der::Tag::BitString.value_error())
+                })
+                .transpose()?;
+
+            if version.has_public_key() != public_key.is_some() {
+                return Err(reader.error(
+                    der::Tag::ContextSpecific {
+                        constructed: true,
+                        number: PUBLIC_KEY_TAG,
+                    }
+                    .value_error()
+                    .kind(),
+                ));
+            }
+
+            // Ignore any remaining extension fields
+            while !reader.is_finished() {
+                reader.decode::<ContextSpecific<AnyRef<'_>>>()?;
+            }
+
+            Ok(Self {
+                algorithm,
+                private_key,
+                public_key,
+            })
+        })
+    }
+}
+
+impl EncodeValue for PrivateKeyInfo<'_> {
+    fn value_len(&self) -> der::Result<Length> {
+        self.version().encoded_len()?
+            + self.algorithm.encoded_len()?
+            + OctetStringRef::new(self.private_key)?.encoded_len()?
+            + self.public_key_bit_string()?.encoded_len()?
+    }
+
+    fn encode_value(&self, writer: &mut impl Writer) -> der::Result<()> {
+        self.version().encode(writer)?;
+        self.algorithm.encode(writer)?;
+        OctetStringRef::new(self.private_key)?.encode(writer)?;
+        self.public_key_bit_string()?.encode(writer)?;
+        Ok(())
+    }
+}
+
+impl<'a> Sequence<'a> for PrivateKeyInfo<'a> {}
+
+impl<'a> TryFrom<&'a [u8]> for PrivateKeyInfo<'a> {
+    type Error = Error;
+
+    fn try_from(bytes: &'a [u8]) -> Result<Self> {
+        Ok(Self::from_der(bytes)?)
+    }
+}
+
+impl<'a> fmt::Debug for PrivateKeyInfo<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("PrivateKeyInfo")
+            .field("version", &self.version())
+            .field("algorithm", &self.algorithm)
+            .field("public_key", &self.public_key)
+            .finish_non_exhaustive()
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl TryFrom<PrivateKeyInfo<'_>> for SecretDocument {
+    type Error = Error;
+
+    fn try_from(private_key: PrivateKeyInfo<'_>) -> Result<SecretDocument> {
+        SecretDocument::try_from(&private_key)
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl TryFrom<&PrivateKeyInfo<'_>> for SecretDocument {
+    type Error = Error;
+
+    fn try_from(private_key: &PrivateKeyInfo<'_>) -> Result<SecretDocument> {
+        Ok(Self::encode_msg(private_key)?)
+    }
+}
+
+#[cfg(feature = "pem")]
+impl PemLabel for PrivateKeyInfo<'_> {
+    const PEM_LABEL: &'static str = "PRIVATE KEY";
+}
+
+#[cfg(feature = "subtle")]
+impl<'a> ConstantTimeEq for PrivateKeyInfo<'a> {
+    fn ct_eq(&self, other: &Self) -> Choice {
+        // NOTE: public fields are not compared in constant time
+        let public_fields_eq =
+            self.algorithm == other.algorithm && self.public_key == other.public_key;
+
+        self.private_key.ct_eq(other.private_key) & Choice::from(public_fields_eq as u8)
+    }
+}
+
+#[cfg(feature = "subtle")]
+impl<'a> Eq for PrivateKeyInfo<'a> {}
+
+#[cfg(feature = "subtle")]
+impl<'a> PartialEq for PrivateKeyInfo<'a> {
+    fn eq(&self, other: &Self) -> bool {
+        self.ct_eq(other).into()
+    }
+}
diff --git a/crates/pkcs8/src/traits.rs b/crates/pkcs8/src/traits.rs
new file mode 100644
index 0000000..b4f80b2
--- /dev/null
+++ b/crates/pkcs8/src/traits.rs
@@ -0,0 +1,140 @@
+//! Traits for parsing objects from PKCS#8 encoded documents
+
+use crate::{Error, PrivateKeyInfo, Result};
+
+#[cfg(feature = "alloc")]
+use der::SecretDocument;
+
+#[cfg(feature = "encryption")]
+use {
+    crate::EncryptedPrivateKeyInfo,
+    rand_core::{CryptoRng, RngCore},
+};
+
+#[cfg(feature = "pem")]
+use {crate::LineEnding, alloc::string::String, der::zeroize::Zeroizing};
+
+#[cfg(feature = "pem")]
+use der::pem::PemLabel;
+
+#[cfg(feature = "std")]
+use std::path::Path;
+
+/// Parse a private key object from a PKCS#8 encoded document.
+pub trait DecodePrivateKey: Sized {
+    /// Deserialize PKCS#8 private key from ASN.1 DER-encoded data
+    /// (binary format).
+    fn from_pkcs8_der(bytes: &[u8]) -> Result<Self>;
+
+    /// Deserialize encrypted PKCS#8 private key from ASN.1 DER-encoded data
+    /// (binary format) and attempt to decrypt it using the provided password.
+    #[cfg(feature = "encryption")]
+    fn from_pkcs8_encrypted_der(bytes: &[u8], password: impl AsRef<[u8]>) -> Result<Self> {
+        let doc = EncryptedPrivateKeyInfo::try_from(bytes)?.decrypt(password)?;
+        Self::from_pkcs8_der(doc.as_bytes())
+    }
+
+    /// Deserialize PKCS#8-encoded private key from PEM.
+    ///
+    /// Keys in this format begin with the following delimiter:
+    ///
+    /// ```text
+    /// -----BEGIN PRIVATE KEY-----
+    /// ```
+    #[cfg(feature = "pem")]
+    fn from_pkcs8_pem(s: &str) -> Result<Self> {
+        let (label, doc) = SecretDocument::from_pem(s)?;
+        PrivateKeyInfo::validate_pem_label(label)?;
+        Self::from_pkcs8_der(doc.as_bytes())
+    }
+
+    /// Deserialize encrypted PKCS#8-encoded private key from PEM and attempt
+    /// to decrypt it using the provided password.
+    ///
+    /// Keys in this format begin with the following delimiter:
+    ///
+    /// ```text
+    /// -----BEGIN ENCRYPTED PRIVATE KEY-----
+    /// ```
+    #[cfg(all(feature = "encryption", feature = "pem"))]
+    fn from_pkcs8_encrypted_pem(s: &str, password: impl AsRef<[u8]>) -> Result<Self> {
+        let (label, doc) = SecretDocument::from_pem(s)?;
+        EncryptedPrivateKeyInfo::validate_pem_label(label)?;
+        Self::from_pkcs8_encrypted_der(doc.as_bytes(), password)
+    }
+
+    /// Load PKCS#8 private key from an ASN.1 DER-encoded file on the local
+    /// filesystem (binary format).
+    #[cfg(feature = "std")]
+    fn read_pkcs8_der_file(path: impl AsRef<Path>) -> Result<Self> {
+        Self::from_pkcs8_der(SecretDocument::read_der_file(path)?.as_bytes())
+    }
+
+    /// Load PKCS#8 private key from a PEM-encoded file on the local filesystem.
+    #[cfg(all(feature = "pem", feature = "std"))]
+    fn read_pkcs8_pem_file(path: impl AsRef<Path>) -> Result<Self> {
+        let (label, doc) = SecretDocument::read_pem_file(path)?;
+        PrivateKeyInfo::validate_pem_label(&label)?;
+        Self::from_pkcs8_der(doc.as_bytes())
+    }
+}
+
+impl<T> DecodePrivateKey for T
+where
+    T: for<'a> TryFrom<PrivateKeyInfo<'a>, Error = Error>,
+{
+    fn from_pkcs8_der(bytes: &[u8]) -> Result<Self> {
+        Self::try_from(PrivateKeyInfo::try_from(bytes)?)
+    }
+}
+
+/// Serialize a private key object to a PKCS#8 encoded document.
+#[cfg(feature = "alloc")]
+pub trait EncodePrivateKey {
+    /// Serialize a [`SecretDocument`] containing a PKCS#8-encoded private key.
+    fn to_pkcs8_der(&self) -> Result<SecretDocument>;
+
+    /// Create an [`SecretDocument`] containing the ciphertext of
+    /// a PKCS#8 encoded private key encrypted under the given `password`.
+    #[cfg(feature = "encryption")]
+    fn to_pkcs8_encrypted_der(
+        &self,
+        rng: impl CryptoRng + RngCore,
+        password: impl AsRef<[u8]>,
+    ) -> Result<SecretDocument> {
+        EncryptedPrivateKeyInfo::encrypt(rng, password, self.to_pkcs8_der()?.as_bytes())
+    }
+
+    /// Serialize this private key as PEM-encoded PKCS#8 with the given [`LineEnding`].
+    #[cfg(feature = "pem")]
+    fn to_pkcs8_pem(&self, line_ending: LineEnding) -> Result<Zeroizing<String>> {
+        let doc = self.to_pkcs8_der()?;
+        Ok(doc.to_pem(PrivateKeyInfo::PEM_LABEL, line_ending)?)
+    }
+
+    /// Serialize this private key as an encrypted PEM-encoded PKCS#8 private
+    /// key using the `provided` to derive an encryption key.
+    #[cfg(all(feature = "encryption", feature = "pem"))]
+    fn to_pkcs8_encrypted_pem(
+        &self,
+        rng: impl CryptoRng + RngCore,
+        password: impl AsRef<[u8]>,
+        line_ending: LineEnding,
+    ) -> Result<Zeroizing<String>> {
+        let doc = self.to_pkcs8_encrypted_der(rng, password)?;
+        Ok(doc.to_pem(EncryptedPrivateKeyInfo::PEM_LABEL, line_ending)?)
+    }
+
+    /// Write ASN.1 DER-encoded PKCS#8 private key to the given path
+    #[cfg(feature = "std")]
+    fn write_pkcs8_der_file(&self, path: impl AsRef<Path>) -> Result<()> {
+        Ok(self.to_pkcs8_der()?.write_der_file(path)?)
+    }
+
+    /// Write ASN.1 DER-encoded PKCS#8 private key to the given path
+    #[cfg(all(feature = "pem", feature = "std"))]
+    fn write_pkcs8_pem_file(&self, path: impl AsRef<Path>, line_ending: LineEnding) -> Result<()> {
+        let doc = self.to_pkcs8_der()?;
+        Ok(doc.write_pem_file(path, PrivateKeyInfo::PEM_LABEL, line_ending)?)
+    }
+}
diff --git a/crates/pkcs8/src/version.rs b/crates/pkcs8/src/version.rs
new file mode 100644
index 0000000..0ca80bc
--- /dev/null
+++ b/crates/pkcs8/src/version.rs
@@ -0,0 +1,63 @@
+//! PKCS#8 version identifier.
+
+use crate::Error;
+use der::{Decode, Encode, FixedTag, Reader, Tag, Writer};
+
+/// Version identifier for PKCS#8 documents.
+///
+/// (RFC 5958 designates `0` and `1` as the only valid versions for PKCS#8 documents)
+#[derive(Clone, Debug, Copy, PartialEq, Eq)]
+pub enum Version {
+    /// Denotes PKCS#8 v1: no public key field.
+    V1 = 0,
+
+    /// Denotes PKCS#8 v2: `OneAsymmetricKey` with public key field.
+    V2 = 1,
+}
+
+impl Version {
+    /// Is this version expected to have a public key?
+    pub fn has_public_key(self) -> bool {
+        match self {
+            Version::V1 => false,
+            Version::V2 => true,
+        }
+    }
+}
+
+impl<'a> Decode<'a> for Version {
+    fn decode<R: Reader<'a>>(decoder: &mut R) -> der::Result<Self> {
+        Version::try_from(u8::decode(decoder)?).map_err(|_| Self::TAG.value_error())
+    }
+}
+
+impl Encode for Version {
+    fn encoded_len(&self) -> der::Result<der::Length> {
+        der::Length::from(1u8).for_tlv()
+    }
+
+    fn encode(&self, writer: &mut impl Writer) -> der::Result<()> {
+        u8::from(*self).encode(writer)
+    }
+}
+
+impl From<Version> for u8 {
+    fn from(version: Version) -> Self {
+        version as u8
+    }
+}
+
+impl TryFrom<u8> for Version {
+    type Error = Error;
+    fn try_from(byte: u8) -> Result<Version, Error> {
+        match byte {
+            0 => Ok(Version::V1),
+            1 => Ok(Version::V2),
+            _ => Err(Self::TAG.value_error().into()),
+        }
+    }
+}
+
+impl FixedTag for Version {
+    const TAG: Tag = Tag::Integer;
+}
diff --git a/crates/pkcs8/tests/encrypted_private_key.rs b/crates/pkcs8/tests/encrypted_private_key.rs
new file mode 100644
index 0000000..dbe0a18
--- /dev/null
+++ b/crates/pkcs8/tests/encrypted_private_key.rs
@@ -0,0 +1,234 @@
+//! Encrypted PKCS#8 private key tests.
+
+#![cfg(feature = "pkcs5")]
+
+use hex_literal::hex;
+use pkcs8::{pkcs5::pbes2, EncryptedPrivateKeyInfo, PrivateKeyInfo};
+
+#[cfg(feature = "alloc")]
+use der::Encode;
+
+#[cfg(feature = "pem")]
+use der::EncodePem;
+
+/// Ed25519 PKCS#8 private key plaintext encoded as ASN.1 DER
+#[cfg(feature = "encryption")]
+const ED25519_DER_PLAINTEXT_EXAMPLE: &[u8] = include_bytes!("examples/ed25519-priv-pkcs8v1.der");
+
+/// Ed25519 PKCS#8 encrypted private key (PBES2 + AES-128-CBC + PBKDF2-SHA1) encoded as ASN.1 DER.
+///
+/// Generated using:
+///
+/// ```
+/// $ openssl pkcs8 -v2 aes256-cbc -v2prf hmacWithSHA1 -topk8 -inform der -in ed25519-priv.der -outform der -out ed25519-encpriv-aes128-pbkdf2-sha1.der
+/// ```
+const ED25519_DER_AES128_PBKDF2_SHA1_EXAMPLE: &[u8] =
+    include_bytes!("examples/ed25519-encpriv-aes128-pbkdf2-sha1.der");
+
+/// Ed25519 PKCS#8 encrypted private key (PBES2 + AES-256-CBC + PBKDF2-SHA256) encoded as ASN.1 DER.
+///
+/// Generated using:
+///
+/// ```
+/// $ openssl pkcs8 -v2 aes256-cbc -v2prf hmacWithSHA256 -topk8 -inform der -in ed25519-priv.der -outform der -out ed25519-encpriv-aes256-pbkdf2-sha256.der
+/// ```
+const ED25519_DER_AES256_PBKDF2_SHA256_EXAMPLE: &[u8] =
+    include_bytes!("examples/ed25519-encpriv-aes256-pbkdf2-sha256.der");
+
+/// Ed25519 PKCS#8 encrypted private key (PBES2 + AES-256-CBC + scrypt) encoded as ASN.1 DER.
+///
+/// Generated using:
+///
+/// ```
+/// $ openssl pkcs8 -v2 aes256-cbc -scrypt -topk8 -inform der -in ed25519-priv.der -outform der -out ed25519-encpriv-aes256-scrypt.der
+/// ```
+#[cfg(feature = "encryption")]
+const ED25519_DER_AES256_SCRYPT_EXAMPLE: &[u8] =
+    include_bytes!("examples/ed25519-encpriv-aes256-scrypt.der");
+
+/// Ed25519 PKCS#8 encrypted private key encoded as PEM
+#[cfg(feature = "pem")]
+const ED25519_PEM_AES256_PBKDF2_SHA256_EXAMPLE: &str =
+    include_str!("examples/ed25519-encpriv-aes256-pbkdf2-sha256.pem");
+
+/// Ed25519 PKCS#8 encrypted private key (PBES2 + 3DES + PBKDF2-SHA256) encoded as ASN.1 DER
+///
+/// Generated using:
+///
+/// ```
+/// $ openssl pkcs8 -v2 des3 -topk8 -inform der -in ed25519-priv-pkcs8v1.der -outform der -out ed25519-encpriv-des3-pbkdf2-sha256.der
+/// ```
+#[cfg(feature = "3des")]
+const ED25519_DER_DES3_PBKDF2_SHA256_EXAMPLE: &[u8] =
+    include_bytes!("examples/ed25519-encpriv-des3-pbkdf2-sha256.der");
+
+/// Ed25519 PKCS#8 encrypted private key (PBES2 + DES + PBKDF2-SHA256) encoded as ASN.1 DER
+///
+/// Generated using:
+///
+/// ```
+/// $ openssl pkcs8 -v2 des -topk8 -inform der -in ed25519-priv-pkcs8v1.der -outform der -out ed25519-encpriv-des3-pbkdf2-sha256.der
+/// ```
+#[cfg(feature = "des-insecure")]
+const ED25519_DER_DES_PBKDF2_SHA256_EXAMPLE: &[u8] =
+    include_bytes!("examples/ed25519-encpriv-des-pbkdf2-sha256.der");
+
+/// Password used to encrypt the keys.
+#[cfg(feature = "encryption")]
+const PASSWORD: &[u8] = b"hunter42"; // Bad password; don't actually use outside tests!
+
+#[test]
+fn decode_ed25519_encpriv_aes128_pbkdf2_sha1_der() {
+    let pk = EncryptedPrivateKeyInfo::try_from(ED25519_DER_AES128_PBKDF2_SHA1_EXAMPLE).unwrap();
+
+    assert_eq!(
+        pk.encryption_algorithm.oid(),
+        "1.2.840.113549.1.5.13".parse().unwrap()
+    ); // PBES2
+
+    let pbes2_params = pk.encryption_algorithm.pbes2().unwrap();
+    let pbkdf2_params = pbes2_params.kdf.pbkdf2().unwrap();
+
+    assert_eq!(pbkdf2_params.salt, hex!("e8765e01e43b6bad"));
+    assert_eq!(pbkdf2_params.iteration_count, 2048);
+    assert_eq!(pbkdf2_params.key_length, None);
+    assert_eq!(pbkdf2_params.prf, pbes2::Pbkdf2Prf::HmacWithSha1);
+
+    match pbes2_params.encryption {
+        pbes2::EncryptionScheme::Aes128Cbc { iv } => {
+            assert_eq!(iv, &hex!("223080a71bcd2b9a256d876c924979d2"));
+        }
+        other => panic!("unexpected encryption scheme: {:?}", other),
+    }
+
+    // Extracted with:
+    // $ openssl asn1parse -inform der -in tests/examples/ed25519-encpriv-aes128-sha1.der
+    assert_eq!(
+        pk.encrypted_data,
+        &hex!("4B4D091548EAC381EE7663B21234CD4FF3C9DF664D713394CACCEA7C9B982BD8F29910FABCA4BF7BE0431FAC5C4D657BE997C1F5BF40E2DA465AC1FCC2E30470")
+    );
+}
+
+#[test]
+fn decode_ed25519_encpriv_aes256_pbkdf2_sha256_der() {
+    let pk = EncryptedPrivateKeyInfo::try_from(ED25519_DER_AES256_PBKDF2_SHA256_EXAMPLE).unwrap();
+
+    assert_eq!(
+        pk.encryption_algorithm.oid(),
+        "1.2.840.113549.1.5.13".parse().unwrap()
+    ); // PBES2
+
+    let pbes2_params = pk.encryption_algorithm.pbes2().unwrap();
+    let pbkdf2_params = pbes2_params.kdf.pbkdf2().unwrap();
+
+    assert_eq!(pbkdf2_params.salt, hex!("79d982e70df91a88"));
+    assert_eq!(pbkdf2_params.iteration_count, 2048);
+    assert_eq!(pbkdf2_params.key_length, None);
+    assert_eq!(pbkdf2_params.prf, pbes2::Pbkdf2Prf::HmacWithSha256);
+
+    match pbes2_params.encryption {
+        pbes2::EncryptionScheme::Aes256Cbc { iv } => {
+            assert_eq!(iv, &hex!("b2d02d78b2efd9dff694cf8e0af40925"));
+        }
+        other => panic!("unexpected encryption scheme: {:?}", other),
+    }
+
+    // Extracted with:
+    // $ openssl asn1parse -inform der -in tests/examples/ed25519-encpriv-aes256-sha256.der
+    assert_eq!(
+        pk.encrypted_data,
+        &hex!("D0CD6C770F4BB87176422305C17401809E226674CE74185D221BFDAA95069890C8882FCE02B05D41BCBF54B035595BCD4154B32593708469B86AACF8815A7B2B")
+    );
+}
+
+#[cfg(feature = "encryption")]
+#[test]
+fn decrypt_ed25519_der_encpriv_aes256_pbkdf2_sha256() {
+    let enc_pk =
+        EncryptedPrivateKeyInfo::try_from(ED25519_DER_AES256_PBKDF2_SHA256_EXAMPLE).unwrap();
+    let pk = enc_pk.decrypt(PASSWORD).unwrap();
+    assert_eq!(pk.as_bytes(), ED25519_DER_PLAINTEXT_EXAMPLE);
+}
+
+#[cfg(feature = "encryption")]
+#[test]
+fn decrypt_ed25519_der_encpriv_aes256_scrypt() {
+    let enc_pk = EncryptedPrivateKeyInfo::try_from(ED25519_DER_AES256_SCRYPT_EXAMPLE).unwrap();
+    let pk = enc_pk.decrypt(PASSWORD).unwrap();
+    assert_eq!(pk.as_bytes(), ED25519_DER_PLAINTEXT_EXAMPLE);
+}
+
+#[cfg(feature = "encryption")]
+#[test]
+fn encrypt_ed25519_der_encpriv_aes256_pbkdf2_sha256() {
+    let pbes2_params = pkcs5::pbes2::Parameters::pbkdf2_sha256_aes256cbc(
+        2048,
+        &hex!("79d982e70df91a88"),
+        &hex!("b2d02d78b2efd9dff694cf8e0af40925"),
+    )
+    .unwrap();
+
+    let pk_plaintext = PrivateKeyInfo::try_from(ED25519_DER_PLAINTEXT_EXAMPLE).unwrap();
+    let pk_encrypted = pk_plaintext
+        .encrypt_with_params(pbes2_params, PASSWORD)
+        .unwrap();
+
+    assert_eq!(
+        pk_encrypted.as_bytes(),
+        ED25519_DER_AES256_PBKDF2_SHA256_EXAMPLE
+    );
+}
+
+#[cfg(feature = "encryption")]
+#[test]
+fn encrypt_ed25519_der_encpriv_aes256_scrypt() {
+    let scrypt_params = pkcs5::pbes2::Parameters::scrypt_aes256cbc(
+        pkcs5::scrypt::Params::new(15, 8, 1, 32).unwrap(),
+        &hex!("E6211E2348AD69E0"),
+        &hex!("9BD0A6251F2254F9FD5963887C27CF01"),
+    )
+    .unwrap();
+
+    let pk_plaintext = PrivateKeyInfo::try_from(ED25519_DER_PLAINTEXT_EXAMPLE).unwrap();
+    let pk_encrypted = pk_plaintext
+        .encrypt_with_params(scrypt_params, PASSWORD)
+        .unwrap();
+
+    assert_eq!(pk_encrypted.as_bytes(), ED25519_DER_AES256_SCRYPT_EXAMPLE);
+}
+
+#[test]
+#[cfg(feature = "alloc")]
+fn encode_ed25519_encpriv_aes256_pbkdf2_sha256_der() {
+    let pk = EncryptedPrivateKeyInfo::try_from(ED25519_DER_AES256_PBKDF2_SHA256_EXAMPLE).unwrap();
+    assert_eq!(
+        ED25519_DER_AES256_PBKDF2_SHA256_EXAMPLE,
+        &pk.to_der().unwrap()
+    );
+}
+
+#[test]
+#[cfg(feature = "pem")]
+fn encode_ed25519_encpriv_aes256_pbkdf2_sha256_pem() {
+    let pk = EncryptedPrivateKeyInfo::try_from(ED25519_DER_AES256_PBKDF2_SHA256_EXAMPLE).unwrap();
+    assert_eq!(
+        ED25519_PEM_AES256_PBKDF2_SHA256_EXAMPLE,
+        pk.to_pem(Default::default()).unwrap()
+    );
+}
+
+#[test]
+#[cfg(feature = "3des")]
+fn decrypt_ed25519_der_encpriv_des3_pbkdf2_sha256() {
+    let enc_pk = EncryptedPrivateKeyInfo::try_from(ED25519_DER_DES3_PBKDF2_SHA256_EXAMPLE).unwrap();
+    let pk = enc_pk.decrypt(PASSWORD).unwrap();
+    assert_eq!(pk.as_bytes(), ED25519_DER_PLAINTEXT_EXAMPLE);
+}
+
+#[test]
+#[cfg(feature = "des-insecure")]
+fn decrypt_ed25519_der_encpriv_des_pbkdf2_sha256() {
+    let enc_pk = EncryptedPrivateKeyInfo::try_from(ED25519_DER_DES_PBKDF2_SHA256_EXAMPLE).unwrap();
+    let pk = enc_pk.decrypt(PASSWORD).unwrap();
+    assert_eq!(pk.as_bytes(), ED25519_DER_PLAINTEXT_EXAMPLE);
+}
diff --git a/crates/pkcs8/tests/examples/ed25519-encpriv-aes128-pbkdf2-sha1.der b/crates/pkcs8/tests/examples/ed25519-encpriv-aes128-pbkdf2-sha1.der
new file mode 100644
index 0000000..c8d6edf
--- /dev/null
+++ b/crates/pkcs8/tests/examples/ed25519-encpriv-aes128-pbkdf2-sha1.der
Binary files differ
diff --git a/crates/pkcs8/tests/examples/ed25519-encpriv-aes256-pbkdf2-sha256.der b/crates/pkcs8/tests/examples/ed25519-encpriv-aes256-pbkdf2-sha256.der
new file mode 100644
index 0000000..5170c06
--- /dev/null
+++ b/crates/pkcs8/tests/examples/ed25519-encpriv-aes256-pbkdf2-sha256.der
Binary files differ
diff --git a/crates/pkcs8/tests/examples/ed25519-encpriv-aes256-pbkdf2-sha256.pem b/crates/pkcs8/tests/examples/ed25519-encpriv-aes256-pbkdf2-sha256.pem
new file mode 100644
index 0000000..e5d3207
--- /dev/null
+++ b/crates/pkcs8/tests/examples/ed25519-encpriv-aes256-pbkdf2-sha256.pem
@@ -0,0 +1,6 @@
+-----BEGIN ENCRYPTED PRIVATE KEY-----
+MIGbMFcGCSqGSIb3DQEFDTBKMCkGCSqGSIb3DQEFDDAcBAh52YLnDfkaiAICCAAw
+DAYIKoZIhvcNAgkFADAdBglghkgBZQMEASoEELLQLXiy79nf9pTPjgr0CSUEQNDN
+bHcPS7hxdkIjBcF0AYCeImZ0znQYXSIb/aqVBpiQyIgvzgKwXUG8v1SwNVlbzUFU
+syWTcIRpuGqs+IFaeys=
+-----END ENCRYPTED PRIVATE KEY-----
diff --git a/crates/pkcs8/tests/examples/ed25519-encpriv-aes256-scrypt.der b/crates/pkcs8/tests/examples/ed25519-encpriv-aes256-scrypt.der
new file mode 100644
index 0000000..a045982
--- /dev/null
+++ b/crates/pkcs8/tests/examples/ed25519-encpriv-aes256-scrypt.der
Binary files differ
diff --git a/crates/pkcs8/tests/examples/ed25519-encpriv-aes256-scrypt.pem b/crates/pkcs8/tests/examples/ed25519-encpriv-aes256-scrypt.pem
new file mode 100644
index 0000000..1f0562d
--- /dev/null
+++ b/crates/pkcs8/tests/examples/ed25519-encpriv-aes256-scrypt.pem
@@ -0,0 +1,6 @@
+-----BEGIN ENCRYPTED PRIVATE KEY-----
+MIGTME8GCSqGSIb3DQEFDTBCMCEGCSsGAQQB2kcECzAUBAjmIR4jSK1p4AICQAAC
+AQgCAQEwHQYJYIZIAWUDBAEqBBCb0KYlHyJU+f1ZY4h8J88BBEDMYrp3PA9JX6s2
+aOT8782wjnig7hXgoVAT9iq+CNqnQgZe6zZtbmyYzDsOfmm9yGHIiv648D26Hixt
+mdBtFzYM
+-----END ENCRYPTED PRIVATE KEY-----
diff --git a/crates/pkcs8/tests/examples/ed25519-encpriv-des-pbkdf2-sha256.der b/crates/pkcs8/tests/examples/ed25519-encpriv-des-pbkdf2-sha256.der
new file mode 100644
index 0000000..85d3b83
--- /dev/null
+++ b/crates/pkcs8/tests/examples/ed25519-encpriv-des-pbkdf2-sha256.der
Binary files differ
diff --git a/crates/pkcs8/tests/examples/ed25519-encpriv-des3-pbkdf2-sha256.der b/crates/pkcs8/tests/examples/ed25519-encpriv-des3-pbkdf2-sha256.der
new file mode 100644
index 0000000..aed05ab
--- /dev/null
+++ b/crates/pkcs8/tests/examples/ed25519-encpriv-des3-pbkdf2-sha256.der
Binary files differ
diff --git a/crates/pkcs8/tests/examples/ed25519-priv-pkcs8v1.der b/crates/pkcs8/tests/examples/ed25519-priv-pkcs8v1.der
new file mode 100644
index 0000000..0cfccc3
--- /dev/null
+++ b/crates/pkcs8/tests/examples/ed25519-priv-pkcs8v1.der
Binary files differ
diff --git a/crates/pkcs8/tests/examples/ed25519-priv-pkcs8v1.pem b/crates/pkcs8/tests/examples/ed25519-priv-pkcs8v1.pem
new file mode 100644
index 0000000..0c0ee10
--- /dev/null
+++ b/crates/pkcs8/tests/examples/ed25519-priv-pkcs8v1.pem
@@ -0,0 +1,3 @@
+-----BEGIN PRIVATE KEY-----
+MC4CAQAwBQYDK2VwBCIEIBftnHPp22SewYmmEoMcX8VwI4IHwaqd+9LFPj/15eqF
+-----END PRIVATE KEY-----
diff --git a/crates/pkcs8/tests/examples/ed25519-priv-pkcs8v2.der b/crates/pkcs8/tests/examples/ed25519-priv-pkcs8v2.der
new file mode 100644
index 0000000..3358e8a
--- /dev/null
+++ b/crates/pkcs8/tests/examples/ed25519-priv-pkcs8v2.der
Binary files differ
diff --git a/crates/pkcs8/tests/examples/ed25519-priv-pkcs8v2.pem b/crates/pkcs8/tests/examples/ed25519-priv-pkcs8v2.pem
new file mode 100644
index 0000000..8496108
--- /dev/null
+++ b/crates/pkcs8/tests/examples/ed25519-priv-pkcs8v2.pem
@@ -0,0 +1,5 @@
+-----BEGIN PRIVATE KEY-----
+MHICAQEwBQYDK2VwBCIEINTuctv5E1hK1bbY8fdp+K06/nwoy/HU++CXqI9EdVhC
+oB8wHQYKKoZIhvcNAQkJFDEPDA1DdXJkbGUgQ2hhaXJzgSEAGb9ECWmEzf6FQbrB
+Z9w7lshQhqowtrbLDFw4rXAxZuE=
+-----END PRIVATE KEY-----
diff --git a/crates/pkcs8/tests/examples/ed25519-pub.der b/crates/pkcs8/tests/examples/ed25519-pub.der
new file mode 100644
index 0000000..1b602ee
--- /dev/null
+++ b/crates/pkcs8/tests/examples/ed25519-pub.der
Binary files differ
diff --git a/crates/pkcs8/tests/examples/ed25519-pub.pem b/crates/pkcs8/tests/examples/ed25519-pub.pem
new file mode 100644
index 0000000..6891701
--- /dev/null
+++ b/crates/pkcs8/tests/examples/ed25519-pub.pem
@@ -0,0 +1,3 @@
+-----BEGIN PUBLIC KEY-----
+MCowBQYDK2VwAyEATSkWfz8ZEqb3rfopOgUaFcBexnuPFyZ7HFVQ3OhTvQ0=
+-----END PUBLIC KEY-----
diff --git a/crates/pkcs8/tests/examples/p256-priv.der b/crates/pkcs8/tests/examples/p256-priv.der
new file mode 100644
index 0000000..c0de45e
--- /dev/null
+++ b/crates/pkcs8/tests/examples/p256-priv.der
Binary files differ
diff --git a/crates/pkcs8/tests/examples/p256-priv.pem b/crates/pkcs8/tests/examples/p256-priv.pem
new file mode 100644
index 0000000..09b9343
--- /dev/null
+++ b/crates/pkcs8/tests/examples/p256-priv.pem
@@ -0,0 +1,5 @@
+-----BEGIN PRIVATE KEY-----
+MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgaWJBcVYaYzQN4OfY
+afKgVJJVjhoEhotqn4VKhmeIGI2hRANCAAQcrP+1Xy8s79idies3SyaBFSRSgC3u
+oJkWBoE32DnPf8SBpESSME1+9mrBF77+g6jQjxVfK1L59hjdRHApBI4P
+-----END PRIVATE KEY-----
diff --git a/crates/pkcs8/tests/examples/p256-pub.der b/crates/pkcs8/tests/examples/p256-pub.der
new file mode 100644
index 0000000..67c719c
--- /dev/null
+++ b/crates/pkcs8/tests/examples/p256-pub.der
Binary files differ
diff --git a/crates/pkcs8/tests/examples/p256-pub.pem b/crates/pkcs8/tests/examples/p256-pub.pem
new file mode 100644
index 0000000..ee7e5b6
--- /dev/null
+++ b/crates/pkcs8/tests/examples/p256-pub.pem
@@ -0,0 +1,4 @@
+-----BEGIN PUBLIC KEY-----
+MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEHKz/tV8vLO/YnYnrN0smgRUkUoAt
+7qCZFgaBN9g5z3/EgaREkjBNfvZqwRe+/oOo0I8VXytS+fYY3URwKQSODw==
+-----END PUBLIC KEY-----
diff --git a/crates/pkcs8/tests/examples/rsa2048-priv.der b/crates/pkcs8/tests/examples/rsa2048-priv.der
new file mode 100644
index 0000000..f4590bb
--- /dev/null
+++ b/crates/pkcs8/tests/examples/rsa2048-priv.der
Binary files differ
diff --git a/crates/pkcs8/tests/examples/rsa2048-priv.pem b/crates/pkcs8/tests/examples/rsa2048-priv.pem
new file mode 100644
index 0000000..e2a218c
--- /dev/null
+++ b/crates/pkcs8/tests/examples/rsa2048-priv.pem
@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQC2xCxRXxCmqvKC
+xj7b4kJDoXDz+iYzvUgzY39Hyk9vNuA6XSnvwxkayA85DYdLOeMPQU/Owfyg7YHl
+R+3CzTgsdvYckBiXPbn6U3lyp8cB9rd+CYLfwV/AGSfuXnzZS09Zn/BwE6fIKBvf
+Ity8mtfKu3xDEcmC9Y7bchOtRVizMiZtdDrtgZLRiEytuLFHOaja2mbclwgG2ces
+RQyxPQ18V1+xmFNPxhvEG8DwV04OATDHu7+9/cn2puLj4q/xy+rIm6V4hFKNVc+w
+gyeh6MifTgA88oiOkzJB2daVvLus3JC0Tj4JX6NwWOolsT9eKVy+rG3oOKuMUK9h
+4piXW4cvAgMBAAECggEAfsyDYsDtsHQRZCFeIvdKudkboGkAcAz2NpDlEU2O5r3P
+uy4/lhRpKmd6CD8Wil5S5ZaOZAe52XxuDkBk+C2gt1ihTxe5t9QfX0jijWVRcE9W
+5p56qfpjD8dkKMBtJeRV3PxVt6wrT3ZkP97T/hX/eKuyfmWsxKrQvfbbJ+9gppEM
+XEoIXtQydasZwdmXoyxu/8598tGTX25gHu3hYaErXMJ8oh+B0smcPR6gjpDjBTqw
+m++nJN7w0MOjwel0DA2fdhJqFJ7Aqn2AeCBUhCVNlR2wfEz5H7ZFTAlliP1ZJNur
+6zWcogJSaNAE+dZus9b3rcETm61A8W3eY54RZHN2wQKBgQDcwGEkLU6Sr67nKsUT
+ymW593A2+b1+Dm5hRhp+92VCJewVPH5cMaYVem5aE/9uF46HWMHLM9nWu+MXnvGJ
+mOQi7Ny+149Oz9vl9PzYrsLJ0NyGRzypvRbZ0jjSH7Xd776xQ8ph0L1qqNkfM6CX
+eQ6WQNvJEIXcXyY0O6MTj2stZwKBgQDT8xR1fkDpVINvkr4kI2ry8NoEo0ZTwYCv
+Z+lgCG2T/eZcsj79nQk3R2L1mB42GEmvaM3XU5T/ak4G62myCeQijbLfpw5A9/l1
+ClKBdmR7eI0OV3eiy4si480mf/cLTzsC06r7DhjFkKVksDGIsKpfxIFWsHYiIUJD
+vRIn76fy+QKBgQDOaLesGw0QDWNuVUiHU8XAmEP9s5DicF33aJRXyb2Nl2XjCXhh
+fi78gEj0wyQgbbhgh7ZU6Xuz1GTn7j+M2D/hBDb33xjpqWPE5kkR1n7eNAQvLibj
+06GtNGra1rm39ncIywlOYt7p/01dZmmvmIryJV0c6O0xfGp9hpHaNU0S2wKBgCX2
+5ZRCIChrTfu/QjXA7lhD0hmAkYlRINbKeyALgm0+znOOLgBJj6wKKmypacfww8oa
+sLxAKXEyvnU4177fTLDvxrmO99ulT1aqmaq85TTEnCeUfUZ4xRxjx4x84WhyMbTI
+61h65u8EgMuvT8AXPP1Yen5nr1FfubnedREYOXIpAoGAMZlUBtQGIHyt6uo1s40E
+DF+Kmhrggn6e0GsVPYO2ghk1tLNqgr6dVseRtYwnJxpXk9U6HWV8CJl5YLFDPlFx
+mH9FLxRKfHIwbWPh0//Atxt1qwjy5FpILpiEUcvkeOEusijQdFbJJLZvbO0EjYU/
+Uz4xpoYU8cPObY7JmDznKvc=
+-----END PRIVATE KEY-----
diff --git a/crates/pkcs8/tests/examples/rsa2048-pub.der b/crates/pkcs8/tests/examples/rsa2048-pub.der
new file mode 100644
index 0000000..4148aaa
--- /dev/null
+++ b/crates/pkcs8/tests/examples/rsa2048-pub.der
Binary files differ
diff --git a/crates/pkcs8/tests/examples/rsa2048-pub.pem b/crates/pkcs8/tests/examples/rsa2048-pub.pem
new file mode 100644
index 0000000..5ecd892
--- /dev/null
+++ b/crates/pkcs8/tests/examples/rsa2048-pub.pem
@@ -0,0 +1,9 @@
+-----BEGIN PUBLIC KEY-----
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAtsQsUV8QpqrygsY+2+JC
+Q6Fw8/omM71IM2N/R8pPbzbgOl0p78MZGsgPOQ2HSznjD0FPzsH8oO2B5Uftws04
+LHb2HJAYlz25+lN5cqfHAfa3fgmC38FfwBkn7l582UtPWZ/wcBOnyCgb3yLcvJrX
+yrt8QxHJgvWO23ITrUVYszImbXQ67YGS0YhMrbixRzmo2tpm3JcIBtnHrEUMsT0N
+fFdfsZhTT8YbxBvA8FdODgEwx7u/vf3J9qbi4+Kv8cvqyJuleIRSjVXPsIMnoejI
+n04APPKIjpMyQdnWlby7rNyQtE4+CV+jcFjqJbE/Xilcvqxt6DirjFCvYeKYl1uH
+LwIDAQAB
+-----END PUBLIC KEY-----
diff --git a/crates/pkcs8/tests/examples/x25519-priv.der b/crates/pkcs8/tests/examples/x25519-priv.der
new file mode 100644
index 0000000..79355d2
--- /dev/null
+++ b/crates/pkcs8/tests/examples/x25519-priv.der
Binary files differ
diff --git a/crates/pkcs8/tests/examples/x25519-priv.pem b/crates/pkcs8/tests/examples/x25519-priv.pem
new file mode 100644
index 0000000..501f95d
--- /dev/null
+++ b/crates/pkcs8/tests/examples/x25519-priv.pem
@@ -0,0 +1,3 @@
+-----BEGIN PRIVATE KEY-----
+MC4CAQAwBQYDK2VuBCIEIHBgJSkzrG56SpsOsmMsWgQKhyV624aaPszD0WtyTyZH
+-----END PRIVATE KEY-----
diff --git a/crates/pkcs8/tests/private_key.rs b/crates/pkcs8/tests/private_key.rs
new file mode 100644
index 0000000..1ef0f73
--- /dev/null
+++ b/crates/pkcs8/tests/private_key.rs
@@ -0,0 +1,187 @@
+//! PKCS#8 private key tests
+
+use der::asn1::ObjectIdentifier;
+use hex_literal::hex;
+use pkcs8::{PrivateKeyInfo, Version};
+
+#[cfg(feature = "alloc")]
+use der::Encode;
+
+#[cfg(feature = "pem")]
+use der::{pem::LineEnding, EncodePem};
+
+/// Elliptic Curve (P-256) PKCS#8 private key encoded as ASN.1 DER
+const EC_P256_DER_EXAMPLE: &[u8] = include_bytes!("examples/p256-priv.der");
+
+/// Ed25519 PKCS#8 v1 private key encoded as ASN.1 DER
+const ED25519_DER_V1_EXAMPLE: &[u8] = include_bytes!("examples/ed25519-priv-pkcs8v1.der");
+
+/// Ed25519 PKCS#8 v2 private key + public key encoded as ASN.1 DER
+const ED25519_DER_V2_EXAMPLE: &[u8] = include_bytes!("examples/ed25519-priv-pkcs8v2.der");
+
+/// RSA-2048 PKCS#8 private key encoded as ASN.1 DER
+const RSA_2048_DER_EXAMPLE: &[u8] = include_bytes!("examples/rsa2048-priv.der");
+
+/// X25519 PKCS#8 private key encoded as ASN.1 DER
+const X25519_DER_EXAMPLE: &[u8] = include_bytes!("examples/x25519-priv.der");
+
+/// Elliptic Curve (P-256) PKCS#8 private key encoded as PEM
+#[cfg(feature = "pem")]
+const EC_P256_PEM_EXAMPLE: &str = include_str!("examples/p256-priv.pem");
+
+/// Ed25519 PKCS#8 private key encoded as PEM
+#[cfg(feature = "pem")]
+const ED25519_PEM_V1_EXAMPLE: &str = include_str!("examples/ed25519-priv-pkcs8v1.pem");
+
+/// RSA-2048 PKCS#8 private key encoded as PEM
+#[cfg(feature = "pem")]
+const RSA_2048_PEM_EXAMPLE: &str = include_str!("examples/rsa2048-priv.pem");
+
+/// X25519 PKCS#8 private key encoded as PEM
+#[cfg(feature = "pem")]
+const X25519_PEM_EXAMPLE: &str = include_str!("examples/x25519-priv.pem");
+
+#[test]
+fn decode_ec_p256_der() {
+    let pk = PrivateKeyInfo::try_from(EC_P256_DER_EXAMPLE).unwrap();
+
+    assert_eq!(pk.version(), Version::V1);
+    assert_eq!(pk.algorithm.oid, "1.2.840.10045.2.1".parse().unwrap());
+
+    assert_eq!(
+        pk.algorithm
+            .parameters
+            .unwrap()
+            .decode_as::<ObjectIdentifier>()
+            .unwrap(),
+        "1.2.840.10045.3.1.7".parse().unwrap()
+    );
+
+    // Extracted with:
+    // $ openssl asn1parse -inform der -in tests/examples/p256-priv.der
+    assert_eq!(pk.private_key, &hex!("306B020101042069624171561A63340DE0E7D869F2A05492558E1A04868B6A9F854A866788188DA144034200041CACFFB55F2F2CEFD89D89EB374B2681152452802DEEA09916068137D839CF7FC481A44492304D7EF66AC117BEFE83A8D08F155F2B52F9F618DD447029048E0F")[..]);
+}
+
+// Test vector from RFC8410 Section 10.3:
+// https://datatracker.ietf.org/doc/html/rfc8410#section-10.3
+#[test]
+fn decode_ed25519_der_v1() {
+    let pk = PrivateKeyInfo::try_from(ED25519_DER_V1_EXAMPLE).unwrap();
+    assert_eq!(pk.version(), Version::V1);
+    assert_eq!(pk.algorithm.oid, "1.3.101.112".parse().unwrap());
+    assert_eq!(pk.algorithm.parameters, None);
+
+    // Extracted with:
+    // $ openssl asn1parse -inform der -in tests/examples/ed25519-priv.der
+    assert_eq!(
+        pk.private_key,
+        &hex!("042017ED9C73E9DB649EC189A612831C5FC570238207C1AA9DFBD2C53E3FF5E5EA85")[..]
+    );
+}
+
+// Test vector from RFC8410 Section 10.3:
+// https://datatracker.ietf.org/doc/html/rfc8410#section-10.3
+#[test]
+fn decode_ed25519_der_v2() {
+    // Extracted with:
+    // $ openssl asn1parse -inform der -in tests/examples/ed25519-priv-pkcs8v2.der
+    const PRIV_KEY: [u8; 34] =
+        hex!("0420D4EE72DBF913584AD5B6D8F1F769F8AD3AFE7C28CBF1D4FBE097A88F44755842");
+    const PUB_KEY: [u8; 32] =
+        hex!("19BF44096984CDFE8541BAC167DC3B96C85086AA30B6B6CB0C5C38AD703166E1");
+
+    let pk = PrivateKeyInfo::try_from(ED25519_DER_V2_EXAMPLE).unwrap();
+    assert_eq!(pk.version(), Version::V2);
+    assert_eq!(pk.algorithm.oid, "1.3.101.112".parse().unwrap());
+    assert_eq!(pk.algorithm.parameters, None);
+    assert_eq!(pk.private_key, PRIV_KEY);
+    assert_eq!(pk.public_key, Some(&PUB_KEY[..]));
+}
+
+#[test]
+fn decode_rsa_2048_der() {
+    let pk = PrivateKeyInfo::try_from(RSA_2048_DER_EXAMPLE).unwrap();
+    assert_eq!(pk.version(), Version::V1);
+    assert_eq!(pk.algorithm.oid, "1.2.840.113549.1.1.1".parse().unwrap());
+    assert!(pk.algorithm.parameters.unwrap().is_null());
+
+    // Extracted with:
+    // $ openssl asn1parse -inform der -in tests/examples/rsa2048-priv.der
+    assert_eq!(pk.private_key, &hex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
+}
+
+#[test]
+fn decode_x25519_der() {
+    let pk = PrivateKeyInfo::try_from(X25519_DER_EXAMPLE).unwrap();
+    assert_eq!(pk.version(), Version::V1);
+    assert_eq!(pk.algorithm.oid, "1.3.101.110".parse().unwrap());
+    assert_eq!(pk.algorithm.parameters, None);
+
+    // Extracted with:
+    // $ openssl asn1parse -inform der -in tests/examples/x25519-priv.der
+    assert_eq!(
+        pk.private_key,
+        &hex!("04207060252933AC6E7A4A9B0EB2632C5A040A87257ADB869A3ECCC3D16B724F2647")[..]
+    );
+}
+
+#[test]
+#[cfg(feature = "alloc")]
+fn encode_ec_p256_der() {
+    let pk = PrivateKeyInfo::try_from(EC_P256_DER_EXAMPLE).unwrap();
+    let pk_encoded = pk.to_der().unwrap();
+    assert_eq!(EC_P256_DER_EXAMPLE, pk_encoded);
+}
+
+#[test]
+#[cfg(feature = "alloc")]
+fn encode_ed25519_der_v1() {
+    let pk = PrivateKeyInfo::try_from(ED25519_DER_V1_EXAMPLE).unwrap();
+    assert_eq!(ED25519_DER_V1_EXAMPLE, pk.to_der().unwrap());
+}
+
+#[test]
+#[cfg(all(feature = "alloc", feature = "subtle"))]
+fn encode_ed25519_der_v2() {
+    let private_key = PrivateKeyInfo::try_from(ED25519_DER_V2_EXAMPLE).unwrap();
+    let private_der = private_key.to_der().unwrap();
+    assert_eq!(
+        private_key,
+        PrivateKeyInfo::try_from(private_der.as_ref()).unwrap()
+    );
+}
+
+#[test]
+#[cfg(feature = "alloc")]
+fn encode_rsa_2048_der() {
+    let pk = PrivateKeyInfo::try_from(RSA_2048_DER_EXAMPLE).unwrap();
+    assert_eq!(RSA_2048_DER_EXAMPLE, &pk.to_der().unwrap());
+}
+
+#[test]
+#[cfg(feature = "pem")]
+fn encode_ec_p256_pem() {
+    let pk = PrivateKeyInfo::try_from(EC_P256_DER_EXAMPLE).unwrap();
+    assert_eq!(EC_P256_PEM_EXAMPLE, pk.to_pem(LineEnding::LF).unwrap());
+}
+
+#[test]
+#[cfg(feature = "pem")]
+fn encode_ed25519_pem() {
+    let pk = PrivateKeyInfo::try_from(ED25519_DER_V1_EXAMPLE).unwrap();
+    assert_eq!(ED25519_PEM_V1_EXAMPLE, pk.to_pem(LineEnding::LF).unwrap());
+}
+
+#[test]
+#[cfg(feature = "pem")]
+fn encode_rsa_2048_pem() {
+    let pk = PrivateKeyInfo::try_from(RSA_2048_DER_EXAMPLE).unwrap();
+    assert_eq!(RSA_2048_PEM_EXAMPLE, pk.to_pem(LineEnding::LF).unwrap());
+}
+
+#[test]
+#[cfg(feature = "pem")]
+fn encode_x25519_pem() {
+    let pk = PrivateKeyInfo::try_from(X25519_DER_EXAMPLE).unwrap();
+    assert_eq!(X25519_PEM_EXAMPLE, pk.to_pem(LineEnding::LF).unwrap());
+}
diff --git a/crates/pkcs8/tests/traits.rs b/crates/pkcs8/tests/traits.rs
new file mode 100644
index 0000000..4a603bb
--- /dev/null
+++ b/crates/pkcs8/tests/traits.rs
@@ -0,0 +1,102 @@
+//! Tests for PKCS#8 encoding/decoding traits.
+
+#![cfg(any(feature = "pem", feature = "std"))]
+
+use der::Encode;
+use pkcs8::{DecodePrivateKey, EncodePrivateKey, Error, PrivateKeyInfo, Result, SecretDocument};
+
+#[cfg(feature = "pem")]
+use pkcs8::der::pem::LineEnding;
+
+#[cfg(feature = "std")]
+use tempfile::tempdir;
+
+#[cfg(all(feature = "pem", feature = "std"))]
+use std::fs;
+
+/// Ed25519 `PrivateKeyInfo` encoded as ASN.1 DER
+const ED25519_DER_EXAMPLE: &[u8] = include_bytes!("examples/ed25519-priv-pkcs8v1.der");
+
+/// Ed25519 private key encoded as PEM
+#[cfg(feature = "pem")]
+const ED25519_PEM_EXAMPLE: &str = include_str!("examples/ed25519-priv-pkcs8v1.pem");
+
+/// Mock key type for testing trait impls against.
+pub struct MockKey(Vec<u8>);
+
+impl AsRef<[u8]> for MockKey {
+    fn as_ref(&self) -> &[u8] {
+        self.0.as_ref()
+    }
+}
+
+impl EncodePrivateKey for MockKey {
+    fn to_pkcs8_der(&self) -> Result<SecretDocument> {
+        Ok(SecretDocument::try_from(self.as_ref())?)
+    }
+}
+
+impl TryFrom<PrivateKeyInfo<'_>> for MockKey {
+    type Error = Error;
+
+    fn try_from(pkcs8: PrivateKeyInfo<'_>) -> Result<MockKey> {
+        Ok(MockKey(pkcs8.to_der()?))
+    }
+}
+
+#[cfg(feature = "pem")]
+#[test]
+fn from_pkcs8_pem() {
+    let key = MockKey::from_pkcs8_pem(ED25519_PEM_EXAMPLE).unwrap();
+    assert_eq!(key.as_ref(), ED25519_DER_EXAMPLE);
+}
+
+#[cfg(feature = "std")]
+#[test]
+fn read_pkcs8_der_file() {
+    let key = MockKey::read_pkcs8_der_file("tests/examples/ed25519-priv-pkcs8v1.der").unwrap();
+    assert_eq!(key.as_ref(), ED25519_DER_EXAMPLE);
+}
+
+#[cfg(all(feature = "pem", feature = "std"))]
+#[test]
+fn read_pkcs8_pem_file() {
+    let key = MockKey::read_pkcs8_pem_file("tests/examples/ed25519-priv-pkcs8v1.pem").unwrap();
+    assert_eq!(key.as_ref(), ED25519_DER_EXAMPLE);
+}
+
+#[cfg(feature = "pem")]
+#[test]
+fn to_pkcs8_pem() {
+    let pem = MockKey(ED25519_DER_EXAMPLE.to_vec())
+        .to_pkcs8_pem(LineEnding::LF)
+        .unwrap();
+
+    assert_eq!(&*pem, ED25519_PEM_EXAMPLE);
+}
+
+#[cfg(feature = "std")]
+#[test]
+fn write_pkcs8_der_file() {
+    let dir = tempdir().unwrap();
+    let path = dir.path().join("example.der");
+    MockKey(ED25519_DER_EXAMPLE.to_vec())
+        .write_pkcs8_der_file(&path)
+        .unwrap();
+
+    let key = MockKey::read_pkcs8_der_file(&path).unwrap();
+    assert_eq!(key.as_ref(), ED25519_DER_EXAMPLE);
+}
+
+#[cfg(all(feature = "pem", feature = "std"))]
+#[test]
+fn write_pkcs8_pem_file() {
+    let dir = tempdir().unwrap();
+    let path = dir.path().join("example.pem");
+    MockKey(ED25519_DER_EXAMPLE.to_vec())
+        .write_pkcs8_pem_file(&path, LineEnding::LF)
+        .unwrap();
+
+    let pem = fs::read_to_string(path).unwrap();
+    assert_eq!(&pem, ED25519_PEM_EXAMPLE);
+}
diff --git a/crates/plotters-backend/.cargo-checksum.json b/crates/plotters-backend/.cargo-checksum.json
new file mode 100644
index 0000000..3372831
--- /dev/null
+++ b/crates/plotters-backend/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"c8624ca3be0b538da30206d6e26e26a99231d406160330003fa628eab19cc59e","LICENSE":"1e881ecf2862d01e6e5bc2b861e46886d2a6fb01499c0c508a209a7271b13cf2","README.md":"4c2c30ecd493e140c61242f4d01a4561dce72ae2c1a9be7df442f2a06f3f1db8","src/lib.rs":"31fe4a889ee62a18ec4eab32e8260bcf11d30830ef490be936a113404aa5a187","src/rasterizer/circle.rs":"5228c47ce8401c728b2c5cf213507dfafbaee2242e9720b308489e7eb4b2b834","src/rasterizer/line.rs":"79690b46f3ef7164a9484a78279047d0f4c52b10585d72a232d38af96b37d094","src/rasterizer/mod.rs":"186e8f15667306a2335e780860f58932639735a0ea0022c5e761137162478be0","src/rasterizer/path.rs":"1031fbe7e0e271ca55ee1a65bb9b9a0e2ec548226e78d325a558d832e1e9025e","src/rasterizer/polygon.rs":"a287a9afa26372b529447234868f08d87d5f69815af834847840c7bcf8559b31","src/rasterizer/rect.rs":"eac6b60b15908677dd8672e30486b1242c74ff72ac3988d5a669e1e5c8e2a83e","src/style.rs":"f6c2f04bcdd556e500a5853d8948ebcfaf990c738678b603c859ba6ef298e5d6","src/text.rs":"cc7867192642837cb8d632474ce40a3dafe9323a80537de27611d48f76a93fce"},"package":"9e76628b4d3a7581389a35d5b6e2139607ad7c75b17aed325f210aa91f4a9609"}
\ No newline at end of file
diff --git a/crates/plotters-backend/Android.bp b/crates/plotters-backend/Android.bp
new file mode 100644
index 0000000..8c50012
--- /dev/null
+++ b/crates/plotters-backend/Android.bp
@@ -0,0 +1,30 @@
+// This file is generated by cargo_embargo.
+// Do not modify this file because the changes will be overridden on upgrade.
+
+package {
+    default_applicable_licenses: ["external_rust_crates_plotters-backend_license"],
+    default_team: "trendy_team_android_rust",
+}
+
+license {
+    name: "external_rust_crates_plotters-backend_license",
+    visibility: [":__subpackages__"],
+    license_kinds: ["SPDX-license-identifier-MIT"],
+    license_text: ["LICENSE"],
+}
+
+rust_library {
+    name: "libplotters_backend",
+    host_supported: true,
+    crate_name: "plotters_backend",
+    cargo_env_compat: true,
+    cargo_pkg_version: "0.3.5",
+    crate_root: "src/lib.rs",
+    edition: "2018",
+    apex_available: [
+        "//apex_available:platform",
+        "//apex_available:anyapex",
+    ],
+    product_available: true,
+    vendor_available: true,
+}
diff --git a/crates/plotters-backend/Cargo.lock b/crates/plotters-backend/Cargo.lock
new file mode 100644
index 0000000..455a5a1
--- /dev/null
+++ b/crates/plotters-backend/Cargo.lock
@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "plotters-backend"
+version = "0.3.5"
diff --git a/crates/plotters-backend/Cargo.toml b/crates/plotters-backend/Cargo.toml
new file mode 100644
index 0000000..7fd1039
--- /dev/null
+++ b/crates/plotters-backend/Cargo.toml
@@ -0,0 +1,23 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2018"
+name = "plotters-backend"
+version = "0.3.5"
+authors = ["Hao Hou <haohou302@gmail.com>"]
+description = "Plotters Backend API"
+homepage = "https://plotters-rs.github.io"
+readme = "README.md"
+license = "MIT"
+repository = "https://github.com/plotters-rs/plotters"
+
+[dependencies]
diff --git a/crates/plotters-backend/LICENSE b/crates/plotters-backend/LICENSE
new file mode 100644
index 0000000..ea5b606
--- /dev/null
+++ b/crates/plotters-backend/LICENSE
@@ -0,0 +1 @@
+../LICENSE
\ No newline at end of file
diff --git a/crates/plotters-backend/METADATA b/crates/plotters-backend/METADATA
new file mode 100644
index 0000000..98e69cc
--- /dev/null
+++ b/crates/plotters-backend/METADATA
@@ -0,0 +1,20 @@
+# This project was upgraded with external_updater.
+# Usage: tools/external_updater/updater.sh update external/rust/crates/plotters-backend
+# For more info, check https://cs.android.com/android/platform/superproject/+/main:tools/external_updater/README.md
+
+name: "plotters-backend"
+description: "Plotters Backend API"
+third_party {
+  license_type: NOTICE
+  last_upgrade_date {
+    year: 2024
+    month: 2
+    day: 5
+  }
+  homepage: "https://crates.io/crates/plotters-backend"
+  identifier {
+    type: "Archive"
+    value: "https://static.crates.io/crates/plotters-backend/plotters-backend-0.3.5.crate"
+    version: "0.3.5"
+  }
+}
diff --git a/crates/plotters-backend/MODULE_LICENSE_MIT b/crates/plotters-backend/MODULE_LICENSE_MIT
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/crates/plotters-backend/MODULE_LICENSE_MIT
diff --git a/crates/plotters-backend/README.md b/crates/plotters-backend/README.md
new file mode 100644
index 0000000..871fc7c
--- /dev/null
+++ b/crates/plotters-backend/README.md
@@ -0,0 +1,8 @@
+# plotters-backend - The base crate for implementing a backend for Plotters
+
+This is a part of plotters project. For more details, please check the following links:
+
+- For high-level intro of Plotters, see: [Plotters on crates.io](https://crates.io/crates/plotters)
+- Check the main repo at [Plotters repo](https://github.com/plotters-rs/plotters.git)
+- For detailed documentation about this crate, check [plotters-backend on docs.rs](https://docs.rs/plotters-backend/)
+- You can also visit Plotters [Homepage](https://plotters-rs.github.io)
diff --git a/crates/plotters-backend/TEST_MAPPING b/crates/plotters-backend/TEST_MAPPING
new file mode 100644
index 0000000..3cbd48d
--- /dev/null
+++ b/crates/plotters-backend/TEST_MAPPING
@@ -0,0 +1,17 @@
+// Generated by update_crate_tests.py for tests that depend on this crate.
+{
+  "imports": [
+    {
+      "path": "external/rust/crates/base64"
+    },
+    {
+      "path": "external/rust/crates/tinytemplate"
+    },
+    {
+      "path": "external/rust/crates/tinyvec"
+    },
+    {
+      "path": "external/rust/crates/unicode-xid"
+    }
+  ]
+}
diff --git a/crates/plotters-backend/cargo_embargo.json b/crates/plotters-backend/cargo_embargo.json
new file mode 100644
index 0000000..cb908d7
--- /dev/null
+++ b/crates/plotters-backend/cargo_embargo.json
@@ -0,0 +1,3 @@
+{
+  "run_cargo": false
+}
diff --git a/crates/plotters-backend/src/lib.rs b/crates/plotters-backend/src/lib.rs
new file mode 100644
index 0000000..d4fd904
--- /dev/null
+++ b/crates/plotters-backend/src/lib.rs
@@ -0,0 +1,328 @@
+/*!
+  The Plotters backend API crate. This is a part of Plotters, the Rust drawing and plotting library, for more details regarding the entire
+  Plotters project, please check the [main crate](https://crates.io/crates/plotters).
+
+  This is the crate that used as the connector between Plotters and different backend crates. Since Plotters 0.3, all the backends has been
+  hosted as seperate crates for the usability and maintainability reasons.
+
+  At the same time, Plotters is now supporting third-party backends and all the backends are now supports "plug-and-play":
+  To use a external backend, just depends on both the Plotters main crate and the third-party backend crate.
+
+  # Notes for implementing Backend for Plotters
+
+  To create a new Plotters backend, this crate should be imported to the crate and the trait [DrawingBackend](trait.DrawingBackend.html) should
+  be implemented. It's highly recommended that the third-party backend uses `plotters-backend` by version specification `^x.y.*`.
+  For more details, see the [compatibility note](#compatibility-note).
+
+  If the backend only implements [DrawingBackend::draw_pixel](trait.DrawingBackend.html#tymethod.draw_pixel), the default CPU rasterizer will be
+  used to give your backend ability of drawing different shapes. For those backend that supports advanced drawing instructions, such as, GPU
+  acelerated shape drawing, all the provided trait method can be overriden from the specific backend code.
+
+  If your backend have text rendering ability, you may want to override the [DrawingBackend::estimate_text_size](trait.DrawingBackend.html#tymethod.estimate_text_size)
+  to avoid wrong spacing, since the Plotters default text handling code may behaves differently from the backend in terms of text rendering.
+
+  ## Animated or Realtime Rendering
+  Backend might render the image realtimely/animated, for example, a GTK backend for realtime display or a GIF image rendering. To support these
+  features, you need to play with `ensure_prepared` and `present` method. The following figure illustrates how Plotters operates a drawing backend.
+
+  - `ensure_prepared` - Called before each time when plotters want to draw. This function should initialize the backend for current frame, if the backend is already prepared
+     for a frame, this function should simply do nothing.
+  - `present` - Called when plotters want to finish current frame drawing
+
+
+  ```text
+                                        .ensure_prepared() &&
+    +-------------+    +-------------+    .draw_pixels()             +--------------+   drop
+    |Start drwaing|--->|Ready to draw| ------------------------+---->|Finish 1 frame| --------->
+    +-------------+    +-------------+                         |     +--------------+
+           ^                  ^                                |            |
+           |                  +------------------------------- +            |
+           |                            continue drawing                    |
+           +----------------------------------------------------------------+
+                                start render the next frame
+                                        .present()
+  ```
+  - For both animated and static drawing, `DrawingBackend::present` indicates current frame should be flushed.
+  - For both animated and static drawing, `DrawingBackend::ensure_prepared` is called every time when plotters need to draw.
+  - For static drawing, the `DrawingBackend::present` is only called once manually, or from the Drop impl for the backend.
+  - For dynamic drawing, frames are defined by invocation of `DrawingBackend::present`, everything prior the invocation should belongs to previous frame
+
+  # Compatibility Note
+  Since Plotters v0.3, plotters use the "plug-and-play" schema to import backends, this requires both Plotters and the backend crates depdens on a
+  same version of `plotters-backend` crate. This crate (`plotters-backend`) will enforce that any revision (means the last number in a version number)
+  won't contains breaking change - both on the Plotters side and backend side.
+
+  Plotters main crate is always importing the backend crate with version specification `plotters-backend = "^<major>.<minor>*"`.
+  It's highly recommended that all the external crates follows the same rule to import `plotters-backend` depdendency, to avoid protential breaking
+  caused by `plotters-backend` crates gets a revision update.
+
+  We also impose a versioning rule with `plotters` and some backends:
+  The compatible main crate (`plotters`) and this crate (`plotters-backend`) are always use the same major and minor version number.
+  All the plotters main crate and second-party backends with version "x.y.*" should be compatible, and they should depens on the latest version of `plotters-backend x.y.*`
+
+*/
+use std::error::Error;
+
+pub mod rasterizer;
+mod style;
+mod text;
+
+pub use style::{BackendColor, BackendStyle};
+pub use text::{text_anchor, BackendTextStyle, FontFamily, FontStyle, FontTransform};
+
+use text_anchor::{HPos, VPos};
+
+/// A coordinate in the pixel-based backend. The coordinate follows the framebuffer's convention,
+/// which defines the top-left point as (0, 0).
+pub type BackendCoord = (i32, i32);
+
+/// The error produced by a drawing backend.
+#[derive(Debug)]
+pub enum DrawingErrorKind<E: Error + Send + Sync> {
+    /// A drawing backend error
+    DrawingError(E),
+    /// A font rendering error
+    FontError(Box<dyn Error + Send + Sync + 'static>),
+}
+
+impl<E: Error + Send + Sync> std::fmt::Display for DrawingErrorKind<E> {
+    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
+        match self {
+            DrawingErrorKind::DrawingError(e) => write!(fmt, "Drawing backend error: {}", e),
+            DrawingErrorKind::FontError(e) => write!(fmt, "Font loading error: {}", e),
+        }
+    }
+}
+
+impl<E: Error + Send + Sync> Error for DrawingErrorKind<E> {}
+
+///  The drawing backend trait, which implements the low-level drawing APIs.
+///  This trait has a set of default implementation. And the minimal requirement of
+///  implementing a drawing backend is implementing the `draw_pixel` function.
+///
+///  If the drawing backend supports vector graphics, the other drawing APIs should be
+///  override by the backend specific implementation. Otherwise, the default implementation
+///  will use the pixel-based approach to draw other types of low-level shapes.
+pub trait DrawingBackend: Sized {
+    /// The error type reported by the backend
+    type ErrorType: Error + Send + Sync;
+
+    /// Get the dimension of the drawing backend in pixels
+    fn get_size(&self) -> (u32, u32);
+
+    /// Ensure the backend is ready to draw
+    fn ensure_prepared(&mut self) -> Result<(), DrawingErrorKind<Self::ErrorType>>;
+
+    /// Finalize the drawing step and present all the changes.
+    /// This is used as the real-time rendering support.
+    /// The backend may implement in the following way, when `ensure_prepared` is called
+    /// it checks if it needs a fresh buffer and `present` is called rendering all the
+    /// pending changes on the screen.
+    fn present(&mut self) -> Result<(), DrawingErrorKind<Self::ErrorType>>;
+
+    /// Draw a pixel on the drawing backend
+    /// - `point`: The backend pixel-based coordinate to draw
+    /// - `color`: The color of the pixel
+    fn draw_pixel(
+        &mut self,
+        point: BackendCoord,
+        color: BackendColor,
+    ) -> Result<(), DrawingErrorKind<Self::ErrorType>>;
+
+    /// Draw a line on the drawing backend
+    /// - `from`: The start point of the line
+    /// - `to`: The end point of the line
+    /// - `style`: The style of the line
+    fn draw_line<S: BackendStyle>(
+        &mut self,
+        from: BackendCoord,
+        to: BackendCoord,
+        style: &S,
+    ) -> Result<(), DrawingErrorKind<Self::ErrorType>> {
+        rasterizer::draw_line(self, from, to, style)
+    }
+
+    /// Draw a rectangle on the drawing backend
+    /// - `upper_left`: The coordinate of the upper-left corner of the rect
+    /// - `bottom_right`: The coordinate of the bottom-right corner of the rect
+    /// - `style`: The style
+    /// - `fill`: If the rectangle should be filled
+    fn draw_rect<S: BackendStyle>(
+        &mut self,
+        upper_left: BackendCoord,
+        bottom_right: BackendCoord,
+        style: &S,
+        fill: bool,
+    ) -> Result<(), DrawingErrorKind<Self::ErrorType>> {
+        rasterizer::draw_rect(self, upper_left, bottom_right, style, fill)
+    }
+
+    /// Draw a path on the drawing backend
+    /// - `path`: The iterator of key points of the path
+    /// - `style`: The style of the path
+    fn draw_path<S: BackendStyle, I: IntoIterator<Item = BackendCoord>>(
+        &mut self,
+        path: I,
+        style: &S,
+    ) -> Result<(), DrawingErrorKind<Self::ErrorType>> {
+        if style.color().alpha == 0.0 {
+            return Ok(());
+        }
+
+        if style.stroke_width() == 1 {
+            let mut begin: Option<BackendCoord> = None;
+            for end in path.into_iter() {
+                if let Some(begin) = begin {
+                    let result = self.draw_line(begin, end, style);
+                    #[allow(clippy::question_mark)]
+                    if result.is_err() {
+                        return result;
+                    }
+                }
+                begin = Some(end);
+            }
+        } else {
+            let p: Vec<_> = path.into_iter().collect();
+            let v = rasterizer::polygonize(&p[..], style.stroke_width());
+            return self.fill_polygon(v, &style.color());
+        }
+        Ok(())
+    }
+
+    /// Draw a circle on the drawing backend
+    /// - `center`: The center coordinate of the circle
+    /// - `radius`: The radius of the circle
+    /// - `style`: The style of the shape
+    /// - `fill`: If the circle should be filled
+    fn draw_circle<S: BackendStyle>(
+        &mut self,
+        center: BackendCoord,
+        radius: u32,
+        style: &S,
+        fill: bool,
+    ) -> Result<(), DrawingErrorKind<Self::ErrorType>> {
+        rasterizer::draw_circle(self, center, radius, style, fill)
+    }
+
+    fn fill_polygon<S: BackendStyle, I: IntoIterator<Item = BackendCoord>>(
+        &mut self,
+        vert: I,
+        style: &S,
+    ) -> Result<(), DrawingErrorKind<Self::ErrorType>> {
+        let vert_buf: Vec<_> = vert.into_iter().collect();
+
+        rasterizer::fill_polygon(self, &vert_buf[..], style)
+    }
+
+    /// Draw a text on the drawing backend
+    /// - `text`: The text to draw
+    /// - `style`: The text style
+    /// - `pos` : The text anchor point
+    fn draw_text<TStyle: BackendTextStyle>(
+        &mut self,
+        text: &str,
+        style: &TStyle,
+        pos: BackendCoord,
+    ) -> Result<(), DrawingErrorKind<Self::ErrorType>> {
+        let color = style.color();
+        if color.alpha == 0.0 {
+            return Ok(());
+        }
+
+        let layout = style
+            .layout_box(text)
+            .map_err(|e| DrawingErrorKind::FontError(Box::new(e)))?;
+        let ((min_x, min_y), (max_x, max_y)) = layout;
+        let width = (max_x - min_x) as i32;
+        let height = (max_y - min_y) as i32;
+        let dx = match style.anchor().h_pos {
+            HPos::Left => 0,
+            HPos::Right => -width,
+            HPos::Center => -width / 2,
+        };
+        let dy = match style.anchor().v_pos {
+            VPos::Top => 0,
+            VPos::Center => -height / 2,
+            VPos::Bottom => -height,
+        };
+        let trans = style.transform();
+        let (w, h) = self.get_size();
+        match style.draw(text, (0, 0), |x, y, color| {
+            let (x, y) = trans.transform(x + dx - min_x, y + dy - min_y);
+            let (x, y) = (pos.0 + x, pos.1 + y);
+            if x >= 0 && x < w as i32 && y >= 0 && y < h as i32 {
+                self.draw_pixel((x, y), color)
+            } else {
+                Ok(())
+            }
+        }) {
+            Ok(drawing_result) => drawing_result,
+            Err(font_error) => Err(DrawingErrorKind::FontError(Box::new(font_error))),
+        }
+    }
+
+    /// Estimate the size of the horizontal text if rendered on this backend.
+    /// This is important because some of the backend may not have font ability.
+    /// Thus this allows those backend reports proper value rather than ask the
+    /// font rasterizer for that.
+    ///
+    /// - `text`: The text to estimate
+    /// - `font`: The font to estimate
+    /// - *Returns* The estimated text size
+    fn estimate_text_size<TStyle: BackendTextStyle>(
+        &self,
+        text: &str,
+        style: &TStyle,
+    ) -> Result<(u32, u32), DrawingErrorKind<Self::ErrorType>> {
+        let layout = style
+            .layout_box(text)
+            .map_err(|e| DrawingErrorKind::FontError(Box::new(e)))?;
+        Ok((
+            ((layout.1).0 - (layout.0).0) as u32,
+            ((layout.1).1 - (layout.0).1) as u32,
+        ))
+    }
+
+    /// Blit a bitmap on to the backend.
+    ///
+    /// - `text`: pos the left upper conner of the bitmap to blit
+    /// - `src`: The source of the image
+    ///
+    /// TODO: The default implementation of bitmap blitting assumes that the bitmap is RGB, but
+    /// this may not be the case. But for bitmap backend it's actually ok if we use the bitmap
+    /// element that matches the pixel format, but we need to fix this.
+    fn blit_bitmap(
+        &mut self,
+        pos: BackendCoord,
+        (iw, ih): (u32, u32),
+        src: &[u8],
+    ) -> Result<(), DrawingErrorKind<Self::ErrorType>> {
+        let (w, h) = self.get_size();
+
+        for dx in 0..iw {
+            if pos.0 + dx as i32 >= w as i32 {
+                break;
+            }
+            for dy in 0..ih {
+                if pos.1 + dy as i32 >= h as i32 {
+                    break;
+                }
+                // FIXME: This assume we have RGB image buffer
+                let r = src[(dx + dy * w) as usize * 3];
+                let g = src[(dx + dy * w) as usize * 3 + 1];
+                let b = src[(dx + dy * w) as usize * 3 + 2];
+                let color = BackendColor {
+                    alpha: 1.0,
+                    rgb: (r, g, b),
+                };
+                let result = self.draw_pixel((pos.0 + dx as i32, pos.1 + dy as i32), color);
+                #[allow(clippy::question_mark)]
+                if result.is_err() {
+                    return result;
+                }
+            }
+        }
+
+        Ok(())
+    }
+}
diff --git a/crates/plotters-backend/src/rasterizer/circle.rs b/crates/plotters-backend/src/rasterizer/circle.rs
new file mode 100644
index 0000000..0584167
--- /dev/null
+++ b/crates/plotters-backend/src/rasterizer/circle.rs
@@ -0,0 +1,342 @@
+use crate::{BackendCoord, BackendStyle, DrawingBackend, DrawingErrorKind};
+
+fn draw_part_a<
+    B: DrawingBackend,
+    Draw: FnMut(i32, (f64, f64)) -> Result<(), DrawingErrorKind<B::ErrorType>>,
+>(
+    height: f64,
+    radius: u32,
+    mut draw: Draw,
+) -> Result<(), DrawingErrorKind<B::ErrorType>> {
+    let half_width = (radius as f64 * radius as f64
+        - (radius as f64 - height) * (radius as f64 - height))
+        .sqrt();
+
+    let x0 = (-half_width).ceil() as i32;
+    let x1 = half_width.floor() as i32;
+
+    let y0 = (radius as f64 - height).ceil();
+
+    for x in x0..=x1 {
+        let y1 = (radius as f64 * radius as f64 - x as f64 * x as f64).sqrt();
+        check_result!(draw(x, (y0, y1)));
+    }
+
+    Ok(())
+}
+
+fn draw_part_b<
+    B: DrawingBackend,
+    Draw: FnMut(i32, (f64, f64)) -> Result<(), DrawingErrorKind<B::ErrorType>>,
+>(
+    from: f64,
+    size: f64,
+    mut draw: Draw,
+) -> Result<(), DrawingErrorKind<B::ErrorType>> {
+    let from = from.floor();
+    for x in (from - size).floor() as i32..=from as i32 {
+        check_result!(draw(x, (-x as f64, x as f64)));
+    }
+    Ok(())
+}
+
+fn draw_part_c<
+    B: DrawingBackend,
+    Draw: FnMut(i32, (f64, f64)) -> Result<(), DrawingErrorKind<B::ErrorType>>,
+>(
+    r: i32,
+    r_limit: i32,
+    mut draw: Draw,
+) -> Result<(), DrawingErrorKind<B::ErrorType>> {
+    let half_size = r as f64 / (2f64).sqrt();
+
+    let (x0, x1) = ((-half_size).ceil() as i32, half_size.floor() as i32);
+
+    for x in x0..x1 {
+        let outter_y0 = ((r_limit as f64) * (r_limit as f64) - x as f64 * x as f64).sqrt();
+        let inner_y0 = r as f64 - 1.0;
+        let mut y1 = outter_y0.min(inner_y0);
+        let y0 = ((r as f64) * (r as f64) - x as f64 * x as f64).sqrt();
+
+        if y0 > y1 {
+            y1 = y0.ceil();
+            if y1 >= r as f64 {
+                continue;
+            }
+        }
+
+        check_result!(draw(x, (y0, y1)));
+    }
+
+    for x in x1 + 1..r {
+        let outter_y0 = ((r_limit as f64) * (r_limit as f64) - x as f64 * x as f64).sqrt();
+        let inner_y0 = r as f64 - 1.0;
+        let y0 = outter_y0.min(inner_y0);
+        let y1 = x as f64;
+
+        if y1 < y0 {
+            check_result!(draw(x, (y0, y1 + 1.0)));
+            check_result!(draw(-x, (y0, y1 + 1.0)));
+        }
+    }
+
+    Ok(())
+}
+
+fn draw_sweep_line<B: DrawingBackend, S: BackendStyle>(
+    b: &mut B,
+    style: &S,
+    (x0, y0): BackendCoord,
+    (dx, dy): (i32, i32),
+    p0: i32,
+    (s, e): (f64, f64),
+) -> Result<(), DrawingErrorKind<B::ErrorType>> {
+    let mut s = if dx < 0 || dy < 0 { -s } else { s };
+    let mut e = if dx < 0 || dy < 0 { -e } else { e };
+    if s > e {
+        std::mem::swap(&mut s, &mut e);
+    }
+
+    let vs = s.ceil() - s;
+    let ve = e - e.floor();
+
+    if dx == 0 {
+        check_result!(b.draw_line(
+            (p0 + x0, s.ceil() as i32 + y0),
+            (p0 + x0, e.floor() as i32 + y0),
+            &style.color()
+        ));
+        check_result!(b.draw_pixel((p0 + x0, s.ceil() as i32 + y0 - 1), style.color().mix(vs)));
+        check_result!(b.draw_pixel((p0 + x0, e.floor() as i32 + y0 + 1), style.color().mix(ve)));
+    } else {
+        check_result!(b.draw_line(
+            (s.ceil() as i32 + x0, p0 + y0),
+            (e.floor() as i32 + x0, p0 + y0),
+            &style.color()
+        ));
+        check_result!(b.draw_pixel((s.ceil() as i32 + x0 - 1, p0 + y0), style.color().mix(vs)));
+        check_result!(b.draw_pixel((e.floor() as i32 + x0 + 1, p0 + y0), style.color().mix(ve)));
+    }
+
+    Ok(())
+}
+
+fn draw_annulus<B: DrawingBackend, S: BackendStyle>(
+    b: &mut B,
+    center: BackendCoord,
+    radius: (u32, u32),
+    style: &S,
+) -> Result<(), DrawingErrorKind<B::ErrorType>> {
+    let a0 = ((radius.0 - radius.1) as f64).min(radius.0 as f64 * (1.0 - 1.0 / (2f64).sqrt()));
+    let a1 = (radius.0 as f64 - a0 - radius.1 as f64).max(0.0);
+
+    check_result!(draw_part_a::<B, _>(a0, radius.0, |p, r| draw_sweep_line(
+        b,
+        style,
+        center,
+        (0, 1),
+        p,
+        r
+    )));
+    check_result!(draw_part_a::<B, _>(a0, radius.0, |p, r| draw_sweep_line(
+        b,
+        style,
+        center,
+        (0, -1),
+        p,
+        r
+    )));
+    check_result!(draw_part_a::<B, _>(a0, radius.0, |p, r| draw_sweep_line(
+        b,
+        style,
+        center,
+        (1, 0),
+        p,
+        r
+    )));
+    check_result!(draw_part_a::<B, _>(a0, radius.0, |p, r| draw_sweep_line(
+        b,
+        style,
+        center,
+        (-1, 0),
+        p,
+        r
+    )));
+
+    if a1 > 0.0 {
+        check_result!(draw_part_b::<B, _>(
+            radius.0 as f64 - a0,
+            a1.floor(),
+            |h, (f, t)| {
+                let h = h as i32;
+                let f = f as i32;
+                let t = t as i32;
+                check_result!(b.draw_line(
+                    (center.0 + h, center.1 + f),
+                    (center.0 + h, center.1 + t),
+                    &style.color()
+                ));
+                check_result!(b.draw_line(
+                    (center.0 - h, center.1 + f),
+                    (center.0 - h, center.1 + t),
+                    &style.color()
+                ));
+
+                check_result!(b.draw_line(
+                    (center.0 + f + 1, center.1 + h),
+                    (center.0 + t - 1, center.1 + h),
+                    &style.color()
+                ));
+                check_result!(b.draw_line(
+                    (center.0 + f + 1, center.1 - h),
+                    (center.0 + t - 1, center.1 - h),
+                    &style.color()
+                ));
+
+                Ok(())
+            }
+        ));
+    }
+
+    check_result!(draw_part_c::<B, _>(
+        radius.1 as i32,
+        radius.0 as i32,
+        |p, r| draw_sweep_line(b, style, center, (0, 1), p, r)
+    ));
+    check_result!(draw_part_c::<B, _>(
+        radius.1 as i32,
+        radius.0 as i32,
+        |p, r| draw_sweep_line(b, style, center, (0, -1), p, r)
+    ));
+    check_result!(draw_part_c::<B, _>(
+        radius.1 as i32,
+        radius.0 as i32,
+        |p, r| draw_sweep_line(b, style, center, (1, 0), p, r)
+    ));
+    check_result!(draw_part_c::<B, _>(
+        radius.1 as i32,
+        radius.0 as i32,
+        |p, r| draw_sweep_line(b, style, center, (-1, 0), p, r)
+    ));
+
+    let d_inner = ((radius.1 as f64) / (2f64).sqrt()) as i32;
+    let d_outter = (((radius.0 as f64) / (2f64).sqrt()) as i32).min(radius.1 as i32 - 1);
+    let d_outter_actually = (radius.1 as i32).min(
+        (radius.0 as f64 * radius.0 as f64 - radius.1 as f64 * radius.1 as f64 / 2.0)
+            .sqrt()
+            .ceil() as i32,
+    );
+
+    check_result!(b.draw_line(
+        (center.0 - d_inner, center.1 - d_inner),
+        (center.0 - d_outter, center.1 - d_outter),
+        &style.color()
+    ));
+    check_result!(b.draw_line(
+        (center.0 + d_inner, center.1 - d_inner),
+        (center.0 + d_outter, center.1 - d_outter),
+        &style.color()
+    ));
+    check_result!(b.draw_line(
+        (center.0 - d_inner, center.1 + d_inner),
+        (center.0 - d_outter, center.1 + d_outter),
+        &style.color()
+    ));
+    check_result!(b.draw_line(
+        (center.0 + d_inner, center.1 + d_inner),
+        (center.0 + d_outter, center.1 + d_outter),
+        &style.color()
+    ));
+
+    check_result!(b.draw_line(
+        (center.0 - d_inner, center.1 + d_inner),
+        (center.0 - d_outter_actually, center.1 + d_inner),
+        &style.color()
+    ));
+    check_result!(b.draw_line(
+        (center.0 + d_inner, center.1 - d_inner),
+        (center.0 + d_inner, center.1 - d_outter_actually),
+        &style.color()
+    ));
+    check_result!(b.draw_line(
+        (center.0 + d_inner, center.1 + d_inner),
+        (center.0 + d_inner, center.1 + d_outter_actually),
+        &style.color()
+    ));
+    check_result!(b.draw_line(
+        (center.0 + d_inner, center.1 + d_inner),
+        (center.0 + d_outter_actually, center.1 + d_inner),
+        &style.color()
+    ));
+
+    Ok(())
+}
+
+pub fn draw_circle<B: DrawingBackend, S: BackendStyle>(
+    b: &mut B,
+    center: BackendCoord,
+    mut radius: u32,
+    style: &S,
+    mut fill: bool,
+) -> Result<(), DrawingErrorKind<B::ErrorType>> {
+    if style.color().alpha == 0.0 {
+        return Ok(());
+    }
+
+    if !fill && style.stroke_width() != 1 {
+        let inner_radius = radius - (style.stroke_width() / 2).min(radius);
+        radius += style.stroke_width() / 2;
+        if inner_radius > 0 {
+            return draw_annulus(b, center, (radius, inner_radius), style);
+        } else {
+            fill = true;
+        }
+    }
+
+    let min = (f64::from(radius) * (1.0 - (2f64).sqrt() / 2.0)).ceil() as i32;
+    let max = (f64::from(radius) * (1.0 + (2f64).sqrt() / 2.0)).floor() as i32;
+
+    let range = min..=max;
+
+    let (up, down) = (
+        range.start() + center.1 - radius as i32,
+        range.end() + center.1 - radius as i32,
+    );
+
+    for dy in range {
+        let dy = dy - radius as i32;
+        let y = center.1 + dy;
+
+        let lx = (f64::from(radius) * f64::from(radius)
+            - (f64::from(dy) * f64::from(dy)).max(1e-5))
+        .sqrt();
+
+        let left = center.0 - lx.floor() as i32;
+        let right = center.0 + lx.floor() as i32;
+
+        let v = lx - lx.floor();
+
+        let x = center.0 + dy;
+        let top = center.1 - lx.floor() as i32;
+        let bottom = center.1 + lx.floor() as i32;
+
+        if fill {
+            check_result!(b.draw_line((left, y), (right, y), &style.color()));
+            check_result!(b.draw_line((x, top), (x, up - 1), &style.color()));
+            check_result!(b.draw_line((x, down + 1), (x, bottom), &style.color()));
+        } else {
+            check_result!(b.draw_pixel((left, y), style.color().mix(1.0 - v)));
+            check_result!(b.draw_pixel((right, y), style.color().mix(1.0 - v)));
+
+            check_result!(b.draw_pixel((x, top), style.color().mix(1.0 - v)));
+            check_result!(b.draw_pixel((x, bottom), style.color().mix(1.0 - v)));
+        }
+
+        check_result!(b.draw_pixel((left - 1, y), style.color().mix(v)));
+        check_result!(b.draw_pixel((right + 1, y), style.color().mix(v)));
+        check_result!(b.draw_pixel((x, top - 1), style.color().mix(v)));
+        check_result!(b.draw_pixel((x, bottom + 1), style.color().mix(v)));
+    }
+
+    Ok(())
+}
diff --git a/crates/plotters-backend/src/rasterizer/line.rs b/crates/plotters-backend/src/rasterizer/line.rs
new file mode 100644
index 0000000..17836d9
--- /dev/null
+++ b/crates/plotters-backend/src/rasterizer/line.rs
@@ -0,0 +1,123 @@
+use crate::{BackendCoord, BackendStyle, DrawingBackend, DrawingErrorKind};
+
+pub fn draw_line<DB: DrawingBackend, S: BackendStyle>(
+    back: &mut DB,
+    mut from: BackendCoord,
+    mut to: BackendCoord,
+    style: &S,
+) -> Result<(), DrawingErrorKind<DB::ErrorType>> {
+    if style.color().alpha == 0.0 || style.stroke_width() == 0 {
+        return Ok(());
+    }
+
+    if style.stroke_width() != 1 {
+        // If the line is wider than 1px, then we need to make it a polygon
+        let v = (i64::from(to.0 - from.0), i64::from(to.1 - from.1));
+        let l = ((v.0 * v.0 + v.1 * v.1) as f64).sqrt();
+
+        if l < 1e-5 {
+            return Ok(());
+        }
+
+        let v = (v.0 as f64 / l, v.1 as f64 / l);
+
+        let r = f64::from(style.stroke_width()) / 2.0;
+        let mut trans = [(v.1 * r, -v.0 * r), (-v.1 * r, v.0 * r)];
+        let mut vertices = vec![];
+
+        for point in [from, to].iter() {
+            for t in trans.iter() {
+                vertices.push((
+                    (f64::from(point.0) + t.0) as i32,
+                    (f64::from(point.1) + t.1) as i32,
+                ))
+            }
+
+            trans.swap(0, 1);
+        }
+
+        return back.fill_polygon(vertices, style);
+    }
+
+    if from.0 == to.0 {
+        if from.1 > to.1 {
+            std::mem::swap(&mut from, &mut to);
+        }
+        for y in from.1..=to.1 {
+            check_result!(back.draw_pixel((from.0, y), style.color()));
+        }
+        return Ok(());
+    }
+
+    if from.1 == to.1 {
+        if from.0 > to.0 {
+            std::mem::swap(&mut from, &mut to);
+        }
+        for x in from.0..=to.0 {
+            check_result!(back.draw_pixel((x, from.1), style.color()));
+        }
+        return Ok(());
+    }
+
+    let steep = (from.0 - to.0).abs() < (from.1 - to.1).abs();
+
+    if steep {
+        from = (from.1, from.0);
+        to = (to.1, to.0);
+    }
+
+    let (from, to) = if from.0 > to.0 {
+        (to, from)
+    } else {
+        (from, to)
+    };
+
+    let mut size_limit = back.get_size();
+
+    if steep {
+        size_limit = (size_limit.1, size_limit.0);
+    }
+
+    let grad = f64::from(to.1 - from.1) / f64::from(to.0 - from.0);
+
+    let mut put_pixel = |(x, y): BackendCoord, b: f64| {
+        if steep {
+            back.draw_pixel((y, x), style.color().mix(b))
+        } else {
+            back.draw_pixel((x, y), style.color().mix(b))
+        }
+    };
+
+    let y_step_limit =
+        (f64::from(to.1.min(size_limit.1 as i32 - 1).max(0) - from.1) / grad).floor() as i32;
+
+    let batch_start = (f64::from(from.1.min(size_limit.1 as i32 - 2).max(0) - from.1) / grad)
+        .abs()
+        .ceil() as i32
+        + from.0;
+
+    let batch_limit =
+        to.0.min(size_limit.0 as i32 - 2)
+            .min(from.0 + y_step_limit - 1);
+
+    let mut y = f64::from(from.1) + f64::from(batch_start - from.0) * grad;
+
+    for x in batch_start..=batch_limit {
+        check_result!(put_pixel((x, y as i32), 1.0 + y.floor() - y));
+        check_result!(put_pixel((x, y as i32 + 1), y - y.floor()));
+
+        y += grad;
+    }
+
+    if to.0 > batch_limit && y < f64::from(to.1) {
+        let x = batch_limit as i32 + 1;
+        if 1.0 + y.floor() - y > 1e-5 {
+            check_result!(put_pixel((x, y as i32), 1.0 + y.floor() - y));
+        }
+        if y - y.floor() > 1e-5 && y + 1.0 < f64::from(to.1) {
+            check_result!(put_pixel((x, y as i32 + 1), y - y.floor()));
+        }
+    }
+
+    Ok(())
+}
diff --git a/crates/plotters-backend/src/rasterizer/mod.rs b/crates/plotters-backend/src/rasterizer/mod.rs
new file mode 100644
index 0000000..b475acd
--- /dev/null
+++ b/crates/plotters-backend/src/rasterizer/mod.rs
@@ -0,0 +1,41 @@
+/*! # The built-in rasterizers.
+
+  Plotters make a minimal backend ability assumption - which is drawing a pixel on
+  backend. And this is the rasterizer that utilize this minimal ability to build a
+  fully functioning backend.
+
+*/
+
+// TODO: We need to revisit this. It has been a long time since last time we figured out
+// the question mark operator has a huge performance impact due to LLVM unable to handle it.
+// So the question is if this trick is still useful, or LLVM is smart enough to handle it since
+// then.
+//
+// --
+// Original comment:
+//
+// ? operator is very slow. See issue #58 for details
+macro_rules! check_result {
+    ($e:expr) => {
+        let result = $e;
+        #[allow(clippy::question_mark)]
+        if result.is_err() {
+            return result;
+        }
+    };
+}
+
+mod line;
+pub use line::draw_line;
+
+mod rect;
+pub use rect::draw_rect;
+
+mod circle;
+pub use circle::draw_circle;
+
+mod polygon;
+pub use polygon::fill_polygon;
+
+mod path;
+pub use path::polygonize;
diff --git a/crates/plotters-backend/src/rasterizer/path.rs b/crates/plotters-backend/src/rasterizer/path.rs
new file mode 100644
index 0000000..eae0bfe
--- /dev/null
+++ b/crates/plotters-backend/src/rasterizer/path.rs
@@ -0,0 +1,151 @@
+use crate::BackendCoord;
+
+// Compute the tanginal and normal vectors of the given straight line.
+fn get_dir_vector(from: BackendCoord, to: BackendCoord, flag: bool) -> ((f64, f64), (f64, f64)) {
+    let v = (i64::from(to.0 - from.0), i64::from(to.1 - from.1));
+    let l = ((v.0 * v.0 + v.1 * v.1) as f64).sqrt();
+
+    let v = (v.0 as f64 / l, v.1 as f64 / l);
+
+    if flag {
+        (v, (v.1, -v.0))
+    } else {
+        (v, (-v.1, v.0))
+    }
+}
+
+// Compute the polygonized vertex of the given angle
+// d is the distance between the polygon edge and the actual line.
+// d can be negative, this will emit a vertex on the other side of the line.
+fn compute_polygon_vertex(triple: &[BackendCoord; 3], d: f64, buf: &mut Vec<BackendCoord>) {
+    buf.clear();
+
+    // Compute the tanginal and normal vectors of the given straight line.
+    let (a_t, a_n) = get_dir_vector(triple[0], triple[1], false);
+    let (b_t, b_n) = get_dir_vector(triple[2], triple[1], true);
+
+    // Compute a point that is d away from the line for line a and line b.
+    let a_p = (
+        f64::from(triple[1].0) + d * a_n.0,
+        f64::from(triple[1].1) + d * a_n.1,
+    );
+    let b_p = (
+        f64::from(triple[1].0) + d * b_n.0,
+        f64::from(triple[1].1) + d * b_n.1,
+    );
+
+    // Check if 3 points are colinear. If so, just emit the point.
+    if a_t.1 * b_t.0 == a_t.0 * b_t.1 {
+        buf.push((a_p.0 as i32, a_p.1 as i32));
+        return;
+    }
+
+    // So we are actually computing the intersection of two lines:
+    // a_p + u * a_t and b_p + v * b_t.
+    // We can solve the following vector equation:
+    // u * a_t + a_p = v * b_t + b_p
+    //
+    // which is actually a equation system:
+    // u * a_t.0 - v * b_t.0 = b_p.0 - a_p.0
+    // u * a_t.1 - v * b_t.1 = b_p.1 - a_p.1
+
+    // The following vars are coefficients of the linear equation system.
+    // a0*u + b0*v = c0
+    // a1*u + b1*v = c1
+    // in which x and y are the coordinates that two polygon edges intersect.
+
+    let a0 = a_t.0;
+    let b0 = -b_t.0;
+    let c0 = b_p.0 - a_p.0;
+    let a1 = a_t.1;
+    let b1 = -b_t.1;
+    let c1 = b_p.1 - a_p.1;
+
+    let mut x = f64::INFINITY;
+    let mut y = f64::INFINITY;
+
+    // Well if the determinant is not 0, then we can actuall get a intersection point.
+    if (a0 * b1 - a1 * b0).abs() > f64::EPSILON {
+        let u = (c0 * b1 - c1 * b0) / (a0 * b1 - a1 * b0);
+
+        x = a_p.0 + u * a_t.0;
+        y = a_p.1 + u * a_t.1;
+    }
+
+    let cross_product = a_t.0 * b_t.1 - a_t.1 * b_t.0;
+    if (cross_product < 0.0 && d < 0.0) || (cross_product > 0.0 && d > 0.0) {
+        // Then we are at the outter side of the angle, so we need to consider a cap.
+        let dist_square = (x - triple[1].0 as f64).powi(2) + (y - triple[1].1 as f64).powi(2);
+        // If the point is too far away from the line, we need to cap it.
+        if dist_square > d * d * 16.0 {
+            buf.push((a_p.0.round() as i32, a_p.1.round() as i32));
+            buf.push((b_p.0.round() as i32, b_p.1.round() as i32));
+            return;
+        }
+    }
+
+    buf.push((x.round() as i32, y.round() as i32));
+}
+
+fn traverse_vertices<'a>(
+    mut vertices: impl Iterator<Item = &'a BackendCoord>,
+    width: u32,
+    mut op: impl FnMut(BackendCoord),
+) {
+    let mut a = vertices.next().unwrap();
+    let mut b = vertices.next().unwrap();
+
+    while a == b {
+        a = b;
+        if let Some(new_b) = vertices.next() {
+            b = new_b;
+        } else {
+            return;
+        }
+    }
+
+    let (_, n) = get_dir_vector(*a, *b, false);
+
+    op((
+        (f64::from(a.0) + n.0 * f64::from(width) / 2.0).round() as i32,
+        (f64::from(a.1) + n.1 * f64::from(width) / 2.0).round() as i32,
+    ));
+
+    let mut recent = [(0, 0), *a, *b];
+    let mut vertex_buf = Vec::with_capacity(3);
+
+    for p in vertices {
+        if *p == recent[2] {
+            continue;
+        }
+        recent.swap(0, 1);
+        recent.swap(1, 2);
+        recent[2] = *p;
+        compute_polygon_vertex(&recent, f64::from(width) / 2.0, &mut vertex_buf);
+        vertex_buf.iter().cloned().for_each(&mut op);
+    }
+
+    let b = recent[1];
+    let a = recent[2];
+
+    let (_, n) = get_dir_vector(a, b, true);
+
+    op((
+        (f64::from(a.0) + n.0 * f64::from(width) / 2.0).round() as i32,
+        (f64::from(a.1) + n.1 * f64::from(width) / 2.0).round() as i32,
+    ));
+}
+
+/// Covert a path with >1px stroke width into polygon.
+pub fn polygonize(vertices: &[BackendCoord], stroke_width: u32) -> Vec<BackendCoord> {
+    if vertices.len() < 2 {
+        return vec![];
+    }
+
+    let mut ret = vec![];
+
+    traverse_vertices(vertices.iter(), stroke_width, |v| ret.push(v));
+    traverse_vertices(vertices.iter().rev(), stroke_width, |v| ret.push(v));
+
+    ret
+}
diff --git a/crates/plotters-backend/src/rasterizer/polygon.rs b/crates/plotters-backend/src/rasterizer/polygon.rs
new file mode 100644
index 0000000..ce33c5c
--- /dev/null
+++ b/crates/plotters-backend/src/rasterizer/polygon.rs
@@ -0,0 +1,242 @@
+use crate::{BackendCoord, BackendStyle, DrawingBackend, DrawingErrorKind};
+
+use std::cmp::{Ord, Ordering, PartialOrd};
+
+#[derive(Clone, Debug)]
+struct Edge {
+    epoch: u32,
+    total_epoch: u32,
+    slave_begin: i32,
+    slave_end: i32,
+}
+
+impl Edge {
+    fn horizontal_sweep(mut from: BackendCoord, mut to: BackendCoord) -> Option<Edge> {
+        if from.0 == to.0 {
+            return None;
+        }
+
+        if from.0 > to.0 {
+            std::mem::swap(&mut from, &mut to);
+        }
+
+        Some(Edge {
+            epoch: 0,
+            total_epoch: (to.0 - from.0) as u32,
+            slave_begin: from.1,
+            slave_end: to.1,
+        })
+    }
+
+    fn vertical_sweep(from: BackendCoord, to: BackendCoord) -> Option<Edge> {
+        Edge::horizontal_sweep((from.1, from.0), (to.1, to.0))
+    }
+
+    fn get_master_pos(&self) -> i32 {
+        (self.total_epoch - self.epoch) as i32
+    }
+
+    fn inc_epoch(&mut self) {
+        self.epoch += 1;
+    }
+
+    fn get_slave_pos(&self) -> f64 {
+        f64::from(self.slave_begin)
+            + (i64::from(self.slave_end - self.slave_begin) * i64::from(self.epoch)) as f64
+                / f64::from(self.total_epoch)
+    }
+}
+
+impl PartialOrd for Edge {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        self.get_slave_pos().partial_cmp(&other.get_slave_pos())
+    }
+}
+
+impl PartialEq for Edge {
+    fn eq(&self, other: &Self) -> bool {
+        self.get_slave_pos() == other.get_slave_pos()
+    }
+}
+
+impl Eq for Edge {}
+
+impl Ord for Edge {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.get_slave_pos()
+            .partial_cmp(&other.get_slave_pos())
+            .unwrap()
+    }
+}
+
+pub fn fill_polygon<DB: DrawingBackend, S: BackendStyle>(
+    back: &mut DB,
+    vertices: &[BackendCoord],
+    style: &S,
+) -> Result<(), DrawingErrorKind<DB::ErrorType>> {
+    if let Some((x_span, y_span)) =
+        vertices
+            .iter()
+            .fold(None, |res: Option<((i32, i32), (i32, i32))>, (x, y)| {
+                Some(
+                    res.map(|((min_x, max_x), (min_y, max_y))| {
+                        (
+                            (min_x.min(*x), max_x.max(*x)),
+                            (min_y.min(*y), max_y.max(*y)),
+                        )
+                    })
+                    .unwrap_or(((*x, *x), (*y, *y))),
+                )
+            })
+    {
+        // First of all, let's handle the case that all the points is in a same vertical or
+        // horizontal line
+        if x_span.0 == x_span.1 || y_span.0 == y_span.1 {
+            return back.draw_line((x_span.0, y_span.0), (x_span.1, y_span.1), style);
+        }
+
+        let horizontal_sweep = x_span.1 - x_span.0 > y_span.1 - y_span.0;
+
+        let mut edges: Vec<_> = vertices
+            .iter()
+            .zip(vertices.iter().skip(1))
+            .map(|(a, b)| (*a, *b))
+            .collect();
+        edges.push((vertices[vertices.len() - 1], vertices[0]));
+        edges.sort_by_key(|((x1, y1), (x2, y2))| {
+            if horizontal_sweep {
+                *x1.min(x2)
+            } else {
+                *y1.min(y2)
+            }
+        });
+
+        for edge in &mut edges.iter_mut() {
+            if horizontal_sweep {
+                if (edge.0).0 > (edge.1).0 {
+                    std::mem::swap(&mut edge.0, &mut edge.1);
+                }
+            } else if (edge.0).1 > (edge.1).1 {
+                std::mem::swap(&mut edge.0, &mut edge.1);
+            }
+        }
+
+        let (low, high) = if horizontal_sweep { x_span } else { y_span };
+
+        let mut idx = 0;
+
+        let mut active_edge: Vec<Edge> = vec![];
+
+        for sweep_line in low..=high {
+            let mut new_vec = vec![];
+
+            for mut e in active_edge {
+                if e.get_master_pos() > 0 {
+                    e.inc_epoch();
+                    new_vec.push(e);
+                }
+            }
+
+            active_edge = new_vec;
+
+            loop {
+                if idx >= edges.len() {
+                    break;
+                }
+                let line = if horizontal_sweep {
+                    (edges[idx].0).0
+                } else {
+                    (edges[idx].0).1
+                };
+                if line > sweep_line {
+                    break;
+                }
+
+                let edge_obj = if horizontal_sweep {
+                    Edge::horizontal_sweep(edges[idx].0, edges[idx].1)
+                } else {
+                    Edge::vertical_sweep(edges[idx].0, edges[idx].1)
+                };
+
+                if let Some(edge_obj) = edge_obj {
+                    active_edge.push(edge_obj);
+                }
+
+                idx += 1;
+            }
+
+            active_edge.sort();
+
+            let mut first = None;
+            let mut second = None;
+
+            for edge in active_edge.iter() {
+                if first.is_none() {
+                    first = Some(edge.clone())
+                } else if second.is_none() {
+                    second = Some(edge.clone())
+                }
+
+                if let Some(a) = first.clone() {
+                    if let Some(b) = second.clone() {
+                        if a.get_master_pos() == 0 && b.get_master_pos() != 0 {
+                            first = Some(b);
+                            second = None;
+                            continue;
+                        }
+
+                        if a.get_master_pos() != 0 && b.get_master_pos() == 0 {
+                            first = Some(a);
+                            second = None;
+                            continue;
+                        }
+
+                        let from = a.get_slave_pos();
+                        let to = b.get_slave_pos();
+
+                        if a.get_master_pos() == 0 && b.get_master_pos() == 0 && to - from > 1.0 {
+                            first = None;
+                            second = None;
+                            continue;
+                        }
+
+                        if horizontal_sweep {
+                            check_result!(back.draw_line(
+                                (sweep_line, from.ceil() as i32),
+                                (sweep_line, to.floor() as i32),
+                                &style.color(),
+                            ));
+                            check_result!(back.draw_pixel(
+                                (sweep_line, from.floor() as i32),
+                                style.color().mix(from.ceil() - from),
+                            ));
+                            check_result!(back.draw_pixel(
+                                (sweep_line, to.ceil() as i32),
+                                style.color().mix(to - to.floor()),
+                            ));
+                        } else {
+                            check_result!(back.draw_line(
+                                (from.ceil() as i32, sweep_line),
+                                (to.floor() as i32, sweep_line),
+                                &style.color(),
+                            ));
+                            check_result!(back.draw_pixel(
+                                (from.floor() as i32, sweep_line),
+                                style.color().mix(from.ceil() - from),
+                            ));
+                            check_result!(back.draw_pixel(
+                                (to.ceil() as i32, sweep_line),
+                                style.color().mix(to.floor() - to),
+                            ));
+                        }
+
+                        first = None;
+                        second = None;
+                    }
+                }
+            }
+        }
+    }
+
+    Ok(())
+}
diff --git a/crates/plotters-backend/src/rasterizer/rect.rs b/crates/plotters-backend/src/rasterizer/rect.rs
new file mode 100644
index 0000000..cd6c774
--- /dev/null
+++ b/crates/plotters-backend/src/rasterizer/rect.rs
@@ -0,0 +1,57 @@
+use crate::{BackendCoord, BackendStyle, DrawingBackend, DrawingErrorKind};
+
+pub fn draw_rect<B: DrawingBackend, S: BackendStyle>(
+    b: &mut B,
+    upper_left: BackendCoord,
+    bottom_right: BackendCoord,
+    style: &S,
+    fill: bool,
+) -> Result<(), DrawingErrorKind<B::ErrorType>> {
+    if style.color().alpha == 0.0 {
+        return Ok(());
+    }
+    let (upper_left, bottom_right) = (
+        (
+            upper_left.0.min(bottom_right.0),
+            upper_left.1.min(bottom_right.1),
+        ),
+        (
+            upper_left.0.max(bottom_right.0),
+            upper_left.1.max(bottom_right.1),
+        ),
+    );
+
+    if fill {
+        if bottom_right.0 - upper_left.0 < bottom_right.1 - upper_left.1 {
+            for x in upper_left.0..=bottom_right.0 {
+                check_result!(b.draw_line((x, upper_left.1), (x, bottom_right.1), style));
+            }
+        } else {
+            for y in upper_left.1..=bottom_right.1 {
+                check_result!(b.draw_line((upper_left.0, y), (bottom_right.0, y), style));
+            }
+        }
+    } else {
+        b.draw_line(
+            (upper_left.0, upper_left.1),
+            (upper_left.0, bottom_right.1),
+            style,
+        )?;
+        b.draw_line(
+            (upper_left.0, upper_left.1),
+            (bottom_right.0, upper_left.1),
+            style,
+        )?;
+        b.draw_line(
+            (bottom_right.0, bottom_right.1),
+            (upper_left.0, bottom_right.1),
+            style,
+        )?;
+        b.draw_line(
+            (bottom_right.0, bottom_right.1),
+            (bottom_right.0, upper_left.1),
+            style,
+        )?;
+    }
+    Ok(())
+}
diff --git a/crates/plotters-backend/src/style.rs b/crates/plotters-backend/src/style.rs
new file mode 100644
index 0000000..028a06b
--- /dev/null
+++ b/crates/plotters-backend/src/style.rs
@@ -0,0 +1,33 @@
+/// The color type that is used by all the backend
+#[derive(Clone, Copy)]
+pub struct BackendColor {
+    pub alpha: f64,
+    pub rgb: (u8, u8, u8),
+}
+
+impl BackendColor {
+    #[inline(always)]
+    pub fn mix(&self, alpha: f64) -> Self {
+        Self {
+            alpha: self.alpha * alpha,
+            rgb: self.rgb,
+        }
+    }
+}
+
+/// The style data for the backend drawing API
+pub trait BackendStyle {
+    /// Get the color of current style
+    fn color(&self) -> BackendColor;
+
+    /// Get the stroke width of current style
+    fn stroke_width(&self) -> u32 {
+        1
+    }
+}
+
+impl BackendStyle for BackendColor {
+    fn color(&self) -> BackendColor {
+        *self
+    }
+}
diff --git a/crates/plotters-backend/src/text.rs b/crates/plotters-backend/src/text.rs
new file mode 100644
index 0000000..16e2c66
--- /dev/null
+++ b/crates/plotters-backend/src/text.rs
@@ -0,0 +1,245 @@
+use super::{BackendColor, BackendCoord};
+use std::error::Error;
+
+/// Describes font family.
+/// This can be either a specific font family name, such as "arial",
+/// or a general font family class, such as "serif" and "sans-serif"
+#[derive(Clone, Copy)]
+pub enum FontFamily<'a> {
+    /// The system default serif font family
+    Serif,
+    /// The system default sans-serif font family
+    SansSerif,
+    /// The system default monospace font
+    Monospace,
+    /// A specific font family name
+    Name(&'a str),
+}
+
+impl<'a> FontFamily<'a> {
+    /// Make a CSS compatible string for the font family name.
+    /// This can be used as the value of `font-family` attribute in SVG.
+    pub fn as_str(&self) -> &str {
+        match self {
+            FontFamily::Serif => "serif",
+            FontFamily::SansSerif => "sans-serif",
+            FontFamily::Monospace => "monospace",
+            FontFamily::Name(face) => face,
+        }
+    }
+}
+
+impl<'a> From<&'a str> for FontFamily<'a> {
+    fn from(from: &'a str) -> FontFamily<'a> {
+        match from.to_lowercase().as_str() {
+            "serif" => FontFamily::Serif,
+            "sans-serif" => FontFamily::SansSerif,
+            "monospace" => FontFamily::Monospace,
+            _ => FontFamily::Name(from),
+        }
+    }
+}
+
+/// Text anchor attributes are used to properly position the text.
+///
+/// # Examples
+///
+/// In the example below, the text anchor (X) position is `Pos::new(HPos::Right, VPos::Center)`.
+/// ```text
+///    ***** X
+/// ```
+/// The position is always relative to the text regardless of its rotation.
+/// In the example below, the text has style
+/// `style.transform(FontTransform::Rotate90).pos(Pos::new(HPos::Center, VPos::Top))`.
+/// ```text
+///        *
+///        *
+///        * X
+///        *
+///        *
+/// ```
+pub mod text_anchor {
+    /// The horizontal position of the anchor point relative to the text.
+    #[derive(Clone, Copy)]
+    pub enum HPos {
+        /// Anchor point is on the left side of the text
+        Left,
+        /// Anchor point is on the right side of the text
+        Right,
+        /// Anchor point is in the horizontal center of the text
+        Center,
+    }
+
+    /// The vertical position of the anchor point relative to the text.
+    #[derive(Clone, Copy)]
+    pub enum VPos {
+        /// Anchor point is on the top of the text
+        Top,
+        /// Anchor point is in the vertical center of the text
+        Center,
+        /// Anchor point is on the bottom of the text
+        Bottom,
+    }
+
+    /// The text anchor position.
+    #[derive(Clone, Copy)]
+    pub struct Pos {
+        /// The horizontal position of the anchor point
+        pub h_pos: HPos,
+        /// The vertical position of the anchor point
+        pub v_pos: VPos,
+    }
+
+    impl Pos {
+        /// Create a new text anchor position.
+        ///
+        /// - `h_pos`: The horizontal position of the anchor point
+        /// - `v_pos`: The vertical position of the anchor point
+        /// - **returns** The newly created text anchor position
+        ///
+        /// ```rust
+        /// use plotters_backend::text_anchor::{Pos, HPos, VPos};
+        ///
+        /// let pos = Pos::new(HPos::Left, VPos::Top);
+        /// ```
+        pub fn new(h_pos: HPos, v_pos: VPos) -> Self {
+            Pos { h_pos, v_pos }
+        }
+
+        /// Create a default text anchor position (top left).
+        ///
+        /// - **returns** The default text anchor position
+        ///
+        /// ```rust
+        /// use plotters_backend::text_anchor::{Pos, HPos, VPos};
+        ///
+        /// let pos = Pos::default();
+        /// ```
+        pub fn default() -> Self {
+            Pos {
+                h_pos: HPos::Left,
+                v_pos: VPos::Top,
+            }
+        }
+    }
+}
+
+/// Specifying text transformations
+#[derive(Clone)]
+pub enum FontTransform {
+    /// Nothing to transform
+    None,
+    /// Rotating the text 90 degree clockwise
+    Rotate90,
+    /// Rotating the text 180 degree clockwise
+    Rotate180,
+    /// Rotating the text 270 degree clockwise
+    Rotate270,
+}
+
+impl FontTransform {
+    /// Transform the coordinate to perform the rotation
+    ///
+    /// - `x`: The x coordinate in pixels before transform
+    /// - `y`: The y coordinate in pixels before transform
+    /// - **returns**: The coordinate after transform
+    pub fn transform(&self, x: i32, y: i32) -> (i32, i32) {
+        match self {
+            FontTransform::None => (x, y),
+            FontTransform::Rotate90 => (-y, x),
+            FontTransform::Rotate180 => (-x, -y),
+            FontTransform::Rotate270 => (y, -x),
+        }
+    }
+}
+
+/// Describes the font style. Such as Italic, Oblique, etc.
+#[derive(Clone, Copy)]
+pub enum FontStyle {
+    /// The normal style
+    Normal,
+    /// The oblique style
+    Oblique,
+    /// The italic style
+    Italic,
+    /// The bold style
+    Bold,
+}
+
+impl FontStyle {
+    /// Convert the font style into a CSS compatible string which can be used in `font-style` attribute.
+    pub fn as_str(&self) -> &str {
+        match self {
+            FontStyle::Normal => "normal",
+            FontStyle::Italic => "italic",
+            FontStyle::Oblique => "oblique",
+            FontStyle::Bold => "bold",
+        }
+    }
+}
+
+impl<'a> From<&'a str> for FontStyle {
+    fn from(from: &'a str) -> FontStyle {
+        match from.to_lowercase().as_str() {
+            "normal" => FontStyle::Normal,
+            "italic" => FontStyle::Italic,
+            "oblique" => FontStyle::Oblique,
+            "bold" => FontStyle::Bold,
+            _ => FontStyle::Normal,
+        }
+    }
+}
+
+/// The trait that abstracts a style of a text.
+///
+/// This is used because the the backend crate have no knowledge about how
+/// the text handling is implemented in plotters.
+///
+/// But the backend still wants to know some information about the font, for
+/// the backend doesn't handles text drawing, may want to call the `draw` method which
+/// is implemented by the plotters main crate. While for the backend that handles the
+/// text drawing, those font information provides instructions about how the text should be
+/// rendered: color, size, slant, anchor, font, etc.
+///
+/// This trait decouples the detailed implementaiton about the font and the backend code which
+/// wants to perfome some operation on the font.
+///
+pub trait BackendTextStyle {
+    /// The error type of this text style implementation
+    type FontError: Error + Sync + Send + 'static;
+
+    fn color(&self) -> BackendColor {
+        BackendColor {
+            alpha: 1.0,
+            rgb: (0, 0, 0),
+        }
+    }
+
+    fn size(&self) -> f64 {
+        1.0
+    }
+
+    fn transform(&self) -> FontTransform {
+        FontTransform::None
+    }
+
+    fn style(&self) -> FontStyle {
+        FontStyle::Normal
+    }
+
+    fn anchor(&self) -> text_anchor::Pos {
+        text_anchor::Pos::default()
+    }
+
+    fn family(&self) -> FontFamily;
+
+    #[allow(clippy::type_complexity)]
+    fn layout_box(&self, text: &str) -> Result<((i32, i32), (i32, i32)), Self::FontError>;
+
+    fn draw<E, DrawFunc: FnMut(i32, i32, BackendColor) -> Result<(), E>>(
+        &self,
+        text: &str,
+        pos: BackendCoord,
+        draw: DrawFunc,
+    ) -> Result<Result<(), E>, Self::FontError>;
+}
diff --git a/crates/plotters-svg/.cargo-checksum.json b/crates/plotters-svg/.cargo-checksum.json
new file mode 100644
index 0000000..6aaf347
--- /dev/null
+++ b/crates/plotters-svg/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"ba1b45b6791e3e6579282ccb15918ac3a3e78f1c87f40916b3e4542f60590555","LICENSE":"1e881ecf2862d01e6e5bc2b861e46886d2a6fb01499c0c508a209a7271b13cf2","README.md":"4e8a1eb3407b1e7366fa6cb5ebfbc87b9e64bf67fcdc2dcf775c1c6ccec04a2d","src/lib.rs":"a16cb6c509cf49213b2955815679bc33db413f5fc17263470d601eb23deb648a","src/svg.rs":"5b7188891265c25b5cc496f30ac2e7ecc50b9c27d4a4262c6621e7154376d46b"},"package":"38f6d39893cca0701371e3c27294f09797214b86f1fb951b89ade8ec04e2abab"}
\ No newline at end of file
diff --git a/crates/plotters-svg/Android.bp b/crates/plotters-svg/Android.bp
new file mode 100644
index 0000000..1b24c16
--- /dev/null
+++ b/crates/plotters-svg/Android.bp
@@ -0,0 +1,31 @@
+// This file is generated by cargo_embargo.
+// Do not modify this file because the changes will be overridden on upgrade.
+
+package {
+    default_applicable_licenses: ["external_rust_crates_plotters-svg_license"],
+    default_team: "trendy_team_android_rust",
+}
+
+license {
+    name: "external_rust_crates_plotters-svg_license",
+    visibility: [":__subpackages__"],
+    license_kinds: ["SPDX-license-identifier-MIT"],
+    license_text: ["LICENSE"],
+}
+
+rust_library {
+    name: "libplotters_svg",
+    host_supported: true,
+    crate_name: "plotters_svg",
+    cargo_env_compat: true,
+    cargo_pkg_version: "0.3.5",
+    crate_root: "src/lib.rs",
+    edition: "2018",
+    rustlibs: ["libplotters_backend"],
+    apex_available: [
+        "//apex_available:platform",
+        "//apex_available:anyapex",
+    ],
+    product_available: true,
+    vendor_available: true,
+}
diff --git a/crates/plotters-svg/Cargo.lock b/crates/plotters-svg/Cargo.lock
new file mode 100644
index 0000000..fd54bb7
--- /dev/null
+++ b/crates/plotters-svg/Cargo.lock
@@ -0,0 +1,160 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "adler"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
+
+[[package]]
+name = "adler2"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "512761e0bb2578dd7380c6baaa0f4ce03e84f95e960231d1dec8bf4d7d6e2627"
+
+[[package]]
+name = "autocfg"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0"
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "bytemuck"
+version = "1.17.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773d90827bc3feecfb67fab12e24de0749aad83c74b9504ecde46237b5cd24e2"
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "color_quant"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b"
+
+[[package]]
+name = "crc32fast"
+version = "1.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a97769d94ddab943e4510d138150169a2758b5ef3eb191a9ee688de3e23ef7b3"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "fdeflate"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4f9bfee30e4dedf0ab8b422f03af778d9612b63f502710fc500a334ebe2de645"
+dependencies = [
+ "simd-adler32",
+]
+
+[[package]]
+name = "flate2"
+version = "1.0.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "324a1be68054ef05ad64b861cc9eaf1d623d2d8cb25b4bf2cb9cdd902b4bf253"
+dependencies = [
+ "crc32fast",
+ "miniz_oxide 0.8.0",
+]
+
+[[package]]
+name = "image"
+version = "0.24.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5690139d2f55868e080017335e4b94cb7414274c74f1669c84fb5feba2c9f69d"
+dependencies = [
+ "bytemuck",
+ "byteorder",
+ "color_quant",
+ "jpeg-decoder",
+ "num-traits",
+ "png",
+]
+
+[[package]]
+name = "jpeg-decoder"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f5d4a7da358eff58addd2877a45865158f0d78c911d43a5784ceb7bbf52833b0"
+
+[[package]]
+name = "miniz_oxide"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8a240ddb74feaf34a79a7add65a741f3167852fba007066dcac1ca548d89c08"
+dependencies = [
+ "adler",
+ "simd-adler32",
+]
+
+[[package]]
+name = "miniz_oxide"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2d80299ef12ff69b16a84bb182e3b9df68b5a91574d3d4fa6e41b65deec4df1"
+dependencies = [
+ "adler2",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "plotters-backend"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "414cec62c6634ae900ea1c56128dfe87cf63e7caece0852ec76aba307cebadb7"
+
+[[package]]
+name = "plotters-svg"
+version = "0.3.5"
+dependencies = [
+ "image",
+ "plotters-backend",
+]
+
+[[package]]
+name = "png"
+version = "0.17.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06e4b0d3d1312775e782c86c91a111aa1f910cbb65e1337f9975b5f9a554b5e1"
+dependencies = [
+ "bitflags",
+ "crc32fast",
+ "fdeflate",
+ "flate2",
+ "miniz_oxide 0.7.4",
+]
+
+[[package]]
+name = "simd-adler32"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d66dc143e6b11c1eddc06d5c423cfc97062865baf299914ab64caa38182078fe"
diff --git a/crates/plotters-svg/Cargo.toml b/crates/plotters-svg/Cargo.toml
new file mode 100644
index 0000000..e659289
--- /dev/null
+++ b/crates/plotters-svg/Cargo.toml
@@ -0,0 +1,40 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2018"
+name = "plotters-svg"
+version = "0.3.5"
+authors = ["Hao Hou <haohou302@gmail.com>"]
+description = "Plotters SVG backend"
+homepage = "https://plotters-rs.github.io"
+readme = "README.md"
+license = "MIT"
+repository = "https://github.com/plotters-rs/plotters.git"
+
+[dependencies.image]
+version = "0.24.2"
+features = [
+    "jpeg",
+    "png",
+    "bmp",
+]
+optional = true
+default-features = false
+
+[dependencies.plotters-backend]
+version = "0.3.5"
+
+[dev-dependencies]
+
+[features]
+bitmap_encoder = ["image"]
+debug = []
diff --git a/crates/plotters-svg/LICENSE b/crates/plotters-svg/LICENSE
new file mode 100644
index 0000000..ea5b606
--- /dev/null
+++ b/crates/plotters-svg/LICENSE
@@ -0,0 +1 @@
+../LICENSE
\ No newline at end of file
diff --git a/crates/plotters-svg/METADATA b/crates/plotters-svg/METADATA
new file mode 100644
index 0000000..76b5a17
--- /dev/null
+++ b/crates/plotters-svg/METADATA
@@ -0,0 +1,20 @@
+# This project was upgraded with external_updater.
+# Usage: tools/external_updater/updater.sh update external/rust/crates/plotters-svg
+# For more info, check https://cs.android.com/android/platform/superproject/+/main:tools/external_updater/README.md
+
+name: "plotters-svg"
+description: "Plotters SVG backend"
+third_party {
+  license_type: NOTICE
+  last_upgrade_date {
+    year: 2024
+    month: 2
+    day: 5
+  }
+  homepage: "https://crates.io/crates/plotters-svg"
+  identifier {
+    type: "Archive"
+    value: "https://static.crates.io/crates/plotters-svg/plotters-svg-0.3.5.crate"
+    version: "0.3.5"
+  }
+}
diff --git a/crates/plotters-svg/MODULE_LICENSE_MIT b/crates/plotters-svg/MODULE_LICENSE_MIT
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/crates/plotters-svg/MODULE_LICENSE_MIT
diff --git a/crates/plotters-svg/README.md b/crates/plotters-svg/README.md
new file mode 100644
index 0000000..0d38126
--- /dev/null
+++ b/crates/plotters-svg/README.md
@@ -0,0 +1,8 @@
+# plotters-svg - The SVG backend for Plotters
+
+This is a part of plotters project. For more details, please check the following links:
+
+- For high-level intro of Plotters, see: [Plotters on crates.io](https://crates.io/crates/plotters)
+- Check the main repo at [Plotters repo](https://github.com/plotters-rs/plotters.git)
+- For detailed documentation about this crate, check [plotters-backend on docs.rs](https://docs.rs/plotters-backend/)
+- You can also visit Plotters [Homepage](https://plotters-rs.github.io)
diff --git a/crates/plotters-svg/TEST_MAPPING b/crates/plotters-svg/TEST_MAPPING
new file mode 100644
index 0000000..3cbd48d
--- /dev/null
+++ b/crates/plotters-svg/TEST_MAPPING
@@ -0,0 +1,17 @@
+// Generated by update_crate_tests.py for tests that depend on this crate.
+{
+  "imports": [
+    {
+      "path": "external/rust/crates/base64"
+    },
+    {
+      "path": "external/rust/crates/tinytemplate"
+    },
+    {
+      "path": "external/rust/crates/tinyvec"
+    },
+    {
+      "path": "external/rust/crates/unicode-xid"
+    }
+  ]
+}
diff --git a/crates/plotters-svg/cargo_embargo.json b/crates/plotters-svg/cargo_embargo.json
new file mode 100644
index 0000000..cb908d7
--- /dev/null
+++ b/crates/plotters-svg/cargo_embargo.json
@@ -0,0 +1,3 @@
+{
+  "run_cargo": false
+}
diff --git a/crates/plotters-svg/src/lib.rs b/crates/plotters-svg/src/lib.rs
new file mode 100644
index 0000000..d4bdbe7
--- /dev/null
+++ b/crates/plotters-svg/src/lib.rs
@@ -0,0 +1,10 @@
+/*!
+   The Plotters SVG backend.
+
+   The plotters bitmap backend allows you to render images by Plotters into SVG vector graphs.
+
+   See the documentation for [SVGBackend](struct.SVGBackend.html) for more details.
+*/
+mod svg;
+
+pub use svg::SVGBackend;
diff --git a/crates/plotters-svg/src/svg.rs b/crates/plotters-svg/src/svg.rs
new file mode 100644
index 0000000..7ea105d
--- /dev/null
+++ b/crates/plotters-svg/src/svg.rs
@@ -0,0 +1,839 @@
+/*!
+The SVG image drawing backend
+*/
+
+use plotters_backend::{
+    text_anchor::{HPos, VPos},
+    BackendColor, BackendCoord, BackendStyle, BackendTextStyle, DrawingBackend, DrawingErrorKind,
+    FontStyle, FontTransform,
+};
+
+use std::fmt::Write as _;
+use std::fs::File;
+#[allow(unused_imports)]
+use std::io::Cursor;
+use std::io::{BufWriter, Error, Write};
+use std::path::Path;
+
+fn make_svg_color(color: BackendColor) -> String {
+    let (r, g, b) = color.rgb;
+    return format!("#{:02X}{:02X}{:02X}", r, g, b);
+}
+
+fn make_svg_opacity(color: BackendColor) -> String {
+    return format!("{}", color.alpha);
+}
+
+enum Target<'a> {
+    File(String, &'a Path),
+    Buffer(&'a mut String),
+    // TODO: At this point we won't make the breaking change
+    // so the u8 buffer is still supported. But in 0.3, we definitely
+    // should get rid of this.
+    #[cfg(feature = "deprecated_items")]
+    U8Buffer(String, &'a mut Vec<u8>),
+}
+
+impl Target<'_> {
+    fn get_mut(&mut self) -> &mut String {
+        match self {
+            Target::File(ref mut buf, _) => buf,
+            Target::Buffer(buf) => buf,
+            #[cfg(feature = "deprecated_items")]
+            Target::U8Buffer(ref mut buf, _) => buf,
+        }
+    }
+}
+
+enum SVGTag {
+    Svg,
+    Circle,
+    Line,
+    Polygon,
+    Polyline,
+    Rectangle,
+    Text,
+    #[allow(dead_code)]
+    Image,
+}
+
+impl SVGTag {
+    fn to_tag_name(&self) -> &'static str {
+        match self {
+            SVGTag::Svg => "svg",
+            SVGTag::Circle => "circle",
+            SVGTag::Line => "line",
+            SVGTag::Polyline => "polyline",
+            SVGTag::Rectangle => "rect",
+            SVGTag::Text => "text",
+            SVGTag::Image => "image",
+            SVGTag::Polygon => "polygon",
+        }
+    }
+}
+
+/// The SVG image drawing backend
+pub struct SVGBackend<'a> {
+    target: Target<'a>,
+    size: (u32, u32),
+    tag_stack: Vec<SVGTag>,
+    saved: bool,
+}
+
+impl<'a> SVGBackend<'a> {
+    fn escape_and_push(buf: &mut String, value: &str) {
+        value.chars().for_each(|c| match c {
+            '<' => buf.push_str("&lt;"),
+            '>' => buf.push_str("&gt;"),
+            '&' => buf.push_str("&amp;"),
+            '"' => buf.push_str("&quot;"),
+            '\'' => buf.push_str("&apos;"),
+            other => buf.push(other),
+        });
+    }
+    fn open_tag(&mut self, tag: SVGTag, attr: &[(&str, &str)], close: bool) {
+        let buf = self.target.get_mut();
+        buf.push('<');
+        buf.push_str(tag.to_tag_name());
+        for (key, value) in attr {
+            buf.push(' ');
+            buf.push_str(key);
+            buf.push_str("=\"");
+            Self::escape_and_push(buf, value);
+            buf.push('\"');
+        }
+        if close {
+            buf.push_str("/>\n");
+        } else {
+            self.tag_stack.push(tag);
+            buf.push_str(">\n");
+        }
+    }
+
+    fn close_tag(&mut self) -> bool {
+        if let Some(tag) = self.tag_stack.pop() {
+            let buf = self.target.get_mut();
+            buf.push_str("</");
+            buf.push_str(tag.to_tag_name());
+            buf.push_str(">\n");
+            return true;
+        }
+        false
+    }
+
+    fn init_svg_file(&mut self, size: (u32, u32)) {
+        self.open_tag(
+            SVGTag::Svg,
+            &[
+                ("width", &format!("{}", size.0)),
+                ("height", &format!("{}", size.1)),
+                ("viewBox", &format!("0 0 {} {}", size.0, size.1)),
+                ("xmlns", "http://www.w3.org/2000/svg"),
+            ],
+            false,
+        );
+    }
+
+    /// Create a new SVG drawing backend
+    pub fn new<T: AsRef<Path> + ?Sized>(path: &'a T, size: (u32, u32)) -> Self {
+        let mut ret = Self {
+            target: Target::File(String::default(), path.as_ref()),
+            size,
+            tag_stack: vec![],
+            saved: false,
+        };
+
+        ret.init_svg_file(size);
+        ret
+    }
+
+    /// Create a new SVG drawing backend and store the document into a u8 vector
+    #[cfg(feature = "deprecated_items")]
+    #[deprecated(
+        note = "This will be replaced by `with_string`, consider use `with_string` to avoid breaking change in the future"
+    )]
+    pub fn with_buffer(buf: &'a mut Vec<u8>, size: (u32, u32)) -> Self {
+        let mut ret = Self {
+            target: Target::U8Buffer(String::default(), buf),
+            size,
+            tag_stack: vec![],
+            saved: false,
+        };
+
+        ret.init_svg_file(size);
+
+        ret
+    }
+
+    /// Create a new SVG drawing backend and store the document into a String buffer
+    pub fn with_string(buf: &'a mut String, size: (u32, u32)) -> Self {
+        let mut ret = Self {
+            target: Target::Buffer(buf),
+            size,
+            tag_stack: vec![],
+            saved: false,
+        };
+
+        ret.init_svg_file(size);
+
+        ret
+    }
+}
+
+impl<'a> DrawingBackend for SVGBackend<'a> {
+    type ErrorType = Error;
+
+    fn get_size(&self) -> (u32, u32) {
+        self.size
+    }
+
+    fn ensure_prepared(&mut self) -> Result<(), DrawingErrorKind<Error>> {
+        Ok(())
+    }
+
+    fn present(&mut self) -> Result<(), DrawingErrorKind<Error>> {
+        if !self.saved {
+            while self.close_tag() {}
+            match self.target {
+                Target::File(ref buf, path) => {
+                    let outfile = File::create(path).map_err(DrawingErrorKind::DrawingError)?;
+                    let mut outfile = BufWriter::new(outfile);
+                    outfile
+                        .write_all(buf.as_ref())
+                        .map_err(DrawingErrorKind::DrawingError)?;
+                }
+                Target::Buffer(_) => {}
+                #[cfg(feature = "deprecated_items")]
+                Target::U8Buffer(ref actual, ref mut target) => {
+                    target.clear();
+                    target.extend_from_slice(actual.as_bytes());
+                }
+            }
+            self.saved = true;
+        }
+        Ok(())
+    }
+
+    fn draw_pixel(
+        &mut self,
+        point: BackendCoord,
+        color: BackendColor,
+    ) -> Result<(), DrawingErrorKind<Error>> {
+        if color.alpha == 0.0 {
+            return Ok(());
+        }
+        self.open_tag(
+            SVGTag::Rectangle,
+            &[
+                ("x", &format!("{}", point.0)),
+                ("y", &format!("{}", point.1)),
+                ("width", "1"),
+                ("height", "1"),
+                ("stroke", "none"),
+                ("opacity", &make_svg_opacity(color)),
+                ("fill", &make_svg_color(color)),
+            ],
+            true,
+        );
+        Ok(())
+    }
+
+    fn draw_line<S: BackendStyle>(
+        &mut self,
+        from: BackendCoord,
+        to: BackendCoord,
+        style: &S,
+    ) -> Result<(), DrawingErrorKind<Self::ErrorType>> {
+        if style.color().alpha == 0.0 {
+            return Ok(());
+        }
+        self.open_tag(
+            SVGTag::Line,
+            &[
+                ("opacity", &make_svg_opacity(style.color())),
+                ("stroke", &make_svg_color(style.color())),
+                ("stroke-width", &format!("{}", style.stroke_width())),
+                ("x1", &format!("{}", from.0)),
+                ("y1", &format!("{}", from.1)),
+                ("x2", &format!("{}", to.0)),
+                ("y2", &format!("{}", to.1)),
+            ],
+            true,
+        );
+        Ok(())
+    }
+
+    fn draw_rect<S: BackendStyle>(
+        &mut self,
+        upper_left: BackendCoord,
+        bottom_right: BackendCoord,
+        style: &S,
+        fill: bool,
+    ) -> Result<(), DrawingErrorKind<Self::ErrorType>> {
+        if style.color().alpha == 0.0 {
+            return Ok(());
+        }
+
+        let (fill, stroke) = if !fill {
+            ("none".to_string(), make_svg_color(style.color()))
+        } else {
+            (make_svg_color(style.color()), "none".to_string())
+        };
+
+        self.open_tag(
+            SVGTag::Rectangle,
+            &[
+                ("x", &format!("{}", upper_left.0)),
+                ("y", &format!("{}", upper_left.1)),
+                ("width", &format!("{}", bottom_right.0 - upper_left.0)),
+                ("height", &format!("{}", bottom_right.1 - upper_left.1)),
+                ("opacity", &make_svg_opacity(style.color())),
+                ("fill", &fill),
+                ("stroke", &stroke),
+            ],
+            true,
+        );
+
+        Ok(())
+    }
+
+    fn draw_path<S: BackendStyle, I: IntoIterator<Item = BackendCoord>>(
+        &mut self,
+        path: I,
+        style: &S,
+    ) -> Result<(), DrawingErrorKind<Self::ErrorType>> {
+        if style.color().alpha == 0.0 {
+            return Ok(());
+        }
+        self.open_tag(
+            SVGTag::Polyline,
+            &[
+                ("fill", "none"),
+                ("opacity", &make_svg_opacity(style.color())),
+                ("stroke", &make_svg_color(style.color())),
+                ("stroke-width", &format!("{}", style.stroke_width())),
+                (
+                    "points",
+                    &path.into_iter().fold(String::new(), |mut s, (x, y)| {
+                        write!(s, "{},{} ", x, y).ok();
+                        s
+                    }),
+                ),
+            ],
+            true,
+        );
+        Ok(())
+    }
+
+    fn fill_polygon<S: BackendStyle, I: IntoIterator<Item = BackendCoord>>(
+        &mut self,
+        path: I,
+        style: &S,
+    ) -> Result<(), DrawingErrorKind<Self::ErrorType>> {
+        if style.color().alpha == 0.0 {
+            return Ok(());
+        }
+        self.open_tag(
+            SVGTag::Polygon,
+            &[
+                ("opacity", &make_svg_opacity(style.color())),
+                ("fill", &make_svg_color(style.color())),
+                (
+                    "points",
+                    &path.into_iter().fold(String::new(), |mut s, (x, y)| {
+                        write!(s, "{},{} ", x, y).ok();
+                        s
+                    }),
+                ),
+            ],
+            true,
+        );
+        Ok(())
+    }
+
+    fn draw_circle<S: BackendStyle>(
+        &mut self,
+        center: BackendCoord,
+        radius: u32,
+        style: &S,
+        fill: bool,
+    ) -> Result<(), DrawingErrorKind<Self::ErrorType>> {
+        if style.color().alpha == 0.0 {
+            return Ok(());
+        }
+        let (stroke, fill) = if !fill {
+            (make_svg_color(style.color()), "none".to_string())
+        } else {
+            ("none".to_string(), make_svg_color(style.color()))
+        };
+        self.open_tag(
+            SVGTag::Circle,
+            &[
+                ("cx", &format!("{}", center.0)),
+                ("cy", &format!("{}", center.1)),
+                ("r", &format!("{}", radius)),
+                ("opacity", &make_svg_opacity(style.color())),
+                ("fill", &fill),
+                ("stroke", &stroke),
+                ("stroke-width", &format!("{}", style.stroke_width())),
+            ],
+            true,
+        );
+        Ok(())
+    }
+
+    fn draw_text<S: BackendTextStyle>(
+        &mut self,
+        text: &str,
+        style: &S,
+        pos: BackendCoord,
+    ) -> Result<(), DrawingErrorKind<Self::ErrorType>> {
+        let color = style.color();
+        if color.alpha == 0.0 {
+            return Ok(());
+        }
+
+        let (x0, y0) = pos;
+        let text_anchor = match style.anchor().h_pos {
+            HPos::Left => "start",
+            HPos::Right => "end",
+            HPos::Center => "middle",
+        };
+
+        let dy = match style.anchor().v_pos {
+            VPos::Top => "0.76em",
+            VPos::Center => "0.5ex",
+            VPos::Bottom => "-0.5ex",
+        };
+
+        #[cfg(feature = "debug")]
+        {
+            let ((fx0, fy0), (fx1, fy1)) =
+                font.layout_box(text).map_err(DrawingErrorKind::FontError)?;
+            let x0 = match style.anchor().h_pos {
+                HPos::Left => x0,
+                HPos::Center => x0 - fx1 / 2 + fx0 / 2,
+                HPos::Right => x0 - fx1 + fx0,
+            };
+            let y0 = match style.anchor().v_pos {
+                VPos::Top => y0,
+                VPos::Center => y0 - fy1 / 2 + fy0 / 2,
+                VPos::Bottom => y0 - fy1 + fy0,
+            };
+            self.draw_rect(
+                (x0, y0),
+                (x0 + fx1 - fx0, y0 + fy1 - fy0),
+                &crate::prelude::RED,
+                false,
+            )
+            .unwrap();
+            self.draw_circle((x0, y0), 2, &crate::prelude::RED, false)
+                .unwrap();
+        }
+
+        let mut attrs = vec![
+            ("x", format!("{}", x0)),
+            ("y", format!("{}", y0)),
+            ("dy", dy.to_owned()),
+            ("text-anchor", text_anchor.to_string()),
+            ("font-family", style.family().as_str().to_string()),
+            ("font-size", format!("{}", style.size() / 1.24)),
+            ("opacity", make_svg_opacity(color)),
+            ("fill", make_svg_color(color)),
+        ];
+
+        match style.style() {
+            FontStyle::Normal => {}
+            FontStyle::Bold => attrs.push(("font-weight", "bold".to_string())),
+            other_style => attrs.push(("font-style", other_style.as_str().to_string())),
+        };
+
+        let trans = style.transform();
+        match trans {
+            FontTransform::Rotate90 => {
+                attrs.push(("transform", format!("rotate(90, {}, {})", x0, y0)))
+            }
+            FontTransform::Rotate180 => {
+                attrs.push(("transform", format!("rotate(180, {}, {})", x0, y0)));
+            }
+            FontTransform::Rotate270 => {
+                attrs.push(("transform", format!("rotate(270, {}, {})", x0, y0)));
+            }
+            _ => {}
+        }
+
+        self.open_tag(
+            SVGTag::Text,
+            attrs
+                .iter()
+                .map(|(a, b)| (*a, b.as_ref()))
+                .collect::<Vec<_>>()
+                .as_ref(),
+            false,
+        );
+
+        Self::escape_and_push(self.target.get_mut(), text);
+        self.target.get_mut().push('\n');
+
+        self.close_tag();
+
+        Ok(())
+    }
+
+    #[cfg(all(not(target_arch = "wasm32"), feature = "image"))]
+    fn blit_bitmap<'b>(
+        &mut self,
+        pos: BackendCoord,
+        (w, h): (u32, u32),
+        src: &'b [u8],
+    ) -> Result<(), DrawingErrorKind<Self::ErrorType>> {
+        use image::codecs::png::PngEncoder;
+        use image::ImageEncoder;
+
+        let mut data = vec![0; 0];
+
+        {
+            let cursor = Cursor::new(&mut data);
+
+            let encoder = PngEncoder::new(cursor);
+
+            let color = image::ColorType::Rgb8;
+
+            encoder.write_image(src, w, h, color).map_err(|e| {
+                DrawingErrorKind::DrawingError(Error::new(
+                    std::io::ErrorKind::Other,
+                    format!("Image error: {}", e),
+                ))
+            })?;
+        }
+
+        let padding = (3 - data.len() % 3) % 3;
+        for _ in 0..padding {
+            data.push(0);
+        }
+
+        let mut rem_bits = 0;
+        let mut rem_num = 0;
+
+        fn cvt_base64(from: u8) -> char {
+            (if from < 26 {
+                b'A' + from
+            } else if from < 52 {
+                b'a' + from - 26
+            } else if from < 62 {
+                b'0' + from - 52
+            } else if from == 62 {
+                b'+'
+            } else {
+                b'/'
+            })
+            .into()
+        }
+
+        let mut buf = String::new();
+        buf.push_str("data:png;base64,");
+
+        for byte in data {
+            let value = (rem_bits << (6 - rem_num)) | (byte >> (rem_num + 2));
+            rem_bits = byte & ((1 << (2 + rem_num)) - 1);
+            rem_num += 2;
+
+            buf.push(cvt_base64(value));
+            if rem_num == 6 {
+                buf.push(cvt_base64(rem_bits));
+                rem_bits = 0;
+                rem_num = 0;
+            }
+        }
+
+        for _ in 0..padding {
+            buf.pop();
+            buf.push('=');
+        }
+
+        self.open_tag(
+            SVGTag::Image,
+            &[
+                ("x", &format!("{}", pos.0)),
+                ("y", &format!("{}", pos.1)),
+                ("width", &format!("{}", w)),
+                ("height", &format!("{}", h)),
+                ("href", buf.as_str()),
+            ],
+            true,
+        );
+
+        Ok(())
+    }
+}
+
+impl Drop for SVGBackend<'_> {
+    fn drop(&mut self) {
+        if !self.saved {
+            // drop should not panic, so we ignore a failed present
+            let _ = self.present();
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use plotters::element::Circle;
+    use plotters::prelude::{
+        ChartBuilder, Color, IntoDrawingArea, IntoFont, SeriesLabelPosition, TextStyle, BLACK,
+        BLUE, RED, WHITE,
+    };
+    use plotters::style::text_anchor::{HPos, Pos, VPos};
+    use std::fs;
+    use std::path::Path;
+
+    static DST_DIR: &str = "target/test/svg";
+
+    fn checked_save_file(name: &str, content: &str) {
+        /*
+          Please use the SVG file to manually verify the results.
+        */
+        assert!(!content.is_empty());
+        fs::create_dir_all(DST_DIR).unwrap();
+        let file_name = format!("{}.svg", name);
+        let file_path = Path::new(DST_DIR).join(file_name);
+        println!("{:?} created", file_path);
+        fs::write(file_path, &content).unwrap();
+    }
+
+    fn draw_mesh_with_custom_ticks(tick_size: i32, test_name: &str) {
+        let mut content: String = Default::default();
+        {
+            let root = SVGBackend::with_string(&mut content, (500, 500)).into_drawing_area();
+
+            let mut chart = ChartBuilder::on(&root)
+                .caption("This is a test", ("sans-serif", 20u32))
+                .set_all_label_area_size(40u32)
+                .build_cartesian_2d(0..10, 0..10)
+                .unwrap();
+
+            chart
+                .configure_mesh()
+                .set_all_tick_mark_size(tick_size)
+                .draw()
+                .unwrap();
+        }
+
+        checked_save_file(test_name, &content);
+
+        assert!(content.contains("This is a test"));
+    }
+
+    #[test]
+    fn test_draw_mesh_no_ticks() {
+        draw_mesh_with_custom_ticks(0, "test_draw_mesh_no_ticks");
+    }
+
+    #[test]
+    fn test_draw_mesh_negative_ticks() {
+        draw_mesh_with_custom_ticks(-10, "test_draw_mesh_negative_ticks");
+    }
+
+    #[test]
+    fn test_text_alignments() {
+        let mut content: String = Default::default();
+        {
+            let mut root = SVGBackend::with_string(&mut content, (500, 500));
+
+            let style = TextStyle::from(("sans-serif", 20).into_font())
+                .pos(Pos::new(HPos::Right, VPos::Top));
+            root.draw_text("right-align", &style, (150, 50)).unwrap();
+
+            let style = style.pos(Pos::new(HPos::Center, VPos::Top));
+            root.draw_text("center-align", &style, (150, 150)).unwrap();
+
+            let style = style.pos(Pos::new(HPos::Left, VPos::Top));
+            root.draw_text("left-align", &style, (150, 200)).unwrap();
+        }
+
+        checked_save_file("test_text_alignments", &content);
+
+        for svg_line in content.split("</text>") {
+            if let Some(anchor_and_rest) = svg_line.split("text-anchor=\"").nth(1) {
+                if anchor_and_rest.starts_with("end") {
+                    assert!(anchor_and_rest.contains("right-align"))
+                }
+                if anchor_and_rest.starts_with("middle") {
+                    assert!(anchor_and_rest.contains("center-align"))
+                }
+                if anchor_and_rest.starts_with("start") {
+                    assert!(anchor_and_rest.contains("left-align"))
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn test_text_draw() {
+        let mut content: String = Default::default();
+        {
+            let root = SVGBackend::with_string(&mut content, (1500, 800)).into_drawing_area();
+            let root = root
+                .titled("Image Title", ("sans-serif", 60).into_font())
+                .unwrap();
+
+            let mut chart = ChartBuilder::on(&root)
+                .caption("All anchor point positions", ("sans-serif", 20u32))
+                .set_all_label_area_size(40u32)
+                .build_cartesian_2d(0..100i32, 0..50i32)
+                .unwrap();
+
+            chart
+                .configure_mesh()
+                .disable_x_mesh()
+                .disable_y_mesh()
+                .x_desc("X Axis")
+                .y_desc("Y Axis")
+                .draw()
+                .unwrap();
+
+            let ((x1, y1), (x2, y2), (x3, y3)) = ((-30, 30), (0, -30), (30, 30));
+
+            for (dy, trans) in [
+                FontTransform::None,
+                FontTransform::Rotate90,
+                FontTransform::Rotate180,
+                FontTransform::Rotate270,
+            ]
+            .iter()
+            .enumerate()
+            {
+                for (dx1, h_pos) in [HPos::Left, HPos::Right, HPos::Center].iter().enumerate() {
+                    for (dx2, v_pos) in [VPos::Top, VPos::Center, VPos::Bottom].iter().enumerate() {
+                        let x = 150_i32 + (dx1 as i32 * 3 + dx2 as i32) * 150;
+                        let y = 120 + dy as i32 * 150;
+                        let draw = |x, y, text| {
+                            root.draw(&Circle::new((x, y), 3, &BLACK.mix(0.5))).unwrap();
+                            let style = TextStyle::from(("sans-serif", 20).into_font())
+                                .pos(Pos::new(*h_pos, *v_pos))
+                                .transform(trans.clone());
+                            root.draw_text(text, &style, (x, y)).unwrap();
+                        };
+                        draw(x + x1, y + y1, "dood");
+                        draw(x + x2, y + y2, "dog");
+                        draw(x + x3, y + y3, "goog");
+                    }
+                }
+            }
+        }
+
+        checked_save_file("test_text_draw", &content);
+
+        assert_eq!(content.matches("dog").count(), 36);
+        assert_eq!(content.matches("dood").count(), 36);
+        assert_eq!(content.matches("goog").count(), 36);
+    }
+
+    #[test]
+    fn test_text_clipping() {
+        let mut content: String = Default::default();
+        {
+            let (width, height) = (500_i32, 500_i32);
+            let root = SVGBackend::with_string(&mut content, (width as u32, height as u32))
+                .into_drawing_area();
+
+            let style = TextStyle::from(("sans-serif", 20).into_font())
+                .pos(Pos::new(HPos::Center, VPos::Center));
+            root.draw_text("TOP LEFT", &style, (0, 0)).unwrap();
+            root.draw_text("TOP CENTER", &style, (width / 2, 0))
+                .unwrap();
+            root.draw_text("TOP RIGHT", &style, (width, 0)).unwrap();
+
+            root.draw_text("MIDDLE LEFT", &style, (0, height / 2))
+                .unwrap();
+            root.draw_text("MIDDLE RIGHT", &style, (width, height / 2))
+                .unwrap();
+
+            root.draw_text("BOTTOM LEFT", &style, (0, height)).unwrap();
+            root.draw_text("BOTTOM CENTER", &style, (width / 2, height))
+                .unwrap();
+            root.draw_text("BOTTOM RIGHT", &style, (width, height))
+                .unwrap();
+        }
+
+        checked_save_file("test_text_clipping", &content);
+    }
+
+    #[test]
+    fn test_series_labels() {
+        let mut content = String::default();
+        {
+            let (width, height) = (500, 500);
+            let root = SVGBackend::with_string(&mut content, (width, height)).into_drawing_area();
+
+            let mut chart = ChartBuilder::on(&root)
+                .caption("All series label positions", ("sans-serif", 20u32))
+                .set_all_label_area_size(40u32)
+                .build_cartesian_2d(0..50i32, 0..50i32)
+                .unwrap();
+
+            chart
+                .configure_mesh()
+                .disable_x_mesh()
+                .disable_y_mesh()
+                .draw()
+                .unwrap();
+
+            chart
+                .draw_series(std::iter::once(Circle::new((5, 15), 5u32, &RED)))
+                .expect("Drawing error")
+                .label("Series 1")
+                .legend(|(x, y)| Circle::new((x, y), 3u32, RED.filled()));
+
+            chart
+                .draw_series(std::iter::once(Circle::new((5, 15), 10u32, &BLUE)))
+                .expect("Drawing error")
+                .label("Series 2")
+                .legend(|(x, y)| Circle::new((x, y), 3u32, BLUE.filled()));
+
+            for pos in vec![
+                SeriesLabelPosition::UpperLeft,
+                SeriesLabelPosition::MiddleLeft,
+                SeriesLabelPosition::LowerLeft,
+                SeriesLabelPosition::UpperMiddle,
+                SeriesLabelPosition::MiddleMiddle,
+                SeriesLabelPosition::LowerMiddle,
+                SeriesLabelPosition::UpperRight,
+                SeriesLabelPosition::MiddleRight,
+                SeriesLabelPosition::LowerRight,
+                SeriesLabelPosition::Coordinate(70, 70),
+            ]
+            .into_iter()
+            {
+                chart
+                    .configure_series_labels()
+                    .border_style(&BLACK.mix(0.5))
+                    .position(pos)
+                    .draw()
+                    .expect("Drawing error");
+            }
+        }
+
+        checked_save_file("test_series_labels", &content);
+    }
+
+    #[test]
+    fn test_draw_pixel_alphas() {
+        let mut content = String::default();
+        {
+            let (width, height) = (100_i32, 100_i32);
+            let root = SVGBackend::with_string(&mut content, (width as u32, height as u32))
+                .into_drawing_area();
+            root.fill(&WHITE).unwrap();
+
+            for i in -20..20 {
+                let alpha = i as f64 * 0.1;
+                root.draw_pixel((50 + i, 50 + i), &BLACK.mix(alpha))
+                    .unwrap();
+            }
+        }
+
+        checked_save_file("test_draw_pixel_alphas", &content);
+    }
+}
diff --git a/crates/ppv-lite86/.cargo-checksum.json b/crates/ppv-lite86/.cargo-checksum.json
new file mode 100644
index 0000000..8453a22
--- /dev/null
+++ b/crates/ppv-lite86/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"CHANGELOG.md":"0bd1d2bdb4a940a0d867a782644eb007e79611be0a8d74d4ba106e83597716df","Cargo.toml":"cff623f02fcb28f62506f25ca2d6898619b42b9fce4fd02bdd8b6f50b074e09c","LICENSE-APACHE":"0218327e7a480793ffdd4eb792379a9709e5c135c7ba267f709d6f6d4d70af0a","LICENSE-MIT":"4cada0bd02ea3692eee6f16400d86c6508bbd3bafb2b65fed0419f36d4f83e8f","src/generic.rs":"a49f9f8fbe3d9e67d67861e77ae9e69cc9f8181edad578be99b19cdf05bd8046","src/lib.rs":"ed340fd5f2c7f8a5dc1ed3666768b2131685b632e5c02b31ce1e847152d876c0","src/soft.rs":"11d7c36036444d3ad1267564b0913e4301d9ba485a7bb596eb39bf2a5973ff57","src/types.rs":"a1c9e993f85a99d1762597193d72ee8ff00c3f1116885040b4e4ecfbdedabf0a","src/x86_64/mod.rs":"145200e7f2dae24e4e0fd1020269132dddd652f30373f70a6b8dd40bf8327fea","src/x86_64/sse2.rs":"a7395837200b4eb03c178c762f3269ce9030187718b8ca62e15070c5c19cba96"},"package":"5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"}
\ No newline at end of file
diff --git a/crates/ppv-lite86/Android.bp b/crates/ppv-lite86/Android.bp
new file mode 100644
index 0000000..f8a5565
--- /dev/null
+++ b/crates/ppv-lite86/Android.bp
@@ -0,0 +1,53 @@
+// This file is generated by cargo_embargo.
+// Do not modify this file because the changes will be overridden on upgrade.
+
+package {
+    default_applicable_licenses: ["external_rust_crates_ppv-lite86_license"],
+    default_team: "trendy_team_android_rust",
+}
+
+license {
+    name: "external_rust_crates_ppv-lite86_license",
+    visibility: [":__subpackages__"],
+    license_kinds: ["SPDX-license-identifier-Apache-2.0"],
+    license_text: ["LICENSE"],
+}
+
+rust_library {
+    name: "libppv_lite86",
+    host_supported: true,
+    crate_name: "ppv_lite86",
+    cargo_env_compat: true,
+    cargo_pkg_version: "0.2.17",
+    crate_root: "src/lib.rs",
+    edition: "2018",
+    features: [
+        "default",
+        "std",
+    ],
+    apex_available: [
+        "//apex_available:platform",
+        "//apex_available:anyapex",
+    ],
+    product_available: true,
+    vendor_available: true,
+}
+
+rust_test {
+    name: "ppv-lite86_test_src_lib",
+    host_supported: true,
+    crate_name: "ppv_lite86",
+    cargo_env_compat: true,
+    cargo_pkg_version: "0.2.17",
+    crate_root: "src/lib.rs",
+    test_suites: ["general-tests"],
+    auto_gen_config: true,
+    test_options: {
+        unit_test: true,
+    },
+    edition: "2018",
+    features: [
+        "default",
+        "std",
+    ],
+}
diff --git a/crates/ppv-lite86/CHANGELOG.md b/crates/ppv-lite86/CHANGELOG.md
new file mode 100644
index 0000000..6e34be3
--- /dev/null
+++ b/crates/ppv-lite86/CHANGELOG.md
@@ -0,0 +1,10 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.2.16]
+### Added
+- add [u64; 4] conversion for generic vec256, to support BLAKE on non-x86.
+- impl `From` (rather than just `Into`) for conversions between `*_storage` types and arrays.
diff --git a/crates/ppv-lite86/Cargo.lock b/crates/ppv-lite86/Cargo.lock
new file mode 100644
index 0000000..45591e9
--- /dev/null
+++ b/crates/ppv-lite86/Cargo.lock
@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.17"
diff --git a/crates/ppv-lite86/Cargo.toml b/crates/ppv-lite86/Cargo.toml
new file mode 100644
index 0000000..4b5b14e
--- /dev/null
+++ b/crates/ppv-lite86/Cargo.toml
@@ -0,0 +1,39 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2018"
+name = "ppv-lite86"
+version = "0.2.17"
+authors = ["The CryptoCorrosion Contributors"]
+description = "Implementation of the crypto-simd API for x86"
+keywords = [
+    "crypto",
+    "simd",
+    "x86",
+]
+categories = [
+    "cryptography",
+    "no-std",
+]
+license = "MIT/Apache-2.0"
+repository = "https://github.com/cryptocorrosion/cryptocorrosion"
+
+[dependencies]
+
+[features]
+default = ["std"]
+no_simd = []
+simd = []
+std = []
+
+[badges.travis-ci]
+repository = "cryptocorrosion/cryptocorrosion"
diff --git a/crates/ppv-lite86/LICENSE b/crates/ppv-lite86/LICENSE
new file mode 120000
index 0000000..6b579aa
--- /dev/null
+++ b/crates/ppv-lite86/LICENSE
@@ -0,0 +1 @@
+LICENSE-APACHE
\ No newline at end of file
diff --git a/crates/ppv-lite86/LICENSE-APACHE b/crates/ppv-lite86/LICENSE-APACHE
new file mode 100644
index 0000000..1eb3215
--- /dev/null
+++ b/crates/ppv-lite86/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 2019 The CryptoCorrosion Contributors
+
+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/crates/ppv-lite86/LICENSE-MIT b/crates/ppv-lite86/LICENSE-MIT
new file mode 100644
index 0000000..d78c961
--- /dev/null
+++ b/crates/ppv-lite86/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2019 The CryptoCorrosion Contributors
+
+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/crates/ppv-lite86/METADATA b/crates/ppv-lite86/METADATA
new file mode 100644
index 0000000..ecc14e6
--- /dev/null
+++ b/crates/ppv-lite86/METADATA
@@ -0,0 +1,23 @@
+# This project was upgraded with external_updater.
+# Usage: tools/external_updater/updater.sh update rust/crates/ppv-lite86
+# For more info, check https://cs.android.com/android/platform/superproject/+/master:tools/external_updater/README.md
+
+name: "ppv-lite86"
+description: "Implementation of the crypto-simd API for x86"
+third_party {
+  url {
+    type: HOMEPAGE
+    value: "https://crates.io/crates/ppv-lite86"
+  }
+  url {
+    type: ARCHIVE
+    value: "https://static.crates.io/crates/ppv-lite86/ppv-lite86-0.2.17.crate"
+  }
+  version: "0.2.17"
+  license_type: NOTICE
+  last_upgrade_date {
+    year: 2022
+    month: 12
+    day: 19
+  }
+}
diff --git a/crates/ppv-lite86/MODULE_LICENSE_APACHE2 b/crates/ppv-lite86/MODULE_LICENSE_APACHE2
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/crates/ppv-lite86/MODULE_LICENSE_APACHE2
diff --git a/crates/ppv-lite86/TEST_MAPPING b/crates/ppv-lite86/TEST_MAPPING
new file mode 100644
index 0000000..656d29d
--- /dev/null
+++ b/crates/ppv-lite86/TEST_MAPPING
@@ -0,0 +1,96 @@
+// Generated by update_crate_tests.py for tests that depend on this crate.
+{
+  "imports": [
+    {
+      "path": "external/rust/crates/base64"
+    },
+    {
+      "path": "external/rust/crates/cast"
+    },
+    {
+      "path": "external/rust/crates/crc32fast"
+    },
+    {
+      "path": "external/rust/crates/crossbeam-deque"
+    },
+    {
+      "path": "external/rust/crates/crossbeam-epoch"
+    },
+    {
+      "path": "external/rust/crates/crossbeam-queue"
+    },
+    {
+      "path": "external/rust/crates/crossbeam-utils"
+    },
+    {
+      "path": "external/rust/crates/flate2"
+    },
+    {
+      "path": "external/rust/crates/hashbrown"
+    },
+    {
+      "path": "external/rust/crates/mio"
+    },
+    {
+      "path": "external/rust/crates/quickcheck"
+    },
+    {
+      "path": "external/rust/crates/rand_chacha"
+    },
+    {
+      "path": "external/rust/crates/regex"
+    },
+    {
+      "path": "external/rust/crates/ryu"
+    },
+    {
+      "path": "external/rust/crates/tokio"
+    },
+    {
+      "path": "external/rust/crates/zerocopy"
+    },
+    {
+      "path": "external/uwb/src"
+    },
+    {
+      "path": "packages/modules/Virtualization/apkdmverity"
+    },
+    {
+      "path": "packages/modules/Virtualization/authfs"
+    },
+    {
+      "path": "packages/modules/Virtualization/avmd"
+    },
+    {
+      "path": "packages/modules/Virtualization/libs/devicemapper"
+    },
+    {
+      "path": "packages/modules/Virtualization/microdroid_manager"
+    },
+    {
+      "path": "packages/modules/Virtualization/virtualizationmanager"
+    },
+    {
+      "path": "packages/modules/Virtualization/vm"
+    },
+    {
+      "path": "packages/modules/Virtualization/zipfuse"
+    },
+    {
+      "path": "system/security/keystore2"
+    },
+    {
+      "path": "system/security/keystore2/legacykeystore"
+    }
+  ],
+  "presubmit": [
+    {
+      "name": "ppv-lite86_test_src_lib"
+    }
+  ],
+  "presubmit-rust": [
+    {
+      "name": "ppv-lite86_test_src_lib"
+    }
+  ]
+}
diff --git a/crates/ppv-lite86/cargo_embargo.json b/crates/ppv-lite86/cargo_embargo.json
new file mode 100644
index 0000000..c8842d1
--- /dev/null
+++ b/crates/ppv-lite86/cargo_embargo.json
@@ -0,0 +1,4 @@
+{
+  "run_cargo": false,
+  "tests": true
+}
diff --git a/crates/ppv-lite86/patches/std.diff b/crates/ppv-lite86/patches/std.diff
new file mode 100644
index 0000000..cdb5b08
--- /dev/null
+++ b/crates/ppv-lite86/patches/std.diff
@@ -0,0 +1,14 @@
+Index: ppv-lite86/src/lib.rs
+===================================================================
+--- ppv-lite86.orig/src/lib.rs
++++ ppv-lite86/src/lib.rs
+@@ -5,6 +5,9 @@
+ //   Machine (which is a ZST + Copy type), which can only by created unsafely or safely
+ //   through feature detection (e.g. fn AVX2::try_get() -> Option<Machine>).
+ 
++// ANDROID: Use std to allow building as a dylib.
++extern crate std;
++
+ mod soft;
+ mod types;
+ pub use self::types::*;
diff --git a/crates/ppv-lite86/src/generic.rs b/crates/ppv-lite86/src/generic.rs
new file mode 100644
index 0000000..add6c48
--- /dev/null
+++ b/crates/ppv-lite86/src/generic.rs
@@ -0,0 +1,865 @@
+#![allow(non_camel_case_types)]
+
+use crate::soft::{x2, x4};
+use crate::types::*;
+use core::ops::*;
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub union vec128_storage {
+    d: [u32; 4],
+    q: [u64; 2],
+}
+impl From<[u32; 4]> for vec128_storage {
+    #[inline(always)]
+    fn from(d: [u32; 4]) -> Self {
+        Self { d }
+    }
+}
+impl From<vec128_storage> for [u32; 4] {
+    #[inline(always)]
+    fn from(d: vec128_storage) -> Self {
+        unsafe { d.d }
+    }
+}
+impl From<[u64; 2]> for vec128_storage {
+    #[inline(always)]
+    fn from(q: [u64; 2]) -> Self {
+        Self { q }
+    }
+}
+impl From<vec128_storage> for [u64; 2] {
+    #[inline(always)]
+    fn from(q: vec128_storage) -> Self {
+        unsafe { q.q }
+    }
+}
+impl Default for vec128_storage {
+    #[inline(always)]
+    fn default() -> Self {
+        Self { q: [0, 0] }
+    }
+}
+impl Eq for vec128_storage {}
+impl PartialEq<vec128_storage> for vec128_storage {
+    #[inline(always)]
+    fn eq(&self, rhs: &Self) -> bool {
+        unsafe { self.q == rhs.q }
+    }
+}
+#[derive(Clone, Copy, PartialEq, Eq, Default)]
+pub struct vec256_storage {
+    v128: [vec128_storage; 2],
+}
+impl vec256_storage {
+    #[inline(always)]
+    pub fn new128(v128: [vec128_storage; 2]) -> Self {
+        Self { v128 }
+    }
+    #[inline(always)]
+    pub fn split128(self) -> [vec128_storage; 2] {
+        self.v128
+    }
+}
+impl From<vec256_storage> for [u64; 4] {
+    #[inline(always)]
+    fn from(q: vec256_storage) -> Self {
+        let [a, b]: [u64; 2] = q.v128[0].into();
+        let [c, d]: [u64; 2] = q.v128[1].into();
+        [a, b, c, d]
+    }
+}
+impl From<[u64; 4]> for vec256_storage {
+    #[inline(always)]
+    fn from([a, b, c, d]: [u64; 4]) -> Self {
+        Self {
+            v128: [[a, b].into(), [c, d].into()],
+        }
+    }
+}
+#[derive(Clone, Copy, PartialEq, Eq, Default)]
+pub struct vec512_storage {
+    v128: [vec128_storage; 4],
+}
+impl vec512_storage {
+    #[inline(always)]
+    pub fn new128(v128: [vec128_storage; 4]) -> Self {
+        Self { v128 }
+    }
+    #[inline(always)]
+    pub fn split128(self) -> [vec128_storage; 4] {
+        self.v128
+    }
+}
+
+#[inline(always)]
+fn dmap<T, F>(t: T, f: F) -> T
+where
+    T: Store<vec128_storage> + Into<vec128_storage>,
+    F: Fn(u32) -> u32,
+{
+    let t: vec128_storage = t.into();
+    let d = unsafe { t.d };
+    let d = vec128_storage {
+        d: [f(d[0]), f(d[1]), f(d[2]), f(d[3])],
+    };
+    unsafe { T::unpack(d) }
+}
+
+fn dmap2<T, F>(a: T, b: T, f: F) -> T
+where
+    T: Store<vec128_storage> + Into<vec128_storage>,
+    F: Fn(u32, u32) -> u32,
+{
+    let a: vec128_storage = a.into();
+    let b: vec128_storage = b.into();
+    let ao = unsafe { a.d };
+    let bo = unsafe { b.d };
+    let d = vec128_storage {
+        d: [
+            f(ao[0], bo[0]),
+            f(ao[1], bo[1]),
+            f(ao[2], bo[2]),
+            f(ao[3], bo[3]),
+        ],
+    };
+    unsafe { T::unpack(d) }
+}
+
+#[inline(always)]
+fn qmap<T, F>(t: T, f: F) -> T
+where
+    T: Store<vec128_storage> + Into<vec128_storage>,
+    F: Fn(u64) -> u64,
+{
+    let t: vec128_storage = t.into();
+    let q = unsafe { t.q };
+    let q = vec128_storage {
+        q: [f(q[0]), f(q[1])],
+    };
+    unsafe { T::unpack(q) }
+}
+
+#[inline(always)]
+fn qmap2<T, F>(a: T, b: T, f: F) -> T
+where
+    T: Store<vec128_storage> + Into<vec128_storage>,
+    F: Fn(u64, u64) -> u64,
+{
+    let a: vec128_storage = a.into();
+    let b: vec128_storage = b.into();
+    let ao = unsafe { a.q };
+    let bo = unsafe { b.q };
+    let q = vec128_storage {
+        q: [f(ao[0], bo[0]), f(ao[1], bo[1])],
+    };
+    unsafe { T::unpack(q) }
+}
+
+#[inline(always)]
+fn o_of_q(q: [u64; 2]) -> u128 {
+    u128::from(q[0]) | (u128::from(q[1]) << 64)
+}
+
+#[inline(always)]
+fn q_of_o(o: u128) -> [u64; 2] {
+    [o as u64, (o >> 64) as u64]
+}
+
+#[inline(always)]
+fn omap<T, F>(a: T, f: F) -> T
+where
+    T: Store<vec128_storage> + Into<vec128_storage>,
+    F: Fn(u128) -> u128,
+{
+    let a: vec128_storage = a.into();
+    let ao = o_of_q(unsafe { a.q });
+    let o = vec128_storage { q: q_of_o(f(ao)) };
+    unsafe { T::unpack(o) }
+}
+
+#[inline(always)]
+fn omap2<T, F>(a: T, b: T, f: F) -> T
+where
+    T: Store<vec128_storage> + Into<vec128_storage>,
+    F: Fn(u128, u128) -> u128,
+{
+    let a: vec128_storage = a.into();
+    let b: vec128_storage = b.into();
+    let ao = o_of_q(unsafe { a.q });
+    let bo = o_of_q(unsafe { b.q });
+    let o = vec128_storage {
+        q: q_of_o(f(ao, bo)),
+    };
+    unsafe { T::unpack(o) }
+}
+
+impl RotateEachWord128 for u128x1_generic {}
+impl BitOps128 for u128x1_generic {}
+impl BitOps64 for u128x1_generic {}
+impl BitOps64 for u64x2_generic {}
+impl BitOps32 for u128x1_generic {}
+impl BitOps32 for u64x2_generic {}
+impl BitOps32 for u32x4_generic {}
+impl BitOps0 for u128x1_generic {}
+impl BitOps0 for u64x2_generic {}
+impl BitOps0 for u32x4_generic {}
+
+macro_rules! impl_bitops {
+    ($vec:ident) => {
+        impl Not for $vec {
+            type Output = Self;
+            #[inline(always)]
+            fn not(self) -> Self::Output {
+                omap(self, |x| !x)
+            }
+        }
+        impl BitAnd for $vec {
+            type Output = Self;
+            #[inline(always)]
+            fn bitand(self, rhs: Self) -> Self::Output {
+                omap2(self, rhs, |x, y| x & y)
+            }
+        }
+        impl BitOr for $vec {
+            type Output = Self;
+            #[inline(always)]
+            fn bitor(self, rhs: Self) -> Self::Output {
+                omap2(self, rhs, |x, y| x | y)
+            }
+        }
+        impl BitXor for $vec {
+            type Output = Self;
+            #[inline(always)]
+            fn bitxor(self, rhs: Self) -> Self::Output {
+                omap2(self, rhs, |x, y| x ^ y)
+            }
+        }
+        impl AndNot for $vec {
+            type Output = Self;
+            #[inline(always)]
+            fn andnot(self, rhs: Self) -> Self::Output {
+                omap2(self, rhs, |x, y| !x & y)
+            }
+        }
+        impl BitAndAssign for $vec {
+            #[inline(always)]
+            fn bitand_assign(&mut self, rhs: Self) {
+                *self = *self & rhs
+            }
+        }
+        impl BitOrAssign for $vec {
+            #[inline(always)]
+            fn bitor_assign(&mut self, rhs: Self) {
+                *self = *self | rhs
+            }
+        }
+        impl BitXorAssign for $vec {
+            #[inline(always)]
+            fn bitxor_assign(&mut self, rhs: Self) {
+                *self = *self ^ rhs
+            }
+        }
+
+        impl Swap64 for $vec {
+            #[inline(always)]
+            fn swap1(self) -> Self {
+                qmap(self, |x| {
+                    ((x & 0x5555555555555555) << 1) | ((x & 0xaaaaaaaaaaaaaaaa) >> 1)
+                })
+            }
+            #[inline(always)]
+            fn swap2(self) -> Self {
+                qmap(self, |x| {
+                    ((x & 0x3333333333333333) << 2) | ((x & 0xcccccccccccccccc) >> 2)
+                })
+            }
+            #[inline(always)]
+            fn swap4(self) -> Self {
+                qmap(self, |x| {
+                    ((x & 0x0f0f0f0f0f0f0f0f) << 4) | ((x & 0xf0f0f0f0f0f0f0f0) >> 4)
+                })
+            }
+            #[inline(always)]
+            fn swap8(self) -> Self {
+                qmap(self, |x| {
+                    ((x & 0x00ff00ff00ff00ff) << 8) | ((x & 0xff00ff00ff00ff00) >> 8)
+                })
+            }
+            #[inline(always)]
+            fn swap16(self) -> Self {
+                dmap(self, |x| x.rotate_left(16))
+            }
+            #[inline(always)]
+            fn swap32(self) -> Self {
+                qmap(self, |x| x.rotate_left(32))
+            }
+            #[inline(always)]
+            fn swap64(self) -> Self {
+                omap(self, |x| (x << 64) | (x >> 64))
+            }
+        }
+    };
+}
+impl_bitops!(u32x4_generic);
+impl_bitops!(u64x2_generic);
+impl_bitops!(u128x1_generic);
+
+impl RotateEachWord32 for u32x4_generic {
+    #[inline(always)]
+    fn rotate_each_word_right7(self) -> Self {
+        dmap(self, |x| x.rotate_right(7))
+    }
+    #[inline(always)]
+    fn rotate_each_word_right8(self) -> Self {
+        dmap(self, |x| x.rotate_right(8))
+    }
+    #[inline(always)]
+    fn rotate_each_word_right11(self) -> Self {
+        dmap(self, |x| x.rotate_right(11))
+    }
+    #[inline(always)]
+    fn rotate_each_word_right12(self) -> Self {
+        dmap(self, |x| x.rotate_right(12))
+    }
+    #[inline(always)]
+    fn rotate_each_word_right16(self) -> Self {
+        dmap(self, |x| x.rotate_right(16))
+    }
+    #[inline(always)]
+    fn rotate_each_word_right20(self) -> Self {
+        dmap(self, |x| x.rotate_right(20))
+    }
+    #[inline(always)]
+    fn rotate_each_word_right24(self) -> Self {
+        dmap(self, |x| x.rotate_right(24))
+    }
+    #[inline(always)]
+    fn rotate_each_word_right25(self) -> Self {
+        dmap(self, |x| x.rotate_right(25))
+    }
+}
+
+impl RotateEachWord32 for u64x2_generic {
+    #[inline(always)]
+    fn rotate_each_word_right7(self) -> Self {
+        qmap(self, |x| x.rotate_right(7))
+    }
+    #[inline(always)]
+    fn rotate_each_word_right8(self) -> Self {
+        qmap(self, |x| x.rotate_right(8))
+    }
+    #[inline(always)]
+    fn rotate_each_word_right11(self) -> Self {
+        qmap(self, |x| x.rotate_right(11))
+    }
+    #[inline(always)]
+    fn rotate_each_word_right12(self) -> Self {
+        qmap(self, |x| x.rotate_right(12))
+    }
+    #[inline(always)]
+    fn rotate_each_word_right16(self) -> Self {
+        qmap(self, |x| x.rotate_right(16))
+    }
+    #[inline(always)]
+    fn rotate_each_word_right20(self) -> Self {
+        qmap(self, |x| x.rotate_right(20))
+    }
+    #[inline(always)]
+    fn rotate_each_word_right24(self) -> Self {
+        qmap(self, |x| x.rotate_right(24))
+    }
+    #[inline(always)]
+    fn rotate_each_word_right25(self) -> Self {
+        qmap(self, |x| x.rotate_right(25))
+    }
+}
+impl RotateEachWord64 for u64x2_generic {
+    #[inline(always)]
+    fn rotate_each_word_right32(self) -> Self {
+        qmap(self, |x| x.rotate_right(32))
+    }
+}
+
+// workaround for koute/cargo-web#52 (u128::rotate_* broken with cargo web)
+#[inline(always)]
+fn rotate_u128_right(x: u128, i: u32) -> u128 {
+    (x >> i) | (x << (128 - i))
+}
+#[test]
+fn test_rotate_u128() {
+    const X: u128 = 0x0001_0203_0405_0607_0809_0a0b_0c0d_0e0f;
+    assert_eq!(rotate_u128_right(X, 17), X.rotate_right(17));
+}
+
+impl RotateEachWord32 for u128x1_generic {
+    #[inline(always)]
+    fn rotate_each_word_right7(self) -> Self {
+        Self([rotate_u128_right(self.0[0], 7)])
+    }
+    #[inline(always)]
+    fn rotate_each_word_right8(self) -> Self {
+        Self([rotate_u128_right(self.0[0], 8)])
+    }
+    #[inline(always)]
+    fn rotate_each_word_right11(self) -> Self {
+        Self([rotate_u128_right(self.0[0], 11)])
+    }
+    #[inline(always)]
+    fn rotate_each_word_right12(self) -> Self {
+        Self([rotate_u128_right(self.0[0], 12)])
+    }
+    #[inline(always)]
+    fn rotate_each_word_right16(self) -> Self {
+        Self([rotate_u128_right(self.0[0], 16)])
+    }
+    #[inline(always)]
+    fn rotate_each_word_right20(self) -> Self {
+        Self([rotate_u128_right(self.0[0], 20)])
+    }
+    #[inline(always)]
+    fn rotate_each_word_right24(self) -> Self {
+        Self([rotate_u128_right(self.0[0], 24)])
+    }
+    #[inline(always)]
+    fn rotate_each_word_right25(self) -> Self {
+        Self([rotate_u128_right(self.0[0], 25)])
+    }
+}
+impl RotateEachWord64 for u128x1_generic {
+    #[inline(always)]
+    fn rotate_each_word_right32(self) -> Self {
+        Self([rotate_u128_right(self.0[0], 32)])
+    }
+}
+
+#[derive(Copy, Clone)]
+pub struct GenericMachine;
+impl Machine for GenericMachine {
+    type u32x4 = u32x4_generic;
+    type u64x2 = u64x2_generic;
+    type u128x1 = u128x1_generic;
+    type u32x4x2 = u32x4x2_generic;
+    type u64x2x2 = u64x2x2_generic;
+    type u64x4 = u64x4_generic;
+    type u128x2 = u128x2_generic;
+    type u32x4x4 = u32x4x4_generic;
+    type u64x2x4 = u64x2x4_generic;
+    type u128x4 = u128x4_generic;
+    #[inline(always)]
+    unsafe fn instance() -> Self {
+        Self
+    }
+}
+
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub struct u32x4_generic([u32; 4]);
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub struct u64x2_generic([u64; 2]);
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub struct u128x1_generic([u128; 1]);
+
+impl From<u32x4_generic> for vec128_storage {
+    #[inline(always)]
+    fn from(d: u32x4_generic) -> Self {
+        Self { d: d.0 }
+    }
+}
+impl From<u64x2_generic> for vec128_storage {
+    #[inline(always)]
+    fn from(q: u64x2_generic) -> Self {
+        Self { q: q.0 }
+    }
+}
+impl From<u128x1_generic> for vec128_storage {
+    #[inline(always)]
+    fn from(o: u128x1_generic) -> Self {
+        Self { q: q_of_o(o.0[0]) }
+    }
+}
+
+impl Store<vec128_storage> for u32x4_generic {
+    #[inline(always)]
+    unsafe fn unpack(s: vec128_storage) -> Self {
+        Self(s.d)
+    }
+}
+impl Store<vec128_storage> for u64x2_generic {
+    #[inline(always)]
+    unsafe fn unpack(s: vec128_storage) -> Self {
+        Self(s.q)
+    }
+}
+impl Store<vec128_storage> for u128x1_generic {
+    #[inline(always)]
+    unsafe fn unpack(s: vec128_storage) -> Self {
+        Self([o_of_q(s.q); 1])
+    }
+}
+
+impl ArithOps for u32x4_generic {}
+impl ArithOps for u64x2_generic {}
+impl ArithOps for u128x1_generic {}
+
+impl Add for u32x4_generic {
+    type Output = Self;
+    #[inline(always)]
+    fn add(self, rhs: Self) -> Self::Output {
+        dmap2(self, rhs, |x, y| x.wrapping_add(y))
+    }
+}
+impl Add for u64x2_generic {
+    type Output = Self;
+    #[inline(always)]
+    fn add(self, rhs: Self) -> Self::Output {
+        qmap2(self, rhs, |x, y| x.wrapping_add(y))
+    }
+}
+impl Add for u128x1_generic {
+    type Output = Self;
+    #[inline(always)]
+    fn add(self, rhs: Self) -> Self::Output {
+        omap2(self, rhs, |x, y| x.wrapping_add(y))
+    }
+}
+impl AddAssign for u32x4_generic {
+    #[inline(always)]
+    fn add_assign(&mut self, rhs: Self) {
+        *self = *self + rhs
+    }
+}
+impl AddAssign for u64x2_generic {
+    #[inline(always)]
+    fn add_assign(&mut self, rhs: Self) {
+        *self = *self + rhs
+    }
+}
+impl AddAssign for u128x1_generic {
+    #[inline(always)]
+    fn add_assign(&mut self, rhs: Self) {
+        *self = *self + rhs
+    }
+}
+impl BSwap for u32x4_generic {
+    #[inline(always)]
+    fn bswap(self) -> Self {
+        dmap(self, |x| x.swap_bytes())
+    }
+}
+impl BSwap for u64x2_generic {
+    #[inline(always)]
+    fn bswap(self) -> Self {
+        qmap(self, |x| x.swap_bytes())
+    }
+}
+impl BSwap for u128x1_generic {
+    #[inline(always)]
+    fn bswap(self) -> Self {
+        omap(self, |x| x.swap_bytes())
+    }
+}
+impl StoreBytes for u32x4_generic {
+    #[inline(always)]
+    unsafe fn unsafe_read_le(input: &[u8]) -> Self {
+        assert_eq!(input.len(), 16);
+        let x = core::mem::transmute(core::ptr::read(input as *const _ as *const [u8; 16]));
+        dmap(x, |x| x.to_le())
+    }
+    #[inline(always)]
+    unsafe fn unsafe_read_be(input: &[u8]) -> Self {
+        assert_eq!(input.len(), 16);
+        let x = core::mem::transmute(core::ptr::read(input as *const _ as *const [u8; 16]));
+        dmap(x, |x| x.to_be())
+    }
+    #[inline(always)]
+    fn write_le(self, out: &mut [u8]) {
+        assert_eq!(out.len(), 16);
+        let x = dmap(self, |x| x.to_le());
+        unsafe { core::ptr::write(out as *mut _ as *mut [u8; 16], core::mem::transmute(x)) }
+    }
+    #[inline(always)]
+    fn write_be(self, out: &mut [u8]) {
+        assert_eq!(out.len(), 16);
+        let x = dmap(self, |x| x.to_be());
+        unsafe { core::ptr::write(out as *mut _ as *mut [u8; 16], core::mem::transmute(x)) }
+    }
+}
+impl StoreBytes for u64x2_generic {
+    #[inline(always)]
+    unsafe fn unsafe_read_le(input: &[u8]) -> Self {
+        assert_eq!(input.len(), 16);
+        let x = core::mem::transmute(core::ptr::read(input as *const _ as *const [u8; 16]));
+        qmap(x, |x| x.to_le())
+    }
+    #[inline(always)]
+    unsafe fn unsafe_read_be(input: &[u8]) -> Self {
+        assert_eq!(input.len(), 16);
+        let x = core::mem::transmute(core::ptr::read(input as *const _ as *const [u8; 16]));
+        qmap(x, |x| x.to_be())
+    }
+    #[inline(always)]
+    fn write_le(self, out: &mut [u8]) {
+        assert_eq!(out.len(), 16);
+        let x = qmap(self, |x| x.to_le());
+        unsafe { core::ptr::write(out as *mut _ as *mut [u8; 16], core::mem::transmute(x)) }
+    }
+    #[inline(always)]
+    fn write_be(self, out: &mut [u8]) {
+        assert_eq!(out.len(), 16);
+        let x = qmap(self, |x| x.to_be());
+        unsafe { core::ptr::write(out as *mut _ as *mut [u8; 16], core::mem::transmute(x)) }
+    }
+}
+
+#[derive(Copy, Clone)]
+pub struct G0;
+#[derive(Copy, Clone)]
+pub struct G1;
+pub type u32x4x2_generic = x2<u32x4_generic, G0>;
+pub type u64x2x2_generic = x2<u64x2_generic, G0>;
+pub type u64x4_generic = x2<u64x2_generic, G1>;
+pub type u128x2_generic = x2<u128x1_generic, G0>;
+pub type u32x4x4_generic = x4<u32x4_generic>;
+pub type u64x2x4_generic = x4<u64x2_generic>;
+pub type u128x4_generic = x4<u128x1_generic>;
+
+impl Vector<[u32; 16]> for u32x4x4_generic {
+    fn to_scalars(self) -> [u32; 16] {
+        let [a, b, c, d] = self.0;
+        let a = a.0;
+        let b = b.0;
+        let c = c.0;
+        let d = d.0;
+        [
+            a[0], a[1], a[2], a[3], //
+            b[0], b[1], b[2], b[3], //
+            c[0], c[1], c[2], c[3], //
+            d[0], d[1], d[2], d[3], //
+        ]
+    }
+}
+
+impl MultiLane<[u32; 4]> for u32x4_generic {
+    #[inline(always)]
+    fn to_lanes(self) -> [u32; 4] {
+        self.0
+    }
+    #[inline(always)]
+    fn from_lanes(xs: [u32; 4]) -> Self {
+        Self(xs)
+    }
+}
+impl MultiLane<[u64; 2]> for u64x2_generic {
+    #[inline(always)]
+    fn to_lanes(self) -> [u64; 2] {
+        self.0
+    }
+    #[inline(always)]
+    fn from_lanes(xs: [u64; 2]) -> Self {
+        Self(xs)
+    }
+}
+impl MultiLane<[u64; 4]> for u64x4_generic {
+    #[inline(always)]
+    fn to_lanes(self) -> [u64; 4] {
+        let (a, b) = (self.0[0].to_lanes(), self.0[1].to_lanes());
+        [a[0], a[1], b[0], b[1]]
+    }
+    #[inline(always)]
+    fn from_lanes(xs: [u64; 4]) -> Self {
+        let (a, b) = (
+            u64x2_generic::from_lanes([xs[0], xs[1]]),
+            u64x2_generic::from_lanes([xs[2], xs[3]]),
+        );
+        x2::new([a, b])
+    }
+}
+impl MultiLane<[u128; 1]> for u128x1_generic {
+    #[inline(always)]
+    fn to_lanes(self) -> [u128; 1] {
+        self.0
+    }
+    #[inline(always)]
+    fn from_lanes(xs: [u128; 1]) -> Self {
+        Self(xs)
+    }
+}
+impl Vec4<u32> for u32x4_generic {
+    #[inline(always)]
+    fn extract(self, i: u32) -> u32 {
+        self.0[i as usize]
+    }
+    #[inline(always)]
+    fn insert(mut self, v: u32, i: u32) -> Self {
+        self.0[i as usize] = v;
+        self
+    }
+}
+impl Vec4<u64> for u64x4_generic {
+    #[inline(always)]
+    fn extract(self, i: u32) -> u64 {
+        let d: [u64; 4] = self.to_lanes();
+        d[i as usize]
+    }
+    #[inline(always)]
+    fn insert(self, v: u64, i: u32) -> Self {
+        self.0[(i / 2) as usize].insert(v, i % 2);
+        self
+    }
+}
+impl Vec2<u64> for u64x2_generic {
+    #[inline(always)]
+    fn extract(self, i: u32) -> u64 {
+        self.0[i as usize]
+    }
+    #[inline(always)]
+    fn insert(mut self, v: u64, i: u32) -> Self {
+        self.0[i as usize] = v;
+        self
+    }
+}
+
+impl Words4 for u32x4_generic {
+    #[inline(always)]
+    fn shuffle2301(self) -> Self {
+        self.swap64()
+    }
+    #[inline(always)]
+    fn shuffle1230(self) -> Self {
+        let x = self.0;
+        Self([x[3], x[0], x[1], x[2]])
+    }
+    #[inline(always)]
+    fn shuffle3012(self) -> Self {
+        let x = self.0;
+        Self([x[1], x[2], x[3], x[0]])
+    }
+}
+impl LaneWords4 for u32x4_generic {
+    #[inline(always)]
+    fn shuffle_lane_words2301(self) -> Self {
+        self.shuffle2301()
+    }
+    #[inline(always)]
+    fn shuffle_lane_words1230(self) -> Self {
+        self.shuffle1230()
+    }
+    #[inline(always)]
+    fn shuffle_lane_words3012(self) -> Self {
+        self.shuffle3012()
+    }
+}
+
+impl Words4 for u64x4_generic {
+    #[inline(always)]
+    fn shuffle2301(self) -> Self {
+        x2::new([self.0[1], self.0[0]])
+    }
+    #[inline(always)]
+    fn shuffle1230(self) -> Self {
+        unimplemented!()
+    }
+    #[inline(always)]
+    fn shuffle3012(self) -> Self {
+        unimplemented!()
+    }
+}
+
+impl u32x4<GenericMachine> for u32x4_generic {}
+impl u64x2<GenericMachine> for u64x2_generic {}
+impl u128x1<GenericMachine> for u128x1_generic {}
+impl u32x4x2<GenericMachine> for u32x4x2_generic {}
+impl u64x2x2<GenericMachine> for u64x2x2_generic {}
+impl u64x4<GenericMachine> for u64x4_generic {}
+impl u128x2<GenericMachine> for u128x2_generic {}
+impl u32x4x4<GenericMachine> for u32x4x4_generic {}
+impl u64x2x4<GenericMachine> for u64x2x4_generic {}
+impl u128x4<GenericMachine> for u128x4_generic {}
+
+#[macro_export]
+macro_rules! dispatch {
+    ($mach:ident, $MTy:ident, { $([$pub:tt$(($krate:tt))*])* fn $name:ident($($arg:ident: $argty:ty),* $(,)*) -> $ret:ty $body:block }) => {
+        #[inline(always)]
+        $($pub$(($krate))*)* fn $name($($arg: $argty),*) -> $ret {
+            let $mach = unsafe { $crate::generic::GenericMachine::instance() };
+            #[inline(always)]
+            fn fn_impl<$MTy: $crate::Machine>($mach: $MTy, $($arg: $argty),*) -> $ret $body
+            fn_impl($mach, $($arg),*)
+        }
+    };
+    ($mach:ident, $MTy:ident, { $([$pub:tt $(($krate:tt))*])* fn $name:ident($($arg:ident: $argty:ty),* $(,)*) $body:block }) => {
+        dispatch!($mach, $MTy, {
+            $([$pub $(($krate))*])* fn $name($($arg: $argty),*) -> () $body
+        });
+    }
+}
+#[macro_export]
+macro_rules! dispatch_light128 {
+    ($mach:ident, $MTy:ident, { $([$pub:tt$(($krate:tt))*])* fn $name:ident($($arg:ident: $argty:ty),* $(,)*) -> $ret:ty $body:block }) => {
+        #[inline(always)]
+        $($pub$(($krate))*)* fn $name($($arg: $argty),*) -> $ret {
+            let $mach = unsafe { $crate::generic::GenericMachine::instance() };
+            #[inline(always)]
+            fn fn_impl<$MTy: $crate::Machine>($mach: $MTy, $($arg: $argty),*) -> $ret $body
+            fn_impl($mach, $($arg),*)
+        }
+    };
+    ($mach:ident, $MTy:ident, { $([$pub:tt $(($krate:tt))*])* fn $name:ident($($arg:ident: $argty:ty),* $(,)*) $body:block }) => {
+        dispatch!($mach, $MTy, {
+            $([$pub $(($krate))*])* fn $name($($arg: $argty),*) -> () $body
+        });
+    }
+}
+#[macro_export]
+macro_rules! dispatch_light256 {
+    ($mach:ident, $MTy:ident, { $([$pub:tt$(($krate:tt))*])* fn $name:ident($($arg:ident: $argty:ty),* $(,)*) -> $ret:ty $body:block }) => {
+        #[inline(always)]
+        $($pub$(($krate))*)* fn $name($($arg: $argty),*) -> $ret {
+            let $mach = unsafe { $crate::generic::GenericMachine::instance() };
+            #[inline(always)]
+            fn fn_impl<$MTy: $crate::Machine>($mach: $MTy, $($arg: $argty),*) -> $ret $body
+            fn_impl($mach, $($arg),*)
+        }
+    };
+    ($mach:ident, $MTy:ident, { $([$pub:tt $(($krate:tt))*])* fn $name:ident($($arg:ident: $argty:ty),* $(,)*) $body:block }) => {
+        dispatch!($mach, $MTy, {
+            $([$pub $(($krate))*])* fn $name($($arg: $argty),*) -> () $body
+        });
+    }
+}
+#[macro_export]
+macro_rules! dispatch_light512 {
+    ($mach:ident, $MTy:ident, { $([$pub:tt$(($krate:tt))*])* fn $name:ident($($arg:ident: $argty:ty),* $(,)*) -> $ret:ty $body:block }) => {
+        #[inline(always)]
+        $($pub$(($krate))*)* fn $name($($arg: $argty),*) -> $ret {
+            let $mach = unsafe { $crate::generic::GenericMachine::instance() };
+            #[inline(always)]
+            fn fn_impl<$MTy: $crate::Machine>($mach: $MTy, $($arg: $argty),*) -> $ret $body
+            fn_impl($mach, $($arg),*)
+        }
+    };
+    ($mach:ident, $MTy:ident, { $([$pub:tt $(($krate:tt))*])* fn $name:ident($($arg:ident: $argty:ty),* $(,)*) $body:block }) => {
+        dispatch!($mach, $MTy, {
+            $([$pub $(($krate))*])* fn $name($($arg: $argty),*) -> () $body
+        });
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_bswap32() {
+        let xs = [0x0f0e_0d0c, 0x0b0a_0908, 0x0706_0504, 0x0302_0100];
+        let ys = [0x0c0d_0e0f, 0x0809_0a0b, 0x0405_0607, 0x0001_0203];
+
+        let m = unsafe { GenericMachine::instance() };
+
+        let x: <GenericMachine as Machine>::u32x4 = m.vec(xs);
+        let x = x.bswap();
+
+        let y = m.vec(ys);
+        assert_eq!(x, y);
+    }
+}
diff --git a/crates/ppv-lite86/src/lib.rs b/crates/ppv-lite86/src/lib.rs
new file mode 100644
index 0000000..1bc27e0
--- /dev/null
+++ b/crates/ppv-lite86/src/lib.rs
@@ -0,0 +1,25 @@
+#![no_std]
+
+// Design:
+// - safety: safe creation of any machine type is done only by instance methods of a
+//   Machine (which is a ZST + Copy type), which can only by created unsafely or safely
+//   through feature detection (e.g. fn AVX2::try_get() -> Option<Machine>).
+
+// ANDROID: Use std to allow building as a dylib.
+extern crate std;
+
+mod soft;
+mod types;
+pub use self::types::*;
+
+#[cfg(all(target_arch = "x86_64", target_feature = "sse2", not(feature = "no_simd"), not(miri)))]
+pub mod x86_64;
+#[cfg(all(target_arch = "x86_64", target_feature = "sse2", not(feature = "no_simd"), not(miri)))]
+use self::x86_64 as arch;
+
+#[cfg(any(feature = "no_simd", miri, not(target_arch = "x86_64"), all(target_arch = "x86_64", not(target_feature = "sse2"))))]
+pub mod generic;
+#[cfg(any(feature = "no_simd", miri, not(target_arch = "x86_64"), all(target_arch = "x86_64", not(target_feature = "sse2"))))]
+use self::generic as arch;
+
+pub use self::arch::{vec128_storage, vec256_storage, vec512_storage};
diff --git a/crates/ppv-lite86/src/soft.rs b/crates/ppv-lite86/src/soft.rs
new file mode 100644
index 0000000..0ae390c
--- /dev/null
+++ b/crates/ppv-lite86/src/soft.rs
@@ -0,0 +1,472 @@
+//! Implement 256- and 512- bit in terms of 128-bit, for machines without native wide SIMD.
+
+use crate::types::*;
+use crate::{vec128_storage, vec256_storage, vec512_storage};
+use core::marker::PhantomData;
+use core::ops::*;
+
+#[derive(Copy, Clone, Default)]
+#[allow(non_camel_case_types)]
+pub struct x2<W, G>(pub [W; 2], PhantomData<G>);
+impl<W, G> x2<W, G> {
+    #[inline(always)]
+    pub fn new(xs: [W; 2]) -> Self {
+        x2(xs, PhantomData)
+    }
+}
+macro_rules! fwd_binop_x2 {
+    ($trait:ident, $fn:ident) => {
+        impl<W: $trait + Copy, G> $trait for x2<W, G> {
+            type Output = x2<W::Output, G>;
+            #[inline(always)]
+            fn $fn(self, rhs: Self) -> Self::Output {
+                x2::new([self.0[0].$fn(rhs.0[0]), self.0[1].$fn(rhs.0[1])])
+            }
+        }
+    };
+}
+macro_rules! fwd_binop_assign_x2 {
+    ($trait:ident, $fn_assign:ident) => {
+        impl<W: $trait + Copy, G> $trait for x2<W, G> {
+            #[inline(always)]
+            fn $fn_assign(&mut self, rhs: Self) {
+                (self.0[0]).$fn_assign(rhs.0[0]);
+                (self.0[1]).$fn_assign(rhs.0[1]);
+            }
+        }
+    };
+}
+macro_rules! fwd_unop_x2 {
+    ($fn:ident) => {
+        #[inline(always)]
+        fn $fn(self) -> Self {
+            x2::new([self.0[0].$fn(), self.0[1].$fn()])
+        }
+    };
+}
+impl<W, G> RotateEachWord32 for x2<W, G>
+where
+    W: Copy + RotateEachWord32,
+{
+    fwd_unop_x2!(rotate_each_word_right7);
+    fwd_unop_x2!(rotate_each_word_right8);
+    fwd_unop_x2!(rotate_each_word_right11);
+    fwd_unop_x2!(rotate_each_word_right12);
+    fwd_unop_x2!(rotate_each_word_right16);
+    fwd_unop_x2!(rotate_each_word_right20);
+    fwd_unop_x2!(rotate_each_word_right24);
+    fwd_unop_x2!(rotate_each_word_right25);
+}
+impl<W, G> RotateEachWord64 for x2<W, G>
+where
+    W: Copy + RotateEachWord64,
+{
+    fwd_unop_x2!(rotate_each_word_right32);
+}
+impl<W, G> RotateEachWord128 for x2<W, G> where W: RotateEachWord128 {}
+impl<W, G> BitOps0 for x2<W, G>
+where
+    W: BitOps0,
+    G: Copy,
+{
+}
+impl<W, G> BitOps32 for x2<W, G>
+where
+    W: BitOps32 + BitOps0,
+    G: Copy,
+{
+}
+impl<W, G> BitOps64 for x2<W, G>
+where
+    W: BitOps64 + BitOps0,
+    G: Copy,
+{
+}
+impl<W, G> BitOps128 for x2<W, G>
+where
+    W: BitOps128 + BitOps0,
+    G: Copy,
+{
+}
+fwd_binop_x2!(BitAnd, bitand);
+fwd_binop_x2!(BitOr, bitor);
+fwd_binop_x2!(BitXor, bitxor);
+fwd_binop_x2!(AndNot, andnot);
+fwd_binop_assign_x2!(BitAndAssign, bitand_assign);
+fwd_binop_assign_x2!(BitOrAssign, bitor_assign);
+fwd_binop_assign_x2!(BitXorAssign, bitxor_assign);
+impl<W, G> ArithOps for x2<W, G>
+where
+    W: ArithOps,
+    G: Copy,
+{
+}
+fwd_binop_x2!(Add, add);
+fwd_binop_assign_x2!(AddAssign, add_assign);
+impl<W: Not + Copy, G> Not for x2<W, G> {
+    type Output = x2<W::Output, G>;
+    #[inline(always)]
+    fn not(self) -> Self::Output {
+        x2::new([self.0[0].not(), self.0[1].not()])
+    }
+}
+impl<W, G> UnsafeFrom<[W; 2]> for x2<W, G> {
+    #[inline(always)]
+    unsafe fn unsafe_from(xs: [W; 2]) -> Self {
+        x2::new(xs)
+    }
+}
+impl<W: Copy, G> Vec2<W> for x2<W, G> {
+    #[inline(always)]
+    fn extract(self, i: u32) -> W {
+        self.0[i as usize]
+    }
+    #[inline(always)]
+    fn insert(mut self, w: W, i: u32) -> Self {
+        self.0[i as usize] = w;
+        self
+    }
+}
+impl<W: Copy + Store<vec128_storage>, G> Store<vec256_storage> for x2<W, G> {
+    #[inline(always)]
+    unsafe fn unpack(p: vec256_storage) -> Self {
+        let p = p.split128();
+        x2::new([W::unpack(p[0]), W::unpack(p[1])])
+    }
+}
+impl<W, G> From<x2<W, G>> for vec256_storage
+where
+    W: Copy,
+    vec128_storage: From<W>,
+{
+    #[inline(always)]
+    fn from(x: x2<W, G>) -> Self {
+        vec256_storage::new128([x.0[0].into(), x.0[1].into()])
+    }
+}
+impl<W, G> Swap64 for x2<W, G>
+where
+    W: Swap64 + Copy,
+{
+    fwd_unop_x2!(swap1);
+    fwd_unop_x2!(swap2);
+    fwd_unop_x2!(swap4);
+    fwd_unop_x2!(swap8);
+    fwd_unop_x2!(swap16);
+    fwd_unop_x2!(swap32);
+    fwd_unop_x2!(swap64);
+}
+impl<W: Copy, G> MultiLane<[W; 2]> for x2<W, G> {
+    #[inline(always)]
+    fn to_lanes(self) -> [W; 2] {
+        self.0
+    }
+    #[inline(always)]
+    fn from_lanes(lanes: [W; 2]) -> Self {
+        x2::new(lanes)
+    }
+}
+impl<W: BSwap + Copy, G> BSwap for x2<W, G> {
+    #[inline(always)]
+    fn bswap(self) -> Self {
+        x2::new([self.0[0].bswap(), self.0[1].bswap()])
+    }
+}
+impl<W: StoreBytes + BSwap + Copy, G> StoreBytes for x2<W, G> {
+    #[inline(always)]
+    unsafe fn unsafe_read_le(input: &[u8]) -> Self {
+        let input = input.split_at(input.len() / 2);
+        x2::new([W::unsafe_read_le(input.0), W::unsafe_read_le(input.1)])
+    }
+    #[inline(always)]
+    unsafe fn unsafe_read_be(input: &[u8]) -> Self {
+        let input = input.split_at(input.len() / 2);
+        x2::new([W::unsafe_read_be(input.0), W::unsafe_read_be(input.1)])
+    }
+    #[inline(always)]
+    fn write_le(self, out: &mut [u8]) {
+        let out = out.split_at_mut(out.len() / 2);
+        self.0[0].write_le(out.0);
+        self.0[1].write_le(out.1);
+    }
+    #[inline(always)]
+    fn write_be(self, out: &mut [u8]) {
+        let out = out.split_at_mut(out.len() / 2);
+        self.0[0].write_be(out.0);
+        self.0[1].write_be(out.1);
+    }
+}
+impl<W: Copy + LaneWords4, G: Copy> LaneWords4 for x2<W, G> {
+    #[inline(always)]
+    fn shuffle_lane_words2301(self) -> Self {
+        Self::new([
+            self.0[0].shuffle_lane_words2301(),
+            self.0[1].shuffle_lane_words2301(),
+        ])
+    }
+    #[inline(always)]
+    fn shuffle_lane_words1230(self) -> Self {
+        Self::new([
+            self.0[0].shuffle_lane_words1230(),
+            self.0[1].shuffle_lane_words1230(),
+        ])
+    }
+    #[inline(always)]
+    fn shuffle_lane_words3012(self) -> Self {
+        Self::new([
+            self.0[0].shuffle_lane_words3012(),
+            self.0[1].shuffle_lane_words3012(),
+        ])
+    }
+}
+
+#[derive(Copy, Clone, Default)]
+#[allow(non_camel_case_types)]
+pub struct x4<W>(pub [W; 4]);
+impl<W> x4<W> {
+    #[inline(always)]
+    pub fn new(xs: [W; 4]) -> Self {
+        x4(xs)
+    }
+}
+macro_rules! fwd_binop_x4 {
+    ($trait:ident, $fn:ident) => {
+        impl<W: $trait + Copy> $trait for x4<W> {
+            type Output = x4<W::Output>;
+            #[inline(always)]
+            fn $fn(self, rhs: Self) -> Self::Output {
+                x4([
+                    self.0[0].$fn(rhs.0[0]),
+                    self.0[1].$fn(rhs.0[1]),
+                    self.0[2].$fn(rhs.0[2]),
+                    self.0[3].$fn(rhs.0[3]),
+                ])
+            }
+        }
+    };
+}
+macro_rules! fwd_binop_assign_x4 {
+    ($trait:ident, $fn_assign:ident) => {
+        impl<W: $trait + Copy> $trait for x4<W> {
+            #[inline(always)]
+            fn $fn_assign(&mut self, rhs: Self) {
+                self.0[0].$fn_assign(rhs.0[0]);
+                self.0[1].$fn_assign(rhs.0[1]);
+                self.0[2].$fn_assign(rhs.0[2]);
+                self.0[3].$fn_assign(rhs.0[3]);
+            }
+        }
+    };
+}
+macro_rules! fwd_unop_x4 {
+    ($fn:ident) => {
+        #[inline(always)]
+        fn $fn(self) -> Self {
+            x4([
+                self.0[0].$fn(),
+                self.0[1].$fn(),
+                self.0[2].$fn(),
+                self.0[3].$fn(),
+            ])
+        }
+    };
+}
+impl<W> RotateEachWord32 for x4<W>
+where
+    W: Copy + RotateEachWord32,
+{
+    fwd_unop_x4!(rotate_each_word_right7);
+    fwd_unop_x4!(rotate_each_word_right8);
+    fwd_unop_x4!(rotate_each_word_right11);
+    fwd_unop_x4!(rotate_each_word_right12);
+    fwd_unop_x4!(rotate_each_word_right16);
+    fwd_unop_x4!(rotate_each_word_right20);
+    fwd_unop_x4!(rotate_each_word_right24);
+    fwd_unop_x4!(rotate_each_word_right25);
+}
+impl<W> RotateEachWord64 for x4<W>
+where
+    W: Copy + RotateEachWord64,
+{
+    fwd_unop_x4!(rotate_each_word_right32);
+}
+impl<W> RotateEachWord128 for x4<W> where W: RotateEachWord128 {}
+impl<W> BitOps0 for x4<W> where W: BitOps0 {}
+impl<W> BitOps32 for x4<W> where W: BitOps32 + BitOps0 {}
+impl<W> BitOps64 for x4<W> where W: BitOps64 + BitOps0 {}
+impl<W> BitOps128 for x4<W> where W: BitOps128 + BitOps0 {}
+fwd_binop_x4!(BitAnd, bitand);
+fwd_binop_x4!(BitOr, bitor);
+fwd_binop_x4!(BitXor, bitxor);
+fwd_binop_x4!(AndNot, andnot);
+fwd_binop_assign_x4!(BitAndAssign, bitand_assign);
+fwd_binop_assign_x4!(BitOrAssign, bitor_assign);
+fwd_binop_assign_x4!(BitXorAssign, bitxor_assign);
+impl<W> ArithOps for x4<W> where W: ArithOps {}
+fwd_binop_x4!(Add, add);
+fwd_binop_assign_x4!(AddAssign, add_assign);
+impl<W: Not + Copy> Not for x4<W> {
+    type Output = x4<W::Output>;
+    #[inline(always)]
+    fn not(self) -> Self::Output {
+        x4([
+            self.0[0].not(),
+            self.0[1].not(),
+            self.0[2].not(),
+            self.0[3].not(),
+        ])
+    }
+}
+impl<W> UnsafeFrom<[W; 4]> for x4<W> {
+    #[inline(always)]
+    unsafe fn unsafe_from(xs: [W; 4]) -> Self {
+        x4(xs)
+    }
+}
+impl<W: Copy> Vec4<W> for x4<W> {
+    #[inline(always)]
+    fn extract(self, i: u32) -> W {
+        self.0[i as usize]
+    }
+    #[inline(always)]
+    fn insert(mut self, w: W, i: u32) -> Self {
+        self.0[i as usize] = w;
+        self
+    }
+}
+impl<W: Copy> Vec4Ext<W> for x4<W> {
+    #[inline(always)]
+    fn transpose4(a: Self, b: Self, c: Self, d: Self) -> (Self, Self, Self, Self)
+    where
+        Self: Sized,
+    {
+        (
+            x4([a.0[0], b.0[0], c.0[0], d.0[0]]),
+            x4([a.0[1], b.0[1], c.0[1], d.0[1]]),
+            x4([a.0[2], b.0[2], c.0[2], d.0[2]]),
+            x4([a.0[3], b.0[3], c.0[3], d.0[3]]),
+        )
+    }
+}
+impl<W: Copy + Store<vec128_storage>> Store<vec512_storage> for x4<W> {
+    #[inline(always)]
+    unsafe fn unpack(p: vec512_storage) -> Self {
+        let p = p.split128();
+        x4([
+            W::unpack(p[0]),
+            W::unpack(p[1]),
+            W::unpack(p[2]),
+            W::unpack(p[3]),
+        ])
+    }
+}
+impl<W> From<x4<W>> for vec512_storage
+where
+    W: Copy,
+    vec128_storage: From<W>,
+{
+    #[inline(always)]
+    fn from(x: x4<W>) -> Self {
+        vec512_storage::new128([x.0[0].into(), x.0[1].into(), x.0[2].into(), x.0[3].into()])
+    }
+}
+impl<W> Swap64 for x4<W>
+where
+    W: Swap64 + Copy,
+{
+    fwd_unop_x4!(swap1);
+    fwd_unop_x4!(swap2);
+    fwd_unop_x4!(swap4);
+    fwd_unop_x4!(swap8);
+    fwd_unop_x4!(swap16);
+    fwd_unop_x4!(swap32);
+    fwd_unop_x4!(swap64);
+}
+impl<W: Copy> MultiLane<[W; 4]> for x4<W> {
+    #[inline(always)]
+    fn to_lanes(self) -> [W; 4] {
+        self.0
+    }
+    #[inline(always)]
+    fn from_lanes(lanes: [W; 4]) -> Self {
+        x4(lanes)
+    }
+}
+impl<W: BSwap + Copy> BSwap for x4<W> {
+    #[inline(always)]
+    fn bswap(self) -> Self {
+        x4([
+            self.0[0].bswap(),
+            self.0[1].bswap(),
+            self.0[2].bswap(),
+            self.0[3].bswap(),
+        ])
+    }
+}
+impl<W: StoreBytes + BSwap + Copy> StoreBytes for x4<W> {
+    #[inline(always)]
+    unsafe fn unsafe_read_le(input: &[u8]) -> Self {
+        let n = input.len() / 4;
+        x4([
+            W::unsafe_read_le(&input[..n]),
+            W::unsafe_read_le(&input[n..n * 2]),
+            W::unsafe_read_le(&input[n * 2..n * 3]),
+            W::unsafe_read_le(&input[n * 3..]),
+        ])
+    }
+    #[inline(always)]
+    unsafe fn unsafe_read_be(input: &[u8]) -> Self {
+        let n = input.len() / 4;
+        x4([
+            W::unsafe_read_be(&input[..n]),
+            W::unsafe_read_be(&input[n..n * 2]),
+            W::unsafe_read_be(&input[n * 2..n * 3]),
+            W::unsafe_read_be(&input[n * 3..]),
+        ])
+    }
+    #[inline(always)]
+    fn write_le(self, out: &mut [u8]) {
+        let n = out.len() / 4;
+        self.0[0].write_le(&mut out[..n]);
+        self.0[1].write_le(&mut out[n..n * 2]);
+        self.0[2].write_le(&mut out[n * 2..n * 3]);
+        self.0[3].write_le(&mut out[n * 3..]);
+    }
+    #[inline(always)]
+    fn write_be(self, out: &mut [u8]) {
+        let n = out.len() / 4;
+        self.0[0].write_be(&mut out[..n]);
+        self.0[1].write_be(&mut out[n..n * 2]);
+        self.0[2].write_be(&mut out[n * 2..n * 3]);
+        self.0[3].write_be(&mut out[n * 3..]);
+    }
+}
+impl<W: Copy + LaneWords4> LaneWords4 for x4<W> {
+    #[inline(always)]
+    fn shuffle_lane_words2301(self) -> Self {
+        x4([
+            self.0[0].shuffle_lane_words2301(),
+            self.0[1].shuffle_lane_words2301(),
+            self.0[2].shuffle_lane_words2301(),
+            self.0[3].shuffle_lane_words2301(),
+        ])
+    }
+    #[inline(always)]
+    fn shuffle_lane_words1230(self) -> Self {
+        x4([
+            self.0[0].shuffle_lane_words1230(),
+            self.0[1].shuffle_lane_words1230(),
+            self.0[2].shuffle_lane_words1230(),
+            self.0[3].shuffle_lane_words1230(),
+        ])
+    }
+    #[inline(always)]
+    fn shuffle_lane_words3012(self) -> Self {
+        x4([
+            self.0[0].shuffle_lane_words3012(),
+            self.0[1].shuffle_lane_words3012(),
+            self.0[2].shuffle_lane_words3012(),
+            self.0[3].shuffle_lane_words3012(),
+        ])
+    }
+}
diff --git a/crates/ppv-lite86/src/types.rs b/crates/ppv-lite86/src/types.rs
new file mode 100644
index 0000000..f9f3bf1
--- /dev/null
+++ b/crates/ppv-lite86/src/types.rs
@@ -0,0 +1,298 @@
+#![allow(non_camel_case_types)]
+use core::ops::{Add, AddAssign, BitAnd, BitOr, BitXor, BitXorAssign, Not};
+
+pub trait AndNot {
+    type Output;
+    fn andnot(self, rhs: Self) -> Self::Output;
+}
+pub trait BSwap {
+    fn bswap(self) -> Self;
+}
+/// Ops that depend on word size
+pub trait ArithOps: Add<Output = Self> + AddAssign + Sized + Copy + Clone + BSwap {}
+/// Ops that are independent of word size and endian
+pub trait BitOps0:
+    BitAnd<Output = Self>
+    + BitOr<Output = Self>
+    + BitXor<Output = Self>
+    + BitXorAssign
+    + Not<Output = Self>
+    + AndNot<Output = Self>
+    + Sized
+    + Copy
+    + Clone
+{
+}
+
+pub trait BitOps32: BitOps0 + RotateEachWord32 {}
+pub trait BitOps64: BitOps32 + RotateEachWord64 {}
+pub trait BitOps128: BitOps64 + RotateEachWord128 {}
+
+pub trait RotateEachWord32 {
+    fn rotate_each_word_right7(self) -> Self;
+    fn rotate_each_word_right8(self) -> Self;
+    fn rotate_each_word_right11(self) -> Self;
+    fn rotate_each_word_right12(self) -> Self;
+    fn rotate_each_word_right16(self) -> Self;
+    fn rotate_each_word_right20(self) -> Self;
+    fn rotate_each_word_right24(self) -> Self;
+    fn rotate_each_word_right25(self) -> Self;
+}
+
+pub trait RotateEachWord64 {
+    fn rotate_each_word_right32(self) -> Self;
+}
+
+pub trait RotateEachWord128 {}
+
+// Vector type naming scheme:
+// uN[xP]xL
+// Unsigned; N-bit words * P bits per lane * L lanes
+//
+// A lane is always 128-bits, chosen because common SIMD architectures treat 128-bit units of
+// wide vectors specially (supporting e.g. intra-lane shuffles), and tend to have limited and
+// slow inter-lane operations.
+
+use crate::arch::{vec128_storage, vec256_storage, vec512_storage};
+
+#[allow(clippy::missing_safety_doc)]
+pub trait UnsafeFrom<T> {
+    unsafe fn unsafe_from(t: T) -> Self;
+}
+
+/// A vector composed of two elements, which may be words or themselves vectors.
+pub trait Vec2<W> {
+    fn extract(self, i: u32) -> W;
+    fn insert(self, w: W, i: u32) -> Self;
+}
+
+/// A vector composed of four elements, which may be words or themselves vectors.
+pub trait Vec4<W> {
+    fn extract(self, i: u32) -> W;
+    fn insert(self, w: W, i: u32) -> Self;
+}
+/// Vec4 functions which may not be implemented yet for all Vec4 types.
+/// NOTE: functions in this trait may be moved to Vec4 in any patch release. To avoid breakage,
+/// import Vec4Ext only together with Vec4, and don't qualify its methods.
+pub trait Vec4Ext<W> {
+    fn transpose4(a: Self, b: Self, c: Self, d: Self) -> (Self, Self, Self, Self)
+    where
+        Self: Sized;
+}
+pub trait Vector<T> {
+    fn to_scalars(self) -> T;
+}
+
+// TODO: multiples of 4 should inherit this
+/// A vector composed of four words; depending on their size, operations may cross lanes.
+pub trait Words4 {
+    fn shuffle1230(self) -> Self;
+    fn shuffle2301(self) -> Self;
+    fn shuffle3012(self) -> Self;
+}
+
+/// A vector composed one or more lanes each composed of four words.
+pub trait LaneWords4 {
+    fn shuffle_lane_words1230(self) -> Self;
+    fn shuffle_lane_words2301(self) -> Self;
+    fn shuffle_lane_words3012(self) -> Self;
+}
+
+// TODO: make this a part of BitOps
+/// Exchange neigboring ranges of bits of the specified size
+pub trait Swap64 {
+    fn swap1(self) -> Self;
+    fn swap2(self) -> Self;
+    fn swap4(self) -> Self;
+    fn swap8(self) -> Self;
+    fn swap16(self) -> Self;
+    fn swap32(self) -> Self;
+    fn swap64(self) -> Self;
+}
+
+pub trait u32x4<M: Machine>:
+    BitOps32
+    + Store<vec128_storage>
+    + ArithOps
+    + Vec4<u32>
+    + Words4
+    + LaneWords4
+    + StoreBytes
+    + MultiLane<[u32; 4]>
+    + Into<vec128_storage>
+{
+}
+pub trait u64x2<M: Machine>:
+    BitOps64 + Store<vec128_storage> + ArithOps + Vec2<u64> + MultiLane<[u64; 2]> + Into<vec128_storage>
+{
+}
+pub trait u128x1<M: Machine>:
+    BitOps128 + Store<vec128_storage> + Swap64 + MultiLane<[u128; 1]> + Into<vec128_storage>
+{
+}
+
+pub trait u32x4x2<M: Machine>:
+    BitOps32
+    + Store<vec256_storage>
+    + Vec2<M::u32x4>
+    + MultiLane<[M::u32x4; 2]>
+    + ArithOps
+    + Into<vec256_storage>
+    + StoreBytes
+{
+}
+pub trait u64x2x2<M: Machine>:
+    BitOps64
+    + Store<vec256_storage>
+    + Vec2<M::u64x2>
+    + MultiLane<[M::u64x2; 2]>
+    + ArithOps
+    + StoreBytes
+    + Into<vec256_storage>
+{
+}
+pub trait u64x4<M: Machine>:
+    BitOps64
+    + Store<vec256_storage>
+    + Vec4<u64>
+    + MultiLane<[u64; 4]>
+    + ArithOps
+    + Words4
+    + StoreBytes
+    + Into<vec256_storage>
+{
+}
+pub trait u128x2<M: Machine>:
+    BitOps128
+    + Store<vec256_storage>
+    + Vec2<M::u128x1>
+    + MultiLane<[M::u128x1; 2]>
+    + Swap64
+    + Into<vec256_storage>
+{
+}
+
+pub trait u32x4x4<M: Machine>:
+    BitOps32
+    + Store<vec512_storage>
+    + Vec4<M::u32x4>
+    + Vec4Ext<M::u32x4>
+    + Vector<[u32; 16]>
+    + MultiLane<[M::u32x4; 4]>
+    + ArithOps
+    + LaneWords4
+    + Into<vec512_storage>
+    + StoreBytes
+{
+}
+pub trait u64x2x4<M: Machine>:
+    BitOps64
+    + Store<vec512_storage>
+    + Vec4<M::u64x2>
+    + MultiLane<[M::u64x2; 4]>
+    + ArithOps
+    + Into<vec512_storage>
+{
+}
+// TODO: Words4
+pub trait u128x4<M: Machine>:
+    BitOps128
+    + Store<vec512_storage>
+    + Vec4<M::u128x1>
+    + MultiLane<[M::u128x1; 4]>
+    + Swap64
+    + Into<vec512_storage>
+{
+}
+
+/// A vector composed of multiple 128-bit lanes.
+pub trait MultiLane<Lanes> {
+    /// Split a multi-lane vector into single-lane vectors.
+    fn to_lanes(self) -> Lanes;
+    /// Build a multi-lane vector from individual lanes.
+    fn from_lanes(lanes: Lanes) -> Self;
+}
+
+/// Combine single vectors into a multi-lane vector.
+pub trait VZip<V> {
+    fn vzip(self) -> V;
+}
+
+impl<V, T> VZip<V> for T
+where
+    V: MultiLane<T>,
+{
+    #[inline(always)]
+    fn vzip(self) -> V {
+        V::from_lanes(self)
+    }
+}
+
+pub trait Machine: Sized + Copy {
+    type u32x4: u32x4<Self>;
+    type u64x2: u64x2<Self>;
+    type u128x1: u128x1<Self>;
+
+    type u32x4x2: u32x4x2<Self>;
+    type u64x2x2: u64x2x2<Self>;
+    type u64x4: u64x4<Self>;
+    type u128x2: u128x2<Self>;
+
+    type u32x4x4: u32x4x4<Self>;
+    type u64x2x4: u64x2x4<Self>;
+    type u128x4: u128x4<Self>;
+
+    #[inline(always)]
+    fn unpack<S, V: Store<S>>(self, s: S) -> V {
+        unsafe { V::unpack(s) }
+    }
+
+    #[inline(always)]
+    fn vec<V, A>(self, a: A) -> V
+    where
+        V: MultiLane<A>,
+    {
+        V::from_lanes(a)
+    }
+
+    #[inline(always)]
+    fn read_le<V>(self, input: &[u8]) -> V
+    where
+        V: StoreBytes,
+    {
+        unsafe { V::unsafe_read_le(input) }
+    }
+
+    #[inline(always)]
+    fn read_be<V>(self, input: &[u8]) -> V
+    where
+        V: StoreBytes,
+    {
+        unsafe { V::unsafe_read_be(input) }
+    }
+
+    /// # Safety
+    /// Caller must ensure the type of Self is appropriate for the hardware of the execution
+    /// environment.
+    unsafe fn instance() -> Self;
+}
+
+pub trait Store<S> {
+    /// # Safety
+    /// Caller must ensure the type of Self is appropriate for the hardware of the execution
+    /// environment.
+    unsafe fn unpack(p: S) -> Self;
+}
+
+pub trait StoreBytes {
+    /// # Safety
+    /// Caller must ensure the type of Self is appropriate for the hardware of the execution
+    /// environment.
+    unsafe fn unsafe_read_le(input: &[u8]) -> Self;
+    /// # Safety
+    /// Caller must ensure the type of Self is appropriate for the hardware of the execution
+    /// environment.
+    unsafe fn unsafe_read_be(input: &[u8]) -> Self;
+    fn write_le(self, out: &mut [u8]);
+    fn write_be(self, out: &mut [u8]);
+}
diff --git a/crates/ppv-lite86/src/x86_64/mod.rs b/crates/ppv-lite86/src/x86_64/mod.rs
new file mode 100644
index 0000000..937732d
--- /dev/null
+++ b/crates/ppv-lite86/src/x86_64/mod.rs
@@ -0,0 +1,437 @@
+// crate minimums: sse2, x86_64
+
+use crate::types::*;
+use core::arch::x86_64::{__m128i, __m256i};
+
+mod sse2;
+
+#[derive(Copy, Clone)]
+pub struct YesS3;
+#[derive(Copy, Clone)]
+pub struct NoS3;
+
+#[derive(Copy, Clone)]
+pub struct YesS4;
+#[derive(Copy, Clone)]
+pub struct NoS4;
+
+#[derive(Copy, Clone)]
+pub struct YesA1;
+#[derive(Copy, Clone)]
+pub struct NoA1;
+
+#[derive(Copy, Clone)]
+pub struct YesA2;
+#[derive(Copy, Clone)]
+pub struct NoA2;
+
+#[derive(Copy, Clone)]
+pub struct YesNI;
+#[derive(Copy, Clone)]
+pub struct NoNI;
+
+use core::marker::PhantomData;
+
+#[derive(Copy, Clone)]
+pub struct SseMachine<S3, S4, NI>(PhantomData<(S3, S4, NI)>);
+impl<S3: Copy, S4: Copy, NI: Copy> Machine for SseMachine<S3, S4, NI>
+where
+    sse2::u128x1_sse2<S3, S4, NI>: Swap64,
+    sse2::u64x2_sse2<S3, S4, NI>: BSwap + RotateEachWord32 + MultiLane<[u64; 2]> + Vec2<u64>,
+    sse2::u32x4_sse2<S3, S4, NI>: BSwap + RotateEachWord32 + MultiLane<[u32; 4]> + Vec4<u32>,
+    sse2::u64x4_sse2<S3, S4, NI>: BSwap + Words4,
+    sse2::u128x1_sse2<S3, S4, NI>: BSwap,
+    sse2::u128x2_sse2<S3, S4, NI>: Into<sse2::u64x2x2_sse2<S3, S4, NI>>,
+    sse2::u128x2_sse2<S3, S4, NI>: Into<sse2::u64x4_sse2<S3, S4, NI>>,
+    sse2::u128x2_sse2<S3, S4, NI>: Into<sse2::u32x4x2_sse2<S3, S4, NI>>,
+    sse2::u128x4_sse2<S3, S4, NI>: Into<sse2::u64x2x4_sse2<S3, S4, NI>>,
+    sse2::u128x4_sse2<S3, S4, NI>: Into<sse2::u32x4x4_sse2<S3, S4, NI>>,
+{
+    type u32x4 = sse2::u32x4_sse2<S3, S4, NI>;
+    type u64x2 = sse2::u64x2_sse2<S3, S4, NI>;
+    type u128x1 = sse2::u128x1_sse2<S3, S4, NI>;
+
+    type u32x4x2 = sse2::u32x4x2_sse2<S3, S4, NI>;
+    type u64x2x2 = sse2::u64x2x2_sse2<S3, S4, NI>;
+    type u64x4 = sse2::u64x4_sse2<S3, S4, NI>;
+    type u128x2 = sse2::u128x2_sse2<S3, S4, NI>;
+
+    type u32x4x4 = sse2::u32x4x4_sse2<S3, S4, NI>;
+    type u64x2x4 = sse2::u64x2x4_sse2<S3, S4, NI>;
+    type u128x4 = sse2::u128x4_sse2<S3, S4, NI>;
+
+    #[inline(always)]
+    unsafe fn instance() -> Self {
+        SseMachine(PhantomData)
+    }
+}
+
+#[derive(Copy, Clone)]
+pub struct Avx2Machine<NI>(PhantomData<NI>);
+impl<NI: Copy> Machine for Avx2Machine<NI>
+where
+    sse2::u128x1_sse2<YesS3, YesS4, NI>: BSwap + Swap64,
+    sse2::u64x2_sse2<YesS3, YesS4, NI>: BSwap + RotateEachWord32 + MultiLane<[u64; 2]> + Vec2<u64>,
+    sse2::u32x4_sse2<YesS3, YesS4, NI>: BSwap + RotateEachWord32 + MultiLane<[u32; 4]> + Vec4<u32>,
+    sse2::u64x4_sse2<YesS3, YesS4, NI>: BSwap + Words4,
+{
+    type u32x4 = sse2::u32x4_sse2<YesS3, YesS4, NI>;
+    type u64x2 = sse2::u64x2_sse2<YesS3, YesS4, NI>;
+    type u128x1 = sse2::u128x1_sse2<YesS3, YesS4, NI>;
+
+    type u32x4x2 = sse2::avx2::u32x4x2_avx2<NI>;
+    type u64x2x2 = sse2::u64x2x2_sse2<YesS3, YesS4, NI>;
+    type u64x4 = sse2::u64x4_sse2<YesS3, YesS4, NI>;
+    type u128x2 = sse2::u128x2_sse2<YesS3, YesS4, NI>;
+
+    type u32x4x4 = sse2::avx2::u32x4x4_avx2<NI>;
+    type u64x2x4 = sse2::u64x2x4_sse2<YesS3, YesS4, NI>;
+    type u128x4 = sse2::u128x4_sse2<YesS3, YesS4, NI>;
+
+    #[inline(always)]
+    unsafe fn instance() -> Self {
+        Avx2Machine(PhantomData)
+    }
+}
+
+pub type SSE2 = SseMachine<NoS3, NoS4, NoNI>;
+pub type SSSE3 = SseMachine<YesS3, NoS4, NoNI>;
+pub type SSE41 = SseMachine<YesS3, YesS4, NoNI>;
+/// AVX but not AVX2: only 128-bit integer operations, but use VEX versions of everything
+/// to avoid expensive SSE/VEX conflicts.
+pub type AVX = SseMachine<YesS3, YesS4, NoNI>;
+pub type AVX2 = Avx2Machine<NoNI>;
+
+/// Generic wrapper for unparameterized storage of any of the possible impls.
+/// Converting into and out of this type should be essentially free, although it may be more
+/// aligned than a particular impl requires.
+#[allow(non_camel_case_types)]
+#[derive(Copy, Clone)]
+pub union vec128_storage {
+    u32x4: [u32; 4],
+    u64x2: [u64; 2],
+    u128x1: [u128; 1],
+    sse2: __m128i,
+}
+impl Store<vec128_storage> for vec128_storage {
+    #[inline(always)]
+    unsafe fn unpack(p: vec128_storage) -> Self {
+        p
+    }
+}
+impl<'a> From<&'a vec128_storage> for &'a [u32; 4] {
+    #[inline(always)]
+    fn from(x: &'a vec128_storage) -> Self {
+        unsafe { &x.u32x4 }
+    }
+}
+impl From<[u32; 4]> for vec128_storage {
+    #[inline(always)]
+    fn from(u32x4: [u32; 4]) -> Self {
+        vec128_storage { u32x4 }
+    }
+}
+impl Default for vec128_storage {
+    #[inline(always)]
+    fn default() -> Self {
+        vec128_storage { u128x1: [0] }
+    }
+}
+impl Eq for vec128_storage {}
+impl PartialEq for vec128_storage {
+    #[inline(always)]
+    fn eq(&self, rhs: &Self) -> bool {
+        unsafe { self.u128x1 == rhs.u128x1 }
+    }
+}
+
+#[allow(non_camel_case_types)]
+#[derive(Copy, Clone)]
+pub union vec256_storage {
+    u32x8: [u32; 8],
+    u64x4: [u64; 4],
+    u128x2: [u128; 2],
+    sse2: [vec128_storage; 2],
+    avx: __m256i,
+}
+impl From<[u64; 4]> for vec256_storage {
+    #[inline(always)]
+    fn from(u64x4: [u64; 4]) -> Self {
+        vec256_storage { u64x4 }
+    }
+}
+impl Default for vec256_storage {
+    #[inline(always)]
+    fn default() -> Self {
+        vec256_storage { u128x2: [0, 0] }
+    }
+}
+impl vec256_storage {
+    #[inline(always)]
+    pub fn new128(xs: [vec128_storage; 2]) -> Self {
+        Self { sse2: xs }
+    }
+    #[inline(always)]
+    pub fn split128(self) -> [vec128_storage; 2] {
+        unsafe { self.sse2 }
+    }
+}
+impl Eq for vec256_storage {}
+impl PartialEq for vec256_storage {
+    #[inline(always)]
+    fn eq(&self, rhs: &Self) -> bool {
+        unsafe { self.sse2 == rhs.sse2 }
+    }
+}
+
+#[allow(non_camel_case_types)]
+#[derive(Copy, Clone)]
+pub union vec512_storage {
+    u32x16: [u32; 16],
+    u64x8: [u64; 8],
+    u128x4: [u128; 4],
+    sse2: [vec128_storage; 4],
+    avx: [vec256_storage; 2],
+}
+impl Default for vec512_storage {
+    #[inline(always)]
+    fn default() -> Self {
+        vec512_storage {
+            u128x4: [0, 0, 0, 0],
+        }
+    }
+}
+impl vec512_storage {
+    #[inline(always)]
+    pub fn new128(xs: [vec128_storage; 4]) -> Self {
+        Self { sse2: xs }
+    }
+    #[inline(always)]
+    pub fn split128(self) -> [vec128_storage; 4] {
+        unsafe { self.sse2 }
+    }
+}
+impl Eq for vec512_storage {}
+impl PartialEq for vec512_storage {
+    #[inline(always)]
+    fn eq(&self, rhs: &Self) -> bool {
+        unsafe { self.avx == rhs.avx }
+    }
+}
+
+macro_rules! impl_into {
+    ($storage:ident, $array:ty, $name:ident) => {
+        impl From<$storage> for $array {
+            #[inline(always)]
+            fn from(vec: $storage) -> Self {
+                unsafe { vec.$name }
+            }
+        }
+    };
+}
+impl_into!(vec128_storage, [u32; 4], u32x4);
+impl_into!(vec128_storage, [u64; 2], u64x2);
+impl_into!(vec128_storage, [u128; 1], u128x1);
+impl_into!(vec256_storage, [u32; 8], u32x8);
+impl_into!(vec256_storage, [u64; 4], u64x4);
+impl_into!(vec256_storage, [u128; 2], u128x2);
+impl_into!(vec512_storage, [u32; 16], u32x16);
+impl_into!(vec512_storage, [u64; 8], u64x8);
+impl_into!(vec512_storage, [u128; 4], u128x4);
+
+/// Generate the full set of optimized implementations to take advantage of the most important
+/// hardware feature sets.
+///
+/// This dispatcher is suitable for maximizing throughput.
+#[macro_export]
+macro_rules! dispatch {
+    ($mach:ident, $MTy:ident, { $([$pub:tt$(($krate:tt))*])* fn $name:ident($($arg:ident: $argty:ty),* $(,)*) -> $ret:ty $body:block }) => {
+        #[cfg(feature = "std")]
+        $($pub$(($krate))*)* fn $name($($arg: $argty),*) -> $ret {
+            #[inline(always)]
+            fn fn_impl<$MTy: $crate::Machine>($mach: $MTy, $($arg: $argty),*) -> $ret $body
+            use std::arch::x86_64::*;
+            #[target_feature(enable = "avx2")]
+            unsafe fn impl_avx2($($arg: $argty),*) -> $ret {
+                let ret = fn_impl($crate::x86_64::AVX2::instance(), $($arg),*);
+                _mm256_zeroupper();
+                ret
+            }
+            #[target_feature(enable = "avx")]
+            #[target_feature(enable = "sse4.1")]
+            #[target_feature(enable = "ssse3")]
+            unsafe fn impl_avx($($arg: $argty),*) -> $ret {
+                let ret = fn_impl($crate::x86_64::AVX::instance(), $($arg),*);
+                _mm256_zeroupper();
+                ret
+            }
+            #[target_feature(enable = "sse4.1")]
+            #[target_feature(enable = "ssse3")]
+            unsafe fn impl_sse41($($arg: $argty),*) -> $ret {
+                fn_impl($crate::x86_64::SSE41::instance(), $($arg),*)
+            }
+            #[target_feature(enable = "ssse3")]
+            unsafe fn impl_ssse3($($arg: $argty),*) -> $ret {
+                fn_impl($crate::x86_64::SSSE3::instance(), $($arg),*)
+            }
+            #[target_feature(enable = "sse2")]
+            unsafe fn impl_sse2($($arg: $argty),*) -> $ret {
+                fn_impl($crate::x86_64::SSE2::instance(), $($arg),*)
+            }
+            unsafe {
+                if is_x86_feature_detected!("avx2") {
+                    impl_avx2($($arg),*)
+                } else if is_x86_feature_detected!("avx") {
+                    impl_avx($($arg),*)
+                } else if is_x86_feature_detected!("sse4.1") {
+                    impl_sse41($($arg),*)
+                } else if is_x86_feature_detected!("ssse3") {
+                    impl_ssse3($($arg),*)
+                } else if is_x86_feature_detected!("sse2") {
+                    impl_sse2($($arg),*)
+                } else {
+                    unimplemented!()
+                }
+            }
+        }
+        #[cfg(not(feature = "std"))]
+        #[inline(always)]
+        $($pub$(($krate))*)* fn $name($($arg: $argty),*) -> $ret {
+            unsafe fn fn_impl<$MTy: $crate::Machine>($mach: $MTy, $($arg: $argty),*) -> $ret $body
+            unsafe {
+                if cfg!(target_feature = "avx2") {
+                    fn_impl($crate::x86_64::AVX2::instance(), $($arg),*)
+                } else if cfg!(target_feature = "avx") {
+                    fn_impl($crate::x86_64::AVX::instance(), $($arg),*)
+                } else if cfg!(target_feature = "sse4.1") {
+                    fn_impl($crate::x86_64::SSE41::instance(), $($arg),*)
+                } else if cfg!(target_feature = "ssse3") {
+                    fn_impl($crate::x86_64::SSSE3::instance(), $($arg),*)
+                } else {
+                    fn_impl($crate::x86_64::SSE2::instance(), $($arg),*)
+                }
+            }
+        }
+    };
+    ($mach:ident, $MTy:ident, { $([$pub:tt $(($krate:tt))*])* fn $name:ident($($arg:ident: $argty:ty),* $(,)*) $body:block }) => {
+        dispatch!($mach, $MTy, {
+            $([$pub $(($krate))*])* fn $name($($arg: $argty),*) -> () $body
+        });
+    }
+}
+
+/// Generate only the basic implementations necessary to be able to operate efficiently on 128-bit
+/// vectors on this platfrom. For x86-64, that would mean SSE2 and AVX.
+///
+/// This dispatcher is suitable for vector operations that do not benefit from advanced hardware
+/// features (e.g. because they are done infrequently), so minimizing their contribution to code
+/// size is more important.
+#[macro_export]
+macro_rules! dispatch_light128 {
+    ($mach:ident, $MTy:ident, { $([$pub:tt$(($krate:tt))*])* fn $name:ident($($arg:ident: $argty:ty),* $(,)*) -> $ret:ty $body:block }) => {
+        #[cfg(feature = "std")]
+        $($pub $(($krate))*)* fn $name($($arg: $argty),*) -> $ret {
+            #[inline(always)]
+            fn fn_impl<$MTy: $crate::Machine>($mach: $MTy, $($arg: $argty),*) -> $ret $body
+            use std::arch::x86_64::*;
+            #[target_feature(enable = "avx")]
+            unsafe fn impl_avx($($arg: $argty),*) -> $ret {
+                fn_impl($crate::x86_64::AVX::instance(), $($arg),*)
+            }
+            #[target_feature(enable = "sse2")]
+            unsafe fn impl_sse2($($arg: $argty),*) -> $ret {
+                fn_impl($crate::x86_64::SSE2::instance(), $($arg),*)
+            }
+            unsafe {
+                if is_x86_feature_detected!("avx") {
+                    impl_avx($($arg),*)
+                } else if is_x86_feature_detected!("sse2") {
+                    impl_sse2($($arg),*)
+                } else {
+                    unimplemented!()
+                }
+            }
+        }
+        #[cfg(not(feature = "std"))]
+        #[inline(always)]
+        $($pub$(($krate))*)* fn $name($($arg: $argty),*) -> $ret {
+            unsafe fn fn_impl<$MTy: $crate::Machine>($mach: $MTy, $($arg: $argty),*) -> $ret $body
+            unsafe {
+                if cfg!(target_feature = "avx2") {
+                    fn_impl($crate::x86_64::AVX2::instance(), $($arg),*)
+                } else if cfg!(target_feature = "avx") {
+                    fn_impl($crate::x86_64::AVX::instance(), $($arg),*)
+                } else if cfg!(target_feature = "sse4.1") {
+                    fn_impl($crate::x86_64::SSE41::instance(), $($arg),*)
+                } else if cfg!(target_feature = "ssse3") {
+                    fn_impl($crate::x86_64::SSSE3::instance(), $($arg),*)
+                } else {
+                    fn_impl($crate::x86_64::SSE2::instance(), $($arg),*)
+                }
+            }
+        }
+    };
+    ($mach:ident, $MTy:ident, { $([$pub:tt$(($krate:tt))*])* fn $name:ident($($arg:ident: $argty:ty),* $(,)*) $body:block }) => {
+        dispatch_light128!($mach, $MTy, {
+            $([$pub $(($krate))*])* fn $name($($arg: $argty),*) -> () $body
+        });
+    }
+}
+
+/// Generate only the basic implementations necessary to be able to operate efficiently on 256-bit
+/// vectors on this platfrom. For x86-64, that would mean SSE2, AVX, and AVX2.
+///
+/// This dispatcher is suitable for vector operations that do not benefit from advanced hardware
+/// features (e.g. because they are done infrequently), so minimizing their contribution to code
+/// size is more important.
+#[macro_export]
+macro_rules! dispatch_light256 {
+    ($mach:ident, $MTy:ident, { $([$pub:tt$(($krate:tt))*])* fn $name:ident($($arg:ident: $argty:ty),* $(,)*) -> $ret:ty $body:block }) => {
+        #[cfg(feature = "std")]
+        $([$pub $(($krate))*])* fn $name($($arg: $argty),*) -> $ret {
+            #[inline(always)]
+            fn fn_impl<$MTy: $crate::Machine>($mach: $MTy, $($arg: $argty),*) -> $ret $body
+            use std::arch::x86_64::*;
+            #[target_feature(enable = "avx")]
+            unsafe fn impl_avx($($arg: $argty),*) -> $ret {
+                fn_impl($crate::x86_64::AVX::instance(), $($arg),*)
+            }
+            #[target_feature(enable = "sse2")]
+            unsafe fn impl_sse2($($arg: $argty),*) -> $ret {
+                fn_impl($crate::x86_64::SSE2::instance(), $($arg),*)
+            }
+            unsafe {
+                if is_x86_feature_detected!("avx") {
+                    impl_avx($($arg),*)
+                } else if is_x86_feature_detected!("sse2") {
+                    impl_sse2($($arg),*)
+                } else {
+                    unimplemented!()
+                }
+            }
+        }
+        #[cfg(not(feature = "std"))]
+        #[inline(always)]
+        $($pub$(($krate))*)* fn $name($($arg: $argty),*) -> $ret {
+            unsafe fn fn_impl<$MTy: $crate::Machine>($mach: $MTy, $($arg: $argty),*) -> $ret $body
+            unsafe {
+                if cfg!(target_feature = "avx2") {
+                    fn_impl($crate::x86_64::AVX2::instance(), $($arg),*)
+                } else if cfg!(target_feature = "avx") {
+                    fn_impl($crate::x86_64::AVX::instance(), $($arg),*)
+                } else if cfg!(target_feature = "sse4.1") {
+                    fn_impl($crate::x86_64::SSE41::instance(), $($arg),*)
+                } else if cfg!(target_feature = "ssse3") {
+                    fn_impl($crate::x86_64::SSSE3::instance(), $($arg),*)
+                } else {
+                    fn_impl($crate::x86_64::SSE2::instance(), $($arg),*)
+                }
+            }
+        }
+    };
+    ($mach:ident, $MTy:ident, { $([$pub:tt$(($krate:tt))*])* fn $name:ident($($arg:ident: $argty:ty),* $(,)*) $body:block }) => {
+        dispatch_light256!($mach, $MTy, {
+            $([$pub $(($krate))*])* fn $name($($arg: $argty),*) -> () $body
+        });
+    }
+}
diff --git a/crates/ppv-lite86/src/x86_64/sse2.rs b/crates/ppv-lite86/src/x86_64/sse2.rs
new file mode 100644
index 0000000..97197a4
--- /dev/null
+++ b/crates/ppv-lite86/src/x86_64/sse2.rs
@@ -0,0 +1,1703 @@
+use crate::soft::{x2, x4};
+use crate::types::*;
+use crate::vec128_storage;
+use crate::x86_64::Avx2Machine;
+use crate::x86_64::SseMachine as Machine86;
+use crate::x86_64::{NoS3, NoS4, YesS3, YesS4};
+use core::arch::x86_64::*;
+use core::marker::PhantomData;
+use core::ops::{
+    Add, AddAssign, BitAnd, BitAndAssign, BitOr, BitOrAssign, BitXor, BitXorAssign, Not,
+};
+
+macro_rules! impl_binop {
+    ($vec:ident, $trait:ident, $fn:ident, $impl_fn:ident) => {
+        impl<S3, S4, NI> $trait for $vec<S3, S4, NI> {
+            type Output = Self;
+            #[inline(always)]
+            fn $fn(self, rhs: Self) -> Self::Output {
+                Self::new(unsafe { $impl_fn(self.x, rhs.x) })
+            }
+        }
+    };
+}
+
+macro_rules! impl_binop_assign {
+    ($vec:ident, $trait:ident, $fn_assign:ident, $fn:ident) => {
+        impl<S3, S4, NI> $trait for $vec<S3, S4, NI>
+        where
+            $vec<S3, S4, NI>: Copy,
+        {
+            #[inline(always)]
+            fn $fn_assign(&mut self, rhs: Self) {
+                *self = self.$fn(rhs);
+            }
+        }
+    };
+}
+
+macro_rules! def_vec {
+    ($vec:ident, $word:ident) => {
+        #[allow(non_camel_case_types)]
+        #[derive(Copy, Clone)]
+        pub struct $vec<S3, S4, NI> {
+            x: __m128i,
+            s3: PhantomData<S3>,
+            s4: PhantomData<S4>,
+            ni: PhantomData<NI>,
+        }
+
+        impl<S3, S4, NI> Store<vec128_storage> for $vec<S3, S4, NI> {
+            #[inline(always)]
+            unsafe fn unpack(x: vec128_storage) -> Self {
+                Self::new(x.sse2)
+            }
+        }
+        impl<S3, S4, NI> From<$vec<S3, S4, NI>> for vec128_storage {
+            #[inline(always)]
+            fn from(x: $vec<S3, S4, NI>) -> Self {
+                vec128_storage { sse2: x.x }
+            }
+        }
+        impl<S3, S4, NI> $vec<S3, S4, NI> {
+            #[inline(always)]
+            fn new(x: __m128i) -> Self {
+                $vec {
+                    x,
+                    s3: PhantomData,
+                    s4: PhantomData,
+                    ni: PhantomData,
+                }
+            }
+        }
+
+        impl<S3, S4, NI> StoreBytes for $vec<S3, S4, NI>
+        where
+            Self: BSwap,
+        {
+            #[inline(always)]
+            unsafe fn unsafe_read_le(input: &[u8]) -> Self {
+                assert_eq!(input.len(), 16);
+                Self::new(_mm_loadu_si128(input.as_ptr() as *const _))
+            }
+            #[inline(always)]
+            unsafe fn unsafe_read_be(input: &[u8]) -> Self {
+                assert_eq!(input.len(), 16);
+                Self::new(_mm_loadu_si128(input.as_ptr() as *const _)).bswap()
+            }
+            #[inline(always)]
+            fn write_le(self, out: &mut [u8]) {
+                assert_eq!(out.len(), 16);
+                unsafe { _mm_storeu_si128(out.as_mut_ptr() as *mut _, self.x) }
+            }
+            #[inline(always)]
+            fn write_be(self, out: &mut [u8]) {
+                assert_eq!(out.len(), 16);
+                let x = self.bswap().x;
+                unsafe {
+                    _mm_storeu_si128(out.as_mut_ptr() as *mut _, x);
+                }
+            }
+        }
+
+        impl<S3, S4, NI> Default for $vec<S3, S4, NI> {
+            #[inline(always)]
+            fn default() -> Self {
+                Self::new(unsafe { _mm_setzero_si128() })
+            }
+        }
+
+        impl<S3, S4, NI> Not for $vec<S3, S4, NI> {
+            type Output = Self;
+            #[inline(always)]
+            fn not(self) -> Self::Output {
+                unsafe {
+                    let ff = _mm_set1_epi64x(-1i64);
+                    self ^ Self::new(ff)
+                }
+            }
+        }
+
+        impl<S3: Copy, S4: Copy, NI: Copy> BitOps0 for $vec<S3, S4, NI> {}
+        impl_binop!($vec, BitAnd, bitand, _mm_and_si128);
+        impl_binop!($vec, BitOr, bitor, _mm_or_si128);
+        impl_binop!($vec, BitXor, bitxor, _mm_xor_si128);
+        impl_binop_assign!($vec, BitAndAssign, bitand_assign, bitand);
+        impl_binop_assign!($vec, BitOrAssign, bitor_assign, bitor);
+        impl_binop_assign!($vec, BitXorAssign, bitxor_assign, bitxor);
+        impl<S3: Copy, S4: Copy, NI: Copy> AndNot for $vec<S3, S4, NI> {
+            type Output = Self;
+            #[inline(always)]
+            fn andnot(self, rhs: Self) -> Self {
+                Self::new(unsafe { _mm_andnot_si128(self.x, rhs.x) })
+            }
+        }
+    };
+}
+
+macro_rules! impl_bitops32 {
+    ($vec:ident) => {
+        impl<S3: Copy, S4: Copy, NI: Copy> BitOps32 for $vec<S3, S4, NI> where
+            $vec<S3, S4, NI>: RotateEachWord32
+        {
+        }
+    };
+}
+
+macro_rules! impl_bitops64 {
+    ($vec:ident) => {
+        impl_bitops32!($vec);
+        impl<S3: Copy, S4: Copy, NI: Copy> BitOps64 for $vec<S3, S4, NI> where
+            $vec<S3, S4, NI>: RotateEachWord64 + RotateEachWord32
+        {
+        }
+    };
+}
+
+macro_rules! impl_bitops128 {
+    ($vec:ident) => {
+        impl_bitops64!($vec);
+        impl<S3: Copy, S4: Copy, NI: Copy> BitOps128 for $vec<S3, S4, NI> where
+            $vec<S3, S4, NI>: RotateEachWord128
+        {
+        }
+    };
+}
+
+macro_rules! rotr_32_s3 {
+    ($name:ident, $k0:expr, $k1:expr) => {
+        #[inline(always)]
+        fn $name(self) -> Self {
+            Self::new(unsafe { _mm_shuffle_epi8(self.x, _mm_set_epi64x($k0, $k1)) })
+        }
+    };
+}
+macro_rules! rotr_32 {
+    ($name:ident, $i:expr) => {
+        #[inline(always)]
+        fn $name(self) -> Self {
+            Self::new(unsafe {
+                _mm_or_si128(
+                    _mm_srli_epi32(self.x, $i as i32),
+                    _mm_slli_epi32(self.x, 32 - $i as i32),
+                )
+            })
+        }
+    };
+}
+impl<S4: Copy, NI: Copy> RotateEachWord32 for u32x4_sse2<YesS3, S4, NI> {
+    rotr_32!(rotate_each_word_right7, 7);
+    rotr_32_s3!(
+        rotate_each_word_right8,
+        0x0c0f_0e0d_080b_0a09,
+        0x0407_0605_0003_0201
+    );
+    rotr_32!(rotate_each_word_right11, 11);
+    rotr_32!(rotate_each_word_right12, 12);
+    rotr_32_s3!(
+        rotate_each_word_right16,
+        0x0d0c_0f0e_0908_0b0a,
+        0x0504_0706_0100_0302
+    );
+    rotr_32!(rotate_each_word_right20, 20);
+    rotr_32_s3!(
+        rotate_each_word_right24,
+        0x0e0d_0c0f_0a09_080b,
+        0x0605_0407_0201_0003
+    );
+    rotr_32!(rotate_each_word_right25, 25);
+}
+impl<S4: Copy, NI: Copy> RotateEachWord32 for u32x4_sse2<NoS3, S4, NI> {
+    rotr_32!(rotate_each_word_right7, 7);
+    rotr_32!(rotate_each_word_right8, 8);
+    rotr_32!(rotate_each_word_right11, 11);
+    rotr_32!(rotate_each_word_right12, 12);
+    #[inline(always)]
+    fn rotate_each_word_right16(self) -> Self {
+        Self::new(swap16_s2(self.x))
+    }
+    rotr_32!(rotate_each_word_right20, 20);
+    rotr_32!(rotate_each_word_right24, 24);
+    rotr_32!(rotate_each_word_right25, 25);
+}
+
+macro_rules! rotr_64_s3 {
+    ($name:ident, $k0:expr, $k1:expr) => {
+        #[inline(always)]
+        fn $name(self) -> Self {
+            Self::new(unsafe { _mm_shuffle_epi8(self.x, _mm_set_epi64x($k0, $k1)) })
+        }
+    };
+}
+macro_rules! rotr_64 {
+    ($name:ident, $i:expr) => {
+        #[inline(always)]
+        fn $name(self) -> Self {
+            Self::new(unsafe {
+                _mm_or_si128(
+                    _mm_srli_epi64(self.x, $i as i32),
+                    _mm_slli_epi64(self.x, 64 - $i as i32),
+                )
+            })
+        }
+    };
+}
+impl<S4: Copy, NI: Copy> RotateEachWord32 for u64x2_sse2<YesS3, S4, NI> {
+    rotr_64!(rotate_each_word_right7, 7);
+    rotr_64_s3!(
+        rotate_each_word_right8,
+        0x080f_0e0d_0c0b_0a09,
+        0x0007_0605_0403_0201
+    );
+    rotr_64!(rotate_each_word_right11, 11);
+    rotr_64!(rotate_each_word_right12, 12);
+    rotr_64_s3!(
+        rotate_each_word_right16,
+        0x0908_0f0e_0d0c_0b0a,
+        0x0100_0706_0504_0302
+    );
+    rotr_64!(rotate_each_word_right20, 20);
+    rotr_64_s3!(
+        rotate_each_word_right24,
+        0x0a09_080f_0e0d_0c0b,
+        0x0201_0007_0605_0403
+    );
+    rotr_64!(rotate_each_word_right25, 25);
+}
+impl<S4: Copy, NI: Copy> RotateEachWord32 for u64x2_sse2<NoS3, S4, NI> {
+    rotr_64!(rotate_each_word_right7, 7);
+    rotr_64!(rotate_each_word_right8, 8);
+    rotr_64!(rotate_each_word_right11, 11);
+    rotr_64!(rotate_each_word_right12, 12);
+    #[inline(always)]
+    fn rotate_each_word_right16(self) -> Self {
+        Self::new(swap16_s2(self.x))
+    }
+    rotr_64!(rotate_each_word_right20, 20);
+    rotr_64!(rotate_each_word_right24, 24);
+    rotr_64!(rotate_each_word_right25, 25);
+}
+impl<S3: Copy, S4: Copy, NI: Copy> RotateEachWord64 for u64x2_sse2<S3, S4, NI> {
+    #[inline(always)]
+    fn rotate_each_word_right32(self) -> Self {
+        Self::new(unsafe { _mm_shuffle_epi32(self.x, 0b10110001) })
+    }
+}
+
+macro_rules! rotr_128 {
+    ($name:ident, $i:expr) => {
+        #[inline(always)]
+        fn $name(self) -> Self {
+            Self::new(unsafe {
+                _mm_or_si128(
+                    _mm_srli_si128(self.x, $i as i32),
+                    _mm_slli_si128(self.x, 128 - $i as i32),
+                )
+            })
+        }
+    };
+}
+// TODO: completely unoptimized
+impl<S3: Copy, S4: Copy, NI: Copy> RotateEachWord32 for u128x1_sse2<S3, S4, NI> {
+    rotr_128!(rotate_each_word_right7, 7);
+    rotr_128!(rotate_each_word_right8, 8);
+    rotr_128!(rotate_each_word_right11, 11);
+    rotr_128!(rotate_each_word_right12, 12);
+    rotr_128!(rotate_each_word_right16, 16);
+    rotr_128!(rotate_each_word_right20, 20);
+    rotr_128!(rotate_each_word_right24, 24);
+    rotr_128!(rotate_each_word_right25, 25);
+}
+// TODO: completely unoptimized
+impl<S3: Copy, S4: Copy, NI: Copy> RotateEachWord64 for u128x1_sse2<S3, S4, NI> {
+    rotr_128!(rotate_each_word_right32, 32);
+}
+impl<S3: Copy, S4: Copy, NI: Copy> RotateEachWord128 for u128x1_sse2<S3, S4, NI> {}
+
+def_vec!(u32x4_sse2, u32);
+def_vec!(u64x2_sse2, u64);
+def_vec!(u128x1_sse2, u128);
+
+impl<S3, NI> MultiLane<[u32; 4]> for u32x4_sse2<S3, YesS4, NI> {
+    #[inline(always)]
+    fn to_lanes(self) -> [u32; 4] {
+        unsafe {
+            let x = _mm_cvtsi128_si64(self.x) as u64;
+            let y = _mm_extract_epi64(self.x, 1) as u64;
+            [x as u32, (x >> 32) as u32, y as u32, (y >> 32) as u32]
+        }
+    }
+    #[inline(always)]
+    fn from_lanes(xs: [u32; 4]) -> Self {
+        unsafe {
+            let mut x = _mm_cvtsi64_si128((xs[0] as u64 | ((xs[1] as u64) << 32)) as i64);
+            x = _mm_insert_epi64(x, (xs[2] as u64 | ((xs[3] as u64) << 32)) as i64, 1);
+            Self::new(x)
+        }
+    }
+}
+impl<S3, NI> MultiLane<[u32; 4]> for u32x4_sse2<S3, NoS4, NI> {
+    #[inline(always)]
+    fn to_lanes(self) -> [u32; 4] {
+        unsafe {
+            let x = _mm_cvtsi128_si64(self.x) as u64;
+            let y = _mm_cvtsi128_si64(_mm_shuffle_epi32(self.x, 0b11101110)) as u64;
+            [x as u32, (x >> 32) as u32, y as u32, (y >> 32) as u32]
+        }
+    }
+    #[inline(always)]
+    fn from_lanes(xs: [u32; 4]) -> Self {
+        unsafe {
+            let x = (xs[0] as u64 | ((xs[1] as u64) << 32)) as i64;
+            let y = (xs[2] as u64 | ((xs[3] as u64) << 32)) as i64;
+            let x = _mm_cvtsi64_si128(x);
+            let y = _mm_slli_si128(_mm_cvtsi64_si128(y), 8);
+            Self::new(_mm_or_si128(x, y))
+        }
+    }
+}
+impl<S3, NI> MultiLane<[u64; 2]> for u64x2_sse2<S3, YesS4, NI> {
+    #[inline(always)]
+    fn to_lanes(self) -> [u64; 2] {
+        unsafe {
+            [
+                _mm_cvtsi128_si64(self.x) as u64,
+                _mm_extract_epi64(self.x, 1) as u64,
+            ]
+        }
+    }
+    #[inline(always)]
+    fn from_lanes(xs: [u64; 2]) -> Self {
+        unsafe {
+            let mut x = _mm_cvtsi64_si128(xs[0] as i64);
+            x = _mm_insert_epi64(x, xs[1] as i64, 1);
+            Self::new(x)
+        }
+    }
+}
+impl<S3, NI> MultiLane<[u64; 2]> for u64x2_sse2<S3, NoS4, NI> {
+    #[inline(always)]
+    fn to_lanes(self) -> [u64; 2] {
+        unsafe {
+            [
+                _mm_cvtsi128_si64(self.x) as u64,
+                _mm_cvtsi128_si64(_mm_srli_si128(self.x, 8)) as u64,
+            ]
+        }
+    }
+    #[inline(always)]
+    fn from_lanes(xs: [u64; 2]) -> Self {
+        unsafe {
+            let x = _mm_cvtsi64_si128(xs[0] as i64);
+            let y = _mm_slli_si128(_mm_cvtsi64_si128(xs[1] as i64), 8);
+            Self::new(_mm_or_si128(x, y))
+        }
+    }
+}
+impl<S3, S4, NI> MultiLane<[u128; 1]> for u128x1_sse2<S3, S4, NI> {
+    #[inline(always)]
+    fn to_lanes(self) -> [u128; 1] {
+        unimplemented!()
+    }
+    #[inline(always)]
+    fn from_lanes(xs: [u128; 1]) -> Self {
+        unimplemented!("{:?}", xs)
+    }
+}
+
+impl<S3, S4, NI> MultiLane<[u64; 4]> for u64x4_sse2<S3, S4, NI>
+where
+    u64x2_sse2<S3, S4, NI>: MultiLane<[u64; 2]> + Copy,
+{
+    #[inline(always)]
+    fn to_lanes(self) -> [u64; 4] {
+        let (a, b) = (self.0[0].to_lanes(), self.0[1].to_lanes());
+        [a[0], a[1], b[0], b[1]]
+    }
+    #[inline(always)]
+    fn from_lanes(xs: [u64; 4]) -> Self {
+        let (a, b) = (
+            u64x2_sse2::from_lanes([xs[0], xs[1]]),
+            u64x2_sse2::from_lanes([xs[2], xs[3]]),
+        );
+        x2::new([a, b])
+    }
+}
+
+macro_rules! impl_into {
+    ($from:ident, $to:ident) => {
+        impl<S3, S4, NI> From<$from<S3, S4, NI>> for $to<S3, S4, NI> {
+            #[inline(always)]
+            fn from(x: $from<S3, S4, NI>) -> Self {
+                $to::new(x.x)
+            }
+        }
+    };
+}
+
+impl_into!(u128x1_sse2, u32x4_sse2);
+impl_into!(u128x1_sse2, u64x2_sse2);
+
+impl_bitops32!(u32x4_sse2);
+impl_bitops64!(u64x2_sse2);
+impl_bitops128!(u128x1_sse2);
+
+impl<S3: Copy, S4: Copy, NI: Copy> ArithOps for u32x4_sse2<S3, S4, NI> where
+    u32x4_sse2<S3, S4, NI>: BSwap
+{
+}
+impl<S3: Copy, S4: Copy, NI: Copy> ArithOps for u64x2_sse2<S3, S4, NI> where
+    u64x2_sse2<S3, S4, NI>: BSwap
+{
+}
+impl_binop!(u32x4_sse2, Add, add, _mm_add_epi32);
+impl_binop!(u64x2_sse2, Add, add, _mm_add_epi64);
+impl_binop_assign!(u32x4_sse2, AddAssign, add_assign, add);
+impl_binop_assign!(u64x2_sse2, AddAssign, add_assign, add);
+
+impl<S3: Copy, S4: Copy, NI: Copy> u32x4<Machine86<S3, S4, NI>> for u32x4_sse2<S3, S4, NI>
+where
+    u32x4_sse2<S3, S4, NI>: RotateEachWord32 + BSwap + MultiLane<[u32; 4]> + Vec4<u32>,
+    Machine86<S3, S4, NI>: Machine,
+{
+}
+impl<S3: Copy, S4: Copy, NI: Copy> u64x2<Machine86<S3, S4, NI>> for u64x2_sse2<S3, S4, NI>
+where
+    u64x2_sse2<S3, S4, NI>:
+        RotateEachWord64 + RotateEachWord32 + BSwap + MultiLane<[u64; 2]> + Vec2<u64>,
+    Machine86<S3, S4, NI>: Machine,
+{
+}
+impl<S3: Copy, S4: Copy, NI: Copy> u128x1<Machine86<S3, S4, NI>> for u128x1_sse2<S3, S4, NI>
+where
+    u128x1_sse2<S3, S4, NI>: Swap64 + RotateEachWord64 + RotateEachWord32 + BSwap,
+    Machine86<S3, S4, NI>: Machine,
+    u128x1_sse2<S3, S4, NI>: Into<<Machine86<S3, S4, NI> as Machine>::u32x4>,
+    u128x1_sse2<S3, S4, NI>: Into<<Machine86<S3, S4, NI> as Machine>::u64x2>,
+{
+}
+
+impl<NI: Copy> u32x4<Avx2Machine<NI>> for u32x4_sse2<YesS3, YesS4, NI>
+where
+    u32x4_sse2<YesS3, YesS4, NI>: RotateEachWord32 + BSwap + MultiLane<[u32; 4]> + Vec4<u32>,
+    Machine86<YesS3, YesS4, NI>: Machine,
+{
+}
+impl<NI: Copy> u64x2<Avx2Machine<NI>> for u64x2_sse2<YesS3, YesS4, NI>
+where
+    u64x2_sse2<YesS3, YesS4, NI>:
+        RotateEachWord64 + RotateEachWord32 + BSwap + MultiLane<[u64; 2]> + Vec2<u64>,
+    Machine86<YesS3, YesS4, NI>: Machine,
+{
+}
+impl<NI: Copy> u128x1<Avx2Machine<NI>> for u128x1_sse2<YesS3, YesS4, NI>
+where
+    u128x1_sse2<YesS3, YesS4, NI>: Swap64 + RotateEachWord64 + RotateEachWord32 + BSwap,
+    Machine86<YesS3, YesS4, NI>: Machine,
+    u128x1_sse2<YesS3, YesS4, NI>: Into<<Machine86<YesS3, YesS4, NI> as Machine>::u32x4>,
+    u128x1_sse2<YesS3, YesS4, NI>: Into<<Machine86<YesS3, YesS4, NI> as Machine>::u64x2>,
+{
+}
+
+impl<S3, S4, NI> UnsafeFrom<[u32; 4]> for u32x4_sse2<S3, S4, NI> {
+    #[inline(always)]
+    unsafe fn unsafe_from(xs: [u32; 4]) -> Self {
+        Self::new(_mm_set_epi32(
+            xs[3] as i32,
+            xs[2] as i32,
+            xs[1] as i32,
+            xs[0] as i32,
+        ))
+    }
+}
+
+impl<S3, NI> Vec4<u32> for u32x4_sse2<S3, YesS4, NI>
+where
+    Self: MultiLane<[u32; 4]>,
+{
+    #[inline(always)]
+    fn extract(self, i: u32) -> u32 {
+        self.to_lanes()[i as usize]
+    }
+    #[inline(always)]
+    fn insert(self, v: u32, i: u32) -> Self {
+        Self::new(unsafe {
+            match i {
+                0 => _mm_insert_epi32(self.x, v as i32, 0),
+                1 => _mm_insert_epi32(self.x, v as i32, 1),
+                2 => _mm_insert_epi32(self.x, v as i32, 2),
+                3 => _mm_insert_epi32(self.x, v as i32, 3),
+                _ => unreachable!(),
+            }
+        })
+    }
+}
+impl<S3, NI> Vec4<u32> for u32x4_sse2<S3, NoS4, NI>
+where
+    Self: MultiLane<[u32; 4]>,
+{
+    #[inline(always)]
+    fn extract(self, i: u32) -> u32 {
+        self.to_lanes()[i as usize]
+    }
+    #[inline(always)]
+    fn insert(self, v: u32, i: u32) -> Self {
+        Self::new(unsafe {
+            match i {
+                0 => {
+                    let x = _mm_andnot_si128(_mm_cvtsi32_si128(-1), self.x);
+                    _mm_or_si128(x, _mm_cvtsi32_si128(v as i32))
+                }
+                1 => {
+                    let mut x = _mm_shuffle_epi32(self.x, 0b0111_1000);
+                    x = _mm_slli_si128(x, 4);
+                    x = _mm_or_si128(x, _mm_cvtsi32_si128(v as i32));
+                    _mm_shuffle_epi32(x, 0b1110_0001)
+                }
+                2 => {
+                    let mut x = _mm_shuffle_epi32(self.x, 0b1011_0100);
+                    x = _mm_slli_si128(x, 4);
+                    x = _mm_or_si128(x, _mm_cvtsi32_si128(v as i32));
+                    _mm_shuffle_epi32(x, 0b1100_1001)
+                }
+                3 => {
+                    let mut x = _mm_slli_si128(self.x, 4);
+                    x = _mm_or_si128(x, _mm_cvtsi32_si128(v as i32));
+                    _mm_shuffle_epi32(x, 0b0011_1001)
+                }
+                _ => unreachable!(),
+            }
+        })
+    }
+}
+
+impl<S3, S4, NI> LaneWords4 for u32x4_sse2<S3, S4, NI> {
+    #[inline(always)]
+    fn shuffle_lane_words2301(self) -> Self {
+        self.shuffle2301()
+    }
+    #[inline(always)]
+    fn shuffle_lane_words1230(self) -> Self {
+        self.shuffle1230()
+    }
+    #[inline(always)]
+    fn shuffle_lane_words3012(self) -> Self {
+        self.shuffle3012()
+    }
+}
+
+impl<S3, S4, NI> Words4 for u32x4_sse2<S3, S4, NI> {
+    #[inline(always)]
+    fn shuffle2301(self) -> Self {
+        Self::new(unsafe { _mm_shuffle_epi32(self.x, 0b0100_1110) })
+    }
+    #[inline(always)]
+    fn shuffle1230(self) -> Self {
+        Self::new(unsafe { _mm_shuffle_epi32(self.x, 0b1001_0011) })
+    }
+    #[inline(always)]
+    fn shuffle3012(self) -> Self {
+        Self::new(unsafe { _mm_shuffle_epi32(self.x, 0b0011_1001) })
+    }
+}
+
+impl<S4, NI> Words4 for u64x4_sse2<YesS3, S4, NI> {
+    #[inline(always)]
+    fn shuffle2301(self) -> Self {
+        x2::new([u64x2_sse2::new(self.0[1].x), u64x2_sse2::new(self.0[0].x)])
+    }
+    #[inline(always)]
+    fn shuffle3012(self) -> Self {
+        unsafe {
+            x2::new([
+                u64x2_sse2::new(_mm_alignr_epi8(self.0[1].x, self.0[0].x, 8)),
+                u64x2_sse2::new(_mm_alignr_epi8(self.0[0].x, self.0[1].x, 8)),
+            ])
+        }
+    }
+    #[inline(always)]
+    fn shuffle1230(self) -> Self {
+        unsafe {
+            x2::new([
+                u64x2_sse2::new(_mm_alignr_epi8(self.0[0].x, self.0[1].x, 8)),
+                u64x2_sse2::new(_mm_alignr_epi8(self.0[1].x, self.0[0].x, 8)),
+            ])
+        }
+    }
+}
+impl<S4, NI> Words4 for u64x4_sse2<NoS3, S4, NI> {
+    #[inline(always)]
+    fn shuffle2301(self) -> Self {
+        x2::new([u64x2_sse2::new(self.0[1].x), u64x2_sse2::new(self.0[0].x)])
+    }
+    #[inline(always)]
+    fn shuffle3012(self) -> Self {
+        unsafe {
+            let a = _mm_srli_si128(self.0[0].x, 8);
+            let b = _mm_slli_si128(self.0[0].x, 8);
+            let c = _mm_srli_si128(self.0[1].x, 8);
+            let d = _mm_slli_si128(self.0[1].x, 8);
+            let da = _mm_or_si128(d, a);
+            let bc = _mm_or_si128(b, c);
+            x2::new([u64x2_sse2::new(da), u64x2_sse2::new(bc)])
+        }
+    }
+    #[inline(always)]
+    fn shuffle1230(self) -> Self {
+        unsafe {
+            let a = _mm_srli_si128(self.0[0].x, 8);
+            let b = _mm_slli_si128(self.0[0].x, 8);
+            let c = _mm_srli_si128(self.0[1].x, 8);
+            let d = _mm_slli_si128(self.0[1].x, 8);
+            let da = _mm_or_si128(d, a);
+            let bc = _mm_or_si128(b, c);
+            x2::new([u64x2_sse2::new(bc), u64x2_sse2::new(da)])
+        }
+    }
+}
+
+impl<S3, S4, NI> UnsafeFrom<[u64; 2]> for u64x2_sse2<S3, S4, NI> {
+    #[inline(always)]
+    unsafe fn unsafe_from(xs: [u64; 2]) -> Self {
+        Self::new(_mm_set_epi64x(xs[1] as i64, xs[0] as i64))
+    }
+}
+
+impl<S3, NI> Vec2<u64> for u64x2_sse2<S3, YesS4, NI> {
+    #[inline(always)]
+    fn extract(self, i: u32) -> u64 {
+        unsafe {
+            match i {
+                0 => _mm_cvtsi128_si64(self.x) as u64,
+                1 => _mm_extract_epi64(self.x, 1) as u64,
+                _ => unreachable!(),
+            }
+        }
+    }
+    #[inline(always)]
+    fn insert(self, x: u64, i: u32) -> Self {
+        Self::new(unsafe {
+            match i {
+                0 => _mm_insert_epi64(self.x, x as i64, 0),
+                1 => _mm_insert_epi64(self.x, x as i64, 1),
+                _ => unreachable!(),
+            }
+        })
+    }
+}
+impl<S3, NI> Vec2<u64> for u64x2_sse2<S3, NoS4, NI> {
+    #[inline(always)]
+    fn extract(self, i: u32) -> u64 {
+        unsafe {
+            match i {
+                0 => _mm_cvtsi128_si64(self.x) as u64,
+                1 => _mm_cvtsi128_si64(_mm_shuffle_epi32(self.x, 0b11101110)) as u64,
+                _ => unreachable!(),
+            }
+        }
+    }
+    #[inline(always)]
+    fn insert(self, x: u64, i: u32) -> Self {
+        Self::new(unsafe {
+            match i {
+                0 => _mm_or_si128(
+                    _mm_andnot_si128(_mm_cvtsi64_si128(-1), self.x),
+                    _mm_cvtsi64_si128(x as i64),
+                ),
+                1 => _mm_or_si128(
+                    _mm_move_epi64(self.x),
+                    _mm_slli_si128(_mm_cvtsi64_si128(x as i64), 8),
+                ),
+                _ => unreachable!(),
+            }
+        })
+    }
+}
+
+impl<S4, NI> BSwap for u32x4_sse2<YesS3, S4, NI> {
+    #[inline(always)]
+    fn bswap(self) -> Self {
+        Self::new(unsafe {
+            let k = _mm_set_epi64x(0x0c0d_0e0f_0809_0a0b, 0x0405_0607_0001_0203);
+            _mm_shuffle_epi8(self.x, k)
+        })
+    }
+}
+#[inline(always)]
+fn bswap32_s2(x: __m128i) -> __m128i {
+    unsafe {
+        let mut y = _mm_unpacklo_epi8(x, _mm_setzero_si128());
+        y = _mm_shufflehi_epi16(y, 0b0001_1011);
+        y = _mm_shufflelo_epi16(y, 0b0001_1011);
+        let mut z = _mm_unpackhi_epi8(x, _mm_setzero_si128());
+        z = _mm_shufflehi_epi16(z, 0b0001_1011);
+        z = _mm_shufflelo_epi16(z, 0b0001_1011);
+        _mm_packus_epi16(y, z)
+    }
+}
+impl<S4, NI> BSwap for u32x4_sse2<NoS3, S4, NI> {
+    #[inline(always)]
+    fn bswap(self) -> Self {
+        Self::new(bswap32_s2(self.x))
+    }
+}
+
+impl<S4, NI> BSwap for u64x2_sse2<YesS3, S4, NI> {
+    #[inline(always)]
+    fn bswap(self) -> Self {
+        Self::new(unsafe {
+            let k = _mm_set_epi64x(0x0809_0a0b_0c0d_0e0f, 0x0001_0203_0405_0607);
+            _mm_shuffle_epi8(self.x, k)
+        })
+    }
+}
+impl<S4, NI> BSwap for u64x2_sse2<NoS3, S4, NI> {
+    #[inline(always)]
+    fn bswap(self) -> Self {
+        Self::new(unsafe { bswap32_s2(_mm_shuffle_epi32(self.x, 0b1011_0001)) })
+    }
+}
+
+impl<S4, NI> BSwap for u128x1_sse2<YesS3, S4, NI> {
+    #[inline(always)]
+    fn bswap(self) -> Self {
+        Self::new(unsafe {
+            let k = _mm_set_epi64x(0x0f0e_0d0c_0b0a_0908, 0x0706_0504_0302_0100);
+            _mm_shuffle_epi8(self.x, k)
+        })
+    }
+}
+impl<S4, NI> BSwap for u128x1_sse2<NoS3, S4, NI> {
+    #[inline(always)]
+    fn bswap(self) -> Self {
+        unimplemented!()
+    }
+}
+
+macro_rules! swapi {
+    ($x:expr, $i:expr, $k:expr) => {
+        unsafe {
+            const K: u8 = $k;
+            let k = _mm_set1_epi8(K as i8);
+            u128x1_sse2::new(_mm_or_si128(
+                _mm_srli_epi16(_mm_and_si128($x.x, k), $i),
+                _mm_and_si128(_mm_slli_epi16($x.x, $i), k),
+            ))
+        }
+    };
+}
+#[inline(always)]
+fn swap16_s2(x: __m128i) -> __m128i {
+    unsafe { _mm_shufflehi_epi16(_mm_shufflelo_epi16(x, 0b1011_0001), 0b1011_0001) }
+}
+impl<S4, NI> Swap64 for u128x1_sse2<YesS3, S4, NI> {
+    #[inline(always)]
+    fn swap1(self) -> Self {
+        swapi!(self, 1, 0xaa)
+    }
+    #[inline(always)]
+    fn swap2(self) -> Self {
+        swapi!(self, 2, 0xcc)
+    }
+    #[inline(always)]
+    fn swap4(self) -> Self {
+        swapi!(self, 4, 0xf0)
+    }
+    #[inline(always)]
+    fn swap8(self) -> Self {
+        u128x1_sse2::new(unsafe {
+            let k = _mm_set_epi64x(0x0e0f_0c0d_0a0b_0809, 0x0607_0405_0203_0001);
+            _mm_shuffle_epi8(self.x, k)
+        })
+    }
+    #[inline(always)]
+    fn swap16(self) -> Self {
+        u128x1_sse2::new(unsafe {
+            let k = _mm_set_epi64x(0x0d0c_0f0e_0908_0b0a, 0x0504_0706_0100_0302);
+            _mm_shuffle_epi8(self.x, k)
+        })
+    }
+    #[inline(always)]
+    fn swap32(self) -> Self {
+        u128x1_sse2::new(unsafe { _mm_shuffle_epi32(self.x, 0b1011_0001) })
+    }
+    #[inline(always)]
+    fn swap64(self) -> Self {
+        u128x1_sse2::new(unsafe { _mm_shuffle_epi32(self.x, 0b0100_1110) })
+    }
+}
+impl<S4, NI> Swap64 for u128x1_sse2<NoS3, S4, NI> {
+    #[inline(always)]
+    fn swap1(self) -> Self {
+        swapi!(self, 1, 0xaa)
+    }
+    #[inline(always)]
+    fn swap2(self) -> Self {
+        swapi!(self, 2, 0xcc)
+    }
+    #[inline(always)]
+    fn swap4(self) -> Self {
+        swapi!(self, 4, 0xf0)
+    }
+    #[inline(always)]
+    fn swap8(self) -> Self {
+        u128x1_sse2::new(unsafe {
+            _mm_or_si128(_mm_slli_epi16(self.x, 8), _mm_srli_epi16(self.x, 8))
+        })
+    }
+    #[inline(always)]
+    fn swap16(self) -> Self {
+        u128x1_sse2::new(swap16_s2(self.x))
+    }
+    #[inline(always)]
+    fn swap32(self) -> Self {
+        u128x1_sse2::new(unsafe { _mm_shuffle_epi32(self.x, 0b1011_0001) })
+    }
+    #[inline(always)]
+    fn swap64(self) -> Self {
+        u128x1_sse2::new(unsafe { _mm_shuffle_epi32(self.x, 0b0100_1110) })
+    }
+}
+
+#[derive(Copy, Clone)]
+pub struct G0;
+#[derive(Copy, Clone)]
+pub struct G1;
+
+#[allow(non_camel_case_types)]
+pub type u32x4x2_sse2<S3, S4, NI> = x2<u32x4_sse2<S3, S4, NI>, G0>;
+#[allow(non_camel_case_types)]
+pub type u64x2x2_sse2<S3, S4, NI> = x2<u64x2_sse2<S3, S4, NI>, G0>;
+#[allow(non_camel_case_types)]
+pub type u64x4_sse2<S3, S4, NI> = x2<u64x2_sse2<S3, S4, NI>, G1>;
+#[allow(non_camel_case_types)]
+pub type u128x2_sse2<S3, S4, NI> = x2<u128x1_sse2<S3, S4, NI>, G0>;
+
+#[allow(non_camel_case_types)]
+pub type u32x4x4_sse2<S3, S4, NI> = x4<u32x4_sse2<S3, S4, NI>>;
+#[allow(non_camel_case_types)]
+pub type u64x2x4_sse2<S3, S4, NI> = x4<u64x2_sse2<S3, S4, NI>>;
+#[allow(non_camel_case_types)]
+pub type u128x4_sse2<S3, S4, NI> = x4<u128x1_sse2<S3, S4, NI>>;
+
+impl<S3, S4, NI> Vector<[u32; 16]> for u32x4x4_sse2<S3, S4, NI> {
+    #[inline(always)]
+    fn to_scalars(self) -> [u32; 16] {
+        unsafe { core::mem::transmute(self) }
+    }
+}
+
+impl<S3: Copy, S4: Copy, NI: Copy> u32x4x2<Machine86<S3, S4, NI>> for u32x4x2_sse2<S3, S4, NI>
+where
+    u32x4_sse2<S3, S4, NI>: RotateEachWord32 + BSwap,
+    Machine86<S3, S4, NI>: Machine,
+    u32x4x2_sse2<S3, S4, NI>: MultiLane<[<Machine86<S3, S4, NI> as Machine>::u32x4; 2]>,
+    u32x4x2_sse2<S3, S4, NI>: Vec2<<Machine86<S3, S4, NI> as Machine>::u32x4>,
+{
+}
+impl<S3: Copy, S4: Copy, NI: Copy> u64x2x2<Machine86<S3, S4, NI>> for u64x2x2_sse2<S3, S4, NI>
+where
+    u64x2_sse2<S3, S4, NI>: RotateEachWord64 + RotateEachWord32 + BSwap,
+    Machine86<S3, S4, NI>: Machine,
+    u64x2x2_sse2<S3, S4, NI>: MultiLane<[<Machine86<S3, S4, NI> as Machine>::u64x2; 2]>,
+    u64x2x2_sse2<S3, S4, NI>: Vec2<<Machine86<S3, S4, NI> as Machine>::u64x2>,
+{
+}
+impl<S3: Copy, S4: Copy, NI: Copy> u64x4<Machine86<S3, S4, NI>> for u64x4_sse2<S3, S4, NI>
+where
+    u64x2_sse2<S3, S4, NI>: RotateEachWord64 + RotateEachWord32 + BSwap,
+    Machine86<S3, S4, NI>: Machine,
+    u64x4_sse2<S3, S4, NI>: MultiLane<[u64; 4]> + Vec4<u64> + Words4,
+{
+}
+impl<S3: Copy, S4: Copy, NI: Copy> u128x2<Machine86<S3, S4, NI>> for u128x2_sse2<S3, S4, NI>
+where
+    u128x1_sse2<S3, S4, NI>: Swap64 + BSwap,
+    Machine86<S3, S4, NI>: Machine,
+    u128x2_sse2<S3, S4, NI>: MultiLane<[<Machine86<S3, S4, NI> as Machine>::u128x1; 2]>,
+    u128x2_sse2<S3, S4, NI>: Vec2<<Machine86<S3, S4, NI> as Machine>::u128x1>,
+    u128x2_sse2<S3, S4, NI>: Into<<Machine86<S3, S4, NI> as Machine>::u32x4x2>,
+    u128x2_sse2<S3, S4, NI>: Into<<Machine86<S3, S4, NI> as Machine>::u64x2x2>,
+    u128x2_sse2<S3, S4, NI>: Into<<Machine86<S3, S4, NI> as Machine>::u64x4>,
+{
+}
+
+impl<NI: Copy> u32x4x2<Avx2Machine<NI>> for u32x4x2_sse2<YesS3, YesS4, NI>
+where
+    u32x4_sse2<YesS3, YesS4, NI>: RotateEachWord32 + BSwap,
+    Avx2Machine<NI>: Machine,
+    u32x4x2_sse2<YesS3, YesS4, NI>: MultiLane<[<Avx2Machine<NI> as Machine>::u32x4; 2]>,
+    u32x4x2_sse2<YesS3, YesS4, NI>: Vec2<<Avx2Machine<NI> as Machine>::u32x4>,
+{
+}
+impl<NI: Copy> u64x2x2<Avx2Machine<NI>> for u64x2x2_sse2<YesS3, YesS4, NI>
+where
+    u64x2_sse2<YesS3, YesS4, NI>: RotateEachWord64 + RotateEachWord32 + BSwap,
+    Avx2Machine<NI>: Machine,
+    u64x2x2_sse2<YesS3, YesS4, NI>: MultiLane<[<Avx2Machine<NI> as Machine>::u64x2; 2]>,
+    u64x2x2_sse2<YesS3, YesS4, NI>: Vec2<<Avx2Machine<NI> as Machine>::u64x2>,
+{
+}
+impl<NI: Copy> u64x4<Avx2Machine<NI>> for u64x4_sse2<YesS3, YesS4, NI>
+where
+    u64x2_sse2<YesS3, YesS4, NI>: RotateEachWord64 + RotateEachWord32 + BSwap,
+    Avx2Machine<NI>: Machine,
+    u64x4_sse2<YesS3, YesS4, NI>: MultiLane<[u64; 4]> + Vec4<u64> + Words4,
+{
+}
+impl<NI: Copy> u128x2<Avx2Machine<NI>> for u128x2_sse2<YesS3, YesS4, NI>
+where
+    u128x1_sse2<YesS3, YesS4, NI>: Swap64 + BSwap,
+    Avx2Machine<NI>: Machine,
+    u128x2_sse2<YesS3, YesS4, NI>: MultiLane<[<Avx2Machine<NI> as Machine>::u128x1; 2]>,
+    u128x2_sse2<YesS3, YesS4, NI>: Vec2<<Avx2Machine<NI> as Machine>::u128x1>,
+    u128x2_sse2<YesS3, YesS4, NI>: Into<<Avx2Machine<NI> as Machine>::u32x4x2>,
+    u128x2_sse2<YesS3, YesS4, NI>: Into<<Avx2Machine<NI> as Machine>::u64x2x2>,
+    u128x2_sse2<YesS3, YesS4, NI>: Into<<Avx2Machine<NI> as Machine>::u64x4>,
+{
+}
+
+impl<S3, S4, NI> Vec4<u64> for u64x4_sse2<S3, S4, NI>
+where
+    u64x2_sse2<S3, S4, NI>: Copy + Vec2<u64>,
+{
+    #[inline(always)]
+    fn extract(self, i: u32) -> u64 {
+        match i {
+            0 => self.0[0].extract(0),
+            1 => self.0[0].extract(1),
+            2 => self.0[1].extract(0),
+            3 => self.0[1].extract(1),
+            _ => panic!(),
+        }
+    }
+    #[inline(always)]
+    fn insert(mut self, w: u64, i: u32) -> Self {
+        match i {
+            0 => self.0[0] = self.0[0].insert(w, 0),
+            1 => self.0[0] = self.0[0].insert(w, 1),
+            2 => self.0[1] = self.0[1].insert(w, 0),
+            3 => self.0[1] = self.0[1].insert(w, 1),
+            _ => panic!(),
+        };
+        self
+    }
+}
+
+impl<S3: Copy, S4: Copy, NI: Copy> u32x4x4<Machine86<S3, S4, NI>> for u32x4x4_sse2<S3, S4, NI>
+where
+    u32x4_sse2<S3, S4, NI>: RotateEachWord32 + BSwap,
+    Machine86<S3, S4, NI>: Machine,
+    u32x4x4_sse2<S3, S4, NI>: MultiLane<[<Machine86<S3, S4, NI> as Machine>::u32x4; 4]>,
+    u32x4x4_sse2<S3, S4, NI>: Vec4<<Machine86<S3, S4, NI> as Machine>::u32x4>,
+    u32x4x4_sse2<S3, S4, NI>: Vec4Ext<<Machine86<S3, S4, NI> as Machine>::u32x4>,
+    u32x4x4_sse2<S3, S4, NI>: Vector<[u32; 16]>,
+{
+}
+impl<S3: Copy, S4: Copy, NI: Copy> u64x2x4<Machine86<S3, S4, NI>> for u64x2x4_sse2<S3, S4, NI>
+where
+    u64x2_sse2<S3, S4, NI>: RotateEachWord64 + RotateEachWord32 + BSwap,
+    Machine86<S3, S4, NI>: Machine,
+    u64x2x4_sse2<S3, S4, NI>: MultiLane<[<Machine86<S3, S4, NI> as Machine>::u64x2; 4]>,
+    u64x2x4_sse2<S3, S4, NI>: Vec4<<Machine86<S3, S4, NI> as Machine>::u64x2>,
+{
+}
+impl<S3: Copy, S4: Copy, NI: Copy> u128x4<Machine86<S3, S4, NI>> for u128x4_sse2<S3, S4, NI>
+where
+    u128x1_sse2<S3, S4, NI>: Swap64 + BSwap,
+    Machine86<S3, S4, NI>: Machine,
+    u128x4_sse2<S3, S4, NI>: MultiLane<[<Machine86<S3, S4, NI> as Machine>::u128x1; 4]>,
+    u128x4_sse2<S3, S4, NI>: Vec4<<Machine86<S3, S4, NI> as Machine>::u128x1>,
+    u128x4_sse2<S3, S4, NI>: Into<<Machine86<S3, S4, NI> as Machine>::u32x4x4>,
+    u128x4_sse2<S3, S4, NI>: Into<<Machine86<S3, S4, NI> as Machine>::u64x2x4>,
+{
+}
+
+impl<NI: Copy> u64x2x4<Avx2Machine<NI>> for u64x2x4_sse2<YesS3, YesS4, NI>
+where
+    u64x2_sse2<YesS3, YesS4, NI>: RotateEachWord64 + RotateEachWord32 + BSwap,
+    Avx2Machine<NI>: Machine,
+    u64x2x4_sse2<YesS3, YesS4, NI>: MultiLane<[<Avx2Machine<NI> as Machine>::u64x2; 4]>,
+    u64x2x4_sse2<YesS3, YesS4, NI>: Vec4<<Avx2Machine<NI> as Machine>::u64x2>,
+{
+}
+impl<NI: Copy> u128x4<Avx2Machine<NI>> for u128x4_sse2<YesS3, YesS4, NI>
+where
+    u128x1_sse2<YesS3, YesS4, NI>: Swap64 + BSwap,
+    Avx2Machine<NI>: Machine,
+    u128x4_sse2<YesS3, YesS4, NI>: MultiLane<[<Avx2Machine<NI> as Machine>::u128x1; 4]>,
+    u128x4_sse2<YesS3, YesS4, NI>: Vec4<<Avx2Machine<NI> as Machine>::u128x1>,
+    u128x4_sse2<YesS3, YesS4, NI>: Into<<Avx2Machine<NI> as Machine>::u32x4x4>,
+    u128x4_sse2<YesS3, YesS4, NI>: Into<<Avx2Machine<NI> as Machine>::u64x2x4>,
+{
+}
+
+macro_rules! impl_into_x {
+    ($from:ident, $to:ident) => {
+        impl<S3: Copy, S4: Copy, NI: Copy, Gf, Gt> From<x2<$from<S3, S4, NI>, Gf>>
+            for x2<$to<S3, S4, NI>, Gt>
+        {
+            #[inline(always)]
+            fn from(x: x2<$from<S3, S4, NI>, Gf>) -> Self {
+                x2::new([$to::from(x.0[0]), $to::from(x.0[1])])
+            }
+        }
+        impl<S3: Copy, S4: Copy, NI: Copy> From<x4<$from<S3, S4, NI>>> for x4<$to<S3, S4, NI>> {
+            #[inline(always)]
+            fn from(x: x4<$from<S3, S4, NI>>) -> Self {
+                x4::new([
+                    $to::from(x.0[0]),
+                    $to::from(x.0[1]),
+                    $to::from(x.0[2]),
+                    $to::from(x.0[3]),
+                ])
+            }
+        }
+    };
+}
+impl_into_x!(u128x1_sse2, u64x2_sse2);
+impl_into_x!(u128x1_sse2, u32x4_sse2);
+
+///// Debugging
+
+use core::fmt::{Debug, Formatter, Result};
+
+impl<W: PartialEq, G> PartialEq for x2<W, G> {
+    #[inline(always)]
+    fn eq(&self, rhs: &Self) -> bool {
+        self.0[0] == rhs.0[0] && self.0[1] == rhs.0[1]
+    }
+}
+
+#[allow(unused)]
+#[inline(always)]
+unsafe fn eq128_s4(x: __m128i, y: __m128i) -> bool {
+    let q = _mm_shuffle_epi32(_mm_cmpeq_epi64(x, y), 0b1100_0110);
+    _mm_cvtsi128_si64(q) == -1
+}
+
+#[inline(always)]
+unsafe fn eq128_s2(x: __m128i, y: __m128i) -> bool {
+    let q = _mm_cmpeq_epi32(x, y);
+    let p = _mm_cvtsi128_si64(_mm_srli_si128(q, 8));
+    let q = _mm_cvtsi128_si64(q);
+    (p & q) == -1
+}
+
+impl<S3, S4, NI> PartialEq for u32x4_sse2<S3, S4, NI> {
+    #[inline(always)]
+    fn eq(&self, rhs: &Self) -> bool {
+        unsafe { eq128_s2(self.x, rhs.x) }
+    }
+}
+impl<S3, S4, NI> Debug for u32x4_sse2<S3, S4, NI>
+where
+    Self: Copy + MultiLane<[u32; 4]>,
+{
+    #[cold]
+    fn fmt(&self, fmt: &mut Formatter) -> Result {
+        fmt.write_fmt(format_args!("{:08x?}", &self.to_lanes()))
+    }
+}
+
+impl<S3, S4, NI> PartialEq for u64x2_sse2<S3, S4, NI> {
+    #[inline(always)]
+    fn eq(&self, rhs: &Self) -> bool {
+        unsafe { eq128_s2(self.x, rhs.x) }
+    }
+}
+impl<S3, S4, NI> Debug for u64x2_sse2<S3, S4, NI>
+where
+    Self: Copy + MultiLane<[u64; 2]>,
+{
+    #[cold]
+    fn fmt(&self, fmt: &mut Formatter) -> Result {
+        fmt.write_fmt(format_args!("{:016x?}", &self.to_lanes()))
+    }
+}
+
+impl<S3, S4, NI> Debug for u64x4_sse2<S3, S4, NI>
+where
+    u64x2_sse2<S3, S4, NI>: Copy + MultiLane<[u64; 2]>,
+{
+    #[cold]
+    fn fmt(&self, fmt: &mut Formatter) -> Result {
+        let (a, b) = (self.0[0].to_lanes(), self.0[1].to_lanes());
+        fmt.write_fmt(format_args!("{:016x?}", &[a[0], a[1], b[0], b[1]]))
+    }
+}
+
+#[cfg(test)]
+#[cfg(target_arch = "x86_64")]
+mod test {
+    use super::*;
+    use crate::x86_64::{SSE2, SSE41, SSSE3};
+    use crate::Machine;
+
+    #[test]
+    #[cfg_attr(not(target_feature = "ssse3"), ignore)]
+    fn test_bswap32_s2_vs_s3() {
+        let xs = [0x0f0e_0d0c, 0x0b0a_0908, 0x0706_0504, 0x0302_0100];
+        let ys = [0x0c0d_0e0f, 0x0809_0a0b, 0x0405_0607, 0x0001_0203];
+
+        let s2 = unsafe { SSE2::instance() };
+        let s3 = unsafe { SSSE3::instance() };
+
+        let x_s2 = {
+            let x_s2: <SSE2 as Machine>::u32x4 = s2.vec(xs);
+            x_s2.bswap()
+        };
+
+        let x_s3 = {
+            let x_s3: <SSSE3 as Machine>::u32x4 = s3.vec(xs);
+            x_s3.bswap()
+        };
+
+        assert_eq!(x_s2, unsafe { core::mem::transmute(x_s3) });
+        assert_eq!(x_s2, s2.vec(ys));
+    }
+
+    #[test]
+    #[cfg_attr(not(target_feature = "ssse3"), ignore)]
+    fn test_bswap64_s2_vs_s3() {
+        let xs = [0x0f0e_0d0c_0b0a_0908, 0x0706_0504_0302_0100];
+        let ys = [0x0809_0a0b_0c0d_0e0f, 0x0001_0203_0405_0607];
+
+        let s2 = unsafe { SSE2::instance() };
+        let s3 = unsafe { SSSE3::instance() };
+
+        let x_s2 = {
+            let x_s2: <SSE2 as Machine>::u64x2 = s2.vec(xs);
+            x_s2.bswap()
+        };
+
+        let x_s3 = {
+            let x_s3: <SSSE3 as Machine>::u64x2 = s3.vec(xs);
+            x_s3.bswap()
+        };
+
+        assert_eq!(x_s2, s2.vec(ys));
+        assert_eq!(x_s3, unsafe { core::mem::transmute(x_s3) });
+    }
+
+    #[test]
+    #[cfg_attr(not(target_feature = "ssse3"), ignore)]
+    fn test_shuffle32_s2_vs_s3() {
+        let xs = [0x0, 0x1, 0x2, 0x3];
+        let ys = [0x2, 0x3, 0x0, 0x1];
+        let zs = [0x1, 0x2, 0x3, 0x0];
+
+        let s2 = unsafe { SSE2::instance() };
+        let s3 = unsafe { SSSE3::instance() };
+
+        let x_s2 = {
+            let x_s2: <SSE2 as Machine>::u32x4 = s2.vec(xs);
+            x_s2.shuffle2301()
+        };
+        let x_s3 = {
+            let x_s3: <SSSE3 as Machine>::u32x4 = s3.vec(xs);
+            x_s3.shuffle2301()
+        };
+        assert_eq!(x_s2, s2.vec(ys));
+        assert_eq!(x_s3, unsafe { core::mem::transmute(x_s3) });
+
+        let x_s2 = {
+            let x_s2: <SSE2 as Machine>::u32x4 = s2.vec(xs);
+            x_s2.shuffle3012()
+        };
+        let x_s3 = {
+            let x_s3: <SSSE3 as Machine>::u32x4 = s3.vec(xs);
+            x_s3.shuffle3012()
+        };
+        assert_eq!(x_s2, s2.vec(zs));
+        assert_eq!(x_s3, unsafe { core::mem::transmute(x_s3) });
+
+        let x_s2 = x_s2.shuffle1230();
+        let x_s3 = x_s3.shuffle1230();
+        assert_eq!(x_s2, s2.vec(xs));
+        assert_eq!(x_s3, unsafe { core::mem::transmute(x_s3) });
+    }
+
+    #[test]
+    #[cfg_attr(not(target_feature = "ssse3"), ignore)]
+    fn test_shuffle64_s2_vs_s3() {
+        let xs = [0x0, 0x1, 0x2, 0x3];
+        let ys = [0x2, 0x3, 0x0, 0x1];
+        let zs = [0x1, 0x2, 0x3, 0x0];
+
+        let s2 = unsafe { SSE2::instance() };
+        let s3 = unsafe { SSSE3::instance() };
+
+        let x_s2 = {
+            let x_s2: <SSE2 as Machine>::u64x4 = s2.vec(xs);
+            x_s2.shuffle2301()
+        };
+        let x_s3 = {
+            let x_s3: <SSSE3 as Machine>::u64x4 = s3.vec(xs);
+            x_s3.shuffle2301()
+        };
+        assert_eq!(x_s2, s2.vec(ys));
+        assert_eq!(x_s3, unsafe { core::mem::transmute(x_s3) });
+
+        let x_s2 = {
+            let x_s2: <SSE2 as Machine>::u64x4 = s2.vec(xs);
+            x_s2.shuffle3012()
+        };
+        let x_s3 = {
+            let x_s3: <SSSE3 as Machine>::u64x4 = s3.vec(xs);
+            x_s3.shuffle3012()
+        };
+        assert_eq!(x_s2, s2.vec(zs));
+        assert_eq!(x_s3, unsafe { core::mem::transmute(x_s3) });
+
+        let x_s2 = x_s2.shuffle1230();
+        let x_s3 = x_s3.shuffle1230();
+        assert_eq!(x_s2, s2.vec(xs));
+        assert_eq!(x_s3, unsafe { core::mem::transmute(x_s3) });
+    }
+
+    #[cfg_attr(not(all(target_feature = "ssse3", target_feature = "sse4.1")), ignore)]
+    #[test]
+    fn test_lanes_u32x4() {
+        let xs = [0x1, 0x2, 0x3, 0x4];
+
+        let s2 = unsafe { SSE2::instance() };
+        let s3 = unsafe { SSSE3::instance() };
+        let s4 = unsafe { SSE41::instance() };
+
+        {
+            let x_s2: <SSE2 as Machine>::u32x4 = s2.vec(xs);
+            let y_s2 = <SSE2 as Machine>::u32x4::from_lanes(xs);
+            assert_eq!(x_s2, y_s2);
+            assert_eq!(xs, y_s2.to_lanes());
+        }
+
+        {
+            let x_s3: <SSSE3 as Machine>::u32x4 = s3.vec(xs);
+            let y_s3 = <SSSE3 as Machine>::u32x4::from_lanes(xs);
+            assert_eq!(x_s3, y_s3);
+            assert_eq!(xs, y_s3.to_lanes());
+        }
+
+        {
+            let x_s4: <SSE41 as Machine>::u32x4 = s4.vec(xs);
+            let y_s4 = <SSE41 as Machine>::u32x4::from_lanes(xs);
+            assert_eq!(x_s4, y_s4);
+            assert_eq!(xs, y_s4.to_lanes());
+        }
+    }
+
+    #[test]
+    #[cfg_attr(not(all(target_feature = "ssse3", target_feature = "sse4.1")), ignore)]
+    fn test_lanes_u64x2() {
+        let xs = [0x1, 0x2];
+
+        let s2 = unsafe { SSE2::instance() };
+        let s3 = unsafe { SSSE3::instance() };
+        let s4 = unsafe { SSE41::instance() };
+
+        {
+            let x_s2: <SSE2 as Machine>::u64x2 = s2.vec(xs);
+            let y_s2 = <SSE2 as Machine>::u64x2::from_lanes(xs);
+            assert_eq!(x_s2, y_s2);
+            assert_eq!(xs, y_s2.to_lanes());
+        }
+
+        {
+            let x_s3: <SSSE3 as Machine>::u64x2 = s3.vec(xs);
+            let y_s3 = <SSSE3 as Machine>::u64x2::from_lanes(xs);
+            assert_eq!(x_s3, y_s3);
+            assert_eq!(xs, y_s3.to_lanes());
+        }
+
+        {
+            let x_s4: <SSE41 as Machine>::u64x2 = s4.vec(xs);
+            let y_s4 = <SSE41 as Machine>::u64x2::from_lanes(xs);
+            assert_eq!(x_s4, y_s4);
+            assert_eq!(xs, y_s4.to_lanes());
+        }
+    }
+
+    #[test]
+    fn test_vec4_u32x4_s2() {
+        let xs = [1, 2, 3, 4];
+        let s2 = unsafe { SSE2::instance() };
+        let x_s2: <SSE2 as Machine>::u32x4 = s2.vec(xs);
+        assert_eq!(x_s2.extract(0), 1);
+        assert_eq!(x_s2.extract(1), 2);
+        assert_eq!(x_s2.extract(2), 3);
+        assert_eq!(x_s2.extract(3), 4);
+        assert_eq!(x_s2.insert(0xf, 0), s2.vec([0xf, 2, 3, 4]));
+        assert_eq!(x_s2.insert(0xf, 1), s2.vec([1, 0xf, 3, 4]));
+        assert_eq!(x_s2.insert(0xf, 2), s2.vec([1, 2, 0xf, 4]));
+        assert_eq!(x_s2.insert(0xf, 3), s2.vec([1, 2, 3, 0xf]));
+    }
+
+    #[test]
+    #[cfg_attr(not(all(target_feature = "ssse3", target_feature = "sse4.1")), ignore)]
+    fn test_vec4_u32x4_s4() {
+        let xs = [1, 2, 3, 4];
+        let s4 = unsafe { SSE41::instance() };
+        let x_s4: <SSE41 as Machine>::u32x4 = s4.vec(xs);
+        assert_eq!(x_s4.extract(0), 1);
+        assert_eq!(x_s4.extract(1), 2);
+        assert_eq!(x_s4.extract(2), 3);
+        assert_eq!(x_s4.extract(3), 4);
+        assert_eq!(x_s4.insert(0xf, 0), s4.vec([0xf, 2, 3, 4]));
+        assert_eq!(x_s4.insert(0xf, 1), s4.vec([1, 0xf, 3, 4]));
+        assert_eq!(x_s4.insert(0xf, 2), s4.vec([1, 2, 0xf, 4]));
+        assert_eq!(x_s4.insert(0xf, 3), s4.vec([1, 2, 3, 0xf]));
+    }
+
+    #[test]
+    fn test_vec2_u64x2_s2() {
+        let xs = [0x1, 0x2];
+        let s2 = unsafe { SSE2::instance() };
+        let x_s2: <SSE2 as Machine>::u64x2 = s2.vec(xs);
+        assert_eq!(x_s2.extract(0), 1);
+        assert_eq!(x_s2.extract(1), 2);
+        assert_eq!(x_s2.insert(0xf, 0), s2.vec([0xf, 2]));
+        assert_eq!(x_s2.insert(0xf, 1), s2.vec([1, 0xf]));
+    }
+
+    #[test]
+    #[cfg_attr(not(all(target_feature = "ssse3", target_feature = "sse4.1")), ignore)]
+    fn test_vec4_u64x2_s4() {
+        let xs = [0x1, 0x2];
+        let s4 = unsafe { SSE41::instance() };
+        let x_s4: <SSE41 as Machine>::u64x2 = s4.vec(xs);
+        assert_eq!(x_s4.extract(0), 1);
+        assert_eq!(x_s4.extract(1), 2);
+        assert_eq!(x_s4.insert(0xf, 0), s4.vec([0xf, 2]));
+        assert_eq!(x_s4.insert(0xf, 1), s4.vec([1, 0xf]));
+    }
+}
+
+pub mod avx2 {
+    #![allow(non_camel_case_types)]
+    use crate::soft::{x2, x4};
+    use crate::types::*;
+    use crate::x86_64::sse2::{u128x1_sse2, u32x4_sse2, G0};
+    use crate::x86_64::{vec256_storage, vec512_storage, Avx2Machine, YesS3, YesS4};
+    use core::arch::x86_64::*;
+    use core::marker::PhantomData;
+    use core::ops::*;
+
+    #[derive(Copy, Clone)]
+    pub struct u32x4x2_avx2<NI> {
+        x: __m256i,
+        ni: PhantomData<NI>,
+    }
+
+    impl<NI> u32x4x2_avx2<NI> {
+        #[inline(always)]
+        fn new(x: __m256i) -> Self {
+            Self { x, ni: PhantomData }
+        }
+    }
+
+    impl<NI> u32x4x2<Avx2Machine<NI>> for u32x4x2_avx2<NI> where NI: Copy {}
+    impl<NI> Store<vec256_storage> for u32x4x2_avx2<NI> {
+        #[inline(always)]
+        unsafe fn unpack(p: vec256_storage) -> Self {
+            Self::new(p.avx)
+        }
+    }
+    impl<NI> StoreBytes for u32x4x2_avx2<NI> {
+        #[inline(always)]
+        unsafe fn unsafe_read_le(input: &[u8]) -> Self {
+            assert_eq!(input.len(), 32);
+            Self::new(_mm256_loadu_si256(input.as_ptr() as *const _))
+        }
+        #[inline(always)]
+        unsafe fn unsafe_read_be(input: &[u8]) -> Self {
+            Self::unsafe_read_le(input).bswap()
+        }
+        #[inline(always)]
+        fn write_le(self, out: &mut [u8]) {
+            unsafe {
+                assert_eq!(out.len(), 32);
+                _mm256_storeu_si256(out.as_mut_ptr() as *mut _, self.x)
+            }
+        }
+        #[inline(always)]
+        fn write_be(self, out: &mut [u8]) {
+            self.bswap().write_le(out)
+        }
+    }
+    impl<NI> MultiLane<[u32x4_sse2<YesS3, YesS4, NI>; 2]> for u32x4x2_avx2<NI> {
+        #[inline(always)]
+        fn to_lanes(self) -> [u32x4_sse2<YesS3, YesS4, NI>; 2] {
+            unsafe {
+                [
+                    u32x4_sse2::new(_mm256_extracti128_si256(self.x, 0)),
+                    u32x4_sse2::new(_mm256_extracti128_si256(self.x, 1)),
+                ]
+            }
+        }
+        #[inline(always)]
+        fn from_lanes(x: [u32x4_sse2<YesS3, YesS4, NI>; 2]) -> Self {
+            Self::new(unsafe { _mm256_setr_m128i(x[0].x, x[1].x) })
+        }
+    }
+    impl<NI> Vec2<u32x4_sse2<YesS3, YesS4, NI>> for u32x4x2_avx2<NI> {
+        #[inline(always)]
+        fn extract(self, i: u32) -> u32x4_sse2<YesS3, YesS4, NI> {
+            unsafe {
+                match i {
+                    0 => u32x4_sse2::new(_mm256_extracti128_si256(self.x, 0)),
+                    1 => u32x4_sse2::new(_mm256_extracti128_si256(self.x, 1)),
+                    _ => panic!(),
+                }
+            }
+        }
+        #[inline(always)]
+        fn insert(self, w: u32x4_sse2<YesS3, YesS4, NI>, i: u32) -> Self {
+            Self::new(unsafe {
+                match i {
+                    0 => _mm256_inserti128_si256(self.x, w.x, 0),
+                    1 => _mm256_inserti128_si256(self.x, w.x, 1),
+                    _ => panic!(),
+                }
+            })
+        }
+    }
+    impl<NI> BitOps32 for u32x4x2_avx2<NI> where NI: Copy {}
+    impl<NI> ArithOps for u32x4x2_avx2<NI> where NI: Copy {}
+    macro_rules! shuf_lane_bytes {
+        ($name:ident, $k0:expr, $k1:expr) => {
+            #[inline(always)]
+            fn $name(self) -> Self {
+                Self::new(unsafe {
+                    _mm256_shuffle_epi8(self.x, _mm256_set_epi64x($k0, $k1, $k0, $k1))
+                })
+            }
+        };
+    }
+    macro_rules! rotr_32 {
+        ($name:ident, $i:expr) => {
+            #[inline(always)]
+            fn $name(self) -> Self {
+                Self::new(unsafe {
+                    _mm256_or_si256(
+                        _mm256_srli_epi32(self.x, $i as i32),
+                        _mm256_slli_epi32(self.x, 32 - $i as i32),
+                    )
+                })
+            }
+        };
+    }
+    impl<NI: Copy> RotateEachWord32 for u32x4x2_avx2<NI> {
+        rotr_32!(rotate_each_word_right7, 7);
+        shuf_lane_bytes!(
+            rotate_each_word_right8,
+            0x0c0f_0e0d_080b_0a09,
+            0x0407_0605_0003_0201
+        );
+        rotr_32!(rotate_each_word_right11, 11);
+        rotr_32!(rotate_each_word_right12, 12);
+        shuf_lane_bytes!(
+            rotate_each_word_right16,
+            0x0d0c_0f0e_0908_0b0a,
+            0x0504_0706_0100_0302
+        );
+        rotr_32!(rotate_each_word_right20, 20);
+        shuf_lane_bytes!(
+            rotate_each_word_right24,
+            0x0e0d_0c0f_0a09_080b,
+            0x0605_0407_0201_0003
+        );
+        rotr_32!(rotate_each_word_right25, 25);
+    }
+    impl<NI> BitOps0 for u32x4x2_avx2<NI> where NI: Copy {}
+    impl<NI> From<u32x4x2_avx2<NI>> for vec256_storage {
+        #[inline(always)]
+        fn from(x: u32x4x2_avx2<NI>) -> Self {
+            Self { avx: x.x }
+        }
+    }
+
+    macro_rules! impl_assign {
+        ($vec:ident, $Assign:ident, $assign_fn:ident, $bin_fn:ident) => {
+            impl<NI> $Assign for $vec<NI>
+            where
+                NI: Copy,
+            {
+                #[inline(always)]
+                fn $assign_fn(&mut self, rhs: Self) {
+                    *self = self.$bin_fn(rhs);
+                }
+            }
+        };
+    }
+    impl_assign!(u32x4x2_avx2, BitXorAssign, bitxor_assign, bitxor);
+    impl_assign!(u32x4x2_avx2, BitOrAssign, bitor_assign, bitor);
+    impl_assign!(u32x4x2_avx2, BitAndAssign, bitand_assign, bitand);
+    impl_assign!(u32x4x2_avx2, AddAssign, add_assign, add);
+
+    macro_rules! impl_bitop {
+        ($vec:ident, $Op:ident, $op_fn:ident, $impl_fn:ident) => {
+            impl<NI> $Op for $vec<NI> {
+                type Output = Self;
+                #[inline(always)]
+                fn $op_fn(self, rhs: Self) -> Self::Output {
+                    Self::new(unsafe { $impl_fn(self.x, rhs.x) })
+                }
+            }
+        };
+    }
+    impl_bitop!(u32x4x2_avx2, BitXor, bitxor, _mm256_xor_si256);
+    impl_bitop!(u32x4x2_avx2, BitOr, bitor, _mm256_or_si256);
+    impl_bitop!(u32x4x2_avx2, BitAnd, bitand, _mm256_and_si256);
+    impl_bitop!(u32x4x2_avx2, AndNot, andnot, _mm256_andnot_si256);
+    impl_bitop!(u32x4x2_avx2, Add, add, _mm256_add_epi32);
+
+    impl<NI> Not for u32x4x2_avx2<NI> {
+        type Output = Self;
+        #[inline(always)]
+        fn not(self) -> Self::Output {
+            unsafe {
+                let f = _mm256_set1_epi8(-0x7f);
+                Self::new(f) ^ self
+            }
+        }
+    }
+
+    impl<NI> BSwap for u32x4x2_avx2<NI> {
+        shuf_lane_bytes!(bswap, 0x0c0d_0e0f_0809_0a0b, 0x0405_0607_0001_0203);
+    }
+
+    impl<NI> From<x2<u128x1_sse2<YesS3, YesS4, NI>, G0>> for u32x4x2_avx2<NI>
+    where
+        NI: Copy,
+    {
+        #[inline(always)]
+        fn from(x: x2<u128x1_sse2<YesS3, YesS4, NI>, G0>) -> Self {
+            Self::new(unsafe { _mm256_setr_m128i(x.0[0].x, x.0[1].x) })
+        }
+    }
+
+    impl<NI> LaneWords4 for u32x4x2_avx2<NI> {
+        #[inline(always)]
+        fn shuffle_lane_words1230(self) -> Self {
+            Self::new(unsafe { _mm256_shuffle_epi32(self.x, 0b1001_0011) })
+        }
+        #[inline(always)]
+        fn shuffle_lane_words2301(self) -> Self {
+            Self::new(unsafe { _mm256_shuffle_epi32(self.x, 0b0100_1110) })
+        }
+        #[inline(always)]
+        fn shuffle_lane_words3012(self) -> Self {
+            Self::new(unsafe { _mm256_shuffle_epi32(self.x, 0b0011_1001) })
+        }
+    }
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+
+    pub type u32x4x4_avx2<NI> = x2<u32x4x2_avx2<NI>, G0>;
+    impl<NI: Copy> u32x4x4<Avx2Machine<NI>> for u32x4x4_avx2<NI> {}
+
+    impl<NI: Copy> Store<vec512_storage> for u32x4x4_avx2<NI> {
+        #[inline(always)]
+        unsafe fn unpack(p: vec512_storage) -> Self {
+            Self::new([
+                u32x4x2_avx2::unpack(p.avx[0]),
+                u32x4x2_avx2::unpack(p.avx[1]),
+            ])
+        }
+    }
+    impl<NI: Copy> MultiLane<[u32x4_sse2<YesS3, YesS4, NI>; 4]> for u32x4x4_avx2<NI> {
+        #[inline(always)]
+        fn to_lanes(self) -> [u32x4_sse2<YesS3, YesS4, NI>; 4] {
+            let [a, b] = self.0[0].to_lanes();
+            let [c, d] = self.0[1].to_lanes();
+            [a, b, c, d]
+        }
+        #[inline(always)]
+        fn from_lanes(x: [u32x4_sse2<YesS3, YesS4, NI>; 4]) -> Self {
+            let ab = u32x4x2_avx2::from_lanes([x[0], x[1]]);
+            let cd = u32x4x2_avx2::from_lanes([x[2], x[3]]);
+            Self::new([ab, cd])
+        }
+    }
+    impl<NI: Copy> Vec4<u32x4_sse2<YesS3, YesS4, NI>> for u32x4x4_avx2<NI> {
+        #[inline(always)]
+        fn extract(self, i: u32) -> u32x4_sse2<YesS3, YesS4, NI> {
+            match i {
+                0 => self.0[0].extract(0),
+                1 => self.0[0].extract(1),
+                2 => self.0[1].extract(0),
+                3 => self.0[1].extract(1),
+                _ => panic!(),
+            }
+        }
+        #[inline(always)]
+        fn insert(self, w: u32x4_sse2<YesS3, YesS4, NI>, i: u32) -> Self {
+            Self::new(match i {
+                0 | 1 => [self.0[0].insert(w, i), self.0[1]],
+                2 | 3 => [self.0[0], self.0[1].insert(w, i - 2)],
+                _ => panic!(),
+            })
+        }
+    }
+    impl<NI: Copy> Vec4Ext<u32x4_sse2<YesS3, YesS4, NI>> for u32x4x4_avx2<NI> {
+        #[inline(always)]
+        fn transpose4(a: Self, b: Self, c: Self, d: Self) -> (Self, Self, Self, Self) {
+            /*
+             * a00:a01 a10:a11
+             * b00:b01 b10:b11
+             * c00:c01 c10:c11
+             * d00:d01 d10:d11
+             *       =>
+             * a00:b00 c00:d00
+             * a01:b01 c01:d01
+             * a10:b10 c10:d10
+             * a11:b11 c11:d11
+             */
+            unsafe {
+                let ab00 = u32x4x2_avx2::new(_mm256_permute2x128_si256(a.0[0].x, b.0[0].x, 0x20));
+                let ab01 = u32x4x2_avx2::new(_mm256_permute2x128_si256(a.0[0].x, b.0[0].x, 0x31));
+                let ab10 = u32x4x2_avx2::new(_mm256_permute2x128_si256(a.0[1].x, b.0[1].x, 0x20));
+                let ab11 = u32x4x2_avx2::new(_mm256_permute2x128_si256(a.0[1].x, b.0[1].x, 0x31));
+                let cd00 = u32x4x2_avx2::new(_mm256_permute2x128_si256(c.0[0].x, d.0[0].x, 0x20));
+                let cd01 = u32x4x2_avx2::new(_mm256_permute2x128_si256(c.0[0].x, d.0[0].x, 0x31));
+                let cd10 = u32x4x2_avx2::new(_mm256_permute2x128_si256(c.0[1].x, d.0[1].x, 0x20));
+                let cd11 = u32x4x2_avx2::new(_mm256_permute2x128_si256(c.0[1].x, d.0[1].x, 0x31));
+                (
+                    Self::new([ab00, cd00]),
+                    Self::new([ab01, cd01]),
+                    Self::new([ab10, cd10]),
+                    Self::new([ab11, cd11]),
+                )
+            }
+        }
+    }
+    impl<NI: Copy> Vector<[u32; 16]> for u32x4x4_avx2<NI> {
+        #[inline(always)]
+        fn to_scalars(self) -> [u32; 16] {
+            unsafe { core::mem::transmute(self) }
+        }
+    }
+    impl<NI: Copy> From<u32x4x4_avx2<NI>> for vec512_storage {
+        #[inline(always)]
+        fn from(x: u32x4x4_avx2<NI>) -> Self {
+            Self {
+                avx: [
+                    vec256_storage { avx: x.0[0].x },
+                    vec256_storage { avx: x.0[1].x },
+                ],
+            }
+        }
+    }
+    impl<NI: Copy> From<x4<u128x1_sse2<YesS3, YesS4, NI>>> for u32x4x4_avx2<NI> {
+        #[inline(always)]
+        fn from(x: x4<u128x1_sse2<YesS3, YesS4, NI>>) -> Self {
+            Self::new(unsafe {
+                [
+                    u32x4x2_avx2::new(_mm256_setr_m128i(x.0[0].x, x.0[1].x)),
+                    u32x4x2_avx2::new(_mm256_setr_m128i(x.0[2].x, x.0[3].x)),
+                ]
+            })
+        }
+    }
+}
diff --git a/crates/predicates-core/.cargo-checksum.json b/crates/predicates-core/.cargo-checksum.json
new file mode 100644
index 0000000..60693ad
--- /dev/null
+++ b/crates/predicates-core/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"84010f585e2969b20c6a2876f28e2adc27286fe646cc5fef5f1a680bc4eb9794","LICENSE-APACHE":"a6cba85bc92e0cff7a450b1d873c0eaa2e9fc96bf472df0247a26bec77bf3ff9","LICENSE-MIT":"9d6bf646112f22f1dd5722fbf615ac184bc372727b615e5dff7e45fe8de3a99e","README.md":"86159502694c7d90efa5fb411b36c51fd212f57022a2541063f36c235d827098","src/core.rs":"19c28cbadf83f50a618fed6f378a03c53f1457bde8c2ba7f12ccd311747607b3","src/lib.rs":"7a3b59e6ae2a15d33ec65feb93202af008763b108a8ae1119dcb3cc2a2a86c94","src/reflection.rs":"6db20379c5530d4c7cda97d5532f9c0d6c4e6f8e9220e1a00b6bc6368a4ed491"},"package":"b794032607612e7abeb4db69adb4e33590fa6cf1149e95fd7cb00e634b92f174"}
\ No newline at end of file
diff --git a/crates/predicates-core/Android.bp b/crates/predicates-core/Android.bp
new file mode 100644
index 0000000..f6f8846
--- /dev/null
+++ b/crates/predicates-core/Android.bp
@@ -0,0 +1,30 @@
+// This file is generated by cargo_embargo.
+// Do not modify this file because the changes will be overridden on upgrade.
+
+package {
+    default_applicable_licenses: ["external_rust_crates_predicates-core_license"],
+    default_team: "trendy_team_android_rust",
+}
+
+license {
+    name: "external_rust_crates_predicates-core_license",
+    visibility: [":__subpackages__"],
+    license_kinds: ["SPDX-license-identifier-Apache-2.0"],
+    license_text: ["LICENSE"],
+}
+
+rust_library {
+    name: "libpredicates_core",
+    host_supported: true,
+    crate_name: "predicates_core",
+    cargo_env_compat: true,
+    cargo_pkg_version: "1.0.6",
+    crate_root: "src/lib.rs",
+    edition: "2021",
+    apex_available: [
+        "//apex_available:platform",
+        "//apex_available:anyapex",
+    ],
+    product_available: true,
+    vendor_available: true,
+}
diff --git a/crates/predicates-core/Cargo.lock b/crates/predicates-core/Cargo.lock
new file mode 100644
index 0000000..5e5b174
--- /dev/null
+++ b/crates/predicates-core/Cargo.lock
@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "predicates-core"
+version = "1.0.6"
diff --git a/crates/predicates-core/Cargo.toml b/crates/predicates-core/Cargo.toml
new file mode 100644
index 0000000..a1de8f1
--- /dev/null
+++ b/crates/predicates-core/Cargo.toml
@@ -0,0 +1,78 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2021"
+rust-version = "1.64.0"
+name = "predicates-core"
+version = "1.0.6"
+authors = ["Nick Stevens <nick@bitcurry.com>"]
+include = [
+    "build.rs",
+    "src/**/*",
+    "Cargo.toml",
+    "LICENSE*",
+    "README.md",
+    "benches/**/*",
+    "examples/**/*",
+]
+description = "An API for boolean-valued predicate functions."
+homepage = "https://github.com/assert-rs/predicates-rs/tree/master/crates/core"
+documentation = "https://docs.rs/predicates-core"
+readme = "README.md"
+keywords = [
+    "predicate",
+    "boolean",
+    "combinatorial",
+    "match",
+    "logic",
+]
+categories = [
+    "data-structures",
+    "rust-patterns",
+]
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/assert-rs/predicates-rs/tree/master/crates/core"
+
+[[package.metadata.release.pre-release-replacements]]
+file = "CHANGELOG.md"
+search = "Unreleased"
+replace = "{{version}}"
+min = 1
+
+[[package.metadata.release.pre-release-replacements]]
+file = "CHANGELOG.md"
+search = '\.\.\.HEAD'
+replace = "...{{tag_name}}"
+exactly = 1
+
+[[package.metadata.release.pre-release-replacements]]
+file = "CHANGELOG.md"
+search = "ReleaseDate"
+replace = "{{date}}"
+min = 1
+
+[[package.metadata.release.pre-release-replacements]]
+file = "CHANGELOG.md"
+search = "<!-- next-header -->"
+replace = """
+<!-- next-header -->
+## [Unreleased] - ReleaseDate
+"""
+exactly = 1
+
+[[package.metadata.release.pre-release-replacements]]
+file = "CHANGELOG.md"
+search = "<!-- next-url -->"
+replace = """
+<!-- next-url -->
+[Unreleased]: https://github.com/assert-rs/predicates-rs/compare/{{tag_name}}...HEAD"""
+exactly = 1
diff --git a/crates/predicates-core/LICENSE b/crates/predicates-core/LICENSE
new file mode 120000
index 0000000..6b579aa
--- /dev/null
+++ b/crates/predicates-core/LICENSE
@@ -0,0 +1 @@
+LICENSE-APACHE
\ No newline at end of file
diff --git a/crates/predicates-core/LICENSE-APACHE b/crates/predicates-core/LICENSE-APACHE
new file mode 100644
index 0000000..d9a10c0
--- /dev/null
+++ b/crates/predicates-core/LICENSE-APACHE
@@ -0,0 +1,176 @@
+                                 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
diff --git a/crates/predicates-core/LICENSE-MIT b/crates/predicates-core/LICENSE-MIT
new file mode 100644
index 0000000..51e7743
--- /dev/null
+++ b/crates/predicates-core/LICENSE-MIT
@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2017 Nick Stevens
+
+
+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/crates/predicates-core/METADATA b/crates/predicates-core/METADATA
new file mode 100644
index 0000000..cd32702
--- /dev/null
+++ b/crates/predicates-core/METADATA
@@ -0,0 +1,20 @@
+name: "predicates-core"
+description: "An API for boolean-valued predicate functions."
+third_party {
+  identifier {
+    type: "crates.io"
+    value: "https://crates.io/crates/predicates-core"
+  }
+  identifier {
+    type: "Archive"
+    value: "https://static.crates.io/crates/predicates-core/predicates-core-1.0.6.crate"
+  }
+  version: "1.0.6"
+  # Dual-licensed, using the least restrictive per go/thirdpartylicenses#same.
+  license_type: NOTICE
+  last_upgrade_date {
+    year: 2023
+    month: 11
+    day: 6
+  }
+}
diff --git a/crates/predicates-core/MODULE_LICENSE_APACHE2 b/crates/predicates-core/MODULE_LICENSE_APACHE2
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/crates/predicates-core/MODULE_LICENSE_APACHE2
diff --git a/crates/predicates-core/README.md b/crates/predicates-core/README.md
new file mode 100644
index 0000000..57ec3ac
--- /dev/null
+++ b/crates/predicates-core/README.md
@@ -0,0 +1,25 @@
+# predicates-core
+
+> Traits for **boolean-valued predicate functions** in Rust.
+
+[![Build Status](https://dev.azure.com/assert-rs/assert-rs/_apis/build/status/predicates-rs?branchName=master)](https://dev.azure.com/assert-rs/assert-rs/_build/latest?definitionId=1&branchName=master)
+[![Documentation](https://img.shields.io/badge/docs-master-blue.svg)](https://docs.rs/predicates-core)
+![License](https://img.shields.io/crates/l/predicates-core.svg)
+[![Crates.io](https://img.shields.io/crates/v/predicates-core.svg?maxAge=2592000)](https://crates.io/crates/predicates-core)
+
+[Changelog](https://github.com/assert-rs/predicates-rs/blob/master/crates/core/CHANGELOG.md)
+
+
+## License
+
+`predicates-core` is distributed under the terms of both the MIT license and the
+Apache License (Version 2.0).
+
+See LICENSE-APACHE, and LICENSE-MIT for details.
+
+
+## Credits
+
+Big thanks to [futures-rs](https://github.com/alexcrichton/futures-rs), whose
+slick API design informed a lot of decisions made on the API design of this
+library.
diff --git a/crates/predicates-core/cargo_embargo.json b/crates/predicates-core/cargo_embargo.json
new file mode 100644
index 0000000..9a0a579
--- /dev/null
+++ b/crates/predicates-core/cargo_embargo.json
@@ -0,0 +1,3 @@
+{
+  "tests": true
+}
diff --git a/crates/predicates-core/src/core.rs b/crates/predicates-core/src/core.rs
new file mode 100644
index 0000000..b5aaa7b
--- /dev/null
+++ b/crates/predicates-core/src/core.rs
@@ -0,0 +1,32 @@
+// Copyright (c) 2018 The predicates-rs Project Developers.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use crate::reflection;
+
+/// Trait for generically evaluating a type against a dynamically created
+/// predicate function.
+///
+/// The exact meaning of `eval` depends on the situation, but will usually
+/// mean that the evaluated item is in some sort of pre-defined set.  This is
+/// different from `Ord` and `Eq` in that an `item` will almost never be the
+/// same type as the implementing `Predicate` type.
+pub trait Predicate<Item: ?Sized>: reflection::PredicateReflection {
+    /// Execute this `Predicate` against `variable`, returning the resulting
+    /// boolean.
+    fn eval(&self, variable: &Item) -> bool;
+
+    /// Find a case that proves this predicate as `expected` when run against `variable`.
+    fn find_case<'a>(&'a self, expected: bool, variable: &Item) -> Option<reflection::Case<'a>> {
+        let actual = self.eval(variable);
+        if expected == actual {
+            Some(reflection::Case::new(None, actual))
+        } else {
+            None
+        }
+    }
+}
diff --git a/crates/predicates-core/src/lib.rs b/crates/predicates-core/src/lib.rs
new file mode 100644
index 0000000..e0c9ace
--- /dev/null
+++ b/crates/predicates-core/src/lib.rs
@@ -0,0 +1,25 @@
+// Copyright (c) 2018 The predicates-rs Project Developers.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/license/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Composable first-order predicate trait.
+//!
+//! This library implements an interface to "predicates" - boolean-valued
+//! functions of one argument. This allows combinatorial logic to be created and
+//! assembled at runtime and then used one or more times for evaluating values.
+//! This sort of object is really useful when creating filters and checks that
+//! can be changed at runtime with user interaction - it allows a clean
+//! separation of concerns where the configuration code can be used to build up
+//! a predicate, and then that predicate can be given to the code that does the
+//! actual filtering without the filtering code knowing anything about user
+//! configuration. See the examples for how this can work.
+
+#![warn(missing_docs, missing_debug_implementations)]
+
+mod core;
+pub use crate::core::*;
+pub mod reflection;
diff --git a/crates/predicates-core/src/reflection.rs b/crates/predicates-core/src/reflection.rs
new file mode 100644
index 0000000..120d1bd
--- /dev/null
+++ b/crates/predicates-core/src/reflection.rs
@@ -0,0 +1,252 @@
+// Copyright (c) 2018 The predicates-rs Project Developers.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Introspect into the state of a `Predicate`.
+
+use std::borrow;
+use std::fmt;
+use std::slice;
+
+/// Introspect the state of a `Predicate`.
+pub trait PredicateReflection: fmt::Display {
+    /// Parameters of the current `Predicate`.
+    fn parameters<'a>(&'a self) -> Box<dyn Iterator<Item = Parameter<'a>> + 'a> {
+        let params = vec![];
+        Box::new(params.into_iter())
+    }
+
+    /// Nested `Predicate`s of the current `Predicate`.
+    fn children<'a>(&'a self) -> Box<dyn Iterator<Item = Child<'a>> + 'a> {
+        let params = vec![];
+        Box::new(params.into_iter())
+    }
+}
+
+/// A view of a `Predicate` parameter, provided by reflection.
+///
+/// ```rust
+/// use predicates_core;
+///
+/// let param = predicates_core::reflection::Parameter::new("key", &10);
+/// println!("{}", param);
+/// ```
+pub struct Parameter<'a>(&'a str, &'a dyn fmt::Display);
+
+impl<'a> Parameter<'a> {
+    /// Create a new `Parameter`.
+    pub fn new(key: &'a str, value: &'a dyn fmt::Display) -> Self {
+        Self(key, value)
+    }
+
+    /// Access the `Parameter` name.
+    pub fn name(&self) -> &str {
+        self.0
+    }
+
+    /// Access the `Parameter` value.
+    pub fn value(&self) -> &dyn fmt::Display {
+        self.1
+    }
+}
+
+impl<'a> fmt::Display for Parameter<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}: {}", self.0, self.1)
+    }
+}
+
+impl<'a> fmt::Debug for Parameter<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "({:?}, {})", self.0, self.1)
+    }
+}
+
+/// A view of a `Predicate` child, provided by reflection.
+pub struct Child<'a>(&'a str, &'a dyn PredicateReflection);
+
+impl<'a> Child<'a> {
+    /// Create a new `Predicate` child.
+    pub fn new(key: &'a str, value: &'a dyn PredicateReflection) -> Self {
+        Self(key, value)
+    }
+
+    /// Access the `Child`'s name.
+    pub fn name(&self) -> &str {
+        self.0
+    }
+
+    /// Access the `Child` `Predicate`.
+    pub fn value(&self) -> &dyn PredicateReflection {
+        self.1
+    }
+}
+
+impl<'a> fmt::Display for Child<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}: {}", self.0, self.1)
+    }
+}
+
+impl<'a> fmt::Debug for Child<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "({:?}, {})", self.0, self.1)
+    }
+}
+
+/// A descriptive explanation for why a predicate failed.
+pub struct Case<'a> {
+    predicate: Option<&'a dyn PredicateReflection>,
+    result: bool,
+    products: Vec<Product>,
+    children: Vec<Case<'a>>,
+}
+
+impl<'a> Case<'a> {
+    /// Create a new `Case` describing the result of a `Predicate`.
+    pub fn new(predicate: Option<&'a dyn PredicateReflection>, result: bool) -> Self {
+        Self {
+            predicate,
+            result,
+            products: Default::default(),
+            children: Default::default(),
+        }
+    }
+
+    /// Add an additional by product to a `Case`.
+    pub fn add_product(mut self, product: Product) -> Self {
+        self.products.push(product);
+        self
+    }
+
+    /// Add an additional by product to a `Case`.
+    pub fn add_child(mut self, child: Case<'a>) -> Self {
+        self.children.push(child);
+        self
+    }
+
+    /// The `Predicate` that produced this case.
+    pub fn predicate(&self) -> Option<&dyn PredicateReflection> {
+        self.predicate
+    }
+
+    /// The result of this case.
+    pub fn result(&self) -> bool {
+        self.result
+    }
+
+    /// Access the by-products from determining this case.
+    pub fn products(&self) -> CaseProducts<'_> {
+        CaseProducts(self.products.iter())
+    }
+
+    /// Access the sub-cases.
+    pub fn children(&self) -> CaseChildren<'_> {
+        CaseChildren(self.children.iter())
+    }
+}
+
+impl<'a> fmt::Debug for Case<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let predicate = if let Some(ref predicate) = self.predicate {
+            format!("Some({})", predicate)
+        } else {
+            "None".to_owned()
+        };
+        f.debug_struct("Case")
+            .field("predicate", &predicate)
+            .field("result", &self.result)
+            .field("products", &self.products)
+            .field("children", &self.children)
+            .finish()
+    }
+}
+
+/// Iterator over a `Case`s by-products.
+#[derive(Debug, Clone)]
+pub struct CaseProducts<'a>(slice::Iter<'a, Product>);
+
+impl<'a> Iterator for CaseProducts<'a> {
+    type Item = &'a Product;
+
+    fn next(&mut self) -> Option<&'a Product> {
+        self.0.next()
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.0.size_hint()
+    }
+
+    fn count(self) -> usize {
+        self.0.count()
+    }
+}
+
+/// Iterator over a `Case`s sub-cases.
+#[derive(Debug, Clone)]
+pub struct CaseChildren<'a>(slice::Iter<'a, Case<'a>>);
+
+impl<'a> Iterator for CaseChildren<'a> {
+    type Item = &'a Case<'a>;
+
+    fn next(&mut self) -> Option<&'a Case<'a>> {
+        self.0.next()
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.0.size_hint()
+    }
+
+    fn count(self) -> usize {
+        self.0.count()
+    }
+}
+
+/// A by-product of a predicate evaluation.
+///
+/// ```rust
+/// use predicates_core;
+///
+/// let product = predicates_core::reflection::Product::new("key", "value");
+/// println!("{}", product);
+/// let product = predicates_core::reflection::Product::new(format!("key-{}", 5), 30);
+/// println!("{}", product);
+/// ```
+pub struct Product(borrow::Cow<'static, str>, Box<dyn fmt::Display>);
+
+impl Product {
+    /// Create a new `Product`.
+    pub fn new<S, D>(key: S, value: D) -> Self
+    where
+        S: Into<borrow::Cow<'static, str>>,
+        D: fmt::Display + 'static,
+    {
+        Self(key.into(), Box::new(value))
+    }
+
+    /// Access the `Product` name.
+    pub fn name(&self) -> &str {
+        self.0.as_ref()
+    }
+
+    /// Access the `Product` value.
+    pub fn value(&self) -> &dyn fmt::Display {
+        &self.1
+    }
+}
+
+impl fmt::Display for Product {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}: {}", self.0, self.1)
+    }
+}
+
+impl fmt::Debug for Product {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "({:?}, {})", self.0, self.1)
+    }
+}
diff --git a/crates/predicates-tree/.cargo-checksum.json b/crates/predicates-tree/.cargo-checksum.json
new file mode 100644
index 0000000..58007c6
--- /dev/null
+++ b/crates/predicates-tree/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"Cargo.lock":"00e7615c11a29d07b20354e6c2bbed48a24d226fa137bf3a6953f631b04ccafe","Cargo.toml":"b52f695e84927ad9887c19b0dc5b9a567d3ed28193fd68d682f207c3ccafbdac","LICENSE-APACHE":"a6cba85bc92e0cff7a450b1d873c0eaa2e9fc96bf472df0247a26bec77bf3ff9","LICENSE-MIT":"9d6bf646112f22f1dd5722fbf615ac184bc372727b615e5dff7e45fe8de3a99e","README.md":"2e96471579f50e44834a5e58f1f16466c0395661873754ac5b8b342ecd157786","examples/failures.rs":"e5c9bafb7649d2b8aad4b585c28385cfc2d55e32aa190da693c920fc61945275","src/lib.rs":"b784e62fc9cd370ce29955e3cbc35ba1456efa0324fb49c0cf705969f691b4ba"},"package":"368ba315fb8c5052ab692e68a0eefec6ec57b23a36959c14496f0b0df2c0cecf"}
\ No newline at end of file
diff --git a/crates/predicates-tree/Android.bp b/crates/predicates-tree/Android.bp
new file mode 100644
index 0000000..d02c50a
--- /dev/null
+++ b/crates/predicates-tree/Android.bp
@@ -0,0 +1,34 @@
+// This file is generated by cargo_embargo.
+// Do not modify this file because the changes will be overridden on upgrade.
+
+package {
+    default_applicable_licenses: ["external_rust_crates_predicates-tree_license"],
+    default_team: "trendy_team_android_rust",
+}
+
+license {
+    name: "external_rust_crates_predicates-tree_license",
+    visibility: [":__subpackages__"],
+    license_kinds: ["SPDX-license-identifier-Apache-2.0"],
+    license_text: ["LICENSE"],
+}
+
+rust_library {
+    name: "libpredicates_tree",
+    host_supported: true,
+    crate_name: "predicates_tree",
+    cargo_env_compat: true,
+    cargo_pkg_version: "1.0.9",
+    crate_root: "src/lib.rs",
+    edition: "2021",
+    rustlibs: [
+        "libpredicates_core",
+        "libtermtree",
+    ],
+    apex_available: [
+        "//apex_available:platform",
+        "//apex_available:anyapex",
+    ],
+    product_available: true,
+    vendor_available: true,
+}
diff --git a/crates/predicates-tree/Cargo.lock b/crates/predicates-tree/Cargo.lock
new file mode 100644
index 0000000..2bae5b1
--- /dev/null
+++ b/crates/predicates-tree/Cargo.lock
@@ -0,0 +1,128 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "aho-corasick"
+version = "0.7.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4f55bd91a0978cbfd91c457a164bab8b4001c833b7f323132c0a4e1922dd44e"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "anstyle"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "80c697cc33851b02ab0c26b2e8a211684fbe627ff1cc506131f35026dd7686dd"
+
+[[package]]
+name = "autocfg"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+
+[[package]]
+name = "difflib"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8"
+
+[[package]]
+name = "either"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "90e5c1c8368803113bf0c9584fc495a58b86dc8a29edbf8fe877d21d9507e797"
+
+[[package]]
+name = "float-cmp"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "98de4bbd547a563b716d8dfa9aad1cb19bfab00f4fa09a6a4ed21dbcf44ce9c4"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "itertools"
+version = "0.10.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "memchr"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
+
+[[package]]
+name = "normalize-line-endings"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61807f77802ff30975e01f4f071c8ba10c022052f98b3294119f3e615d13e5be"
+
+[[package]]
+name = "num-traits"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "predicates"
+version = "3.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ba7d6ead3e3966038f68caa9fc1f860185d95a793180bbcfe0d0da47b3961ed"
+dependencies = [
+ "anstyle",
+ "difflib",
+ "float-cmp",
+ "itertools",
+ "normalize-line-endings",
+ "predicates-core",
+ "regex",
+]
+
+[[package]]
+name = "predicates-core"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b794032607612e7abeb4db69adb4e33590fa6cf1149e95fd7cb00e634b92f174"
+
+[[package]]
+name = "predicates-tree"
+version = "1.0.9"
+dependencies = [
+ "predicates",
+ "predicates-core",
+ "termtree",
+]
+
+[[package]]
+name = "regex"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c4eb3267174b8c6c2f654116623910a0fef09c4753f8dd83db29c48a0df988b"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.6.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3f87b73ce11b1619a3c6332f45341e0047173771e8b8b73f87bfeefb7b56244"
+
+[[package]]
+name = "termtree"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3369f5ac52d5eb6ab48c6b4ffdc8efbcad6b89c765749064ba298f2c68a16a76"
diff --git a/crates/predicates-tree/Cargo.toml b/crates/predicates-tree/Cargo.toml
new file mode 100644
index 0000000..4716753
--- /dev/null
+++ b/crates/predicates-tree/Cargo.toml
@@ -0,0 +1,88 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2021"
+rust-version = "1.64.0"
+name = "predicates-tree"
+version = "1.0.9"
+authors = ["Nick Stevens <nick@bitcurry.com>"]
+include = [
+    "build.rs",
+    "src/**/*",
+    "Cargo.toml",
+    "LICENSE*",
+    "README.md",
+    "benches/**/*",
+    "examples/**/*",
+]
+description = "Render boolean-valued predicate functions results as a tree."
+homepage = "https://github.com/assert-rs/predicates-rs/tree/master/crates/tree"
+documentation = "https://docs.rs/predicates-tree"
+readme = "README.md"
+keywords = [
+    "predicate",
+    "boolean",
+    "combinatorial",
+    "match",
+    "logic",
+]
+categories = [
+    "data-structures",
+    "rust-patterns",
+]
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/assert-rs/predicates-rs/tree/master/crates/tree"
+
+[[package.metadata.release.pre-release-replacements]]
+file = "CHANGELOG.md"
+search = "Unreleased"
+replace = "{{version}}"
+min = 1
+
+[[package.metadata.release.pre-release-replacements]]
+file = "CHANGELOG.md"
+search = '\.\.\.HEAD'
+replace = "...{{tag_name}}"
+exactly = 1
+
+[[package.metadata.release.pre-release-replacements]]
+file = "CHANGELOG.md"
+search = "ReleaseDate"
+replace = "{{date}}"
+min = 1
+
+[[package.metadata.release.pre-release-replacements]]
+file = "CHANGELOG.md"
+search = "<!-- next-header -->"
+replace = """
+<!-- next-header -->
+## [Unreleased] - ReleaseDate
+"""
+exactly = 1
+
+[[package.metadata.release.pre-release-replacements]]
+file = "CHANGELOG.md"
+search = "<!-- next-url -->"
+replace = """
+<!-- next-url -->
+[Unreleased]: https://github.com/assert-rs/predicates-rs/compare/{{tag_name}}...HEAD"""
+exactly = 1
+
+[dependencies.predicates-core]
+version = "1.0"
+
+[dependencies.termtree]
+version = "0.4.1"
+
+[dev-dependencies.predicates]
+version = "3.0"
+features = ["color"]
diff --git a/crates/predicates-tree/LICENSE b/crates/predicates-tree/LICENSE
new file mode 120000
index 0000000..6b579aa
--- /dev/null
+++ b/crates/predicates-tree/LICENSE
@@ -0,0 +1 @@
+LICENSE-APACHE
\ No newline at end of file
diff --git a/crates/predicates-tree/LICENSE-APACHE b/crates/predicates-tree/LICENSE-APACHE
new file mode 100644
index 0000000..d9a10c0
--- /dev/null
+++ b/crates/predicates-tree/LICENSE-APACHE
@@ -0,0 +1,176 @@
+                                 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
diff --git a/crates/predicates-tree/LICENSE-MIT b/crates/predicates-tree/LICENSE-MIT
new file mode 100644
index 0000000..51e7743
--- /dev/null
+++ b/crates/predicates-tree/LICENSE-MIT
@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2017 Nick Stevens
+
+
+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/crates/predicates-tree/METADATA b/crates/predicates-tree/METADATA
new file mode 100644
index 0000000..a9e26f8
--- /dev/null
+++ b/crates/predicates-tree/METADATA
@@ -0,0 +1,20 @@
+name: "predicates-tree"
+description: "Render boolean-valued predicate functions results as a tree."
+third_party {
+  identifier {
+    type: "crates.io"
+    value: "https://crates.io/crates/predicates-tree"
+  }
+  identifier {
+    type: "Archive"
+    value: "https://static.crates.io/crates/predicates-tree/predicates-tree-1.0.9.crate"
+  }
+  version: "1.0.9"
+  # Dual-licensed, using the least restrictive per go/thirdpartylicenses#same.
+  license_type: NOTICE
+  last_upgrade_date {
+    year: 2023
+    month: 11
+    day: 6
+  }
+}
diff --git a/crates/predicates-tree/MODULE_LICENSE_APACHE2 b/crates/predicates-tree/MODULE_LICENSE_APACHE2
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/crates/predicates-tree/MODULE_LICENSE_APACHE2
diff --git a/crates/predicates-tree/README.md b/crates/predicates-tree/README.md
new file mode 100644
index 0000000..4902db1
--- /dev/null
+++ b/crates/predicates-tree/README.md
@@ -0,0 +1,18 @@
+# predicates-tree
+
+> Render **boolean-valued predicate functions** results as a tree.
+
+[![Build Status](https://dev.azure.com/assert-rs/assert-rs/_apis/build/status/predicates-rs?branchName=master)](https://dev.azure.com/assert-rs/assert-rs/_build/latest?definitionId=1&branchName=master)
+[![Documentation](https://img.shields.io/badge/docs-master-blue.svg)](https://docs.rs/predicates-tree)
+![License](https://img.shields.io/crates/l/predicates-tree.svg)
+[![Crates.io](https://img.shields.io/crates/v/predicates-tree.svg?maxAge=2592000)](https://crates.io/crates/predicates-tree)
+
+[Changelog](https://github.com/assert-rs/predicates-rs/blob/master/predicates-tree/CHANGELOG.md)
+
+
+## License
+
+`predicates-tree` is distributed under the terms of both the MIT license and the
+Apache License (Version 2.0).
+
+See LICENSE-APACHE, and LICENSE-MIT for details.
diff --git a/crates/predicates-tree/cargo_embargo.json b/crates/predicates-tree/cargo_embargo.json
new file mode 100644
index 0000000..9a0a579
--- /dev/null
+++ b/crates/predicates-tree/cargo_embargo.json
@@ -0,0 +1,3 @@
+{
+  "tests": true
+}
diff --git a/crates/predicates-tree/examples/failures.rs b/crates/predicates-tree/examples/failures.rs
new file mode 100644
index 0000000..9ba640c
--- /dev/null
+++ b/crates/predicates-tree/examples/failures.rs
@@ -0,0 +1,48 @@
+use predicates::prelude::*;
+use predicates_tree::CaseTreeExt;
+
+fn main() {
+    let expected = 10;
+    let actual = 15;
+    let pred = predicates::ord::eq(expected);
+    if let Some(case) = pred.find_case(false, &actual) {
+        let tree = case.tree();
+        println!("{}", tree);
+    }
+
+    let expected = [1, 2, 3];
+    let actual = 15;
+    let pred = predicates::iter::in_iter(IntoIterator::into_iter(expected));
+    if let Some(case) = pred.find_case(false, &actual) {
+        let tree = case.tree();
+        println!("{}", tree);
+    }
+
+    let expected = "Hello
+World!
+
+Goodbye!";
+    let actual = "Hello
+Moon!
+
+Goodbye!";
+    let pred = predicates::ord::eq(expected);
+    if let Some(case) = pred.find_case(false, &actual) {
+        let tree = case.tree();
+        println!("{}", tree);
+    }
+
+    let expected = "Hello
+World!
+
+Goodbye!";
+    let actual = "Hello
+Moon!
+
+Goodbye!";
+    let pred = predicates::str::diff(expected);
+    if let Some(case) = pred.find_case(false, actual) {
+        let tree = case.tree();
+        println!("{}", tree);
+    }
+}
diff --git a/crates/predicates-tree/src/lib.rs b/crates/predicates-tree/src/lib.rs
new file mode 100644
index 0000000..f0d2fd5
--- /dev/null
+++ b/crates/predicates-tree/src/lib.rs
@@ -0,0 +1,85 @@
+// Copyright (c) 2018 The predicates-rs Project Developers.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/license/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Render `Case` as a tree.
+
+use std::fmt;
+
+use predicates_core::reflection;
+
+/// Render `Self` as a displayable tree.
+pub trait CaseTreeExt {
+    /// Render `Self` as a displayable tree.
+    fn tree(&self) -> CaseTree;
+}
+
+impl<'a> CaseTreeExt for reflection::Case<'a> {
+    fn tree(&self) -> CaseTree {
+        CaseTree(convert(self))
+    }
+}
+
+type CaseTreeInner = termtree::Tree<Displayable>;
+
+fn convert(case: &reflection::Case<'_>) -> CaseTreeInner {
+    let mut leaves: Vec<CaseTreeInner> = vec![];
+
+    leaves.extend(case.predicate().iter().flat_map(|pred| {
+        pred.parameters().map(|item| {
+            let root = Displayable::new(&item);
+            termtree::Tree::new(root).with_multiline(true)
+        })
+    }));
+
+    leaves.extend(case.products().map(|item| {
+        let root = Displayable::new(item);
+        termtree::Tree::new(root).with_multiline(true)
+    }));
+
+    leaves.extend(case.children().map(convert));
+
+    let root = case
+        .predicate()
+        .map(|p| Displayable::new(&p))
+        .unwrap_or_default();
+    CaseTreeInner::new(root).with_leaves(leaves)
+}
+
+/// A `Case` rendered as a tree for display.
+#[allow(missing_debug_implementations)]
+pub struct CaseTree(CaseTreeInner);
+
+impl fmt::Display for CaseTree {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+#[derive(Default)]
+struct Displayable {
+    primary: String,
+    alternate: String,
+}
+
+impl Displayable {
+    fn new(display: &dyn std::fmt::Display) -> Self {
+        let primary = format!("{}", display);
+        let alternate = format!("{:#}", display);
+        Self { primary, alternate }
+    }
+}
+
+impl fmt::Display for Displayable {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if f.alternate() {
+            self.alternate.fmt(f)
+        } else {
+            self.primary.fmt(f)
+        }
+    }
+}
diff --git a/crates/prettyplease/.cargo-checksum.json b/crates/prettyplease/.cargo-checksum.json
new file mode 100644
index 0000000..10771d9
--- /dev/null
+++ b/crates/prettyplease/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"7bf8851c7835be64e76bba308a375ee711e12f2d8c2c56a54f0689c0a99cf3ce","LICENSE-APACHE":"62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","README.md":"dde54d4d5c759fbaea82b4039ab9cea7ee91918431dae011ffe01472e2e9eb44","build.rs":"fdf8aa9b5441b298c72ae23645e227adc52ac69d2decc1bda04e1a91f70ff87d","examples/input.rs":"53350088f12a346a99034af41ef432dedcc9e5d581c5592d9aae3807c42656c1","examples/output.prettyplease.rs":"fa63c118daadb64c456ec5b8d5e46e5d7fabbbeb6a6e61a08eabc23360a18fbd","examples/output.rustc.rs":"0c66f8929fa40a2822d4ea1aec3d8b83db598aba043b17f3c1a6133f0d657135","examples/output.rustfmt.rs":"914a9aea1c51e097bfd80c9af4011811e6126c9df5fb0eac3d40b1203fba7c58","src/algorithm.rs":"7a4a7b62f5300aabf7fcff3cd8c8aaa3ae1e3d1dc717eea1e4797988ce0e18c7","src/attr.rs":"54e829ae468f22c8e2853d669515575f1444bfee026cfd9b19538f77caf10ab7","src/convenience.rs":"dd392b009b691d3587c7d8e3caeaacf450303c4223792b5f89c336358e371c39","src/data.rs":"9db6623d3ccc79b541a28bdc88875ad0036576689e085007eb362819f8e9a2d3","src/expr.rs":"86bb85f9358b56fc703c7fe1bc499cd6b0f089488cf8ae218fd2289a362f9522","src/file.rs":"5689efa3c5959a6a0d8cfc2c13bf8a37ab0669e2b81dbded3f3c28884a88fca0","src/generics.rs":"0099fbd3f1520237fea960a63cef6d846019f3f9ce3c3308f38cef7c817de5c2","src/item.rs":"c689df7cab102a53409f02f2b2b2e00a0af26295ce3b6008b97086334b25942d","src/iter.rs":"38b2cd3b38719c6024fb6b3aa739f6f8736c83193fd21e2365d4f6c27bc41666","src/lib.rs":"0674ee9ce602859d148294e6b8c4290d81c4a61520c8500e8037c987e5c25b88","src/lifetime.rs":"6d420430168185b2da3409bc38a45f63cced9443915f04e6aec71367fc070dcf","src/lit.rs":"43ad4c7e1ff52b6649e79136186caefc1f3b064c04a01d12a5db511fa6f142d4","src/mac.rs":"78e7b4e519c2bb83a125ed8d0dd9afca0425762cb10562b073a862d2c098cf91","src/pat.rs":"37d626c401b171f6accf245b8fee6110e948968f59dcafe0889a9375667315f2","src/path.rs":"f2689a5d401a7c9943f626cbd13cf65b97b988b8d4e015f3dbe8c7d9c7a415de","src/ring.rs":"e23d133209b977e457b07b0cd93b3711d01f4172d7cfa4cf6a7247637390e606","src/stmt.rs":"54adef5e80a1a89062da3dc75b0646d2f2610f27ca26ec24b4c13fafbc6f3e7b","src/token.rs":"c288b1d81f2a35673d4ca1dd10d3386670b067460121df3038303e1ed73b41a7","src/ty.rs":"4db4ed58fa21ba19c11b47b53c9d21624691cce50c39462660ab1fd8ba1161e2"},"package":"3b69d39aab54d069e7f2fe8cb970493e7834601ca2d8c65fd7bbd183578080d1"}
\ No newline at end of file
diff --git a/crates/prettyplease/Android.bp b/crates/prettyplease/Android.bp
new file mode 100644
index 0000000..93a7bfa
--- /dev/null
+++ b/crates/prettyplease/Android.bp
@@ -0,0 +1,29 @@
+// This file is generated by cargo_embargo.
+// Do not modify this file because the changes will be overridden on upgrade.
+
+package {
+    default_applicable_licenses: ["external_rust_crates_prettyplease_license"],
+    default_team: "trendy_team_android_rust",
+}
+
+license {
+    name: "external_rust_crates_prettyplease_license",
+    visibility: [":__subpackages__"],
+    license_kinds: ["SPDX-license-identifier-Apache-2.0"],
+    license_text: ["LICENSE"],
+}
+
+rust_library_host {
+    name: "libprettyplease",
+    host_cross_supported: false,
+    crate_name: "prettyplease",
+    cargo_env_compat: true,
+    cargo_pkg_version: "0.2.6",
+    crate_root: "src/lib.rs",
+    edition: "2021",
+    rustlibs: [
+        "libproc_macro2",
+        "libsyn",
+    ],
+    compile_multilib: "first",
+}
diff --git a/crates/prettyplease/Cargo.lock b/crates/prettyplease/Cargo.lock
new file mode 100644
index 0000000..aa1c34e
--- /dev/null
+++ b/crates/prettyplease/Cargo.lock
@@ -0,0 +1,36 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "prettyplease"
+version = "0.2.6"
+dependencies = [
+ "proc-macro2",
+ "syn",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.86"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.76"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "578e081a14e0cefc3279b0472138c513f37b41a08d5a3cca9b6e4e8ceb6cd525"
+dependencies = [
+ "proc-macro2",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
diff --git a/crates/prettyplease/Cargo.toml b/crates/prettyplease/Cargo.toml
new file mode 100644
index 0000000..744d02e
--- /dev/null
+++ b/crates/prettyplease/Cargo.toml
@@ -0,0 +1,50 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2021"
+rust-version = "1.56"
+name = "prettyplease"
+version = "0.2.6"
+authors = ["David Tolnay <dtolnay@gmail.com>"]
+links = "prettyplease02"
+exclude = ["cargo-expand"]
+autoexamples = false
+description = "A minimal `syn` syntax tree pretty-printer"
+documentation = "https://docs.rs/prettyplease"
+readme = "README.md"
+keywords = ["rustfmt"]
+categories = ["development-tools"]
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/dtolnay/prettyplease"
+
+[package.metadata.playground]
+features = ["verbatim"]
+
+[lib]
+doc-scrape-examples = false
+
+[dependencies.proc-macro2]
+version = "1.0"
+default-features = false
+
+[dependencies.syn]
+version = "2.0.16"
+features = ["full"]
+default-features = false
+
+[dev-dependencies.syn]
+version = "2.0.16"
+features = ["parsing"]
+default-features = false
+
+[features]
+verbatim = ["syn/parsing"]
diff --git a/crates/prettyplease/LICENSE b/crates/prettyplease/LICENSE
new file mode 120000
index 0000000..6b579aa
--- /dev/null
+++ b/crates/prettyplease/LICENSE
@@ -0,0 +1 @@
+LICENSE-APACHE
\ No newline at end of file
diff --git a/crates/prettyplease/LICENSE-APACHE b/crates/prettyplease/LICENSE-APACHE
new file mode 100644
index 0000000..1b5ec8b
--- /dev/null
+++ b/crates/prettyplease/LICENSE-APACHE
@@ -0,0 +1,176 @@
+                              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
diff --git a/crates/prettyplease/LICENSE-MIT b/crates/prettyplease/LICENSE-MIT
new file mode 100644
index 0000000..31aa793
--- /dev/null
+++ b/crates/prettyplease/LICENSE-MIT
@@ -0,0 +1,23 @@
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/crates/prettyplease/METADATA b/crates/prettyplease/METADATA
new file mode 100644
index 0000000..6d6bed3
--- /dev/null
+++ b/crates/prettyplease/METADATA
@@ -0,0 +1,23 @@
+# This project was upgraded with external_updater.
+# Usage: tools/external_updater/updater.sh update rust/crates/prettyplease
+# For more info, check https://cs.android.com/android/platform/superproject/+/master:tools/external_updater/README.md
+
+name: "prettyplease"
+description: "A minimal `syn` syntax tree pretty-printer"
+third_party {
+  url {
+    type: HOMEPAGE
+    value: "https://crates.io/crates/prettyplease"
+  }
+  url {
+    type: ARCHIVE
+    value: "https://static.crates.io/crates/prettyplease/prettyplease-0.2.6.crate"
+  }
+  version: "0.2.6"
+  license_type: NOTICE
+  last_upgrade_date {
+    year: 2023
+    month: 5
+    day: 23
+  }
+}
diff --git a/crates/prettyplease/MODULE_LICENSE_APACHE2 b/crates/prettyplease/MODULE_LICENSE_APACHE2
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/crates/prettyplease/MODULE_LICENSE_APACHE2
diff --git a/crates/prettyplease/README.md b/crates/prettyplease/README.md
new file mode 100644
index 0000000..bd0439b
--- /dev/null
+++ b/crates/prettyplease/README.md
@@ -0,0 +1,312 @@
+prettyplease::unparse
+=====================
+
+[<img alt="github" src="https://img.shields.io/badge/github-dtolnay/prettyplease-8da0cb?style=for-the-badge&labelColor=555555&logo=github" height="20">](https://github.com/dtolnay/prettyplease)
+[<img alt="crates.io" src="https://img.shields.io/crates/v/prettyplease.svg?style=for-the-badge&color=fc8d62&logo=rust" height="20">](https://crates.io/crates/prettyplease)
+[<img alt="docs.rs" src="https://img.shields.io/badge/docs.rs-prettyplease-66c2a5?style=for-the-badge&labelColor=555555&logo=docs.rs" height="20">](https://docs.rs/prettyplease)
+[<img alt="build status" src="https://img.shields.io/github/actions/workflow/status/dtolnay/prettyplease/ci.yml?branch=master&style=for-the-badge" height="20">](https://github.com/dtolnay/prettyplease/actions?query=branch%3Amaster)
+
+A minimal `syn` syntax tree pretty-printer.
+
+<br>
+
+## Overview
+
+This is a pretty-printer to turn a `syn` syntax tree into a `String` of
+well-formatted source code. In contrast to rustfmt, this library is intended to
+be suitable for arbitrary generated code.
+
+Rustfmt prioritizes high-quality output that is impeccable enough that you'd be
+comfortable spending your career staring at its output &mdash; but that means
+some heavyweight algorithms, and it has a tendency to bail out on code that is
+hard to format (for example [rustfmt#3697], and there are dozens more issues
+like it). That's not necessarily a big deal for human-generated code because
+when code gets highly nested, the human will naturally be inclined to refactor
+into more easily formattable code. But for generated code, having the formatter
+just give up leaves it totally unreadable.
+
+[rustfmt#3697]: https://github.com/rust-lang/rustfmt/issues/3697
+
+This library is designed using the simplest possible algorithm and data
+structures that can deliver about 95% of the quality of rustfmt-formatted
+output. In my experience testing real-world code, approximately 97-98% of output
+lines come out identical between rustfmt's formatting and this crate's. The rest
+have slightly different linebreak decisions, but still clearly follow the
+dominant modern Rust style.
+
+The tradeoffs made by this crate are a good fit for generated code that you will
+*not* spend your career staring at. For example, the output of `bindgen`, or the
+output of `cargo-expand`. In those cases it's more important that the whole
+thing be formattable without the formatter giving up, than that it be flawless.
+
+<br>
+
+## Feature matrix
+
+Here are a few superficial comparisons of this crate against the AST
+pretty-printer built into rustc, and rustfmt. The sections below go into more
+detail comparing the output of each of these libraries.
+
+| | prettyplease | rustc | rustfmt |
+|:---|:---:|:---:|:---:|
+| non-pathological behavior on big or generated code | 💚 | ❌ | ❌ |
+| idiomatic modern formatting ("locally indistinguishable from rustfmt") | 💚 | ❌ | 💚 |
+| throughput | 60 MB/s | 39 MB/s | 2.8 MB/s |
+| number of dependencies | 3 | 72 | 66 |
+| compile time including dependencies | 2.4 sec | 23.1 sec | 29.8 sec |
+| buildable using a stable Rust compiler | 💚 | ❌ | ❌ |
+| published to crates.io | 💚 | ❌ | ❌ |
+| extensively configurable output | ❌ | ❌ | 💚 |
+| intended to accommodate hand-maintained source code | ❌ | ❌ | 💚 |
+
+<br>
+
+## Comparison to rustfmt
+
+- [input.rs](https://github.com/dtolnay/prettyplease/blob/0.1.0/examples/input.rs)
+- [output.prettyplease.rs](https://github.com/dtolnay/prettyplease/blob/0.1.0/examples/output.prettyplease.rs)
+- [output.rustfmt.rs](https://github.com/dtolnay/prettyplease/blob/0.1.0/examples/output.rustfmt.rs)
+
+If you weren't told which output file is which, it would be practically
+impossible to tell &mdash; **except** for line 435 in the rustfmt output, which
+is more than 1000 characters long because rustfmt just gave up formatting that
+part of the file:
+
+```rust
+            match segments[5] {
+                0 => write!(f, "::{}", ipv4),
+                0xffff => write!(f, "::ffff:{}", ipv4),
+                _ => unreachable!(),
+            }
+        } else { # [derive (Copy , Clone , Default)] struct Span { start : usize , len : usize , } let zeroes = { let mut longest = Span :: default () ; let mut current = Span :: default () ; for (i , & segment) in segments . iter () . enumerate () { if segment == 0 { if current . len == 0 { current . start = i ; } current . len += 1 ; if current . len > longest . len { longest = current ; } } else { current = Span :: default () ; } } longest } ; # [doc = " Write a colon-separated part of the address"] # [inline] fn fmt_subslice (f : & mut fmt :: Formatter < '_ > , chunk : & [u16]) -> fmt :: Result { if let Some ((first , tail)) = chunk . split_first () { write ! (f , "{:x}" , first) ? ; for segment in tail { f . write_char (':') ? ; write ! (f , "{:x}" , segment) ? ; } } Ok (()) } if zeroes . len > 1 { fmt_subslice (f , & segments [.. zeroes . start]) ? ; f . write_str ("::") ? ; fmt_subslice (f , & segments [zeroes . start + zeroes . len ..]) } else { fmt_subslice (f , & segments) } }
+    } else {
+        const IPV6_BUF_LEN: usize = (4 * 8) + 7;
+        let mut buf = [0u8; IPV6_BUF_LEN];
+        let mut buf_slice = &mut buf[..];
+```
+
+This is a pretty typical manifestation of rustfmt bailing out in generated code
+&mdash; a chunk of the input ends up on one line. The other manifestation is
+that you're working on some code, running rustfmt on save like a conscientious
+developer, but after a while notice it isn't doing anything. You introduce an
+intentional formatting issue, like a stray indent or semicolon, and run rustfmt
+to check your suspicion. Nope, it doesn't get cleaned up &mdash; rustfmt is just
+not formatting the part of the file you are working on.
+
+The prettyplease library is designed to have no pathological cases that force a
+bail out; the entire input you give it will get formatted in some "good enough"
+form.
+
+Separately, rustfmt can be problematic to integrate into projects. It's written
+using rustc's internal syntax tree, so it can't be built by a stable compiler.
+Its releases are not regularly published to crates.io, so in Cargo builds you'd
+need to depend on it as a git dependency, which precludes publishing your crate
+to crates.io also. You can shell out to a `rustfmt` binary, but that'll be
+whatever rustfmt version is installed on each developer's system (if any), which
+can lead to spurious diffs in checked-in generated code formatted by different
+versions. In contrast prettyplease is designed to be easy to pull in as a
+library, and compiles fast.
+
+<br>
+
+## Comparison to rustc_ast_pretty
+
+- [input.rs](https://github.com/dtolnay/prettyplease/blob/0.1.0/examples/input.rs)
+- [output.prettyplease.rs](https://github.com/dtolnay/prettyplease/blob/0.1.0/examples/output.prettyplease.rs)
+- [output.rustc.rs](https://github.com/dtolnay/prettyplease/blob/0.1.0/examples/output.rustc.rs)
+
+This is the pretty-printer that gets used when rustc prints source code, such as
+`rustc -Zunpretty=expanded`. It's used also by the standard library's
+`stringify!` when stringifying an interpolated macro_rules AST fragment, like an
+$:expr, and transitively by `dbg!` and many macros in the ecosystem.
+
+Rustc's formatting is mostly okay, but does not hew closely to the dominant
+contemporary style of Rust formatting. Some things wouldn't ever be written on
+one line, like this `match` expression, and certainly not with a comma in front
+of the closing brace:
+
+```rust
+fn eq(&self, other: &IpAddr) -> bool {
+    match other { IpAddr::V4(v4) => self == v4, IpAddr::V6(_) => false, }
+}
+```
+
+Some places use non-multiple-of-4 indentation, which is definitely not the norm:
+
+```rust
+pub const fn to_ipv6_mapped(&self) -> Ipv6Addr {
+    let [a, b, c, d] = self.octets();
+    Ipv6Addr{inner:
+                 c::in6_addr{s6_addr:
+                                 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF,
+                                  0xFF, a, b, c, d],},}
+}
+```
+
+And although there isn't an egregious example of it in the link because the
+input code is pretty tame, in general rustc_ast_pretty has pathological behavior
+on generated code. It has a tendency to use excessive horizontal indentation and
+rapidly run out of width:
+
+```rust
+::std::io::_print(::core::fmt::Arguments::new_v1(&[""],
+                                                 &match (&msg,) {
+                                                      _args =>
+                                                      [::core::fmt::ArgumentV1::new(_args.0,
+                                                                                    ::core::fmt::Display::fmt)],
+                                                  }));
+```
+
+The snippets above are clearly different from modern rustfmt style. In contrast,
+prettyplease is designed to have output that is practically indistinguishable
+from rustfmt-formatted code.
+
+<br>
+
+## Example
+
+```rust
+// [dependencies]
+// prettyplease = "0.2"
+// syn = { version = "2", default-features = false, features = ["full", "parsing"] }
+
+const INPUT: &str = stringify! {
+    use crate::{
+          lazy::{Lazy, SyncLazy, SyncOnceCell}, panic,
+        sync::{ atomic::{AtomicUsize, Ordering::SeqCst},
+            mpsc::channel, Mutex, },
+      thread,
+    };
+    impl<T, U> Into<U> for T where U: From<T> {
+        fn into(self) -> U { U::from(self) }
+    }
+};
+
+fn main() {
+    let syntax_tree = syn::parse_file(INPUT).unwrap();
+    let formatted = prettyplease::unparse(&syntax_tree);
+    print!("{}", formatted);
+}
+```
+
+<br>
+
+## Algorithm notes
+
+The approach and terminology used in the implementation are derived from [*Derek
+C. Oppen, "Pretty Printing" (1979)*][paper], on which rustc_ast_pretty is also
+based, and from rustc_ast_pretty's implementation written by Graydon Hoare in
+2011 (and modernized over the years by dozens of volunteer maintainers).
+
+[paper]: http://i.stanford.edu/pub/cstr/reports/cs/tr/79/770/CS-TR-79-770.pdf
+
+The paper describes two language-agnostic interacting procedures `Scan()` and
+`Print()`. Language-specific code decomposes an input data structure into a
+stream of `string` and `break` tokens, and `begin` and `end` tokens for
+grouping. Each `begin`&ndash;`end` range may be identified as either "consistent
+breaking" or "inconsistent breaking". If a group is consistently breaking, then
+if the whole contents do not fit on the line, *every* `break` token in the group
+will receive a linebreak. This is appropriate, for example, for Rust struct
+literals, or arguments of a function call. If a group is inconsistently
+breaking, then the `string` tokens in the group are greedily placed on the line
+until out of space, and linebroken only at those `break` tokens for which the
+next string would not fit. For example, this is appropriate for the contents of
+a braced `use` statement in Rust.
+
+Scan's job is to efficiently accumulate sizing information about groups and
+breaks. For every `begin` token we compute the distance to the matched `end`
+token, and for every `break` we compute the distance to the next `break`. The
+algorithm uses a ringbuffer to hold tokens whose size is not yet ascertained.
+The maximum size of the ringbuffer is bounded by the target line length and does
+not grow indefinitely, regardless of deep nesting in the input stream. That's
+because once a group is sufficiently big, the precise size can no longer make a
+difference to linebreak decisions and we can effectively treat it as "infinity".
+
+Print's job is to use the sizing information to efficiently assign a "broken" or
+"not broken" status to every `begin` token. At that point the output is easily
+constructed by concatenating `string` tokens and breaking at `break` tokens
+contained within a broken group.
+
+Leveraging these primitives (i.e. cleverly placing the all-or-nothing consistent
+breaks and greedy inconsistent breaks) to yield rustfmt-compatible formatting
+for all of Rust's syntax tree nodes is a fun challenge.
+
+Here is a visualization of some Rust tokens fed into the pretty printing
+algorithm. Consistently breaking `begin`&mdash;`end` pairs are represented by
+`«`&#8288;`»`, inconsistently breaking by `‹`&#8288;`›`, `break` by `·`, and the
+rest of the non-whitespace are `string`.
+
+```text
+use crate::«{·
+‹    lazy::«{·‹Lazy,· SyncLazy,· SyncOnceCell›·}»,·
+    panic,·
+    sync::«{·
+‹        atomic::«{·‹AtomicUsize,· Ordering::SeqCst›·}»,·
+        mpsc::channel,· Mutex›,·
+    }»,·
+    thread›,·
+}»;·
+«‹«impl<«·T‹›,· U‹›·»>» Into<«·U·»>· for T›·
+where·
+    U:‹ From<«·T·»>›,·
+{·
+«    fn into(·«·self·») -> U {·
+‹        U::from(«·self·»)›·
+»    }·
+»}·
+```
+
+The algorithm described in the paper is not quite sufficient for producing
+well-formatted Rust code that is locally indistinguishable from rustfmt's style.
+The reason is that in the paper, the complete non-whitespace contents are
+assumed to be independent of linebreak decisions, with Scan and Print being only
+in control of the whitespace (spaces and line breaks). In Rust as idiomatically
+formattted by rustfmt, that is not the case. Trailing commas are one example;
+the punctuation is only known *after* the broken vs non-broken status of the
+surrounding group is known:
+
+```rust
+let _ = Struct { x: 0, y: true };
+
+let _ = Struct {
+    x: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx,
+    y: yyyyyyyyyyyyyyyyyyyyyyyyyyyyyy,   //<- trailing comma if the expression wrapped
+};
+```
+
+The formatting of `match` expressions is another case; we want small arms on the
+same line as the pattern, and big arms wrapped in a brace. The presence of the
+brace punctuation, comma, and semicolon are all dependent on whether the arm
+fits on the line:
+
+```rust
+match total_nanos.checked_add(entry.nanos as u64) {
+    Some(n) => tmp = n,   //<- small arm, inline with comma
+    None => {
+        total_secs = total_secs
+            .checked_add(total_nanos / NANOS_PER_SEC as u64)
+            .expect("overflow in iter::sum over durations");
+    }   //<- big arm, needs brace added, and also semicolon^
+}
+```
+
+The printing algorithm implementation in this crate accommodates all of these
+situations with conditional punctuation tokens whose selection can be deferred
+and populated after it's known that the group is or is not broken.
+
+<br>
+
+#### License
+
+<sup>
+Licensed under either of <a href="LICENSE-APACHE">Apache License, Version
+2.0</a> or <a href="LICENSE-MIT">MIT license</a> at your option.
+</sup>
+
+<br>
+
+<sub>
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in this crate by you, as defined in the Apache-2.0 license, shall
+be dual licensed as above, without any additional terms or conditions.
+</sub>
diff --git a/crates/prettyplease/build.rs b/crates/prettyplease/build.rs
new file mode 100644
index 0000000..0d798ed
--- /dev/null
+++ b/crates/prettyplease/build.rs
@@ -0,0 +1,5 @@
+fn main() {
+    println!("cargo:rerun-if-changed=build.rs");
+
+    println!(concat!("cargo:VERSION=", env!("CARGO_PKG_VERSION")));
+}
diff --git a/crates/prettyplease/cargo_embargo.json b/crates/prettyplease/cargo_embargo.json
new file mode 100644
index 0000000..1ac440f
--- /dev/null
+++ b/crates/prettyplease/cargo_embargo.json
@@ -0,0 +1,9 @@
+{
+  "package": {
+    "prettyplease": {
+      "device_supported": false,
+      "host_first_multilib": true
+    }
+  },
+  "run_cargo": false
+}
diff --git a/crates/prettyplease/examples/input.rs b/crates/prettyplease/examples/input.rs
new file mode 100644
index 0000000..ca3d980
--- /dev/null
+++ b/crates/prettyplease/examples/input.rs
@@ -0,0 +1 @@
+use crate :: cmp :: Ordering ; use crate :: fmt :: { self , Write as FmtWrite } ; use crate :: hash ; use crate :: io :: Write as IoWrite ; use crate :: mem :: transmute ; use crate :: sys :: net :: netc as c ; use crate :: sys_common :: { AsInner , FromInner , IntoInner } ; # [derive (Copy , Clone , Eq , PartialEq , Hash , PartialOrd , Ord)] pub enum IpAddr { V4 (Ipv4Addr) , V6 (Ipv6Addr) , } # [derive (Copy)] pub struct Ipv4Addr { inner : c :: in_addr , } # [derive (Copy)] pub struct Ipv6Addr { inner : c :: in6_addr , } # [derive (Copy , PartialEq , Eq , Clone , Hash , Debug)] # [non_exhaustive] pub enum Ipv6MulticastScope { InterfaceLocal , LinkLocal , RealmLocal , AdminLocal , SiteLocal , OrganizationLocal , Global , } impl IpAddr { pub const fn is_unspecified (& self) -> bool { match self { IpAddr :: V4 (ip) => ip . is_unspecified () , IpAddr :: V6 (ip) => ip . is_unspecified () , } } pub const fn is_loopback (& self) -> bool { match self { IpAddr :: V4 (ip) => ip . is_loopback () , IpAddr :: V6 (ip) => ip . is_loopback () , } } pub const fn is_global (& self) -> bool { match self { IpAddr :: V4 (ip) => ip . is_global () , IpAddr :: V6 (ip) => ip . is_global () , } } pub const fn is_multicast (& self) -> bool { match self { IpAddr :: V4 (ip) => ip . is_multicast () , IpAddr :: V6 (ip) => ip . is_multicast () , } } pub const fn is_documentation (& self) -> bool { match self { IpAddr :: V4 (ip) => ip . is_documentation () , IpAddr :: V6 (ip) => ip . is_documentation () , } } pub const fn is_benchmarking (& self) -> bool { match self { IpAddr :: V4 (ip) => ip . is_benchmarking () , IpAddr :: V6 (ip) => ip . is_benchmarking () , } } pub const fn is_ipv4 (& self) -> bool { matches ! (self , IpAddr :: V4 (_)) } pub const fn is_ipv6 (& self) -> bool { matches ! (self , IpAddr :: V6 (_)) } pub const fn to_canonical (& self) -> IpAddr { match self { & v4 @ IpAddr :: V4 (_) => v4 , IpAddr :: V6 (v6) => v6 . to_canonical () , } } } impl Ipv4Addr { pub const fn new (a : u8 , b : u8 , c : u8 , d : u8) -> Ipv4Addr { Ipv4Addr { inner : c :: in_addr { s_addr : u32 :: from_ne_bytes ([a , b , c , d]) } } } pub const LOCALHOST : Self = Ipv4Addr :: new (127 , 0 , 0 , 1) ; # [doc (alias = "INADDR_ANY")] pub const UNSPECIFIED : Self = Ipv4Addr :: new (0 , 0 , 0 , 0) ; pub const BROADCAST : Self = Ipv4Addr :: new (255 , 255 , 255 , 255) ; pub const fn octets (& self) -> [u8 ; 4] { self . inner . s_addr . to_ne_bytes () } pub const fn is_unspecified (& self) -> bool { self . inner . s_addr == 0 } pub const fn is_loopback (& self) -> bool { self . octets () [0] == 127 } pub const fn is_private (& self) -> bool { match self . octets () { [10 , ..] => true , [172 , b , ..] if b >= 16 && b <= 31 => true , [192 , 168 , ..] => true , _ => false , } } pub const fn is_link_local (& self) -> bool { matches ! (self . octets () , [169 , 254 , ..]) } pub const fn is_global (& self) -> bool { if u32 :: from_be_bytes (self . octets ()) == 0xc0000009 || u32 :: from_be_bytes (self . octets ()) == 0xc000000a { return true ; } ! self . is_private () && ! self . is_loopback () && ! self . is_link_local () && ! self . is_broadcast () && ! self . is_documentation () && ! self . is_shared () && ! (self . octets () [0] == 192 && self . octets () [1] == 0 && self . octets () [2] == 0) && ! self . is_reserved () && ! self . is_benchmarking () && self . octets () [0] != 0 } pub const fn is_shared (& self) -> bool { self . octets () [0] == 100 && (self . octets () [1] & 0b1100_0000 == 0b0100_0000) } pub const fn is_benchmarking (& self) -> bool { self . octets () [0] == 198 && (self . octets () [1] & 0xfe) == 18 } pub const fn is_reserved (& self) -> bool { self . octets () [0] & 240 == 240 && ! self . is_broadcast () } pub const fn is_multicast (& self) -> bool { self . octets () [0] >= 224 && self . octets () [0] <= 239 } pub const fn is_broadcast (& self) -> bool { u32 :: from_be_bytes (self . octets ()) == u32 :: from_be_bytes (Self :: BROADCAST . octets ()) } pub const fn is_documentation (& self) -> bool { matches ! (self . octets () , [192 , 0 , 2 , _] | [198 , 51 , 100 , _] | [203 , 0 , 113 , _]) } pub const fn to_ipv6_compatible (& self) -> Ipv6Addr { let [a , b , c , d] = self . octets () ; Ipv6Addr { inner : c :: in6_addr { s6_addr : [0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , a , b , c , d] } , } } pub const fn to_ipv6_mapped (& self) -> Ipv6Addr { let [a , b , c , d] = self . octets () ; Ipv6Addr { inner : c :: in6_addr { s6_addr : [0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0xFF , 0xFF , a , b , c , d] } , } } } impl fmt :: Display for IpAddr { fn fmt (& self , fmt : & mut fmt :: Formatter < '_ >) -> fmt :: Result { match self { IpAddr :: V4 (ip) => ip . fmt (fmt) , IpAddr :: V6 (ip) => ip . fmt (fmt) , } } } impl fmt :: Debug for IpAddr { fn fmt (& self , fmt : & mut fmt :: Formatter < '_ >) -> fmt :: Result { fmt :: Display :: fmt (self , fmt) } } impl From < Ipv4Addr > for IpAddr { fn from (ipv4 : Ipv4Addr) -> IpAddr { IpAddr :: V4 (ipv4) } } impl From < Ipv6Addr > for IpAddr { fn from (ipv6 : Ipv6Addr) -> IpAddr { IpAddr :: V6 (ipv6) } } impl fmt :: Display for Ipv4Addr { fn fmt (& self , fmt : & mut fmt :: Formatter < '_ >) -> fmt :: Result { let octets = self . octets () ; if fmt . precision () . is_none () && fmt . width () . is_none () { write ! (fmt , "{}.{}.{}.{}" , octets [0] , octets [1] , octets [2] , octets [3]) } else { const IPV4_BUF_LEN : usize = 15 ; let mut buf = [0u8 ; IPV4_BUF_LEN] ; let mut buf_slice = & mut buf [..] ; write ! (buf_slice , "{}.{}.{}.{}" , octets [0] , octets [1] , octets [2] , octets [3]) . unwrap () ; let len = IPV4_BUF_LEN - buf_slice . len () ; let buf = unsafe { crate :: str :: from_utf8_unchecked (& buf [.. len]) } ; fmt . pad (buf) } } } impl fmt :: Debug for Ipv4Addr { fn fmt (& self , fmt : & mut fmt :: Formatter < '_ >) -> fmt :: Result { fmt :: Display :: fmt (self , fmt) } } impl Clone for Ipv4Addr { fn clone (& self) -> Ipv4Addr { * self } } impl PartialEq for Ipv4Addr { fn eq (& self , other : & Ipv4Addr) -> bool { self . inner . s_addr == other . inner . s_addr } } impl PartialEq < Ipv4Addr > for IpAddr { fn eq (& self , other : & Ipv4Addr) -> bool { match self { IpAddr :: V4 (v4) => v4 == other , IpAddr :: V6 (_) => false , } } } impl PartialEq < IpAddr > for Ipv4Addr { fn eq (& self , other : & IpAddr) -> bool { match other { IpAddr :: V4 (v4) => self == v4 , IpAddr :: V6 (_) => false , } } } impl Eq for Ipv4Addr { } impl hash :: Hash for Ipv4Addr { fn hash < H : hash :: Hasher > (& self , s : & mut H) { { self . inner . s_addr } . hash (s) } } impl PartialOrd for Ipv4Addr { fn partial_cmp (& self , other : & Ipv4Addr) -> Option < Ordering > { Some (self . cmp (other)) } } impl PartialOrd < Ipv4Addr > for IpAddr { fn partial_cmp (& self , other : & Ipv4Addr) -> Option < Ordering > { match self { IpAddr :: V4 (v4) => v4 . partial_cmp (other) , IpAddr :: V6 (_) => Some (Ordering :: Greater) , } } } impl PartialOrd < IpAddr > for Ipv4Addr { fn partial_cmp (& self , other : & IpAddr) -> Option < Ordering > { match other { IpAddr :: V4 (v4) => self . partial_cmp (v4) , IpAddr :: V6 (_) => Some (Ordering :: Less) , } } } impl Ord for Ipv4Addr { fn cmp (& self , other : & Ipv4Addr) -> Ordering { u32 :: from_be (self . inner . s_addr) . cmp (& u32 :: from_be (other . inner . s_addr)) } } impl IntoInner < c :: in_addr > for Ipv4Addr { fn into_inner (self) -> c :: in_addr { self . inner } } impl From < Ipv4Addr > for u32 { fn from (ip : Ipv4Addr) -> u32 { let ip = ip . octets () ; u32 :: from_be_bytes (ip) } } impl From < u32 > for Ipv4Addr { fn from (ip : u32) -> Ipv4Addr { Ipv4Addr :: from (ip . to_be_bytes ()) } } impl From < [u8 ; 4] > for Ipv4Addr { fn from (octets : [u8 ; 4]) -> Ipv4Addr { Ipv4Addr :: new (octets [0] , octets [1] , octets [2] , octets [3]) } } impl From < [u8 ; 4] > for IpAddr { fn from (octets : [u8 ; 4]) -> IpAddr { IpAddr :: V4 (Ipv4Addr :: from (octets)) } } impl Ipv6Addr { pub const fn new (a : u16 , b : u16 , c : u16 , d : u16 , e : u16 , f : u16 , g : u16 , h : u16) -> Ipv6Addr { let addr16 = [a . to_be () , b . to_be () , c . to_be () , d . to_be () , e . to_be () , f . to_be () , g . to_be () , h . to_be () ,] ; Ipv6Addr { inner : c :: in6_addr { s6_addr : unsafe { transmute :: < _ , [u8 ; 16] > (addr16) } , } , } } pub const LOCALHOST : Self = Ipv6Addr :: new (0 , 0 , 0 , 0 , 0 , 0 , 0 , 1) ; pub const UNSPECIFIED : Self = Ipv6Addr :: new (0 , 0 , 0 , 0 , 0 , 0 , 0 , 0) ; pub const fn segments (& self) -> [u16 ; 8] { let [a , b , c , d , e , f , g , h] = unsafe { transmute :: < _ , [u16 ; 8] > (self . inner . s6_addr) } ; [u16 :: from_be (a) , u16 :: from_be (b) , u16 :: from_be (c) , u16 :: from_be (d) , u16 :: from_be (e) , u16 :: from_be (f) , u16 :: from_be (g) , u16 :: from_be (h) ,] } pub const fn is_unspecified (& self) -> bool { u128 :: from_be_bytes (self . octets ()) == u128 :: from_be_bytes (Ipv6Addr :: UNSPECIFIED . octets ()) } pub const fn is_loopback (& self) -> bool { u128 :: from_be_bytes (self . octets ()) == u128 :: from_be_bytes (Ipv6Addr :: LOCALHOST . octets ()) } pub const fn is_global (& self) -> bool { match self . multicast_scope () { Some (Ipv6MulticastScope :: Global) => true , None => self . is_unicast_global () , _ => false , } } pub const fn is_unique_local (& self) -> bool { (self . segments () [0] & 0xfe00) == 0xfc00 } pub const fn is_unicast (& self) -> bool { ! self . is_multicast () } pub const fn is_unicast_link_local (& self) -> bool { (self . segments () [0] & 0xffc0) == 0xfe80 } pub const fn is_documentation (& self) -> bool { (self . segments () [0] == 0x2001) && (self . segments () [1] == 0xdb8) } pub const fn is_benchmarking (& self) -> bool { (self . segments () [0] == 0x2001) && (self . segments () [1] == 0x2) && (self . segments () [2] == 0) } pub const fn is_unicast_global (& self) -> bool { self . is_unicast () && ! self . is_loopback () && ! self . is_unicast_link_local () && ! self . is_unique_local () && ! self . is_unspecified () && ! self . is_documentation () } pub const fn multicast_scope (& self) -> Option < Ipv6MulticastScope > { if self . is_multicast () { match self . segments () [0] & 0x000f { 1 => Some (Ipv6MulticastScope :: InterfaceLocal) , 2 => Some (Ipv6MulticastScope :: LinkLocal) , 3 => Some (Ipv6MulticastScope :: RealmLocal) , 4 => Some (Ipv6MulticastScope :: AdminLocal) , 5 => Some (Ipv6MulticastScope :: SiteLocal) , 8 => Some (Ipv6MulticastScope :: OrganizationLocal) , 14 => Some (Ipv6MulticastScope :: Global) , _ => None , } } else { None } } pub const fn is_multicast (& self) -> bool { (self . segments () [0] & 0xff00) == 0xff00 } pub const fn to_ipv4_mapped (& self) -> Option < Ipv4Addr > { match self . octets () { [0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0xff , 0xff , a , b , c , d] => { Some (Ipv4Addr :: new (a , b , c , d)) } _ => None , } } pub const fn to_ipv4 (& self) -> Option < Ipv4Addr > { if let [0 , 0 , 0 , 0 , 0 , 0 | 0xffff , ab , cd] = self . segments () { let [a , b] = ab . to_be_bytes () ; let [c , d] = cd . to_be_bytes () ; Some (Ipv4Addr :: new (a , b , c , d)) } else { None } } pub const fn to_canonical (& self) -> IpAddr { if let Some (mapped) = self . to_ipv4_mapped () { return IpAddr :: V4 (mapped) ; } IpAddr :: V6 (* self) } pub const fn octets (& self) -> [u8 ; 16] { self . inner . s6_addr } } impl fmt :: Display for Ipv6Addr { fn fmt (& self , f : & mut fmt :: Formatter < '_ >) -> fmt :: Result { if f . precision () . is_none () && f . width () . is_none () { let segments = self . segments () ; if self . is_unspecified () { f . write_str ("::") } else if self . is_loopback () { f . write_str ("::1") } else if let Some (ipv4) = self . to_ipv4 () { match segments [5] { 0 => write ! (f , "::{}" , ipv4) , 0xffff => write ! (f , "::ffff:{}" , ipv4) , _ => unreachable ! () , } } else { # [derive (Copy , Clone , Default)] struct Span { start : usize , len : usize , } let zeroes = { let mut longest = Span :: default () ; let mut current = Span :: default () ; for (i , & segment) in segments . iter () . enumerate () { if segment == 0 { if current . len == 0 { current . start = i ; } current . len += 1 ; if current . len > longest . len { longest = current ; } } else { current = Span :: default () ; } } longest } ; # [doc = " Write a colon-separated part of the address"] # [inline] fn fmt_subslice (f : & mut fmt :: Formatter < '_ > , chunk : & [u16]) -> fmt :: Result { if let Some ((first , tail)) = chunk . split_first () { write ! (f , "{:x}" , first) ? ; for segment in tail { f . write_char (':') ? ; write ! (f , "{:x}" , segment) ? ; } } Ok (()) } if zeroes . len > 1 { fmt_subslice (f , & segments [.. zeroes . start]) ? ; f . write_str ("::") ? ; fmt_subslice (f , & segments [zeroes . start + zeroes . len ..]) } else { fmt_subslice (f , & segments) } } } else { const IPV6_BUF_LEN : usize = (4 * 8) + 7 ; let mut buf = [0u8 ; IPV6_BUF_LEN] ; let mut buf_slice = & mut buf [..] ; write ! (buf_slice , "{}" , self) . unwrap () ; let len = IPV6_BUF_LEN - buf_slice . len () ; let buf = unsafe { crate :: str :: from_utf8_unchecked (& buf [.. len]) } ; f . pad (buf) } } } impl fmt :: Debug for Ipv6Addr { fn fmt (& self , fmt : & mut fmt :: Formatter < '_ >) -> fmt :: Result { fmt :: Display :: fmt (self , fmt) } } impl Clone for Ipv6Addr { fn clone (& self) -> Ipv6Addr { * self } } impl PartialEq for Ipv6Addr { fn eq (& self , other : & Ipv6Addr) -> bool { self . inner . s6_addr == other . inner . s6_addr } } impl PartialEq < IpAddr > for Ipv6Addr { fn eq (& self , other : & IpAddr) -> bool { match other { IpAddr :: V4 (_) => false , IpAddr :: V6 (v6) => self == v6 , } } } impl PartialEq < Ipv6Addr > for IpAddr { fn eq (& self , other : & Ipv6Addr) -> bool { match self { IpAddr :: V4 (_) => false , IpAddr :: V6 (v6) => v6 == other , } } } impl Eq for Ipv6Addr { } impl hash :: Hash for Ipv6Addr { fn hash < H : hash :: Hasher > (& self , s : & mut H) { self . inner . s6_addr . hash (s) } } impl PartialOrd for Ipv6Addr { fn partial_cmp (& self , other : & Ipv6Addr) -> Option < Ordering > { Some (self . cmp (other)) } } impl PartialOrd < Ipv6Addr > for IpAddr { fn partial_cmp (& self , other : & Ipv6Addr) -> Option < Ordering > { match self { IpAddr :: V4 (_) => Some (Ordering :: Less) , IpAddr :: V6 (v6) => v6 . partial_cmp (other) , } } } impl PartialOrd < IpAddr > for Ipv6Addr { fn partial_cmp (& self , other : & IpAddr) -> Option < Ordering > { match other { IpAddr :: V4 (_) => Some (Ordering :: Greater) , IpAddr :: V6 (v6) => self . partial_cmp (v6) , } } } impl Ord for Ipv6Addr { fn cmp (& self , other : & Ipv6Addr) -> Ordering { self . segments () . cmp (& other . segments ()) } } impl AsInner < c :: in6_addr > for Ipv6Addr { fn as_inner (& self) -> & c :: in6_addr { & self . inner } } impl FromInner < c :: in6_addr > for Ipv6Addr { fn from_inner (addr : c :: in6_addr) -> Ipv6Addr { Ipv6Addr { inner : addr } } } impl From < Ipv6Addr > for u128 { fn from (ip : Ipv6Addr) -> u128 { let ip = ip . octets () ; u128 :: from_be_bytes (ip) } } impl From < u128 > for Ipv6Addr { fn from (ip : u128) -> Ipv6Addr { Ipv6Addr :: from (ip . to_be_bytes ()) } } impl From < [u8 ; 16] > for Ipv6Addr { fn from (octets : [u8 ; 16]) -> Ipv6Addr { let inner = c :: in6_addr { s6_addr : octets } ; Ipv6Addr :: from_inner (inner) } } impl From < [u16 ; 8] > for Ipv6Addr { fn from (segments : [u16 ; 8]) -> Ipv6Addr { let [a , b , c , d , e , f , g , h] = segments ; Ipv6Addr :: new (a , b , c , d , e , f , g , h) } } impl From < [u8 ; 16] > for IpAddr { fn from (octets : [u8 ; 16]) -> IpAddr { IpAddr :: V6 (Ipv6Addr :: from (octets)) } } impl From < [u16 ; 8] > for IpAddr { fn from (segments : [u16 ; 8]) -> IpAddr { IpAddr :: V6 (Ipv6Addr :: from (segments)) } }
diff --git a/crates/prettyplease/examples/output.prettyplease.rs b/crates/prettyplease/examples/output.prettyplease.rs
new file mode 100644
index 0000000..45b65d0
--- /dev/null
+++ b/crates/prettyplease/examples/output.prettyplease.rs
@@ -0,0 +1,593 @@
+use crate::cmp::Ordering;
+use crate::fmt::{self, Write as FmtWrite};
+use crate::hash;
+use crate::io::Write as IoWrite;
+use crate::mem::transmute;
+use crate::sys::net::netc as c;
+use crate::sys_common::{AsInner, FromInner, IntoInner};
+#[derive(Copy, Clone, Eq, PartialEq, Hash, PartialOrd, Ord)]
+pub enum IpAddr {
+    V4(Ipv4Addr),
+    V6(Ipv6Addr),
+}
+#[derive(Copy)]
+pub struct Ipv4Addr {
+    inner: c::in_addr,
+}
+#[derive(Copy)]
+pub struct Ipv6Addr {
+    inner: c::in6_addr,
+}
+#[derive(Copy, PartialEq, Eq, Clone, Hash, Debug)]
+#[non_exhaustive]
+pub enum Ipv6MulticastScope {
+    InterfaceLocal,
+    LinkLocal,
+    RealmLocal,
+    AdminLocal,
+    SiteLocal,
+    OrganizationLocal,
+    Global,
+}
+impl IpAddr {
+    pub const fn is_unspecified(&self) -> bool {
+        match self {
+            IpAddr::V4(ip) => ip.is_unspecified(),
+            IpAddr::V6(ip) => ip.is_unspecified(),
+        }
+    }
+    pub const fn is_loopback(&self) -> bool {
+        match self {
+            IpAddr::V4(ip) => ip.is_loopback(),
+            IpAddr::V6(ip) => ip.is_loopback(),
+        }
+    }
+    pub const fn is_global(&self) -> bool {
+        match self {
+            IpAddr::V4(ip) => ip.is_global(),
+            IpAddr::V6(ip) => ip.is_global(),
+        }
+    }
+    pub const fn is_multicast(&self) -> bool {
+        match self {
+            IpAddr::V4(ip) => ip.is_multicast(),
+            IpAddr::V6(ip) => ip.is_multicast(),
+        }
+    }
+    pub const fn is_documentation(&self) -> bool {
+        match self {
+            IpAddr::V4(ip) => ip.is_documentation(),
+            IpAddr::V6(ip) => ip.is_documentation(),
+        }
+    }
+    pub const fn is_benchmarking(&self) -> bool {
+        match self {
+            IpAddr::V4(ip) => ip.is_benchmarking(),
+            IpAddr::V6(ip) => ip.is_benchmarking(),
+        }
+    }
+    pub const fn is_ipv4(&self) -> bool {
+        matches!(self, IpAddr::V4(_))
+    }
+    pub const fn is_ipv6(&self) -> bool {
+        matches!(self, IpAddr::V6(_))
+    }
+    pub const fn to_canonical(&self) -> IpAddr {
+        match self {
+            &v4 @ IpAddr::V4(_) => v4,
+            IpAddr::V6(v6) => v6.to_canonical(),
+        }
+    }
+}
+impl Ipv4Addr {
+    pub const fn new(a: u8, b: u8, c: u8, d: u8) -> Ipv4Addr {
+        Ipv4Addr {
+            inner: c::in_addr {
+                s_addr: u32::from_ne_bytes([a, b, c, d]),
+            },
+        }
+    }
+    pub const LOCALHOST: Self = Ipv4Addr::new(127, 0, 0, 1);
+    #[doc(alias = "INADDR_ANY")]
+    pub const UNSPECIFIED: Self = Ipv4Addr::new(0, 0, 0, 0);
+    pub const BROADCAST: Self = Ipv4Addr::new(255, 255, 255, 255);
+    pub const fn octets(&self) -> [u8; 4] {
+        self.inner.s_addr.to_ne_bytes()
+    }
+    pub const fn is_unspecified(&self) -> bool {
+        self.inner.s_addr == 0
+    }
+    pub const fn is_loopback(&self) -> bool {
+        self.octets()[0] == 127
+    }
+    pub const fn is_private(&self) -> bool {
+        match self.octets() {
+            [10, ..] => true,
+            [172, b, ..] if b >= 16 && b <= 31 => true,
+            [192, 168, ..] => true,
+            _ => false,
+        }
+    }
+    pub const fn is_link_local(&self) -> bool {
+        matches!(self.octets(), [169, 254, ..])
+    }
+    pub const fn is_global(&self) -> bool {
+        if u32::from_be_bytes(self.octets()) == 0xc0000009
+            || u32::from_be_bytes(self.octets()) == 0xc000000a
+        {
+            return true;
+        }
+        !self.is_private() && !self.is_loopback() && !self.is_link_local()
+            && !self.is_broadcast() && !self.is_documentation() && !self.is_shared()
+            && !(self.octets()[0] == 192 && self.octets()[1] == 0
+                && self.octets()[2] == 0) && !self.is_reserved()
+            && !self.is_benchmarking() && self.octets()[0] != 0
+    }
+    pub const fn is_shared(&self) -> bool {
+        self.octets()[0] == 100 && (self.octets()[1] & 0b1100_0000 == 0b0100_0000)
+    }
+    pub const fn is_benchmarking(&self) -> bool {
+        self.octets()[0] == 198 && (self.octets()[1] & 0xfe) == 18
+    }
+    pub const fn is_reserved(&self) -> bool {
+        self.octets()[0] & 240 == 240 && !self.is_broadcast()
+    }
+    pub const fn is_multicast(&self) -> bool {
+        self.octets()[0] >= 224 && self.octets()[0] <= 239
+    }
+    pub const fn is_broadcast(&self) -> bool {
+        u32::from_be_bytes(self.octets()) == u32::from_be_bytes(Self::BROADCAST.octets())
+    }
+    pub const fn is_documentation(&self) -> bool {
+        matches!(self.octets(), [192, 0, 2, _] | [198, 51, 100, _] | [203, 0, 113, _])
+    }
+    pub const fn to_ipv6_compatible(&self) -> Ipv6Addr {
+        let [a, b, c, d] = self.octets();
+        Ipv6Addr {
+            inner: c::in6_addr {
+                s6_addr: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, a, b, c, d],
+            },
+        }
+    }
+    pub const fn to_ipv6_mapped(&self) -> Ipv6Addr {
+        let [a, b, c, d] = self.octets();
+        Ipv6Addr {
+            inner: c::in6_addr {
+                s6_addr: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF, a, b, c, d],
+            },
+        }
+    }
+}
+impl fmt::Display for IpAddr {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            IpAddr::V4(ip) => ip.fmt(fmt),
+            IpAddr::V6(ip) => ip.fmt(fmt),
+        }
+    }
+}
+impl fmt::Debug for IpAddr {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(self, fmt)
+    }
+}
+impl From<Ipv4Addr> for IpAddr {
+    fn from(ipv4: Ipv4Addr) -> IpAddr {
+        IpAddr::V4(ipv4)
+    }
+}
+impl From<Ipv6Addr> for IpAddr {
+    fn from(ipv6: Ipv6Addr) -> IpAddr {
+        IpAddr::V6(ipv6)
+    }
+}
+impl fmt::Display for Ipv4Addr {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let octets = self.octets();
+        if fmt.precision().is_none() && fmt.width().is_none() {
+            write!(fmt, "{}.{}.{}.{}", octets[0], octets[1], octets[2], octets[3])
+        } else {
+            const IPV4_BUF_LEN: usize = 15;
+            let mut buf = [0u8; IPV4_BUF_LEN];
+            let mut buf_slice = &mut buf[..];
+            write!(buf_slice, "{}.{}.{}.{}", octets[0], octets[1], octets[2], octets[3])
+                .unwrap();
+            let len = IPV4_BUF_LEN - buf_slice.len();
+            let buf = unsafe { crate::str::from_utf8_unchecked(&buf[..len]) };
+            fmt.pad(buf)
+        }
+    }
+}
+impl fmt::Debug for Ipv4Addr {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(self, fmt)
+    }
+}
+impl Clone for Ipv4Addr {
+    fn clone(&self) -> Ipv4Addr {
+        *self
+    }
+}
+impl PartialEq for Ipv4Addr {
+    fn eq(&self, other: &Ipv4Addr) -> bool {
+        self.inner.s_addr == other.inner.s_addr
+    }
+}
+impl PartialEq<Ipv4Addr> for IpAddr {
+    fn eq(&self, other: &Ipv4Addr) -> bool {
+        match self {
+            IpAddr::V4(v4) => v4 == other,
+            IpAddr::V6(_) => false,
+        }
+    }
+}
+impl PartialEq<IpAddr> for Ipv4Addr {
+    fn eq(&self, other: &IpAddr) -> bool {
+        match other {
+            IpAddr::V4(v4) => self == v4,
+            IpAddr::V6(_) => false,
+        }
+    }
+}
+impl Eq for Ipv4Addr {}
+impl hash::Hash for Ipv4Addr {
+    fn hash<H: hash::Hasher>(&self, s: &mut H) {
+        { self.inner.s_addr }.hash(s)
+    }
+}
+impl PartialOrd for Ipv4Addr {
+    fn partial_cmp(&self, other: &Ipv4Addr) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+impl PartialOrd<Ipv4Addr> for IpAddr {
+    fn partial_cmp(&self, other: &Ipv4Addr) -> Option<Ordering> {
+        match self {
+            IpAddr::V4(v4) => v4.partial_cmp(other),
+            IpAddr::V6(_) => Some(Ordering::Greater),
+        }
+    }
+}
+impl PartialOrd<IpAddr> for Ipv4Addr {
+    fn partial_cmp(&self, other: &IpAddr) -> Option<Ordering> {
+        match other {
+            IpAddr::V4(v4) => self.partial_cmp(v4),
+            IpAddr::V6(_) => Some(Ordering::Less),
+        }
+    }
+}
+impl Ord for Ipv4Addr {
+    fn cmp(&self, other: &Ipv4Addr) -> Ordering {
+        u32::from_be(self.inner.s_addr).cmp(&u32::from_be(other.inner.s_addr))
+    }
+}
+impl IntoInner<c::in_addr> for Ipv4Addr {
+    fn into_inner(self) -> c::in_addr {
+        self.inner
+    }
+}
+impl From<Ipv4Addr> for u32 {
+    fn from(ip: Ipv4Addr) -> u32 {
+        let ip = ip.octets();
+        u32::from_be_bytes(ip)
+    }
+}
+impl From<u32> for Ipv4Addr {
+    fn from(ip: u32) -> Ipv4Addr {
+        Ipv4Addr::from(ip.to_be_bytes())
+    }
+}
+impl From<[u8; 4]> for Ipv4Addr {
+    fn from(octets: [u8; 4]) -> Ipv4Addr {
+        Ipv4Addr::new(octets[0], octets[1], octets[2], octets[3])
+    }
+}
+impl From<[u8; 4]> for IpAddr {
+    fn from(octets: [u8; 4]) -> IpAddr {
+        IpAddr::V4(Ipv4Addr::from(octets))
+    }
+}
+impl Ipv6Addr {
+    pub const fn new(
+        a: u16,
+        b: u16,
+        c: u16,
+        d: u16,
+        e: u16,
+        f: u16,
+        g: u16,
+        h: u16,
+    ) -> Ipv6Addr {
+        let addr16 = [
+            a.to_be(),
+            b.to_be(),
+            c.to_be(),
+            d.to_be(),
+            e.to_be(),
+            f.to_be(),
+            g.to_be(),
+            h.to_be(),
+        ];
+        Ipv6Addr {
+            inner: c::in6_addr {
+                s6_addr: unsafe { transmute::<_, [u8; 16]>(addr16) },
+            },
+        }
+    }
+    pub const LOCALHOST: Self = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1);
+    pub const UNSPECIFIED: Self = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0);
+    pub const fn segments(&self) -> [u16; 8] {
+        let [a, b, c, d, e, f, g, h] = unsafe {
+            transmute::<_, [u16; 8]>(self.inner.s6_addr)
+        };
+        [
+            u16::from_be(a),
+            u16::from_be(b),
+            u16::from_be(c),
+            u16::from_be(d),
+            u16::from_be(e),
+            u16::from_be(f),
+            u16::from_be(g),
+            u16::from_be(h),
+        ]
+    }
+    pub const fn is_unspecified(&self) -> bool {
+        u128::from_be_bytes(self.octets())
+            == u128::from_be_bytes(Ipv6Addr::UNSPECIFIED.octets())
+    }
+    pub const fn is_loopback(&self) -> bool {
+        u128::from_be_bytes(self.octets())
+            == u128::from_be_bytes(Ipv6Addr::LOCALHOST.octets())
+    }
+    pub const fn is_global(&self) -> bool {
+        match self.multicast_scope() {
+            Some(Ipv6MulticastScope::Global) => true,
+            None => self.is_unicast_global(),
+            _ => false,
+        }
+    }
+    pub const fn is_unique_local(&self) -> bool {
+        (self.segments()[0] & 0xfe00) == 0xfc00
+    }
+    pub const fn is_unicast(&self) -> bool {
+        !self.is_multicast()
+    }
+    pub const fn is_unicast_link_local(&self) -> bool {
+        (self.segments()[0] & 0xffc0) == 0xfe80
+    }
+    pub const fn is_documentation(&self) -> bool {
+        (self.segments()[0] == 0x2001) && (self.segments()[1] == 0xdb8)
+    }
+    pub const fn is_benchmarking(&self) -> bool {
+        (self.segments()[0] == 0x2001) && (self.segments()[1] == 0x2)
+            && (self.segments()[2] == 0)
+    }
+    pub const fn is_unicast_global(&self) -> bool {
+        self.is_unicast() && !self.is_loopback() && !self.is_unicast_link_local()
+            && !self.is_unique_local() && !self.is_unspecified()
+            && !self.is_documentation()
+    }
+    pub const fn multicast_scope(&self) -> Option<Ipv6MulticastScope> {
+        if self.is_multicast() {
+            match self.segments()[0] & 0x000f {
+                1 => Some(Ipv6MulticastScope::InterfaceLocal),
+                2 => Some(Ipv6MulticastScope::LinkLocal),
+                3 => Some(Ipv6MulticastScope::RealmLocal),
+                4 => Some(Ipv6MulticastScope::AdminLocal),
+                5 => Some(Ipv6MulticastScope::SiteLocal),
+                8 => Some(Ipv6MulticastScope::OrganizationLocal),
+                14 => Some(Ipv6MulticastScope::Global),
+                _ => None,
+            }
+        } else {
+            None
+        }
+    }
+    pub const fn is_multicast(&self) -> bool {
+        (self.segments()[0] & 0xff00) == 0xff00
+    }
+    pub const fn to_ipv4_mapped(&self) -> Option<Ipv4Addr> {
+        match self.octets() {
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, a, b, c, d] => {
+                Some(Ipv4Addr::new(a, b, c, d))
+            }
+            _ => None,
+        }
+    }
+    pub const fn to_ipv4(&self) -> Option<Ipv4Addr> {
+        if let [0, 0, 0, 0, 0, 0 | 0xffff, ab, cd] = self.segments() {
+            let [a, b] = ab.to_be_bytes();
+            let [c, d] = cd.to_be_bytes();
+            Some(Ipv4Addr::new(a, b, c, d))
+        } else {
+            None
+        }
+    }
+    pub const fn to_canonical(&self) -> IpAddr {
+        if let Some(mapped) = self.to_ipv4_mapped() {
+            return IpAddr::V4(mapped);
+        }
+        IpAddr::V6(*self)
+    }
+    pub const fn octets(&self) -> [u8; 16] {
+        self.inner.s6_addr
+    }
+}
+impl fmt::Display for Ipv6Addr {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if f.precision().is_none() && f.width().is_none() {
+            let segments = self.segments();
+            if self.is_unspecified() {
+                f.write_str("::")
+            } else if self.is_loopback() {
+                f.write_str("::1")
+            } else if let Some(ipv4) = self.to_ipv4() {
+                match segments[5] {
+                    0 => write!(f, "::{}", ipv4),
+                    0xffff => write!(f, "::ffff:{}", ipv4),
+                    _ => unreachable!(),
+                }
+            } else {
+                #[derive(Copy, Clone, Default)]
+                struct Span {
+                    start: usize,
+                    len: usize,
+                }
+                let zeroes = {
+                    let mut longest = Span::default();
+                    let mut current = Span::default();
+                    for (i, &segment) in segments.iter().enumerate() {
+                        if segment == 0 {
+                            if current.len == 0 {
+                                current.start = i;
+                            }
+                            current.len += 1;
+                            if current.len > longest.len {
+                                longest = current;
+                            }
+                        } else {
+                            current = Span::default();
+                        }
+                    }
+                    longest
+                };
+                /// Write a colon-separated part of the address
+                #[inline]
+                fn fmt_subslice(
+                    f: &mut fmt::Formatter<'_>,
+                    chunk: &[u16],
+                ) -> fmt::Result {
+                    if let Some((first, tail)) = chunk.split_first() {
+                        write!(f, "{:x}", first)?;
+                        for segment in tail {
+                            f.write_char(':')?;
+                            write!(f, "{:x}", segment)?;
+                        }
+                    }
+                    Ok(())
+                }
+                if zeroes.len > 1 {
+                    fmt_subslice(f, &segments[..zeroes.start])?;
+                    f.write_str("::")?;
+                    fmt_subslice(f, &segments[zeroes.start + zeroes.len..])
+                } else {
+                    fmt_subslice(f, &segments)
+                }
+            }
+        } else {
+            const IPV6_BUF_LEN: usize = (4 * 8) + 7;
+            let mut buf = [0u8; IPV6_BUF_LEN];
+            let mut buf_slice = &mut buf[..];
+            write!(buf_slice, "{}", self).unwrap();
+            let len = IPV6_BUF_LEN - buf_slice.len();
+            let buf = unsafe { crate::str::from_utf8_unchecked(&buf[..len]) };
+            f.pad(buf)
+        }
+    }
+}
+impl fmt::Debug for Ipv6Addr {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(self, fmt)
+    }
+}
+impl Clone for Ipv6Addr {
+    fn clone(&self) -> Ipv6Addr {
+        *self
+    }
+}
+impl PartialEq for Ipv6Addr {
+    fn eq(&self, other: &Ipv6Addr) -> bool {
+        self.inner.s6_addr == other.inner.s6_addr
+    }
+}
+impl PartialEq<IpAddr> for Ipv6Addr {
+    fn eq(&self, other: &IpAddr) -> bool {
+        match other {
+            IpAddr::V4(_) => false,
+            IpAddr::V6(v6) => self == v6,
+        }
+    }
+}
+impl PartialEq<Ipv6Addr> for IpAddr {
+    fn eq(&self, other: &Ipv6Addr) -> bool {
+        match self {
+            IpAddr::V4(_) => false,
+            IpAddr::V6(v6) => v6 == other,
+        }
+    }
+}
+impl Eq for Ipv6Addr {}
+impl hash::Hash for Ipv6Addr {
+    fn hash<H: hash::Hasher>(&self, s: &mut H) {
+        self.inner.s6_addr.hash(s)
+    }
+}
+impl PartialOrd for Ipv6Addr {
+    fn partial_cmp(&self, other: &Ipv6Addr) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+impl PartialOrd<Ipv6Addr> for IpAddr {
+    fn partial_cmp(&self, other: &Ipv6Addr) -> Option<Ordering> {
+        match self {
+            IpAddr::V4(_) => Some(Ordering::Less),
+            IpAddr::V6(v6) => v6.partial_cmp(other),
+        }
+    }
+}
+impl PartialOrd<IpAddr> for Ipv6Addr {
+    fn partial_cmp(&self, other: &IpAddr) -> Option<Ordering> {
+        match other {
+            IpAddr::V4(_) => Some(Ordering::Greater),
+            IpAddr::V6(v6) => self.partial_cmp(v6),
+        }
+    }
+}
+impl Ord for Ipv6Addr {
+    fn cmp(&self, other: &Ipv6Addr) -> Ordering {
+        self.segments().cmp(&other.segments())
+    }
+}
+impl AsInner<c::in6_addr> for Ipv6Addr {
+    fn as_inner(&self) -> &c::in6_addr {
+        &self.inner
+    }
+}
+impl FromInner<c::in6_addr> for Ipv6Addr {
+    fn from_inner(addr: c::in6_addr) -> Ipv6Addr {
+        Ipv6Addr { inner: addr }
+    }
+}
+impl From<Ipv6Addr> for u128 {
+    fn from(ip: Ipv6Addr) -> u128 {
+        let ip = ip.octets();
+        u128::from_be_bytes(ip)
+    }
+}
+impl From<u128> for Ipv6Addr {
+    fn from(ip: u128) -> Ipv6Addr {
+        Ipv6Addr::from(ip.to_be_bytes())
+    }
+}
+impl From<[u8; 16]> for Ipv6Addr {
+    fn from(octets: [u8; 16]) -> Ipv6Addr {
+        let inner = c::in6_addr { s6_addr: octets };
+        Ipv6Addr::from_inner(inner)
+    }
+}
+impl From<[u16; 8]> for Ipv6Addr {
+    fn from(segments: [u16; 8]) -> Ipv6Addr {
+        let [a, b, c, d, e, f, g, h] = segments;
+        Ipv6Addr::new(a, b, c, d, e, f, g, h)
+    }
+}
+impl From<[u8; 16]> for IpAddr {
+    fn from(octets: [u8; 16]) -> IpAddr {
+        IpAddr::V6(Ipv6Addr::from(octets))
+    }
+}
+impl From<[u16; 8]> for IpAddr {
+    fn from(segments: [u16; 8]) -> IpAddr {
+        IpAddr::V6(Ipv6Addr::from(segments))
+    }
+}
diff --git a/crates/prettyplease/examples/output.rustc.rs b/crates/prettyplease/examples/output.rustc.rs
new file mode 100644
index 0000000..609a8c3
--- /dev/null
+++ b/crates/prettyplease/examples/output.rustc.rs
@@ -0,0 +1,508 @@
+use crate::cmp::Ordering;use crate::fmt::{self, Write as FmtWrite};
+use crate::hash;
+use crate::io::Write as IoWrite;
+use crate::mem::transmute;
+use crate::sys::net::netc as c;
+use crate::sys_common::{AsInner, FromInner, IntoInner};
+#[derive(Copy, Clone, Eq, PartialEq, Hash, PartialOrd, Ord)]
+pub enum IpAddr { V4(Ipv4Addr), V6(Ipv6Addr), }
+#[derive(Copy)]
+pub struct Ipv4Addr {
+    inner: c::in_addr,
+}
+#[derive(Copy)]
+pub struct Ipv6Addr {
+    inner: c::in6_addr,
+}
+#[derive(Copy, PartialEq, Eq, Clone, Hash, Debug)]
+#[non_exhaustive]
+pub enum Ipv6MulticastScope {
+    InterfaceLocal,
+    LinkLocal,
+    RealmLocal,
+    AdminLocal,
+    SiteLocal,
+    OrganizationLocal,
+    Global,
+}
+impl IpAddr {
+    pub const fn is_unspecified(&self) -> bool {
+        match self {
+            IpAddr::V4(ip) => ip.is_unspecified(),
+            IpAddr::V6(ip) => ip.is_unspecified(),
+        }
+    }
+    pub const fn is_loopback(&self) -> bool {
+        match self {
+            IpAddr::V4(ip) => ip.is_loopback(),
+            IpAddr::V6(ip) => ip.is_loopback(),
+        }
+    }
+    pub const fn is_global(&self) -> bool {
+        match self {
+            IpAddr::V4(ip) => ip.is_global(),
+            IpAddr::V6(ip) => ip.is_global(),
+        }
+    }
+    pub const fn is_multicast(&self) -> bool {
+        match self {
+            IpAddr::V4(ip) => ip.is_multicast(),
+            IpAddr::V6(ip) => ip.is_multicast(),
+        }
+    }
+    pub const fn is_documentation(&self) -> bool {
+        match self {
+            IpAddr::V4(ip) => ip.is_documentation(),
+            IpAddr::V6(ip) => ip.is_documentation(),
+        }
+    }
+    pub const fn is_benchmarking(&self) -> bool {
+        match self {
+            IpAddr::V4(ip) => ip.is_benchmarking(),
+            IpAddr::V6(ip) => ip.is_benchmarking(),
+        }
+    }
+    pub const fn is_ipv4(&self) -> bool { matches!(self, IpAddr :: V4(_)) }
+    pub const fn is_ipv6(&self) -> bool { matches!(self, IpAddr :: V6(_)) }
+    pub const fn to_canonical(&self) -> IpAddr {
+        match self {
+            &v4 @ IpAddr::V4(_) => v4,
+            IpAddr::V6(v6) => v6.to_canonical(),
+        }
+    }
+}
+impl Ipv4Addr {
+    pub const fn new(a: u8, b: u8, c: u8, d: u8) -> Ipv4Addr {
+        Ipv4Addr {
+            inner: c::in_addr { s_addr: u32::from_ne_bytes([a, b, c, d]) },
+        }
+    }
+    pub const LOCALHOST: Self = Ipv4Addr::new(127, 0, 0, 1);
+    #[doc(alias = "INADDR_ANY")]
+    pub const UNSPECIFIED: Self = Ipv4Addr::new(0, 0, 0, 0);
+    pub const BROADCAST: Self = Ipv4Addr::new(255, 255, 255, 255);
+    pub const fn octets(&self) -> [u8; 4] { self.inner.s_addr.to_ne_bytes() }
+    pub const fn is_unspecified(&self) -> bool { self.inner.s_addr == 0 }
+    pub const fn is_loopback(&self) -> bool { self.octets()[0] == 127 }
+    pub const fn is_private(&self) -> bool {
+        match self.octets() {
+            [10, ..] => true,
+            [172, b, ..] if b >= 16 && b <= 31 => true,
+            [192, 168, ..] => true,
+            _ => false,
+        }
+    }
+    pub const fn is_link_local(&self) -> bool {
+        matches!(self.octets(), [169, 254, ..])
+    }
+    pub const fn is_global(&self) -> bool {
+        if u32::from_be_bytes(self.octets()) == 0xc0000009 ||
+                    u32::from_be_bytes(self.octets()) == 0xc000000a {
+                return true;
+            }
+        !self.is_private() && !self.is_loopback() && !self.is_link_local() &&
+                                    !self.is_broadcast() && !self.is_documentation() &&
+                            !self.is_shared() &&
+                        !(self.octets()[0] == 192 && self.octets()[1] == 0 &&
+                                    self.octets()[2] == 0) && !self.is_reserved() &&
+                !self.is_benchmarking() && self.octets()[0] != 0
+    }
+    pub const fn is_shared(&self) -> bool {
+        self.octets()[0] == 100 &&
+            (self.octets()[1] & 0b1100_0000 == 0b0100_0000)
+    }
+    pub const fn is_benchmarking(&self) -> bool {
+        self.octets()[0] == 198 && (self.octets()[1] & 0xfe) == 18
+    }
+    pub const fn is_reserved(&self) -> bool {
+        self.octets()[0] & 240 == 240 && !self.is_broadcast()
+    }
+    pub const fn is_multicast(&self) -> bool {
+        self.octets()[0] >= 224 && self.octets()[0] <= 239
+    }
+    pub const fn is_broadcast(&self) -> bool {
+        u32::from_be_bytes(self.octets()) ==
+            u32::from_be_bytes(Self::BROADCAST.octets())
+    }
+    pub const fn is_documentation(&self) -> bool {
+        matches!(self.octets(), [192, 0, 2, _] | [198, 51, 100, _] |
+            [203, 0, 113, _])
+    }
+    pub const fn to_ipv6_compatible(&self) -> Ipv6Addr {
+        let [a, b, c, d] = self.octets();
+        Ipv6Addr {
+            inner: c::in6_addr {
+                s6_addr: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, a, b, c, d],
+            },
+        }
+    }
+    pub const fn to_ipv6_mapped(&self) -> Ipv6Addr {
+        let [a, b, c, d] = self.octets();
+        Ipv6Addr {
+            inner: c::in6_addr {
+                s6_addr: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF, a, b, c,
+                        d],
+            },
+        }
+    }
+}
+impl fmt::Display for IpAddr {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            IpAddr::V4(ip) => ip.fmt(fmt),
+            IpAddr::V6(ip) => ip.fmt(fmt),
+        }
+    }
+}
+impl fmt::Debug for IpAddr {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(self, fmt)
+    }
+}
+impl From<Ipv4Addr> for IpAddr {
+    fn from(ipv4: Ipv4Addr) -> IpAddr { IpAddr::V4(ipv4) }
+}
+impl From<Ipv6Addr> for IpAddr {
+    fn from(ipv6: Ipv6Addr) -> IpAddr { IpAddr::V6(ipv6) }
+}
+impl fmt::Display for Ipv4Addr {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let octets = self.octets();
+        if fmt.precision().is_none() && fmt.width().is_none() {
+                write!(fmt, "{}.{}.{}.{}", octets [0], octets [1], octets [2],
+                    octets [3])
+            } else {
+               const IPV4_BUF_LEN: usize = 15;
+               let mut buf = [0u8; IPV4_BUF_LEN];
+               let mut buf_slice = &mut buf[..];
+               write!(buf_slice, "{}.{}.{}.{}", octets [0], octets [1], octets
+                       [2], octets [3]).unwrap();
+               let len = IPV4_BUF_LEN - buf_slice.len();
+               let buf =
+                   unsafe { crate::str::from_utf8_unchecked(&buf[..len]) };
+               fmt.pad(buf)
+           }
+    }
+}
+impl fmt::Debug for Ipv4Addr {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(self, fmt)
+    }
+}
+impl Clone for Ipv4Addr {
+    fn clone(&self) -> Ipv4Addr { *self }
+}
+impl PartialEq for Ipv4Addr {
+    fn eq(&self, other: &Ipv4Addr) -> bool {
+        self.inner.s_addr == other.inner.s_addr
+    }
+}
+impl PartialEq<Ipv4Addr> for IpAddr {
+    fn eq(&self, other: &Ipv4Addr) -> bool {
+        match self { IpAddr::V4(v4) => v4 == other, IpAddr::V6(_) => false, }
+    }
+}
+impl PartialEq<IpAddr> for Ipv4Addr {
+    fn eq(&self, other: &IpAddr) -> bool {
+        match other { IpAddr::V4(v4) => self == v4, IpAddr::V6(_) => false, }
+    }
+}
+impl Eq for Ipv4Addr {}
+impl hash::Hash for Ipv4Addr {
+    fn hash<H: hash::Hasher>(&self, s: &mut H) {
+        { self.inner.s_addr }.hash(s)
+    }
+}
+impl PartialOrd for Ipv4Addr {
+    fn partial_cmp(&self, other: &Ipv4Addr) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+impl PartialOrd<Ipv4Addr> for IpAddr {
+    fn partial_cmp(&self, other: &Ipv4Addr) -> Option<Ordering> {
+        match self {
+            IpAddr::V4(v4) => v4.partial_cmp(other),
+            IpAddr::V6(_) => Some(Ordering::Greater),
+        }
+    }
+}
+impl PartialOrd<IpAddr> for Ipv4Addr {
+    fn partial_cmp(&self, other: &IpAddr) -> Option<Ordering> {
+        match other {
+            IpAddr::V4(v4) => self.partial_cmp(v4),
+            IpAddr::V6(_) => Some(Ordering::Less),
+        }
+    }
+}
+impl Ord for Ipv4Addr {
+    fn cmp(&self, other: &Ipv4Addr) -> Ordering {
+        u32::from_be(self.inner.s_addr).cmp(&u32::from_be(other.inner.s_addr))
+    }
+}
+impl IntoInner<c::in_addr> for Ipv4Addr {
+    fn into_inner(self) -> c::in_addr { self.inner }
+}
+impl From<Ipv4Addr> for u32 {
+    fn from(ip: Ipv4Addr) -> u32 {
+        let ip = ip.octets();
+        u32::from_be_bytes(ip)
+    }
+}
+impl From<u32> for Ipv4Addr {
+    fn from(ip: u32) -> Ipv4Addr { Ipv4Addr::from(ip.to_be_bytes()) }
+}
+impl From<[u8; 4]> for Ipv4Addr {
+    fn from(octets: [u8; 4]) -> Ipv4Addr {
+        Ipv4Addr::new(octets[0], octets[1], octets[2], octets[3])
+    }
+}
+impl From<[u8; 4]> for IpAddr {
+    fn from(octets: [u8; 4]) -> IpAddr { IpAddr::V4(Ipv4Addr::from(octets)) }
+}
+impl Ipv6Addr {
+    pub const fn new(a: u16, b: u16, c: u16, d: u16, e: u16, f: u16, g: u16,
+        h: u16) -> Ipv6Addr {
+        let addr16 =
+            [a.to_be(), b.to_be(), c.to_be(), d.to_be(), e.to_be(), f.to_be(),
+                    g.to_be(), h.to_be()];
+        Ipv6Addr {
+            inner: c::in6_addr {
+                s6_addr: unsafe { transmute::<_, [u8; 16]>(addr16) },
+            },
+        }
+    }
+    pub const LOCALHOST: Self = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1);
+    pub const UNSPECIFIED: Self = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0);
+    pub const fn segments(&self) -> [u16; 8] {
+        let [a, b, c, d, e, f, g, h] =
+            unsafe { transmute::<_, [u16; 8]>(self.inner.s6_addr) };
+        [u16::from_be(a), u16::from_be(b), u16::from_be(c), u16::from_be(d),
+                u16::from_be(e), u16::from_be(f), u16::from_be(g),
+                u16::from_be(h)]
+    }
+    pub const fn is_unspecified(&self) -> bool {
+        u128::from_be_bytes(self.octets()) ==
+            u128::from_be_bytes(Ipv6Addr::UNSPECIFIED.octets())
+    }
+    pub const fn is_loopback(&self) -> bool {
+        u128::from_be_bytes(self.octets()) ==
+            u128::from_be_bytes(Ipv6Addr::LOCALHOST.octets())
+    }
+    pub const fn is_global(&self) -> bool {
+        match self.multicast_scope() {
+            Some(Ipv6MulticastScope::Global) => true,
+            None => self.is_unicast_global(),
+            _ => false,
+        }
+    }
+    pub const fn is_unique_local(&self) -> bool {
+        (self.segments()[0] & 0xfe00) == 0xfc00
+    }
+    pub const fn is_unicast(&self) -> bool { !self.is_multicast() }
+    pub const fn is_unicast_link_local(&self) -> bool {
+        (self.segments()[0] & 0xffc0) == 0xfe80
+    }
+    pub const fn is_documentation(&self) -> bool {
+        (self.segments()[0] == 0x2001) && (self.segments()[1] == 0xdb8)
+    }
+    pub const fn is_benchmarking(&self) -> bool {
+        (self.segments()[0] == 0x2001) && (self.segments()[1] == 0x2) &&
+            (self.segments()[2] == 0)
+    }
+    pub const fn is_unicast_global(&self) -> bool {
+        self.is_unicast() && !self.is_loopback() &&
+                        !self.is_unicast_link_local() && !self.is_unique_local() &&
+                !self.is_unspecified() && !self.is_documentation()
+    }
+    pub const fn multicast_scope(&self) -> Option<Ipv6MulticastScope> {
+        if self.is_multicast() {
+                match self.segments()[0] & 0x000f {
+                    1 => Some(Ipv6MulticastScope::InterfaceLocal),
+                    2 => Some(Ipv6MulticastScope::LinkLocal),
+                    3 => Some(Ipv6MulticastScope::RealmLocal),
+                    4 => Some(Ipv6MulticastScope::AdminLocal),
+                    5 => Some(Ipv6MulticastScope::SiteLocal),
+                    8 => Some(Ipv6MulticastScope::OrganizationLocal),
+                    14 => Some(Ipv6MulticastScope::Global),
+                    _ => None,
+                }
+            } else { None }
+    }
+    pub const fn is_multicast(&self) -> bool {
+        (self.segments()[0] & 0xff00) == 0xff00
+    }
+    pub const fn to_ipv4_mapped(&self) -> Option<Ipv4Addr> {
+        match self.octets() {
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, a, b, c, d] => {
+                Some(Ipv4Addr::new(a, b, c, d))
+            }
+            _ => None,
+        }
+    }
+    pub const fn to_ipv4(&self) -> Option<Ipv4Addr> {
+        if let [0, 0, 0, 0, 0, 0 | 0xffff, ab, cd] = self.segments() {
+                let [a, b] = ab.to_be_bytes();
+                let [c, d] = cd.to_be_bytes();
+                Some(Ipv4Addr::new(a, b, c, d))
+            } else { None }
+    }
+    pub const fn to_canonical(&self) -> IpAddr {
+        if let Some(mapped) = self.to_ipv4_mapped() {
+                return IpAddr::V4(mapped);
+            }
+        IpAddr::V6(*self)
+    }
+    pub const fn octets(&self) -> [u8; 16] { self.inner.s6_addr }
+}
+impl fmt::Display for Ipv6Addr {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if f.precision().is_none() && f.width().is_none() {
+                let segments = self.segments();
+                if self.is_unspecified() {
+                        f.write_str("::")
+                    } else if self.is_loopback() {
+                       f.write_str("::1")
+                   } else if let Some(ipv4) = self.to_ipv4() {
+                       match segments[5] {
+                           0 => write!(f, "::{}", ipv4),
+                           0xffff => write!(f, "::ffff:{}", ipv4),
+                           _ => unreachable!(),
+                       }
+                   } else {
+                       #[derive(Copy, Clone, Default)]
+                       struct Span {
+                           start: usize,
+                           len: usize,
+                       }
+                       let zeroes =
+                           {
+                               let mut longest = Span::default();
+                               let mut current = Span::default();
+                               for (i, &segment) in segments.iter().enumerate() {
+                                   if segment == 0 {
+                                           if current.len == 0 { current.start = i; }
+                                           current.len += 1;
+                                           if current.len > longest.len { longest = current; }
+                                       } else { current = Span::default(); }
+                               }
+                               longest
+                           };
+                       #[doc = " Write a colon-separated part of the address"]
+                       #[inline]
+                       fn fmt_subslice(f: &mut fmt::Formatter<'_>, chunk: &[u16])
+                           -> fmt::Result {
+                           if let Some((first, tail)) = chunk.split_first() {
+                                   write!(f, "{:x}", first)?;
+                                   for segment in tail {
+                                       f.write_char(':')?;
+                                       write!(f, "{:x}", segment)?;
+                                   }
+                               }
+                           Ok(())
+                       }
+                       if zeroes.len > 1 {
+                               fmt_subslice(f, &segments[..zeroes.start])?;
+                               f.write_str("::")?;
+                               fmt_subslice(f, &segments[zeroes.start + zeroes.len..])
+                           } else { fmt_subslice(f, &segments) }
+                   }
+            } else {
+               const IPV6_BUF_LEN: usize = (4 * 8) + 7;
+               let mut buf = [0u8; IPV6_BUF_LEN];
+               let mut buf_slice = &mut buf[..];
+               write!(buf_slice, "{}", self).unwrap();
+               let len = IPV6_BUF_LEN - buf_slice.len();
+               let buf =
+                   unsafe { crate::str::from_utf8_unchecked(&buf[..len]) };
+               f.pad(buf)
+           }
+    }
+}
+impl fmt::Debug for Ipv6Addr {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(self, fmt)
+    }
+}
+impl Clone for Ipv6Addr {
+    fn clone(&self) -> Ipv6Addr { *self }
+}
+impl PartialEq for Ipv6Addr {
+    fn eq(&self, other: &Ipv6Addr) -> bool {
+        self.inner.s6_addr == other.inner.s6_addr
+    }
+}
+impl PartialEq<IpAddr> for Ipv6Addr {
+    fn eq(&self, other: &IpAddr) -> bool {
+        match other { IpAddr::V4(_) => false, IpAddr::V6(v6) => self == v6, }
+    }
+}
+impl PartialEq<Ipv6Addr> for IpAddr {
+    fn eq(&self, other: &Ipv6Addr) -> bool {
+        match self { IpAddr::V4(_) => false, IpAddr::V6(v6) => v6 == other, }
+    }
+}
+impl Eq for Ipv6Addr {}
+impl hash::Hash for Ipv6Addr {
+    fn hash<H: hash::Hasher>(&self, s: &mut H) { self.inner.s6_addr.hash(s) }
+}
+impl PartialOrd for Ipv6Addr {
+    fn partial_cmp(&self, other: &Ipv6Addr) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+impl PartialOrd<Ipv6Addr> for IpAddr {
+    fn partial_cmp(&self, other: &Ipv6Addr) -> Option<Ordering> {
+        match self {
+            IpAddr::V4(_) => Some(Ordering::Less),
+            IpAddr::V6(v6) => v6.partial_cmp(other),
+        }
+    }
+}
+impl PartialOrd<IpAddr> for Ipv6Addr {
+    fn partial_cmp(&self, other: &IpAddr) -> Option<Ordering> {
+        match other {
+            IpAddr::V4(_) => Some(Ordering::Greater),
+            IpAddr::V6(v6) => self.partial_cmp(v6),
+        }
+    }
+}
+impl Ord for Ipv6Addr {
+    fn cmp(&self, other: &Ipv6Addr) -> Ordering {
+        self.segments().cmp(&other.segments())
+    }
+}
+impl AsInner<c::in6_addr> for Ipv6Addr {
+    fn as_inner(&self) -> &c::in6_addr { &self.inner }
+}
+impl FromInner<c::in6_addr> for Ipv6Addr {
+    fn from_inner(addr: c::in6_addr) -> Ipv6Addr { Ipv6Addr { inner: addr } }
+}
+impl From<Ipv6Addr> for u128 {
+    fn from(ip: Ipv6Addr) -> u128 {
+        let ip = ip.octets();
+        u128::from_be_bytes(ip)
+    }
+}
+impl From<u128> for Ipv6Addr {
+    fn from(ip: u128) -> Ipv6Addr { Ipv6Addr::from(ip.to_be_bytes()) }
+}
+impl From<[u8; 16]> for Ipv6Addr {
+    fn from(octets: [u8; 16]) -> Ipv6Addr {
+        let inner = c::in6_addr { s6_addr: octets };
+        Ipv6Addr::from_inner(inner)
+    }
+}
+impl From<[u16; 8]> for Ipv6Addr {
+    fn from(segments: [u16; 8]) -> Ipv6Addr {
+        let [a, b, c, d, e, f, g, h] = segments;
+        Ipv6Addr::new(a, b, c, d, e, f, g, h)
+    }
+}
+impl From<[u8; 16]> for IpAddr {
+    fn from(octets: [u8; 16]) -> IpAddr { IpAddr::V6(Ipv6Addr::from(octets)) }
+}
+impl From<[u16; 8]> for IpAddr {
+    fn from(segments: [u16; 8]) -> IpAddr {
+        IpAddr::V6(Ipv6Addr::from(segments))
+    }
+}
diff --git a/crates/prettyplease/examples/output.rustfmt.rs b/crates/prettyplease/examples/output.rustfmt.rs
new file mode 100644
index 0000000..3c7181d
--- /dev/null
+++ b/crates/prettyplease/examples/output.rustfmt.rs
@@ -0,0 +1,552 @@
+use crate::cmp::Ordering;
+use crate::fmt::{self, Write as FmtWrite};
+use crate::hash;
+use crate::io::Write as IoWrite;
+use crate::mem::transmute;
+use crate::sys::net::netc as c;
+use crate::sys_common::{AsInner, FromInner, IntoInner};
+#[derive(Copy, Clone, Eq, PartialEq, Hash, PartialOrd, Ord)]
+pub enum IpAddr {
+    V4(Ipv4Addr),
+    V6(Ipv6Addr),
+}
+#[derive(Copy)]
+pub struct Ipv4Addr {
+    inner: c::in_addr,
+}
+#[derive(Copy)]
+pub struct Ipv6Addr {
+    inner: c::in6_addr,
+}
+#[derive(Copy, PartialEq, Eq, Clone, Hash, Debug)]
+#[non_exhaustive]
+pub enum Ipv6MulticastScope {
+    InterfaceLocal,
+    LinkLocal,
+    RealmLocal,
+    AdminLocal,
+    SiteLocal,
+    OrganizationLocal,
+    Global,
+}
+impl IpAddr {
+    pub const fn is_unspecified(&self) -> bool {
+        match self {
+            IpAddr::V4(ip) => ip.is_unspecified(),
+            IpAddr::V6(ip) => ip.is_unspecified(),
+        }
+    }
+    pub const fn is_loopback(&self) -> bool {
+        match self {
+            IpAddr::V4(ip) => ip.is_loopback(),
+            IpAddr::V6(ip) => ip.is_loopback(),
+        }
+    }
+    pub const fn is_global(&self) -> bool {
+        match self {
+            IpAddr::V4(ip) => ip.is_global(),
+            IpAddr::V6(ip) => ip.is_global(),
+        }
+    }
+    pub const fn is_multicast(&self) -> bool {
+        match self {
+            IpAddr::V4(ip) => ip.is_multicast(),
+            IpAddr::V6(ip) => ip.is_multicast(),
+        }
+    }
+    pub const fn is_documentation(&self) -> bool {
+        match self {
+            IpAddr::V4(ip) => ip.is_documentation(),
+            IpAddr::V6(ip) => ip.is_documentation(),
+        }
+    }
+    pub const fn is_benchmarking(&self) -> bool {
+        match self {
+            IpAddr::V4(ip) => ip.is_benchmarking(),
+            IpAddr::V6(ip) => ip.is_benchmarking(),
+        }
+    }
+    pub const fn is_ipv4(&self) -> bool {
+        matches!(self, IpAddr::V4(_))
+    }
+    pub const fn is_ipv6(&self) -> bool {
+        matches!(self, IpAddr::V6(_))
+    }
+    pub const fn to_canonical(&self) -> IpAddr {
+        match self {
+            &v4 @ IpAddr::V4(_) => v4,
+            IpAddr::V6(v6) => v6.to_canonical(),
+        }
+    }
+}
+impl Ipv4Addr {
+    pub const fn new(a: u8, b: u8, c: u8, d: u8) -> Ipv4Addr {
+        Ipv4Addr {
+            inner: c::in_addr {
+                s_addr: u32::from_ne_bytes([a, b, c, d]),
+            },
+        }
+    }
+    pub const LOCALHOST: Self = Ipv4Addr::new(127, 0, 0, 1);
+    #[doc(alias = "INADDR_ANY")]
+    pub const UNSPECIFIED: Self = Ipv4Addr::new(0, 0, 0, 0);
+    pub const BROADCAST: Self = Ipv4Addr::new(255, 255, 255, 255);
+    pub const fn octets(&self) -> [u8; 4] {
+        self.inner.s_addr.to_ne_bytes()
+    }
+    pub const fn is_unspecified(&self) -> bool {
+        self.inner.s_addr == 0
+    }
+    pub const fn is_loopback(&self) -> bool {
+        self.octets()[0] == 127
+    }
+    pub const fn is_private(&self) -> bool {
+        match self.octets() {
+            [10, ..] => true,
+            [172, b, ..] if b >= 16 && b <= 31 => true,
+            [192, 168, ..] => true,
+            _ => false,
+        }
+    }
+    pub const fn is_link_local(&self) -> bool {
+        matches!(self.octets(), [169, 254, ..])
+    }
+    pub const fn is_global(&self) -> bool {
+        if u32::from_be_bytes(self.octets()) == 0xc0000009
+            || u32::from_be_bytes(self.octets()) == 0xc000000a
+        {
+            return true;
+        }
+        !self.is_private()
+            && !self.is_loopback()
+            && !self.is_link_local()
+            && !self.is_broadcast()
+            && !self.is_documentation()
+            && !self.is_shared()
+            && !(self.octets()[0] == 192 && self.octets()[1] == 0 && self.octets()[2] == 0)
+            && !self.is_reserved()
+            && !self.is_benchmarking()
+            && self.octets()[0] != 0
+    }
+    pub const fn is_shared(&self) -> bool {
+        self.octets()[0] == 100 && (self.octets()[1] & 0b1100_0000 == 0b0100_0000)
+    }
+    pub const fn is_benchmarking(&self) -> bool {
+        self.octets()[0] == 198 && (self.octets()[1] & 0xfe) == 18
+    }
+    pub const fn is_reserved(&self) -> bool {
+        self.octets()[0] & 240 == 240 && !self.is_broadcast()
+    }
+    pub const fn is_multicast(&self) -> bool {
+        self.octets()[0] >= 224 && self.octets()[0] <= 239
+    }
+    pub const fn is_broadcast(&self) -> bool {
+        u32::from_be_bytes(self.octets()) == u32::from_be_bytes(Self::BROADCAST.octets())
+    }
+    pub const fn is_documentation(&self) -> bool {
+        matches!(
+            self.octets(),
+            [192, 0, 2, _] | [198, 51, 100, _] | [203, 0, 113, _]
+        )
+    }
+    pub const fn to_ipv6_compatible(&self) -> Ipv6Addr {
+        let [a, b, c, d] = self.octets();
+        Ipv6Addr {
+            inner: c::in6_addr {
+                s6_addr: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, a, b, c, d],
+            },
+        }
+    }
+    pub const fn to_ipv6_mapped(&self) -> Ipv6Addr {
+        let [a, b, c, d] = self.octets();
+        Ipv6Addr {
+            inner: c::in6_addr {
+                s6_addr: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF, a, b, c, d],
+            },
+        }
+    }
+}
+impl fmt::Display for IpAddr {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            IpAddr::V4(ip) => ip.fmt(fmt),
+            IpAddr::V6(ip) => ip.fmt(fmt),
+        }
+    }
+}
+impl fmt::Debug for IpAddr {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(self, fmt)
+    }
+}
+impl From<Ipv4Addr> for IpAddr {
+    fn from(ipv4: Ipv4Addr) -> IpAddr {
+        IpAddr::V4(ipv4)
+    }
+}
+impl From<Ipv6Addr> for IpAddr {
+    fn from(ipv6: Ipv6Addr) -> IpAddr {
+        IpAddr::V6(ipv6)
+    }
+}
+impl fmt::Display for Ipv4Addr {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let octets = self.octets();
+        if fmt.precision().is_none() && fmt.width().is_none() {
+            write!(
+                fmt,
+                "{}.{}.{}.{}",
+                octets[0], octets[1], octets[2], octets[3]
+            )
+        } else {
+            const IPV4_BUF_LEN: usize = 15;
+            let mut buf = [0u8; IPV4_BUF_LEN];
+            let mut buf_slice = &mut buf[..];
+            write!(
+                buf_slice,
+                "{}.{}.{}.{}",
+                octets[0], octets[1], octets[2], octets[3]
+            )
+            .unwrap();
+            let len = IPV4_BUF_LEN - buf_slice.len();
+            let buf = unsafe { crate::str::from_utf8_unchecked(&buf[..len]) };
+            fmt.pad(buf)
+        }
+    }
+}
+impl fmt::Debug for Ipv4Addr {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(self, fmt)
+    }
+}
+impl Clone for Ipv4Addr {
+    fn clone(&self) -> Ipv4Addr {
+        *self
+    }
+}
+impl PartialEq for Ipv4Addr {
+    fn eq(&self, other: &Ipv4Addr) -> bool {
+        self.inner.s_addr == other.inner.s_addr
+    }
+}
+impl PartialEq<Ipv4Addr> for IpAddr {
+    fn eq(&self, other: &Ipv4Addr) -> bool {
+        match self {
+            IpAddr::V4(v4) => v4 == other,
+            IpAddr::V6(_) => false,
+        }
+    }
+}
+impl PartialEq<IpAddr> for Ipv4Addr {
+    fn eq(&self, other: &IpAddr) -> bool {
+        match other {
+            IpAddr::V4(v4) => self == v4,
+            IpAddr::V6(_) => false,
+        }
+    }
+}
+impl Eq for Ipv4Addr {}
+impl hash::Hash for Ipv4Addr {
+    fn hash<H: hash::Hasher>(&self, s: &mut H) {
+        { self.inner.s_addr }.hash(s)
+    }
+}
+impl PartialOrd for Ipv4Addr {
+    fn partial_cmp(&self, other: &Ipv4Addr) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+impl PartialOrd<Ipv4Addr> for IpAddr {
+    fn partial_cmp(&self, other: &Ipv4Addr) -> Option<Ordering> {
+        match self {
+            IpAddr::V4(v4) => v4.partial_cmp(other),
+            IpAddr::V6(_) => Some(Ordering::Greater),
+        }
+    }
+}
+impl PartialOrd<IpAddr> for Ipv4Addr {
+    fn partial_cmp(&self, other: &IpAddr) -> Option<Ordering> {
+        match other {
+            IpAddr::V4(v4) => self.partial_cmp(v4),
+            IpAddr::V6(_) => Some(Ordering::Less),
+        }
+    }
+}
+impl Ord for Ipv4Addr {
+    fn cmp(&self, other: &Ipv4Addr) -> Ordering {
+        u32::from_be(self.inner.s_addr).cmp(&u32::from_be(other.inner.s_addr))
+    }
+}
+impl IntoInner<c::in_addr> for Ipv4Addr {
+    fn into_inner(self) -> c::in_addr {
+        self.inner
+    }
+}
+impl From<Ipv4Addr> for u32 {
+    fn from(ip: Ipv4Addr) -> u32 {
+        let ip = ip.octets();
+        u32::from_be_bytes(ip)
+    }
+}
+impl From<u32> for Ipv4Addr {
+    fn from(ip: u32) -> Ipv4Addr {
+        Ipv4Addr::from(ip.to_be_bytes())
+    }
+}
+impl From<[u8; 4]> for Ipv4Addr {
+    fn from(octets: [u8; 4]) -> Ipv4Addr {
+        Ipv4Addr::new(octets[0], octets[1], octets[2], octets[3])
+    }
+}
+impl From<[u8; 4]> for IpAddr {
+    fn from(octets: [u8; 4]) -> IpAddr {
+        IpAddr::V4(Ipv4Addr::from(octets))
+    }
+}
+impl Ipv6Addr {
+    pub const fn new(a: u16, b: u16, c: u16, d: u16, e: u16, f: u16, g: u16, h: u16) -> Ipv6Addr {
+        let addr16 = [
+            a.to_be(),
+            b.to_be(),
+            c.to_be(),
+            d.to_be(),
+            e.to_be(),
+            f.to_be(),
+            g.to_be(),
+            h.to_be(),
+        ];
+        Ipv6Addr {
+            inner: c::in6_addr {
+                s6_addr: unsafe { transmute::<_, [u8; 16]>(addr16) },
+            },
+        }
+    }
+    pub const LOCALHOST: Self = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1);
+    pub const UNSPECIFIED: Self = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0);
+    pub const fn segments(&self) -> [u16; 8] {
+        let [a, b, c, d, e, f, g, h] = unsafe { transmute::<_, [u16; 8]>(self.inner.s6_addr) };
+        [
+            u16::from_be(a),
+            u16::from_be(b),
+            u16::from_be(c),
+            u16::from_be(d),
+            u16::from_be(e),
+            u16::from_be(f),
+            u16::from_be(g),
+            u16::from_be(h),
+        ]
+    }
+    pub const fn is_unspecified(&self) -> bool {
+        u128::from_be_bytes(self.octets()) == u128::from_be_bytes(Ipv6Addr::UNSPECIFIED.octets())
+    }
+    pub const fn is_loopback(&self) -> bool {
+        u128::from_be_bytes(self.octets()) == u128::from_be_bytes(Ipv6Addr::LOCALHOST.octets())
+    }
+    pub const fn is_global(&self) -> bool {
+        match self.multicast_scope() {
+            Some(Ipv6MulticastScope::Global) => true,
+            None => self.is_unicast_global(),
+            _ => false,
+        }
+    }
+    pub const fn is_unique_local(&self) -> bool {
+        (self.segments()[0] & 0xfe00) == 0xfc00
+    }
+    pub const fn is_unicast(&self) -> bool {
+        !self.is_multicast()
+    }
+    pub const fn is_unicast_link_local(&self) -> bool {
+        (self.segments()[0] & 0xffc0) == 0xfe80
+    }
+    pub const fn is_documentation(&self) -> bool {
+        (self.segments()[0] == 0x2001) && (self.segments()[1] == 0xdb8)
+    }
+    pub const fn is_benchmarking(&self) -> bool {
+        (self.segments()[0] == 0x2001) && (self.segments()[1] == 0x2) && (self.segments()[2] == 0)
+    }
+    pub const fn is_unicast_global(&self) -> bool {
+        self.is_unicast()
+            && !self.is_loopback()
+            && !self.is_unicast_link_local()
+            && !self.is_unique_local()
+            && !self.is_unspecified()
+            && !self.is_documentation()
+    }
+    pub const fn multicast_scope(&self) -> Option<Ipv6MulticastScope> {
+        if self.is_multicast() {
+            match self.segments()[0] & 0x000f {
+                1 => Some(Ipv6MulticastScope::InterfaceLocal),
+                2 => Some(Ipv6MulticastScope::LinkLocal),
+                3 => Some(Ipv6MulticastScope::RealmLocal),
+                4 => Some(Ipv6MulticastScope::AdminLocal),
+                5 => Some(Ipv6MulticastScope::SiteLocal),
+                8 => Some(Ipv6MulticastScope::OrganizationLocal),
+                14 => Some(Ipv6MulticastScope::Global),
+                _ => None,
+            }
+        } else {
+            None
+        }
+    }
+    pub const fn is_multicast(&self) -> bool {
+        (self.segments()[0] & 0xff00) == 0xff00
+    }
+    pub const fn to_ipv4_mapped(&self) -> Option<Ipv4Addr> {
+        match self.octets() {
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, a, b, c, d] => {
+                Some(Ipv4Addr::new(a, b, c, d))
+            }
+            _ => None,
+        }
+    }
+    pub const fn to_ipv4(&self) -> Option<Ipv4Addr> {
+        if let [0, 0, 0, 0, 0, 0 | 0xffff, ab, cd] = self.segments() {
+            let [a, b] = ab.to_be_bytes();
+            let [c, d] = cd.to_be_bytes();
+            Some(Ipv4Addr::new(a, b, c, d))
+        } else {
+            None
+        }
+    }
+    pub const fn to_canonical(&self) -> IpAddr {
+        if let Some(mapped) = self.to_ipv4_mapped() {
+            return IpAddr::V4(mapped);
+        }
+        IpAddr::V6(*self)
+    }
+    pub const fn octets(&self) -> [u8; 16] {
+        self.inner.s6_addr
+    }
+}
+impl fmt::Display for Ipv6Addr {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if f.precision().is_none() && f.width().is_none() {
+            let segments = self.segments();
+            if self.is_unspecified() {
+                f.write_str("::")
+            } else if self.is_loopback() {
+                f.write_str("::1")
+            } else if let Some(ipv4) = self.to_ipv4() {
+                match segments[5] {
+                    0 => write!(f, "::{}", ipv4),
+                    0xffff => write!(f, "::ffff:{}", ipv4),
+                    _ => unreachable!(),
+                }
+            } else { # [derive (Copy , Clone , Default)] struct Span { start : usize , len : usize , } let zeroes = { let mut longest = Span :: default () ; let mut current = Span :: default () ; for (i , & segment) in segments . iter () . enumerate () { if segment == 0 { if current . len == 0 { current . start = i ; } current . len += 1 ; if current . len > longest . len { longest = current ; } } else { current = Span :: default () ; } } longest } ; # [doc = " Write a colon-separated part of the address"] # [inline] fn fmt_subslice (f : & mut fmt :: Formatter < '_ > , chunk : & [u16]) -> fmt :: Result { if let Some ((first , tail)) = chunk . split_first () { write ! (f , "{:x}" , first) ? ; for segment in tail { f . write_char (':') ? ; write ! (f , "{:x}" , segment) ? ; } } Ok (()) } if zeroes . len > 1 { fmt_subslice (f , & segments [.. zeroes . start]) ? ; f . write_str ("::") ? ; fmt_subslice (f , & segments [zeroes . start + zeroes . len ..]) } else { fmt_subslice (f , & segments) } }
+        } else {
+            const IPV6_BUF_LEN: usize = (4 * 8) + 7;
+            let mut buf = [0u8; IPV6_BUF_LEN];
+            let mut buf_slice = &mut buf[..];
+            write!(buf_slice, "{}", self).unwrap();
+            let len = IPV6_BUF_LEN - buf_slice.len();
+            let buf = unsafe { crate::str::from_utf8_unchecked(&buf[..len]) };
+            f.pad(buf)
+        }
+    }
+}
+impl fmt::Debug for Ipv6Addr {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(self, fmt)
+    }
+}
+impl Clone for Ipv6Addr {
+    fn clone(&self) -> Ipv6Addr {
+        *self
+    }
+}
+impl PartialEq for Ipv6Addr {
+    fn eq(&self, other: &Ipv6Addr) -> bool {
+        self.inner.s6_addr == other.inner.s6_addr
+    }
+}
+impl PartialEq<IpAddr> for Ipv6Addr {
+    fn eq(&self, other: &IpAddr) -> bool {
+        match other {
+            IpAddr::V4(_) => false,
+            IpAddr::V6(v6) => self == v6,
+        }
+    }
+}
+impl PartialEq<Ipv6Addr> for IpAddr {
+    fn eq(&self, other: &Ipv6Addr) -> bool {
+        match self {
+            IpAddr::V4(_) => false,
+            IpAddr::V6(v6) => v6 == other,
+        }
+    }
+}
+impl Eq for Ipv6Addr {}
+impl hash::Hash for Ipv6Addr {
+    fn hash<H: hash::Hasher>(&self, s: &mut H) {
+        self.inner.s6_addr.hash(s)
+    }
+}
+impl PartialOrd for Ipv6Addr {
+    fn partial_cmp(&self, other: &Ipv6Addr) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+impl PartialOrd<Ipv6Addr> for IpAddr {
+    fn partial_cmp(&self, other: &Ipv6Addr) -> Option<Ordering> {
+        match self {
+            IpAddr::V4(_) => Some(Ordering::Less),
+            IpAddr::V6(v6) => v6.partial_cmp(other),
+        }
+    }
+}
+impl PartialOrd<IpAddr> for Ipv6Addr {
+    fn partial_cmp(&self, other: &IpAddr) -> Option<Ordering> {
+        match other {
+            IpAddr::V4(_) => Some(Ordering::Greater),
+            IpAddr::V6(v6) => self.partial_cmp(v6),
+        }
+    }
+}
+impl Ord for Ipv6Addr {
+    fn cmp(&self, other: &Ipv6Addr) -> Ordering {
+        self.segments().cmp(&other.segments())
+    }
+}
+impl AsInner<c::in6_addr> for Ipv6Addr {
+    fn as_inner(&self) -> &c::in6_addr {
+        &self.inner
+    }
+}
+impl FromInner<c::in6_addr> for Ipv6Addr {
+    fn from_inner(addr: c::in6_addr) -> Ipv6Addr {
+        Ipv6Addr { inner: addr }
+    }
+}
+impl From<Ipv6Addr> for u128 {
+    fn from(ip: Ipv6Addr) -> u128 {
+        let ip = ip.octets();
+        u128::from_be_bytes(ip)
+    }
+}
+impl From<u128> for Ipv6Addr {
+    fn from(ip: u128) -> Ipv6Addr {
+        Ipv6Addr::from(ip.to_be_bytes())
+    }
+}
+impl From<[u8; 16]> for Ipv6Addr {
+    fn from(octets: [u8; 16]) -> Ipv6Addr {
+        let inner = c::in6_addr { s6_addr: octets };
+        Ipv6Addr::from_inner(inner)
+    }
+}
+impl From<[u16; 8]> for Ipv6Addr {
+    fn from(segments: [u16; 8]) -> Ipv6Addr {
+        let [a, b, c, d, e, f, g, h] = segments;
+        Ipv6Addr::new(a, b, c, d, e, f, g, h)
+    }
+}
+impl From<[u8; 16]> for IpAddr {
+    fn from(octets: [u8; 16]) -> IpAddr {
+        IpAddr::V6(Ipv6Addr::from(octets))
+    }
+}
+impl From<[u16; 8]> for IpAddr {
+    fn from(segments: [u16; 8]) -> IpAddr {
+        IpAddr::V6(Ipv6Addr::from(segments))
+    }
+}
diff --git a/crates/prettyplease/src/algorithm.rs b/crates/prettyplease/src/algorithm.rs
new file mode 100644
index 0000000..6e2b961
--- /dev/null
+++ b/crates/prettyplease/src/algorithm.rs
@@ -0,0 +1,376 @@
+// Adapted from https://github.com/rust-lang/rust/blob/1.57.0/compiler/rustc_ast_pretty/src/pp.rs.
+// See "Algorithm notes" in the crate-level rustdoc.
+
+use crate::ring::RingBuffer;
+use crate::{MARGIN, MIN_SPACE};
+use std::borrow::Cow;
+use std::cmp;
+use std::collections::VecDeque;
+use std::iter;
+
+#[derive(Clone, Copy, PartialEq)]
+pub enum Breaks {
+    Consistent,
+    Inconsistent,
+}
+
+#[derive(Clone, Copy, Default)]
+pub struct BreakToken {
+    pub offset: isize,
+    pub blank_space: usize,
+    pub pre_break: Option<char>,
+    pub post_break: Option<char>,
+    pub no_break: Option<char>,
+    pub if_nonempty: bool,
+    pub never_break: bool,
+}
+
+#[derive(Clone, Copy)]
+pub struct BeginToken {
+    pub offset: isize,
+    pub breaks: Breaks,
+}
+
+#[derive(Clone)]
+pub enum Token {
+    String(Cow<'static, str>),
+    Break(BreakToken),
+    Begin(BeginToken),
+    End,
+}
+
+#[derive(Copy, Clone)]
+enum PrintFrame {
+    Fits(Breaks),
+    Broken(usize, Breaks),
+}
+
+pub const SIZE_INFINITY: isize = 0xffff;
+
+pub struct Printer {
+    out: String,
+    // Number of spaces left on line
+    space: isize,
+    // Ring-buffer of tokens and calculated sizes
+    buf: RingBuffer<BufEntry>,
+    // Total size of tokens already printed
+    left_total: isize,
+    // Total size of tokens enqueued, including printed and not yet printed
+    right_total: isize,
+    // Holds the ring-buffer index of the Begin that started the current block,
+    // possibly with the most recent Break after that Begin (if there is any) on
+    // top of it. Values are pushed and popped on the back of the queue using it
+    // like stack, and elsewhere old values are popped from the front of the
+    // queue as they become irrelevant due to the primary ring-buffer advancing.
+    scan_stack: VecDeque<usize>,
+    // Stack of blocks-in-progress being flushed by print
+    print_stack: Vec<PrintFrame>,
+    // Level of indentation of current line
+    indent: usize,
+    // Buffered indentation to avoid writing trailing whitespace
+    pending_indentation: usize,
+}
+
+#[derive(Clone)]
+struct BufEntry {
+    token: Token,
+    size: isize,
+}
+
+impl Printer {
+    pub fn new() -> Self {
+        Printer {
+            out: String::new(),
+            space: MARGIN,
+            buf: RingBuffer::new(),
+            left_total: 0,
+            right_total: 0,
+            scan_stack: VecDeque::new(),
+            print_stack: Vec::new(),
+            indent: 0,
+            pending_indentation: 0,
+        }
+    }
+
+    pub fn eof(mut self) -> String {
+        if !self.scan_stack.is_empty() {
+            self.check_stack(0);
+            self.advance_left();
+        }
+        self.out
+    }
+
+    pub fn scan_begin(&mut self, token: BeginToken) {
+        if self.scan_stack.is_empty() {
+            self.left_total = 1;
+            self.right_total = 1;
+            self.buf.clear();
+        }
+        let right = self.buf.push(BufEntry {
+            token: Token::Begin(token),
+            size: -self.right_total,
+        });
+        self.scan_stack.push_back(right);
+    }
+
+    pub fn scan_end(&mut self) {
+        if self.scan_stack.is_empty() {
+            self.print_end();
+        } else {
+            if !self.buf.is_empty() {
+                if let Token::Break(break_token) = self.buf.last().token {
+                    if self.buf.len() >= 2 {
+                        if let Token::Begin(_) = self.buf.second_last().token {
+                            self.buf.pop_last();
+                            self.buf.pop_last();
+                            self.scan_stack.pop_back();
+                            self.scan_stack.pop_back();
+                            self.right_total -= break_token.blank_space as isize;
+                            return;
+                        }
+                    }
+                    if break_token.if_nonempty {
+                        self.buf.pop_last();
+                        self.scan_stack.pop_back();
+                        self.right_total -= break_token.blank_space as isize;
+                    }
+                }
+            }
+            let right = self.buf.push(BufEntry {
+                token: Token::End,
+                size: -1,
+            });
+            self.scan_stack.push_back(right);
+        }
+    }
+
+    pub fn scan_break(&mut self, token: BreakToken) {
+        if self.scan_stack.is_empty() {
+            self.left_total = 1;
+            self.right_total = 1;
+            self.buf.clear();
+        } else {
+            self.check_stack(0);
+        }
+        let right = self.buf.push(BufEntry {
+            token: Token::Break(token),
+            size: -self.right_total,
+        });
+        self.scan_stack.push_back(right);
+        self.right_total += token.blank_space as isize;
+    }
+
+    pub fn scan_string(&mut self, string: Cow<'static, str>) {
+        if self.scan_stack.is_empty() {
+            self.print_string(string);
+        } else {
+            let len = string.len() as isize;
+            self.buf.push(BufEntry {
+                token: Token::String(string),
+                size: len,
+            });
+            self.right_total += len;
+            self.check_stream();
+        }
+    }
+
+    pub fn offset(&mut self, offset: isize) {
+        match &mut self.buf.last_mut().token {
+            Token::Break(token) => token.offset += offset,
+            Token::Begin(_) => {}
+            Token::String(_) | Token::End => unreachable!(),
+        }
+    }
+
+    pub fn end_with_max_width(&mut self, max: isize) {
+        let mut depth = 1;
+        for &index in self.scan_stack.iter().rev() {
+            let entry = &self.buf[index];
+            match entry.token {
+                Token::Begin(_) => {
+                    depth -= 1;
+                    if depth == 0 {
+                        if entry.size < 0 {
+                            let actual_width = entry.size + self.right_total;
+                            if actual_width > max {
+                                self.buf.push(BufEntry {
+                                    token: Token::String(Cow::Borrowed("")),
+                                    size: SIZE_INFINITY,
+                                });
+                                self.right_total += SIZE_INFINITY;
+                            }
+                        }
+                        break;
+                    }
+                }
+                Token::End => depth += 1,
+                Token::Break(_) => {}
+                Token::String(_) => unreachable!(),
+            }
+        }
+        self.scan_end();
+    }
+
+    fn check_stream(&mut self) {
+        while self.right_total - self.left_total > self.space {
+            if *self.scan_stack.front().unwrap() == self.buf.index_of_first() {
+                self.scan_stack.pop_front().unwrap();
+                self.buf.first_mut().size = SIZE_INFINITY;
+            }
+
+            self.advance_left();
+
+            if self.buf.is_empty() {
+                break;
+            }
+        }
+    }
+
+    fn advance_left(&mut self) {
+        while self.buf.first().size >= 0 {
+            let left = self.buf.pop_first();
+
+            match left.token {
+                Token::String(string) => {
+                    self.left_total += left.size;
+                    self.print_string(string);
+                }
+                Token::Break(token) => {
+                    self.left_total += token.blank_space as isize;
+                    self.print_break(token, left.size);
+                }
+                Token::Begin(token) => self.print_begin(token, left.size),
+                Token::End => self.print_end(),
+            }
+
+            if self.buf.is_empty() {
+                break;
+            }
+        }
+    }
+
+    fn check_stack(&mut self, mut depth: usize) {
+        while let Some(&index) = self.scan_stack.back() {
+            let entry = &mut self.buf[index];
+            match entry.token {
+                Token::Begin(_) => {
+                    if depth == 0 {
+                        break;
+                    }
+                    self.scan_stack.pop_back().unwrap();
+                    entry.size += self.right_total;
+                    depth -= 1;
+                }
+                Token::End => {
+                    self.scan_stack.pop_back().unwrap();
+                    entry.size = 1;
+                    depth += 1;
+                }
+                Token::Break(_) => {
+                    self.scan_stack.pop_back().unwrap();
+                    entry.size += self.right_total;
+                    if depth == 0 {
+                        break;
+                    }
+                }
+                Token::String(_) => unreachable!(),
+            }
+        }
+    }
+
+    fn get_top(&self) -> PrintFrame {
+        const OUTER: PrintFrame = PrintFrame::Broken(0, Breaks::Inconsistent);
+        self.print_stack.last().map_or(OUTER, PrintFrame::clone)
+    }
+
+    fn print_begin(&mut self, token: BeginToken, size: isize) {
+        if cfg!(prettyplease_debug) {
+            self.out.push(match token.breaks {
+                Breaks::Consistent => '«',
+                Breaks::Inconsistent => '‹',
+            });
+            if cfg!(prettyplease_debug_indent) {
+                self.out
+                    .extend(token.offset.to_string().chars().map(|ch| match ch {
+                        '0'..='9' => ['₀', '₁', '₂', '₃', '₄', '₅', '₆', '₇', '₈', '₉']
+                            [(ch as u8 - b'0') as usize],
+                        '-' => '₋',
+                        _ => unreachable!(),
+                    }));
+            }
+        }
+        if size > self.space {
+            self.print_stack
+                .push(PrintFrame::Broken(self.indent, token.breaks));
+            self.indent = usize::try_from(self.indent as isize + token.offset).unwrap();
+        } else {
+            self.print_stack.push(PrintFrame::Fits(token.breaks));
+        }
+    }
+
+    fn print_end(&mut self) {
+        let breaks = match self.print_stack.pop().unwrap() {
+            PrintFrame::Broken(indent, breaks) => {
+                self.indent = indent;
+                breaks
+            }
+            PrintFrame::Fits(breaks) => breaks,
+        };
+        if cfg!(prettyplease_debug) {
+            self.out.push(match breaks {
+                Breaks::Consistent => '»',
+                Breaks::Inconsistent => '›',
+            });
+        }
+    }
+
+    fn print_break(&mut self, token: BreakToken, size: isize) {
+        let fits = token.never_break
+            || match self.get_top() {
+                PrintFrame::Fits(..) => true,
+                PrintFrame::Broken(.., Breaks::Consistent) => false,
+                PrintFrame::Broken(.., Breaks::Inconsistent) => size <= self.space,
+            };
+        if fits {
+            self.pending_indentation += token.blank_space;
+            self.space -= token.blank_space as isize;
+            if let Some(no_break) = token.no_break {
+                self.out.push(no_break);
+                self.space -= no_break.len_utf8() as isize;
+            }
+            if cfg!(prettyplease_debug) {
+                self.out.push('·');
+            }
+        } else {
+            if let Some(pre_break) = token.pre_break {
+                self.print_indent();
+                self.out.push(pre_break);
+            }
+            if cfg!(prettyplease_debug) {
+                self.out.push('·');
+            }
+            self.out.push('\n');
+            let indent = self.indent as isize + token.offset;
+            self.pending_indentation = usize::try_from(indent).unwrap();
+            self.space = cmp::max(MARGIN - indent, MIN_SPACE);
+            if let Some(post_break) = token.post_break {
+                self.print_indent();
+                self.out.push(post_break);
+                self.space -= post_break.len_utf8() as isize;
+            }
+        }
+    }
+
+    fn print_string(&mut self, string: Cow<'static, str>) {
+        self.print_indent();
+        self.out.push_str(&string);
+        self.space -= string.len() as isize;
+    }
+
+    fn print_indent(&mut self) {
+        self.out.reserve(self.pending_indentation);
+        self.out
+            .extend(iter::repeat(' ').take(self.pending_indentation));
+        self.pending_indentation = 0;
+    }
+}
diff --git a/crates/prettyplease/src/attr.rs b/crates/prettyplease/src/attr.rs
new file mode 100644
index 0000000..0388d66
--- /dev/null
+++ b/crates/prettyplease/src/attr.rs
@@ -0,0 +1,287 @@
+use crate::algorithm::Printer;
+use crate::path::PathKind;
+use crate::INDENT;
+use proc_macro2::{Delimiter, Group, TokenStream, TokenTree};
+use syn::{AttrStyle, Attribute, Expr, Lit, MacroDelimiter, Meta, MetaList, MetaNameValue};
+
+impl Printer {
+    pub fn outer_attrs(&mut self, attrs: &[Attribute]) {
+        for attr in attrs {
+            if let AttrStyle::Outer = attr.style {
+                self.attr(attr);
+            }
+        }
+    }
+
+    pub fn inner_attrs(&mut self, attrs: &[Attribute]) {
+        for attr in attrs {
+            if let AttrStyle::Inner(_) = attr.style {
+                self.attr(attr);
+            }
+        }
+    }
+
+    fn attr(&mut self, attr: &Attribute) {
+        if let Some(mut doc) = value_of_attribute("doc", attr) {
+            if !doc.contains('\n')
+                && match attr.style {
+                    AttrStyle::Outer => !doc.starts_with('/'),
+                    AttrStyle::Inner(_) => true,
+                }
+            {
+                trim_trailing_spaces(&mut doc);
+                self.word(match attr.style {
+                    AttrStyle::Outer => "///",
+                    AttrStyle::Inner(_) => "//!",
+                });
+                self.word(doc);
+                self.hardbreak();
+                return;
+            } else if can_be_block_comment(&doc)
+                && match attr.style {
+                    AttrStyle::Outer => !doc.starts_with(&['*', '/'][..]),
+                    AttrStyle::Inner(_) => true,
+                }
+            {
+                trim_interior_trailing_spaces(&mut doc);
+                self.word(match attr.style {
+                    AttrStyle::Outer => "/**",
+                    AttrStyle::Inner(_) => "/*!",
+                });
+                self.word(doc);
+                self.word("*/");
+                self.hardbreak();
+                return;
+            }
+        } else if let Some(mut comment) = value_of_attribute("comment", attr) {
+            if !comment.contains('\n') {
+                trim_trailing_spaces(&mut comment);
+                self.word("//");
+                self.word(comment);
+                self.hardbreak();
+                return;
+            } else if can_be_block_comment(&comment) && !comment.starts_with(&['*', '!'][..]) {
+                trim_interior_trailing_spaces(&mut comment);
+                self.word("/*");
+                self.word(comment);
+                self.word("*/");
+                self.hardbreak();
+                return;
+            }
+        }
+
+        self.word(match attr.style {
+            AttrStyle::Outer => "#",
+            AttrStyle::Inner(_) => "#!",
+        });
+        self.word("[");
+        self.meta(&attr.meta);
+        self.word("]");
+        self.space();
+    }
+
+    fn meta(&mut self, meta: &Meta) {
+        match meta {
+            Meta::Path(path) => self.path(path, PathKind::Simple),
+            Meta::List(meta) => self.meta_list(meta),
+            Meta::NameValue(meta) => self.meta_name_value(meta),
+        }
+    }
+
+    fn meta_list(&mut self, meta: &MetaList) {
+        self.path(&meta.path, PathKind::Simple);
+        let delimiter = match meta.delimiter {
+            MacroDelimiter::Paren(_) => Delimiter::Parenthesis,
+            MacroDelimiter::Brace(_) => Delimiter::Brace,
+            MacroDelimiter::Bracket(_) => Delimiter::Bracket,
+        };
+        let group = Group::new(delimiter, meta.tokens.clone());
+        self.attr_tokens(TokenStream::from(TokenTree::Group(group)));
+    }
+
+    fn meta_name_value(&mut self, meta: &MetaNameValue) {
+        self.path(&meta.path, PathKind::Simple);
+        self.word(" = ");
+        self.expr(&meta.value);
+    }
+
+    fn attr_tokens(&mut self, tokens: TokenStream) {
+        let mut stack = Vec::new();
+        stack.push((tokens.into_iter().peekable(), Delimiter::None));
+        let mut space = Self::nbsp as fn(&mut Self);
+
+        #[derive(PartialEq)]
+        enum State {
+            Word,
+            Punct,
+            TrailingComma,
+        }
+
+        use State::*;
+        let mut state = Word;
+
+        while let Some((tokens, delimiter)) = stack.last_mut() {
+            match tokens.next() {
+                Some(TokenTree::Ident(ident)) => {
+                    if let Word = state {
+                        space(self);
+                    }
+                    self.ident(&ident);
+                    state = Word;
+                }
+                Some(TokenTree::Punct(punct)) => {
+                    let ch = punct.as_char();
+                    if let (Word, '=') = (state, ch) {
+                        self.nbsp();
+                    }
+                    if ch == ',' && tokens.peek().is_none() {
+                        self.trailing_comma(true);
+                        state = TrailingComma;
+                    } else {
+                        self.token_punct(ch);
+                        if ch == '=' {
+                            self.nbsp();
+                        } else if ch == ',' {
+                            space(self);
+                        }
+                        state = Punct;
+                    }
+                }
+                Some(TokenTree::Literal(literal)) => {
+                    if let Word = state {
+                        space(self);
+                    }
+                    self.token_literal(&literal);
+                    state = Word;
+                }
+                Some(TokenTree::Group(group)) => {
+                    let delimiter = group.delimiter();
+                    let stream = group.stream();
+                    match delimiter {
+                        Delimiter::Parenthesis => {
+                            self.word("(");
+                            self.cbox(INDENT);
+                            self.zerobreak();
+                            state = Punct;
+                        }
+                        Delimiter::Brace => {
+                            self.word("{");
+                            state = Punct;
+                        }
+                        Delimiter::Bracket => {
+                            self.word("[");
+                            state = Punct;
+                        }
+                        Delimiter::None => {}
+                    }
+                    stack.push((stream.into_iter().peekable(), delimiter));
+                    space = Self::space;
+                }
+                None => {
+                    match delimiter {
+                        Delimiter::Parenthesis => {
+                            if state != TrailingComma {
+                                self.zerobreak();
+                            }
+                            self.offset(-INDENT);
+                            self.end();
+                            self.word(")");
+                            state = Punct;
+                        }
+                        Delimiter::Brace => {
+                            self.word("}");
+                            state = Punct;
+                        }
+                        Delimiter::Bracket => {
+                            self.word("]");
+                            state = Punct;
+                        }
+                        Delimiter::None => {}
+                    }
+                    stack.pop();
+                    if stack.is_empty() {
+                        space = Self::nbsp;
+                    }
+                }
+            }
+        }
+    }
+}
+
+fn value_of_attribute(requested: &str, attr: &Attribute) -> Option<String> {
+    let value = match &attr.meta {
+        Meta::NameValue(meta) if meta.path.is_ident(requested) => &meta.value,
+        _ => return None,
+    };
+    let lit = match value {
+        Expr::Lit(expr) if expr.attrs.is_empty() => &expr.lit,
+        _ => return None,
+    };
+    match lit {
+        Lit::Str(string) => Some(string.value()),
+        _ => None,
+    }
+}
+
+pub fn has_outer(attrs: &[Attribute]) -> bool {
+    for attr in attrs {
+        if let AttrStyle::Outer = attr.style {
+            return true;
+        }
+    }
+    false
+}
+
+pub fn has_inner(attrs: &[Attribute]) -> bool {
+    for attr in attrs {
+        if let AttrStyle::Inner(_) = attr.style {
+            return true;
+        }
+    }
+    false
+}
+
+fn trim_trailing_spaces(doc: &mut String) {
+    doc.truncate(doc.trim_end_matches(' ').len());
+}
+
+fn trim_interior_trailing_spaces(doc: &mut String) {
+    if !doc.contains(" \n") {
+        return;
+    }
+    let mut trimmed = String::with_capacity(doc.len());
+    let mut lines = doc.split('\n').peekable();
+    while let Some(line) = lines.next() {
+        if lines.peek().is_some() {
+            trimmed.push_str(line.trim_end_matches(' '));
+            trimmed.push('\n');
+        } else {
+            trimmed.push_str(line);
+        }
+    }
+    *doc = trimmed;
+}
+
+fn can_be_block_comment(value: &str) -> bool {
+    let mut depth = 0usize;
+    let bytes = value.as_bytes();
+    let mut i = 0usize;
+    let upper = bytes.len() - 1;
+
+    while i < upper {
+        if bytes[i] == b'/' && bytes[i + 1] == b'*' {
+            depth += 1;
+            i += 2;
+        } else if bytes[i] == b'*' && bytes[i + 1] == b'/' {
+            if depth == 0 {
+                return false;
+            }
+            depth -= 1;
+            i += 2;
+        } else {
+            i += 1;
+        }
+    }
+
+    depth == 0
+}
diff --git a/crates/prettyplease/src/convenience.rs b/crates/prettyplease/src/convenience.rs
new file mode 100644
index 0000000..bc4add6
--- /dev/null
+++ b/crates/prettyplease/src/convenience.rs
@@ -0,0 +1,98 @@
+use crate::algorithm::{self, BeginToken, BreakToken, Breaks, Printer};
+use std::borrow::Cow;
+
+impl Printer {
+    pub fn ibox(&mut self, indent: isize) {
+        self.scan_begin(BeginToken {
+            offset: indent,
+            breaks: Breaks::Inconsistent,
+        });
+    }
+
+    pub fn cbox(&mut self, indent: isize) {
+        self.scan_begin(BeginToken {
+            offset: indent,
+            breaks: Breaks::Consistent,
+        });
+    }
+
+    pub fn end(&mut self) {
+        self.scan_end();
+    }
+
+    pub fn word<S: Into<Cow<'static, str>>>(&mut self, wrd: S) {
+        let s = wrd.into();
+        self.scan_string(s);
+    }
+
+    fn spaces(&mut self, n: usize) {
+        self.scan_break(BreakToken {
+            blank_space: n,
+            ..BreakToken::default()
+        });
+    }
+
+    pub fn zerobreak(&mut self) {
+        self.spaces(0);
+    }
+
+    pub fn space(&mut self) {
+        self.spaces(1);
+    }
+
+    pub fn nbsp(&mut self) {
+        self.word(" ");
+    }
+
+    pub fn hardbreak(&mut self) {
+        self.spaces(algorithm::SIZE_INFINITY as usize);
+    }
+
+    pub fn space_if_nonempty(&mut self) {
+        self.scan_break(BreakToken {
+            blank_space: 1,
+            if_nonempty: true,
+            ..BreakToken::default()
+        });
+    }
+
+    pub fn hardbreak_if_nonempty(&mut self) {
+        self.scan_break(BreakToken {
+            blank_space: algorithm::SIZE_INFINITY as usize,
+            if_nonempty: true,
+            ..BreakToken::default()
+        });
+    }
+
+    pub fn trailing_comma(&mut self, is_last: bool) {
+        if is_last {
+            self.scan_break(BreakToken {
+                pre_break: Some(','),
+                ..BreakToken::default()
+            });
+        } else {
+            self.word(",");
+            self.space();
+        }
+    }
+
+    pub fn trailing_comma_or_space(&mut self, is_last: bool) {
+        if is_last {
+            self.scan_break(BreakToken {
+                blank_space: 1,
+                pre_break: Some(','),
+                ..BreakToken::default()
+            });
+        } else {
+            self.word(",");
+            self.space();
+        }
+    }
+
+    pub fn neverbreak(&mut self) {
+        self.scan_break(BreakToken {
+            never_break: true,
+            ..BreakToken::default()
+        });
+    }
+}
diff --git a/crates/prettyplease/src/data.rs b/crates/prettyplease/src/data.rs
new file mode 100644
index 0000000..d823ee3
--- /dev/null
+++ b/crates/prettyplease/src/data.rs
@@ -0,0 +1,78 @@
+use crate::algorithm::Printer;
+use crate::iter::IterDelimited;
+use crate::path::PathKind;
+use crate::INDENT;
+use syn::{Field, Fields, FieldsUnnamed, Variant, VisRestricted, Visibility};
+
+impl Printer {
+    pub fn variant(&mut self, variant: &Variant) {
+        self.outer_attrs(&variant.attrs);
+        self.ident(&variant.ident);
+        match &variant.fields {
+            Fields::Named(fields) => {
+                self.nbsp();
+                self.word("{");
+                self.cbox(INDENT);
+                self.space();
+                for field in fields.named.iter().delimited() {
+                    self.field(&field);
+                    self.trailing_comma_or_space(field.is_last);
+                }
+                self.offset(-INDENT);
+                self.end();
+                self.word("}");
+            }
+            Fields::Unnamed(fields) => {
+                self.cbox(INDENT);
+                self.fields_unnamed(fields);
+                self.end();
+            }
+            Fields::Unit => {}
+        }
+        if let Some((_eq_token, discriminant)) = &variant.discriminant {
+            self.word(" = ");
+            self.expr(discriminant);
+        }
+    }
+
+    pub fn fields_unnamed(&mut self, fields: &FieldsUnnamed) {
+        self.word("(");
+        self.zerobreak();
+        for field in fields.unnamed.iter().delimited() {
+            self.field(&field);
+            self.trailing_comma(field.is_last);
+        }
+        self.offset(-INDENT);
+        self.word(")");
+    }
+
+    pub fn field(&mut self, field: &Field) {
+        self.outer_attrs(&field.attrs);
+        self.visibility(&field.vis);
+        if let Some(ident) = &field.ident {
+            self.ident(ident);
+            self.word(": ");
+        }
+        self.ty(&field.ty);
+    }
+
+    pub fn visibility(&mut self, vis: &Visibility) {
+        match vis {
+            Visibility::Public(_) => self.word("pub "),
+            Visibility::Restricted(vis) => self.vis_restricted(vis),
+            Visibility::Inherited => {}
+        }
+    }
+
+    fn vis_restricted(&mut self, vis: &VisRestricted) {
+        self.word("pub(");
+        let omit_in = vis.path.get_ident().map_or(false, |ident| {
+            matches!(ident.to_string().as_str(), "self" | "super" | "crate")
+        });
+        if !omit_in {
+            self.word("in ");
+        }
+        self.path(&vis.path, PathKind::Simple);
+        self.word(") ");
+    }
+}
diff --git a/crates/prettyplease/src/expr.rs b/crates/prettyplease/src/expr.rs
new file mode 100644
index 0000000..92c50e7
--- /dev/null
+++ b/crates/prettyplease/src/expr.rs
@@ -0,0 +1,1193 @@
+use crate::algorithm::{BreakToken, Printer};
+use crate::attr;
+use crate::iter::IterDelimited;
+use crate::path::PathKind;
+use crate::stmt;
+use crate::INDENT;
+use proc_macro2::TokenStream;
+use syn::punctuated::Punctuated;
+use syn::{
+    token, Arm, Attribute, BinOp, Block, Expr, ExprArray, ExprAssign, ExprAsync, ExprAwait,
+    ExprBinary, ExprBlock, ExprBreak, ExprCall, ExprCast, ExprClosure, ExprConst, ExprContinue,
+    ExprField, ExprForLoop, ExprGroup, ExprIf, ExprIndex, ExprInfer, ExprLet, ExprLit, ExprLoop,
+    ExprMacro, ExprMatch, ExprMethodCall, ExprParen, ExprPath, ExprRange, ExprReference,
+    ExprRepeat, ExprReturn, ExprStruct, ExprTry, ExprTryBlock, ExprTuple, ExprUnary, ExprUnsafe,
+    ExprWhile, ExprYield, FieldValue, Index, Label, Member, RangeLimits, ReturnType, Stmt, Token,
+    UnOp,
+};
+
+impl Printer {
+    pub fn expr(&mut self, expr: &Expr) {
+        match expr {
+            Expr::Array(expr) => self.expr_array(expr),
+            Expr::Assign(expr) => self.expr_assign(expr),
+            Expr::Async(expr) => self.expr_async(expr),
+            Expr::Await(expr) => self.expr_await(expr, false),
+            Expr::Binary(expr) => self.expr_binary(expr),
+            Expr::Block(expr) => self.expr_block(expr),
+            Expr::Break(expr) => self.expr_break(expr),
+            Expr::Call(expr) => self.expr_call(expr, false),
+            Expr::Cast(expr) => self.expr_cast(expr),
+            Expr::Closure(expr) => self.expr_closure(expr),
+            Expr::Const(expr) => self.expr_const(expr),
+            Expr::Continue(expr) => self.expr_continue(expr),
+            Expr::Field(expr) => self.expr_field(expr, false),
+            Expr::ForLoop(expr) => self.expr_for_loop(expr),
+            Expr::Group(expr) => self.expr_group(expr),
+            Expr::If(expr) => self.expr_if(expr),
+            Expr::Index(expr) => self.expr_index(expr, false),
+            Expr::Infer(expr) => self.expr_infer(expr),
+            Expr::Let(expr) => self.expr_let(expr),
+            Expr::Lit(expr) => self.expr_lit(expr),
+            Expr::Loop(expr) => self.expr_loop(expr),
+            Expr::Macro(expr) => self.expr_macro(expr),
+            Expr::Match(expr) => self.expr_match(expr),
+            Expr::MethodCall(expr) => self.expr_method_call(expr, false),
+            Expr::Paren(expr) => self.expr_paren(expr),
+            Expr::Path(expr) => self.expr_path(expr),
+            Expr::Range(expr) => self.expr_range(expr),
+            Expr::Reference(expr) => self.expr_reference(expr),
+            Expr::Repeat(expr) => self.expr_repeat(expr),
+            Expr::Return(expr) => self.expr_return(expr),
+            Expr::Struct(expr) => self.expr_struct(expr),
+            Expr::Try(expr) => self.expr_try(expr, false),
+            Expr::TryBlock(expr) => self.expr_try_block(expr),
+            Expr::Tuple(expr) => self.expr_tuple(expr),
+            Expr::Unary(expr) => self.expr_unary(expr),
+            Expr::Unsafe(expr) => self.expr_unsafe(expr),
+            Expr::Verbatim(expr) => self.expr_verbatim(expr),
+            Expr::While(expr) => self.expr_while(expr),
+            Expr::Yield(expr) => self.expr_yield(expr),
+            #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
+            _ => unimplemented!("unknown Expr"),
+        }
+    }
+
+    pub fn expr_beginning_of_line(&mut self, expr: &Expr, beginning_of_line: bool) {
+        match expr {
+            Expr::Await(expr) => self.expr_await(expr, beginning_of_line),
+            Expr::Field(expr) => self.expr_field(expr, beginning_of_line),
+            Expr::Index(expr) => self.expr_index(expr, beginning_of_line),
+            Expr::MethodCall(expr) => self.expr_method_call(expr, beginning_of_line),
+            Expr::Try(expr) => self.expr_try(expr, beginning_of_line),
+            _ => self.expr(expr),
+        }
+    }
+
+    fn subexpr(&mut self, expr: &Expr, beginning_of_line: bool) {
+        match expr {
+            Expr::Await(expr) => self.subexpr_await(expr, beginning_of_line),
+            Expr::Call(expr) => self.subexpr_call(expr),
+            Expr::Field(expr) => self.subexpr_field(expr, beginning_of_line),
+            Expr::Index(expr) => self.subexpr_index(expr, beginning_of_line),
+            Expr::MethodCall(expr) => self.subexpr_method_call(expr, beginning_of_line, false),
+            Expr::Try(expr) => self.subexpr_try(expr, beginning_of_line),
+            _ => {
+                self.cbox(-INDENT);
+                self.expr(expr);
+                self.end();
+            }
+        }
+    }
+
+    fn wrap_exterior_struct(&mut self, expr: &Expr) {
+        let needs_paren = contains_exterior_struct_lit(expr);
+        if needs_paren {
+            self.word("(");
+        }
+        self.cbox(0);
+        self.expr(expr);
+        if needs_paren {
+            self.word(")");
+        }
+        if needs_newline_if_wrap(expr) {
+            self.space();
+        } else {
+            self.nbsp();
+        }
+        self.end();
+    }
+
+    fn expr_array(&mut self, expr: &ExprArray) {
+        self.outer_attrs(&expr.attrs);
+        self.word("[");
+        self.cbox(INDENT);
+        self.zerobreak();
+        for element in expr.elems.iter().delimited() {
+            self.expr(&element);
+            self.trailing_comma(element.is_last);
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word("]");
+    }
+
+    fn expr_assign(&mut self, expr: &ExprAssign) {
+        self.outer_attrs(&expr.attrs);
+        self.ibox(0);
+        self.expr(&expr.left);
+        self.word(" = ");
+        self.expr(&expr.right);
+        self.end();
+    }
+
+    fn expr_async(&mut self, expr: &ExprAsync) {
+        self.outer_attrs(&expr.attrs);
+        self.word("async ");
+        if expr.capture.is_some() {
+            self.word("move ");
+        }
+        self.cbox(INDENT);
+        self.small_block(&expr.block, &expr.attrs);
+        self.end();
+    }
+
+    fn expr_await(&mut self, expr: &ExprAwait, beginning_of_line: bool) {
+        self.outer_attrs(&expr.attrs);
+        self.cbox(INDENT);
+        self.subexpr_await(expr, beginning_of_line);
+        self.end();
+    }
+
+    fn subexpr_await(&mut self, expr: &ExprAwait, beginning_of_line: bool) {
+        self.subexpr(&expr.base, beginning_of_line);
+        self.zerobreak_unless_short_ident(beginning_of_line, &expr.base);
+        self.word(".await");
+    }
+
+    fn expr_binary(&mut self, expr: &ExprBinary) {
+        self.outer_attrs(&expr.attrs);
+        self.ibox(INDENT);
+        self.ibox(-INDENT);
+        self.expr(&expr.left);
+        self.end();
+        self.space();
+        self.binary_operator(&expr.op);
+        self.nbsp();
+        self.expr(&expr.right);
+        self.end();
+    }
+
+    pub fn expr_block(&mut self, expr: &ExprBlock) {
+        self.outer_attrs(&expr.attrs);
+        if let Some(label) = &expr.label {
+            self.label(label);
+        }
+        self.cbox(INDENT);
+        self.small_block(&expr.block, &expr.attrs);
+        self.end();
+    }
+
+    fn expr_break(&mut self, expr: &ExprBreak) {
+        self.outer_attrs(&expr.attrs);
+        self.word("break");
+        if let Some(lifetime) = &expr.label {
+            self.nbsp();
+            self.lifetime(lifetime);
+        }
+        if let Some(value) = &expr.expr {
+            self.nbsp();
+            self.expr(value);
+        }
+    }
+
+    fn expr_call(&mut self, expr: &ExprCall, beginning_of_line: bool) {
+        self.outer_attrs(&expr.attrs);
+        self.expr_beginning_of_line(&expr.func, beginning_of_line);
+        self.word("(");
+        self.call_args(&expr.args);
+        self.word(")");
+    }
+
+    fn subexpr_call(&mut self, expr: &ExprCall) {
+        self.subexpr(&expr.func, false);
+        self.word("(");
+        self.call_args(&expr.args);
+        self.word(")");
+    }
+
+    fn expr_cast(&mut self, expr: &ExprCast) {
+        self.outer_attrs(&expr.attrs);
+        self.ibox(INDENT);
+        self.ibox(-INDENT);
+        self.expr(&expr.expr);
+        self.end();
+        self.space();
+        self.word("as ");
+        self.ty(&expr.ty);
+        self.end();
+    }
+
+    fn expr_closure(&mut self, expr: &ExprClosure) {
+        self.outer_attrs(&expr.attrs);
+        self.ibox(0);
+        if let Some(bound_lifetimes) = &expr.lifetimes {
+            self.bound_lifetimes(bound_lifetimes);
+        }
+        if expr.constness.is_some() {
+            self.word("const ");
+        }
+        if expr.movability.is_some() {
+            self.word("static ");
+        }
+        if expr.asyncness.is_some() {
+            self.word("async ");
+        }
+        if expr.capture.is_some() {
+            self.word("move ");
+        }
+        self.cbox(INDENT);
+        self.word("|");
+        for pat in expr.inputs.iter().delimited() {
+            if pat.is_first {
+                self.zerobreak();
+            }
+            self.pat(&pat);
+            if !pat.is_last {
+                self.word(",");
+                self.space();
+            }
+        }
+        match &expr.output {
+            ReturnType::Default => {
+                self.word("|");
+                self.space();
+                self.offset(-INDENT);
+                self.end();
+                self.neverbreak();
+                let wrap_in_brace = match &*expr.body {
+                    Expr::Match(ExprMatch { attrs, .. }) | Expr::Call(ExprCall { attrs, .. }) => {
+                        attr::has_outer(attrs)
+                    }
+                    body => !is_blocklike(body),
+                };
+                if wrap_in_brace {
+                    self.cbox(INDENT);
+                    self.scan_break(BreakToken {
+                        pre_break: Some('{'),
+                        ..BreakToken::default()
+                    });
+                    self.expr(&expr.body);
+                    self.scan_break(BreakToken {
+                        offset: -INDENT,
+                        pre_break: stmt::add_semi(&expr.body).then(|| ';'),
+                        post_break: Some('}'),
+                        ..BreakToken::default()
+                    });
+                    self.end();
+                } else {
+                    self.expr(&expr.body);
+                }
+            }
+            ReturnType::Type(_arrow, ty) => {
+                if !expr.inputs.is_empty() {
+                    self.trailing_comma(true);
+                    self.offset(-INDENT);
+                }
+                self.word("|");
+                self.end();
+                self.word(" -> ");
+                self.ty(ty);
+                self.nbsp();
+                self.neverbreak();
+                self.expr(&expr.body);
+            }
+        }
+        self.end();
+    }
+
+    pub fn expr_const(&mut self, expr: &ExprConst) {
+        self.outer_attrs(&expr.attrs);
+        self.word("const ");
+        self.cbox(INDENT);
+        self.small_block(&expr.block, &expr.attrs);
+        self.end();
+    }
+
+    fn expr_continue(&mut self, expr: &ExprContinue) {
+        self.outer_attrs(&expr.attrs);
+        self.word("continue");
+        if let Some(lifetime) = &expr.label {
+            self.nbsp();
+            self.lifetime(lifetime);
+        }
+    }
+
+    fn expr_field(&mut self, expr: &ExprField, beginning_of_line: bool) {
+        self.outer_attrs(&expr.attrs);
+        self.cbox(INDENT);
+        self.subexpr_field(expr, beginning_of_line);
+        self.end();
+    }
+
+    fn subexpr_field(&mut self, expr: &ExprField, beginning_of_line: bool) {
+        self.subexpr(&expr.base, beginning_of_line);
+        self.zerobreak_unless_short_ident(beginning_of_line, &expr.base);
+        self.word(".");
+        self.member(&expr.member);
+    }
+
+    fn expr_for_loop(&mut self, expr: &ExprForLoop) {
+        self.outer_attrs(&expr.attrs);
+        self.ibox(0);
+        if let Some(label) = &expr.label {
+            self.label(label);
+        }
+        self.word("for ");
+        self.pat(&expr.pat);
+        self.word(" in ");
+        self.neverbreak();
+        self.wrap_exterior_struct(&expr.expr);
+        self.word("{");
+        self.neverbreak();
+        self.cbox(INDENT);
+        self.hardbreak_if_nonempty();
+        self.inner_attrs(&expr.attrs);
+        for stmt in &expr.body.stmts {
+            self.stmt(stmt);
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word("}");
+        self.end();
+    }
+
+    fn expr_group(&mut self, expr: &ExprGroup) {
+        self.outer_attrs(&expr.attrs);
+        self.expr(&expr.expr);
+    }
+
+    fn expr_if(&mut self, expr: &ExprIf) {
+        self.outer_attrs(&expr.attrs);
+        self.cbox(INDENT);
+        self.word("if ");
+        self.cbox(-INDENT);
+        self.wrap_exterior_struct(&expr.cond);
+        self.end();
+        if let Some((_else_token, else_branch)) = &expr.else_branch {
+            let mut else_branch = &**else_branch;
+            self.small_block(&expr.then_branch, &[]);
+            loop {
+                self.word(" else ");
+                match else_branch {
+                    Expr::If(expr) => {
+                        self.word("if ");
+                        self.cbox(-INDENT);
+                        self.wrap_exterior_struct(&expr.cond);
+                        self.end();
+                        self.small_block(&expr.then_branch, &[]);
+                        if let Some((_else_token, next)) = &expr.else_branch {
+                            else_branch = next;
+                            continue;
+                        }
+                    }
+                    Expr::Block(expr) => {
+                        self.small_block(&expr.block, &[]);
+                    }
+                    // If not one of the valid expressions to exist in an else
+                    // clause, wrap in a block.
+                    other => {
+                        self.word("{");
+                        self.space();
+                        self.ibox(INDENT);
+                        self.expr(other);
+                        self.end();
+                        self.space();
+                        self.offset(-INDENT);
+                        self.word("}");
+                    }
+                }
+                break;
+            }
+        } else if expr.then_branch.stmts.is_empty() {
+            self.word("{}");
+        } else {
+            self.word("{");
+            self.hardbreak();
+            for stmt in &expr.then_branch.stmts {
+                self.stmt(stmt);
+            }
+            self.offset(-INDENT);
+            self.word("}");
+        }
+        self.end();
+    }
+
+    fn expr_index(&mut self, expr: &ExprIndex, beginning_of_line: bool) {
+        self.outer_attrs(&expr.attrs);
+        self.expr_beginning_of_line(&expr.expr, beginning_of_line);
+        self.word("[");
+        self.expr(&expr.index);
+        self.word("]");
+    }
+
+    fn subexpr_index(&mut self, expr: &ExprIndex, beginning_of_line: bool) {
+        self.subexpr(&expr.expr, beginning_of_line);
+        self.word("[");
+        self.expr(&expr.index);
+        self.word("]");
+    }
+
+    fn expr_infer(&mut self, expr: &ExprInfer) {
+        self.outer_attrs(&expr.attrs);
+        self.word("_");
+    }
+
+    fn expr_let(&mut self, expr: &ExprLet) {
+        self.outer_attrs(&expr.attrs);
+        self.ibox(INDENT);
+        self.word("let ");
+        self.ibox(-INDENT);
+        self.pat(&expr.pat);
+        self.end();
+        self.space();
+        self.word("= ");
+        let needs_paren = contains_exterior_struct_lit(&expr.expr);
+        if needs_paren {
+            self.word("(");
+        }
+        self.expr(&expr.expr);
+        if needs_paren {
+            self.word(")");
+        }
+        self.end();
+    }
+
+    pub fn expr_lit(&mut self, expr: &ExprLit) {
+        self.outer_attrs(&expr.attrs);
+        self.lit(&expr.lit);
+    }
+
+    fn expr_loop(&mut self, expr: &ExprLoop) {
+        self.outer_attrs(&expr.attrs);
+        if let Some(label) = &expr.label {
+            self.label(label);
+        }
+        self.word("loop {");
+        self.cbox(INDENT);
+        self.hardbreak_if_nonempty();
+        self.inner_attrs(&expr.attrs);
+        for stmt in &expr.body.stmts {
+            self.stmt(stmt);
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word("}");
+    }
+
+    pub fn expr_macro(&mut self, expr: &ExprMacro) {
+        self.outer_attrs(&expr.attrs);
+        let semicolon = false;
+        self.mac(&expr.mac, None, semicolon);
+    }
+
+    fn expr_match(&mut self, expr: &ExprMatch) {
+        self.outer_attrs(&expr.attrs);
+        self.ibox(0);
+        self.word("match ");
+        self.wrap_exterior_struct(&expr.expr);
+        self.word("{");
+        self.neverbreak();
+        self.cbox(INDENT);
+        self.hardbreak_if_nonempty();
+        self.inner_attrs(&expr.attrs);
+        for arm in &expr.arms {
+            self.arm(arm);
+            self.hardbreak();
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word("}");
+        self.end();
+    }
+
+    fn expr_method_call(&mut self, expr: &ExprMethodCall, beginning_of_line: bool) {
+        self.outer_attrs(&expr.attrs);
+        self.cbox(INDENT);
+        let unindent_call_args = beginning_of_line && is_short_ident(&expr.receiver);
+        self.subexpr_method_call(expr, beginning_of_line, unindent_call_args);
+        self.end();
+    }
+
+    fn subexpr_method_call(
+        &mut self,
+        expr: &ExprMethodCall,
+        beginning_of_line: bool,
+        unindent_call_args: bool,
+    ) {
+        self.subexpr(&expr.receiver, beginning_of_line);
+        self.zerobreak_unless_short_ident(beginning_of_line, &expr.receiver);
+        self.word(".");
+        self.ident(&expr.method);
+        if let Some(turbofish) = &expr.turbofish {
+            self.angle_bracketed_generic_arguments(turbofish, PathKind::Expr);
+        }
+        self.cbox(if unindent_call_args { -INDENT } else { 0 });
+        self.word("(");
+        self.call_args(&expr.args);
+        self.word(")");
+        self.end();
+    }
+
+    fn expr_paren(&mut self, expr: &ExprParen) {
+        self.outer_attrs(&expr.attrs);
+        self.word("(");
+        self.expr(&expr.expr);
+        self.word(")");
+    }
+
+    pub fn expr_path(&mut self, expr: &ExprPath) {
+        self.outer_attrs(&expr.attrs);
+        self.qpath(&expr.qself, &expr.path, PathKind::Expr);
+    }
+
+    pub fn expr_range(&mut self, expr: &ExprRange) {
+        self.outer_attrs(&expr.attrs);
+        if let Some(start) = &expr.start {
+            self.expr(start);
+        }
+        self.word(match expr.limits {
+            RangeLimits::HalfOpen(_) => "..",
+            RangeLimits::Closed(_) => "..=",
+        });
+        if let Some(end) = &expr.end {
+            self.expr(end);
+        }
+    }
+
+    fn expr_reference(&mut self, expr: &ExprReference) {
+        self.outer_attrs(&expr.attrs);
+        self.word("&");
+        if expr.mutability.is_some() {
+            self.word("mut ");
+        }
+        self.expr(&expr.expr);
+    }
+
+    fn expr_repeat(&mut self, expr: &ExprRepeat) {
+        self.outer_attrs(&expr.attrs);
+        self.word("[");
+        self.expr(&expr.expr);
+        self.word("; ");
+        self.expr(&expr.len);
+        self.word("]");
+    }
+
+    fn expr_return(&mut self, expr: &ExprReturn) {
+        self.outer_attrs(&expr.attrs);
+        self.word("return");
+        if let Some(value) = &expr.expr {
+            self.nbsp();
+            self.expr(value);
+        }
+    }
+
+    fn expr_struct(&mut self, expr: &ExprStruct) {
+        self.outer_attrs(&expr.attrs);
+        self.cbox(INDENT);
+        self.ibox(-INDENT);
+        self.qpath(&expr.qself, &expr.path, PathKind::Expr);
+        self.end();
+        self.word(" {");
+        self.space_if_nonempty();
+        for field_value in expr.fields.iter().delimited() {
+            self.field_value(&field_value);
+            self.trailing_comma_or_space(field_value.is_last && expr.rest.is_none());
+        }
+        if let Some(rest) = &expr.rest {
+            self.word("..");
+            self.expr(rest);
+            self.space();
+        }
+        self.offset(-INDENT);
+        self.end_with_max_width(34);
+        self.word("}");
+    }
+
+    fn expr_try(&mut self, expr: &ExprTry, beginning_of_line: bool) {
+        self.outer_attrs(&expr.attrs);
+        self.expr_beginning_of_line(&expr.expr, beginning_of_line);
+        self.word("?");
+    }
+
+    fn subexpr_try(&mut self, expr: &ExprTry, beginning_of_line: bool) {
+        self.subexpr(&expr.expr, beginning_of_line);
+        self.word("?");
+    }
+
+    fn expr_try_block(&mut self, expr: &ExprTryBlock) {
+        self.outer_attrs(&expr.attrs);
+        self.word("try ");
+        self.cbox(INDENT);
+        self.small_block(&expr.block, &expr.attrs);
+        self.end();
+    }
+
+    fn expr_tuple(&mut self, expr: &ExprTuple) {
+        self.outer_attrs(&expr.attrs);
+        self.word("(");
+        self.cbox(INDENT);
+        self.zerobreak();
+        for elem in expr.elems.iter().delimited() {
+            self.expr(&elem);
+            if expr.elems.len() == 1 {
+                self.word(",");
+                self.zerobreak();
+            } else {
+                self.trailing_comma(elem.is_last);
+            }
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word(")");
+    }
+
+    fn expr_unary(&mut self, expr: &ExprUnary) {
+        self.outer_attrs(&expr.attrs);
+        self.unary_operator(&expr.op);
+        self.expr(&expr.expr);
+    }
+
+    fn expr_unsafe(&mut self, expr: &ExprUnsafe) {
+        self.outer_attrs(&expr.attrs);
+        self.word("unsafe ");
+        self.cbox(INDENT);
+        self.small_block(&expr.block, &expr.attrs);
+        self.end();
+    }
+
+    #[cfg(not(feature = "verbatim"))]
+    fn expr_verbatim(&mut self, expr: &TokenStream) {
+        if !expr.is_empty() {
+            unimplemented!("Expr::Verbatim `{}`", expr);
+        }
+    }
+
+    #[cfg(feature = "verbatim")]
+    fn expr_verbatim(&mut self, tokens: &TokenStream) {
+        use syn::parse::{Parse, ParseStream, Result};
+        use syn::{parenthesized, Ident};
+
+        enum ExprVerbatim {
+            Empty,
+            Builtin(Builtin),
+            RawReference(RawReference),
+        }
+
+        struct Builtin {
+            name: Ident,
+            args: TokenStream,
+        }
+
+        struct RawReference {
+            mutable: bool,
+            expr: Expr,
+        }
+
+        mod kw {
+            syn::custom_keyword!(builtin);
+            syn::custom_keyword!(raw);
+        }
+
+        impl Parse for ExprVerbatim {
+            fn parse(input: ParseStream) -> Result<Self> {
+                let lookahead = input.lookahead1();
+                if input.is_empty() {
+                    Ok(ExprVerbatim::Empty)
+                } else if lookahead.peek(kw::builtin) {
+                    input.parse::<kw::builtin>()?;
+                    input.parse::<Token![#]>()?;
+                    let name: Ident = input.parse()?;
+                    let args;
+                    parenthesized!(args in input);
+                    let args: TokenStream = args.parse()?;
+                    Ok(ExprVerbatim::Builtin(Builtin { name, args }))
+                } else if lookahead.peek(Token![&]) {
+                    input.parse::<Token![&]>()?;
+                    input.parse::<kw::raw>()?;
+                    let mutable = input.parse::<Option<Token![mut]>>()?.is_some();
+                    if !mutable {
+                        input.parse::<Token![const]>()?;
+                    }
+                    let expr: Expr = input.parse()?;
+                    Ok(ExprVerbatim::RawReference(RawReference { mutable, expr }))
+                } else {
+                    Err(lookahead.error())
+                }
+            }
+        }
+
+        let expr: ExprVerbatim = match syn::parse2(tokens.clone()) {
+            Ok(expr) => expr,
+            Err(_) => unimplemented!("Expr::Verbatim `{}`", tokens),
+        };
+
+        match expr {
+            ExprVerbatim::Empty => {}
+            ExprVerbatim::Builtin(expr) => {
+                self.word("builtin # ");
+                self.ident(&expr.name);
+                self.word("(");
+                if !expr.args.is_empty() {
+                    self.cbox(INDENT);
+                    self.zerobreak();
+                    self.ibox(0);
+                    self.macro_rules_tokens(expr.args, false);
+                    self.end();
+                    self.zerobreak();
+                    self.offset(-INDENT);
+                    self.end();
+                }
+                self.word(")");
+            }
+            ExprVerbatim::RawReference(expr) => {
+                self.word("&raw ");
+                self.word(if expr.mutable { "mut " } else { "const " });
+                self.expr(&expr.expr);
+            }
+        }
+    }
+
+    fn expr_while(&mut self, expr: &ExprWhile) {
+        self.outer_attrs(&expr.attrs);
+        if let Some(label) = &expr.label {
+            self.label(label);
+        }
+        self.word("while ");
+        self.wrap_exterior_struct(&expr.cond);
+        self.word("{");
+        self.neverbreak();
+        self.cbox(INDENT);
+        self.hardbreak_if_nonempty();
+        self.inner_attrs(&expr.attrs);
+        for stmt in &expr.body.stmts {
+            self.stmt(stmt);
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word("}");
+    }
+
+    fn expr_yield(&mut self, expr: &ExprYield) {
+        self.outer_attrs(&expr.attrs);
+        self.word("yield");
+        if let Some(value) = &expr.expr {
+            self.nbsp();
+            self.expr(value);
+        }
+    }
+
+    fn label(&mut self, label: &Label) {
+        self.lifetime(&label.name);
+        self.word(": ");
+    }
+
+    fn field_value(&mut self, field_value: &FieldValue) {
+        self.outer_attrs(&field_value.attrs);
+        self.member(&field_value.member);
+        if field_value.colon_token.is_some() {
+            self.word(": ");
+            self.ibox(0);
+            self.expr(&field_value.expr);
+            self.end();
+        }
+    }
+
+    fn arm(&mut self, arm: &Arm) {
+        self.outer_attrs(&arm.attrs);
+        self.ibox(0);
+        self.pat(&arm.pat);
+        if let Some((_if_token, guard)) = &arm.guard {
+            self.word(" if ");
+            self.expr(guard);
+        }
+        self.word(" =>");
+        let empty_block;
+        let mut body = &*arm.body;
+        while let Expr::Block(expr) = body {
+            if expr.attrs.is_empty() && expr.label.is_none() {
+                let mut stmts = expr.block.stmts.iter();
+                if let (Some(Stmt::Expr(inner, None)), None) = (stmts.next(), stmts.next()) {
+                    body = inner;
+                    continue;
+                }
+            }
+            break;
+        }
+        if let Expr::Tuple(expr) = body {
+            if expr.elems.is_empty() && expr.attrs.is_empty() {
+                empty_block = Expr::Block(ExprBlock {
+                    attrs: Vec::new(),
+                    label: None,
+                    block: Block {
+                        brace_token: token::Brace::default(),
+                        stmts: Vec::new(),
+                    },
+                });
+                body = &empty_block;
+            }
+        }
+        if let Expr::Block(body) = body {
+            self.nbsp();
+            if let Some(label) = &body.label {
+                self.label(label);
+            }
+            self.word("{");
+            self.neverbreak();
+            self.cbox(INDENT);
+            self.hardbreak_if_nonempty();
+            self.inner_attrs(&body.attrs);
+            for stmt in &body.block.stmts {
+                self.stmt(stmt);
+            }
+            self.offset(-INDENT);
+            self.end();
+            self.word("}");
+            self.end();
+        } else {
+            self.nbsp();
+            self.neverbreak();
+            self.cbox(INDENT);
+            self.scan_break(BreakToken {
+                pre_break: Some('{'),
+                ..BreakToken::default()
+            });
+            self.expr_beginning_of_line(body, true);
+            self.scan_break(BreakToken {
+                offset: -INDENT,
+                pre_break: stmt::add_semi(body).then(|| ';'),
+                post_break: Some('}'),
+                no_break: requires_terminator(body).then(|| ','),
+                ..BreakToken::default()
+            });
+            self.end();
+            self.end();
+        }
+    }
+
+    fn call_args(&mut self, args: &Punctuated<Expr, Token![,]>) {
+        let mut iter = args.iter();
+        match (iter.next(), iter.next()) {
+            (Some(expr), None) if is_blocklike(expr) => {
+                self.expr(expr);
+            }
+            _ => {
+                self.cbox(INDENT);
+                self.zerobreak();
+                for arg in args.iter().delimited() {
+                    self.expr(&arg);
+                    self.trailing_comma(arg.is_last);
+                }
+                self.offset(-INDENT);
+                self.end();
+            }
+        }
+    }
+
+    pub fn small_block(&mut self, block: &Block, attrs: &[Attribute]) {
+        self.word("{");
+        if attr::has_inner(attrs) || !block.stmts.is_empty() {
+            self.space();
+            self.inner_attrs(attrs);
+            match (block.stmts.get(0), block.stmts.get(1)) {
+                (Some(Stmt::Expr(expr, None)), None) if stmt::break_after(expr) => {
+                    self.ibox(0);
+                    self.expr_beginning_of_line(expr, true);
+                    self.end();
+                    self.space();
+                }
+                _ => {
+                    for stmt in &block.stmts {
+                        self.stmt(stmt);
+                    }
+                }
+            }
+            self.offset(-INDENT);
+        }
+        self.word("}");
+    }
+
+    pub fn member(&mut self, member: &Member) {
+        match member {
+            Member::Named(ident) => self.ident(ident),
+            Member::Unnamed(index) => self.index(index),
+        }
+    }
+
+    fn index(&mut self, member: &Index) {
+        self.word(member.index.to_string());
+    }
+
+    fn binary_operator(&mut self, op: &BinOp) {
+        self.word(match op {
+            BinOp::Add(_) => "+",
+            BinOp::Sub(_) => "-",
+            BinOp::Mul(_) => "*",
+            BinOp::Div(_) => "/",
+            BinOp::Rem(_) => "%",
+            BinOp::And(_) => "&&",
+            BinOp::Or(_) => "||",
+            BinOp::BitXor(_) => "^",
+            BinOp::BitAnd(_) => "&",
+            BinOp::BitOr(_) => "|",
+            BinOp::Shl(_) => "<<",
+            BinOp::Shr(_) => ">>",
+            BinOp::Eq(_) => "==",
+            BinOp::Lt(_) => "<",
+            BinOp::Le(_) => "<=",
+            BinOp::Ne(_) => "!=",
+            BinOp::Ge(_) => ">=",
+            BinOp::Gt(_) => ">",
+            BinOp::AddAssign(_) => "+=",
+            BinOp::SubAssign(_) => "-=",
+            BinOp::MulAssign(_) => "*=",
+            BinOp::DivAssign(_) => "/=",
+            BinOp::RemAssign(_) => "%=",
+            BinOp::BitXorAssign(_) => "^=",
+            BinOp::BitAndAssign(_) => "&=",
+            BinOp::BitOrAssign(_) => "|=",
+            BinOp::ShlAssign(_) => "<<=",
+            BinOp::ShrAssign(_) => ">>=",
+            #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
+            _ => unimplemented!("unknown BinOp"),
+        });
+    }
+
+    fn unary_operator(&mut self, op: &UnOp) {
+        self.word(match op {
+            UnOp::Deref(_) => "*",
+            UnOp::Not(_) => "!",
+            UnOp::Neg(_) => "-",
+            #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
+            _ => unimplemented!("unknown UnOp"),
+        });
+    }
+
+    fn zerobreak_unless_short_ident(&mut self, beginning_of_line: bool, expr: &Expr) {
+        if beginning_of_line && is_short_ident(expr) {
+            return;
+        }
+        self.zerobreak();
+    }
+}
+
+pub fn requires_terminator(expr: &Expr) -> bool {
+    // see https://github.com/rust-lang/rust/blob/a266f1199/compiler/rustc_ast/src/util/classify.rs#L7-L26
+    match expr {
+        Expr::If(_)
+        | Expr::Match(_)
+        | Expr::Block(_) | Expr::Unsafe(_) // both under ExprKind::Block in rustc
+        | Expr::While(_)
+        | Expr::Loop(_)
+        | Expr::ForLoop(_)
+        | Expr::TryBlock(_)
+        | Expr::Const(_) => false,
+
+        Expr::Array(_)
+        | Expr::Assign(_)
+        | Expr::Async(_)
+        | Expr::Await(_)
+        | Expr::Binary(_)
+        | Expr::Break(_)
+        | Expr::Call(_)
+        | Expr::Cast(_)
+        | Expr::Closure(_)
+        | Expr::Continue(_)
+        | Expr::Field(_)
+        | Expr::Group(_)
+        | Expr::Index(_)
+        | Expr::Infer(_)
+        | Expr::Let(_)
+        | Expr::Lit(_)
+        | Expr::Macro(_)
+        | Expr::MethodCall(_)
+        | Expr::Paren(_)
+        | Expr::Path(_)
+        | Expr::Range(_)
+        | Expr::Reference(_)
+        | Expr::Repeat(_)
+        | Expr::Return(_)
+        | Expr::Struct(_)
+        | Expr::Try(_)
+        | Expr::Tuple(_)
+        | Expr::Unary(_)
+        | Expr::Verbatim(_)
+        | Expr::Yield(_) => true,
+
+        #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
+        _ => true,
+    }
+}
+
+// Expressions that syntactically contain an "exterior" struct literal i.e. not
+// surrounded by any parens or other delimiters. For example `X { y: 1 }`, `X {
+// y: 1 }.method()`, `foo == X { y: 1 }` and `X { y: 1 } == foo` all do, but `(X
+// { y: 1 }) == foo` does not.
+fn contains_exterior_struct_lit(expr: &Expr) -> bool {
+    match expr {
+        Expr::Struct(_) => true,
+
+        Expr::Assign(ExprAssign { left, right, .. })
+        | Expr::Binary(ExprBinary { left, right, .. }) => {
+            // X { y: 1 } + X { y: 2 }
+            contains_exterior_struct_lit(left) || contains_exterior_struct_lit(right)
+        }
+
+        Expr::Await(ExprAwait { base: e, .. })
+        | Expr::Cast(ExprCast { expr: e, .. })
+        | Expr::Field(ExprField { base: e, .. })
+        | Expr::Index(ExprIndex { expr: e, .. })
+        | Expr::MethodCall(ExprMethodCall { receiver: e, .. })
+        | Expr::Reference(ExprReference { expr: e, .. })
+        | Expr::Unary(ExprUnary { expr: e, .. }) => {
+            // &X { y: 1 }, X { y: 1 }.y
+            contains_exterior_struct_lit(e)
+        }
+
+        Expr::Array(_)
+        | Expr::Async(_)
+        | Expr::Block(_)
+        | Expr::Break(_)
+        | Expr::Call(_)
+        | Expr::Closure(_)
+        | Expr::Const(_)
+        | Expr::Continue(_)
+        | Expr::ForLoop(_)
+        | Expr::Group(_)
+        | Expr::If(_)
+        | Expr::Infer(_)
+        | Expr::Let(_)
+        | Expr::Lit(_)
+        | Expr::Loop(_)
+        | Expr::Macro(_)
+        | Expr::Match(_)
+        | Expr::Paren(_)
+        | Expr::Path(_)
+        | Expr::Range(_)
+        | Expr::Repeat(_)
+        | Expr::Return(_)
+        | Expr::Try(_)
+        | Expr::TryBlock(_)
+        | Expr::Tuple(_)
+        | Expr::Unsafe(_)
+        | Expr::Verbatim(_)
+        | Expr::While(_)
+        | Expr::Yield(_) => false,
+
+        #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
+        _ => false,
+    }
+}
+
+fn needs_newline_if_wrap(expr: &Expr) -> bool {
+    match expr {
+        Expr::Array(_)
+        | Expr::Async(_)
+        | Expr::Block(_)
+        | Expr::Break(ExprBreak { expr: None, .. })
+        | Expr::Closure(_)
+        | Expr::Const(_)
+        | Expr::Continue(_)
+        | Expr::ForLoop(_)
+        | Expr::If(_)
+        | Expr::Infer(_)
+        | Expr::Lit(_)
+        | Expr::Loop(_)
+        | Expr::Macro(_)
+        | Expr::Match(_)
+        | Expr::Path(_)
+        | Expr::Range(ExprRange { end: None, .. })
+        | Expr::Repeat(_)
+        | Expr::Return(ExprReturn { expr: None, .. })
+        | Expr::Struct(_)
+        | Expr::TryBlock(_)
+        | Expr::Tuple(_)
+        | Expr::Unsafe(_)
+        | Expr::Verbatim(_)
+        | Expr::While(_)
+        | Expr::Yield(ExprYield { expr: None, .. }) => false,
+
+        Expr::Assign(_)
+        | Expr::Await(_)
+        | Expr::Binary(_)
+        | Expr::Cast(_)
+        | Expr::Field(_)
+        | Expr::Index(_)
+        | Expr::MethodCall(_) => true,
+
+        Expr::Break(ExprBreak { expr: Some(e), .. })
+        | Expr::Call(ExprCall { func: e, .. })
+        | Expr::Group(ExprGroup { expr: e, .. })
+        | Expr::Let(ExprLet { expr: e, .. })
+        | Expr::Paren(ExprParen { expr: e, .. })
+        | Expr::Range(ExprRange { end: Some(e), .. })
+        | Expr::Reference(ExprReference { expr: e, .. })
+        | Expr::Return(ExprReturn { expr: Some(e), .. })
+        | Expr::Try(ExprTry { expr: e, .. })
+        | Expr::Unary(ExprUnary { expr: e, .. })
+        | Expr::Yield(ExprYield { expr: Some(e), .. }) => needs_newline_if_wrap(e),
+
+        #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
+        _ => false,
+    }
+}
+
+fn is_short_ident(expr: &Expr) -> bool {
+    if let Expr::Path(expr) = expr {
+        return expr.attrs.is_empty()
+            && expr.qself.is_none()
+            && expr
+                .path
+                .get_ident()
+                .map_or(false, |ident| ident.to_string().len() as isize <= INDENT);
+    }
+    false
+}
+
+fn is_blocklike(expr: &Expr) -> bool {
+    match expr {
+        Expr::Array(ExprArray { attrs, .. })
+        | Expr::Async(ExprAsync { attrs, .. })
+        | Expr::Block(ExprBlock { attrs, .. })
+        | Expr::Closure(ExprClosure { attrs, .. })
+        | Expr::Const(ExprConst { attrs, .. })
+        | Expr::Struct(ExprStruct { attrs, .. })
+        | Expr::TryBlock(ExprTryBlock { attrs, .. })
+        | Expr::Tuple(ExprTuple { attrs, .. })
+        | Expr::Unsafe(ExprUnsafe { attrs, .. }) => !attr::has_outer(attrs),
+
+        Expr::Assign(_)
+        | Expr::Await(_)
+        | Expr::Binary(_)
+        | Expr::Break(_)
+        | Expr::Call(_)
+        | Expr::Cast(_)
+        | Expr::Continue(_)
+        | Expr::Field(_)
+        | Expr::ForLoop(_)
+        | Expr::Group(_)
+        | Expr::If(_)
+        | Expr::Index(_)
+        | Expr::Infer(_)
+        | Expr::Let(_)
+        | Expr::Lit(_)
+        | Expr::Loop(_)
+        | Expr::Macro(_)
+        | Expr::Match(_)
+        | Expr::MethodCall(_)
+        | Expr::Paren(_)
+        | Expr::Path(_)
+        | Expr::Range(_)
+        | Expr::Reference(_)
+        | Expr::Repeat(_)
+        | Expr::Return(_)
+        | Expr::Try(_)
+        | Expr::Unary(_)
+        | Expr::Verbatim(_)
+        | Expr::While(_)
+        | Expr::Yield(_) => false,
+
+        #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
+        _ => false,
+    }
+}
diff --git a/crates/prettyplease/src/file.rs b/crates/prettyplease/src/file.rs
new file mode 100644
index 0000000..e23bd12
--- /dev/null
+++ b/crates/prettyplease/src/file.rs
@@ -0,0 +1,17 @@
+use crate::algorithm::Printer;
+use syn::File;
+
+impl Printer {
+    pub fn file(&mut self, file: &File) {
+        self.cbox(0);
+        if let Some(shebang) = &file.shebang {
+            self.word(shebang.clone());
+            self.hardbreak();
+        }
+        self.inner_attrs(&file.attrs);
+        for item in &file.items {
+            self.item(item);
+        }
+        self.end();
+    }
+}
diff --git a/crates/prettyplease/src/generics.rs b/crates/prettyplease/src/generics.rs
new file mode 100644
index 0000000..35da0b2
--- /dev/null
+++ b/crates/prettyplease/src/generics.rs
@@ -0,0 +1,325 @@
+use crate::algorithm::Printer;
+use crate::iter::IterDelimited;
+use crate::path::PathKind;
+use crate::INDENT;
+use proc_macro2::TokenStream;
+use std::ptr;
+use syn::{
+    BoundLifetimes, ConstParam, GenericParam, Generics, LifetimeParam, PredicateLifetime,
+    PredicateType, TraitBound, TraitBoundModifier, TypeParam, TypeParamBound, WhereClause,
+    WherePredicate,
+};
+
+impl Printer {
+    pub fn generics(&mut self, generics: &Generics) {
+        if generics.params.is_empty() {
+            return;
+        }
+
+        self.word("<");
+        self.cbox(0);
+        self.zerobreak();
+
+        // Print lifetimes before types and consts, regardless of their
+        // order in self.params.
+        #[derive(Ord, PartialOrd, Eq, PartialEq)]
+        enum Group {
+            First,
+            Second,
+        }
+        fn group(param: &GenericParam) -> Group {
+            match param {
+                GenericParam::Lifetime(_) => Group::First,
+                GenericParam::Type(_) | GenericParam::Const(_) => Group::Second,
+            }
+        }
+        let last = generics.params.iter().max_by_key(|param| group(param));
+        for current_group in [Group::First, Group::Second] {
+            for param in &generics.params {
+                if group(param) == current_group {
+                    self.generic_param(param);
+                    self.trailing_comma(ptr::eq(param, last.unwrap()));
+                }
+            }
+        }
+
+        self.offset(-INDENT);
+        self.end();
+        self.word(">");
+    }
+
+    fn generic_param(&mut self, generic_param: &GenericParam) {
+        match generic_param {
+            GenericParam::Type(type_param) => self.type_param(type_param),
+            GenericParam::Lifetime(lifetime_param) => self.lifetime_param(lifetime_param),
+            GenericParam::Const(const_param) => self.const_param(const_param),
+        }
+    }
+
+    pub fn bound_lifetimes(&mut self, bound_lifetimes: &BoundLifetimes) {
+        self.word("for<");
+        for param in bound_lifetimes.lifetimes.iter().delimited() {
+            self.generic_param(&param);
+            if !param.is_last {
+                self.word(", ");
+            }
+        }
+        self.word("> ");
+    }
+
+    fn lifetime_param(&mut self, lifetime_param: &LifetimeParam) {
+        self.outer_attrs(&lifetime_param.attrs);
+        self.lifetime(&lifetime_param.lifetime);
+        for lifetime in lifetime_param.bounds.iter().delimited() {
+            if lifetime.is_first {
+                self.word(": ");
+            } else {
+                self.word(" + ");
+            }
+            self.lifetime(&lifetime);
+        }
+    }
+
+    fn type_param(&mut self, type_param: &TypeParam) {
+        self.outer_attrs(&type_param.attrs);
+        self.ident(&type_param.ident);
+        self.ibox(INDENT);
+        for type_param_bound in type_param.bounds.iter().delimited() {
+            if type_param_bound.is_first {
+                self.word(": ");
+            } else {
+                self.space();
+                self.word("+ ");
+            }
+            self.type_param_bound(&type_param_bound);
+        }
+        if let Some(default) = &type_param.default {
+            self.space();
+            self.word("= ");
+            self.ty(default);
+        }
+        self.end();
+    }
+
+    pub fn type_param_bound(&mut self, type_param_bound: &TypeParamBound) {
+        match type_param_bound {
+            TypeParamBound::Trait(trait_bound) => {
+                let tilde_const = false;
+                self.trait_bound(trait_bound, tilde_const);
+            }
+            TypeParamBound::Lifetime(lifetime) => self.lifetime(lifetime),
+            TypeParamBound::Verbatim(bound) => self.type_param_bound_verbatim(bound),
+            #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
+            _ => unimplemented!("unknown TypeParamBound"),
+        }
+    }
+
+    fn trait_bound(&mut self, trait_bound: &TraitBound, tilde_const: bool) {
+        if trait_bound.paren_token.is_some() {
+            self.word("(");
+        }
+        if tilde_const {
+            self.word("~const ");
+        }
+        self.trait_bound_modifier(&trait_bound.modifier);
+        if let Some(bound_lifetimes) = &trait_bound.lifetimes {
+            self.bound_lifetimes(bound_lifetimes);
+        }
+        for segment in trait_bound.path.segments.iter().delimited() {
+            if !segment.is_first || trait_bound.path.leading_colon.is_some() {
+                self.word("::");
+            }
+            self.path_segment(&segment, PathKind::Type);
+        }
+        if trait_bound.paren_token.is_some() {
+            self.word(")");
+        }
+    }
+
+    fn trait_bound_modifier(&mut self, trait_bound_modifier: &TraitBoundModifier) {
+        match trait_bound_modifier {
+            TraitBoundModifier::None => {}
+            TraitBoundModifier::Maybe(_question_mark) => self.word("?"),
+        }
+    }
+
+    #[cfg(not(feature = "verbatim"))]
+    fn type_param_bound_verbatim(&mut self, bound: &TokenStream) {
+        unimplemented!("TypeParamBound::Verbatim `{}`", bound);
+    }
+
+    #[cfg(feature = "verbatim")]
+    fn type_param_bound_verbatim(&mut self, tokens: &TokenStream) {
+        use syn::parse::{Parse, ParseStream, Result};
+        use syn::{parenthesized, token, Token};
+
+        enum TypeParamBoundVerbatim {
+            TildeConst(TraitBound),
+        }
+
+        impl Parse for TypeParamBoundVerbatim {
+            fn parse(input: ParseStream) -> Result<Self> {
+                let content;
+                let (paren_token, content) = if input.peek(token::Paren) {
+                    (Some(parenthesized!(content in input)), &content)
+                } else {
+                    (None, input)
+                };
+                content.parse::<Token![~]>()?;
+                content.parse::<Token![const]>()?;
+                let mut bound: TraitBound = content.parse()?;
+                bound.paren_token = paren_token;
+                Ok(TypeParamBoundVerbatim::TildeConst(bound))
+            }
+        }
+
+        let bound: TypeParamBoundVerbatim = match syn::parse2(tokens.clone()) {
+            Ok(bound) => bound,
+            Err(_) => unimplemented!("TypeParamBound::Verbatim `{}`", tokens),
+        };
+
+        match bound {
+            TypeParamBoundVerbatim::TildeConst(trait_bound) => {
+                let tilde_const = true;
+                self.trait_bound(&trait_bound, tilde_const);
+            }
+        }
+    }
+
+    fn const_param(&mut self, const_param: &ConstParam) {
+        self.outer_attrs(&const_param.attrs);
+        self.word("const ");
+        self.ident(&const_param.ident);
+        self.word(": ");
+        self.ty(&const_param.ty);
+        if let Some(default) = &const_param.default {
+            self.word(" = ");
+            self.expr(default);
+        }
+    }
+
+    pub fn where_clause_for_body(&mut self, where_clause: &Option<WhereClause>) {
+        let hardbreaks = true;
+        let semi = false;
+        self.where_clause_impl(where_clause, hardbreaks, semi);
+    }
+
+    pub fn where_clause_semi(&mut self, where_clause: &Option<WhereClause>) {
+        let hardbreaks = true;
+        let semi = true;
+        self.where_clause_impl(where_clause, hardbreaks, semi);
+    }
+
+    pub fn where_clause_oneline(&mut self, where_clause: &Option<WhereClause>) {
+        let hardbreaks = false;
+        let semi = false;
+        self.where_clause_impl(where_clause, hardbreaks, semi);
+    }
+
+    pub fn where_clause_oneline_semi(&mut self, where_clause: &Option<WhereClause>) {
+        let hardbreaks = false;
+        let semi = true;
+        self.where_clause_impl(where_clause, hardbreaks, semi);
+    }
+
+    fn where_clause_impl(
+        &mut self,
+        where_clause: &Option<WhereClause>,
+        hardbreaks: bool,
+        semi: bool,
+    ) {
+        let where_clause = match where_clause {
+            Some(where_clause) if !where_clause.predicates.is_empty() => where_clause,
+            _ => {
+                if semi {
+                    self.word(";");
+                } else {
+                    self.nbsp();
+                }
+                return;
+            }
+        };
+        if hardbreaks {
+            self.hardbreak();
+            self.offset(-INDENT);
+            self.word("where");
+            self.hardbreak();
+            for predicate in where_clause.predicates.iter().delimited() {
+                self.where_predicate(&predicate);
+                if predicate.is_last && semi {
+                    self.word(";");
+                } else {
+                    self.word(",");
+                    self.hardbreak();
+                }
+            }
+            if !semi {
+                self.offset(-INDENT);
+            }
+        } else {
+            self.space();
+            self.offset(-INDENT);
+            self.word("where");
+            self.space();
+            for predicate in where_clause.predicates.iter().delimited() {
+                self.where_predicate(&predicate);
+                if predicate.is_last && semi {
+                    self.word(";");
+                } else {
+                    self.trailing_comma_or_space(predicate.is_last);
+                }
+            }
+            if !semi {
+                self.offset(-INDENT);
+            }
+        }
+    }
+
+    fn where_predicate(&mut self, predicate: &WherePredicate) {
+        match predicate {
+            WherePredicate::Type(predicate) => self.predicate_type(predicate),
+            WherePredicate::Lifetime(predicate) => self.predicate_lifetime(predicate),
+            #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
+            _ => unimplemented!("unknown WherePredicate"),
+        }
+    }
+
+    fn predicate_type(&mut self, predicate: &PredicateType) {
+        if let Some(bound_lifetimes) = &predicate.lifetimes {
+            self.bound_lifetimes(bound_lifetimes);
+        }
+        self.ty(&predicate.bounded_ty);
+        self.word(":");
+        if predicate.bounds.len() == 1 {
+            self.ibox(0);
+        } else {
+            self.ibox(INDENT);
+        }
+        for type_param_bound in predicate.bounds.iter().delimited() {
+            if type_param_bound.is_first {
+                self.nbsp();
+            } else {
+                self.space();
+                self.word("+ ");
+            }
+            self.type_param_bound(&type_param_bound);
+        }
+        self.end();
+    }
+
+    fn predicate_lifetime(&mut self, predicate: &PredicateLifetime) {
+        self.lifetime(&predicate.lifetime);
+        self.word(":");
+        self.ibox(INDENT);
+        for lifetime in predicate.bounds.iter().delimited() {
+            if lifetime.is_first {
+                self.nbsp();
+            } else {
+                self.space();
+                self.word("+ ");
+            }
+            self.lifetime(&lifetime);
+        }
+        self.end();
+    }
+}
diff --git a/crates/prettyplease/src/item.rs b/crates/prettyplease/src/item.rs
new file mode 100644
index 0000000..88d0c04
--- /dev/null
+++ b/crates/prettyplease/src/item.rs
@@ -0,0 +1,1646 @@
+use crate::algorithm::Printer;
+use crate::iter::IterDelimited;
+use crate::path::PathKind;
+use crate::INDENT;
+use proc_macro2::TokenStream;
+use syn::{
+    Fields, FnArg, ForeignItem, ForeignItemFn, ForeignItemMacro, ForeignItemStatic,
+    ForeignItemType, ImplItem, ImplItemConst, ImplItemFn, ImplItemMacro, ImplItemType, Item,
+    ItemConst, ItemEnum, ItemExternCrate, ItemFn, ItemForeignMod, ItemImpl, ItemMacro, ItemMod,
+    ItemStatic, ItemStruct, ItemTrait, ItemTraitAlias, ItemType, ItemUnion, ItemUse, Receiver,
+    Signature, StaticMutability, TraitItem, TraitItemConst, TraitItemFn, TraitItemMacro,
+    TraitItemType, Type, UseGlob, UseGroup, UseName, UsePath, UseRename, UseTree, Variadic,
+};
+
+impl Printer {
+    pub fn item(&mut self, item: &Item) {
+        match item {
+            Item::Const(item) => self.item_const(item),
+            Item::Enum(item) => self.item_enum(item),
+            Item::ExternCrate(item) => self.item_extern_crate(item),
+            Item::Fn(item) => self.item_fn(item),
+            Item::ForeignMod(item) => self.item_foreign_mod(item),
+            Item::Impl(item) => self.item_impl(item),
+            Item::Macro(item) => self.item_macro(item),
+            Item::Mod(item) => self.item_mod(item),
+            Item::Static(item) => self.item_static(item),
+            Item::Struct(item) => self.item_struct(item),
+            Item::Trait(item) => self.item_trait(item),
+            Item::TraitAlias(item) => self.item_trait_alias(item),
+            Item::Type(item) => self.item_type(item),
+            Item::Union(item) => self.item_union(item),
+            Item::Use(item) => self.item_use(item),
+            Item::Verbatim(item) => self.item_verbatim(item),
+            #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
+            _ => unimplemented!("unknown Item"),
+        }
+    }
+
+    fn item_const(&mut self, item: &ItemConst) {
+        self.outer_attrs(&item.attrs);
+        self.cbox(0);
+        self.visibility(&item.vis);
+        self.word("const ");
+        self.ident(&item.ident);
+        self.generics(&item.generics);
+        self.word(": ");
+        self.ty(&item.ty);
+        self.word(" = ");
+        self.neverbreak();
+        self.expr(&item.expr);
+        self.word(";");
+        self.end();
+        self.hardbreak();
+    }
+
+    fn item_enum(&mut self, item: &ItemEnum) {
+        self.outer_attrs(&item.attrs);
+        self.cbox(INDENT);
+        self.visibility(&item.vis);
+        self.word("enum ");
+        self.ident(&item.ident);
+        self.generics(&item.generics);
+        self.where_clause_for_body(&item.generics.where_clause);
+        self.word("{");
+        self.hardbreak_if_nonempty();
+        for variant in &item.variants {
+            self.variant(variant);
+            self.word(",");
+            self.hardbreak();
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word("}");
+        self.hardbreak();
+    }
+
+    fn item_extern_crate(&mut self, item: &ItemExternCrate) {
+        self.outer_attrs(&item.attrs);
+        self.visibility(&item.vis);
+        self.word("extern crate ");
+        self.ident(&item.ident);
+        if let Some((_as_token, rename)) = &item.rename {
+            self.word(" as ");
+            self.ident(rename);
+        }
+        self.word(";");
+        self.hardbreak();
+    }
+
+    fn item_fn(&mut self, item: &ItemFn) {
+        self.outer_attrs(&item.attrs);
+        self.cbox(INDENT);
+        self.visibility(&item.vis);
+        self.signature(&item.sig);
+        self.where_clause_for_body(&item.sig.generics.where_clause);
+        self.word("{");
+        self.hardbreak_if_nonempty();
+        self.inner_attrs(&item.attrs);
+        for stmt in &item.block.stmts {
+            self.stmt(stmt);
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word("}");
+        self.hardbreak();
+    }
+
+    fn item_foreign_mod(&mut self, item: &ItemForeignMod) {
+        self.outer_attrs(&item.attrs);
+        self.cbox(INDENT);
+        if item.unsafety.is_some() {
+            self.word("unsafe ");
+        }
+        self.abi(&item.abi);
+        self.word("{");
+        self.hardbreak_if_nonempty();
+        self.inner_attrs(&item.attrs);
+        for foreign_item in &item.items {
+            self.foreign_item(foreign_item);
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word("}");
+        self.hardbreak();
+    }
+
+    fn item_impl(&mut self, item: &ItemImpl) {
+        self.outer_attrs(&item.attrs);
+        self.cbox(INDENT);
+        self.ibox(-INDENT);
+        self.cbox(INDENT);
+        if item.defaultness.is_some() {
+            self.word("default ");
+        }
+        if item.unsafety.is_some() {
+            self.word("unsafe ");
+        }
+        self.word("impl");
+        self.generics(&item.generics);
+        self.end();
+        self.nbsp();
+        if let Some((negative_polarity, path, _for_token)) = &item.trait_ {
+            if negative_polarity.is_some() {
+                self.word("!");
+            }
+            self.path(path, PathKind::Type);
+            self.space();
+            self.word("for ");
+        }
+        self.ty(&item.self_ty);
+        self.end();
+        self.where_clause_for_body(&item.generics.where_clause);
+        self.word("{");
+        self.hardbreak_if_nonempty();
+        self.inner_attrs(&item.attrs);
+        for impl_item in &item.items {
+            self.impl_item(impl_item);
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word("}");
+        self.hardbreak();
+    }
+
+    fn item_macro(&mut self, item: &ItemMacro) {
+        self.outer_attrs(&item.attrs);
+        let semicolon = true;
+        self.mac(&item.mac, item.ident.as_ref(), semicolon);
+        self.hardbreak();
+    }
+
+    fn item_mod(&mut self, item: &ItemMod) {
+        self.outer_attrs(&item.attrs);
+        self.cbox(INDENT);
+        self.visibility(&item.vis);
+        if item.unsafety.is_some() {
+            self.word("unsafe ");
+        }
+        self.word("mod ");
+        self.ident(&item.ident);
+        if let Some((_brace, items)) = &item.content {
+            self.word(" {");
+            self.hardbreak_if_nonempty();
+            self.inner_attrs(&item.attrs);
+            for item in items {
+                self.item(item);
+            }
+            self.offset(-INDENT);
+            self.end();
+            self.word("}");
+        } else {
+            self.word(";");
+            self.end();
+        }
+        self.hardbreak();
+    }
+
+    fn item_static(&mut self, item: &ItemStatic) {
+        self.outer_attrs(&item.attrs);
+        self.cbox(0);
+        self.visibility(&item.vis);
+        self.word("static ");
+        self.static_mutability(&item.mutability);
+        self.ident(&item.ident);
+        self.word(": ");
+        self.ty(&item.ty);
+        self.word(" = ");
+        self.neverbreak();
+        self.expr(&item.expr);
+        self.word(";");
+        self.end();
+        self.hardbreak();
+    }
+
+    fn item_struct(&mut self, item: &ItemStruct) {
+        self.outer_attrs(&item.attrs);
+        self.cbox(INDENT);
+        self.visibility(&item.vis);
+        self.word("struct ");
+        self.ident(&item.ident);
+        self.generics(&item.generics);
+        match &item.fields {
+            Fields::Named(fields) => {
+                self.where_clause_for_body(&item.generics.where_clause);
+                self.word("{");
+                self.hardbreak_if_nonempty();
+                for field in &fields.named {
+                    self.field(field);
+                    self.word(",");
+                    self.hardbreak();
+                }
+                self.offset(-INDENT);
+                self.end();
+                self.word("}");
+            }
+            Fields::Unnamed(fields) => {
+                self.fields_unnamed(fields);
+                self.where_clause_semi(&item.generics.where_clause);
+                self.end();
+            }
+            Fields::Unit => {
+                self.where_clause_semi(&item.generics.where_clause);
+                self.end();
+            }
+        }
+        self.hardbreak();
+    }
+
+    fn item_trait(&mut self, item: &ItemTrait) {
+        self.outer_attrs(&item.attrs);
+        self.cbox(INDENT);
+        self.visibility(&item.vis);
+        if item.unsafety.is_some() {
+            self.word("unsafe ");
+        }
+        if item.auto_token.is_some() {
+            self.word("auto ");
+        }
+        self.word("trait ");
+        self.ident(&item.ident);
+        self.generics(&item.generics);
+        for supertrait in item.supertraits.iter().delimited() {
+            if supertrait.is_first {
+                self.word(": ");
+            } else {
+                self.word(" + ");
+            }
+            self.type_param_bound(&supertrait);
+        }
+        self.where_clause_for_body(&item.generics.where_clause);
+        self.word("{");
+        self.hardbreak_if_nonempty();
+        self.inner_attrs(&item.attrs);
+        for trait_item in &item.items {
+            self.trait_item(trait_item);
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word("}");
+        self.hardbreak();
+    }
+
+    fn item_trait_alias(&mut self, item: &ItemTraitAlias) {
+        self.outer_attrs(&item.attrs);
+        self.cbox(INDENT);
+        self.visibility(&item.vis);
+        self.word("trait ");
+        self.ident(&item.ident);
+        self.generics(&item.generics);
+        self.word(" = ");
+        self.neverbreak();
+        for bound in item.bounds.iter().delimited() {
+            if !bound.is_first {
+                self.space();
+                self.word("+ ");
+            }
+            self.type_param_bound(&bound);
+        }
+        self.where_clause_semi(&item.generics.where_clause);
+        self.end();
+        self.hardbreak();
+    }
+
+    fn item_type(&mut self, item: &ItemType) {
+        self.outer_attrs(&item.attrs);
+        self.cbox(INDENT);
+        self.visibility(&item.vis);
+        self.word("type ");
+        self.ident(&item.ident);
+        self.generics(&item.generics);
+        self.where_clause_oneline(&item.generics.where_clause);
+        self.word("= ");
+        self.neverbreak();
+        self.ibox(-INDENT);
+        self.ty(&item.ty);
+        self.end();
+        self.word(";");
+        self.end();
+        self.hardbreak();
+    }
+
+    fn item_union(&mut self, item: &ItemUnion) {
+        self.outer_attrs(&item.attrs);
+        self.cbox(INDENT);
+        self.visibility(&item.vis);
+        self.word("union ");
+        self.ident(&item.ident);
+        self.generics(&item.generics);
+        self.where_clause_for_body(&item.generics.where_clause);
+        self.word("{");
+        self.hardbreak_if_nonempty();
+        for field in &item.fields.named {
+            self.field(field);
+            self.word(",");
+            self.hardbreak();
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word("}");
+        self.hardbreak();
+    }
+
+    fn item_use(&mut self, item: &ItemUse) {
+        self.outer_attrs(&item.attrs);
+        self.visibility(&item.vis);
+        self.word("use ");
+        if item.leading_colon.is_some() {
+            self.word("::");
+        }
+        self.use_tree(&item.tree);
+        self.word(";");
+        self.hardbreak();
+    }
+
+    #[cfg(not(feature = "verbatim"))]
+    fn item_verbatim(&mut self, item: &TokenStream) {
+        if !item.is_empty() {
+            unimplemented!("Item::Verbatim `{}`", item);
+        }
+        self.hardbreak();
+    }
+
+    #[cfg(feature = "verbatim")]
+    fn item_verbatim(&mut self, tokens: &TokenStream) {
+        use syn::parse::{Parse, ParseStream, Result};
+        use syn::punctuated::Punctuated;
+        use syn::{
+            braced, parenthesized, token, Attribute, Generics, Ident, Lifetime, Token, Visibility,
+        };
+        use verbatim::{
+            FlexibleItemConst, FlexibleItemFn, FlexibleItemStatic, FlexibleItemType,
+            WhereClauseLocation,
+        };
+
+        enum ItemVerbatim {
+            Empty,
+            ConstFlexible(FlexibleItemConst),
+            FnFlexible(FlexibleItemFn),
+            ImplFlexible(ImplFlexible),
+            Macro2(Macro2),
+            StaticFlexible(FlexibleItemStatic),
+            TypeFlexible(FlexibleItemType),
+            UseBrace(UseBrace),
+        }
+
+        struct ImplFlexible {
+            attrs: Vec<Attribute>,
+            vis: Visibility,
+            defaultness: bool,
+            unsafety: bool,
+            generics: Generics,
+            constness: ImplConstness,
+            negative_impl: bool,
+            trait_: Option<Type>,
+            self_ty: Type,
+            items: Vec<ImplItem>,
+        }
+
+        enum ImplConstness {
+            None,
+            MaybeConst,
+            Const,
+        }
+
+        struct Macro2 {
+            attrs: Vec<Attribute>,
+            vis: Visibility,
+            ident: Ident,
+            args: Option<TokenStream>,
+            body: TokenStream,
+        }
+
+        struct UseBrace {
+            attrs: Vec<Attribute>,
+            vis: Visibility,
+            trees: Punctuated<RootUseTree, Token![,]>,
+        }
+
+        struct RootUseTree {
+            leading_colon: Option<Token![::]>,
+            inner: UseTree,
+        }
+
+        impl Parse for ImplConstness {
+            fn parse(input: ParseStream) -> Result<Self> {
+                if input.parse::<Option<Token![?]>>()?.is_some() {
+                    input.parse::<Token![const]>()?;
+                    Ok(ImplConstness::MaybeConst)
+                } else if input.parse::<Option<Token![const]>>()?.is_some() {
+                    Ok(ImplConstness::Const)
+                } else {
+                    Ok(ImplConstness::None)
+                }
+            }
+        }
+
+        impl Parse for RootUseTree {
+            fn parse(input: ParseStream) -> Result<Self> {
+                Ok(RootUseTree {
+                    leading_colon: input.parse()?,
+                    inner: input.parse()?,
+                })
+            }
+        }
+
+        impl Parse for ItemVerbatim {
+            fn parse(input: ParseStream) -> Result<Self> {
+                if input.is_empty() {
+                    return Ok(ItemVerbatim::Empty);
+                }
+
+                let mut attrs = input.call(Attribute::parse_outer)?;
+                let vis: Visibility = input.parse()?;
+
+                let lookahead = input.lookahead1();
+                if lookahead.peek(Token![const]) && (input.peek2(Ident) || input.peek2(Token![_])) {
+                    let defaultness = false;
+                    let flexible_item = FlexibleItemConst::parse(attrs, vis, defaultness, input)?;
+                    Ok(ItemVerbatim::ConstFlexible(flexible_item))
+                } else if input.peek(Token![const])
+                    || lookahead.peek(Token![async])
+                    || lookahead.peek(Token![unsafe]) && !input.peek2(Token![impl])
+                    || lookahead.peek(Token![extern])
+                    || lookahead.peek(Token![fn])
+                {
+                    let defaultness = false;
+                    let flexible_item = FlexibleItemFn::parse(attrs, vis, defaultness, input)?;
+                    Ok(ItemVerbatim::FnFlexible(flexible_item))
+                } else if lookahead.peek(Token![default])
+                    || input.peek(Token![unsafe])
+                    || lookahead.peek(Token![impl])
+                {
+                    let defaultness = input.parse::<Option<Token![default]>>()?.is_some();
+                    let unsafety = input.parse::<Option<Token![unsafe]>>()?.is_some();
+                    input.parse::<Token![impl]>()?;
+                    let has_generics = input.peek(Token![<])
+                        && (input.peek2(Token![>])
+                            || input.peek2(Token![#])
+                            || (input.peek2(Ident) || input.peek2(Lifetime))
+                                && (input.peek3(Token![:])
+                                    || input.peek3(Token![,])
+                                    || input.peek3(Token![>])
+                                    || input.peek3(Token![=]))
+                            || input.peek2(Token![const]));
+                    let mut generics: Generics = if has_generics {
+                        input.parse()?
+                    } else {
+                        Generics::default()
+                    };
+                    let constness: ImplConstness = input.parse()?;
+                    let negative_impl =
+                        !input.peek2(token::Brace) && input.parse::<Option<Token![!]>>()?.is_some();
+                    let first_ty: Type = input.parse()?;
+                    let (trait_, self_ty) = if input.parse::<Option<Token![for]>>()?.is_some() {
+                        (Some(first_ty), input.parse()?)
+                    } else {
+                        (None, first_ty)
+                    };
+                    generics.where_clause = input.parse()?;
+                    let content;
+                    braced!(content in input);
+                    let inner_attrs = content.call(Attribute::parse_inner)?;
+                    attrs.extend(inner_attrs);
+                    let mut items = Vec::new();
+                    while !content.is_empty() {
+                        items.push(content.parse()?);
+                    }
+                    Ok(ItemVerbatim::ImplFlexible(ImplFlexible {
+                        attrs,
+                        vis,
+                        defaultness,
+                        unsafety,
+                        generics,
+                        constness,
+                        negative_impl,
+                        trait_,
+                        self_ty,
+                        items,
+                    }))
+                } else if lookahead.peek(Token![macro]) {
+                    input.parse::<Token![macro]>()?;
+                    let ident: Ident = input.parse()?;
+                    let args = if input.peek(token::Paren) {
+                        let paren_content;
+                        parenthesized!(paren_content in input);
+                        Some(paren_content.parse::<TokenStream>()?)
+                    } else {
+                        None
+                    };
+                    let brace_content;
+                    braced!(brace_content in input);
+                    let body: TokenStream = brace_content.parse()?;
+                    Ok(ItemVerbatim::Macro2(Macro2 {
+                        attrs,
+                        vis,
+                        ident,
+                        args,
+                        body,
+                    }))
+                } else if lookahead.peek(Token![static]) {
+                    let flexible_item = FlexibleItemStatic::parse(attrs, vis, input)?;
+                    Ok(ItemVerbatim::StaticFlexible(flexible_item))
+                } else if lookahead.peek(Token![type]) {
+                    let defaultness = false;
+                    let flexible_item = FlexibleItemType::parse(
+                        attrs,
+                        vis,
+                        defaultness,
+                        input,
+                        WhereClauseLocation::BeforeEq,
+                    )?;
+                    Ok(ItemVerbatim::TypeFlexible(flexible_item))
+                } else if lookahead.peek(Token![use]) {
+                    input.parse::<Token![use]>()?;
+                    let content;
+                    braced!(content in input);
+                    let trees = content.parse_terminated(RootUseTree::parse, Token![,])?;
+                    input.parse::<Token![;]>()?;
+                    Ok(ItemVerbatim::UseBrace(UseBrace { attrs, vis, trees }))
+                } else {
+                    Err(lookahead.error())
+                }
+            }
+        }
+
+        let item: ItemVerbatim = match syn::parse2(tokens.clone()) {
+            Ok(item) => item,
+            Err(_) => unimplemented!("Item::Verbatim `{}`", tokens),
+        };
+
+        match item {
+            ItemVerbatim::Empty => {
+                self.hardbreak();
+            }
+            ItemVerbatim::ConstFlexible(item) => {
+                self.flexible_item_const(&item);
+            }
+            ItemVerbatim::FnFlexible(item) => {
+                self.flexible_item_fn(&item);
+            }
+            ItemVerbatim::ImplFlexible(item) => {
+                self.outer_attrs(&item.attrs);
+                self.cbox(INDENT);
+                self.ibox(-INDENT);
+                self.cbox(INDENT);
+                self.visibility(&item.vis);
+                if item.defaultness {
+                    self.word("default ");
+                }
+                if item.unsafety {
+                    self.word("unsafe ");
+                }
+                self.word("impl");
+                self.generics(&item.generics);
+                self.end();
+                self.nbsp();
+                match item.constness {
+                    ImplConstness::None => {}
+                    ImplConstness::MaybeConst => self.word("?const "),
+                    ImplConstness::Const => self.word("const "),
+                }
+                if item.negative_impl {
+                    self.word("!");
+                }
+                if let Some(trait_) = &item.trait_ {
+                    self.ty(trait_);
+                    self.space();
+                    self.word("for ");
+                }
+                self.ty(&item.self_ty);
+                self.end();
+                self.where_clause_for_body(&item.generics.where_clause);
+                self.word("{");
+                self.hardbreak_if_nonempty();
+                self.inner_attrs(&item.attrs);
+                for impl_item in &item.items {
+                    self.impl_item(impl_item);
+                }
+                self.offset(-INDENT);
+                self.end();
+                self.word("}");
+                self.hardbreak();
+            }
+            ItemVerbatim::Macro2(item) => {
+                self.outer_attrs(&item.attrs);
+                self.visibility(&item.vis);
+                self.word("macro ");
+                self.ident(&item.ident);
+                if let Some(args) = &item.args {
+                    self.word("(");
+                    self.cbox(INDENT);
+                    self.zerobreak();
+                    self.ibox(0);
+                    self.macro_rules_tokens(args.clone(), true);
+                    self.end();
+                    self.zerobreak();
+                    self.offset(-INDENT);
+                    self.end();
+                    self.word(")");
+                }
+                self.word(" {");
+                if !item.body.is_empty() {
+                    self.neverbreak();
+                    self.cbox(INDENT);
+                    self.hardbreak();
+                    self.ibox(0);
+                    self.macro_rules_tokens(item.body.clone(), false);
+                    self.end();
+                    self.hardbreak();
+                    self.offset(-INDENT);
+                    self.end();
+                }
+                self.word("}");
+                self.hardbreak();
+            }
+            ItemVerbatim::StaticFlexible(item) => {
+                self.flexible_item_static(&item);
+            }
+            ItemVerbatim::TypeFlexible(item) => {
+                self.flexible_item_type(&item);
+            }
+            ItemVerbatim::UseBrace(item) => {
+                self.outer_attrs(&item.attrs);
+                self.visibility(&item.vis);
+                self.word("use ");
+                if item.trees.len() == 1 {
+                    self.word("::");
+                    self.use_tree(&item.trees[0].inner);
+                } else {
+                    self.cbox(INDENT);
+                    self.word("{");
+                    self.zerobreak();
+                    self.ibox(0);
+                    for use_tree in item.trees.iter().delimited() {
+                        if use_tree.leading_colon.is_some() {
+                            self.word("::");
+                        }
+                        self.use_tree(&use_tree.inner);
+                        if !use_tree.is_last {
+                            self.word(",");
+                            let mut use_tree = &use_tree.inner;
+                            while let UseTree::Path(use_path) = use_tree {
+                                use_tree = &use_path.tree;
+                            }
+                            if let UseTree::Group(_) = use_tree {
+                                self.hardbreak();
+                            } else {
+                                self.space();
+                            }
+                        }
+                    }
+                    self.end();
+                    self.trailing_comma(true);
+                    self.offset(-INDENT);
+                    self.word("}");
+                    self.end();
+                }
+                self.word(";");
+                self.hardbreak();
+            }
+        }
+    }
+
+    fn use_tree(&mut self, use_tree: &UseTree) {
+        match use_tree {
+            UseTree::Path(use_path) => self.use_path(use_path),
+            UseTree::Name(use_name) => self.use_name(use_name),
+            UseTree::Rename(use_rename) => self.use_rename(use_rename),
+            UseTree::Glob(use_glob) => self.use_glob(use_glob),
+            UseTree::Group(use_group) => self.use_group(use_group),
+        }
+    }
+
+    fn use_path(&mut self, use_path: &UsePath) {
+        self.ident(&use_path.ident);
+        self.word("::");
+        self.use_tree(&use_path.tree);
+    }
+
+    fn use_name(&mut self, use_name: &UseName) {
+        self.ident(&use_name.ident);
+    }
+
+    fn use_rename(&mut self, use_rename: &UseRename) {
+        self.ident(&use_rename.ident);
+        self.word(" as ");
+        self.ident(&use_rename.rename);
+    }
+
+    fn use_glob(&mut self, use_glob: &UseGlob) {
+        let _ = use_glob;
+        self.word("*");
+    }
+
+    fn use_group(&mut self, use_group: &UseGroup) {
+        if use_group.items.is_empty() {
+            self.word("{}");
+        } else if use_group.items.len() == 1 {
+            self.use_tree(&use_group.items[0]);
+        } else {
+            self.cbox(INDENT);
+            self.word("{");
+            self.zerobreak();
+            self.ibox(0);
+            for use_tree in use_group.items.iter().delimited() {
+                self.use_tree(&use_tree);
+                if !use_tree.is_last {
+                    self.word(",");
+                    let mut use_tree = *use_tree;
+                    while let UseTree::Path(use_path) = use_tree {
+                        use_tree = &use_path.tree;
+                    }
+                    if let UseTree::Group(_) = use_tree {
+                        self.hardbreak();
+                    } else {
+                        self.space();
+                    }
+                }
+            }
+            self.end();
+            self.trailing_comma(true);
+            self.offset(-INDENT);
+            self.word("}");
+            self.end();
+        }
+    }
+
+    fn foreign_item(&mut self, foreign_item: &ForeignItem) {
+        match foreign_item {
+            ForeignItem::Fn(item) => self.foreign_item_fn(item),
+            ForeignItem::Static(item) => self.foreign_item_static(item),
+            ForeignItem::Type(item) => self.foreign_item_type(item),
+            ForeignItem::Macro(item) => self.foreign_item_macro(item),
+            ForeignItem::Verbatim(item) => self.foreign_item_verbatim(item),
+            #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
+            _ => unimplemented!("unknown ForeignItem"),
+        }
+    }
+
+    fn foreign_item_fn(&mut self, foreign_item: &ForeignItemFn) {
+        self.outer_attrs(&foreign_item.attrs);
+        self.cbox(INDENT);
+        self.visibility(&foreign_item.vis);
+        self.signature(&foreign_item.sig);
+        self.where_clause_semi(&foreign_item.sig.generics.where_clause);
+        self.end();
+        self.hardbreak();
+    }
+
+    fn foreign_item_static(&mut self, foreign_item: &ForeignItemStatic) {
+        self.outer_attrs(&foreign_item.attrs);
+        self.cbox(0);
+        self.visibility(&foreign_item.vis);
+        self.word("static ");
+        self.static_mutability(&foreign_item.mutability);
+        self.ident(&foreign_item.ident);
+        self.word(": ");
+        self.ty(&foreign_item.ty);
+        self.word(";");
+        self.end();
+        self.hardbreak();
+    }
+
+    fn foreign_item_type(&mut self, foreign_item: &ForeignItemType) {
+        self.outer_attrs(&foreign_item.attrs);
+        self.cbox(0);
+        self.visibility(&foreign_item.vis);
+        self.word("type ");
+        self.ident(&foreign_item.ident);
+        self.generics(&foreign_item.generics);
+        self.word(";");
+        self.end();
+        self.hardbreak();
+    }
+
+    fn foreign_item_macro(&mut self, foreign_item: &ForeignItemMacro) {
+        self.outer_attrs(&foreign_item.attrs);
+        let semicolon = true;
+        self.mac(&foreign_item.mac, None, semicolon);
+        self.hardbreak();
+    }
+
+    #[cfg(not(feature = "verbatim"))]
+    fn foreign_item_verbatim(&mut self, foreign_item: &TokenStream) {
+        if !foreign_item.is_empty() {
+            unimplemented!("ForeignItem::Verbatim `{}`", foreign_item);
+        }
+        self.hardbreak();
+    }
+
+    #[cfg(feature = "verbatim")]
+    fn foreign_item_verbatim(&mut self, tokens: &TokenStream) {
+        use syn::parse::{Parse, ParseStream, Result};
+        use syn::{Attribute, Token, Visibility};
+        use verbatim::{FlexibleItemFn, FlexibleItemStatic, FlexibleItemType, WhereClauseLocation};
+
+        enum ForeignItemVerbatim {
+            Empty,
+            FnFlexible(FlexibleItemFn),
+            StaticFlexible(FlexibleItemStatic),
+            TypeFlexible(FlexibleItemType),
+        }
+
+        impl Parse for ForeignItemVerbatim {
+            fn parse(input: ParseStream) -> Result<Self> {
+                if input.is_empty() {
+                    return Ok(ForeignItemVerbatim::Empty);
+                }
+
+                let attrs = input.call(Attribute::parse_outer)?;
+                let vis: Visibility = input.parse()?;
+                let defaultness = false;
+
+                let lookahead = input.lookahead1();
+                if lookahead.peek(Token![const])
+                    || lookahead.peek(Token![async])
+                    || lookahead.peek(Token![unsafe])
+                    || lookahead.peek(Token![extern])
+                    || lookahead.peek(Token![fn])
+                {
+                    let flexible_item = FlexibleItemFn::parse(attrs, vis, defaultness, input)?;
+                    Ok(ForeignItemVerbatim::FnFlexible(flexible_item))
+                } else if lookahead.peek(Token![static]) {
+                    let flexible_item = FlexibleItemStatic::parse(attrs, vis, input)?;
+                    Ok(ForeignItemVerbatim::StaticFlexible(flexible_item))
+                } else if lookahead.peek(Token![type]) {
+                    let flexible_item = FlexibleItemType::parse(
+                        attrs,
+                        vis,
+                        defaultness,
+                        input,
+                        WhereClauseLocation::Both,
+                    )?;
+                    Ok(ForeignItemVerbatim::TypeFlexible(flexible_item))
+                } else {
+                    Err(lookahead.error())
+                }
+            }
+        }
+
+        let foreign_item: ForeignItemVerbatim = match syn::parse2(tokens.clone()) {
+            Ok(foreign_item) => foreign_item,
+            Err(_) => unimplemented!("ForeignItem::Verbatim `{}`", tokens),
+        };
+
+        match foreign_item {
+            ForeignItemVerbatim::Empty => {
+                self.hardbreak();
+            }
+            ForeignItemVerbatim::FnFlexible(foreign_item) => {
+                self.flexible_item_fn(&foreign_item);
+            }
+            ForeignItemVerbatim::StaticFlexible(foreign_item) => {
+                self.flexible_item_static(&foreign_item);
+            }
+            ForeignItemVerbatim::TypeFlexible(foreign_item) => {
+                self.flexible_item_type(&foreign_item);
+            }
+        }
+    }
+
+    fn trait_item(&mut self, trait_item: &TraitItem) {
+        match trait_item {
+            TraitItem::Const(item) => self.trait_item_const(item),
+            TraitItem::Fn(item) => self.trait_item_fn(item),
+            TraitItem::Type(item) => self.trait_item_type(item),
+            TraitItem::Macro(item) => self.trait_item_macro(item),
+            TraitItem::Verbatim(item) => self.trait_item_verbatim(item),
+            #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
+            _ => unimplemented!("unknown TraitItem"),
+        }
+    }
+
+    fn trait_item_const(&mut self, trait_item: &TraitItemConst) {
+        self.outer_attrs(&trait_item.attrs);
+        self.cbox(0);
+        self.word("const ");
+        self.ident(&trait_item.ident);
+        self.generics(&trait_item.generics);
+        self.word(": ");
+        self.ty(&trait_item.ty);
+        if let Some((_eq_token, default)) = &trait_item.default {
+            self.word(" = ");
+            self.neverbreak();
+            self.expr(default);
+        }
+        self.word(";");
+        self.end();
+        self.hardbreak();
+    }
+
+    fn trait_item_fn(&mut self, trait_item: &TraitItemFn) {
+        self.outer_attrs(&trait_item.attrs);
+        self.cbox(INDENT);
+        self.signature(&trait_item.sig);
+        if let Some(block) = &trait_item.default {
+            self.where_clause_for_body(&trait_item.sig.generics.where_clause);
+            self.word("{");
+            self.hardbreak_if_nonempty();
+            self.inner_attrs(&trait_item.attrs);
+            for stmt in &block.stmts {
+                self.stmt(stmt);
+            }
+            self.offset(-INDENT);
+            self.end();
+            self.word("}");
+        } else {
+            self.where_clause_semi(&trait_item.sig.generics.where_clause);
+            self.end();
+        }
+        self.hardbreak();
+    }
+
+    fn trait_item_type(&mut self, trait_item: &TraitItemType) {
+        self.outer_attrs(&trait_item.attrs);
+        self.cbox(INDENT);
+        self.word("type ");
+        self.ident(&trait_item.ident);
+        self.generics(&trait_item.generics);
+        for bound in trait_item.bounds.iter().delimited() {
+            if bound.is_first {
+                self.word(": ");
+            } else {
+                self.space();
+                self.word("+ ");
+            }
+            self.type_param_bound(&bound);
+        }
+        if let Some((_eq_token, default)) = &trait_item.default {
+            self.word(" = ");
+            self.neverbreak();
+            self.ibox(-INDENT);
+            self.ty(default);
+            self.end();
+        }
+        self.where_clause_oneline_semi(&trait_item.generics.where_clause);
+        self.end();
+        self.hardbreak();
+    }
+
+    fn trait_item_macro(&mut self, trait_item: &TraitItemMacro) {
+        self.outer_attrs(&trait_item.attrs);
+        let semicolon = true;
+        self.mac(&trait_item.mac, None, semicolon);
+        self.hardbreak();
+    }
+
+    #[cfg(not(feature = "verbatim"))]
+    fn trait_item_verbatim(&mut self, trait_item: &TokenStream) {
+        if !trait_item.is_empty() {
+            unimplemented!("TraitItem::Verbatim `{}`", trait_item);
+        }
+        self.hardbreak();
+    }
+
+    #[cfg(feature = "verbatim")]
+    fn trait_item_verbatim(&mut self, tokens: &TokenStream) {
+        use syn::parse::{Parse, ParseStream, Result};
+        use syn::{Attribute, Token, Visibility};
+        use verbatim::{FlexibleItemType, WhereClauseLocation};
+
+        enum TraitItemVerbatim {
+            Empty,
+            TypeFlexible(FlexibleItemType),
+            PubOrDefault(PubOrDefaultTraitItem),
+        }
+
+        struct PubOrDefaultTraitItem {
+            attrs: Vec<Attribute>,
+            vis: Visibility,
+            defaultness: bool,
+            trait_item: TraitItem,
+        }
+
+        impl Parse for TraitItemVerbatim {
+            fn parse(input: ParseStream) -> Result<Self> {
+                if input.is_empty() {
+                    return Ok(TraitItemVerbatim::Empty);
+                }
+
+                let attrs = input.call(Attribute::parse_outer)?;
+                let vis: Visibility = input.parse()?;
+                let defaultness = input.parse::<Option<Token![default]>>()?.is_some();
+
+                let lookahead = input.lookahead1();
+                if lookahead.peek(Token![type]) {
+                    let flexible_item = FlexibleItemType::parse(
+                        attrs,
+                        vis,
+                        defaultness,
+                        input,
+                        WhereClauseLocation::AfterEq,
+                    )?;
+                    Ok(TraitItemVerbatim::TypeFlexible(flexible_item))
+                } else if (lookahead.peek(Token![const])
+                    || lookahead.peek(Token![async])
+                    || lookahead.peek(Token![unsafe])
+                    || lookahead.peek(Token![extern])
+                    || lookahead.peek(Token![fn]))
+                    && (!matches!(vis, Visibility::Inherited) || defaultness)
+                {
+                    Ok(TraitItemVerbatim::PubOrDefault(PubOrDefaultTraitItem {
+                        attrs,
+                        vis,
+                        defaultness,
+                        trait_item: input.parse()?,
+                    }))
+                } else {
+                    Err(lookahead.error())
+                }
+            }
+        }
+
+        let impl_item: TraitItemVerbatim = match syn::parse2(tokens.clone()) {
+            Ok(impl_item) => impl_item,
+            Err(_) => unimplemented!("TraitItem::Verbatim `{}`", tokens),
+        };
+
+        match impl_item {
+            TraitItemVerbatim::Empty => {
+                self.hardbreak();
+            }
+            TraitItemVerbatim::TypeFlexible(trait_item) => {
+                self.flexible_item_type(&trait_item);
+            }
+            TraitItemVerbatim::PubOrDefault(trait_item) => {
+                self.outer_attrs(&trait_item.attrs);
+                self.visibility(&trait_item.vis);
+                if trait_item.defaultness {
+                    self.word("default ");
+                }
+                self.trait_item(&trait_item.trait_item);
+            }
+        }
+    }
+
+    fn impl_item(&mut self, impl_item: &ImplItem) {
+        match impl_item {
+            ImplItem::Const(item) => self.impl_item_const(item),
+            ImplItem::Fn(item) => self.impl_item_fn(item),
+            ImplItem::Type(item) => self.impl_item_type(item),
+            ImplItem::Macro(item) => self.impl_item_macro(item),
+            ImplItem::Verbatim(item) => self.impl_item_verbatim(item),
+            #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
+            _ => unimplemented!("unknown ImplItem"),
+        }
+    }
+
+    fn impl_item_const(&mut self, impl_item: &ImplItemConst) {
+        self.outer_attrs(&impl_item.attrs);
+        self.cbox(0);
+        self.visibility(&impl_item.vis);
+        if impl_item.defaultness.is_some() {
+            self.word("default ");
+        }
+        self.word("const ");
+        self.ident(&impl_item.ident);
+        self.generics(&impl_item.generics);
+        self.word(": ");
+        self.ty(&impl_item.ty);
+        self.word(" = ");
+        self.neverbreak();
+        self.expr(&impl_item.expr);
+        self.word(";");
+        self.end();
+        self.hardbreak();
+    }
+
+    fn impl_item_fn(&mut self, impl_item: &ImplItemFn) {
+        self.outer_attrs(&impl_item.attrs);
+        self.cbox(INDENT);
+        self.visibility(&impl_item.vis);
+        if impl_item.defaultness.is_some() {
+            self.word("default ");
+        }
+        self.signature(&impl_item.sig);
+        self.where_clause_for_body(&impl_item.sig.generics.where_clause);
+        self.word("{");
+        self.hardbreak_if_nonempty();
+        self.inner_attrs(&impl_item.attrs);
+        for stmt in &impl_item.block.stmts {
+            self.stmt(stmt);
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word("}");
+        self.hardbreak();
+    }
+
+    fn impl_item_type(&mut self, impl_item: &ImplItemType) {
+        self.outer_attrs(&impl_item.attrs);
+        self.cbox(INDENT);
+        self.visibility(&impl_item.vis);
+        if impl_item.defaultness.is_some() {
+            self.word("default ");
+        }
+        self.word("type ");
+        self.ident(&impl_item.ident);
+        self.generics(&impl_item.generics);
+        self.word(" = ");
+        self.neverbreak();
+        self.ibox(-INDENT);
+        self.ty(&impl_item.ty);
+        self.end();
+        self.where_clause_oneline_semi(&impl_item.generics.where_clause);
+        self.end();
+        self.hardbreak();
+    }
+
+    fn impl_item_macro(&mut self, impl_item: &ImplItemMacro) {
+        self.outer_attrs(&impl_item.attrs);
+        let semicolon = true;
+        self.mac(&impl_item.mac, None, semicolon);
+        self.hardbreak();
+    }
+
+    #[cfg(not(feature = "verbatim"))]
+    fn impl_item_verbatim(&mut self, impl_item: &TokenStream) {
+        if !impl_item.is_empty() {
+            unimplemented!("ImplItem::Verbatim `{}`", impl_item);
+        }
+        self.hardbreak();
+    }
+
+    #[cfg(feature = "verbatim")]
+    fn impl_item_verbatim(&mut self, tokens: &TokenStream) {
+        use syn::parse::{Parse, ParseStream, Result};
+        use syn::{Attribute, Ident, Token, Visibility};
+        use verbatim::{FlexibleItemConst, FlexibleItemFn, FlexibleItemType, WhereClauseLocation};
+
+        enum ImplItemVerbatim {
+            Empty,
+            ConstFlexible(FlexibleItemConst),
+            FnFlexible(FlexibleItemFn),
+            TypeFlexible(FlexibleItemType),
+        }
+
+        impl Parse for ImplItemVerbatim {
+            fn parse(input: ParseStream) -> Result<Self> {
+                if input.is_empty() {
+                    return Ok(ImplItemVerbatim::Empty);
+                }
+
+                let attrs = input.call(Attribute::parse_outer)?;
+                let vis: Visibility = input.parse()?;
+                let defaultness = input.parse::<Option<Token![default]>>()?.is_some();
+
+                let lookahead = input.lookahead1();
+                if lookahead.peek(Token![const]) && (input.peek2(Ident) || input.peek2(Token![_])) {
+                    let flexible_item = FlexibleItemConst::parse(attrs, vis, defaultness, input)?;
+                    Ok(ImplItemVerbatim::ConstFlexible(flexible_item))
+                } else if input.peek(Token![const])
+                    || lookahead.peek(Token![async])
+                    || lookahead.peek(Token![unsafe])
+                    || lookahead.peek(Token![extern])
+                    || lookahead.peek(Token![fn])
+                {
+                    let flexible_item = FlexibleItemFn::parse(attrs, vis, defaultness, input)?;
+                    Ok(ImplItemVerbatim::FnFlexible(flexible_item))
+                } else if lookahead.peek(Token![type]) {
+                    let flexible_item = FlexibleItemType::parse(
+                        attrs,
+                        vis,
+                        defaultness,
+                        input,
+                        WhereClauseLocation::AfterEq,
+                    )?;
+                    Ok(ImplItemVerbatim::TypeFlexible(flexible_item))
+                } else {
+                    Err(lookahead.error())
+                }
+            }
+        }
+
+        let impl_item: ImplItemVerbatim = match syn::parse2(tokens.clone()) {
+            Ok(impl_item) => impl_item,
+            Err(_) => unimplemented!("ImplItem::Verbatim `{}`", tokens),
+        };
+
+        match impl_item {
+            ImplItemVerbatim::Empty => {
+                self.hardbreak();
+            }
+            ImplItemVerbatim::ConstFlexible(impl_item) => {
+                self.flexible_item_const(&impl_item);
+            }
+            ImplItemVerbatim::FnFlexible(impl_item) => {
+                self.flexible_item_fn(&impl_item);
+            }
+            ImplItemVerbatim::TypeFlexible(impl_item) => {
+                self.flexible_item_type(&impl_item);
+            }
+        }
+    }
+
+    fn signature(&mut self, signature: &Signature) {
+        if signature.constness.is_some() {
+            self.word("const ");
+        }
+        if signature.asyncness.is_some() {
+            self.word("async ");
+        }
+        if signature.unsafety.is_some() {
+            self.word("unsafe ");
+        }
+        if let Some(abi) = &signature.abi {
+            self.abi(abi);
+        }
+        self.word("fn ");
+        self.ident(&signature.ident);
+        self.generics(&signature.generics);
+        self.word("(");
+        self.neverbreak();
+        self.cbox(0);
+        self.zerobreak();
+        for input in signature.inputs.iter().delimited() {
+            self.fn_arg(&input);
+            let is_last = input.is_last && signature.variadic.is_none();
+            self.trailing_comma(is_last);
+        }
+        if let Some(variadic) = &signature.variadic {
+            self.variadic(variadic);
+            self.zerobreak();
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word(")");
+        self.cbox(-INDENT);
+        self.return_type(&signature.output);
+        self.end();
+    }
+
+    fn fn_arg(&mut self, fn_arg: &FnArg) {
+        match fn_arg {
+            FnArg::Receiver(receiver) => self.receiver(receiver),
+            FnArg::Typed(pat_type) => self.pat_type(pat_type),
+        }
+    }
+
+    fn receiver(&mut self, receiver: &Receiver) {
+        self.outer_attrs(&receiver.attrs);
+        if let Some((_ampersand, lifetime)) = &receiver.reference {
+            self.word("&");
+            if let Some(lifetime) = lifetime {
+                self.lifetime(lifetime);
+                self.nbsp();
+            }
+        }
+        if receiver.mutability.is_some() {
+            self.word("mut ");
+        }
+        self.word("self");
+        if receiver.colon_token.is_some() {
+            self.word(": ");
+            self.ty(&receiver.ty);
+        } else {
+            let consistent = match (&receiver.reference, &receiver.mutability, &*receiver.ty) {
+                (Some(_), mutability, Type::Reference(ty)) => {
+                    mutability.is_some() == ty.mutability.is_some()
+                        && match &*ty.elem {
+                            Type::Path(ty) => ty.qself.is_none() && ty.path.is_ident("Self"),
+                            _ => false,
+                        }
+                }
+                (None, _, Type::Path(ty)) => ty.qself.is_none() && ty.path.is_ident("Self"),
+                _ => false,
+            };
+            if !consistent {
+                self.word(": ");
+                self.ty(&receiver.ty);
+            }
+        }
+    }
+
+    fn variadic(&mut self, variadic: &Variadic) {
+        self.outer_attrs(&variadic.attrs);
+        if let Some((pat, _colon)) = &variadic.pat {
+            self.pat(pat);
+            self.word(": ");
+        }
+        self.word("...");
+    }
+
+    fn static_mutability(&mut self, mutability: &StaticMutability) {
+        match mutability {
+            StaticMutability::Mut(_) => self.word("mut "),
+            StaticMutability::None => {}
+            #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
+            _ => unimplemented!("unknown StaticMutability"),
+        }
+    }
+}
+
+#[cfg(feature = "verbatim")]
+mod verbatim {
+    use crate::algorithm::Printer;
+    use crate::iter::IterDelimited;
+    use crate::INDENT;
+    use syn::ext::IdentExt;
+    use syn::parse::{ParseStream, Result};
+    use syn::{
+        braced, token, Attribute, Block, Expr, Generics, Ident, Signature, StaticMutability, Stmt,
+        Token, Type, TypeParamBound, Visibility, WhereClause,
+    };
+
+    pub struct FlexibleItemConst {
+        pub attrs: Vec<Attribute>,
+        pub vis: Visibility,
+        pub defaultness: bool,
+        pub ident: Ident,
+        pub ty: Type,
+    }
+
+    pub struct FlexibleItemFn {
+        pub attrs: Vec<Attribute>,
+        pub vis: Visibility,
+        pub defaultness: bool,
+        pub sig: Signature,
+        pub body: Option<Vec<Stmt>>,
+    }
+
+    pub struct FlexibleItemStatic {
+        pub attrs: Vec<Attribute>,
+        pub vis: Visibility,
+        pub mutability: StaticMutability,
+        pub ident: Ident,
+        pub ty: Option<Type>,
+        pub expr: Option<Expr>,
+    }
+
+    pub struct FlexibleItemType {
+        pub attrs: Vec<Attribute>,
+        pub vis: Visibility,
+        pub defaultness: bool,
+        pub ident: Ident,
+        pub generics: Generics,
+        pub bounds: Vec<TypeParamBound>,
+        pub definition: Option<Type>,
+        pub where_clause_after_eq: Option<WhereClause>,
+    }
+
+    pub enum WhereClauseLocation {
+        // type Ty<T> where T: 'static = T;
+        BeforeEq,
+        // type Ty<T> = T where T: 'static;
+        AfterEq,
+        // TODO: goes away once the migration period on rust-lang/rust#89122 is over
+        Both,
+    }
+
+    impl FlexibleItemConst {
+        pub fn parse(
+            attrs: Vec<Attribute>,
+            vis: Visibility,
+            defaultness: bool,
+            input: ParseStream,
+        ) -> Result<Self> {
+            input.parse::<Token![const]>()?;
+            let ident = input.call(Ident::parse_any)?;
+            input.parse::<Token![:]>()?;
+            let ty: Type = input.parse()?;
+            input.parse::<Token![;]>()?;
+
+            Ok(FlexibleItemConst {
+                attrs,
+                vis,
+                defaultness,
+                ident,
+                ty,
+            })
+        }
+    }
+
+    impl FlexibleItemFn {
+        pub fn parse(
+            mut attrs: Vec<Attribute>,
+            vis: Visibility,
+            defaultness: bool,
+            input: ParseStream,
+        ) -> Result<Self> {
+            let sig: Signature = input.parse()?;
+
+            let lookahead = input.lookahead1();
+            let body = if lookahead.peek(Token![;]) {
+                input.parse::<Token![;]>()?;
+                None
+            } else if lookahead.peek(token::Brace) {
+                let content;
+                braced!(content in input);
+                attrs.extend(content.call(Attribute::parse_inner)?);
+                Some(content.call(Block::parse_within)?)
+            } else {
+                return Err(lookahead.error());
+            };
+
+            Ok(FlexibleItemFn {
+                attrs,
+                vis,
+                defaultness,
+                sig,
+                body,
+            })
+        }
+    }
+
+    impl FlexibleItemStatic {
+        pub fn parse(attrs: Vec<Attribute>, vis: Visibility, input: ParseStream) -> Result<Self> {
+            input.parse::<Token![static]>()?;
+            let mutability: StaticMutability = input.parse()?;
+            let ident = input.parse()?;
+
+            let lookahead = input.lookahead1();
+            let has_type = lookahead.peek(Token![:]);
+            let has_expr = lookahead.peek(Token![=]);
+            if !has_type && !has_expr {
+                return Err(lookahead.error());
+            }
+
+            let ty: Option<Type> = if has_type {
+                input.parse::<Token![:]>()?;
+                input.parse().map(Some)?
+            } else {
+                None
+            };
+
+            let expr: Option<Expr> = if input.parse::<Option<Token![=]>>()?.is_some() {
+                input.parse().map(Some)?
+            } else {
+                None
+            };
+
+            input.parse::<Token![;]>()?;
+
+            Ok(FlexibleItemStatic {
+                attrs,
+                vis,
+                mutability,
+                ident,
+                ty,
+                expr,
+            })
+        }
+    }
+
+    impl FlexibleItemType {
+        pub fn parse(
+            attrs: Vec<Attribute>,
+            vis: Visibility,
+            defaultness: bool,
+            input: ParseStream,
+            where_clause_location: WhereClauseLocation,
+        ) -> Result<Self> {
+            input.parse::<Token![type]>()?;
+            let ident: Ident = input.parse()?;
+            let mut generics: Generics = input.parse()?;
+
+            let mut bounds = Vec::new();
+            if input.parse::<Option<Token![:]>>()?.is_some() {
+                loop {
+                    if input.peek(Token![where]) || input.peek(Token![=]) || input.peek(Token![;]) {
+                        break;
+                    }
+                    bounds.push(input.parse::<TypeParamBound>()?);
+                    if input.peek(Token![where]) || input.peek(Token![=]) || input.peek(Token![;]) {
+                        break;
+                    }
+                    input.parse::<Token![+]>()?;
+                }
+            }
+
+            match where_clause_location {
+                WhereClauseLocation::BeforeEq | WhereClauseLocation::Both => {
+                    generics.where_clause = input.parse()?;
+                }
+                WhereClauseLocation::AfterEq => {}
+            }
+
+            let definition = if input.parse::<Option<Token![=]>>()?.is_some() {
+                Some(input.parse()?)
+            } else {
+                None
+            };
+
+            let where_clause_after_eq = match where_clause_location {
+                WhereClauseLocation::AfterEq | WhereClauseLocation::Both
+                    if generics.where_clause.is_none() =>
+                {
+                    input.parse()?
+                }
+                _ => None,
+            };
+
+            input.parse::<Token![;]>()?;
+
+            Ok(FlexibleItemType {
+                attrs,
+                vis,
+                defaultness,
+                ident,
+                generics,
+                bounds,
+                definition,
+                where_clause_after_eq,
+            })
+        }
+    }
+
+    impl Printer {
+        pub fn flexible_item_const(&mut self, item: &FlexibleItemConst) {
+            self.outer_attrs(&item.attrs);
+            self.cbox(0);
+            self.visibility(&item.vis);
+            if item.defaultness {
+                self.word("default ");
+            }
+            self.word("const ");
+            self.ident(&item.ident);
+            self.word(": ");
+            self.ty(&item.ty);
+            self.word(";");
+            self.end();
+            self.hardbreak();
+        }
+
+        pub fn flexible_item_fn(&mut self, item: &FlexibleItemFn) {
+            self.outer_attrs(&item.attrs);
+            self.cbox(INDENT);
+            self.visibility(&item.vis);
+            if item.defaultness {
+                self.word("default ");
+            }
+            self.signature(&item.sig);
+            if let Some(body) = &item.body {
+                self.where_clause_for_body(&item.sig.generics.where_clause);
+                self.word("{");
+                self.hardbreak_if_nonempty();
+                self.inner_attrs(&item.attrs);
+                for stmt in body {
+                    self.stmt(stmt);
+                }
+                self.offset(-INDENT);
+                self.end();
+                self.word("}");
+            } else {
+                self.where_clause_semi(&item.sig.generics.where_clause);
+                self.end();
+            }
+            self.hardbreak();
+        }
+
+        pub fn flexible_item_static(&mut self, item: &FlexibleItemStatic) {
+            self.outer_attrs(&item.attrs);
+            self.cbox(0);
+            self.visibility(&item.vis);
+            self.word("static ");
+            self.static_mutability(&item.mutability);
+            self.ident(&item.ident);
+            if let Some(ty) = &item.ty {
+                self.word(": ");
+                self.ty(ty);
+            }
+            if let Some(expr) = &item.expr {
+                self.word(" = ");
+                self.neverbreak();
+                self.expr(expr);
+            }
+            self.word(";");
+            self.end();
+            self.hardbreak();
+        }
+
+        pub fn flexible_item_type(&mut self, item: &FlexibleItemType) {
+            self.outer_attrs(&item.attrs);
+            self.cbox(INDENT);
+            self.visibility(&item.vis);
+            if item.defaultness {
+                self.word("default ");
+            }
+            self.word("type ");
+            self.ident(&item.ident);
+            self.generics(&item.generics);
+            for bound in item.bounds.iter().delimited() {
+                if bound.is_first {
+                    self.word(": ");
+                } else {
+                    self.space();
+                    self.word("+ ");
+                }
+                self.type_param_bound(&bound);
+            }
+            if let Some(definition) = &item.definition {
+                self.where_clause_oneline(&item.generics.where_clause);
+                self.word("= ");
+                self.neverbreak();
+                self.ibox(-INDENT);
+                self.ty(definition);
+                self.end();
+                self.where_clause_oneline_semi(&item.where_clause_after_eq);
+            } else {
+                self.where_clause_oneline_semi(&item.generics.where_clause);
+            }
+            self.end();
+            self.hardbreak();
+        }
+    }
+}
diff --git a/crates/prettyplease/src/iter.rs b/crates/prettyplease/src/iter.rs
new file mode 100644
index 0000000..702c653
--- /dev/null
+++ b/crates/prettyplease/src/iter.rs
@@ -0,0 +1,46 @@
+use std::iter::Peekable;
+use std::ops::Deref;
+
+pub struct Delimited<I: Iterator> {
+    is_first: bool,
+    iter: Peekable<I>,
+}
+
+pub trait IterDelimited: Iterator + Sized {
+    fn delimited(self) -> Delimited<Self> {
+        Delimited {
+            is_first: true,
+            iter: self.peekable(),
+        }
+    }
+}
+
+impl<I: Iterator> IterDelimited for I {}
+
+pub struct IteratorItem<T> {
+    value: T,
+    pub is_first: bool,
+    pub is_last: bool,
+}
+
+impl<I: Iterator> Iterator for Delimited<I> {
+    type Item = IteratorItem<I::Item>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let item = IteratorItem {
+            value: self.iter.next()?,
+            is_first: self.is_first,
+            is_last: self.iter.peek().is_none(),
+        };
+        self.is_first = false;
+        Some(item)
+    }
+}
+
+impl<T> Deref for IteratorItem<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.value
+    }
+}
diff --git a/crates/prettyplease/src/lib.rs b/crates/prettyplease/src/lib.rs
new file mode 100644
index 0000000..b8d5f04
--- /dev/null
+++ b/crates/prettyplease/src/lib.rs
@@ -0,0 +1,379 @@
+//! [![github]](https://github.com/dtolnay/prettyplease)&ensp;[![crates-io]](https://crates.io/crates/prettyplease)&ensp;[![docs-rs]](https://docs.rs/prettyplease)
+//!
+//! [github]: https://img.shields.io/badge/github-8da0cb?style=for-the-badge&labelColor=555555&logo=github
+//! [crates-io]: https://img.shields.io/badge/crates.io-fc8d62?style=for-the-badge&labelColor=555555&logo=rust
+//! [docs-rs]: https://img.shields.io/badge/docs.rs-66c2a5?style=for-the-badge&labelColor=555555&logo=docs.rs
+//!
+//! <br>
+//!
+//! **prettyplease::unparse** &mdash; a minimal `syn` syntax tree pretty-printer
+//!
+//! <br>
+//!
+//! # Overview
+//!
+//! This is a pretty-printer to turn a `syn` syntax tree into a `String` of
+//! well-formatted source code. In contrast to rustfmt, this library is intended
+//! to be suitable for arbitrary generated code.
+//!
+//! Rustfmt prioritizes high-quality output that is impeccable enough that you'd
+//! be comfortable spending your career staring at its output &mdash; but that
+//! means some heavyweight algorithms, and it has a tendency to bail out on code
+//! that is hard to format (for example [rustfmt#3697], and there are dozens
+//! more issues like it). That's not necessarily a big deal for human-generated
+//! code because when code gets highly nested, the human will naturally be
+//! inclined to refactor into more easily formattable code. But for generated
+//! code, having the formatter just give up leaves it totally unreadable.
+//!
+//! [rustfmt#3697]: https://github.com/rust-lang/rustfmt/issues/3697
+//!
+//! This library is designed using the simplest possible algorithm and data
+//! structures that can deliver about 95% of the quality of rustfmt-formatted
+//! output. In my experience testing real-world code, approximately 97-98% of
+//! output lines come out identical between rustfmt's formatting and this
+//! crate's. The rest have slightly different linebreak decisions, but still
+//! clearly follow the dominant modern Rust style.
+//!
+//! The tradeoffs made by this crate are a good fit for generated code that you
+//! will *not* spend your career staring at. For example, the output of
+//! `bindgen`, or the output of `cargo-expand`. In those cases it's more
+//! important that the whole thing be formattable without the formatter giving
+//! up, than that it be flawless.
+//!
+//! <br>
+//!
+//! # Feature matrix
+//!
+//! Here are a few superficial comparisons of this crate against the AST
+//! pretty-printer built into rustc, and rustfmt. The sections below go into
+//! more detail comparing the output of each of these libraries.
+//!
+//! | | prettyplease | rustc | rustfmt |
+//! |:---|:---:|:---:|:---:|
+//! | non-pathological behavior on big or generated code | 💚 | ❌ | ❌ |
+//! | idiomatic modern formatting ("locally indistinguishable from rustfmt") | 💚 | ❌ | 💚 |
+//! | throughput | 60 MB/s | 39 MB/s | 2.8 MB/s |
+//! | number of dependencies | 3 | 72 | 66 |
+//! | compile time including dependencies | 2.4 sec | 23.1 sec | 29.8 sec |
+//! | buildable using a stable Rust compiler | 💚 | ❌ | ❌ |
+//! | published to crates.io | 💚 | ❌ | ❌ |
+//! | extensively configurable output | ❌ | ❌ | 💚 |
+//! | intended to accommodate hand-maintained source code | ❌ | ❌ | 💚 |
+//!
+//! <br>
+//!
+//! # Comparison to rustfmt
+//!
+//! - [input.rs](https://github.com/dtolnay/prettyplease/blob/0.1.0/examples/input.rs)
+//! - [output.prettyplease.rs](https://github.com/dtolnay/prettyplease/blob/0.1.0/examples/output.prettyplease.rs)
+//! - [output.rustfmt.rs](https://github.com/dtolnay/prettyplease/blob/0.1.0/examples/output.rustfmt.rs)
+//!
+//! If you weren't told which output file is which, it would be practically
+//! impossible to tell &mdash; **except** for line 435 in the rustfmt output,
+//! which is more than 1000 characters long because rustfmt just gave up
+//! formatting that part of the file:
+//!
+//! ```
+//! # const _: &str = stringify! {{{
+//!             match segments[5] {
+//!                 0 => write!(f, "::{}", ipv4),
+//!                 0xffff => write!(f, "::ffff:{}", ipv4),
+//!                 _ => unreachable!(),
+//!             }
+//!         } else { # [derive (Copy , Clone , Default)] struct Span { start : usize , len : usize , } let zeroes = { let mut longest = Span :: default () ; let mut current = Span :: default () ; for (i , & segment) in segments . iter () . enumerate () { if segment == 0 { if current . len == 0 { current . start = i ; } current . len += 1 ; if current . len > longest . len { longest = current ; } } else { current = Span :: default () ; } } longest } ; # [doc = " Write a colon-separated part of the address"] # [inline] fn fmt_subslice (f : & mut fmt :: Formatter < '_ > , chunk : & [u16]) -> fmt :: Result { if let Some ((first , tail)) = chunk . split_first () { write ! (f , "{:x}" , first) ? ; for segment in tail { f . write_char (':') ? ; write ! (f , "{:x}" , segment) ? ; } } Ok (()) } if zeroes . len > 1 { fmt_subslice (f , & segments [.. zeroes . start]) ? ; f . write_str ("::") ? ; fmt_subslice (f , & segments [zeroes . start + zeroes . len ..]) } else { fmt_subslice (f , & segments) } }
+//!     } else {
+//!         const IPV6_BUF_LEN: usize = (4 * 8) + 7;
+//!         let mut buf = [0u8; IPV6_BUF_LEN];
+//!         let mut buf_slice = &mut buf[..];
+//! # }};
+//! ```
+//!
+//! This is a pretty typical manifestation of rustfmt bailing out in generated
+//! code &mdash; a chunk of the input ends up on one line. The other
+//! manifestation is that you're working on some code, running rustfmt on save
+//! like a conscientious developer, but after a while notice it isn't doing
+//! anything. You introduce an intentional formatting issue, like a stray indent
+//! or semicolon, and run rustfmt to check your suspicion. Nope, it doesn't get
+//! cleaned up &mdash; rustfmt is just not formatting the part of the file you
+//! are working on.
+//!
+//! The prettyplease library is designed to have no pathological cases that
+//! force a bail out; the entire input you give it will get formatted in some
+//! "good enough" form.
+//!
+//! Separately, rustfmt can be problematic to integrate into projects. It's
+//! written using rustc's internal syntax tree, so it can't be built by a stable
+//! compiler. Its releases are not regularly published to crates.io, so in Cargo
+//! builds you'd need to depend on it as a git dependency, which precludes
+//! publishing your crate to crates.io also. You can shell out to a `rustfmt`
+//! binary, but that'll be whatever rustfmt version is installed on each
+//! developer's system (if any), which can lead to spurious diffs in checked-in
+//! generated code formatted by different versions. In contrast prettyplease is
+//! designed to be easy to pull in as a library, and compiles fast.
+//!
+//! <br>
+//!
+//! # Comparison to rustc_ast_pretty
+//!
+//! - [input.rs](https://github.com/dtolnay/prettyplease/blob/0.1.0/examples/input.rs)
+//! - [output.prettyplease.rs](https://github.com/dtolnay/prettyplease/blob/0.1.0/examples/output.prettyplease.rs)
+//! - [output.rustc.rs](https://github.com/dtolnay/prettyplease/blob/0.1.0/examples/output.rustc.rs)
+//!
+//! This is the pretty-printer that gets used when rustc prints source code,
+//! such as `rustc -Zunpretty=expanded`. It's used also by the standard
+//! library's `stringify!` when stringifying an interpolated macro_rules AST
+//! fragment, like an $:expr, and transitively by `dbg!` and many macros in the
+//! ecosystem.
+//!
+//! Rustc's formatting is mostly okay, but does not hew closely to the dominant
+//! contemporary style of Rust formatting. Some things wouldn't ever be written
+//! on one line, like this `match` expression, and certainly not with a comma in
+//! front of the closing brace:
+//!
+//! ```
+//! # const _: &str = stringify! {
+//! fn eq(&self, other: &IpAddr) -> bool {
+//!     match other { IpAddr::V4(v4) => self == v4, IpAddr::V6(_) => false, }
+//! }
+//! # };
+//! ```
+//!
+//! Some places use non-multiple-of-4 indentation, which is definitely not the
+//! norm:
+//!
+//! ```
+//! # const _: &str = stringify! {
+//! pub const fn to_ipv6_mapped(&self) -> Ipv6Addr {
+//!     let [a, b, c, d] = self.octets();
+//!     Ipv6Addr{inner:
+//!                  c::in6_addr{s6_addr:
+//!                                  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF,
+//!                                   0xFF, a, b, c, d],},}
+//! }
+//! # };
+//! ```
+//!
+//! And although there isn't an egregious example of it in the link because the
+//! input code is pretty tame, in general rustc_ast_pretty has pathological
+//! behavior on generated code. It has a tendency to use excessive horizontal
+//! indentation and rapidly run out of width:
+//!
+//! ```
+//! # const _: &str = stringify! {
+//! ::std::io::_print(::core::fmt::Arguments::new_v1(&[""],
+//!                                                  &match (&msg,) {
+//!                                                       _args =>
+//!                                                       [::core::fmt::ArgumentV1::new(_args.0,
+//!                                                                                     ::core::fmt::Display::fmt)],
+//!                                                   }));
+//! # };
+//! ```
+//!
+//! The snippets above are clearly different from modern rustfmt style. In
+//! contrast, prettyplease is designed to have output that is practically
+//! indistinguishable from rustfmt-formatted code.
+//!
+//! <br>
+//!
+//! # Example
+//!
+//! ```
+//! // [dependencies]
+//! // prettyplease = "0.2"
+//! // syn = { version = "2", default-features = false, features = ["full", "parsing"] }
+//!
+//! const INPUT: &str = stringify! {
+//!     use crate::{
+//!           lazy::{Lazy, SyncLazy, SyncOnceCell}, panic,
+//!         sync::{ atomic::{AtomicUsize, Ordering::SeqCst},
+//!             mpsc::channel, Mutex, },
+//!       thread,
+//!     };
+//!     impl<T, U> Into<U> for T where U: From<T> {
+//!         fn into(self) -> U { U::from(self) }
+//!     }
+//! };
+//!
+//! fn main() {
+//!     let syntax_tree = syn::parse_file(INPUT).unwrap();
+//!     let formatted = prettyplease::unparse(&syntax_tree);
+//!     print!("{}", formatted);
+//! }
+//! ```
+//!
+//! <br>
+//!
+//! # Algorithm notes
+//!
+//! The approach and terminology used in the implementation are derived from
+//! [*Derek C. Oppen, "Pretty Printing" (1979)*][paper], on which
+//! rustc_ast_pretty is also based, and from rustc_ast_pretty's implementation
+//! written by Graydon Hoare in 2011 (and modernized over the years by dozens of
+//! volunteer maintainers).
+//!
+//! [paper]: http://i.stanford.edu/pub/cstr/reports/cs/tr/79/770/CS-TR-79-770.pdf
+//!
+//! The paper describes two language-agnostic interacting procedures `Scan()`
+//! and `Print()`. Language-specific code decomposes an input data structure
+//! into a stream of `string` and `break` tokens, and `begin` and `end` tokens
+//! for grouping. Each `begin`&ndash;`end` range may be identified as either
+//! "consistent breaking" or "inconsistent breaking". If a group is consistently
+//! breaking, then if the whole contents do not fit on the line, *every* `break`
+//! token in the group will receive a linebreak. This is appropriate, for
+//! example, for Rust struct literals, or arguments of a function call. If a
+//! group is inconsistently breaking, then the `string` tokens in the group are
+//! greedily placed on the line until out of space, and linebroken only at those
+//! `break` tokens for which the next string would not fit. For example, this is
+//! appropriate for the contents of a braced `use` statement in Rust.
+//!
+//! Scan's job is to efficiently accumulate sizing information about groups and
+//! breaks. For every `begin` token we compute the distance to the matched `end`
+//! token, and for every `break` we compute the distance to the next `break`.
+//! The algorithm uses a ringbuffer to hold tokens whose size is not yet
+//! ascertained. The maximum size of the ringbuffer is bounded by the target
+//! line length and does not grow indefinitely, regardless of deep nesting in
+//! the input stream. That's because once a group is sufficiently big, the
+//! precise size can no longer make a difference to linebreak decisions and we
+//! can effectively treat it as "infinity".
+//!
+//! Print's job is to use the sizing information to efficiently assign a
+//! "broken" or "not broken" status to every `begin` token. At that point the
+//! output is easily constructed by concatenating `string` tokens and breaking
+//! at `break` tokens contained within a broken group.
+//!
+//! Leveraging these primitives (i.e. cleverly placing the all-or-nothing
+//! consistent breaks and greedy inconsistent breaks) to yield
+//! rustfmt-compatible formatting for all of Rust's syntax tree nodes is a fun
+//! challenge.
+//!
+//! Here is a visualization of some Rust tokens fed into the pretty printing
+//! algorithm. Consistently breaking `begin`&mdash;`end` pairs are represented
+//! by `«`&#8288;`»`, inconsistently breaking by `‹`&#8288;`›`, `break` by `·`,
+//! and the rest of the non-whitespace are `string`.
+//!
+//! ```text
+//! use crate::«{·
+//! ‹    lazy::«{·‹Lazy,· SyncLazy,· SyncOnceCell›·}»,·
+//!     panic,·
+//!     sync::«{·
+//! ‹        atomic::«{·‹AtomicUsize,· Ordering::SeqCst›·}»,·
+//!         mpsc::channel,· Mutex›,·
+//!     }»,·
+//!     thread›,·
+//! }»;·
+//! «‹«impl<«·T‹›,· U‹›·»>» Into<«·U·»>· for T›·
+//! where·
+//!     U:‹ From<«·T·»>›,·
+//! {·
+//! «    fn into(·«·self·») -> U {·
+//! ‹        U::from(«·self·»)›·
+//! »    }·
+//! »}·
+//! ```
+//!
+//! The algorithm described in the paper is not quite sufficient for producing
+//! well-formatted Rust code that is locally indistinguishable from rustfmt's
+//! style. The reason is that in the paper, the complete non-whitespace contents
+//! are assumed to be independent of linebreak decisions, with Scan and Print
+//! being only in control of the whitespace (spaces and line breaks). In Rust as
+//! idiomatically formattted by rustfmt, that is not the case. Trailing commas
+//! are one example; the punctuation is only known *after* the broken vs
+//! non-broken status of the surrounding group is known:
+//!
+//! ```
+//! # struct Struct { x: u64, y: bool }
+//! # let xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx = 0;
+//! # let yyyyyyyyyyyyyyyyyyyyyyyyyyyyyy = true;
+//! #
+//! let _ = Struct { x: 0, y: true };
+//!
+//! let _ = Struct {
+//!     x: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx,
+//!     y: yyyyyyyyyyyyyyyyyyyyyyyyyyyyyy,   //<- trailing comma if the expression wrapped
+//! };
+//! ```
+//!
+//! The formatting of `match` expressions is another case; we want small arms on
+//! the same line as the pattern, and big arms wrapped in a brace. The presence
+//! of the brace punctuation, comma, and semicolon are all dependent on whether
+//! the arm fits on the line:
+//!
+//! ```
+//! # struct Entry { nanos: u32 }
+//! # let total_nanos = 0u64;
+//! # let mut total_secs = 0u64;
+//! # let tmp;
+//! # let entry = Entry { nanos: 0 };
+//! # const NANOS_PER_SEC: u32 = 1_000_000_000;
+//! #
+//! match total_nanos.checked_add(entry.nanos as u64) {
+//!     Some(n) => tmp = n,   //<- small arm, inline with comma
+//!     None => {
+//!         total_secs = total_secs
+//!             .checked_add(total_nanos / NANOS_PER_SEC as u64)
+//!             .expect("overflow in iter::sum over durations");
+//!     }   //<- big arm, needs brace added, and also semicolon^
+//! }
+//! ```
+//!
+//! The printing algorithm implementation in this crate accommodates all of
+//! these situations with conditional punctuation tokens whose selection can be
+//! deferred and populated after it's known that the group is or is not broken.
+
+#![doc(html_root_url = "https://docs.rs/prettyplease/0.2.6")]
+#![allow(
+    clippy::cast_possible_wrap,
+    clippy::cast_sign_loss,
+    clippy::derive_partial_eq_without_eq,
+    clippy::doc_markdown,
+    clippy::enum_glob_use,
+    clippy::items_after_statements,
+    clippy::let_underscore_untyped,
+    clippy::match_like_matches_macro,
+    clippy::match_same_arms,
+    clippy::module_name_repetitions,
+    clippy::must_use_candidate,
+    clippy::needless_pass_by_value,
+    clippy::similar_names,
+    clippy::too_many_lines,
+    clippy::unused_self,
+    clippy::vec_init_then_push
+)]
+#![cfg_attr(all(test, exhaustive), feature(non_exhaustive_omitted_patterns_lint))]
+
+mod algorithm;
+mod attr;
+mod convenience;
+mod data;
+mod expr;
+mod file;
+mod generics;
+mod item;
+mod iter;
+mod lifetime;
+mod lit;
+mod mac;
+mod pat;
+mod path;
+mod ring;
+mod stmt;
+mod token;
+mod ty;
+
+use crate::algorithm::Printer;
+use syn::File;
+
+// Target line width.
+const MARGIN: isize = 89;
+
+// Number of spaces increment at each level of block indentation.
+const INDENT: isize = 4;
+
+// Every line is allowed at least this much space, even if highly indented.
+const MIN_SPACE: isize = 60;
+
+pub fn unparse(file: &File) -> String {
+    let mut p = Printer::new();
+    p.file(file);
+    p.eof()
+}
diff --git a/crates/prettyplease/src/lifetime.rs b/crates/prettyplease/src/lifetime.rs
new file mode 100644
index 0000000..665caa3
--- /dev/null
+++ b/crates/prettyplease/src/lifetime.rs
@@ -0,0 +1,9 @@
+use crate::algorithm::Printer;
+use syn::Lifetime;
+
+impl Printer {
+    pub fn lifetime(&mut self, lifetime: &Lifetime) {
+        self.word("'");
+        self.ident(&lifetime.ident);
+    }
+}
diff --git a/crates/prettyplease/src/lit.rs b/crates/prettyplease/src/lit.rs
new file mode 100644
index 0000000..c38cf60
--- /dev/null
+++ b/crates/prettyplease/src/lit.rs
@@ -0,0 +1,52 @@
+use crate::algorithm::Printer;
+use proc_macro2::Literal;
+use syn::{Lit, LitBool, LitByte, LitByteStr, LitChar, LitFloat, LitInt, LitStr};
+
+impl Printer {
+    pub fn lit(&mut self, lit: &Lit) {
+        match lit {
+            Lit::Str(lit) => self.lit_str(lit),
+            Lit::ByteStr(lit) => self.lit_byte_str(lit),
+            Lit::Byte(lit) => self.lit_byte(lit),
+            Lit::Char(lit) => self.lit_char(lit),
+            Lit::Int(lit) => self.lit_int(lit),
+            Lit::Float(lit) => self.lit_float(lit),
+            Lit::Bool(lit) => self.lit_bool(lit),
+            Lit::Verbatim(lit) => self.lit_verbatim(lit),
+            #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
+            _ => unimplemented!("unknown Lit"),
+        }
+    }
+
+    pub fn lit_str(&mut self, lit: &LitStr) {
+        self.word(lit.token().to_string());
+    }
+
+    fn lit_byte_str(&mut self, lit: &LitByteStr) {
+        self.word(lit.token().to_string());
+    }
+
+    fn lit_byte(&mut self, lit: &LitByte) {
+        self.word(lit.token().to_string());
+    }
+
+    fn lit_char(&mut self, lit: &LitChar) {
+        self.word(lit.token().to_string());
+    }
+
+    fn lit_int(&mut self, lit: &LitInt) {
+        self.word(lit.token().to_string());
+    }
+
+    fn lit_float(&mut self, lit: &LitFloat) {
+        self.word(lit.token().to_string());
+    }
+
+    fn lit_bool(&mut self, lit: &LitBool) {
+        self.word(if lit.value { "true" } else { "false" });
+    }
+
+    fn lit_verbatim(&mut self, token: &Literal) {
+        self.word(token.to_string());
+    }
+}
diff --git a/crates/prettyplease/src/mac.rs b/crates/prettyplease/src/mac.rs
new file mode 100644
index 0000000..731b1f0
--- /dev/null
+++ b/crates/prettyplease/src/mac.rs
@@ -0,0 +1,218 @@
+use crate::algorithm::Printer;
+use crate::path::PathKind;
+use crate::token::Token;
+use crate::INDENT;
+use proc_macro2::{Delimiter, Spacing, TokenStream};
+use syn::{Ident, Macro, MacroDelimiter};
+
+impl Printer {
+    pub fn mac(&mut self, mac: &Macro, ident: Option<&Ident>, semicolon: bool) {
+        if mac.path.is_ident("macro_rules") {
+            if let Some(ident) = ident {
+                self.macro_rules(ident, &mac.tokens);
+                return;
+            }
+        }
+        self.path(&mac.path, PathKind::Simple);
+        self.word("!");
+        if let Some(ident) = ident {
+            self.nbsp();
+            self.ident(ident);
+        }
+        let (open, close, delimiter_break) = match mac.delimiter {
+            MacroDelimiter::Paren(_) => ("(", ")", Self::zerobreak as fn(&mut Self)),
+            MacroDelimiter::Brace(_) => (" {", "}", Self::hardbreak as fn(&mut Self)),
+            MacroDelimiter::Bracket(_) => ("[", "]", Self::zerobreak as fn(&mut Self)),
+        };
+        self.word(open);
+        if !mac.tokens.is_empty() {
+            self.cbox(INDENT);
+            delimiter_break(self);
+            self.ibox(0);
+            self.macro_rules_tokens(mac.tokens.clone(), false);
+            self.end();
+            delimiter_break(self);
+            self.offset(-INDENT);
+            self.end();
+        }
+        self.word(close);
+        if semicolon {
+            match mac.delimiter {
+                MacroDelimiter::Paren(_) | MacroDelimiter::Bracket(_) => self.word(";"),
+                MacroDelimiter::Brace(_) => {}
+            }
+        }
+    }
+
+    fn macro_rules(&mut self, name: &Ident, rules: &TokenStream) {
+        enum State {
+            Start,
+            Matcher,
+            Equal,
+            Greater,
+            Expander,
+        }
+
+        use State::*;
+
+        self.word("macro_rules! ");
+        self.ident(name);
+        self.word(" {");
+        self.cbox(INDENT);
+        self.hardbreak_if_nonempty();
+        let mut state = State::Start;
+        for tt in rules.clone() {
+            let token = Token::from(tt);
+            match (state, token) {
+                (Start, Token::Group(delimiter, stream)) => {
+                    self.delimiter_open(delimiter);
+                    if !stream.is_empty() {
+                        self.cbox(INDENT);
+                        self.zerobreak();
+                        self.ibox(0);
+                        self.macro_rules_tokens(stream, true);
+                        self.end();
+                        self.zerobreak();
+                        self.offset(-INDENT);
+                        self.end();
+                    }
+                    self.delimiter_close(delimiter);
+                    state = Matcher;
+                }
+                (Matcher, Token::Punct('=', Spacing::Joint)) => {
+                    self.word(" =");
+                    state = Equal;
+                }
+                (Equal, Token::Punct('>', Spacing::Alone)) => {
+                    self.word(">");
+                    state = Greater;
+                }
+                (Greater, Token::Group(_delimiter, stream)) => {
+                    self.word(" {");
+                    self.neverbreak();
+                    if !stream.is_empty() {
+                        self.cbox(INDENT);
+                        self.hardbreak();
+                        self.ibox(0);
+                        self.macro_rules_tokens(stream, false);
+                        self.end();
+                        self.hardbreak();
+                        self.offset(-INDENT);
+                        self.end();
+                    }
+                    self.word("}");
+                    state = Expander;
+                }
+                (Expander, Token::Punct(';', Spacing::Alone)) => {
+                    self.word(";");
+                    self.hardbreak();
+                    state = Start;
+                }
+                _ => unimplemented!("bad macro_rules syntax"),
+            }
+        }
+        match state {
+            Start => {}
+            Expander => {
+                self.word(";");
+                self.hardbreak();
+            }
+            _ => self.hardbreak(),
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word("}");
+    }
+
+    pub fn macro_rules_tokens(&mut self, stream: TokenStream, matcher: bool) {
+        #[derive(PartialEq)]
+        enum State {
+            Start,
+            Dollar,
+            DollarIdent,
+            DollarIdentColon,
+            DollarParen,
+            DollarParenSep,
+            Pound,
+            PoundBang,
+            Dot,
+            Colon,
+            Colon2,
+            Ident,
+            IdentBang,
+            Delim,
+            Other,
+        }
+
+        use State::*;
+
+        let mut state = Start;
+        let mut previous_is_joint = true;
+        for tt in stream {
+            let token = Token::from(tt);
+            let (needs_space, next_state) = match (&state, &token) {
+                (Dollar, Token::Ident(_)) => (false, if matcher { DollarIdent } else { Other }),
+                (DollarIdent, Token::Punct(':', Spacing::Alone)) => (false, DollarIdentColon),
+                (DollarIdentColon, Token::Ident(_)) => (false, Other),
+                (DollarParen, Token::Punct('+' | '*' | '?', Spacing::Alone)) => (false, Other),
+                (DollarParen, Token::Ident(_) | Token::Literal(_)) => (false, DollarParenSep),
+                (DollarParen, Token::Punct(_, Spacing::Joint)) => (false, DollarParen),
+                (DollarParen, Token::Punct(_, Spacing::Alone)) => (false, DollarParenSep),
+                (DollarParenSep, Token::Punct('+' | '*', _)) => (false, Other),
+                (Pound, Token::Punct('!', _)) => (false, PoundBang),
+                (Dollar, Token::Group(Delimiter::Parenthesis, _)) => (false, DollarParen),
+                (Pound | PoundBang, Token::Group(Delimiter::Bracket, _)) => (false, Other),
+                (Ident, Token::Group(Delimiter::Parenthesis | Delimiter::Bracket, _)) => {
+                    (false, Delim)
+                }
+                (Ident, Token::Punct('!', Spacing::Alone)) => (false, IdentBang),
+                (IdentBang, Token::Group(Delimiter::Parenthesis | Delimiter::Bracket, _)) => {
+                    (false, Other)
+                }
+                (Colon, Token::Punct(':', _)) => (false, Colon2),
+                (_, Token::Group(Delimiter::Parenthesis | Delimiter::Bracket, _)) => (true, Delim),
+                (_, Token::Group(Delimiter::Brace | Delimiter::None, _)) => (true, Other),
+                (_, Token::Ident(ident)) if !is_keyword(ident) => {
+                    (state != Dot && state != Colon2, Ident)
+                }
+                (_, Token::Literal(_)) => (state != Dot, Ident),
+                (_, Token::Punct(',' | ';', _)) => (false, Other),
+                (_, Token::Punct('.', _)) if !matcher => (state != Ident && state != Delim, Dot),
+                (_, Token::Punct(':', Spacing::Joint)) => (state != Ident, Colon),
+                (_, Token::Punct('$', _)) => (true, Dollar),
+                (_, Token::Punct('#', _)) => (true, Pound),
+                (_, _) => (true, Other),
+            };
+            if !previous_is_joint {
+                if needs_space {
+                    self.space();
+                } else if let Token::Punct('.', _) = token {
+                    self.zerobreak();
+                }
+            }
+            previous_is_joint = match token {
+                Token::Punct(_, Spacing::Joint) | Token::Punct('$', _) => true,
+                _ => false,
+            };
+            self.single_token(
+                token,
+                if matcher {
+                    |printer, stream| printer.macro_rules_tokens(stream, true)
+                } else {
+                    |printer, stream| printer.macro_rules_tokens(stream, false)
+                },
+            );
+            state = next_state;
+        }
+    }
+}
+
+fn is_keyword(ident: &Ident) -> bool {
+    match ident.to_string().as_str() {
+        "as" | "async" | "await" | "box" | "break" | "const" | "continue" | "crate" | "dyn"
+        | "else" | "enum" | "extern" | "fn" | "for" | "if" | "impl" | "in" | "let" | "loop"
+        | "macro" | "match" | "mod" | "move" | "mut" | "pub" | "ref" | "return" | "static"
+        | "struct" | "trait" | "type" | "unsafe" | "use" | "where" | "while" | "yield" => true,
+        _ => false,
+    }
+}
diff --git a/crates/prettyplease/src/pat.rs b/crates/prettyplease/src/pat.rs
new file mode 100644
index 0000000..ba9c84d
--- /dev/null
+++ b/crates/prettyplease/src/pat.rs
@@ -0,0 +1,246 @@
+use crate::algorithm::Printer;
+use crate::iter::IterDelimited;
+use crate::path::PathKind;
+use crate::INDENT;
+use proc_macro2::TokenStream;
+use syn::{
+    FieldPat, Pat, PatIdent, PatOr, PatParen, PatReference, PatRest, PatSlice, PatStruct, PatTuple,
+    PatTupleStruct, PatType, PatWild,
+};
+
+impl Printer {
+    pub fn pat(&mut self, pat: &Pat) {
+        match pat {
+            Pat::Const(pat) => self.expr_const(pat),
+            Pat::Ident(pat) => self.pat_ident(pat),
+            Pat::Lit(pat) => self.expr_lit(pat),
+            Pat::Macro(pat) => self.expr_macro(pat),
+            Pat::Or(pat) => self.pat_or(pat),
+            Pat::Paren(pat) => self.pat_paren(pat),
+            Pat::Path(pat) => self.expr_path(pat),
+            Pat::Range(pat) => self.expr_range(pat),
+            Pat::Reference(pat) => self.pat_reference(pat),
+            Pat::Rest(pat) => self.pat_rest(pat),
+            Pat::Slice(pat) => self.pat_slice(pat),
+            Pat::Struct(pat) => self.pat_struct(pat),
+            Pat::Tuple(pat) => self.pat_tuple(pat),
+            Pat::TupleStruct(pat) => self.pat_tuple_struct(pat),
+            Pat::Type(pat) => self.pat_type(pat),
+            Pat::Verbatim(pat) => self.pat_verbatim(pat),
+            Pat::Wild(pat) => self.pat_wild(pat),
+            #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
+            _ => unimplemented!("unknown Pat"),
+        }
+    }
+
+    fn pat_ident(&mut self, pat: &PatIdent) {
+        self.outer_attrs(&pat.attrs);
+        if pat.by_ref.is_some() {
+            self.word("ref ");
+        }
+        if pat.mutability.is_some() {
+            self.word("mut ");
+        }
+        self.ident(&pat.ident);
+        if let Some((_at_token, subpat)) = &pat.subpat {
+            self.word(" @ ");
+            self.pat(subpat);
+        }
+    }
+
+    fn pat_or(&mut self, pat: &PatOr) {
+        self.outer_attrs(&pat.attrs);
+        let mut consistent_break = false;
+        for case in &pat.cases {
+            match case {
+                Pat::Lit(_) | Pat::Wild(_) => {}
+                _ => {
+                    consistent_break = true;
+                    break;
+                }
+            }
+        }
+        if consistent_break {
+            self.cbox(0);
+        } else {
+            self.ibox(0);
+        }
+        for case in pat.cases.iter().delimited() {
+            if !case.is_first {
+                self.space();
+                self.word("| ");
+            }
+            self.pat(&case);
+        }
+        self.end();
+    }
+
+    fn pat_paren(&mut self, pat: &PatParen) {
+        self.outer_attrs(&pat.attrs);
+        self.word("(");
+        self.pat(&pat.pat);
+        self.word(")");
+    }
+
+    fn pat_reference(&mut self, pat: &PatReference) {
+        self.outer_attrs(&pat.attrs);
+        self.word("&");
+        if pat.mutability.is_some() {
+            self.word("mut ");
+        }
+        self.pat(&pat.pat);
+    }
+
+    fn pat_rest(&mut self, pat: &PatRest) {
+        self.outer_attrs(&pat.attrs);
+        self.word("..");
+    }
+
+    fn pat_slice(&mut self, pat: &PatSlice) {
+        self.outer_attrs(&pat.attrs);
+        self.word("[");
+        for elem in pat.elems.iter().delimited() {
+            self.pat(&elem);
+            self.trailing_comma(elem.is_last);
+        }
+        self.word("]");
+    }
+
+    fn pat_struct(&mut self, pat: &PatStruct) {
+        self.outer_attrs(&pat.attrs);
+        self.cbox(INDENT);
+        self.path(&pat.path, PathKind::Expr);
+        self.word(" {");
+        self.space_if_nonempty();
+        for field in pat.fields.iter().delimited() {
+            self.field_pat(&field);
+            self.trailing_comma_or_space(field.is_last && pat.rest.is_none());
+        }
+        if let Some(rest) = &pat.rest {
+            self.pat_rest(rest);
+            self.space();
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word("}");
+    }
+
+    fn pat_tuple(&mut self, pat: &PatTuple) {
+        self.outer_attrs(&pat.attrs);
+        self.word("(");
+        self.cbox(INDENT);
+        self.zerobreak();
+        for elem in pat.elems.iter().delimited() {
+            self.pat(&elem);
+            if pat.elems.len() == 1 {
+                if pat.elems.trailing_punct() {
+                    self.word(",");
+                }
+                self.zerobreak();
+            } else {
+                self.trailing_comma(elem.is_last);
+            }
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word(")");
+    }
+
+    fn pat_tuple_struct(&mut self, pat: &PatTupleStruct) {
+        self.outer_attrs(&pat.attrs);
+        self.path(&pat.path, PathKind::Expr);
+        self.word("(");
+        self.cbox(INDENT);
+        self.zerobreak();
+        for elem in pat.elems.iter().delimited() {
+            self.pat(&elem);
+            self.trailing_comma(elem.is_last);
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word(")");
+    }
+
+    pub fn pat_type(&mut self, pat: &PatType) {
+        self.outer_attrs(&pat.attrs);
+        self.pat(&pat.pat);
+        self.word(": ");
+        self.ty(&pat.ty);
+    }
+
+    #[cfg(not(feature = "verbatim"))]
+    fn pat_verbatim(&mut self, pat: &TokenStream) {
+        unimplemented!("Pat::Verbatim `{}`", pat);
+    }
+
+    #[cfg(feature = "verbatim")]
+    fn pat_verbatim(&mut self, tokens: &TokenStream) {
+        use syn::parse::{Parse, ParseStream, Result};
+        use syn::{braced, Attribute, Block, Token};
+
+        enum PatVerbatim {
+            Box(Pat),
+            Const(PatConst),
+        }
+
+        struct PatConst {
+            attrs: Vec<Attribute>,
+            block: Block,
+        }
+
+        impl Parse for PatVerbatim {
+            fn parse(input: ParseStream) -> Result<Self> {
+                let lookahead = input.lookahead1();
+                if lookahead.peek(Token![box]) {
+                    input.parse::<Token![box]>()?;
+                    let inner = Pat::parse_single(input)?;
+                    Ok(PatVerbatim::Box(inner))
+                } else if lookahead.peek(Token![const]) {
+                    input.parse::<Token![const]>()?;
+                    let content;
+                    let brace_token = braced!(content in input);
+                    let attrs = content.call(Attribute::parse_inner)?;
+                    let stmts = content.call(Block::parse_within)?;
+                    Ok(PatVerbatim::Const(PatConst {
+                        attrs,
+                        block: Block { brace_token, stmts },
+                    }))
+                } else {
+                    Err(lookahead.error())
+                }
+            }
+        }
+
+        let pat: PatVerbatim = match syn::parse2(tokens.clone()) {
+            Ok(pat) => pat,
+            Err(_) => unimplemented!("Pat::Verbatim `{}`", tokens),
+        };
+
+        match pat {
+            PatVerbatim::Box(pat) => {
+                self.word("box ");
+                self.pat(&pat);
+            }
+            PatVerbatim::Const(pat) => {
+                self.word("const ");
+                self.cbox(INDENT);
+                self.small_block(&pat.block, &pat.attrs);
+                self.end();
+            }
+        }
+    }
+
+    fn pat_wild(&mut self, pat: &PatWild) {
+        self.outer_attrs(&pat.attrs);
+        self.word("_");
+    }
+
+    fn field_pat(&mut self, field_pat: &FieldPat) {
+        self.outer_attrs(&field_pat.attrs);
+        if field_pat.colon_token.is_some() {
+            self.member(&field_pat.member);
+            self.word(": ");
+        }
+        self.pat(&field_pat.pat);
+    }
+}
diff --git a/crates/prettyplease/src/path.rs b/crates/prettyplease/src/path.rs
new file mode 100644
index 0000000..d704bfd
--- /dev/null
+++ b/crates/prettyplease/src/path.rs
@@ -0,0 +1,207 @@
+use crate::algorithm::Printer;
+use crate::iter::IterDelimited;
+use crate::INDENT;
+use std::ptr;
+use syn::{
+    AngleBracketedGenericArguments, AssocConst, AssocType, Constraint, Expr, GenericArgument,
+    ParenthesizedGenericArguments, Path, PathArguments, PathSegment, QSelf,
+};
+
+#[derive(Copy, Clone, PartialEq)]
+pub enum PathKind {
+    // a::B
+    Simple,
+    // a::B<T>
+    Type,
+    // a::B::<T>
+    Expr,
+}
+
+impl Printer {
+    pub fn path(&mut self, path: &Path, kind: PathKind) {
+        assert!(!path.segments.is_empty());
+        for segment in path.segments.iter().delimited() {
+            if !segment.is_first || path.leading_colon.is_some() {
+                self.word("::");
+            }
+            self.path_segment(&segment, kind);
+        }
+    }
+
+    pub fn path_segment(&mut self, segment: &PathSegment, kind: PathKind) {
+        self.ident(&segment.ident);
+        self.path_arguments(&segment.arguments, kind);
+    }
+
+    fn path_arguments(&mut self, arguments: &PathArguments, kind: PathKind) {
+        match arguments {
+            PathArguments::None => {}
+            PathArguments::AngleBracketed(arguments) => {
+                self.angle_bracketed_generic_arguments(arguments, kind);
+            }
+            PathArguments::Parenthesized(arguments) => {
+                self.parenthesized_generic_arguments(arguments);
+            }
+        }
+    }
+
+    fn generic_argument(&mut self, arg: &GenericArgument) {
+        match arg {
+            GenericArgument::Lifetime(lifetime) => self.lifetime(lifetime),
+            GenericArgument::Type(ty) => self.ty(ty),
+            GenericArgument::Const(expr) => {
+                match expr {
+                    Expr::Lit(expr) => self.expr_lit(expr),
+                    Expr::Block(expr) => self.expr_block(expr),
+                    // ERROR CORRECTION: Add braces to make sure that the
+                    // generated code is valid.
+                    _ => {
+                        self.word("{");
+                        self.expr(expr);
+                        self.word("}");
+                    }
+                }
+            }
+            GenericArgument::AssocType(assoc) => self.assoc_type(assoc),
+            GenericArgument::AssocConst(assoc) => self.assoc_const(assoc),
+            GenericArgument::Constraint(constraint) => self.constraint(constraint),
+            #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
+            _ => unimplemented!("unknown GenericArgument"),
+        }
+    }
+
+    pub fn angle_bracketed_generic_arguments(
+        &mut self,
+        generic: &AngleBracketedGenericArguments,
+        path_kind: PathKind,
+    ) {
+        if generic.args.is_empty() || path_kind == PathKind::Simple {
+            return;
+        }
+
+        if path_kind == PathKind::Expr {
+            self.word("::");
+        }
+        self.word("<");
+        self.cbox(INDENT);
+        self.zerobreak();
+
+        // Print lifetimes before types/consts/bindings, regardless of their
+        // order in self.args.
+        #[derive(Ord, PartialOrd, Eq, PartialEq)]
+        enum Group {
+            First,
+            Second,
+        }
+        fn group(arg: &GenericArgument) -> Group {
+            match arg {
+                GenericArgument::Lifetime(_) => Group::First,
+                GenericArgument::Type(_)
+                | GenericArgument::Const(_)
+                | GenericArgument::AssocType(_)
+                | GenericArgument::AssocConst(_)
+                | GenericArgument::Constraint(_) => Group::Second,
+                #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
+                _ => Group::Second,
+            }
+        }
+        let last = generic.args.iter().max_by_key(|param| group(param));
+        for current_group in [Group::First, Group::Second] {
+            for arg in &generic.args {
+                if group(arg) == current_group {
+                    self.generic_argument(arg);
+                    self.trailing_comma(ptr::eq(arg, last.unwrap()));
+                }
+            }
+        }
+
+        self.offset(-INDENT);
+        self.end();
+        self.word(">");
+    }
+
+    fn assoc_type(&mut self, assoc: &AssocType) {
+        self.ident(&assoc.ident);
+        if let Some(generics) = &assoc.generics {
+            self.angle_bracketed_generic_arguments(generics, PathKind::Type);
+        }
+        self.word(" = ");
+        self.ty(&assoc.ty);
+    }
+
+    fn assoc_const(&mut self, assoc: &AssocConst) {
+        self.ident(&assoc.ident);
+        if let Some(generics) = &assoc.generics {
+            self.angle_bracketed_generic_arguments(generics, PathKind::Type);
+        }
+        self.word(" = ");
+        self.expr(&assoc.value);
+    }
+
+    fn constraint(&mut self, constraint: &Constraint) {
+        self.ident(&constraint.ident);
+        if let Some(generics) = &constraint.generics {
+            self.angle_bracketed_generic_arguments(generics, PathKind::Type);
+        }
+        self.ibox(INDENT);
+        for bound in constraint.bounds.iter().delimited() {
+            if bound.is_first {
+                self.word(": ");
+            } else {
+                self.space();
+                self.word("+ ");
+            }
+            self.type_param_bound(&bound);
+        }
+        self.end();
+    }
+
+    fn parenthesized_generic_arguments(&mut self, arguments: &ParenthesizedGenericArguments) {
+        self.cbox(INDENT);
+        self.word("(");
+        self.zerobreak();
+        for ty in arguments.inputs.iter().delimited() {
+            self.ty(&ty);
+            self.trailing_comma(ty.is_last);
+        }
+        self.offset(-INDENT);
+        self.word(")");
+        self.return_type(&arguments.output);
+        self.end();
+    }
+
+    pub fn qpath(&mut self, qself: &Option<QSelf>, path: &Path, kind: PathKind) {
+        let qself = match qself {
+            Some(qself) => qself,
+            None => {
+                self.path(path, kind);
+                return;
+            }
+        };
+
+        assert!(qself.position < path.segments.len());
+
+        self.word("<");
+        self.ty(&qself.ty);
+
+        let mut segments = path.segments.iter();
+        if qself.position > 0 {
+            self.word(" as ");
+            for segment in segments.by_ref().take(qself.position).delimited() {
+                if !segment.is_first || path.leading_colon.is_some() {
+                    self.word("::");
+                }
+                self.path_segment(&segment, PathKind::Type);
+                if segment.is_last {
+                    self.word(">");
+                }
+            }
+        } else {
+            self.word(">");
+        }
+        for segment in segments {
+            self.word("::");
+            self.path_segment(segment, kind);
+        }
+    }
+}
diff --git a/crates/prettyplease/src/ring.rs b/crates/prettyplease/src/ring.rs
new file mode 100644
index 0000000..aff9258
--- /dev/null
+++ b/crates/prettyplease/src/ring.rs
@@ -0,0 +1,81 @@
+use std::collections::VecDeque;
+use std::ops::{Index, IndexMut};
+
+pub struct RingBuffer<T> {
+    data: VecDeque<T>,
+    // Abstract index of data[0] in infinitely sized queue
+    offset: usize,
+}
+
+impl<T> RingBuffer<T> {
+    pub fn new() -> Self {
+        RingBuffer {
+            data: VecDeque::new(),
+            offset: 0,
+        }
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.data.is_empty()
+    }
+
+    pub fn len(&self) -> usize {
+        self.data.len()
+    }
+
+    pub fn push(&mut self, value: T) -> usize {
+        let index = self.offset + self.data.len();
+        self.data.push_back(value);
+        index
+    }
+
+    pub fn clear(&mut self) {
+        self.data.clear();
+    }
+
+    pub fn index_of_first(&self) -> usize {
+        self.offset
+    }
+
+    pub fn first(&self) -> &T {
+        &self.data[0]
+    }
+
+    pub fn first_mut(&mut self) -> &mut T {
+        &mut self.data[0]
+    }
+
+    pub fn pop_first(&mut self) -> T {
+        self.offset += 1;
+        self.data.pop_front().unwrap()
+    }
+
+    pub fn last(&self) -> &T {
+        self.data.back().unwrap()
+    }
+
+    pub fn last_mut(&mut self) -> &mut T {
+        self.data.back_mut().unwrap()
+    }
+
+    pub fn second_last(&self) -> &T {
+        &self.data[self.data.len() - 2]
+    }
+
+    pub fn pop_last(&mut self) {
+        self.data.pop_back().unwrap();
+    }
+}
+
+impl<T> Index<usize> for RingBuffer<T> {
+    type Output = T;
+    fn index(&self, index: usize) -> &Self::Output {
+        &self.data[index.checked_sub(self.offset).unwrap()]
+    }
+}
+
+impl<T> IndexMut<usize> for RingBuffer<T> {
+    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
+        &mut self.data[index.checked_sub(self.offset).unwrap()]
+    }
+}
diff --git a/crates/prettyplease/src/stmt.rs b/crates/prettyplease/src/stmt.rs
new file mode 100644
index 0000000..268a79e
--- /dev/null
+++ b/crates/prettyplease/src/stmt.rs
@@ -0,0 +1,209 @@
+use crate::algorithm::Printer;
+use crate::INDENT;
+use syn::{BinOp, Expr, Stmt};
+
+impl Printer {
+    pub fn stmt(&mut self, stmt: &Stmt) {
+        match stmt {
+            Stmt::Local(local) => {
+                self.outer_attrs(&local.attrs);
+                self.ibox(0);
+                self.word("let ");
+                self.pat(&local.pat);
+                if let Some(local_init) = &local.init {
+                    self.word(" = ");
+                    self.neverbreak();
+                    self.expr(&local_init.expr);
+                    if let Some((_else, diverge)) = &local_init.diverge {
+                        self.word(" else ");
+                        if let Expr::Block(expr) = diverge.as_ref() {
+                            self.small_block(&expr.block, &[]);
+                        } else {
+                            self.word("{");
+                            self.space();
+                            self.ibox(INDENT);
+                            self.expr(diverge);
+                            self.end();
+                            self.space();
+                            self.offset(-INDENT);
+                            self.word("}");
+                        }
+                    }
+                }
+                self.word(";");
+                self.end();
+                self.hardbreak();
+            }
+            Stmt::Item(item) => self.item(item),
+            Stmt::Expr(expr, None) => {
+                if break_after(expr) {
+                    self.ibox(0);
+                    self.expr_beginning_of_line(expr, true);
+                    if add_semi(expr) {
+                        self.word(";");
+                    }
+                    self.end();
+                    self.hardbreak();
+                } else {
+                    self.expr_beginning_of_line(expr, true);
+                }
+            }
+            Stmt::Expr(expr, Some(_semi)) => {
+                if let Expr::Verbatim(tokens) = expr {
+                    if tokens.is_empty() {
+                        return;
+                    }
+                }
+                self.ibox(0);
+                self.expr_beginning_of_line(expr, true);
+                if !remove_semi(expr) {
+                    self.word(";");
+                }
+                self.end();
+                self.hardbreak();
+            }
+            Stmt::Macro(stmt) => {
+                self.outer_attrs(&stmt.attrs);
+                let semicolon = true;
+                self.mac(&stmt.mac, None, semicolon);
+                self.hardbreak();
+            }
+        }
+    }
+}
+
+pub fn add_semi(expr: &Expr) -> bool {
+    match expr {
+        Expr::Assign(_) | Expr::Break(_) | Expr::Continue(_) | Expr::Return(_) | Expr::Yield(_) => {
+            true
+        }
+        Expr::Binary(expr) => match expr.op {
+            BinOp::AddAssign(_)
+            | BinOp::SubAssign(_)
+            | BinOp::MulAssign(_)
+            | BinOp::DivAssign(_)
+            | BinOp::RemAssign(_)
+            | BinOp::BitXorAssign(_)
+            | BinOp::BitAndAssign(_)
+            | BinOp::BitOrAssign(_)
+            | BinOp::ShlAssign(_)
+            | BinOp::ShrAssign(_) => true,
+            BinOp::Add(_)
+            | BinOp::Sub(_)
+            | BinOp::Mul(_)
+            | BinOp::Div(_)
+            | BinOp::Rem(_)
+            | BinOp::And(_)
+            | BinOp::Or(_)
+            | BinOp::BitXor(_)
+            | BinOp::BitAnd(_)
+            | BinOp::BitOr(_)
+            | BinOp::Shl(_)
+            | BinOp::Shr(_)
+            | BinOp::Eq(_)
+            | BinOp::Lt(_)
+            | BinOp::Le(_)
+            | BinOp::Ne(_)
+            | BinOp::Ge(_)
+            | BinOp::Gt(_) => false,
+            #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
+            _ => unimplemented!("unknown BinOp"),
+        },
+        Expr::Group(group) => add_semi(&group.expr),
+
+        Expr::Array(_)
+        | Expr::Async(_)
+        | Expr::Await(_)
+        | Expr::Block(_)
+        | Expr::Call(_)
+        | Expr::Cast(_)
+        | Expr::Closure(_)
+        | Expr::Const(_)
+        | Expr::Field(_)
+        | Expr::ForLoop(_)
+        | Expr::If(_)
+        | Expr::Index(_)
+        | Expr::Infer(_)
+        | Expr::Let(_)
+        | Expr::Lit(_)
+        | Expr::Loop(_)
+        | Expr::Macro(_)
+        | Expr::Match(_)
+        | Expr::MethodCall(_)
+        | Expr::Paren(_)
+        | Expr::Path(_)
+        | Expr::Range(_)
+        | Expr::Reference(_)
+        | Expr::Repeat(_)
+        | Expr::Struct(_)
+        | Expr::Try(_)
+        | Expr::TryBlock(_)
+        | Expr::Tuple(_)
+        | Expr::Unary(_)
+        | Expr::Unsafe(_)
+        | Expr::Verbatim(_)
+        | Expr::While(_) => false,
+
+        #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
+        _ => false,
+    }
+}
+
+pub fn break_after(expr: &Expr) -> bool {
+    if let Expr::Group(group) = expr {
+        if let Expr::Verbatim(verbatim) = group.expr.as_ref() {
+            return !verbatim.is_empty();
+        }
+    }
+    true
+}
+
+fn remove_semi(expr: &Expr) -> bool {
+    match expr {
+        Expr::ForLoop(_) | Expr::While(_) => true,
+        Expr::Group(group) => remove_semi(&group.expr),
+        Expr::If(expr) => match &expr.else_branch {
+            Some((_else_token, else_branch)) => remove_semi(else_branch),
+            None => true,
+        },
+
+        Expr::Array(_)
+        | Expr::Assign(_)
+        | Expr::Async(_)
+        | Expr::Await(_)
+        | Expr::Binary(_)
+        | Expr::Block(_)
+        | Expr::Break(_)
+        | Expr::Call(_)
+        | Expr::Cast(_)
+        | Expr::Closure(_)
+        | Expr::Continue(_)
+        | Expr::Const(_)
+        | Expr::Field(_)
+        | Expr::Index(_)
+        | Expr::Infer(_)
+        | Expr::Let(_)
+        | Expr::Lit(_)
+        | Expr::Loop(_)
+        | Expr::Macro(_)
+        | Expr::Match(_)
+        | Expr::MethodCall(_)
+        | Expr::Paren(_)
+        | Expr::Path(_)
+        | Expr::Range(_)
+        | Expr::Reference(_)
+        | Expr::Repeat(_)
+        | Expr::Return(_)
+        | Expr::Struct(_)
+        | Expr::Try(_)
+        | Expr::TryBlock(_)
+        | Expr::Tuple(_)
+        | Expr::Unary(_)
+        | Expr::Unsafe(_)
+        | Expr::Verbatim(_)
+        | Expr::Yield(_) => false,
+
+        #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
+        _ => false,
+    }
+}
diff --git a/crates/prettyplease/src/token.rs b/crates/prettyplease/src/token.rs
new file mode 100644
index 0000000..e41fd72
--- /dev/null
+++ b/crates/prettyplease/src/token.rs
@@ -0,0 +1,80 @@
+use crate::algorithm::Printer;
+use proc_macro2::{Delimiter, Ident, Literal, Spacing, TokenStream, TokenTree};
+
+impl Printer {
+    pub fn single_token(&mut self, token: Token, group_contents: fn(&mut Self, TokenStream)) {
+        match token {
+            Token::Group(delimiter, stream) => self.token_group(delimiter, stream, group_contents),
+            Token::Ident(ident) => self.ident(&ident),
+            Token::Punct(ch, _spacing) => self.token_punct(ch),
+            Token::Literal(literal) => self.token_literal(&literal),
+        }
+    }
+
+    fn token_group(
+        &mut self,
+        delimiter: Delimiter,
+        stream: TokenStream,
+        group_contents: fn(&mut Self, TokenStream),
+    ) {
+        self.delimiter_open(delimiter);
+        if !stream.is_empty() {
+            if delimiter == Delimiter::Brace {
+                self.space();
+            }
+            group_contents(self, stream);
+            if delimiter == Delimiter::Brace {
+                self.space();
+            }
+        }
+        self.delimiter_close(delimiter);
+    }
+
+    pub fn ident(&mut self, ident: &Ident) {
+        self.word(ident.to_string());
+    }
+
+    pub fn token_punct(&mut self, ch: char) {
+        self.word(ch.to_string());
+    }
+
+    pub fn token_literal(&mut self, literal: &Literal) {
+        self.word(literal.to_string());
+    }
+
+    pub fn delimiter_open(&mut self, delimiter: Delimiter) {
+        self.word(match delimiter {
+            Delimiter::Parenthesis => "(",
+            Delimiter::Brace => "{",
+            Delimiter::Bracket => "[",
+            Delimiter::None => return,
+        });
+    }
+
+    pub fn delimiter_close(&mut self, delimiter: Delimiter) {
+        self.word(match delimiter {
+            Delimiter::Parenthesis => ")",
+            Delimiter::Brace => "}",
+            Delimiter::Bracket => "]",
+            Delimiter::None => return,
+        });
+    }
+}
+
+pub enum Token {
+    Group(Delimiter, TokenStream),
+    Ident(Ident),
+    Punct(char, Spacing),
+    Literal(Literal),
+}
+
+impl From<TokenTree> for Token {
+    fn from(tt: TokenTree) -> Self {
+        match tt {
+            TokenTree::Group(group) => Token::Group(group.delimiter(), group.stream()),
+            TokenTree::Ident(ident) => Token::Ident(ident),
+            TokenTree::Punct(punct) => Token::Punct(punct.as_char(), punct.spacing()),
+            TokenTree::Literal(literal) => Token::Literal(literal),
+        }
+    }
+}
diff --git a/crates/prettyplease/src/ty.rs b/crates/prettyplease/src/ty.rs
new file mode 100644
index 0000000..0b72724
--- /dev/null
+++ b/crates/prettyplease/src/ty.rs
@@ -0,0 +1,287 @@
+use crate::algorithm::Printer;
+use crate::iter::IterDelimited;
+use crate::path::PathKind;
+use crate::INDENT;
+use proc_macro2::TokenStream;
+use syn::{
+    Abi, BareFnArg, BareVariadic, ReturnType, Type, TypeArray, TypeBareFn, TypeGroup,
+    TypeImplTrait, TypeInfer, TypeMacro, TypeNever, TypeParen, TypePath, TypePtr, TypeReference,
+    TypeSlice, TypeTraitObject, TypeTuple,
+};
+
+impl Printer {
+    pub fn ty(&mut self, ty: &Type) {
+        match ty {
+            Type::Array(ty) => self.type_array(ty),
+            Type::BareFn(ty) => self.type_bare_fn(ty),
+            Type::Group(ty) => self.type_group(ty),
+            Type::ImplTrait(ty) => self.type_impl_trait(ty),
+            Type::Infer(ty) => self.type_infer(ty),
+            Type::Macro(ty) => self.type_macro(ty),
+            Type::Never(ty) => self.type_never(ty),
+            Type::Paren(ty) => self.type_paren(ty),
+            Type::Path(ty) => self.type_path(ty),
+            Type::Ptr(ty) => self.type_ptr(ty),
+            Type::Reference(ty) => self.type_reference(ty),
+            Type::Slice(ty) => self.type_slice(ty),
+            Type::TraitObject(ty) => self.type_trait_object(ty),
+            Type::Tuple(ty) => self.type_tuple(ty),
+            Type::Verbatim(ty) => self.type_verbatim(ty),
+            #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
+            _ => unimplemented!("unknown Type"),
+        }
+    }
+
+    fn type_array(&mut self, ty: &TypeArray) {
+        self.word("[");
+        self.ty(&ty.elem);
+        self.word("; ");
+        self.expr(&ty.len);
+        self.word("]");
+    }
+
+    fn type_bare_fn(&mut self, ty: &TypeBareFn) {
+        if let Some(bound_lifetimes) = &ty.lifetimes {
+            self.bound_lifetimes(bound_lifetimes);
+        }
+        if ty.unsafety.is_some() {
+            self.word("unsafe ");
+        }
+        if let Some(abi) = &ty.abi {
+            self.abi(abi);
+        }
+        self.word("fn(");
+        self.cbox(INDENT);
+        self.zerobreak();
+        for bare_fn_arg in ty.inputs.iter().delimited() {
+            self.bare_fn_arg(&bare_fn_arg);
+            self.trailing_comma(bare_fn_arg.is_last && ty.variadic.is_none());
+        }
+        if let Some(variadic) = &ty.variadic {
+            self.bare_variadic(variadic);
+            self.zerobreak();
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word(")");
+        self.return_type(&ty.output);
+    }
+
+    fn type_group(&mut self, ty: &TypeGroup) {
+        self.ty(&ty.elem);
+    }
+
+    fn type_impl_trait(&mut self, ty: &TypeImplTrait) {
+        self.word("impl ");
+        for type_param_bound in ty.bounds.iter().delimited() {
+            if !type_param_bound.is_first {
+                self.word(" + ");
+            }
+            self.type_param_bound(&type_param_bound);
+        }
+    }
+
+    fn type_infer(&mut self, ty: &TypeInfer) {
+        let _ = ty;
+        self.word("_");
+    }
+
+    fn type_macro(&mut self, ty: &TypeMacro) {
+        let semicolon = false;
+        self.mac(&ty.mac, None, semicolon);
+    }
+
+    fn type_never(&mut self, ty: &TypeNever) {
+        let _ = ty;
+        self.word("!");
+    }
+
+    fn type_paren(&mut self, ty: &TypeParen) {
+        self.word("(");
+        self.ty(&ty.elem);
+        self.word(")");
+    }
+
+    fn type_path(&mut self, ty: &TypePath) {
+        self.qpath(&ty.qself, &ty.path, PathKind::Type);
+    }
+
+    fn type_ptr(&mut self, ty: &TypePtr) {
+        self.word("*");
+        if ty.mutability.is_some() {
+            self.word("mut ");
+        } else {
+            self.word("const ");
+        }
+        self.ty(&ty.elem);
+    }
+
+    fn type_reference(&mut self, ty: &TypeReference) {
+        self.word("&");
+        if let Some(lifetime) = &ty.lifetime {
+            self.lifetime(lifetime);
+            self.nbsp();
+        }
+        if ty.mutability.is_some() {
+            self.word("mut ");
+        }
+        self.ty(&ty.elem);
+    }
+
+    fn type_slice(&mut self, ty: &TypeSlice) {
+        self.word("[");
+        self.ty(&ty.elem);
+        self.word("]");
+    }
+
+    fn type_trait_object(&mut self, ty: &TypeTraitObject) {
+        self.word("dyn ");
+        for type_param_bound in ty.bounds.iter().delimited() {
+            if !type_param_bound.is_first {
+                self.word(" + ");
+            }
+            self.type_param_bound(&type_param_bound);
+        }
+    }
+
+    fn type_tuple(&mut self, ty: &TypeTuple) {
+        self.word("(");
+        self.cbox(INDENT);
+        self.zerobreak();
+        for elem in ty.elems.iter().delimited() {
+            self.ty(&elem);
+            if ty.elems.len() == 1 {
+                self.word(",");
+                self.zerobreak();
+            } else {
+                self.trailing_comma(elem.is_last);
+            }
+        }
+        self.offset(-INDENT);
+        self.end();
+        self.word(")");
+    }
+
+    #[cfg(not(feature = "verbatim"))]
+    fn type_verbatim(&mut self, ty: &TokenStream) {
+        unimplemented!("Type::Verbatim `{}`", ty);
+    }
+
+    #[cfg(feature = "verbatim")]
+    fn type_verbatim(&mut self, tokens: &TokenStream) {
+        use syn::parse::{Parse, ParseStream, Result};
+        use syn::punctuated::Punctuated;
+        use syn::{Token, TypeParamBound};
+
+        enum TypeVerbatim {
+            DynStar(DynStar),
+            MutSelf(MutSelf),
+            NotType(NotType),
+        }
+
+        struct DynStar {
+            bounds: Punctuated<TypeParamBound, Token![+]>,
+        }
+
+        struct MutSelf {
+            ty: Option<Type>,
+        }
+
+        struct NotType {
+            inner: Type,
+        }
+
+        impl Parse for TypeVerbatim {
+            fn parse(input: ParseStream) -> Result<Self> {
+                let lookahead = input.lookahead1();
+                if lookahead.peek(Token![dyn]) {
+                    input.parse::<Token![dyn]>()?;
+                    input.parse::<Token![*]>()?;
+                    let bounds = input.parse_terminated(TypeParamBound::parse, Token![+])?;
+                    Ok(TypeVerbatim::DynStar(DynStar { bounds }))
+                } else if lookahead.peek(Token![mut]) {
+                    input.parse::<Token![mut]>()?;
+                    input.parse::<Token![self]>()?;
+                    let ty = if input.is_empty() {
+                        None
+                    } else {
+                        input.parse::<Token![:]>()?;
+                        let ty: Type = input.parse()?;
+                        Some(ty)
+                    };
+                    Ok(TypeVerbatim::MutSelf(MutSelf { ty }))
+                } else if lookahead.peek(Token![!]) {
+                    input.parse::<Token![!]>()?;
+                    let inner: Type = input.parse()?;
+                    Ok(TypeVerbatim::NotType(NotType { inner }))
+                } else {
+                    Err(lookahead.error())
+                }
+            }
+        }
+
+        let ty: TypeVerbatim = match syn::parse2(tokens.clone()) {
+            Ok(ty) => ty,
+            Err(_) => unimplemented!("Type::Verbatim `{}`", tokens),
+        };
+
+        match ty {
+            TypeVerbatim::DynStar(ty) => {
+                self.word("dyn* ");
+                for type_param_bound in ty.bounds.iter().delimited() {
+                    if !type_param_bound.is_first {
+                        self.word(" + ");
+                    }
+                    self.type_param_bound(&type_param_bound);
+                }
+            }
+            TypeVerbatim::MutSelf(bare_fn_arg) => {
+                self.word("mut self");
+                if let Some(ty) = &bare_fn_arg.ty {
+                    self.word(": ");
+                    self.ty(ty);
+                }
+            }
+            TypeVerbatim::NotType(ty) => {
+                self.word("!");
+                self.ty(&ty.inner);
+            }
+        }
+    }
+
+    pub fn return_type(&mut self, ty: &ReturnType) {
+        match ty {
+            ReturnType::Default => {}
+            ReturnType::Type(_arrow, ty) => {
+                self.word(" -> ");
+                self.ty(ty);
+            }
+        }
+    }
+
+    fn bare_fn_arg(&mut self, bare_fn_arg: &BareFnArg) {
+        self.outer_attrs(&bare_fn_arg.attrs);
+        if let Some((name, _colon)) = &bare_fn_arg.name {
+            self.ident(name);
+            self.word(": ");
+        }
+        self.ty(&bare_fn_arg.ty);
+    }
+
+    fn bare_variadic(&mut self, variadic: &BareVariadic) {
+        self.outer_attrs(&variadic.attrs);
+        if let Some((name, _colon)) = &variadic.name {
+            self.ident(name);
+            self.word(": ");
+        }
+        self.word("...");
+    }
+
+    pub fn abi(&mut self, abi: &Abi) {
+        self.word("extern ");
+        if let Some(name) = &abi.name {
+            self.lit_str(name);
+            self.nbsp();
+        }
+    }
+}
diff --git a/crates/proc-macro2/.cargo-checksum.json b/crates/proc-macro2/.cargo-checksum.json
new file mode 100644
index 0000000..9d2b5e1
--- /dev/null
+++ b/crates/proc-macro2/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"01a9ffc0f14fe891a6a75927a22429879d06ea732b24ab1229838e6c827d9630","LICENSE-APACHE":"62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","README.md":"c609b6865476d6c35879784e9155367a97a0da496aa5c3c61488440a20f59883","build.rs":"6b0b19a3af5248513b186b9c28c133f5af34a1d11122c0268c68e89724aa40fa","rust-toolchain.toml":"6bbb61302978c736b2da03e4fb40e3beab908f85d533ab46fd541e637b5f3e0f","src/detection.rs":"ed9a5f9a979ab01247d7a68eeb1afa3c13209334c5bfff0f9289cb07e5bb4e8b","src/extra.rs":"d378a9e799e5c49933b067cd38f5364d16a152ef337eef86ce42fdc86005ddf3","src/fallback.rs":"11b005c95258ad50362bcaa9b778aab15a8d49a0c434cd2b42afff98416ae1fe","src/lib.rs":"99a6acbddbe01cd906ac243a3db52a28b9fbb2bdc5f238f992d15fb0cebdbcdc","src/location.rs":"f55d2e61f1bb1af65e14ed04c9e91eb1ddbf8430e8c05f2048d1cd538d27368e","src/marker.rs":"43f5a18f5059f1a16507c047b3b7387afee7f25ac45ba4eb1621ca7fa733eb01","src/parse.rs":"6ceaad0a6375af9a202cf8df6ebe72e1bce9543b1f0db71ea03929ac02c3a8b8","src/rcvec.rs":"1c3c48c4f819927cc445ae15ca3bb06775feff2fd1cb21901ae4c40c7e6b4e82","src/wrapper.rs":"06624150b94f4fd9ada30b2c9ad6936ea695d05c2138ceb14f2304e757133d52","tests/comments.rs":"31115b3a56c83d93eef2fb4c9566bf4543e302560732986161b98aef504785ed","tests/features.rs":"a86deb8644992a4eb64d9fd493eff16f9cf9c5cb6ade3a634ce0c990cf87d559","tests/marker.rs":"3190ee07dae510251f360db701ce257030f94a479b6689c3a9ef804bd5d8d099","tests/test.rs":"7511be57e097b15403cf36feb858b4aabdc832fac7024571059a559a7e2ed2a0","tests/test_fmt.rs":"b7743b612af65f2c88cbe109d50a093db7aa7e87f9e37bf45b7bbaeb240aa020","tests/test_size.rs":"acf05963c1e62052d769d237b50844a2c59b4182b491231b099a4f74e5456ab0"},"package":"134c189feb4956b20f6f547d2cf727d4c0fe06722b20a0eec87ed445a97f92da"}
\ No newline at end of file
diff --git a/crates/proc-macro2/Android.bp b/crates/proc-macro2/Android.bp
new file mode 100644
index 0000000..93e2645
--- /dev/null
+++ b/crates/proc-macro2/Android.bp
@@ -0,0 +1,222 @@
+// This file is generated by cargo_embargo.
+// Do not modify this file because the changes will be overridden on upgrade.
+
+package {
+    default_applicable_licenses: ["external_rust_crates_proc-macro2_license"],
+    default_team: "trendy_team_android_rust",
+}
+
+license {
+    name: "external_rust_crates_proc-macro2_license",
+    visibility: [":__subpackages__"],
+    license_kinds: ["SPDX-license-identifier-Apache-2.0"],
+    license_text: ["LICENSE"],
+}
+
+rust_library_host {
+    name: "libproc_macro2",
+    host_cross_supported: false,
+    crate_name: "proc_macro2",
+    cargo_env_compat: true,
+    cargo_pkg_version: "1.0.69",
+    crate_root: "src/lib.rs",
+    edition: "2021",
+    features: [
+        "default",
+        "proc-macro",
+        "span-locations",
+    ],
+    cfgs: [
+        "proc_macro_span",
+        "span_locations",
+        "wrap_proc_macro",
+    ],
+    rustlibs: ["libunicode_ident"],
+    compile_multilib: "first",
+}
+
+rust_test_host {
+    name: "proc-macro2_test_tests_comments",
+    host_cross_supported: false,
+    crate_name: "comments",
+    cargo_env_compat: true,
+    cargo_pkg_version: "1.0.69",
+    crate_root: "tests/comments.rs",
+    test_suites: ["general-tests"],
+    auto_gen_config: true,
+    test_options: {
+        unit_test: true,
+    },
+    edition: "2021",
+    features: [
+        "default",
+        "proc-macro",
+        "span-locations",
+    ],
+    cfgs: [
+        "proc_macro_span",
+        "span_locations",
+        "wrap_proc_macro",
+    ],
+    rustlibs: [
+        "libproc_macro2",
+        "libquote",
+        "libunicode_ident",
+    ],
+    proc_macros: ["librustversion"],
+}
+
+rust_test_host {
+    name: "proc-macro2_test_tests_features",
+    host_cross_supported: false,
+    crate_name: "features",
+    cargo_env_compat: true,
+    cargo_pkg_version: "1.0.69",
+    crate_root: "tests/features.rs",
+    test_suites: ["general-tests"],
+    auto_gen_config: true,
+    test_options: {
+        unit_test: true,
+    },
+    edition: "2021",
+    features: [
+        "default",
+        "proc-macro",
+        "span-locations",
+    ],
+    cfgs: [
+        "proc_macro_span",
+        "span_locations",
+        "wrap_proc_macro",
+    ],
+    rustlibs: [
+        "libproc_macro2",
+        "libquote",
+        "libunicode_ident",
+    ],
+    proc_macros: ["librustversion"],
+}
+
+rust_test_host {
+    name: "proc-macro2_test_tests_marker",
+    host_cross_supported: false,
+    crate_name: "marker",
+    cargo_env_compat: true,
+    cargo_pkg_version: "1.0.69",
+    crate_root: "tests/marker.rs",
+    test_suites: ["general-tests"],
+    auto_gen_config: true,
+    test_options: {
+        unit_test: true,
+    },
+    edition: "2021",
+    features: [
+        "default",
+        "proc-macro",
+        "span-locations",
+    ],
+    cfgs: [
+        "proc_macro_span",
+        "span_locations",
+        "wrap_proc_macro",
+    ],
+    rustlibs: [
+        "libproc_macro2",
+        "libquote",
+        "libunicode_ident",
+    ],
+    proc_macros: ["librustversion"],
+}
+
+rust_test_host {
+    name: "proc-macro2_test_tests_test",
+    host_cross_supported: false,
+    crate_name: "test",
+    cargo_env_compat: true,
+    cargo_pkg_version: "1.0.69",
+    crate_root: "tests/test.rs",
+    test_suites: ["general-tests"],
+    auto_gen_config: true,
+    test_options: {
+        unit_test: true,
+    },
+    edition: "2021",
+    features: [
+        "default",
+        "proc-macro",
+        "span-locations",
+    ],
+    cfgs: [
+        "proc_macro_span",
+        "span_locations",
+        "wrap_proc_macro",
+    ],
+    rustlibs: [
+        "libproc_macro2",
+        "libquote",
+        "libunicode_ident",
+    ],
+    proc_macros: ["librustversion"],
+}
+
+rust_test_host {
+    name: "proc-macro2_test_tests_test_fmt",
+    host_cross_supported: false,
+    crate_name: "test_fmt",
+    cargo_env_compat: true,
+    cargo_pkg_version: "1.0.69",
+    crate_root: "tests/test_fmt.rs",
+    test_suites: ["general-tests"],
+    auto_gen_config: true,
+    test_options: {
+        unit_test: true,
+    },
+    edition: "2021",
+    features: [
+        "default",
+        "proc-macro",
+        "span-locations",
+    ],
+    cfgs: [
+        "proc_macro_span",
+        "span_locations",
+        "wrap_proc_macro",
+    ],
+    rustlibs: [
+        "libproc_macro2",
+        "libquote",
+        "libunicode_ident",
+    ],
+    proc_macros: ["librustversion"],
+}
+
+rust_test_host {
+    name: "proc-macro2_test_tests_test_size",
+    host_cross_supported: false,
+    crate_name: "test_size",
+    cargo_env_compat: true,
+    cargo_pkg_version: "1.0.69",
+    crate_root: "tests/test_size.rs",
+    test_suites: ["general-tests"],
+    auto_gen_config: true,
+    test_options: {
+        unit_test: true,
+    },
+    edition: "2021",
+    features: [
+        "default",
+        "proc-macro",
+        "span-locations",
+    ],
+    cfgs: [
+        "proc_macro_span",
+        "span_locations",
+        "wrap_proc_macro",
+    ],
+    rustlibs: [
+        "libproc_macro2",
+        "libquote",
+        "libunicode_ident",
+    ],
+    proc_macros: ["librustversion"],
+}
diff --git a/crates/proc-macro2/Cargo.lock b/crates/proc-macro2/Cargo.lock
new file mode 100644
index 0000000..b20cae9
--- /dev/null
+++ b/crates/proc-macro2/Cargo.lock
@@ -0,0 +1,42 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.69"
+dependencies = [
+ "quote",
+ "rustversion",
+ "unicode-ident",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.86"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
+dependencies = [
+ "proc-macro2 1.0.86",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "955d28af4278de8121b7ebeb796b6a45735dc01436d898801014aced2773a3d6"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
diff --git a/crates/proc-macro2/Cargo.toml b/crates/proc-macro2/Cargo.toml
new file mode 100644
index 0000000..6f4ed46
--- /dev/null
+++ b/crates/proc-macro2/Cargo.toml
@@ -0,0 +1,67 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2021"
+rust-version = "1.56"
+name = "proc-macro2"
+version = "1.0.69"
+authors = [
+    "David Tolnay <dtolnay@gmail.com>",
+    "Alex Crichton <alex@alexcrichton.com>",
+]
+autobenches = false
+description = "A substitute implementation of the compiler's `proc_macro` API to decouple token-based libraries from the procedural macro use case."
+documentation = "https://docs.rs/proc-macro2"
+readme = "README.md"
+keywords = [
+    "macros",
+    "syn",
+]
+categories = ["development-tools::procedural-macro-helpers"]
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/dtolnay/proc-macro2"
+
+[package.metadata.docs.rs]
+rustc-args = [
+    "--cfg",
+    "procmacro2_semver_exempt",
+]
+rustdoc-args = [
+    "--cfg",
+    "procmacro2_semver_exempt",
+    "--cfg",
+    "doc_cfg",
+    "--generate-link-to-definition",
+]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[package.metadata.playground]
+features = ["span-locations"]
+
+[lib]
+doc-scrape-examples = false
+
+[dependencies.unicode-ident]
+version = "1.0"
+
+[dev-dependencies.quote]
+version = "1.0"
+default_features = false
+
+[dev-dependencies.rustversion]
+version = "1"
+
+[features]
+default = ["proc-macro"]
+nightly = []
+proc-macro = []
+span-locations = []
diff --git a/crates/proc-macro2/LICENSE b/crates/proc-macro2/LICENSE
new file mode 120000
index 0000000..6b579aa
--- /dev/null
+++ b/crates/proc-macro2/LICENSE
@@ -0,0 +1 @@
+LICENSE-APACHE
\ No newline at end of file
diff --git a/crates/proc-macro2/LICENSE-APACHE b/crates/proc-macro2/LICENSE-APACHE
new file mode 100644
index 0000000..1b5ec8b
--- /dev/null
+++ b/crates/proc-macro2/LICENSE-APACHE
@@ -0,0 +1,176 @@
+                              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
diff --git a/crates/proc-macro2/LICENSE-MIT b/crates/proc-macro2/LICENSE-MIT
new file mode 100644
index 0000000..31aa793
--- /dev/null
+++ b/crates/proc-macro2/LICENSE-MIT
@@ -0,0 +1,23 @@
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/crates/proc-macro2/METADATA b/crates/proc-macro2/METADATA
new file mode 100644
index 0000000..34f90ff
--- /dev/null
+++ b/crates/proc-macro2/METADATA
@@ -0,0 +1,23 @@
+# This project was upgraded with external_updater.
+# Usage: tools/external_updater/updater.sh update rust/crates/proc-macro2
+# For more info, check https://cs.android.com/android/platform/superproject/+/main:tools/external_updater/README.md
+
+name: "proc-macro2"
+description: "A substitute implementation of the compiler\'s `proc_macro` API to decouple token-based libraries from the procedural macro use case."
+third_party {
+  url {
+    type: HOMEPAGE
+    value: "https://crates.io/crates/proc-macro2"
+  }
+  url {
+    type: ARCHIVE
+    value: "https://static.crates.io/crates/proc-macro2/proc-macro2-1.0.66.crate"
+  }
+  version: "1.0.66"
+  license_type: NOTICE
+  last_upgrade_date {
+    year: 2023
+    month: 8
+    day: 15
+  }
+}
diff --git a/crates/proc-macro2/MODULE_LICENSE_APACHE2 b/crates/proc-macro2/MODULE_LICENSE_APACHE2
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/crates/proc-macro2/MODULE_LICENSE_APACHE2
diff --git a/crates/proc-macro2/README.md b/crates/proc-macro2/README.md
new file mode 100644
index 0000000..3a29ce8
--- /dev/null
+++ b/crates/proc-macro2/README.md
@@ -0,0 +1,94 @@
+# proc-macro2
+
+[<img alt="github" src="https://img.shields.io/badge/github-dtolnay/proc--macro2-8da0cb?style=for-the-badge&labelColor=555555&logo=github" height="20">](https://github.com/dtolnay/proc-macro2)
+[<img alt="crates.io" src="https://img.shields.io/crates/v/proc-macro2.svg?style=for-the-badge&color=fc8d62&logo=rust" height="20">](https://crates.io/crates/proc-macro2)
+[<img alt="docs.rs" src="https://img.shields.io/badge/docs.rs-proc--macro2-66c2a5?style=for-the-badge&labelColor=555555&logo=docs.rs" height="20">](https://docs.rs/proc-macro2)
+[<img alt="build status" src="https://img.shields.io/github/actions/workflow/status/dtolnay/proc-macro2/ci.yml?branch=master&style=for-the-badge" height="20">](https://github.com/dtolnay/proc-macro2/actions?query=branch%3Amaster)
+
+A wrapper around the procedural macro API of the compiler's `proc_macro` crate.
+This library serves two purposes:
+
+- **Bring proc-macro-like functionality to other contexts like build.rs and
+  main.rs.** Types from `proc_macro` are entirely specific to procedural macros
+  and cannot ever exist in code outside of a procedural macro. Meanwhile
+  `proc_macro2` types may exist anywhere including non-macro code. By developing
+  foundational libraries like [syn] and [quote] against `proc_macro2` rather
+  than `proc_macro`, the procedural macro ecosystem becomes easily applicable to
+  many other use cases and we avoid reimplementing non-macro equivalents of
+  those libraries.
+
+- **Make procedural macros unit testable.** As a consequence of being specific
+  to procedural macros, nothing that uses `proc_macro` can be executed from a
+  unit test. In order for helper libraries or components of a macro to be
+  testable in isolation, they must be implemented using `proc_macro2`.
+
+[syn]: https://github.com/dtolnay/syn
+[quote]: https://github.com/dtolnay/quote
+
+## Usage
+
+```toml
+[dependencies]
+proc-macro2 = "1.0"
+```
+
+The skeleton of a typical procedural macro typically looks like this:
+
+```rust
+extern crate proc_macro;
+
+#[proc_macro_derive(MyDerive)]
+pub fn my_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let input = proc_macro2::TokenStream::from(input);
+
+    let output: proc_macro2::TokenStream = {
+        /* transform input */
+    };
+
+    proc_macro::TokenStream::from(output)
+}
+```
+
+If parsing with [Syn], you'll use [`parse_macro_input!`] instead to propagate
+parse errors correctly back to the compiler when parsing fails.
+
+[`parse_macro_input!`]: https://docs.rs/syn/2.0/syn/macro.parse_macro_input.html
+
+## Unstable features
+
+The default feature set of proc-macro2 tracks the most recent stable compiler
+API. Functionality in `proc_macro` that is not yet stable is not exposed by
+proc-macro2 by default.
+
+To opt into the additional APIs available in the most recent nightly compiler,
+the `procmacro2_semver_exempt` config flag must be passed to rustc. We will
+polyfill those nightly-only APIs back to Rust 1.56.0. As these are unstable APIs
+that track the nightly compiler, minor versions of proc-macro2 may make breaking
+changes to them at any time.
+
+```
+RUSTFLAGS='--cfg procmacro2_semver_exempt' cargo build
+```
+
+Note that this must not only be done for your crate, but for any crate that
+depends on your crate. This infectious nature is intentional, as it serves as a
+reminder that you are outside of the normal semver guarantees.
+
+Semver exempt methods are marked as such in the proc-macro2 documentation.
+
+<br>
+
+#### License
+
+<sup>
+Licensed under either of <a href="LICENSE-APACHE">Apache License, Version
+2.0</a> or <a href="LICENSE-MIT">MIT license</a> at your option.
+</sup>
+
+<br>
+
+<sub>
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in this crate by you, as defined in the Apache-2.0 license, shall
+be dual licensed as above, without any additional terms or conditions.
+</sub>
diff --git a/crates/proc-macro2/TEST_MAPPING b/crates/proc-macro2/TEST_MAPPING
new file mode 100644
index 0000000..7c46892
--- /dev/null
+++ b/crates/proc-macro2/TEST_MAPPING
@@ -0,0 +1,167 @@
+// Generated by update_crate_tests.py for tests that depend on this crate.
+{
+  "imports": [
+    {
+      "path": "external/rust/crates/anyhow"
+    },
+    {
+      "path": "external/rust/crates/arbitrary"
+    },
+    {
+      "path": "external/rust/crates/argh"
+    },
+    {
+      "path": "external/rust/crates/async-stream"
+    },
+    {
+      "path": "external/rust/crates/base64"
+    },
+    {
+      "path": "external/rust/crates/bitflags"
+    },
+    {
+      "path": "external/rust/crates/bytes"
+    },
+    {
+      "path": "external/rust/crates/coset"
+    },
+    {
+      "path": "external/rust/crates/either"
+    },
+    {
+      "path": "external/rust/crates/futures-channel"
+    },
+    {
+      "path": "external/rust/crates/futures-executor"
+    },
+    {
+      "path": "external/rust/crates/futures-test"
+    },
+    {
+      "path": "external/rust/crates/futures-util"
+    },
+    {
+      "path": "external/rust/crates/hashbrown"
+    },
+    {
+      "path": "external/rust/crates/hashlink"
+    },
+    {
+      "path": "external/rust/crates/jni"
+    },
+    {
+      "path": "external/rust/crates/libm"
+    },
+    {
+      "path": "external/rust/crates/libsqlite3-sys"
+    },
+    {
+      "path": "external/rust/crates/oid-registry"
+    },
+    {
+      "path": "external/rust/crates/rand_chacha"
+    },
+    {
+      "path": "external/rust/crates/serde"
+    },
+    {
+      "path": "external/rust/crates/serde-xml-rs"
+    },
+    {
+      "path": "external/rust/crates/serde_cbor"
+    },
+    {
+      "path": "external/rust/crates/slab"
+    },
+    {
+      "path": "external/rust/crates/tinytemplate"
+    },
+    {
+      "path": "external/rust/crates/tinyvec"
+    },
+    {
+      "path": "external/rust/crates/tokio"
+    },
+    {
+      "path": "external/rust/crates/tokio-test"
+    },
+    {
+      "path": "external/rust/crates/unicode-bidi"
+    },
+    {
+      "path": "external/rust/crates/unicode-xid"
+    },
+    {
+      "path": "external/rust/crates/url"
+    },
+    {
+      "path": "external/rust/crates/virtio-drivers"
+    },
+    {
+      "path": "external/rust/crates/zerocopy"
+    },
+    {
+      "path": "external/rust/crates/zeroize"
+    },
+    {
+      "path": "external/uwb/src"
+    },
+    {
+      "path": "packages/modules/DnsResolver"
+    },
+    {
+      "path": "packages/modules/Virtualization/apkdmverity"
+    },
+    {
+      "path": "packages/modules/Virtualization/authfs"
+    },
+    {
+      "path": "packages/modules/Virtualization/avmd"
+    },
+    {
+      "path": "packages/modules/Virtualization/encryptedstore"
+    },
+    {
+      "path": "packages/modules/Virtualization/libs/apexutil"
+    },
+    {
+      "path": "packages/modules/Virtualization/libs/apkverify"
+    },
+    {
+      "path": "packages/modules/Virtualization/libs/devicemapper"
+    },
+    {
+      "path": "packages/modules/Virtualization/microdroid_manager"
+    },
+    {
+      "path": "packages/modules/Virtualization/virtualizationmanager"
+    },
+    {
+      "path": "packages/modules/Virtualization/vm"
+    },
+    {
+      "path": "packages/modules/Virtualization/zipfuse"
+    },
+    {
+      "path": "system/keymint/derive"
+    },
+    {
+      "path": "system/keymint/hal"
+    },
+    {
+      "path": "system/security/diced"
+    },
+    {
+      "path": "system/security/keystore2"
+    },
+    {
+      "path": "system/security/keystore2/legacykeystore"
+    },
+    {
+      "path": "system/security/keystore2/selinux"
+    },
+    {
+      "path": "system/security/keystore2/src/crypto"
+    }
+  ]
+}
diff --git a/crates/proc-macro2/build.rs b/crates/proc-macro2/build.rs
new file mode 100644
index 0000000..9f0fb51
--- /dev/null
+++ b/crates/proc-macro2/build.rs
@@ -0,0 +1,133 @@
+// rustc-cfg emitted by the build script:
+//
+// "wrap_proc_macro"
+//     Wrap types from libproc_macro rather than polyfilling the whole API.
+//     Enabled on rustc 1.29+ as long as procmacro2_semver_exempt is not set,
+//     because we can't emulate the unstable API without emulating everything
+//     else. Also enabled unconditionally on nightly, in which case the
+//     procmacro2_semver_exempt surface area is implemented by using the
+//     nightly-only proc_macro API.
+//
+// "hygiene"
+//    Enable Span::mixed_site() and non-dummy behavior of Span::resolved_at
+//    and Span::located_at. Enabled on Rust 1.45+.
+//
+// "proc_macro_span"
+//     Enable non-dummy behavior of Span::start and Span::end methods which
+//     requires an unstable compiler feature. Enabled when building with
+//     nightly, unless `-Z allow-feature` in RUSTFLAGS disallows unstable
+//     features.
+//
+// "super_unstable"
+//     Implement the semver exempt API in terms of the nightly-only proc_macro
+//     API. Enabled when using procmacro2_semver_exempt on a nightly compiler.
+//
+// "span_locations"
+//     Provide methods Span::start and Span::end which give the line/column
+//     location of a token. Enabled by procmacro2_semver_exempt or the
+//     "span-locations" Cargo cfg. This is behind a cfg because tracking
+//     location inside spans is a performance hit.
+//
+// "is_available"
+//     Use proc_macro::is_available() to detect if the proc macro API is
+//     available or needs to be polyfilled instead of trying to use the proc
+//     macro API and catching a panic if it isn't available. Enabled on Rust
+//     1.57+.
+
+use std::env;
+use std::process::Command;
+use std::str;
+use std::u32;
+
+fn main() {
+    println!("cargo:rerun-if-changed=build.rs");
+
+    let version = rustc_version().unwrap_or(RustcVersion {
+        minor: u32::MAX,
+        nightly: false,
+    });
+
+    let docs_rs = env::var_os("DOCS_RS").is_some();
+    let semver_exempt = cfg!(procmacro2_semver_exempt) || docs_rs;
+    if semver_exempt {
+        // https://github.com/dtolnay/proc-macro2/issues/147
+        println!("cargo:rustc-cfg=procmacro2_semver_exempt");
+    }
+
+    if semver_exempt || cfg!(feature = "span-locations") {
+        println!("cargo:rustc-cfg=span_locations");
+    }
+
+    if version.minor < 57 {
+        println!("cargo:rustc-cfg=no_is_available");
+    }
+
+    if version.minor < 66 {
+        println!("cargo:rustc-cfg=no_source_text");
+    }
+
+    if !cfg!(feature = "proc-macro") {
+        return;
+    }
+
+    if version.nightly || !semver_exempt {
+        println!("cargo:rustc-cfg=wrap_proc_macro");
+    }
+
+    if version.nightly && feature_allowed("proc_macro_span") {
+        println!("cargo:rustc-cfg=proc_macro_span");
+    }
+
+    if semver_exempt && version.nightly {
+        println!("cargo:rustc-cfg=super_unstable");
+    }
+}
+
+struct RustcVersion {
+    minor: u32,
+    nightly: bool,
+}
+
+fn rustc_version() -> Option<RustcVersion> {
+    let rustc = env::var_os("RUSTC")?;
+    let output = Command::new(rustc).arg("--version").output().ok()?;
+    let version = str::from_utf8(&output.stdout).ok()?;
+    let nightly = version.contains("nightly") || version.contains("dev");
+    let mut pieces = version.split('.');
+    if pieces.next() != Some("rustc 1") {
+        return None;
+    }
+    let minor = pieces.next()?.parse().ok()?;
+    Some(RustcVersion { minor, nightly })
+}
+
+fn feature_allowed(feature: &str) -> bool {
+    // Recognized formats:
+    //
+    //     -Z allow-features=feature1,feature2
+    //
+    //     -Zallow-features=feature1,feature2
+
+    let flags_var;
+    let flags_var_string;
+    let flags = if let Some(encoded_rustflags) = env::var_os("CARGO_ENCODED_RUSTFLAGS") {
+        flags_var = encoded_rustflags;
+        flags_var_string = flags_var.to_string_lossy();
+        flags_var_string.split('\x1f')
+    } else {
+        return true;
+    };
+
+    for mut flag in flags {
+        if flag.starts_with("-Z") {
+            flag = &flag["-Z".len()..];
+        }
+        if flag.starts_with("allow-features=") {
+            flag = &flag["allow-features=".len()..];
+            return flag.split(',').any(|allowed| allowed == feature);
+        }
+    }
+
+    // No allow-features= flag, allowed by default.
+    true
+}
diff --git a/crates/proc-macro2/cargo_embargo.json b/crates/proc-macro2/cargo_embargo.json
new file mode 100644
index 0000000..a64c9e4
--- /dev/null
+++ b/crates/proc-macro2/cargo_embargo.json
@@ -0,0 +1,13 @@
+{
+  "features": [
+    "default",
+    "span-locations"
+  ],
+  "package": {
+    "proc-macro2": {
+      "device_supported": false,
+      "host_first_multilib": true
+    }
+  },
+  "tests": true
+}
diff --git a/crates/proc-macro2/rust-toolchain.toml b/crates/proc-macro2/rust-toolchain.toml
new file mode 100644
index 0000000..20fe888
--- /dev/null
+++ b/crates/proc-macro2/rust-toolchain.toml
@@ -0,0 +1,2 @@
+[toolchain]
+components = ["rust-src"]
diff --git a/crates/proc-macro2/src/detection.rs b/crates/proc-macro2/src/detection.rs
new file mode 100644
index 0000000..beba7b2
--- /dev/null
+++ b/crates/proc-macro2/src/detection.rs
@@ -0,0 +1,75 @@
+use core::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::Once;
+
+static WORKS: AtomicUsize = AtomicUsize::new(0);
+static INIT: Once = Once::new();
+
+pub(crate) fn inside_proc_macro() -> bool {
+    match WORKS.load(Ordering::Relaxed) {
+        1 => return false,
+        2 => return true,
+        _ => {}
+    }
+
+    INIT.call_once(initialize);
+    inside_proc_macro()
+}
+
+pub(crate) fn force_fallback() {
+    WORKS.store(1, Ordering::Relaxed);
+}
+
+pub(crate) fn unforce_fallback() {
+    initialize();
+}
+
+#[cfg(not(no_is_available))]
+fn initialize() {
+    let available = proc_macro::is_available();
+    WORKS.store(available as usize + 1, Ordering::Relaxed);
+}
+
+// Swap in a null panic hook to avoid printing "thread panicked" to stderr,
+// then use catch_unwind to determine whether the compiler's proc_macro is
+// working. When proc-macro2 is used from outside of a procedural macro all
+// of the proc_macro crate's APIs currently panic.
+//
+// The Once is to prevent the possibility of this ordering:
+//
+//     thread 1 calls take_hook, gets the user's original hook
+//     thread 1 calls set_hook with the null hook
+//     thread 2 calls take_hook, thinks null hook is the original hook
+//     thread 2 calls set_hook with the null hook
+//     thread 1 calls set_hook with the actual original hook
+//     thread 2 calls set_hook with what it thinks is the original hook
+//
+// in which the user's hook has been lost.
+//
+// There is still a race condition where a panic in a different thread can
+// happen during the interval that the user's original panic hook is
+// unregistered such that their hook is incorrectly not called. This is
+// sufficiently unlikely and less bad than printing panic messages to stderr
+// on correct use of this crate. Maybe there is a libstd feature request
+// here. For now, if a user needs to guarantee that this failure mode does
+// not occur, they need to call e.g. `proc_macro2::Span::call_site()` from
+// the main thread before launching any other threads.
+#[cfg(no_is_available)]
+fn initialize() {
+    use std::panic::{self, PanicInfo};
+
+    type PanicHook = dyn Fn(&PanicInfo) + Sync + Send + 'static;
+
+    let null_hook: Box<PanicHook> = Box::new(|_panic_info| { /* ignore */ });
+    let sanity_check = &*null_hook as *const PanicHook;
+    let original_hook = panic::take_hook();
+    panic::set_hook(null_hook);
+
+    let works = panic::catch_unwind(proc_macro::Span::call_site).is_ok();
+    WORKS.store(works as usize + 1, Ordering::Relaxed);
+
+    let hopefully_null_hook = panic::take_hook();
+    panic::set_hook(original_hook);
+    if sanity_check != &*hopefully_null_hook {
+        panic!("observed race condition in proc_macro2::inside_proc_macro");
+    }
+}
diff --git a/crates/proc-macro2/src/extra.rs b/crates/proc-macro2/src/extra.rs
new file mode 100644
index 0000000..4a69d46
--- /dev/null
+++ b/crates/proc-macro2/src/extra.rs
@@ -0,0 +1,84 @@
+//! Items which do not have a correspondence to any API in the proc_macro crate,
+//! but are necessary to include in proc-macro2.
+
+use crate::fallback;
+use crate::imp;
+use crate::marker::Marker;
+use crate::Span;
+use core::fmt::{self, Debug};
+
+/// An object that holds a [`Group`]'s `span_open()` and `span_close()` together
+/// (in a more compact representation than holding those 2 spans individually.
+///
+/// [`Group`]: crate::Group
+#[derive(Copy, Clone)]
+pub struct DelimSpan {
+    inner: DelimSpanEnum,
+    _marker: Marker,
+}
+
+#[derive(Copy, Clone)]
+enum DelimSpanEnum {
+    #[cfg(wrap_proc_macro)]
+    Compiler {
+        join: proc_macro::Span,
+        open: proc_macro::Span,
+        close: proc_macro::Span,
+    },
+    Fallback(fallback::Span),
+}
+
+impl DelimSpan {
+    pub(crate) fn new(group: &imp::Group) -> Self {
+        #[cfg(wrap_proc_macro)]
+        let inner = match group {
+            imp::Group::Compiler(group) => DelimSpanEnum::Compiler {
+                join: group.span(),
+                open: group.span_open(),
+                close: group.span_close(),
+            },
+            imp::Group::Fallback(group) => DelimSpanEnum::Fallback(group.span()),
+        };
+
+        #[cfg(not(wrap_proc_macro))]
+        let inner = DelimSpanEnum::Fallback(group.span());
+
+        DelimSpan {
+            inner,
+            _marker: Marker,
+        }
+    }
+
+    /// Returns a span covering the entire delimited group.
+    pub fn join(&self) -> Span {
+        match &self.inner {
+            #[cfg(wrap_proc_macro)]
+            DelimSpanEnum::Compiler { join, .. } => Span::_new(imp::Span::Compiler(*join)),
+            DelimSpanEnum::Fallback(span) => Span::_new_fallback(*span),
+        }
+    }
+
+    /// Returns a span for the opening punctuation of the group only.
+    pub fn open(&self) -> Span {
+        match &self.inner {
+            #[cfg(wrap_proc_macro)]
+            DelimSpanEnum::Compiler { open, .. } => Span::_new(imp::Span::Compiler(*open)),
+            DelimSpanEnum::Fallback(span) => Span::_new_fallback(span.first_byte()),
+        }
+    }
+
+    /// Returns a span for the closing punctuation of the group only.
+    pub fn close(&self) -> Span {
+        match &self.inner {
+            #[cfg(wrap_proc_macro)]
+            DelimSpanEnum::Compiler { close, .. } => Span::_new(imp::Span::Compiler(*close)),
+            DelimSpanEnum::Fallback(span) => Span::_new_fallback(span.last_byte()),
+        }
+    }
+}
+
+impl Debug for DelimSpan {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        Debug::fmt(&self.join(), f)
+    }
+}
diff --git a/crates/proc-macro2/src/fallback.rs b/crates/proc-macro2/src/fallback.rs
new file mode 100644
index 0000000..7f559cf
--- /dev/null
+++ b/crates/proc-macro2/src/fallback.rs
@@ -0,0 +1,1129 @@
+#[cfg(span_locations)]
+use crate::location::LineColumn;
+use crate::parse::{self, Cursor};
+use crate::rcvec::{RcVec, RcVecBuilder, RcVecIntoIter, RcVecMut};
+use crate::{Delimiter, Spacing, TokenTree};
+#[cfg(all(span_locations, not(fuzzing)))]
+use alloc::collections::BTreeMap;
+#[cfg(all(span_locations, not(fuzzing)))]
+use core::cell::RefCell;
+#[cfg(span_locations)]
+use core::cmp;
+use core::fmt::{self, Debug, Display, Write};
+use core::mem::ManuallyDrop;
+use core::ops::RangeBounds;
+use core::ptr;
+use core::str::FromStr;
+use std::path::PathBuf;
+
+/// Force use of proc-macro2's fallback implementation of the API for now, even
+/// if the compiler's implementation is available.
+pub fn force() {
+    #[cfg(wrap_proc_macro)]
+    crate::detection::force_fallback();
+}
+
+/// Resume using the compiler's implementation of the proc macro API if it is
+/// available.
+pub fn unforce() {
+    #[cfg(wrap_proc_macro)]
+    crate::detection::unforce_fallback();
+}
+
+#[derive(Clone)]
+pub(crate) struct TokenStream {
+    inner: RcVec<TokenTree>,
+}
+
+#[derive(Debug)]
+pub(crate) struct LexError {
+    pub(crate) span: Span,
+}
+
+impl LexError {
+    pub(crate) fn span(&self) -> Span {
+        self.span
+    }
+
+    fn call_site() -> Self {
+        LexError {
+            span: Span::call_site(),
+        }
+    }
+}
+
+impl TokenStream {
+    pub fn new() -> Self {
+        TokenStream {
+            inner: RcVecBuilder::new().build(),
+        }
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.inner.len() == 0
+    }
+
+    fn take_inner(self) -> RcVecBuilder<TokenTree> {
+        let nodrop = ManuallyDrop::new(self);
+        unsafe { ptr::read(&nodrop.inner) }.make_owned()
+    }
+}
+
+fn push_token_from_proc_macro(mut vec: RcVecMut<TokenTree>, token: TokenTree) {
+    // https://github.com/dtolnay/proc-macro2/issues/235
+    match token {
+        TokenTree::Literal(crate::Literal {
+            #[cfg(wrap_proc_macro)]
+                inner: crate::imp::Literal::Fallback(literal),
+            #[cfg(not(wrap_proc_macro))]
+                inner: literal,
+            ..
+        }) if literal.repr.starts_with('-') => {
+            push_negative_literal(vec, literal);
+        }
+        _ => vec.push(token),
+    }
+
+    #[cold]
+    fn push_negative_literal(mut vec: RcVecMut<TokenTree>, mut literal: Literal) {
+        literal.repr.remove(0);
+        let mut punct = crate::Punct::new('-', Spacing::Alone);
+        punct.set_span(crate::Span::_new_fallback(literal.span));
+        vec.push(TokenTree::Punct(punct));
+        vec.push(TokenTree::Literal(crate::Literal::_new_fallback(literal)));
+    }
+}
+
+// Nonrecursive to prevent stack overflow.
+impl Drop for TokenStream {
+    fn drop(&mut self) {
+        let mut inner = match self.inner.get_mut() {
+            Some(inner) => inner,
+            None => return,
+        };
+        while let Some(token) = inner.pop() {
+            let group = match token {
+                TokenTree::Group(group) => group.inner,
+                _ => continue,
+            };
+            #[cfg(wrap_proc_macro)]
+            let group = match group {
+                crate::imp::Group::Fallback(group) => group,
+                crate::imp::Group::Compiler(_) => continue,
+            };
+            inner.extend(group.stream.take_inner());
+        }
+    }
+}
+
+pub(crate) struct TokenStreamBuilder {
+    inner: RcVecBuilder<TokenTree>,
+}
+
+impl TokenStreamBuilder {
+    pub fn new() -> Self {
+        TokenStreamBuilder {
+            inner: RcVecBuilder::new(),
+        }
+    }
+
+    pub fn with_capacity(cap: usize) -> Self {
+        TokenStreamBuilder {
+            inner: RcVecBuilder::with_capacity(cap),
+        }
+    }
+
+    pub fn push_token_from_parser(&mut self, tt: TokenTree) {
+        self.inner.push(tt);
+    }
+
+    pub fn build(self) -> TokenStream {
+        TokenStream {
+            inner: self.inner.build(),
+        }
+    }
+}
+
+#[cfg(span_locations)]
+fn get_cursor(src: &str) -> Cursor {
+    #[cfg(fuzzing)]
+    return Cursor { rest: src, off: 1 };
+
+    // Create a dummy file & add it to the source map
+    #[cfg(not(fuzzing))]
+    SOURCE_MAP.with(|cm| {
+        let mut cm = cm.borrow_mut();
+        let span = cm.add_file(src);
+        Cursor {
+            rest: src,
+            off: span.lo,
+        }
+    })
+}
+
+#[cfg(not(span_locations))]
+fn get_cursor(src: &str) -> Cursor {
+    Cursor { rest: src }
+}
+
+impl FromStr for TokenStream {
+    type Err = LexError;
+
+    fn from_str(src: &str) -> Result<TokenStream, LexError> {
+        // Create a dummy file & add it to the source map
+        let mut cursor = get_cursor(src);
+
+        // Strip a byte order mark if present
+        const BYTE_ORDER_MARK: &str = "\u{feff}";
+        if cursor.starts_with(BYTE_ORDER_MARK) {
+            cursor = cursor.advance(BYTE_ORDER_MARK.len());
+        }
+
+        parse::token_stream(cursor)
+    }
+}
+
+impl Display for LexError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str("cannot parse string into token stream")
+    }
+}
+
+impl Display for TokenStream {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let mut joint = false;
+        for (i, tt) in self.inner.iter().enumerate() {
+            if i != 0 && !joint {
+                write!(f, " ")?;
+            }
+            joint = false;
+            match tt {
+                TokenTree::Group(tt) => Display::fmt(tt, f),
+                TokenTree::Ident(tt) => Display::fmt(tt, f),
+                TokenTree::Punct(tt) => {
+                    joint = tt.spacing() == Spacing::Joint;
+                    Display::fmt(tt, f)
+                }
+                TokenTree::Literal(tt) => Display::fmt(tt, f),
+            }?;
+        }
+
+        Ok(())
+    }
+}
+
+impl Debug for TokenStream {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str("TokenStream ")?;
+        f.debug_list().entries(self.clone()).finish()
+    }
+}
+
+#[cfg(feature = "proc-macro")]
+impl From<proc_macro::TokenStream> for TokenStream {
+    fn from(inner: proc_macro::TokenStream) -> Self {
+        inner
+            .to_string()
+            .parse()
+            .expect("compiler token stream parse failed")
+    }
+}
+
+#[cfg(feature = "proc-macro")]
+impl From<TokenStream> for proc_macro::TokenStream {
+    fn from(inner: TokenStream) -> Self {
+        inner
+            .to_string()
+            .parse()
+            .expect("failed to parse to compiler tokens")
+    }
+}
+
+impl From<TokenTree> for TokenStream {
+    fn from(tree: TokenTree) -> Self {
+        let mut stream = RcVecBuilder::new();
+        push_token_from_proc_macro(stream.as_mut(), tree);
+        TokenStream {
+            inner: stream.build(),
+        }
+    }
+}
+
+impl FromIterator<TokenTree> for TokenStream {
+    fn from_iter<I: IntoIterator<Item = TokenTree>>(tokens: I) -> Self {
+        let mut stream = TokenStream::new();
+        stream.extend(tokens);
+        stream
+    }
+}
+
+impl FromIterator<TokenStream> for TokenStream {
+    fn from_iter<I: IntoIterator<Item = TokenStream>>(streams: I) -> Self {
+        let mut v = RcVecBuilder::new();
+
+        for stream in streams {
+            v.extend(stream.take_inner());
+        }
+
+        TokenStream { inner: v.build() }
+    }
+}
+
+impl Extend<TokenTree> for TokenStream {
+    fn extend<I: IntoIterator<Item = TokenTree>>(&mut self, tokens: I) {
+        let mut vec = self.inner.make_mut();
+        tokens
+            .into_iter()
+            .for_each(|token| push_token_from_proc_macro(vec.as_mut(), token));
+    }
+}
+
+impl Extend<TokenStream> for TokenStream {
+    fn extend<I: IntoIterator<Item = TokenStream>>(&mut self, streams: I) {
+        self.inner.make_mut().extend(streams.into_iter().flatten());
+    }
+}
+
+pub(crate) type TokenTreeIter = RcVecIntoIter<TokenTree>;
+
+impl IntoIterator for TokenStream {
+    type Item = TokenTree;
+    type IntoIter = TokenTreeIter;
+
+    fn into_iter(self) -> TokenTreeIter {
+        self.take_inner().into_iter()
+    }
+}
+
+#[derive(Clone, PartialEq, Eq)]
+pub(crate) struct SourceFile {
+    path: PathBuf,
+}
+
+impl SourceFile {
+    /// Get the path to this source file as a string.
+    pub fn path(&self) -> PathBuf {
+        self.path.clone()
+    }
+
+    pub fn is_real(&self) -> bool {
+        false
+    }
+}
+
+impl Debug for SourceFile {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("SourceFile")
+            .field("path", &self.path())
+            .field("is_real", &self.is_real())
+            .finish()
+    }
+}
+
+#[cfg(all(span_locations, not(fuzzing)))]
+thread_local! {
+    static SOURCE_MAP: RefCell<SourceMap> = RefCell::new(SourceMap {
+        // Start with a single dummy file which all call_site() and def_site()
+        // spans reference.
+        files: vec![FileInfo {
+            source_text: String::new(),
+            span: Span { lo: 0, hi: 0 },
+            lines: vec![0],
+            char_index_to_byte_offset: BTreeMap::new(),
+        }],
+    });
+}
+
+#[cfg(all(span_locations, not(fuzzing)))]
+struct FileInfo {
+    source_text: String,
+    span: Span,
+    lines: Vec<usize>,
+    char_index_to_byte_offset: BTreeMap<usize, usize>,
+}
+
+#[cfg(all(span_locations, not(fuzzing)))]
+impl FileInfo {
+    fn offset_line_column(&self, offset: usize) -> LineColumn {
+        assert!(self.span_within(Span {
+            lo: offset as u32,
+            hi: offset as u32
+        }));
+        let offset = offset - self.span.lo as usize;
+        match self.lines.binary_search(&offset) {
+            Ok(found) => LineColumn {
+                line: found + 1,
+                column: 0,
+            },
+            Err(idx) => LineColumn {
+                line: idx,
+                column: offset - self.lines[idx - 1],
+            },
+        }
+    }
+
+    fn span_within(&self, span: Span) -> bool {
+        span.lo >= self.span.lo && span.hi <= self.span.hi
+    }
+
+    fn source_text(&mut self, span: Span) -> String {
+        let lo_char = (span.lo - self.span.lo) as usize;
+
+        // Look up offset of the largest already-computed char index that is
+        // less than or equal to the current requested one. We resume counting
+        // chars from that point.
+        let (&last_char_index, &last_byte_offset) = self
+            .char_index_to_byte_offset
+            .range(..=lo_char)
+            .next_back()
+            .unwrap_or((&0, &0));
+
+        let lo_byte = if last_char_index == lo_char {
+            last_byte_offset
+        } else {
+            let total_byte_offset = match self.source_text[last_byte_offset..]
+                .char_indices()
+                .nth(lo_char - last_char_index)
+            {
+                Some((additional_offset, _ch)) => last_byte_offset + additional_offset,
+                None => self.source_text.len(),
+            };
+            self.char_index_to_byte_offset
+                .insert(lo_char, total_byte_offset);
+            total_byte_offset
+        };
+
+        let trunc_lo = &self.source_text[lo_byte..];
+        let char_len = (span.hi - span.lo) as usize;
+        let source_text = match trunc_lo.char_indices().nth(char_len) {
+            Some((offset, _ch)) => &trunc_lo[..offset],
+            None => trunc_lo,
+        };
+        source_text.to_owned()
+    }
+}
+
+/// Computes the offsets of each line in the given source string
+/// and the total number of characters
+#[cfg(all(span_locations, not(fuzzing)))]
+fn lines_offsets(s: &str) -> (usize, Vec<usize>) {
+    let mut lines = vec![0];
+    let mut total = 0;
+
+    for ch in s.chars() {
+        total += 1;
+        if ch == '\n' {
+            lines.push(total);
+        }
+    }
+
+    (total, lines)
+}
+
+#[cfg(all(span_locations, not(fuzzing)))]
+struct SourceMap {
+    files: Vec<FileInfo>,
+}
+
+#[cfg(all(span_locations, not(fuzzing)))]
+impl SourceMap {
+    fn next_start_pos(&self) -> u32 {
+        // Add 1 so there's always space between files.
+        //
+        // We'll always have at least 1 file, as we initialize our files list
+        // with a dummy file.
+        self.files.last().unwrap().span.hi + 1
+    }
+
+    fn add_file(&mut self, src: &str) -> Span {
+        let (len, lines) = lines_offsets(src);
+        let lo = self.next_start_pos();
+        let span = Span {
+            lo,
+            hi: lo + (len as u32),
+        };
+
+        self.files.push(FileInfo {
+            source_text: src.to_owned(),
+            span,
+            lines,
+            // Populated lazily by source_text().
+            char_index_to_byte_offset: BTreeMap::new(),
+        });
+
+        span
+    }
+
+    #[cfg(procmacro2_semver_exempt)]
+    fn filepath(&self, span: Span) -> PathBuf {
+        for (i, file) in self.files.iter().enumerate() {
+            if file.span_within(span) {
+                return PathBuf::from(if i == 0 {
+                    "<unspecified>".to_owned()
+                } else {
+                    format!("<parsed string {}>", i)
+                });
+            }
+        }
+        unreachable!("Invalid span with no related FileInfo!");
+    }
+
+    fn fileinfo(&self, span: Span) -> &FileInfo {
+        for file in &self.files {
+            if file.span_within(span) {
+                return file;
+            }
+        }
+        unreachable!("Invalid span with no related FileInfo!");
+    }
+
+    fn fileinfo_mut(&mut self, span: Span) -> &mut FileInfo {
+        for file in &mut self.files {
+            if file.span_within(span) {
+                return file;
+            }
+        }
+        unreachable!("Invalid span with no related FileInfo!");
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub(crate) struct Span {
+    #[cfg(span_locations)]
+    pub(crate) lo: u32,
+    #[cfg(span_locations)]
+    pub(crate) hi: u32,
+}
+
+impl Span {
+    #[cfg(not(span_locations))]
+    pub fn call_site() -> Self {
+        Span {}
+    }
+
+    #[cfg(span_locations)]
+    pub fn call_site() -> Self {
+        Span { lo: 0, hi: 0 }
+    }
+
+    pub fn mixed_site() -> Self {
+        Span::call_site()
+    }
+
+    #[cfg(procmacro2_semver_exempt)]
+    pub fn def_site() -> Self {
+        Span::call_site()
+    }
+
+    pub fn resolved_at(&self, _other: Span) -> Span {
+        // Stable spans consist only of line/column information, so
+        // `resolved_at` and `located_at` only select which span the
+        // caller wants line/column information from.
+        *self
+    }
+
+    pub fn located_at(&self, other: Span) -> Span {
+        other
+    }
+
+    #[cfg(procmacro2_semver_exempt)]
+    pub fn source_file(&self) -> SourceFile {
+        #[cfg(fuzzing)]
+        return SourceFile {
+            path: PathBuf::from("<unspecified>"),
+        };
+
+        #[cfg(not(fuzzing))]
+        SOURCE_MAP.with(|cm| {
+            let cm = cm.borrow();
+            let path = cm.filepath(*self);
+            SourceFile { path }
+        })
+    }
+
+    #[cfg(span_locations)]
+    pub fn start(&self) -> LineColumn {
+        #[cfg(fuzzing)]
+        return LineColumn { line: 0, column: 0 };
+
+        #[cfg(not(fuzzing))]
+        SOURCE_MAP.with(|cm| {
+            let cm = cm.borrow();
+            let fi = cm.fileinfo(*self);
+            fi.offset_line_column(self.lo as usize)
+        })
+    }
+
+    #[cfg(span_locations)]
+    pub fn end(&self) -> LineColumn {
+        #[cfg(fuzzing)]
+        return LineColumn { line: 0, column: 0 };
+
+        #[cfg(not(fuzzing))]
+        SOURCE_MAP.with(|cm| {
+            let cm = cm.borrow();
+            let fi = cm.fileinfo(*self);
+            fi.offset_line_column(self.hi as usize)
+        })
+    }
+
+    #[cfg(not(span_locations))]
+    pub fn join(&self, _other: Span) -> Option<Span> {
+        Some(Span {})
+    }
+
+    #[cfg(span_locations)]
+    pub fn join(&self, other: Span) -> Option<Span> {
+        #[cfg(fuzzing)]
+        return {
+            let _ = other;
+            None
+        };
+
+        #[cfg(not(fuzzing))]
+        SOURCE_MAP.with(|cm| {
+            let cm = cm.borrow();
+            // If `other` is not within the same FileInfo as us, return None.
+            if !cm.fileinfo(*self).span_within(other) {
+                return None;
+            }
+            Some(Span {
+                lo: cmp::min(self.lo, other.lo),
+                hi: cmp::max(self.hi, other.hi),
+            })
+        })
+    }
+
+    #[cfg(not(span_locations))]
+    pub fn source_text(&self) -> Option<String> {
+        None
+    }
+
+    #[cfg(span_locations)]
+    pub fn source_text(&self) -> Option<String> {
+        #[cfg(fuzzing)]
+        return None;
+
+        #[cfg(not(fuzzing))]
+        {
+            if self.is_call_site() {
+                None
+            } else {
+                Some(SOURCE_MAP.with(|cm| cm.borrow_mut().fileinfo_mut(*self).source_text(*self)))
+            }
+        }
+    }
+
+    #[cfg(not(span_locations))]
+    pub(crate) fn first_byte(self) -> Self {
+        self
+    }
+
+    #[cfg(span_locations)]
+    pub(crate) fn first_byte(self) -> Self {
+        Span {
+            lo: self.lo,
+            hi: cmp::min(self.lo.saturating_add(1), self.hi),
+        }
+    }
+
+    #[cfg(not(span_locations))]
+    pub(crate) fn last_byte(self) -> Self {
+        self
+    }
+
+    #[cfg(span_locations)]
+    pub(crate) fn last_byte(self) -> Self {
+        Span {
+            lo: cmp::max(self.hi.saturating_sub(1), self.lo),
+            hi: self.hi,
+        }
+    }
+
+    #[cfg(span_locations)]
+    fn is_call_site(&self) -> bool {
+        self.lo == 0 && self.hi == 0
+    }
+}
+
+impl Debug for Span {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        #[cfg(span_locations)]
+        return write!(f, "bytes({}..{})", self.lo, self.hi);
+
+        #[cfg(not(span_locations))]
+        write!(f, "Span")
+    }
+}
+
+pub(crate) fn debug_span_field_if_nontrivial(debug: &mut fmt::DebugStruct, span: Span) {
+    #[cfg(span_locations)]
+    {
+        if span.is_call_site() {
+            return;
+        }
+    }
+
+    if cfg!(span_locations) {
+        debug.field("span", &span);
+    }
+}
+
+#[derive(Clone)]
+pub(crate) struct Group {
+    delimiter: Delimiter,
+    stream: TokenStream,
+    span: Span,
+}
+
+impl Group {
+    pub fn new(delimiter: Delimiter, stream: TokenStream) -> Self {
+        Group {
+            delimiter,
+            stream,
+            span: Span::call_site(),
+        }
+    }
+
+    pub fn delimiter(&self) -> Delimiter {
+        self.delimiter
+    }
+
+    pub fn stream(&self) -> TokenStream {
+        self.stream.clone()
+    }
+
+    pub fn span(&self) -> Span {
+        self.span
+    }
+
+    pub fn span_open(&self) -> Span {
+        self.span.first_byte()
+    }
+
+    pub fn span_close(&self) -> Span {
+        self.span.last_byte()
+    }
+
+    pub fn set_span(&mut self, span: Span) {
+        self.span = span;
+    }
+}
+
+impl Display for Group {
+    // We attempt to match libproc_macro's formatting.
+    // Empty parens: ()
+    // Nonempty parens: (...)
+    // Empty brackets: []
+    // Nonempty brackets: [...]
+    // Empty braces: { }
+    // Nonempty braces: { ... }
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let (open, close) = match self.delimiter {
+            Delimiter::Parenthesis => ("(", ")"),
+            Delimiter::Brace => ("{ ", "}"),
+            Delimiter::Bracket => ("[", "]"),
+            Delimiter::None => ("", ""),
+        };
+
+        f.write_str(open)?;
+        Display::fmt(&self.stream, f)?;
+        if self.delimiter == Delimiter::Brace && !self.stream.inner.is_empty() {
+            f.write_str(" ")?;
+        }
+        f.write_str(close)?;
+
+        Ok(())
+    }
+}
+
+impl Debug for Group {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        let mut debug = fmt.debug_struct("Group");
+        debug.field("delimiter", &self.delimiter);
+        debug.field("stream", &self.stream);
+        debug_span_field_if_nontrivial(&mut debug, self.span);
+        debug.finish()
+    }
+}
+
+#[derive(Clone)]
+pub(crate) struct Ident {
+    sym: String,
+    span: Span,
+    raw: bool,
+}
+
+impl Ident {
+    fn _new(string: &str, raw: bool, span: Span) -> Self {
+        validate_ident(string, raw);
+
+        Ident {
+            sym: string.to_owned(),
+            span,
+            raw,
+        }
+    }
+
+    pub fn new(string: &str, span: Span) -> Self {
+        Ident::_new(string, false, span)
+    }
+
+    pub fn new_raw(string: &str, span: Span) -> Self {
+        Ident::_new(string, true, span)
+    }
+
+    pub fn span(&self) -> Span {
+        self.span
+    }
+
+    pub fn set_span(&mut self, span: Span) {
+        self.span = span;
+    }
+}
+
+pub(crate) fn is_ident_start(c: char) -> bool {
+    c == '_' || unicode_ident::is_xid_start(c)
+}
+
+pub(crate) fn is_ident_continue(c: char) -> bool {
+    unicode_ident::is_xid_continue(c)
+}
+
+fn validate_ident(string: &str, raw: bool) {
+    if string.is_empty() {
+        panic!("Ident is not allowed to be empty; use Option<Ident>");
+    }
+
+    if string.bytes().all(|digit| b'0' <= digit && digit <= b'9') {
+        panic!("Ident cannot be a number; use Literal instead");
+    }
+
+    fn ident_ok(string: &str) -> bool {
+        let mut chars = string.chars();
+        let first = chars.next().unwrap();
+        if !is_ident_start(first) {
+            return false;
+        }
+        for ch in chars {
+            if !is_ident_continue(ch) {
+                return false;
+            }
+        }
+        true
+    }
+
+    if !ident_ok(string) {
+        panic!("{:?} is not a valid Ident", string);
+    }
+
+    if raw {
+        match string {
+            "_" | "super" | "self" | "Self" | "crate" => {
+                panic!("`r#{}` cannot be a raw identifier", string);
+            }
+            _ => {}
+        }
+    }
+}
+
+impl PartialEq for Ident {
+    fn eq(&self, other: &Ident) -> bool {
+        self.sym == other.sym && self.raw == other.raw
+    }
+}
+
+impl<T> PartialEq<T> for Ident
+where
+    T: ?Sized + AsRef<str>,
+{
+    fn eq(&self, other: &T) -> bool {
+        let other = other.as_ref();
+        if self.raw {
+            other.starts_with("r#") && self.sym == other[2..]
+        } else {
+            self.sym == other
+        }
+    }
+}
+
+impl Display for Ident {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        if self.raw {
+            f.write_str("r#")?;
+        }
+        Display::fmt(&self.sym, f)
+    }
+}
+
+#[allow(clippy::missing_fields_in_debug)]
+impl Debug for Ident {
+    // Ident(proc_macro), Ident(r#union)
+    #[cfg(not(span_locations))]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let mut debug = f.debug_tuple("Ident");
+        debug.field(&format_args!("{}", self));
+        debug.finish()
+    }
+
+    // Ident {
+    //     sym: proc_macro,
+    //     span: bytes(128..138)
+    // }
+    #[cfg(span_locations)]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let mut debug = f.debug_struct("Ident");
+        debug.field("sym", &format_args!("{}", self));
+        debug_span_field_if_nontrivial(&mut debug, self.span);
+        debug.finish()
+    }
+}
+
+#[derive(Clone)]
+pub(crate) struct Literal {
+    repr: String,
+    span: Span,
+}
+
+macro_rules! suffixed_numbers {
+    ($($name:ident => $kind:ident,)*) => ($(
+        pub fn $name(n: $kind) -> Literal {
+            Literal::_new(format!(concat!("{}", stringify!($kind)), n))
+        }
+    )*)
+}
+
+macro_rules! unsuffixed_numbers {
+    ($($name:ident => $kind:ident,)*) => ($(
+        pub fn $name(n: $kind) -> Literal {
+            Literal::_new(n.to_string())
+        }
+    )*)
+}
+
+impl Literal {
+    pub(crate) fn _new(repr: String) -> Self {
+        Literal {
+            repr,
+            span: Span::call_site(),
+        }
+    }
+
+    pub(crate) unsafe fn from_str_unchecked(repr: &str) -> Self {
+        Literal::_new(repr.to_owned())
+    }
+
+    suffixed_numbers! {
+        u8_suffixed => u8,
+        u16_suffixed => u16,
+        u32_suffixed => u32,
+        u64_suffixed => u64,
+        u128_suffixed => u128,
+        usize_suffixed => usize,
+        i8_suffixed => i8,
+        i16_suffixed => i16,
+        i32_suffixed => i32,
+        i64_suffixed => i64,
+        i128_suffixed => i128,
+        isize_suffixed => isize,
+
+        f32_suffixed => f32,
+        f64_suffixed => f64,
+    }
+
+    unsuffixed_numbers! {
+        u8_unsuffixed => u8,
+        u16_unsuffixed => u16,
+        u32_unsuffixed => u32,
+        u64_unsuffixed => u64,
+        u128_unsuffixed => u128,
+        usize_unsuffixed => usize,
+        i8_unsuffixed => i8,
+        i16_unsuffixed => i16,
+        i32_unsuffixed => i32,
+        i64_unsuffixed => i64,
+        i128_unsuffixed => i128,
+        isize_unsuffixed => isize,
+    }
+
+    pub fn f32_unsuffixed(f: f32) -> Literal {
+        let mut s = f.to_string();
+        if !s.contains('.') {
+            s.push_str(".0");
+        }
+        Literal::_new(s)
+    }
+
+    pub fn f64_unsuffixed(f: f64) -> Literal {
+        let mut s = f.to_string();
+        if !s.contains('.') {
+            s.push_str(".0");
+        }
+        Literal::_new(s)
+    }
+
+    pub fn string(t: &str) -> Literal {
+        let mut repr = String::with_capacity(t.len() + 2);
+        repr.push('"');
+        let mut chars = t.chars();
+        while let Some(ch) = chars.next() {
+            if ch == '\0' {
+                repr.push_str(
+                    if chars
+                        .as_str()
+                        .starts_with(|next| '0' <= next && next <= '7')
+                    {
+                        // circumvent clippy::octal_escapes lint
+                        "\\x00"
+                    } else {
+                        "\\0"
+                    },
+                );
+            } else if ch == '\'' {
+                // escape_debug turns this into "\'" which is unnecessary.
+                repr.push(ch);
+            } else {
+                repr.extend(ch.escape_debug());
+            }
+        }
+        repr.push('"');
+        Literal::_new(repr)
+    }
+
+    pub fn character(t: char) -> Literal {
+        let mut repr = String::new();
+        repr.push('\'');
+        if t == '"' {
+            // escape_debug turns this into '\"' which is unnecessary.
+            repr.push(t);
+        } else {
+            repr.extend(t.escape_debug());
+        }
+        repr.push('\'');
+        Literal::_new(repr)
+    }
+
+    pub fn byte_string(bytes: &[u8]) -> Literal {
+        let mut escaped = "b\"".to_string();
+        let mut bytes = bytes.iter();
+        while let Some(&b) = bytes.next() {
+            #[allow(clippy::match_overlapping_arm)]
+            match b {
+                b'\0' => escaped.push_str(match bytes.as_slice().first() {
+                    // circumvent clippy::octal_escapes lint
+                    Some(b'0'..=b'7') => r"\x00",
+                    _ => r"\0",
+                }),
+                b'\t' => escaped.push_str(r"\t"),
+                b'\n' => escaped.push_str(r"\n"),
+                b'\r' => escaped.push_str(r"\r"),
+                b'"' => escaped.push_str("\\\""),
+                b'\\' => escaped.push_str("\\\\"),
+                b'\x20'..=b'\x7E' => escaped.push(b as char),
+                _ => {
+                    let _ = write!(escaped, "\\x{:02X}", b);
+                }
+            }
+        }
+        escaped.push('"');
+        Literal::_new(escaped)
+    }
+
+    pub fn span(&self) -> Span {
+        self.span
+    }
+
+    pub fn set_span(&mut self, span: Span) {
+        self.span = span;
+    }
+
+    pub fn subspan<R: RangeBounds<usize>>(&self, range: R) -> Option<Span> {
+        #[cfg(not(span_locations))]
+        {
+            let _ = range;
+            None
+        }
+
+        #[cfg(span_locations)]
+        {
+            use core::ops::Bound;
+
+            let lo = match range.start_bound() {
+                Bound::Included(start) => {
+                    let start = u32::try_from(*start).ok()?;
+                    self.span.lo.checked_add(start)?
+                }
+                Bound::Excluded(start) => {
+                    let start = u32::try_from(*start).ok()?;
+                    self.span.lo.checked_add(start)?.checked_add(1)?
+                }
+                Bound::Unbounded => self.span.lo,
+            };
+            let hi = match range.end_bound() {
+                Bound::Included(end) => {
+                    let end = u32::try_from(*end).ok()?;
+                    self.span.lo.checked_add(end)?.checked_add(1)?
+                }
+                Bound::Excluded(end) => {
+                    let end = u32::try_from(*end).ok()?;
+                    self.span.lo.checked_add(end)?
+                }
+                Bound::Unbounded => self.span.hi,
+            };
+            if lo <= hi && hi <= self.span.hi {
+                Some(Span { lo, hi })
+            } else {
+                None
+            }
+        }
+    }
+}
+
+impl FromStr for Literal {
+    type Err = LexError;
+
+    fn from_str(repr: &str) -> Result<Self, Self::Err> {
+        let mut cursor = get_cursor(repr);
+        #[cfg(span_locations)]
+        let lo = cursor.off;
+
+        let negative = cursor.starts_with_char('-');
+        if negative {
+            cursor = cursor.advance(1);
+            if !cursor.starts_with_fn(|ch| ch.is_ascii_digit()) {
+                return Err(LexError::call_site());
+            }
+        }
+
+        if let Ok((rest, mut literal)) = parse::literal(cursor) {
+            if rest.is_empty() {
+                if negative {
+                    literal.repr.insert(0, '-');
+                }
+                literal.span = Span {
+                    #[cfg(span_locations)]
+                    lo,
+                    #[cfg(span_locations)]
+                    hi: rest.off,
+                };
+                return Ok(literal);
+            }
+        }
+        Err(LexError::call_site())
+    }
+}
+
+impl Display for Literal {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        Display::fmt(&self.repr, f)
+    }
+}
+
+impl Debug for Literal {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        let mut debug = fmt.debug_struct("Literal");
+        debug.field("lit", &format_args!("{}", self.repr));
+        debug_span_field_if_nontrivial(&mut debug, self.span);
+        debug.finish()
+    }
+}
diff --git a/crates/proc-macro2/src/lib.rs b/crates/proc-macro2/src/lib.rs
new file mode 100644
index 0000000..56d986b
--- /dev/null
+++ b/crates/proc-macro2/src/lib.rs
@@ -0,0 +1,1318 @@
+//! [![github]](https://github.com/dtolnay/proc-macro2)&ensp;[![crates-io]](https://crates.io/crates/proc-macro2)&ensp;[![docs-rs]](crate)
+//!
+//! [github]: https://img.shields.io/badge/github-8da0cb?style=for-the-badge&labelColor=555555&logo=github
+//! [crates-io]: https://img.shields.io/badge/crates.io-fc8d62?style=for-the-badge&labelColor=555555&logo=rust
+//! [docs-rs]: https://img.shields.io/badge/docs.rs-66c2a5?style=for-the-badge&labelColor=555555&logo=docs.rs
+//!
+//! <br>
+//!
+//! A wrapper around the procedural macro API of the compiler's [`proc_macro`]
+//! crate. This library serves two purposes:
+//!
+//! [`proc_macro`]: https://doc.rust-lang.org/proc_macro/
+//!
+//! - **Bring proc-macro-like functionality to other contexts like build.rs and
+//!   main.rs.** Types from `proc_macro` are entirely specific to procedural
+//!   macros and cannot ever exist in code outside of a procedural macro.
+//!   Meanwhile `proc_macro2` types may exist anywhere including non-macro code.
+//!   By developing foundational libraries like [syn] and [quote] against
+//!   `proc_macro2` rather than `proc_macro`, the procedural macro ecosystem
+//!   becomes easily applicable to many other use cases and we avoid
+//!   reimplementing non-macro equivalents of those libraries.
+//!
+//! - **Make procedural macros unit testable.** As a consequence of being
+//!   specific to procedural macros, nothing that uses `proc_macro` can be
+//!   executed from a unit test. In order for helper libraries or components of
+//!   a macro to be testable in isolation, they must be implemented using
+//!   `proc_macro2`.
+//!
+//! [syn]: https://github.com/dtolnay/syn
+//! [quote]: https://github.com/dtolnay/quote
+//!
+//! # Usage
+//!
+//! The skeleton of a typical procedural macro typically looks like this:
+//!
+//! ```
+//! extern crate proc_macro;
+//!
+//! # const IGNORE: &str = stringify! {
+//! #[proc_macro_derive(MyDerive)]
+//! # };
+//! # #[cfg(wrap_proc_macro)]
+//! pub fn my_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+//!     let input = proc_macro2::TokenStream::from(input);
+//!
+//!     let output: proc_macro2::TokenStream = {
+//!         /* transform input */
+//!         # input
+//!     };
+//!
+//!     proc_macro::TokenStream::from(output)
+//! }
+//! ```
+//!
+//! If parsing with [Syn], you'll use [`parse_macro_input!`] instead to
+//! propagate parse errors correctly back to the compiler when parsing fails.
+//!
+//! [`parse_macro_input!`]: https://docs.rs/syn/2.0/syn/macro.parse_macro_input.html
+//!
+//! # Unstable features
+//!
+//! The default feature set of proc-macro2 tracks the most recent stable
+//! compiler API. Functionality in `proc_macro` that is not yet stable is not
+//! exposed by proc-macro2 by default.
+//!
+//! To opt into the additional APIs available in the most recent nightly
+//! compiler, the `procmacro2_semver_exempt` config flag must be passed to
+//! rustc. We will polyfill those nightly-only APIs back to Rust 1.56.0. As
+//! these are unstable APIs that track the nightly compiler, minor versions of
+//! proc-macro2 may make breaking changes to them at any time.
+//!
+//! ```sh
+//! RUSTFLAGS='--cfg procmacro2_semver_exempt' cargo build
+//! ```
+//!
+//! Note that this must not only be done for your crate, but for any crate that
+//! depends on your crate. This infectious nature is intentional, as it serves
+//! as a reminder that you are outside of the normal semver guarantees.
+//!
+//! Semver exempt methods are marked as such in the proc-macro2 documentation.
+//!
+//! # Thread-Safety
+//!
+//! Most types in this crate are `!Sync` because the underlying compiler
+//! types make use of thread-local memory, meaning they cannot be accessed from
+//! a different thread.
+
+// Proc-macro2 types in rustdoc of other crates get linked to here.
+#![doc(html_root_url = "https://docs.rs/proc-macro2/1.0.69")]
+#![cfg_attr(any(proc_macro_span, super_unstable), feature(proc_macro_span))]
+#![cfg_attr(super_unstable, feature(proc_macro_def_site))]
+#![cfg_attr(doc_cfg, feature(doc_cfg))]
+#![allow(
+    clippy::cast_lossless,
+    clippy::cast_possible_truncation,
+    clippy::doc_markdown,
+    clippy::items_after_statements,
+    clippy::iter_without_into_iter,
+    clippy::let_underscore_untyped,
+    clippy::manual_assert,
+    clippy::manual_range_contains,
+    clippy::missing_safety_doc,
+    clippy::must_use_candidate,
+    clippy::needless_doctest_main,
+    clippy::new_without_default,
+    clippy::return_self_not_must_use,
+    clippy::shadow_unrelated,
+    clippy::trivially_copy_pass_by_ref,
+    clippy::unnecessary_wraps,
+    clippy::unused_self,
+    clippy::used_underscore_binding,
+    clippy::vec_init_then_push
+)]
+
+#[cfg(all(procmacro2_semver_exempt, wrap_proc_macro, not(super_unstable)))]
+compile_error! {"\
+    Something is not right. If you've tried to turn on \
+    procmacro2_semver_exempt, you need to ensure that it \
+    is turned on for the compilation of the proc-macro2 \
+    build script as well.
+"}
+
+extern crate alloc;
+
+#[cfg(feature = "proc-macro")]
+extern crate proc_macro;
+
+mod marker;
+mod parse;
+mod rcvec;
+
+#[cfg(wrap_proc_macro)]
+mod detection;
+
+// Public for proc_macro2::fallback::force() and unforce(), but those are quite
+// a niche use case so we omit it from rustdoc.
+#[doc(hidden)]
+pub mod fallback;
+
+pub mod extra;
+
+#[cfg(not(wrap_proc_macro))]
+use crate::fallback as imp;
+#[path = "wrapper.rs"]
+#[cfg(wrap_proc_macro)]
+mod imp;
+
+#[cfg(span_locations)]
+mod location;
+
+use crate::extra::DelimSpan;
+use crate::marker::Marker;
+use core::cmp::Ordering;
+use core::fmt::{self, Debug, Display};
+use core::hash::{Hash, Hasher};
+use core::ops::RangeBounds;
+use core::str::FromStr;
+use std::error::Error;
+#[cfg(procmacro2_semver_exempt)]
+use std::path::PathBuf;
+
+#[cfg(span_locations)]
+pub use crate::location::LineColumn;
+
+/// An abstract stream of tokens, or more concretely a sequence of token trees.
+///
+/// This type provides interfaces for iterating over token trees and for
+/// collecting token trees into one stream.
+///
+/// Token stream is both the input and output of `#[proc_macro]`,
+/// `#[proc_macro_attribute]` and `#[proc_macro_derive]` definitions.
+#[derive(Clone)]
+pub struct TokenStream {
+    inner: imp::TokenStream,
+    _marker: Marker,
+}
+
+/// Error returned from `TokenStream::from_str`.
+pub struct LexError {
+    inner: imp::LexError,
+    _marker: Marker,
+}
+
+impl TokenStream {
+    fn _new(inner: imp::TokenStream) -> Self {
+        TokenStream {
+            inner,
+            _marker: Marker,
+        }
+    }
+
+    fn _new_fallback(inner: fallback::TokenStream) -> Self {
+        TokenStream {
+            inner: inner.into(),
+            _marker: Marker,
+        }
+    }
+
+    /// Returns an empty `TokenStream` containing no token trees.
+    pub fn new() -> Self {
+        TokenStream::_new(imp::TokenStream::new())
+    }
+
+    /// Checks if this `TokenStream` is empty.
+    pub fn is_empty(&self) -> bool {
+        self.inner.is_empty()
+    }
+}
+
+/// `TokenStream::default()` returns an empty stream,
+/// i.e. this is equivalent with `TokenStream::new()`.
+impl Default for TokenStream {
+    fn default() -> Self {
+        TokenStream::new()
+    }
+}
+
+/// Attempts to break the string into tokens and parse those tokens into a token
+/// stream.
+///
+/// May fail for a number of reasons, for example, if the string contains
+/// unbalanced delimiters or characters not existing in the language.
+///
+/// NOTE: Some errors may cause panics instead of returning `LexError`. We
+/// reserve the right to change these errors into `LexError`s later.
+impl FromStr for TokenStream {
+    type Err = LexError;
+
+    fn from_str(src: &str) -> Result<TokenStream, LexError> {
+        let e = src.parse().map_err(|e| LexError {
+            inner: e,
+            _marker: Marker,
+        })?;
+        Ok(TokenStream::_new(e))
+    }
+}
+
+#[cfg(feature = "proc-macro")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "proc-macro")))]
+impl From<proc_macro::TokenStream> for TokenStream {
+    fn from(inner: proc_macro::TokenStream) -> Self {
+        TokenStream::_new(inner.into())
+    }
+}
+
+#[cfg(feature = "proc-macro")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "proc-macro")))]
+impl From<TokenStream> for proc_macro::TokenStream {
+    fn from(inner: TokenStream) -> Self {
+        inner.inner.into()
+    }
+}
+
+impl From<TokenTree> for TokenStream {
+    fn from(token: TokenTree) -> Self {
+        TokenStream::_new(imp::TokenStream::from(token))
+    }
+}
+
+impl Extend<TokenTree> for TokenStream {
+    fn extend<I: IntoIterator<Item = TokenTree>>(&mut self, streams: I) {
+        self.inner.extend(streams);
+    }
+}
+
+impl Extend<TokenStream> for TokenStream {
+    fn extend<I: IntoIterator<Item = TokenStream>>(&mut self, streams: I) {
+        self.inner
+            .extend(streams.into_iter().map(|stream| stream.inner));
+    }
+}
+
+/// Collects a number of token trees into a single stream.
+impl FromIterator<TokenTree> for TokenStream {
+    fn from_iter<I: IntoIterator<Item = TokenTree>>(streams: I) -> Self {
+        TokenStream::_new(streams.into_iter().collect())
+    }
+}
+impl FromIterator<TokenStream> for TokenStream {
+    fn from_iter<I: IntoIterator<Item = TokenStream>>(streams: I) -> Self {
+        TokenStream::_new(streams.into_iter().map(|i| i.inner).collect())
+    }
+}
+
+/// Prints the token stream as a string that is supposed to be losslessly
+/// convertible back into the same token stream (modulo spans), except for
+/// possibly `TokenTree::Group`s with `Delimiter::None` delimiters and negative
+/// numeric literals.
+impl Display for TokenStream {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        Display::fmt(&self.inner, f)
+    }
+}
+
+/// Prints token in a form convenient for debugging.
+impl Debug for TokenStream {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        Debug::fmt(&self.inner, f)
+    }
+}
+
+impl LexError {
+    pub fn span(&self) -> Span {
+        Span::_new(self.inner.span())
+    }
+}
+
+impl Debug for LexError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        Debug::fmt(&self.inner, f)
+    }
+}
+
+impl Display for LexError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        Display::fmt(&self.inner, f)
+    }
+}
+
+impl Error for LexError {}
+
+/// The source file of a given `Span`.
+///
+/// This type is semver exempt and not exposed by default.
+#[cfg(all(procmacro2_semver_exempt, any(not(wrap_proc_macro), super_unstable)))]
+#[cfg_attr(doc_cfg, doc(cfg(procmacro2_semver_exempt)))]
+#[derive(Clone, PartialEq, Eq)]
+pub struct SourceFile {
+    inner: imp::SourceFile,
+    _marker: Marker,
+}
+
+#[cfg(all(procmacro2_semver_exempt, any(not(wrap_proc_macro), super_unstable)))]
+impl SourceFile {
+    fn _new(inner: imp::SourceFile) -> Self {
+        SourceFile {
+            inner,
+            _marker: Marker,
+        }
+    }
+
+    /// Get the path to this source file.
+    ///
+    /// ### Note
+    ///
+    /// If the code span associated with this `SourceFile` was generated by an
+    /// external macro, this may not be an actual path on the filesystem. Use
+    /// [`is_real`] to check.
+    ///
+    /// Also note that even if `is_real` returns `true`, if
+    /// `--remap-path-prefix` was passed on the command line, the path as given
+    /// may not actually be valid.
+    ///
+    /// [`is_real`]: #method.is_real
+    pub fn path(&self) -> PathBuf {
+        self.inner.path()
+    }
+
+    /// Returns `true` if this source file is a real source file, and not
+    /// generated by an external macro's expansion.
+    pub fn is_real(&self) -> bool {
+        self.inner.is_real()
+    }
+}
+
+#[cfg(all(procmacro2_semver_exempt, any(not(wrap_proc_macro), super_unstable)))]
+impl Debug for SourceFile {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        Debug::fmt(&self.inner, f)
+    }
+}
+
+/// A region of source code, along with macro expansion information.
+#[derive(Copy, Clone)]
+pub struct Span {
+    inner: imp::Span,
+    _marker: Marker,
+}
+
+impl Span {
+    fn _new(inner: imp::Span) -> Self {
+        Span {
+            inner,
+            _marker: Marker,
+        }
+    }
+
+    fn _new_fallback(inner: fallback::Span) -> Self {
+        Span {
+            inner: inner.into(),
+            _marker: Marker,
+        }
+    }
+
+    /// The span of the invocation of the current procedural macro.
+    ///
+    /// Identifiers created with this span will be resolved as if they were
+    /// written directly at the macro call location (call-site hygiene) and
+    /// other code at the macro call site will be able to refer to them as well.
+    pub fn call_site() -> Self {
+        Span::_new(imp::Span::call_site())
+    }
+
+    /// The span located at the invocation of the procedural macro, but with
+    /// local variables, labels, and `$crate` resolved at the definition site
+    /// of the macro. This is the same hygiene behavior as `macro_rules`.
+    pub fn mixed_site() -> Self {
+        Span::_new(imp::Span::mixed_site())
+    }
+
+    /// A span that resolves at the macro definition site.
+    ///
+    /// This method is semver exempt and not exposed by default.
+    #[cfg(procmacro2_semver_exempt)]
+    #[cfg_attr(doc_cfg, doc(cfg(procmacro2_semver_exempt)))]
+    pub fn def_site() -> Self {
+        Span::_new(imp::Span::def_site())
+    }
+
+    /// Creates a new span with the same line/column information as `self` but
+    /// that resolves symbols as though it were at `other`.
+    pub fn resolved_at(&self, other: Span) -> Span {
+        Span::_new(self.inner.resolved_at(other.inner))
+    }
+
+    /// Creates a new span with the same name resolution behavior as `self` but
+    /// with the line/column information of `other`.
+    pub fn located_at(&self, other: Span) -> Span {
+        Span::_new(self.inner.located_at(other.inner))
+    }
+
+    /// Convert `proc_macro2::Span` to `proc_macro::Span`.
+    ///
+    /// This method is available when building with a nightly compiler, or when
+    /// building with rustc 1.29+ *without* semver exempt features.
+    ///
+    /// # Panics
+    ///
+    /// Panics if called from outside of a procedural macro. Unlike
+    /// `proc_macro2::Span`, the `proc_macro::Span` type can only exist within
+    /// the context of a procedural macro invocation.
+    #[cfg(wrap_proc_macro)]
+    pub fn unwrap(self) -> proc_macro::Span {
+        self.inner.unwrap()
+    }
+
+    // Soft deprecated. Please use Span::unwrap.
+    #[cfg(wrap_proc_macro)]
+    #[doc(hidden)]
+    pub fn unstable(self) -> proc_macro::Span {
+        self.unwrap()
+    }
+
+    /// The original source file into which this span points.
+    ///
+    /// This method is semver exempt and not exposed by default.
+    #[cfg(all(procmacro2_semver_exempt, any(not(wrap_proc_macro), super_unstable)))]
+    #[cfg_attr(doc_cfg, doc(cfg(procmacro2_semver_exempt)))]
+    pub fn source_file(&self) -> SourceFile {
+        SourceFile::_new(self.inner.source_file())
+    }
+
+    /// Get the starting line/column in the source file for this span.
+    ///
+    /// This method requires the `"span-locations"` feature to be enabled.
+    ///
+    /// When executing in a procedural macro context, the returned line/column
+    /// are only meaningful if compiled with a nightly toolchain. The stable
+    /// toolchain does not have this information available. When executing
+    /// outside of a procedural macro, such as main.rs or build.rs, the
+    /// line/column are always meaningful regardless of toolchain.
+    #[cfg(span_locations)]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "span-locations")))]
+    pub fn start(&self) -> LineColumn {
+        self.inner.start()
+    }
+
+    /// Get the ending line/column in the source file for this span.
+    ///
+    /// This method requires the `"span-locations"` feature to be enabled.
+    ///
+    /// When executing in a procedural macro context, the returned line/column
+    /// are only meaningful if compiled with a nightly toolchain. The stable
+    /// toolchain does not have this information available. When executing
+    /// outside of a procedural macro, such as main.rs or build.rs, the
+    /// line/column are always meaningful regardless of toolchain.
+    #[cfg(span_locations)]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "span-locations")))]
+    pub fn end(&self) -> LineColumn {
+        self.inner.end()
+    }
+
+    /// Create a new span encompassing `self` and `other`.
+    ///
+    /// Returns `None` if `self` and `other` are from different files.
+    ///
+    /// Warning: the underlying [`proc_macro::Span::join`] method is
+    /// nightly-only. When called from within a procedural macro not using a
+    /// nightly compiler, this method will always return `None`.
+    ///
+    /// [`proc_macro::Span::join`]: https://doc.rust-lang.org/proc_macro/struct.Span.html#method.join
+    pub fn join(&self, other: Span) -> Option<Span> {
+        self.inner.join(other.inner).map(Span::_new)
+    }
+
+    /// Compares two spans to see if they're equal.
+    ///
+    /// This method is semver exempt and not exposed by default.
+    #[cfg(procmacro2_semver_exempt)]
+    #[cfg_attr(doc_cfg, doc(cfg(procmacro2_semver_exempt)))]
+    pub fn eq(&self, other: &Span) -> bool {
+        self.inner.eq(&other.inner)
+    }
+
+    /// Returns the source text behind a span. This preserves the original
+    /// source code, including spaces and comments. It only returns a result if
+    /// the span corresponds to real source code.
+    ///
+    /// Note: The observable result of a macro should only rely on the tokens
+    /// and not on this source text. The result of this function is a best
+    /// effort to be used for diagnostics only.
+    pub fn source_text(&self) -> Option<String> {
+        self.inner.source_text()
+    }
+}
+
+/// Prints a span in a form convenient for debugging.
+impl Debug for Span {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        Debug::fmt(&self.inner, f)
+    }
+}
+
+/// A single token or a delimited sequence of token trees (e.g. `[1, (), ..]`).
+#[derive(Clone)]
+pub enum TokenTree {
+    /// A token stream surrounded by bracket delimiters.
+    Group(Group),
+    /// An identifier.
+    Ident(Ident),
+    /// A single punctuation character (`+`, `,`, `$`, etc.).
+    Punct(Punct),
+    /// A literal character (`'a'`), string (`"hello"`), number (`2.3`), etc.
+    Literal(Literal),
+}
+
+impl TokenTree {
+    /// Returns the span of this tree, delegating to the `span` method of
+    /// the contained token or a delimited stream.
+    pub fn span(&self) -> Span {
+        match self {
+            TokenTree::Group(t) => t.span(),
+            TokenTree::Ident(t) => t.span(),
+            TokenTree::Punct(t) => t.span(),
+            TokenTree::Literal(t) => t.span(),
+        }
+    }
+
+    /// Configures the span for *only this token*.
+    ///
+    /// Note that if this token is a `Group` then this method will not configure
+    /// the span of each of the internal tokens, this will simply delegate to
+    /// the `set_span` method of each variant.
+    pub fn set_span(&mut self, span: Span) {
+        match self {
+            TokenTree::Group(t) => t.set_span(span),
+            TokenTree::Ident(t) => t.set_span(span),
+            TokenTree::Punct(t) => t.set_span(span),
+            TokenTree::Literal(t) => t.set_span(span),
+        }
+    }
+}
+
+impl From<Group> for TokenTree {
+    fn from(g: Group) -> Self {
+        TokenTree::Group(g)
+    }
+}
+
+impl From<Ident> for TokenTree {
+    fn from(g: Ident) -> Self {
+        TokenTree::Ident(g)
+    }
+}
+
+impl From<Punct> for TokenTree {
+    fn from(g: Punct) -> Self {
+        TokenTree::Punct(g)
+    }
+}
+
+impl From<Literal> for TokenTree {
+    fn from(g: Literal) -> Self {
+        TokenTree::Literal(g)
+    }
+}
+
+/// Prints the token tree as a string that is supposed to be losslessly
+/// convertible back into the same token tree (modulo spans), except for
+/// possibly `TokenTree::Group`s with `Delimiter::None` delimiters and negative
+/// numeric literals.
+impl Display for TokenTree {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            TokenTree::Group(t) => Display::fmt(t, f),
+            TokenTree::Ident(t) => Display::fmt(t, f),
+            TokenTree::Punct(t) => Display::fmt(t, f),
+            TokenTree::Literal(t) => Display::fmt(t, f),
+        }
+    }
+}
+
+/// Prints token tree in a form convenient for debugging.
+impl Debug for TokenTree {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        // Each of these has the name in the struct type in the derived debug,
+        // so don't bother with an extra layer of indirection
+        match self {
+            TokenTree::Group(t) => Debug::fmt(t, f),
+            TokenTree::Ident(t) => {
+                let mut debug = f.debug_struct("Ident");
+                debug.field("sym", &format_args!("{}", t));
+                imp::debug_span_field_if_nontrivial(&mut debug, t.span().inner);
+                debug.finish()
+            }
+            TokenTree::Punct(t) => Debug::fmt(t, f),
+            TokenTree::Literal(t) => Debug::fmt(t, f),
+        }
+    }
+}
+
+/// A delimited token stream.
+///
+/// A `Group` internally contains a `TokenStream` which is surrounded by
+/// `Delimiter`s.
+#[derive(Clone)]
+pub struct Group {
+    inner: imp::Group,
+}
+
+/// Describes how a sequence of token trees is delimited.
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum Delimiter {
+    /// `( ... )`
+    Parenthesis,
+    /// `{ ... }`
+    Brace,
+    /// `[ ... ]`
+    Bracket,
+    /// `Ø ... Ø`
+    ///
+    /// An implicit delimiter, that may, for example, appear around tokens
+    /// coming from a "macro variable" `$var`. It is important to preserve
+    /// operator priorities in cases like `$var * 3` where `$var` is `1 + 2`.
+    /// Implicit delimiters may not survive roundtrip of a token stream through
+    /// a string.
+    None,
+}
+
+impl Group {
+    fn _new(inner: imp::Group) -> Self {
+        Group { inner }
+    }
+
+    fn _new_fallback(inner: fallback::Group) -> Self {
+        Group {
+            inner: inner.into(),
+        }
+    }
+
+    /// Creates a new `Group` with the given delimiter and token stream.
+    ///
+    /// This constructor will set the span for this group to
+    /// `Span::call_site()`. To change the span you can use the `set_span`
+    /// method below.
+    pub fn new(delimiter: Delimiter, stream: TokenStream) -> Self {
+        Group {
+            inner: imp::Group::new(delimiter, stream.inner),
+        }
+    }
+
+    /// Returns the punctuation used as the delimiter for this group: a set of
+    /// parentheses, square brackets, or curly braces.
+    pub fn delimiter(&self) -> Delimiter {
+        self.inner.delimiter()
+    }
+
+    /// Returns the `TokenStream` of tokens that are delimited in this `Group`.
+    ///
+    /// Note that the returned token stream does not include the delimiter
+    /// returned above.
+    pub fn stream(&self) -> TokenStream {
+        TokenStream::_new(self.inner.stream())
+    }
+
+    /// Returns the span for the delimiters of this token stream, spanning the
+    /// entire `Group`.
+    ///
+    /// ```text
+    /// pub fn span(&self) -> Span {
+    ///            ^^^^^^^
+    /// ```
+    pub fn span(&self) -> Span {
+        Span::_new(self.inner.span())
+    }
+
+    /// Returns the span pointing to the opening delimiter of this group.
+    ///
+    /// ```text
+    /// pub fn span_open(&self) -> Span {
+    ///                 ^
+    /// ```
+    pub fn span_open(&self) -> Span {
+        Span::_new(self.inner.span_open())
+    }
+
+    /// Returns the span pointing to the closing delimiter of this group.
+    ///
+    /// ```text
+    /// pub fn span_close(&self) -> Span {
+    ///                        ^
+    /// ```
+    pub fn span_close(&self) -> Span {
+        Span::_new(self.inner.span_close())
+    }
+
+    /// Returns an object that holds this group's `span_open()` and
+    /// `span_close()` together (in a more compact representation than holding
+    /// those 2 spans individually).
+    pub fn delim_span(&self) -> DelimSpan {
+        DelimSpan::new(&self.inner)
+    }
+
+    /// Configures the span for this `Group`'s delimiters, but not its internal
+    /// tokens.
+    ///
+    /// This method will **not** set the span of all the internal tokens spanned
+    /// by this group, but rather it will only set the span of the delimiter
+    /// tokens at the level of the `Group`.
+    pub fn set_span(&mut self, span: Span) {
+        self.inner.set_span(span.inner);
+    }
+}
+
+/// Prints the group as a string that should be losslessly convertible back
+/// into the same group (modulo spans), except for possibly `TokenTree::Group`s
+/// with `Delimiter::None` delimiters.
+impl Display for Group {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        Display::fmt(&self.inner, formatter)
+    }
+}
+
+impl Debug for Group {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        Debug::fmt(&self.inner, formatter)
+    }
+}
+
+/// A `Punct` is a single punctuation character like `+`, `-` or `#`.
+///
+/// Multicharacter operators like `+=` are represented as two instances of
+/// `Punct` with different forms of `Spacing` returned.
+#[derive(Clone)]
+pub struct Punct {
+    ch: char,
+    spacing: Spacing,
+    span: Span,
+}
+
+/// Whether a `Punct` is followed immediately by another `Punct` or followed by
+/// another token or whitespace.
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum Spacing {
+    /// E.g. `+` is `Alone` in `+ =`, `+ident` or `+()`.
+    Alone,
+    /// E.g. `+` is `Joint` in `+=` or `'` is `Joint` in `'#`.
+    ///
+    /// Additionally, single quote `'` can join with identifiers to form
+    /// lifetimes `'ident`.
+    Joint,
+}
+
+impl Punct {
+    /// Creates a new `Punct` from the given character and spacing.
+    ///
+    /// The `ch` argument must be a valid punctuation character permitted by the
+    /// language, otherwise the function will panic.
+    ///
+    /// The returned `Punct` will have the default span of `Span::call_site()`
+    /// which can be further configured with the `set_span` method below.
+    pub fn new(ch: char, spacing: Spacing) -> Self {
+        Punct {
+            ch,
+            spacing,
+            span: Span::call_site(),
+        }
+    }
+
+    /// Returns the value of this punctuation character as `char`.
+    pub fn as_char(&self) -> char {
+        self.ch
+    }
+
+    /// Returns the spacing of this punctuation character, indicating whether
+    /// it's immediately followed by another `Punct` in the token stream, so
+    /// they can potentially be combined into a multicharacter operator
+    /// (`Joint`), or it's followed by some other token or whitespace (`Alone`)
+    /// so the operator has certainly ended.
+    pub fn spacing(&self) -> Spacing {
+        self.spacing
+    }
+
+    /// Returns the span for this punctuation character.
+    pub fn span(&self) -> Span {
+        self.span
+    }
+
+    /// Configure the span for this punctuation character.
+    pub fn set_span(&mut self, span: Span) {
+        self.span = span;
+    }
+}
+
+/// Prints the punctuation character as a string that should be losslessly
+/// convertible back into the same character.
+impl Display for Punct {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        Display::fmt(&self.ch, f)
+    }
+}
+
+impl Debug for Punct {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        let mut debug = fmt.debug_struct("Punct");
+        debug.field("char", &self.ch);
+        debug.field("spacing", &self.spacing);
+        imp::debug_span_field_if_nontrivial(&mut debug, self.span.inner);
+        debug.finish()
+    }
+}
+
+/// A word of Rust code, which may be a keyword or legal variable name.
+///
+/// An identifier consists of at least one Unicode code point, the first of
+/// which has the XID_Start property and the rest of which have the XID_Continue
+/// property.
+///
+/// - The empty string is not an identifier. Use `Option<Ident>`.
+/// - A lifetime is not an identifier. Use `syn::Lifetime` instead.
+///
+/// An identifier constructed with `Ident::new` is permitted to be a Rust
+/// keyword, though parsing one through its [`Parse`] implementation rejects
+/// Rust keywords. Use `input.call(Ident::parse_any)` when parsing to match the
+/// behaviour of `Ident::new`.
+///
+/// [`Parse`]: https://docs.rs/syn/2.0/syn/parse/trait.Parse.html
+///
+/// # Examples
+///
+/// A new ident can be created from a string using the `Ident::new` function.
+/// A span must be provided explicitly which governs the name resolution
+/// behavior of the resulting identifier.
+///
+/// ```
+/// use proc_macro2::{Ident, Span};
+///
+/// fn main() {
+///     let call_ident = Ident::new("calligraphy", Span::call_site());
+///
+///     println!("{}", call_ident);
+/// }
+/// ```
+///
+/// An ident can be interpolated into a token stream using the `quote!` macro.
+///
+/// ```
+/// use proc_macro2::{Ident, Span};
+/// use quote::quote;
+///
+/// fn main() {
+///     let ident = Ident::new("demo", Span::call_site());
+///
+///     // Create a variable binding whose name is this ident.
+///     let expanded = quote! { let #ident = 10; };
+///
+///     // Create a variable binding with a slightly different name.
+///     let temp_ident = Ident::new(&format!("new_{}", ident), Span::call_site());
+///     let expanded = quote! { let #temp_ident = 10; };
+/// }
+/// ```
+///
+/// A string representation of the ident is available through the `to_string()`
+/// method.
+///
+/// ```
+/// # use proc_macro2::{Ident, Span};
+/// #
+/// # let ident = Ident::new("another_identifier", Span::call_site());
+/// #
+/// // Examine the ident as a string.
+/// let ident_string = ident.to_string();
+/// if ident_string.len() > 60 {
+///     println!("Very long identifier: {}", ident_string)
+/// }
+/// ```
+#[derive(Clone)]
+pub struct Ident {
+    inner: imp::Ident,
+    _marker: Marker,
+}
+
+impl Ident {
+    fn _new(inner: imp::Ident) -> Self {
+        Ident {
+            inner,
+            _marker: Marker,
+        }
+    }
+
+    /// Creates a new `Ident` with the given `string` as well as the specified
+    /// `span`.
+    ///
+    /// The `string` argument must be a valid identifier permitted by the
+    /// language, otherwise the function will panic.
+    ///
+    /// Note that `span`, currently in rustc, configures the hygiene information
+    /// for this identifier.
+    ///
+    /// As of this time `Span::call_site()` explicitly opts-in to "call-site"
+    /// hygiene meaning that identifiers created with this span will be resolved
+    /// as if they were written directly at the location of the macro call, and
+    /// other code at the macro call site will be able to refer to them as well.
+    ///
+    /// Later spans like `Span::def_site()` will allow to opt-in to
+    /// "definition-site" hygiene meaning that identifiers created with this
+    /// span will be resolved at the location of the macro definition and other
+    /// code at the macro call site will not be able to refer to them.
+    ///
+    /// Due to the current importance of hygiene this constructor, unlike other
+    /// tokens, requires a `Span` to be specified at construction.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the input string is neither a keyword nor a legal variable
+    /// name. If you are not sure whether the string contains an identifier and
+    /// need to handle an error case, use
+    /// <a href="https://docs.rs/syn/2.0/syn/fn.parse_str.html"><code
+    ///   style="padding-right:0;">syn::parse_str</code></a><code
+    ///   style="padding-left:0;">::&lt;Ident&gt;</code>
+    /// rather than `Ident::new`.
+    pub fn new(string: &str, span: Span) -> Self {
+        Ident::_new(imp::Ident::new(string, span.inner))
+    }
+
+    /// Same as `Ident::new`, but creates a raw identifier (`r#ident`). The
+    /// `string` argument must be a valid identifier permitted by the language
+    /// (including keywords, e.g. `fn`). Keywords which are usable in path
+    /// segments (e.g. `self`, `super`) are not supported, and will cause a
+    /// panic.
+    pub fn new_raw(string: &str, span: Span) -> Self {
+        Ident::_new_raw(string, span)
+    }
+
+    fn _new_raw(string: &str, span: Span) -> Self {
+        Ident::_new(imp::Ident::new_raw(string, span.inner))
+    }
+
+    /// Returns the span of this `Ident`.
+    pub fn span(&self) -> Span {
+        Span::_new(self.inner.span())
+    }
+
+    /// Configures the span of this `Ident`, possibly changing its hygiene
+    /// context.
+    pub fn set_span(&mut self, span: Span) {
+        self.inner.set_span(span.inner);
+    }
+}
+
+impl PartialEq for Ident {
+    fn eq(&self, other: &Ident) -> bool {
+        self.inner == other.inner
+    }
+}
+
+impl<T> PartialEq<T> for Ident
+where
+    T: ?Sized + AsRef<str>,
+{
+    fn eq(&self, other: &T) -> bool {
+        self.inner == other
+    }
+}
+
+impl Eq for Ident {}
+
+impl PartialOrd for Ident {
+    fn partial_cmp(&self, other: &Ident) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for Ident {
+    fn cmp(&self, other: &Ident) -> Ordering {
+        self.to_string().cmp(&other.to_string())
+    }
+}
+
+impl Hash for Ident {
+    fn hash<H: Hasher>(&self, hasher: &mut H) {
+        self.to_string().hash(hasher);
+    }
+}
+
+/// Prints the identifier as a string that should be losslessly convertible back
+/// into the same identifier.
+impl Display for Ident {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        Display::fmt(&self.inner, f)
+    }
+}
+
+impl Debug for Ident {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        Debug::fmt(&self.inner, f)
+    }
+}
+
+/// A literal string (`"hello"`), byte string (`b"hello"`), character (`'a'`),
+/// byte character (`b'a'`), an integer or floating point number with or without
+/// a suffix (`1`, `1u8`, `2.3`, `2.3f32`).
+///
+/// Boolean literals like `true` and `false` do not belong here, they are
+/// `Ident`s.
+#[derive(Clone)]
+pub struct Literal {
+    inner: imp::Literal,
+    _marker: Marker,
+}
+
+macro_rules! suffixed_int_literals {
+    ($($name:ident => $kind:ident,)*) => ($(
+        /// Creates a new suffixed integer literal with the specified value.
+        ///
+        /// This function will create an integer like `1u32` where the integer
+        /// value specified is the first part of the token and the integral is
+        /// also suffixed at the end. Literals created from negative numbers may
+        /// not survive roundtrips through `TokenStream` or strings and may be
+        /// broken into two tokens (`-` and positive literal).
+        ///
+        /// Literals created through this method have the `Span::call_site()`
+        /// span by default, which can be configured with the `set_span` method
+        /// below.
+        pub fn $name(n: $kind) -> Literal {
+            Literal::_new(imp::Literal::$name(n))
+        }
+    )*)
+}
+
+macro_rules! unsuffixed_int_literals {
+    ($($name:ident => $kind:ident,)*) => ($(
+        /// Creates a new unsuffixed integer literal with the specified value.
+        ///
+        /// This function will create an integer like `1` where the integer
+        /// value specified is the first part of the token. No suffix is
+        /// specified on this token, meaning that invocations like
+        /// `Literal::i8_unsuffixed(1)` are equivalent to
+        /// `Literal::u32_unsuffixed(1)`. Literals created from negative numbers
+        /// may not survive roundtrips through `TokenStream` or strings and may
+        /// be broken into two tokens (`-` and positive literal).
+        ///
+        /// Literals created through this method have the `Span::call_site()`
+        /// span by default, which can be configured with the `set_span` method
+        /// below.
+        pub fn $name(n: $kind) -> Literal {
+            Literal::_new(imp::Literal::$name(n))
+        }
+    )*)
+}
+
+impl Literal {
+    fn _new(inner: imp::Literal) -> Self {
+        Literal {
+            inner,
+            _marker: Marker,
+        }
+    }
+
+    fn _new_fallback(inner: fallback::Literal) -> Self {
+        Literal {
+            inner: inner.into(),
+            _marker: Marker,
+        }
+    }
+
+    suffixed_int_literals! {
+        u8_suffixed => u8,
+        u16_suffixed => u16,
+        u32_suffixed => u32,
+        u64_suffixed => u64,
+        u128_suffixed => u128,
+        usize_suffixed => usize,
+        i8_suffixed => i8,
+        i16_suffixed => i16,
+        i32_suffixed => i32,
+        i64_suffixed => i64,
+        i128_suffixed => i128,
+        isize_suffixed => isize,
+    }
+
+    unsuffixed_int_literals! {
+        u8_unsuffixed => u8,
+        u16_unsuffixed => u16,
+        u32_unsuffixed => u32,
+        u64_unsuffixed => u64,
+        u128_unsuffixed => u128,
+        usize_unsuffixed => usize,
+        i8_unsuffixed => i8,
+        i16_unsuffixed => i16,
+        i32_unsuffixed => i32,
+        i64_unsuffixed => i64,
+        i128_unsuffixed => i128,
+        isize_unsuffixed => isize,
+    }
+
+    /// Creates a new unsuffixed floating-point literal.
+    ///
+    /// This constructor is similar to those like `Literal::i8_unsuffixed` where
+    /// the float's value is emitted directly into the token but no suffix is
+    /// used, so it may be inferred to be a `f64` later in the compiler.
+    /// Literals created from negative numbers may not survive round-trips
+    /// through `TokenStream` or strings and may be broken into two tokens (`-`
+    /// and positive literal).
+    ///
+    /// # Panics
+    ///
+    /// This function requires that the specified float is finite, for example
+    /// if it is infinity or NaN this function will panic.
+    pub fn f64_unsuffixed(f: f64) -> Literal {
+        assert!(f.is_finite());
+        Literal::_new(imp::Literal::f64_unsuffixed(f))
+    }
+
+    /// Creates a new suffixed floating-point literal.
+    ///
+    /// This constructor will create a literal like `1.0f64` where the value
+    /// specified is the preceding part of the token and `f64` is the suffix of
+    /// the token. This token will always be inferred to be an `f64` in the
+    /// compiler. Literals created from negative numbers may not survive
+    /// round-trips through `TokenStream` or strings and may be broken into two
+    /// tokens (`-` and positive literal).
+    ///
+    /// # Panics
+    ///
+    /// This function requires that the specified float is finite, for example
+    /// if it is infinity or NaN this function will panic.
+    pub fn f64_suffixed(f: f64) -> Literal {
+        assert!(f.is_finite());
+        Literal::_new(imp::Literal::f64_suffixed(f))
+    }
+
+    /// Creates a new unsuffixed floating-point literal.
+    ///
+    /// This constructor is similar to those like `Literal::i8_unsuffixed` where
+    /// the float's value is emitted directly into the token but no suffix is
+    /// used, so it may be inferred to be a `f64` later in the compiler.
+    /// Literals created from negative numbers may not survive round-trips
+    /// through `TokenStream` or strings and may be broken into two tokens (`-`
+    /// and positive literal).
+    ///
+    /// # Panics
+    ///
+    /// This function requires that the specified float is finite, for example
+    /// if it is infinity or NaN this function will panic.
+    pub fn f32_unsuffixed(f: f32) -> Literal {
+        assert!(f.is_finite());
+        Literal::_new(imp::Literal::f32_unsuffixed(f))
+    }
+
+    /// Creates a new suffixed floating-point literal.
+    ///
+    /// This constructor will create a literal like `1.0f32` where the value
+    /// specified is the preceding part of the token and `f32` is the suffix of
+    /// the token. This token will always be inferred to be an `f32` in the
+    /// compiler. Literals created from negative numbers may not survive
+    /// round-trips through `TokenStream` or strings and may be broken into two
+    /// tokens (`-` and positive literal).
+    ///
+    /// # Panics
+    ///
+    /// This function requires that the specified float is finite, for example
+    /// if it is infinity or NaN this function will panic.
+    pub fn f32_suffixed(f: f32) -> Literal {
+        assert!(f.is_finite());
+        Literal::_new(imp::Literal::f32_suffixed(f))
+    }
+
+    /// String literal.
+    pub fn string(string: &str) -> Literal {
+        Literal::_new(imp::Literal::string(string))
+    }
+
+    /// Character literal.
+    pub fn character(ch: char) -> Literal {
+        Literal::_new(imp::Literal::character(ch))
+    }
+
+    /// Byte string literal.
+    pub fn byte_string(s: &[u8]) -> Literal {
+        Literal::_new(imp::Literal::byte_string(s))
+    }
+
+    /// Returns the span encompassing this literal.
+    pub fn span(&self) -> Span {
+        Span::_new(self.inner.span())
+    }
+
+    /// Configures the span associated for this literal.
+    pub fn set_span(&mut self, span: Span) {
+        self.inner.set_span(span.inner);
+    }
+
+    /// Returns a `Span` that is a subset of `self.span()` containing only
+    /// the source bytes in range `range`. Returns `None` if the would-be
+    /// trimmed span is outside the bounds of `self`.
+    ///
+    /// Warning: the underlying [`proc_macro::Literal::subspan`] method is
+    /// nightly-only. When called from within a procedural macro not using a
+    /// nightly compiler, this method will always return `None`.
+    ///
+    /// [`proc_macro::Literal::subspan`]: https://doc.rust-lang.org/proc_macro/struct.Literal.html#method.subspan
+    pub fn subspan<R: RangeBounds<usize>>(&self, range: R) -> Option<Span> {
+        self.inner.subspan(range).map(Span::_new)
+    }
+
+    // Intended for the `quote!` macro to use when constructing a proc-macro2
+    // token out of a macro_rules $:literal token, which is already known to be
+    // a valid literal. This avoids reparsing/validating the literal's string
+    // representation. This is not public API other than for quote.
+    #[doc(hidden)]
+    pub unsafe fn from_str_unchecked(repr: &str) -> Self {
+        Literal::_new(imp::Literal::from_str_unchecked(repr))
+    }
+}
+
+impl FromStr for Literal {
+    type Err = LexError;
+
+    fn from_str(repr: &str) -> Result<Self, LexError> {
+        repr.parse().map(Literal::_new).map_err(|inner| LexError {
+            inner,
+            _marker: Marker,
+        })
+    }
+}
+
+impl Debug for Literal {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        Debug::fmt(&self.inner, f)
+    }
+}
+
+impl Display for Literal {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        Display::fmt(&self.inner, f)
+    }
+}
+
+/// Public implementation details for the `TokenStream` type, such as iterators.
+pub mod token_stream {
+    use crate::marker::Marker;
+    use crate::{imp, TokenTree};
+    use core::fmt::{self, Debug};
+
+    pub use crate::TokenStream;
+
+    /// An iterator over `TokenStream`'s `TokenTree`s.
+    ///
+    /// The iteration is "shallow", e.g. the iterator doesn't recurse into
+    /// delimited groups, and returns whole groups as token trees.
+    #[derive(Clone)]
+    pub struct IntoIter {
+        inner: imp::TokenTreeIter,
+        _marker: Marker,
+    }
+
+    impl Iterator for IntoIter {
+        type Item = TokenTree;
+
+        fn next(&mut self) -> Option<TokenTree> {
+            self.inner.next()
+        }
+
+        fn size_hint(&self) -> (usize, Option<usize>) {
+            self.inner.size_hint()
+        }
+    }
+
+    impl Debug for IntoIter {
+        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+            f.write_str("TokenStream ")?;
+            f.debug_list().entries(self.clone()).finish()
+        }
+    }
+
+    impl IntoIterator for TokenStream {
+        type Item = TokenTree;
+        type IntoIter = IntoIter;
+
+        fn into_iter(self) -> IntoIter {
+            IntoIter {
+                inner: self.inner.into_iter(),
+                _marker: Marker,
+            }
+        }
+    }
+}
diff --git a/crates/proc-macro2/src/location.rs b/crates/proc-macro2/src/location.rs
new file mode 100644
index 0000000..463026c
--- /dev/null
+++ b/crates/proc-macro2/src/location.rs
@@ -0,0 +1,29 @@
+use core::cmp::Ordering;
+
+/// A line-column pair representing the start or end of a `Span`.
+///
+/// This type is semver exempt and not exposed by default.
+#[cfg_attr(doc_cfg, doc(cfg(feature = "span-locations")))]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub struct LineColumn {
+    /// The 1-indexed line in the source file on which the span starts or ends
+    /// (inclusive).
+    pub line: usize,
+    /// The 0-indexed column (in UTF-8 characters) in the source file on which
+    /// the span starts or ends (inclusive).
+    pub column: usize,
+}
+
+impl Ord for LineColumn {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.line
+            .cmp(&other.line)
+            .then(self.column.cmp(&other.column))
+    }
+}
+
+impl PartialOrd for LineColumn {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
diff --git a/crates/proc-macro2/src/marker.rs b/crates/proc-macro2/src/marker.rs
new file mode 100644
index 0000000..e648dd2
--- /dev/null
+++ b/crates/proc-macro2/src/marker.rs
@@ -0,0 +1,18 @@
+use alloc::rc::Rc;
+use core::marker::PhantomData;
+use core::panic::{RefUnwindSafe, UnwindSafe};
+
+// Zero sized marker with the correct set of autotrait impls we want all proc
+// macro types to have.
+pub(crate) type Marker = PhantomData<ProcMacroAutoTraits>;
+
+pub(crate) use self::value::*;
+
+mod value {
+    pub(crate) use core::marker::PhantomData as Marker;
+}
+
+pub(crate) struct ProcMacroAutoTraits(Rc<()>);
+
+impl UnwindSafe for ProcMacroAutoTraits {}
+impl RefUnwindSafe for ProcMacroAutoTraits {}
diff --git a/crates/proc-macro2/src/parse.rs b/crates/proc-macro2/src/parse.rs
new file mode 100644
index 0000000..1430d73
--- /dev/null
+++ b/crates/proc-macro2/src/parse.rs
@@ -0,0 +1,989 @@
+use crate::fallback::{
+    is_ident_continue, is_ident_start, Group, LexError, Literal, Span, TokenStream,
+    TokenStreamBuilder,
+};
+use crate::{Delimiter, Punct, Spacing, TokenTree};
+use core::char;
+use core::str::{Bytes, CharIndices, Chars};
+
+#[derive(Copy, Clone, Eq, PartialEq)]
+pub(crate) struct Cursor<'a> {
+    pub rest: &'a str,
+    #[cfg(span_locations)]
+    pub off: u32,
+}
+
+impl<'a> Cursor<'a> {
+    pub fn advance(&self, bytes: usize) -> Cursor<'a> {
+        let (_front, rest) = self.rest.split_at(bytes);
+        Cursor {
+            rest,
+            #[cfg(span_locations)]
+            off: self.off + _front.chars().count() as u32,
+        }
+    }
+
+    pub fn starts_with(&self, s: &str) -> bool {
+        self.rest.starts_with(s)
+    }
+
+    pub fn starts_with_char(&self, ch: char) -> bool {
+        self.rest.starts_with(ch)
+    }
+
+    pub fn starts_with_fn<Pattern>(&self, f: Pattern) -> bool
+    where
+        Pattern: FnMut(char) -> bool,
+    {
+        self.rest.starts_with(f)
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.rest.is_empty()
+    }
+
+    fn len(&self) -> usize {
+        self.rest.len()
+    }
+
+    fn as_bytes(&self) -> &'a [u8] {
+        self.rest.as_bytes()
+    }
+
+    fn bytes(&self) -> Bytes<'a> {
+        self.rest.bytes()
+    }
+
+    fn chars(&self) -> Chars<'a> {
+        self.rest.chars()
+    }
+
+    fn char_indices(&self) -> CharIndices<'a> {
+        self.rest.char_indices()
+    }
+
+    fn parse(&self, tag: &str) -> Result<Cursor<'a>, Reject> {
+        if self.starts_with(tag) {
+            Ok(self.advance(tag.len()))
+        } else {
+            Err(Reject)
+        }
+    }
+}
+
+pub(crate) struct Reject;
+type PResult<'a, O> = Result<(Cursor<'a>, O), Reject>;
+
+fn skip_whitespace(input: Cursor) -> Cursor {
+    let mut s = input;
+
+    while !s.is_empty() {
+        let byte = s.as_bytes()[0];
+        if byte == b'/' {
+            if s.starts_with("//")
+                && (!s.starts_with("///") || s.starts_with("////"))
+                && !s.starts_with("//!")
+            {
+                let (cursor, _) = take_until_newline_or_eof(s);
+                s = cursor;
+                continue;
+            } else if s.starts_with("/**/") {
+                s = s.advance(4);
+                continue;
+            } else if s.starts_with("/*")
+                && (!s.starts_with("/**") || s.starts_with("/***"))
+                && !s.starts_with("/*!")
+            {
+                match block_comment(s) {
+                    Ok((rest, _)) => {
+                        s = rest;
+                        continue;
+                    }
+                    Err(Reject) => return s,
+                }
+            }
+        }
+        match byte {
+            b' ' | 0x09..=0x0d => {
+                s = s.advance(1);
+                continue;
+            }
+            b if b.is_ascii() => {}
+            _ => {
+                let ch = s.chars().next().unwrap();
+                if is_whitespace(ch) {
+                    s = s.advance(ch.len_utf8());
+                    continue;
+                }
+            }
+        }
+        return s;
+    }
+    s
+}
+
+fn block_comment(input: Cursor) -> PResult<&str> {
+    if !input.starts_with("/*") {
+        return Err(Reject);
+    }
+
+    let mut depth = 0usize;
+    let bytes = input.as_bytes();
+    let mut i = 0usize;
+    let upper = bytes.len() - 1;
+
+    while i < upper {
+        if bytes[i] == b'/' && bytes[i + 1] == b'*' {
+            depth += 1;
+            i += 1; // eat '*'
+        } else if bytes[i] == b'*' && bytes[i + 1] == b'/' {
+            depth -= 1;
+            if depth == 0 {
+                return Ok((input.advance(i + 2), &input.rest[..i + 2]));
+            }
+            i += 1; // eat '/'
+        }
+        i += 1;
+    }
+
+    Err(Reject)
+}
+
+fn is_whitespace(ch: char) -> bool {
+    // Rust treats left-to-right mark and right-to-left mark as whitespace
+    ch.is_whitespace() || ch == '\u{200e}' || ch == '\u{200f}'
+}
+
+fn word_break(input: Cursor) -> Result<Cursor, Reject> {
+    match input.chars().next() {
+        Some(ch) if is_ident_continue(ch) => Err(Reject),
+        Some(_) | None => Ok(input),
+    }
+}
+
+// Rustc's representation of a macro expansion error in expression position or
+// type position.
+const ERROR: &str = "(/*ERROR*/)";
+
+pub(crate) fn token_stream(mut input: Cursor) -> Result<TokenStream, LexError> {
+    let mut trees = TokenStreamBuilder::new();
+    let mut stack = Vec::new();
+
+    loop {
+        input = skip_whitespace(input);
+
+        if let Ok((rest, ())) = doc_comment(input, &mut trees) {
+            input = rest;
+            continue;
+        }
+
+        #[cfg(span_locations)]
+        let lo = input.off;
+
+        let first = match input.bytes().next() {
+            Some(first) => first,
+            None => match stack.last() {
+                None => return Ok(trees.build()),
+                #[cfg(span_locations)]
+                Some((lo, _frame)) => {
+                    return Err(LexError {
+                        span: Span { lo: *lo, hi: *lo },
+                    })
+                }
+                #[cfg(not(span_locations))]
+                Some(_frame) => return Err(LexError { span: Span {} }),
+            },
+        };
+
+        if let Some(open_delimiter) = match first {
+            b'(' if !input.starts_with(ERROR) => Some(Delimiter::Parenthesis),
+            b'[' => Some(Delimiter::Bracket),
+            b'{' => Some(Delimiter::Brace),
+            _ => None,
+        } {
+            input = input.advance(1);
+            let frame = (open_delimiter, trees);
+            #[cfg(span_locations)]
+            let frame = (lo, frame);
+            stack.push(frame);
+            trees = TokenStreamBuilder::new();
+        } else if let Some(close_delimiter) = match first {
+            b')' => Some(Delimiter::Parenthesis),
+            b']' => Some(Delimiter::Bracket),
+            b'}' => Some(Delimiter::Brace),
+            _ => None,
+        } {
+            let frame = match stack.pop() {
+                Some(frame) => frame,
+                None => return Err(lex_error(input)),
+            };
+            #[cfg(span_locations)]
+            let (lo, frame) = frame;
+            let (open_delimiter, outer) = frame;
+            if open_delimiter != close_delimiter {
+                return Err(lex_error(input));
+            }
+            input = input.advance(1);
+            let mut g = Group::new(open_delimiter, trees.build());
+            g.set_span(Span {
+                #[cfg(span_locations)]
+                lo,
+                #[cfg(span_locations)]
+                hi: input.off,
+            });
+            trees = outer;
+            trees.push_token_from_parser(TokenTree::Group(crate::Group::_new_fallback(g)));
+        } else {
+            let (rest, mut tt) = match leaf_token(input) {
+                Ok((rest, tt)) => (rest, tt),
+                Err(Reject) => return Err(lex_error(input)),
+            };
+            tt.set_span(crate::Span::_new_fallback(Span {
+                #[cfg(span_locations)]
+                lo,
+                #[cfg(span_locations)]
+                hi: rest.off,
+            }));
+            trees.push_token_from_parser(tt);
+            input = rest;
+        }
+    }
+}
+
+fn lex_error(cursor: Cursor) -> LexError {
+    #[cfg(not(span_locations))]
+    let _ = cursor;
+    LexError {
+        span: Span {
+            #[cfg(span_locations)]
+            lo: cursor.off,
+            #[cfg(span_locations)]
+            hi: cursor.off,
+        },
+    }
+}
+
+fn leaf_token(input: Cursor) -> PResult<TokenTree> {
+    if let Ok((input, l)) = literal(input) {
+        // must be parsed before ident
+        Ok((input, TokenTree::Literal(crate::Literal::_new_fallback(l))))
+    } else if let Ok((input, p)) = punct(input) {
+        Ok((input, TokenTree::Punct(p)))
+    } else if let Ok((input, i)) = ident(input) {
+        Ok((input, TokenTree::Ident(i)))
+    } else if input.starts_with(ERROR) {
+        let rest = input.advance(ERROR.len());
+        let repr = crate::Literal::_new_fallback(Literal::_new(ERROR.to_owned()));
+        Ok((rest, TokenTree::Literal(repr)))
+    } else {
+        Err(Reject)
+    }
+}
+
+fn ident(input: Cursor) -> PResult<crate::Ident> {
+    if [
+        "r\"", "r#\"", "r##", "b\"", "b\'", "br\"", "br#", "c\"", "cr\"", "cr#",
+    ]
+    .iter()
+    .any(|prefix| input.starts_with(prefix))
+    {
+        Err(Reject)
+    } else {
+        ident_any(input)
+    }
+}
+
+fn ident_any(input: Cursor) -> PResult<crate::Ident> {
+    let raw = input.starts_with("r#");
+    let rest = input.advance((raw as usize) << 1);
+
+    let (rest, sym) = ident_not_raw(rest)?;
+
+    if !raw {
+        let ident = crate::Ident::new(sym, crate::Span::call_site());
+        return Ok((rest, ident));
+    }
+
+    match sym {
+        "_" | "super" | "self" | "Self" | "crate" => return Err(Reject),
+        _ => {}
+    }
+
+    let ident = crate::Ident::_new_raw(sym, crate::Span::call_site());
+    Ok((rest, ident))
+}
+
+fn ident_not_raw(input: Cursor) -> PResult<&str> {
+    let mut chars = input.char_indices();
+
+    match chars.next() {
+        Some((_, ch)) if is_ident_start(ch) => {}
+        _ => return Err(Reject),
+    }
+
+    let mut end = input.len();
+    for (i, ch) in chars {
+        if !is_ident_continue(ch) {
+            end = i;
+            break;
+        }
+    }
+
+    Ok((input.advance(end), &input.rest[..end]))
+}
+
+pub(crate) fn literal(input: Cursor) -> PResult<Literal> {
+    let rest = literal_nocapture(input)?;
+    let end = input.len() - rest.len();
+    Ok((rest, Literal::_new(input.rest[..end].to_string())))
+}
+
+fn literal_nocapture(input: Cursor) -> Result<Cursor, Reject> {
+    if let Ok(ok) = string(input) {
+        Ok(ok)
+    } else if let Ok(ok) = byte_string(input) {
+        Ok(ok)
+    } else if let Ok(ok) = c_string(input) {
+        Ok(ok)
+    } else if let Ok(ok) = byte(input) {
+        Ok(ok)
+    } else if let Ok(ok) = character(input) {
+        Ok(ok)
+    } else if let Ok(ok) = float(input) {
+        Ok(ok)
+    } else if let Ok(ok) = int(input) {
+        Ok(ok)
+    } else {
+        Err(Reject)
+    }
+}
+
+fn literal_suffix(input: Cursor) -> Cursor {
+    match ident_not_raw(input) {
+        Ok((input, _)) => input,
+        Err(Reject) => input,
+    }
+}
+
+fn string(input: Cursor) -> Result<Cursor, Reject> {
+    if let Ok(input) = input.parse("\"") {
+        cooked_string(input)
+    } else if let Ok(input) = input.parse("r") {
+        raw_string(input)
+    } else {
+        Err(Reject)
+    }
+}
+
+fn cooked_string(mut input: Cursor) -> Result<Cursor, Reject> {
+    let mut chars = input.char_indices();
+
+    while let Some((i, ch)) = chars.next() {
+        match ch {
+            '"' => {
+                let input = input.advance(i + 1);
+                return Ok(literal_suffix(input));
+            }
+            '\r' => match chars.next() {
+                Some((_, '\n')) => {}
+                _ => break,
+            },
+            '\\' => match chars.next() {
+                Some((_, 'x')) => {
+                    backslash_x_char(&mut chars)?;
+                }
+                Some((_, 'n' | 'r' | 't' | '\\' | '\'' | '"' | '0')) => {}
+                Some((_, 'u')) => {
+                    backslash_u(&mut chars)?;
+                }
+                Some((newline, ch @ ('\n' | '\r'))) => {
+                    input = input.advance(newline + 1);
+                    trailing_backslash(&mut input, ch as u8)?;
+                    chars = input.char_indices();
+                }
+                _ => break,
+            },
+            _ch => {}
+        }
+    }
+    Err(Reject)
+}
+
+fn raw_string(input: Cursor) -> Result<Cursor, Reject> {
+    let (input, delimiter) = delimiter_of_raw_string(input)?;
+    let mut bytes = input.bytes().enumerate();
+    while let Some((i, byte)) = bytes.next() {
+        match byte {
+            b'"' if input.rest[i + 1..].starts_with(delimiter) => {
+                let rest = input.advance(i + 1 + delimiter.len());
+                return Ok(literal_suffix(rest));
+            }
+            b'\r' => match bytes.next() {
+                Some((_, b'\n')) => {}
+                _ => break,
+            },
+            _ => {}
+        }
+    }
+    Err(Reject)
+}
+
+fn byte_string(input: Cursor) -> Result<Cursor, Reject> {
+    if let Ok(input) = input.parse("b\"") {
+        cooked_byte_string(input)
+    } else if let Ok(input) = input.parse("br") {
+        raw_byte_string(input)
+    } else {
+        Err(Reject)
+    }
+}
+
+fn cooked_byte_string(mut input: Cursor) -> Result<Cursor, Reject> {
+    let mut bytes = input.bytes().enumerate();
+    while let Some((offset, b)) = bytes.next() {
+        match b {
+            b'"' => {
+                let input = input.advance(offset + 1);
+                return Ok(literal_suffix(input));
+            }
+            b'\r' => match bytes.next() {
+                Some((_, b'\n')) => {}
+                _ => break,
+            },
+            b'\\' => match bytes.next() {
+                Some((_, b'x')) => {
+                    backslash_x_byte(&mut bytes)?;
+                }
+                Some((_, b'n' | b'r' | b't' | b'\\' | b'0' | b'\'' | b'"')) => {}
+                Some((newline, b @ (b'\n' | b'\r'))) => {
+                    input = input.advance(newline + 1);
+                    trailing_backslash(&mut input, b)?;
+                    bytes = input.bytes().enumerate();
+                }
+                _ => break,
+            },
+            b if b.is_ascii() => {}
+            _ => break,
+        }
+    }
+    Err(Reject)
+}
+
+fn delimiter_of_raw_string(input: Cursor) -> PResult<&str> {
+    for (i, byte) in input.bytes().enumerate() {
+        match byte {
+            b'"' => {
+                if i > 255 {
+                    // https://github.com/rust-lang/rust/pull/95251
+                    return Err(Reject);
+                }
+                return Ok((input.advance(i + 1), &input.rest[..i]));
+            }
+            b'#' => {}
+            _ => break,
+        }
+    }
+    Err(Reject)
+}
+
+fn raw_byte_string(input: Cursor) -> Result<Cursor, Reject> {
+    let (input, delimiter) = delimiter_of_raw_string(input)?;
+    let mut bytes = input.bytes().enumerate();
+    while let Some((i, byte)) = bytes.next() {
+        match byte {
+            b'"' if input.rest[i + 1..].starts_with(delimiter) => {
+                let rest = input.advance(i + 1 + delimiter.len());
+                return Ok(literal_suffix(rest));
+            }
+            b'\r' => match bytes.next() {
+                Some((_, b'\n')) => {}
+                _ => break,
+            },
+            other => {
+                if !other.is_ascii() {
+                    break;
+                }
+            }
+        }
+    }
+    Err(Reject)
+}
+
+fn c_string(input: Cursor) -> Result<Cursor, Reject> {
+    if let Ok(input) = input.parse("c\"") {
+        cooked_c_string(input)
+    } else if let Ok(input) = input.parse("cr") {
+        raw_c_string(input)
+    } else {
+        Err(Reject)
+    }
+}
+
+fn raw_c_string(input: Cursor) -> Result<Cursor, Reject> {
+    let (input, delimiter) = delimiter_of_raw_string(input)?;
+    let mut bytes = input.bytes().enumerate();
+    while let Some((i, byte)) = bytes.next() {
+        match byte {
+            b'"' if input.rest[i + 1..].starts_with(delimiter) => {
+                let rest = input.advance(i + 1 + delimiter.len());
+                return Ok(literal_suffix(rest));
+            }
+            b'\r' => match bytes.next() {
+                Some((_, b'\n')) => {}
+                _ => break,
+            },
+            b'\0' => break,
+            _ => {}
+        }
+    }
+    Err(Reject)
+}
+
+fn cooked_c_string(mut input: Cursor) -> Result<Cursor, Reject> {
+    let mut chars = input.char_indices();
+
+    while let Some((i, ch)) = chars.next() {
+        match ch {
+            '"' => {
+                let input = input.advance(i + 1);
+                return Ok(literal_suffix(input));
+            }
+            '\r' => match chars.next() {
+                Some((_, '\n')) => {}
+                _ => break,
+            },
+            '\\' => match chars.next() {
+                Some((_, 'x')) => {
+                    backslash_x_nonzero(&mut chars)?;
+                }
+                Some((_, 'n' | 'r' | 't' | '\\' | '\'' | '"')) => {}
+                Some((_, 'u')) => {
+                    if backslash_u(&mut chars)? == '\0' {
+                        break;
+                    }
+                }
+                Some((newline, ch @ ('\n' | '\r'))) => {
+                    input = input.advance(newline + 1);
+                    trailing_backslash(&mut input, ch as u8)?;
+                    chars = input.char_indices();
+                }
+                _ => break,
+            },
+            '\0' => break,
+            _ch => {}
+        }
+    }
+    Err(Reject)
+}
+
+fn byte(input: Cursor) -> Result<Cursor, Reject> {
+    let input = input.parse("b'")?;
+    let mut bytes = input.bytes().enumerate();
+    let ok = match bytes.next().map(|(_, b)| b) {
+        Some(b'\\') => match bytes.next().map(|(_, b)| b) {
+            Some(b'x') => backslash_x_byte(&mut bytes).is_ok(),
+            Some(b'n' | b'r' | b't' | b'\\' | b'0' | b'\'' | b'"') => true,
+            _ => false,
+        },
+        b => b.is_some(),
+    };
+    if !ok {
+        return Err(Reject);
+    }
+    let (offset, _) = bytes.next().ok_or(Reject)?;
+    if !input.chars().as_str().is_char_boundary(offset) {
+        return Err(Reject);
+    }
+    let input = input.advance(offset).parse("'")?;
+    Ok(literal_suffix(input))
+}
+
+fn character(input: Cursor) -> Result<Cursor, Reject> {
+    let input = input.parse("'")?;
+    let mut chars = input.char_indices();
+    let ok = match chars.next().map(|(_, ch)| ch) {
+        Some('\\') => match chars.next().map(|(_, ch)| ch) {
+            Some('x') => backslash_x_char(&mut chars).is_ok(),
+            Some('u') => backslash_u(&mut chars).is_ok(),
+            Some('n' | 'r' | 't' | '\\' | '0' | '\'' | '"') => true,
+            _ => false,
+        },
+        ch => ch.is_some(),
+    };
+    if !ok {
+        return Err(Reject);
+    }
+    let (idx, _) = chars.next().ok_or(Reject)?;
+    let input = input.advance(idx).parse("'")?;
+    Ok(literal_suffix(input))
+}
+
+macro_rules! next_ch {
+    ($chars:ident @ $pat:pat) => {
+        match $chars.next() {
+            Some((_, ch)) => match ch {
+                $pat => ch,
+                _ => return Err(Reject),
+            },
+            None => return Err(Reject),
+        }
+    };
+}
+
+fn backslash_x_char<I>(chars: &mut I) -> Result<(), Reject>
+where
+    I: Iterator<Item = (usize, char)>,
+{
+    next_ch!(chars @ '0'..='7');
+    next_ch!(chars @ '0'..='9' | 'a'..='f' | 'A'..='F');
+    Ok(())
+}
+
+fn backslash_x_byte<I>(chars: &mut I) -> Result<(), Reject>
+where
+    I: Iterator<Item = (usize, u8)>,
+{
+    next_ch!(chars @ b'0'..=b'9' | b'a'..=b'f' | b'A'..=b'F');
+    next_ch!(chars @ b'0'..=b'9' | b'a'..=b'f' | b'A'..=b'F');
+    Ok(())
+}
+
+fn backslash_x_nonzero<I>(chars: &mut I) -> Result<(), Reject>
+where
+    I: Iterator<Item = (usize, char)>,
+{
+    let first = next_ch!(chars @ '0'..='9' | 'a'..='f' | 'A'..='F');
+    let second = next_ch!(chars @ '0'..='9' | 'a'..='f' | 'A'..='F');
+    if first == '0' && second == '0' {
+        Err(Reject)
+    } else {
+        Ok(())
+    }
+}
+
+fn backslash_u<I>(chars: &mut I) -> Result<char, Reject>
+where
+    I: Iterator<Item = (usize, char)>,
+{
+    next_ch!(chars @ '{');
+    let mut value = 0;
+    let mut len = 0;
+    for (_, ch) in chars {
+        let digit = match ch {
+            '0'..='9' => ch as u8 - b'0',
+            'a'..='f' => 10 + ch as u8 - b'a',
+            'A'..='F' => 10 + ch as u8 - b'A',
+            '_' if len > 0 => continue,
+            '}' if len > 0 => return char::from_u32(value).ok_or(Reject),
+            _ => break,
+        };
+        if len == 6 {
+            break;
+        }
+        value *= 0x10;
+        value += u32::from(digit);
+        len += 1;
+    }
+    Err(Reject)
+}
+
+fn trailing_backslash(input: &mut Cursor, mut last: u8) -> Result<(), Reject> {
+    let mut whitespace = input.bytes().enumerate();
+    loop {
+        if last == b'\r' && whitespace.next().map_or(true, |(_, b)| b != b'\n') {
+            return Err(Reject);
+        }
+        match whitespace.next() {
+            Some((_, b @ (b' ' | b'\t' | b'\n' | b'\r'))) => {
+                last = b;
+            }
+            Some((offset, _)) => {
+                *input = input.advance(offset);
+                return Ok(());
+            }
+            None => return Err(Reject),
+        }
+    }
+}
+
+fn float(input: Cursor) -> Result<Cursor, Reject> {
+    let mut rest = float_digits(input)?;
+    if let Some(ch) = rest.chars().next() {
+        if is_ident_start(ch) {
+            rest = ident_not_raw(rest)?.0;
+        }
+    }
+    word_break(rest)
+}
+
+fn float_digits(input: Cursor) -> Result<Cursor, Reject> {
+    let mut chars = input.chars().peekable();
+    match chars.next() {
+        Some(ch) if '0' <= ch && ch <= '9' => {}
+        _ => return Err(Reject),
+    }
+
+    let mut len = 1;
+    let mut has_dot = false;
+    let mut has_exp = false;
+    while let Some(&ch) = chars.peek() {
+        match ch {
+            '0'..='9' | '_' => {
+                chars.next();
+                len += 1;
+            }
+            '.' => {
+                if has_dot {
+                    break;
+                }
+                chars.next();
+                if chars
+                    .peek()
+                    .map_or(false, |&ch| ch == '.' || is_ident_start(ch))
+                {
+                    return Err(Reject);
+                }
+                len += 1;
+                has_dot = true;
+            }
+            'e' | 'E' => {
+                chars.next();
+                len += 1;
+                has_exp = true;
+                break;
+            }
+            _ => break,
+        }
+    }
+
+    if !(has_dot || has_exp) {
+        return Err(Reject);
+    }
+
+    if has_exp {
+        let token_before_exp = if has_dot {
+            Ok(input.advance(len - 1))
+        } else {
+            Err(Reject)
+        };
+        let mut has_sign = false;
+        let mut has_exp_value = false;
+        while let Some(&ch) = chars.peek() {
+            match ch {
+                '+' | '-' => {
+                    if has_exp_value {
+                        break;
+                    }
+                    if has_sign {
+                        return token_before_exp;
+                    }
+                    chars.next();
+                    len += 1;
+                    has_sign = true;
+                }
+                '0'..='9' => {
+                    chars.next();
+                    len += 1;
+                    has_exp_value = true;
+                }
+                '_' => {
+                    chars.next();
+                    len += 1;
+                }
+                _ => break,
+            }
+        }
+        if !has_exp_value {
+            return token_before_exp;
+        }
+    }
+
+    Ok(input.advance(len))
+}
+
+fn int(input: Cursor) -> Result<Cursor, Reject> {
+    let mut rest = digits(input)?;
+    if let Some(ch) = rest.chars().next() {
+        if is_ident_start(ch) {
+            rest = ident_not_raw(rest)?.0;
+        }
+    }
+    word_break(rest)
+}
+
+fn digits(mut input: Cursor) -> Result<Cursor, Reject> {
+    let base = if input.starts_with("0x") {
+        input = input.advance(2);
+        16
+    } else if input.starts_with("0o") {
+        input = input.advance(2);
+        8
+    } else if input.starts_with("0b") {
+        input = input.advance(2);
+        2
+    } else {
+        10
+    };
+
+    let mut len = 0;
+    let mut empty = true;
+    for b in input.bytes() {
+        match b {
+            b'0'..=b'9' => {
+                let digit = (b - b'0') as u64;
+                if digit >= base {
+                    return Err(Reject);
+                }
+            }
+            b'a'..=b'f' => {
+                let digit = 10 + (b - b'a') as u64;
+                if digit >= base {
+                    break;
+                }
+            }
+            b'A'..=b'F' => {
+                let digit = 10 + (b - b'A') as u64;
+                if digit >= base {
+                    break;
+                }
+            }
+            b'_' => {
+                if empty && base == 10 {
+                    return Err(Reject);
+                }
+                len += 1;
+                continue;
+            }
+            _ => break,
+        };
+        len += 1;
+        empty = false;
+    }
+    if empty {
+        Err(Reject)
+    } else {
+        Ok(input.advance(len))
+    }
+}
+
+fn punct(input: Cursor) -> PResult<Punct> {
+    let (rest, ch) = punct_char(input)?;
+    if ch == '\'' {
+        if ident_any(rest)?.0.starts_with_char('\'') {
+            Err(Reject)
+        } else {
+            Ok((rest, Punct::new('\'', Spacing::Joint)))
+        }
+    } else {
+        let kind = match punct_char(rest) {
+            Ok(_) => Spacing::Joint,
+            Err(Reject) => Spacing::Alone,
+        };
+        Ok((rest, Punct::new(ch, kind)))
+    }
+}
+
+fn punct_char(input: Cursor) -> PResult<char> {
+    if input.starts_with("//") || input.starts_with("/*") {
+        // Do not accept `/` of a comment as a punct.
+        return Err(Reject);
+    }
+
+    let mut chars = input.chars();
+    let first = match chars.next() {
+        Some(ch) => ch,
+        None => {
+            return Err(Reject);
+        }
+    };
+    let recognized = "~!@#$%^&*-=+|;:,<.>/?'";
+    if recognized.contains(first) {
+        Ok((input.advance(first.len_utf8()), first))
+    } else {
+        Err(Reject)
+    }
+}
+
+fn doc_comment<'a>(input: Cursor<'a>, trees: &mut TokenStreamBuilder) -> PResult<'a, ()> {
+    #[cfg(span_locations)]
+    let lo = input.off;
+    let (rest, (comment, inner)) = doc_comment_contents(input)?;
+    let span = crate::Span::_new_fallback(Span {
+        #[cfg(span_locations)]
+        lo,
+        #[cfg(span_locations)]
+        hi: rest.off,
+    });
+
+    let mut scan_for_bare_cr = comment;
+    while let Some(cr) = scan_for_bare_cr.find('\r') {
+        let rest = &scan_for_bare_cr[cr + 1..];
+        if !rest.starts_with('\n') {
+            return Err(Reject);
+        }
+        scan_for_bare_cr = rest;
+    }
+
+    let mut pound = Punct::new('#', Spacing::Alone);
+    pound.set_span(span);
+    trees.push_token_from_parser(TokenTree::Punct(pound));
+
+    if inner {
+        let mut bang = Punct::new('!', Spacing::Alone);
+        bang.set_span(span);
+        trees.push_token_from_parser(TokenTree::Punct(bang));
+    }
+
+    let doc_ident = crate::Ident::new("doc", span);
+    let mut equal = Punct::new('=', Spacing::Alone);
+    equal.set_span(span);
+    let mut literal = crate::Literal::string(comment);
+    literal.set_span(span);
+    let mut bracketed = TokenStreamBuilder::with_capacity(3);
+    bracketed.push_token_from_parser(TokenTree::Ident(doc_ident));
+    bracketed.push_token_from_parser(TokenTree::Punct(equal));
+    bracketed.push_token_from_parser(TokenTree::Literal(literal));
+    let group = Group::new(Delimiter::Bracket, bracketed.build());
+    let mut group = crate::Group::_new_fallback(group);
+    group.set_span(span);
+    trees.push_token_from_parser(TokenTree::Group(group));
+
+    Ok((rest, ()))
+}
+
+fn doc_comment_contents(input: Cursor) -> PResult<(&str, bool)> {
+    if input.starts_with("//!") {
+        let input = input.advance(3);
+        let (input, s) = take_until_newline_or_eof(input);
+        Ok((input, (s, true)))
+    } else if input.starts_with("/*!") {
+        let (input, s) = block_comment(input)?;
+        Ok((input, (&s[3..s.len() - 2], true)))
+    } else if input.starts_with("///") {
+        let input = input.advance(3);
+        if input.starts_with_char('/') {
+            return Err(Reject);
+        }
+        let (input, s) = take_until_newline_or_eof(input);
+        Ok((input, (s, false)))
+    } else if input.starts_with("/**") && !input.rest[3..].starts_with('*') {
+        let (input, s) = block_comment(input)?;
+        Ok((input, (&s[3..s.len() - 2], false)))
+    } else {
+        Err(Reject)
+    }
+}
+
+fn take_until_newline_or_eof(input: Cursor) -> (Cursor, &str) {
+    let chars = input.char_indices();
+
+    for (i, ch) in chars {
+        if ch == '\n' {
+            return (input.advance(i), &input.rest[..i]);
+        } else if ch == '\r' && input.rest[i + 1..].starts_with('\n') {
+            return (input.advance(i + 1), &input.rest[..i]);
+        }
+    }
+
+    (input.advance(input.len()), input.rest)
+}
diff --git a/crates/proc-macro2/src/rcvec.rs b/crates/proc-macro2/src/rcvec.rs
new file mode 100644
index 0000000..37955af
--- /dev/null
+++ b/crates/proc-macro2/src/rcvec.rs
@@ -0,0 +1,145 @@
+use alloc::rc::Rc;
+use alloc::vec;
+use core::mem;
+use core::panic::RefUnwindSafe;
+use core::slice;
+
+pub(crate) struct RcVec<T> {
+    inner: Rc<Vec<T>>,
+}
+
+pub(crate) struct RcVecBuilder<T> {
+    inner: Vec<T>,
+}
+
+pub(crate) struct RcVecMut<'a, T> {
+    inner: &'a mut Vec<T>,
+}
+
+#[derive(Clone)]
+pub(crate) struct RcVecIntoIter<T> {
+    inner: vec::IntoIter<T>,
+}
+
+impl<T> RcVec<T> {
+    pub fn is_empty(&self) -> bool {
+        self.inner.is_empty()
+    }
+
+    pub fn len(&self) -> usize {
+        self.inner.len()
+    }
+
+    pub fn iter(&self) -> slice::Iter<T> {
+        self.inner.iter()
+    }
+
+    pub fn make_mut(&mut self) -> RcVecMut<T>
+    where
+        T: Clone,
+    {
+        RcVecMut {
+            inner: Rc::make_mut(&mut self.inner),
+        }
+    }
+
+    pub fn get_mut(&mut self) -> Option<RcVecMut<T>> {
+        let inner = Rc::get_mut(&mut self.inner)?;
+        Some(RcVecMut { inner })
+    }
+
+    pub fn make_owned(mut self) -> RcVecBuilder<T>
+    where
+        T: Clone,
+    {
+        let vec = if let Some(owned) = Rc::get_mut(&mut self.inner) {
+            mem::take(owned)
+        } else {
+            Vec::clone(&self.inner)
+        };
+        RcVecBuilder { inner: vec }
+    }
+}
+
+impl<T> RcVecBuilder<T> {
+    pub fn new() -> Self {
+        RcVecBuilder { inner: Vec::new() }
+    }
+
+    pub fn with_capacity(cap: usize) -> Self {
+        RcVecBuilder {
+            inner: Vec::with_capacity(cap),
+        }
+    }
+
+    pub fn push(&mut self, element: T) {
+        self.inner.push(element);
+    }
+
+    pub fn extend(&mut self, iter: impl IntoIterator<Item = T>) {
+        self.inner.extend(iter);
+    }
+
+    pub fn as_mut(&mut self) -> RcVecMut<T> {
+        RcVecMut {
+            inner: &mut self.inner,
+        }
+    }
+
+    pub fn build(self) -> RcVec<T> {
+        RcVec {
+            inner: Rc::new(self.inner),
+        }
+    }
+}
+
+impl<'a, T> RcVecMut<'a, T> {
+    pub fn push(&mut self, element: T) {
+        self.inner.push(element);
+    }
+
+    pub fn extend(&mut self, iter: impl IntoIterator<Item = T>) {
+        self.inner.extend(iter);
+    }
+
+    pub fn pop(&mut self) -> Option<T> {
+        self.inner.pop()
+    }
+
+    pub fn as_mut(&mut self) -> RcVecMut<T> {
+        RcVecMut { inner: self.inner }
+    }
+}
+
+impl<T> Clone for RcVec<T> {
+    fn clone(&self) -> Self {
+        RcVec {
+            inner: Rc::clone(&self.inner),
+        }
+    }
+}
+
+impl<T> IntoIterator for RcVecBuilder<T> {
+    type Item = T;
+    type IntoIter = RcVecIntoIter<T>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        RcVecIntoIter {
+            inner: self.inner.into_iter(),
+        }
+    }
+}
+
+impl<T> Iterator for RcVecIntoIter<T> {
+    type Item = T;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.inner.next()
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.inner.size_hint()
+    }
+}
+
+impl<T> RefUnwindSafe for RcVec<T> where T: RefUnwindSafe {}
diff --git a/crates/proc-macro2/src/wrapper.rs b/crates/proc-macro2/src/wrapper.rs
new file mode 100644
index 0000000..860b6b7
--- /dev/null
+++ b/crates/proc-macro2/src/wrapper.rs
@@ -0,0 +1,901 @@
+use crate::detection::inside_proc_macro;
+#[cfg(span_locations)]
+use crate::location::LineColumn;
+use crate::{fallback, Delimiter, Punct, Spacing, TokenTree};
+use core::fmt::{self, Debug, Display};
+use core::ops::RangeBounds;
+use core::str::FromStr;
+use std::panic;
+#[cfg(super_unstable)]
+use std::path::PathBuf;
+
+#[derive(Clone)]
+pub(crate) enum TokenStream {
+    Compiler(DeferredTokenStream),
+    Fallback(fallback::TokenStream),
+}
+
+// Work around https://github.com/rust-lang/rust/issues/65080.
+// In `impl Extend<TokenTree> for TokenStream` which is used heavily by quote,
+// we hold on to the appended tokens and do proc_macro::TokenStream::extend as
+// late as possible to batch together consecutive uses of the Extend impl.
+#[derive(Clone)]
+pub(crate) struct DeferredTokenStream {
+    stream: proc_macro::TokenStream,
+    extra: Vec<proc_macro::TokenTree>,
+}
+
+pub(crate) enum LexError {
+    Compiler(proc_macro::LexError),
+    Fallback(fallback::LexError),
+}
+
+impl LexError {
+    fn call_site() -> Self {
+        LexError::Fallback(fallback::LexError {
+            span: fallback::Span::call_site(),
+        })
+    }
+}
+
+fn mismatch() -> ! {
+    panic!("compiler/fallback mismatch")
+}
+
+impl DeferredTokenStream {
+    fn new(stream: proc_macro::TokenStream) -> Self {
+        DeferredTokenStream {
+            stream,
+            extra: Vec::new(),
+        }
+    }
+
+    fn is_empty(&self) -> bool {
+        self.stream.is_empty() && self.extra.is_empty()
+    }
+
+    fn evaluate_now(&mut self) {
+        // If-check provides a fast short circuit for the common case of `extra`
+        // being empty, which saves a round trip over the proc macro bridge.
+        // Improves macro expansion time in winrt by 6% in debug mode.
+        if !self.extra.is_empty() {
+            self.stream.extend(self.extra.drain(..));
+        }
+    }
+
+    fn into_token_stream(mut self) -> proc_macro::TokenStream {
+        self.evaluate_now();
+        self.stream
+    }
+}
+
+impl TokenStream {
+    pub fn new() -> Self {
+        if inside_proc_macro() {
+            TokenStream::Compiler(DeferredTokenStream::new(proc_macro::TokenStream::new()))
+        } else {
+            TokenStream::Fallback(fallback::TokenStream::new())
+        }
+    }
+
+    pub fn is_empty(&self) -> bool {
+        match self {
+            TokenStream::Compiler(tts) => tts.is_empty(),
+            TokenStream::Fallback(tts) => tts.is_empty(),
+        }
+    }
+
+    fn unwrap_nightly(self) -> proc_macro::TokenStream {
+        match self {
+            TokenStream::Compiler(s) => s.into_token_stream(),
+            TokenStream::Fallback(_) => mismatch(),
+        }
+    }
+
+    fn unwrap_stable(self) -> fallback::TokenStream {
+        match self {
+            TokenStream::Compiler(_) => mismatch(),
+            TokenStream::Fallback(s) => s,
+        }
+    }
+}
+
+impl FromStr for TokenStream {
+    type Err = LexError;
+
+    fn from_str(src: &str) -> Result<TokenStream, LexError> {
+        if inside_proc_macro() {
+            Ok(TokenStream::Compiler(DeferredTokenStream::new(
+                proc_macro_parse(src)?,
+            )))
+        } else {
+            Ok(TokenStream::Fallback(src.parse()?))
+        }
+    }
+}
+
+// Work around https://github.com/rust-lang/rust/issues/58736.
+fn proc_macro_parse(src: &str) -> Result<proc_macro::TokenStream, LexError> {
+    let result = panic::catch_unwind(|| src.parse().map_err(LexError::Compiler));
+    result.unwrap_or_else(|_| Err(LexError::call_site()))
+}
+
+impl Display for TokenStream {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            TokenStream::Compiler(tts) => Display::fmt(&tts.clone().into_token_stream(), f),
+            TokenStream::Fallback(tts) => Display::fmt(tts, f),
+        }
+    }
+}
+
+impl From<proc_macro::TokenStream> for TokenStream {
+    fn from(inner: proc_macro::TokenStream) -> Self {
+        TokenStream::Compiler(DeferredTokenStream::new(inner))
+    }
+}
+
+impl From<TokenStream> for proc_macro::TokenStream {
+    fn from(inner: TokenStream) -> Self {
+        match inner {
+            TokenStream::Compiler(inner) => inner.into_token_stream(),
+            TokenStream::Fallback(inner) => inner.to_string().parse().unwrap(),
+        }
+    }
+}
+
+impl From<fallback::TokenStream> for TokenStream {
+    fn from(inner: fallback::TokenStream) -> Self {
+        TokenStream::Fallback(inner)
+    }
+}
+
+// Assumes inside_proc_macro().
+fn into_compiler_token(token: TokenTree) -> proc_macro::TokenTree {
+    match token {
+        TokenTree::Group(tt) => tt.inner.unwrap_nightly().into(),
+        TokenTree::Punct(tt) => {
+            let spacing = match tt.spacing() {
+                Spacing::Joint => proc_macro::Spacing::Joint,
+                Spacing::Alone => proc_macro::Spacing::Alone,
+            };
+            let mut punct = proc_macro::Punct::new(tt.as_char(), spacing);
+            punct.set_span(tt.span().inner.unwrap_nightly());
+            punct.into()
+        }
+        TokenTree::Ident(tt) => tt.inner.unwrap_nightly().into(),
+        TokenTree::Literal(tt) => tt.inner.unwrap_nightly().into(),
+    }
+}
+
+impl From<TokenTree> for TokenStream {
+    fn from(token: TokenTree) -> Self {
+        if inside_proc_macro() {
+            TokenStream::Compiler(DeferredTokenStream::new(into_compiler_token(token).into()))
+        } else {
+            TokenStream::Fallback(token.into())
+        }
+    }
+}
+
+impl FromIterator<TokenTree> for TokenStream {
+    fn from_iter<I: IntoIterator<Item = TokenTree>>(trees: I) -> Self {
+        if inside_proc_macro() {
+            TokenStream::Compiler(DeferredTokenStream::new(
+                trees.into_iter().map(into_compiler_token).collect(),
+            ))
+        } else {
+            TokenStream::Fallback(trees.into_iter().collect())
+        }
+    }
+}
+
+impl FromIterator<TokenStream> for TokenStream {
+    fn from_iter<I: IntoIterator<Item = TokenStream>>(streams: I) -> Self {
+        let mut streams = streams.into_iter();
+        match streams.next() {
+            Some(TokenStream::Compiler(mut first)) => {
+                first.evaluate_now();
+                first.stream.extend(streams.map(|s| match s {
+                    TokenStream::Compiler(s) => s.into_token_stream(),
+                    TokenStream::Fallback(_) => mismatch(),
+                }));
+                TokenStream::Compiler(first)
+            }
+            Some(TokenStream::Fallback(mut first)) => {
+                first.extend(streams.map(|s| match s {
+                    TokenStream::Fallback(s) => s,
+                    TokenStream::Compiler(_) => mismatch(),
+                }));
+                TokenStream::Fallback(first)
+            }
+            None => TokenStream::new(),
+        }
+    }
+}
+
+impl Extend<TokenTree> for TokenStream {
+    fn extend<I: IntoIterator<Item = TokenTree>>(&mut self, stream: I) {
+        match self {
+            TokenStream::Compiler(tts) => {
+                // Here is the reason for DeferredTokenStream.
+                for token in stream {
+                    tts.extra.push(into_compiler_token(token));
+                }
+            }
+            TokenStream::Fallback(tts) => tts.extend(stream),
+        }
+    }
+}
+
+impl Extend<TokenStream> for TokenStream {
+    fn extend<I: IntoIterator<Item = TokenStream>>(&mut self, streams: I) {
+        match self {
+            TokenStream::Compiler(tts) => {
+                tts.evaluate_now();
+                tts.stream
+                    .extend(streams.into_iter().map(TokenStream::unwrap_nightly));
+            }
+            TokenStream::Fallback(tts) => {
+                tts.extend(streams.into_iter().map(TokenStream::unwrap_stable));
+            }
+        }
+    }
+}
+
+impl Debug for TokenStream {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            TokenStream::Compiler(tts) => Debug::fmt(&tts.clone().into_token_stream(), f),
+            TokenStream::Fallback(tts) => Debug::fmt(tts, f),
+        }
+    }
+}
+
+impl LexError {
+    pub(crate) fn span(&self) -> Span {
+        match self {
+            LexError::Compiler(_) => Span::call_site(),
+            LexError::Fallback(e) => Span::Fallback(e.span()),
+        }
+    }
+}
+
+impl From<proc_macro::LexError> for LexError {
+    fn from(e: proc_macro::LexError) -> Self {
+        LexError::Compiler(e)
+    }
+}
+
+impl From<fallback::LexError> for LexError {
+    fn from(e: fallback::LexError) -> Self {
+        LexError::Fallback(e)
+    }
+}
+
+impl Debug for LexError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            LexError::Compiler(e) => Debug::fmt(e, f),
+            LexError::Fallback(e) => Debug::fmt(e, f),
+        }
+    }
+}
+
+impl Display for LexError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            LexError::Compiler(e) => Display::fmt(e, f),
+            LexError::Fallback(e) => Display::fmt(e, f),
+        }
+    }
+}
+
+#[derive(Clone)]
+pub(crate) enum TokenTreeIter {
+    Compiler(proc_macro::token_stream::IntoIter),
+    Fallback(fallback::TokenTreeIter),
+}
+
+impl IntoIterator for TokenStream {
+    type Item = TokenTree;
+    type IntoIter = TokenTreeIter;
+
+    fn into_iter(self) -> TokenTreeIter {
+        match self {
+            TokenStream::Compiler(tts) => {
+                TokenTreeIter::Compiler(tts.into_token_stream().into_iter())
+            }
+            TokenStream::Fallback(tts) => TokenTreeIter::Fallback(tts.into_iter()),
+        }
+    }
+}
+
+impl Iterator for TokenTreeIter {
+    type Item = TokenTree;
+
+    fn next(&mut self) -> Option<TokenTree> {
+        let token = match self {
+            TokenTreeIter::Compiler(iter) => iter.next()?,
+            TokenTreeIter::Fallback(iter) => return iter.next(),
+        };
+        Some(match token {
+            proc_macro::TokenTree::Group(tt) => crate::Group::_new(Group::Compiler(tt)).into(),
+            proc_macro::TokenTree::Punct(tt) => {
+                let spacing = match tt.spacing() {
+                    proc_macro::Spacing::Joint => Spacing::Joint,
+                    proc_macro::Spacing::Alone => Spacing::Alone,
+                };
+                let mut o = Punct::new(tt.as_char(), spacing);
+                o.set_span(crate::Span::_new(Span::Compiler(tt.span())));
+                o.into()
+            }
+            proc_macro::TokenTree::Ident(s) => crate::Ident::_new(Ident::Compiler(s)).into(),
+            proc_macro::TokenTree::Literal(l) => crate::Literal::_new(Literal::Compiler(l)).into(),
+        })
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        match self {
+            TokenTreeIter::Compiler(tts) => tts.size_hint(),
+            TokenTreeIter::Fallback(tts) => tts.size_hint(),
+        }
+    }
+}
+
+#[derive(Clone, PartialEq, Eq)]
+#[cfg(super_unstable)]
+pub(crate) enum SourceFile {
+    Compiler(proc_macro::SourceFile),
+    Fallback(fallback::SourceFile),
+}
+
+#[cfg(super_unstable)]
+impl SourceFile {
+    fn nightly(sf: proc_macro::SourceFile) -> Self {
+        SourceFile::Compiler(sf)
+    }
+
+    /// Get the path to this source file as a string.
+    pub fn path(&self) -> PathBuf {
+        match self {
+            SourceFile::Compiler(a) => a.path(),
+            SourceFile::Fallback(a) => a.path(),
+        }
+    }
+
+    pub fn is_real(&self) -> bool {
+        match self {
+            SourceFile::Compiler(a) => a.is_real(),
+            SourceFile::Fallback(a) => a.is_real(),
+        }
+    }
+}
+
+#[cfg(super_unstable)]
+impl Debug for SourceFile {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            SourceFile::Compiler(a) => Debug::fmt(a, f),
+            SourceFile::Fallback(a) => Debug::fmt(a, f),
+        }
+    }
+}
+
+#[derive(Copy, Clone)]
+pub(crate) enum Span {
+    Compiler(proc_macro::Span),
+    Fallback(fallback::Span),
+}
+
+impl Span {
+    pub fn call_site() -> Self {
+        if inside_proc_macro() {
+            Span::Compiler(proc_macro::Span::call_site())
+        } else {
+            Span::Fallback(fallback::Span::call_site())
+        }
+    }
+
+    pub fn mixed_site() -> Self {
+        if inside_proc_macro() {
+            Span::Compiler(proc_macro::Span::mixed_site())
+        } else {
+            Span::Fallback(fallback::Span::mixed_site())
+        }
+    }
+
+    #[cfg(super_unstable)]
+    pub fn def_site() -> Self {
+        if inside_proc_macro() {
+            Span::Compiler(proc_macro::Span::def_site())
+        } else {
+            Span::Fallback(fallback::Span::def_site())
+        }
+    }
+
+    pub fn resolved_at(&self, other: Span) -> Span {
+        match (self, other) {
+            (Span::Compiler(a), Span::Compiler(b)) => Span::Compiler(a.resolved_at(b)),
+            (Span::Fallback(a), Span::Fallback(b)) => Span::Fallback(a.resolved_at(b)),
+            _ => mismatch(),
+        }
+    }
+
+    pub fn located_at(&self, other: Span) -> Span {
+        match (self, other) {
+            (Span::Compiler(a), Span::Compiler(b)) => Span::Compiler(a.located_at(b)),
+            (Span::Fallback(a), Span::Fallback(b)) => Span::Fallback(a.located_at(b)),
+            _ => mismatch(),
+        }
+    }
+
+    pub fn unwrap(self) -> proc_macro::Span {
+        match self {
+            Span::Compiler(s) => s,
+            Span::Fallback(_) => panic!("proc_macro::Span is only available in procedural macros"),
+        }
+    }
+
+    #[cfg(super_unstable)]
+    pub fn source_file(&self) -> SourceFile {
+        match self {
+            Span::Compiler(s) => SourceFile::nightly(s.source_file()),
+            Span::Fallback(s) => SourceFile::Fallback(s.source_file()),
+        }
+    }
+
+    #[cfg(span_locations)]
+    pub fn start(&self) -> LineColumn {
+        match self {
+            Span::Compiler(_) => LineColumn { line: 0, column: 0 },
+            Span::Fallback(s) => s.start(),
+        }
+    }
+
+    #[cfg(span_locations)]
+    pub fn end(&self) -> LineColumn {
+        match self {
+            Span::Compiler(_) => LineColumn { line: 0, column: 0 },
+            Span::Fallback(s) => s.end(),
+        }
+    }
+
+    pub fn join(&self, other: Span) -> Option<Span> {
+        let ret = match (self, other) {
+            #[cfg(proc_macro_span)]
+            (Span::Compiler(a), Span::Compiler(b)) => Span::Compiler(a.join(b)?),
+            (Span::Fallback(a), Span::Fallback(b)) => Span::Fallback(a.join(b)?),
+            _ => return None,
+        };
+        Some(ret)
+    }
+
+    #[cfg(super_unstable)]
+    pub fn eq(&self, other: &Span) -> bool {
+        match (self, other) {
+            (Span::Compiler(a), Span::Compiler(b)) => a.eq(b),
+            (Span::Fallback(a), Span::Fallback(b)) => a.eq(b),
+            _ => false,
+        }
+    }
+
+    pub fn source_text(&self) -> Option<String> {
+        match self {
+            #[cfg(not(no_source_text))]
+            Span::Compiler(s) => s.source_text(),
+            #[cfg(no_source_text)]
+            Span::Compiler(_) => None,
+            Span::Fallback(s) => s.source_text(),
+        }
+    }
+
+    fn unwrap_nightly(self) -> proc_macro::Span {
+        match self {
+            Span::Compiler(s) => s,
+            Span::Fallback(_) => mismatch(),
+        }
+    }
+}
+
+impl From<proc_macro::Span> for crate::Span {
+    fn from(proc_span: proc_macro::Span) -> Self {
+        crate::Span::_new(Span::Compiler(proc_span))
+    }
+}
+
+impl From<fallback::Span> for Span {
+    fn from(inner: fallback::Span) -> Self {
+        Span::Fallback(inner)
+    }
+}
+
+impl Debug for Span {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Span::Compiler(s) => Debug::fmt(s, f),
+            Span::Fallback(s) => Debug::fmt(s, f),
+        }
+    }
+}
+
+pub(crate) fn debug_span_field_if_nontrivial(debug: &mut fmt::DebugStruct, span: Span) {
+    match span {
+        Span::Compiler(s) => {
+            debug.field("span", &s);
+        }
+        Span::Fallback(s) => fallback::debug_span_field_if_nontrivial(debug, s),
+    }
+}
+
+#[derive(Clone)]
+pub(crate) enum Group {
+    Compiler(proc_macro::Group),
+    Fallback(fallback::Group),
+}
+
+impl Group {
+    pub fn new(delimiter: Delimiter, stream: TokenStream) -> Self {
+        match stream {
+            TokenStream::Compiler(tts) => {
+                let delimiter = match delimiter {
+                    Delimiter::Parenthesis => proc_macro::Delimiter::Parenthesis,
+                    Delimiter::Bracket => proc_macro::Delimiter::Bracket,
+                    Delimiter::Brace => proc_macro::Delimiter::Brace,
+                    Delimiter::None => proc_macro::Delimiter::None,
+                };
+                Group::Compiler(proc_macro::Group::new(delimiter, tts.into_token_stream()))
+            }
+            TokenStream::Fallback(stream) => {
+                Group::Fallback(fallback::Group::new(delimiter, stream))
+            }
+        }
+    }
+
+    pub fn delimiter(&self) -> Delimiter {
+        match self {
+            Group::Compiler(g) => match g.delimiter() {
+                proc_macro::Delimiter::Parenthesis => Delimiter::Parenthesis,
+                proc_macro::Delimiter::Bracket => Delimiter::Bracket,
+                proc_macro::Delimiter::Brace => Delimiter::Brace,
+                proc_macro::Delimiter::None => Delimiter::None,
+            },
+            Group::Fallback(g) => g.delimiter(),
+        }
+    }
+
+    pub fn stream(&self) -> TokenStream {
+        match self {
+            Group::Compiler(g) => TokenStream::Compiler(DeferredTokenStream::new(g.stream())),
+            Group::Fallback(g) => TokenStream::Fallback(g.stream()),
+        }
+    }
+
+    pub fn span(&self) -> Span {
+        match self {
+            Group::Compiler(g) => Span::Compiler(g.span()),
+            Group::Fallback(g) => Span::Fallback(g.span()),
+        }
+    }
+
+    pub fn span_open(&self) -> Span {
+        match self {
+            Group::Compiler(g) => Span::Compiler(g.span_open()),
+            Group::Fallback(g) => Span::Fallback(g.span_open()),
+        }
+    }
+
+    pub fn span_close(&self) -> Span {
+        match self {
+            Group::Compiler(g) => Span::Compiler(g.span_close()),
+            Group::Fallback(g) => Span::Fallback(g.span_close()),
+        }
+    }
+
+    pub fn set_span(&mut self, span: Span) {
+        match (self, span) {
+            (Group::Compiler(g), Span::Compiler(s)) => g.set_span(s),
+            (Group::Fallback(g), Span::Fallback(s)) => g.set_span(s),
+            _ => mismatch(),
+        }
+    }
+
+    fn unwrap_nightly(self) -> proc_macro::Group {
+        match self {
+            Group::Compiler(g) => g,
+            Group::Fallback(_) => mismatch(),
+        }
+    }
+}
+
+impl From<fallback::Group> for Group {
+    fn from(g: fallback::Group) -> Self {
+        Group::Fallback(g)
+    }
+}
+
+impl Display for Group {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Group::Compiler(group) => Display::fmt(group, formatter),
+            Group::Fallback(group) => Display::fmt(group, formatter),
+        }
+    }
+}
+
+impl Debug for Group {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Group::Compiler(group) => Debug::fmt(group, formatter),
+            Group::Fallback(group) => Debug::fmt(group, formatter),
+        }
+    }
+}
+
+#[derive(Clone)]
+pub(crate) enum Ident {
+    Compiler(proc_macro::Ident),
+    Fallback(fallback::Ident),
+}
+
+impl Ident {
+    pub fn new(string: &str, span: Span) -> Self {
+        match span {
+            Span::Compiler(s) => Ident::Compiler(proc_macro::Ident::new(string, s)),
+            Span::Fallback(s) => Ident::Fallback(fallback::Ident::new(string, s)),
+        }
+    }
+
+    pub fn new_raw(string: &str, span: Span) -> Self {
+        match span {
+            Span::Compiler(s) => Ident::Compiler(proc_macro::Ident::new_raw(string, s)),
+            Span::Fallback(s) => Ident::Fallback(fallback::Ident::new_raw(string, s)),
+        }
+    }
+
+    pub fn span(&self) -> Span {
+        match self {
+            Ident::Compiler(t) => Span::Compiler(t.span()),
+            Ident::Fallback(t) => Span::Fallback(t.span()),
+        }
+    }
+
+    pub fn set_span(&mut self, span: Span) {
+        match (self, span) {
+            (Ident::Compiler(t), Span::Compiler(s)) => t.set_span(s),
+            (Ident::Fallback(t), Span::Fallback(s)) => t.set_span(s),
+            _ => mismatch(),
+        }
+    }
+
+    fn unwrap_nightly(self) -> proc_macro::Ident {
+        match self {
+            Ident::Compiler(s) => s,
+            Ident::Fallback(_) => mismatch(),
+        }
+    }
+}
+
+impl PartialEq for Ident {
+    fn eq(&self, other: &Ident) -> bool {
+        match (self, other) {
+            (Ident::Compiler(t), Ident::Compiler(o)) => t.to_string() == o.to_string(),
+            (Ident::Fallback(t), Ident::Fallback(o)) => t == o,
+            _ => mismatch(),
+        }
+    }
+}
+
+impl<T> PartialEq<T> for Ident
+where
+    T: ?Sized + AsRef<str>,
+{
+    fn eq(&self, other: &T) -> bool {
+        let other = other.as_ref();
+        match self {
+            Ident::Compiler(t) => t.to_string() == other,
+            Ident::Fallback(t) => t == other,
+        }
+    }
+}
+
+impl Display for Ident {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Ident::Compiler(t) => Display::fmt(t, f),
+            Ident::Fallback(t) => Display::fmt(t, f),
+        }
+    }
+}
+
+impl Debug for Ident {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Ident::Compiler(t) => Debug::fmt(t, f),
+            Ident::Fallback(t) => Debug::fmt(t, f),
+        }
+    }
+}
+
+#[derive(Clone)]
+pub(crate) enum Literal {
+    Compiler(proc_macro::Literal),
+    Fallback(fallback::Literal),
+}
+
+macro_rules! suffixed_numbers {
+    ($($name:ident => $kind:ident,)*) => ($(
+        pub fn $name(n: $kind) -> Literal {
+            if inside_proc_macro() {
+                Literal::Compiler(proc_macro::Literal::$name(n))
+            } else {
+                Literal::Fallback(fallback::Literal::$name(n))
+            }
+        }
+    )*)
+}
+
+macro_rules! unsuffixed_integers {
+    ($($name:ident => $kind:ident,)*) => ($(
+        pub fn $name(n: $kind) -> Literal {
+            if inside_proc_macro() {
+                Literal::Compiler(proc_macro::Literal::$name(n))
+            } else {
+                Literal::Fallback(fallback::Literal::$name(n))
+            }
+        }
+    )*)
+}
+
+impl Literal {
+    pub unsafe fn from_str_unchecked(repr: &str) -> Self {
+        if inside_proc_macro() {
+            Literal::Compiler(proc_macro::Literal::from_str(repr).expect("invalid literal"))
+        } else {
+            Literal::Fallback(fallback::Literal::from_str_unchecked(repr))
+        }
+    }
+
+    suffixed_numbers! {
+        u8_suffixed => u8,
+        u16_suffixed => u16,
+        u32_suffixed => u32,
+        u64_suffixed => u64,
+        u128_suffixed => u128,
+        usize_suffixed => usize,
+        i8_suffixed => i8,
+        i16_suffixed => i16,
+        i32_suffixed => i32,
+        i64_suffixed => i64,
+        i128_suffixed => i128,
+        isize_suffixed => isize,
+
+        f32_suffixed => f32,
+        f64_suffixed => f64,
+    }
+
+    unsuffixed_integers! {
+        u8_unsuffixed => u8,
+        u16_unsuffixed => u16,
+        u32_unsuffixed => u32,
+        u64_unsuffixed => u64,
+        u128_unsuffixed => u128,
+        usize_unsuffixed => usize,
+        i8_unsuffixed => i8,
+        i16_unsuffixed => i16,
+        i32_unsuffixed => i32,
+        i64_unsuffixed => i64,
+        i128_unsuffixed => i128,
+        isize_unsuffixed => isize,
+    }
+
+    pub fn f32_unsuffixed(f: f32) -> Literal {
+        if inside_proc_macro() {
+            Literal::Compiler(proc_macro::Literal::f32_unsuffixed(f))
+        } else {
+            Literal::Fallback(fallback::Literal::f32_unsuffixed(f))
+        }
+    }
+
+    pub fn f64_unsuffixed(f: f64) -> Literal {
+        if inside_proc_macro() {
+            Literal::Compiler(proc_macro::Literal::f64_unsuffixed(f))
+        } else {
+            Literal::Fallback(fallback::Literal::f64_unsuffixed(f))
+        }
+    }
+
+    pub fn string(t: &str) -> Literal {
+        if inside_proc_macro() {
+            Literal::Compiler(proc_macro::Literal::string(t))
+        } else {
+            Literal::Fallback(fallback::Literal::string(t))
+        }
+    }
+
+    pub fn character(t: char) -> Literal {
+        if inside_proc_macro() {
+            Literal::Compiler(proc_macro::Literal::character(t))
+        } else {
+            Literal::Fallback(fallback::Literal::character(t))
+        }
+    }
+
+    pub fn byte_string(bytes: &[u8]) -> Literal {
+        if inside_proc_macro() {
+            Literal::Compiler(proc_macro::Literal::byte_string(bytes))
+        } else {
+            Literal::Fallback(fallback::Literal::byte_string(bytes))
+        }
+    }
+
+    pub fn span(&self) -> Span {
+        match self {
+            Literal::Compiler(lit) => Span::Compiler(lit.span()),
+            Literal::Fallback(lit) => Span::Fallback(lit.span()),
+        }
+    }
+
+    pub fn set_span(&mut self, span: Span) {
+        match (self, span) {
+            (Literal::Compiler(lit), Span::Compiler(s)) => lit.set_span(s),
+            (Literal::Fallback(lit), Span::Fallback(s)) => lit.set_span(s),
+            _ => mismatch(),
+        }
+    }
+
+    pub fn subspan<R: RangeBounds<usize>>(&self, range: R) -> Option<Span> {
+        match self {
+            #[cfg(proc_macro_span)]
+            Literal::Compiler(lit) => lit.subspan(range).map(Span::Compiler),
+            #[cfg(not(proc_macro_span))]
+            Literal::Compiler(_lit) => None,
+            Literal::Fallback(lit) => lit.subspan(range).map(Span::Fallback),
+        }
+    }
+
+    fn unwrap_nightly(self) -> proc_macro::Literal {
+        match self {
+            Literal::Compiler(s) => s,
+            Literal::Fallback(_) => mismatch(),
+        }
+    }
+}
+
+impl From<fallback::Literal> for Literal {
+    fn from(s: fallback::Literal) -> Self {
+        Literal::Fallback(s)
+    }
+}
+
+impl FromStr for Literal {
+    type Err = LexError;
+
+    fn from_str(repr: &str) -> Result<Self, Self::Err> {
+        if inside_proc_macro() {
+            let literal = proc_macro::Literal::from_str(repr)?;
+            Ok(Literal::Compiler(literal))
+        } else {
+            let literal = fallback::Literal::from_str(repr)?;
+            Ok(Literal::Fallback(literal))
+        }
+    }
+}
+
+impl Display for Literal {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Literal::Compiler(t) => Display::fmt(t, f),
+            Literal::Fallback(t) => Display::fmt(t, f),
+        }
+    }
+}
+
+impl Debug for Literal {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Literal::Compiler(t) => Debug::fmt(t, f),
+            Literal::Fallback(t) => Debug::fmt(t, f),
+        }
+    }
+}
diff --git a/crates/proc-macro2/tests/comments.rs b/crates/proc-macro2/tests/comments.rs
new file mode 100644
index 0000000..4f7236d
--- /dev/null
+++ b/crates/proc-macro2/tests/comments.rs
@@ -0,0 +1,105 @@
+#![allow(clippy::assertions_on_result_states)]
+
+use proc_macro2::{Delimiter, Literal, Spacing, TokenStream, TokenTree};
+
+// #[doc = "..."] -> "..."
+fn lit_of_outer_doc_comment(tokens: &TokenStream) -> Literal {
+    lit_of_doc_comment(tokens, false)
+}
+
+// #![doc = "..."] -> "..."
+fn lit_of_inner_doc_comment(tokens: &TokenStream) -> Literal {
+    lit_of_doc_comment(tokens, true)
+}
+
+fn lit_of_doc_comment(tokens: &TokenStream, inner: bool) -> Literal {
+    let mut iter = tokens.clone().into_iter();
+    match iter.next().unwrap() {
+        TokenTree::Punct(punct) => {
+            assert_eq!(punct.as_char(), '#');
+            assert_eq!(punct.spacing(), Spacing::Alone);
+        }
+        _ => panic!("wrong token {:?}", tokens),
+    }
+    if inner {
+        match iter.next().unwrap() {
+            TokenTree::Punct(punct) => {
+                assert_eq!(punct.as_char(), '!');
+                assert_eq!(punct.spacing(), Spacing::Alone);
+            }
+            _ => panic!("wrong token {:?}", tokens),
+        }
+    }
+    iter = match iter.next().unwrap() {
+        TokenTree::Group(group) => {
+            assert_eq!(group.delimiter(), Delimiter::Bracket);
+            assert!(iter.next().is_none(), "unexpected token {:?}", tokens);
+            group.stream().into_iter()
+        }
+        _ => panic!("wrong token {:?}", tokens),
+    };
+    match iter.next().unwrap() {
+        TokenTree::Ident(ident) => assert_eq!(ident.to_string(), "doc"),
+        _ => panic!("wrong token {:?}", tokens),
+    }
+    match iter.next().unwrap() {
+        TokenTree::Punct(punct) => {
+            assert_eq!(punct.as_char(), '=');
+            assert_eq!(punct.spacing(), Spacing::Alone);
+        }
+        _ => panic!("wrong token {:?}", tokens),
+    }
+    match iter.next().unwrap() {
+        TokenTree::Literal(literal) => {
+            assert!(iter.next().is_none(), "unexpected token {:?}", tokens);
+            literal
+        }
+        _ => panic!("wrong token {:?}", tokens),
+    }
+}
+
+#[test]
+fn closed_immediately() {
+    let stream = "/**/".parse::<TokenStream>().unwrap();
+    let tokens = stream.into_iter().collect::<Vec<_>>();
+    assert!(tokens.is_empty(), "not empty -- {:?}", tokens);
+}
+
+#[test]
+fn incomplete() {
+    assert!("/*/".parse::<TokenStream>().is_err());
+}
+
+#[test]
+fn lit() {
+    let stream = "/// doc".parse::<TokenStream>().unwrap();
+    let lit = lit_of_outer_doc_comment(&stream);
+    assert_eq!(lit.to_string(), "\" doc\"");
+
+    let stream = "//! doc".parse::<TokenStream>().unwrap();
+    let lit = lit_of_inner_doc_comment(&stream);
+    assert_eq!(lit.to_string(), "\" doc\"");
+
+    let stream = "/** doc */".parse::<TokenStream>().unwrap();
+    let lit = lit_of_outer_doc_comment(&stream);
+    assert_eq!(lit.to_string(), "\" doc \"");
+
+    let stream = "/*! doc */".parse::<TokenStream>().unwrap();
+    let lit = lit_of_inner_doc_comment(&stream);
+    assert_eq!(lit.to_string(), "\" doc \"");
+}
+
+#[test]
+fn carriage_return() {
+    let stream = "///\r\n".parse::<TokenStream>().unwrap();
+    let lit = lit_of_outer_doc_comment(&stream);
+    assert_eq!(lit.to_string(), "\"\"");
+
+    let stream = "/**\r\n*/".parse::<TokenStream>().unwrap();
+    let lit = lit_of_outer_doc_comment(&stream);
+    assert_eq!(lit.to_string(), "\"\\r\\n\"");
+
+    "///\r".parse::<TokenStream>().unwrap_err();
+    "///\r \n".parse::<TokenStream>().unwrap_err();
+    "/**\r \n*/".parse::<TokenStream>().unwrap_err();
+}
diff --git a/crates/proc-macro2/tests/features.rs b/crates/proc-macro2/tests/features.rs
new file mode 100644
index 0000000..073f6e6
--- /dev/null
+++ b/crates/proc-macro2/tests/features.rs
@@ -0,0 +1,8 @@
+#[test]
+#[ignore]
+fn make_sure_no_proc_macro() {
+    assert!(
+        !cfg!(feature = "proc-macro"),
+        "still compiled with proc_macro?"
+    );
+}
diff --git a/crates/proc-macro2/tests/marker.rs b/crates/proc-macro2/tests/marker.rs
new file mode 100644
index 0000000..d08fbfc
--- /dev/null
+++ b/crates/proc-macro2/tests/marker.rs
@@ -0,0 +1,99 @@
+#![allow(clippy::extra_unused_type_parameters)]
+
+use proc_macro2::{
+    Delimiter, Group, Ident, LexError, Literal, Punct, Spacing, Span, TokenStream, TokenTree,
+};
+
+macro_rules! assert_impl {
+    ($ty:ident is $($marker:ident) and +) => {
+        #[test]
+        #[allow(non_snake_case)]
+        fn $ty() {
+            fn assert_implemented<T: $($marker +)+>() {}
+            assert_implemented::<$ty>();
+        }
+    };
+
+    ($ty:ident is not $($marker:ident) or +) => {
+        #[test]
+        #[allow(non_snake_case)]
+        fn $ty() {
+            $(
+                {
+                    // Implemented for types that implement $marker.
+                    trait IsNotImplemented {
+                        fn assert_not_implemented() {}
+                    }
+                    impl<T: $marker> IsNotImplemented for T {}
+
+                    // Implemented for the type being tested.
+                    trait IsImplemented {
+                        fn assert_not_implemented() {}
+                    }
+                    impl IsImplemented for $ty {}
+
+                    // If $ty does not implement $marker, there is no ambiguity
+                    // in the following trait method call.
+                    <$ty>::assert_not_implemented();
+                }
+            )+
+        }
+    };
+}
+
+assert_impl!(Delimiter is Send and Sync);
+assert_impl!(Spacing is Send and Sync);
+
+assert_impl!(Group is not Send or Sync);
+assert_impl!(Ident is not Send or Sync);
+assert_impl!(LexError is not Send or Sync);
+assert_impl!(Literal is not Send or Sync);
+assert_impl!(Punct is not Send or Sync);
+assert_impl!(Span is not Send or Sync);
+assert_impl!(TokenStream is not Send or Sync);
+assert_impl!(TokenTree is not Send or Sync);
+
+#[cfg(procmacro2_semver_exempt)]
+mod semver_exempt {
+    use proc_macro2::{LineColumn, SourceFile};
+
+    assert_impl!(LineColumn is Send and Sync);
+
+    assert_impl!(SourceFile is not Send or Sync);
+}
+
+mod unwind_safe {
+    use proc_macro2::{
+        Delimiter, Group, Ident, LexError, Literal, Punct, Spacing, Span, TokenStream, TokenTree,
+    };
+    #[cfg(procmacro2_semver_exempt)]
+    use proc_macro2::{LineColumn, SourceFile};
+    use std::panic::{RefUnwindSafe, UnwindSafe};
+
+    macro_rules! assert_unwind_safe {
+        ($($types:ident)*) => {
+            $(
+                assert_impl!($types is UnwindSafe and RefUnwindSafe);
+            )*
+        };
+    }
+
+    assert_unwind_safe! {
+        Delimiter
+        Group
+        Ident
+        LexError
+        Literal
+        Punct
+        Spacing
+        Span
+        TokenStream
+        TokenTree
+    }
+
+    #[cfg(procmacro2_semver_exempt)]
+    assert_unwind_safe! {
+        LineColumn
+        SourceFile
+    }
+}
diff --git a/crates/proc-macro2/tests/test.rs b/crates/proc-macro2/tests/test.rs
new file mode 100644
index 0000000..b75cd55
--- /dev/null
+++ b/crates/proc-macro2/tests/test.rs
@@ -0,0 +1,759 @@
+#![allow(
+    clippy::assertions_on_result_states,
+    clippy::items_after_statements,
+    clippy::non_ascii_literal,
+    clippy::octal_escapes
+)]
+
+use proc_macro2::{Ident, Literal, Punct, Spacing, Span, TokenStream, TokenTree};
+use std::iter;
+use std::str::{self, FromStr};
+
+#[test]
+fn idents() {
+    assert_eq!(
+        Ident::new("String", Span::call_site()).to_string(),
+        "String"
+    );
+    assert_eq!(Ident::new("fn", Span::call_site()).to_string(), "fn");
+    assert_eq!(Ident::new("_", Span::call_site()).to_string(), "_");
+}
+
+#[test]
+fn raw_idents() {
+    assert_eq!(
+        Ident::new_raw("String", Span::call_site()).to_string(),
+        "r#String"
+    );
+    assert_eq!(Ident::new_raw("fn", Span::call_site()).to_string(), "r#fn");
+}
+
+#[test]
+#[should_panic(expected = "`r#_` cannot be a raw identifier")]
+fn ident_raw_underscore() {
+    Ident::new_raw("_", Span::call_site());
+}
+
+#[test]
+#[should_panic(expected = "`r#super` cannot be a raw identifier")]
+fn ident_raw_reserved() {
+    Ident::new_raw("super", Span::call_site());
+}
+
+#[test]
+#[should_panic(expected = "Ident is not allowed to be empty; use Option<Ident>")]
+fn ident_empty() {
+    Ident::new("", Span::call_site());
+}
+
+#[test]
+#[should_panic(expected = "Ident cannot be a number; use Literal instead")]
+fn ident_number() {
+    Ident::new("255", Span::call_site());
+}
+
+#[test]
+#[should_panic(expected = "\"a#\" is not a valid Ident")]
+fn ident_invalid() {
+    Ident::new("a#", Span::call_site());
+}
+
+#[test]
+#[should_panic(expected = "not a valid Ident")]
+fn raw_ident_empty() {
+    Ident::new("r#", Span::call_site());
+}
+
+#[test]
+#[should_panic(expected = "not a valid Ident")]
+fn raw_ident_number() {
+    Ident::new("r#255", Span::call_site());
+}
+
+#[test]
+#[should_panic(expected = "\"r#a#\" is not a valid Ident")]
+fn raw_ident_invalid() {
+    Ident::new("r#a#", Span::call_site());
+}
+
+#[test]
+#[should_panic(expected = "not a valid Ident")]
+fn lifetime_empty() {
+    Ident::new("'", Span::call_site());
+}
+
+#[test]
+#[should_panic(expected = "not a valid Ident")]
+fn lifetime_number() {
+    Ident::new("'255", Span::call_site());
+}
+
+#[test]
+#[should_panic(expected = r#""'a#" is not a valid Ident"#)]
+fn lifetime_invalid() {
+    Ident::new("'a#", Span::call_site());
+}
+
+#[test]
+fn literal_string() {
+    assert_eq!(Literal::string("foo").to_string(), "\"foo\"");
+    assert_eq!(Literal::string("\"").to_string(), "\"\\\"\"");
+    assert_eq!(Literal::string("didn't").to_string(), "\"didn't\"");
+    assert_eq!(
+        Literal::string("a\00b\07c\08d\0e\0").to_string(),
+        "\"a\\x000b\\x007c\\08d\\0e\\0\"",
+    );
+
+    "\"\\\r\n    x\"".parse::<TokenStream>().unwrap();
+    "\"\\\r\n  \rx\"".parse::<TokenStream>().unwrap_err();
+}
+
+#[test]
+fn literal_raw_string() {
+    "r\"\r\n\"".parse::<TokenStream>().unwrap();
+
+    fn raw_string_literal_with_hashes(n: usize) -> String {
+        let mut literal = String::new();
+        literal.push('r');
+        literal.extend(iter::repeat('#').take(n));
+        literal.push('"');
+        literal.push('"');
+        literal.extend(iter::repeat('#').take(n));
+        literal
+    }
+
+    raw_string_literal_with_hashes(255)
+        .parse::<TokenStream>()
+        .unwrap();
+
+    // https://github.com/rust-lang/rust/pull/95251
+    raw_string_literal_with_hashes(256)
+        .parse::<TokenStream>()
+        .unwrap_err();
+}
+
+#[test]
+fn literal_byte_string() {
+    assert_eq!(Literal::byte_string(b"").to_string(), "b\"\"");
+    assert_eq!(
+        Literal::byte_string(b"\0\t\n\r\"\\2\x10").to_string(),
+        "b\"\\0\\t\\n\\r\\\"\\\\2\\x10\"",
+    );
+    assert_eq!(
+        Literal::byte_string(b"a\00b\07c\08d\0e\0").to_string(),
+        "b\"a\\x000b\\x007c\\08d\\0e\\0\"",
+    );
+
+    "b\"\\\r\n    x\"".parse::<TokenStream>().unwrap();
+    "b\"\\\r\n  \rx\"".parse::<TokenStream>().unwrap_err();
+    "b\"\\\r\n  \u{a0}x\"".parse::<TokenStream>().unwrap_err();
+    "br\"\u{a0}\"".parse::<TokenStream>().unwrap_err();
+}
+
+#[test]
+fn literal_c_string() {
+    let strings = r###"
+        c"hello\x80我叫\u{1F980}"  // from the RFC
+        cr"\"
+        cr##"Hello "world"!"##
+        c"\t\n\r\"\\"
+    "###;
+
+    let mut tokens = strings.parse::<TokenStream>().unwrap().into_iter();
+
+    for expected in &[
+        r#"c"hello\x80我叫\u{1F980}""#,
+        r#"cr"\""#,
+        r###"cr##"Hello "world"!"##"###,
+        r#"c"\t\n\r\"\\""#,
+    ] {
+        match tokens.next().unwrap() {
+            TokenTree::Literal(literal) => {
+                assert_eq!(literal.to_string(), *expected);
+            }
+            unexpected => panic!("unexpected token: {:?}", unexpected),
+        }
+    }
+
+    if let Some(unexpected) = tokens.next() {
+        panic!("unexpected token: {:?}", unexpected);
+    }
+
+    for invalid in &[r#"c"\0""#, r#"c"\x00""#, r#"c"\u{0}""#, "c\"\0\""] {
+        if let Ok(unexpected) = invalid.parse::<TokenStream>() {
+            panic!("unexpected token: {:?}", unexpected);
+        }
+    }
+}
+
+#[test]
+fn literal_character() {
+    assert_eq!(Literal::character('x').to_string(), "'x'");
+    assert_eq!(Literal::character('\'').to_string(), "'\\''");
+    assert_eq!(Literal::character('"').to_string(), "'\"'");
+}
+
+#[test]
+fn literal_integer() {
+    assert_eq!(Literal::u8_suffixed(10).to_string(), "10u8");
+    assert_eq!(Literal::u16_suffixed(10).to_string(), "10u16");
+    assert_eq!(Literal::u32_suffixed(10).to_string(), "10u32");
+    assert_eq!(Literal::u64_suffixed(10).to_string(), "10u64");
+    assert_eq!(Literal::u128_suffixed(10).to_string(), "10u128");
+    assert_eq!(Literal::usize_suffixed(10).to_string(), "10usize");
+
+    assert_eq!(Literal::i8_suffixed(10).to_string(), "10i8");
+    assert_eq!(Literal::i16_suffixed(10).to_string(), "10i16");
+    assert_eq!(Literal::i32_suffixed(10).to_string(), "10i32");
+    assert_eq!(Literal::i64_suffixed(10).to_string(), "10i64");
+    assert_eq!(Literal::i128_suffixed(10).to_string(), "10i128");
+    assert_eq!(Literal::isize_suffixed(10).to_string(), "10isize");
+
+    assert_eq!(Literal::u8_unsuffixed(10).to_string(), "10");
+    assert_eq!(Literal::u16_unsuffixed(10).to_string(), "10");
+    assert_eq!(Literal::u32_unsuffixed(10).to_string(), "10");
+    assert_eq!(Literal::u64_unsuffixed(10).to_string(), "10");
+    assert_eq!(Literal::u128_unsuffixed(10).to_string(), "10");
+    assert_eq!(Literal::usize_unsuffixed(10).to_string(), "10");
+
+    assert_eq!(Literal::i8_unsuffixed(10).to_string(), "10");
+    assert_eq!(Literal::i16_unsuffixed(10).to_string(), "10");
+    assert_eq!(Literal::i32_unsuffixed(10).to_string(), "10");
+    assert_eq!(Literal::i64_unsuffixed(10).to_string(), "10");
+    assert_eq!(Literal::i128_unsuffixed(10).to_string(), "10");
+    assert_eq!(Literal::isize_unsuffixed(10).to_string(), "10");
+}
+
+#[test]
+fn literal_float() {
+    assert_eq!(Literal::f32_suffixed(10.0).to_string(), "10f32");
+    assert_eq!(Literal::f64_suffixed(10.0).to_string(), "10f64");
+
+    assert_eq!(Literal::f32_unsuffixed(10.0).to_string(), "10.0");
+    assert_eq!(Literal::f64_unsuffixed(10.0).to_string(), "10.0");
+}
+
+#[test]
+fn literal_suffix() {
+    fn token_count(p: &str) -> usize {
+        p.parse::<TokenStream>().unwrap().into_iter().count()
+    }
+
+    assert_eq!(token_count("999u256"), 1);
+    assert_eq!(token_count("999r#u256"), 3);
+    assert_eq!(token_count("1."), 1);
+    assert_eq!(token_count("1.f32"), 3);
+    assert_eq!(token_count("1.0_0"), 1);
+    assert_eq!(token_count("1._0"), 3);
+    assert_eq!(token_count("1._m"), 3);
+    assert_eq!(token_count("\"\"s"), 1);
+    assert_eq!(token_count("r\"\"r"), 1);
+    assert_eq!(token_count("b\"\"b"), 1);
+    assert_eq!(token_count("br\"\"br"), 1);
+    assert_eq!(token_count("r#\"\"#r"), 1);
+    assert_eq!(token_count("'c'c"), 1);
+    assert_eq!(token_count("b'b'b"), 1);
+    assert_eq!(token_count("0E"), 1);
+    assert_eq!(token_count("0o0A"), 1);
+    assert_eq!(token_count("0E--0"), 4);
+    assert_eq!(token_count("0.0ECMA"), 1);
+}
+
+#[test]
+fn literal_iter_negative() {
+    let negative_literal = Literal::i32_suffixed(-3);
+    let tokens = TokenStream::from(TokenTree::Literal(negative_literal));
+    let mut iter = tokens.into_iter();
+    match iter.next().unwrap() {
+        TokenTree::Punct(punct) => {
+            assert_eq!(punct.as_char(), '-');
+            assert_eq!(punct.spacing(), Spacing::Alone);
+        }
+        unexpected => panic!("unexpected token {:?}", unexpected),
+    }
+    match iter.next().unwrap() {
+        TokenTree::Literal(literal) => {
+            assert_eq!(literal.to_string(), "3i32");
+        }
+        unexpected => panic!("unexpected token {:?}", unexpected),
+    }
+    assert!(iter.next().is_none());
+}
+
+#[test]
+fn literal_parse() {
+    assert!("1".parse::<Literal>().is_ok());
+    assert!("-1".parse::<Literal>().is_ok());
+    assert!("-1u12".parse::<Literal>().is_ok());
+    assert!("1.0".parse::<Literal>().is_ok());
+    assert!("-1.0".parse::<Literal>().is_ok());
+    assert!("-1.0f12".parse::<Literal>().is_ok());
+    assert!("'a'".parse::<Literal>().is_ok());
+    assert!("\"\n\"".parse::<Literal>().is_ok());
+    assert!("0 1".parse::<Literal>().is_err());
+    assert!(" 0".parse::<Literal>().is_err());
+    assert!("0 ".parse::<Literal>().is_err());
+    assert!("/* comment */0".parse::<Literal>().is_err());
+    assert!("0/* comment */".parse::<Literal>().is_err());
+    assert!("0// comment".parse::<Literal>().is_err());
+    assert!("- 1".parse::<Literal>().is_err());
+    assert!("- 1.0".parse::<Literal>().is_err());
+    assert!("-\"\"".parse::<Literal>().is_err());
+}
+
+#[test]
+fn literal_span() {
+    let positive = "0.1".parse::<Literal>().unwrap();
+    let negative = "-0.1".parse::<Literal>().unwrap();
+    let subspan = positive.subspan(1..2);
+
+    #[cfg(not(span_locations))]
+    {
+        let _ = negative;
+        assert!(subspan.is_none());
+    }
+
+    #[cfg(span_locations)]
+    {
+        assert_eq!(positive.span().start().column, 0);
+        assert_eq!(positive.span().end().column, 3);
+        assert_eq!(negative.span().start().column, 0);
+        assert_eq!(negative.span().end().column, 4);
+        assert_eq!(subspan.unwrap().source_text().unwrap(), ".");
+    }
+
+    assert!(positive.subspan(1..4).is_none());
+}
+
+#[cfg(span_locations)]
+#[test]
+fn source_text() {
+    let input = "    𓀕 a z    ";
+    let mut tokens = input
+        .parse::<proc_macro2::TokenStream>()
+        .unwrap()
+        .into_iter();
+
+    let first = tokens.next().unwrap();
+    assert_eq!("𓀕", first.span().source_text().unwrap());
+
+    let second = tokens.next().unwrap();
+    let third = tokens.next().unwrap();
+    assert_eq!("z", third.span().source_text().unwrap());
+    assert_eq!("a", second.span().source_text().unwrap());
+}
+
+#[test]
+fn roundtrip() {
+    fn roundtrip(p: &str) {
+        println!("parse: {}", p);
+        let s = p.parse::<TokenStream>().unwrap().to_string();
+        println!("first: {}", s);
+        let s2 = s.parse::<TokenStream>().unwrap().to_string();
+        assert_eq!(s, s2);
+    }
+    roundtrip("a");
+    roundtrip("<<");
+    roundtrip("<<=");
+    roundtrip(
+        "
+        1
+        1.0
+        1f32
+        2f64
+        1usize
+        4isize
+        4e10
+        1_000
+        1_0i32
+        8u8
+        9
+        0
+        0xffffffffffffffffffffffffffffffff
+        1x
+        1u80
+        1f320
+    ",
+    );
+    roundtrip("'a");
+    roundtrip("'_");
+    roundtrip("'static");
+    roundtrip("'\\u{10__FFFF}'");
+    roundtrip("\"\\u{10_F0FF__}foo\\u{1_0_0_0__}\"");
+}
+
+#[test]
+fn fail() {
+    fn fail(p: &str) {
+        if let Ok(s) = p.parse::<TokenStream>() {
+            panic!("should have failed to parse: {}\n{:#?}", p, s);
+        }
+    }
+    fail("' static");
+    fail("r#1");
+    fail("r#_");
+    fail("\"\\u{0000000}\""); // overlong unicode escape (rust allows at most 6 hex digits)
+    fail("\"\\u{999999}\""); // outside of valid range of char
+    fail("\"\\u{_0}\""); // leading underscore
+    fail("\"\\u{}\""); // empty
+    fail("b\"\r\""); // bare carriage return in byte string
+    fail("r\"\r\""); // bare carriage return in raw string
+    fail("\"\\\r  \""); // backslash carriage return
+    fail("'aa'aa");
+    fail("br##\"\"#");
+    fail("\"\\\n\u{85}\r\"");
+}
+
+#[cfg(span_locations)]
+#[test]
+fn span_test() {
+    check_spans(
+        "\
+/// This is a document comment
+testing 123
+{
+  testing 234
+}",
+        &[
+            (1, 0, 1, 30),  // #
+            (1, 0, 1, 30),  // [ ... ]
+            (1, 0, 1, 30),  // doc
+            (1, 0, 1, 30),  // =
+            (1, 0, 1, 30),  // "This is..."
+            (2, 0, 2, 7),   // testing
+            (2, 8, 2, 11),  // 123
+            (3, 0, 5, 1),   // { ... }
+            (4, 2, 4, 9),   // testing
+            (4, 10, 4, 13), // 234
+        ],
+    );
+}
+
+#[cfg(procmacro2_semver_exempt)]
+#[cfg(not(nightly))]
+#[test]
+fn default_span() {
+    let start = Span::call_site().start();
+    assert_eq!(start.line, 1);
+    assert_eq!(start.column, 0);
+    let end = Span::call_site().end();
+    assert_eq!(end.line, 1);
+    assert_eq!(end.column, 0);
+    let source_file = Span::call_site().source_file();
+    assert_eq!(source_file.path().to_string_lossy(), "<unspecified>");
+    assert!(!source_file.is_real());
+}
+
+#[cfg(procmacro2_semver_exempt)]
+#[test]
+fn span_join() {
+    let source1 = "aaa\nbbb"
+        .parse::<TokenStream>()
+        .unwrap()
+        .into_iter()
+        .collect::<Vec<_>>();
+    let source2 = "ccc\nddd"
+        .parse::<TokenStream>()
+        .unwrap()
+        .into_iter()
+        .collect::<Vec<_>>();
+
+    assert!(source1[0].span().source_file() != source2[0].span().source_file());
+    assert_eq!(
+        source1[0].span().source_file(),
+        source1[1].span().source_file()
+    );
+
+    let joined1 = source1[0].span().join(source1[1].span());
+    let joined2 = source1[0].span().join(source2[0].span());
+    assert!(joined1.is_some());
+    assert!(joined2.is_none());
+
+    let start = joined1.unwrap().start();
+    let end = joined1.unwrap().end();
+    assert_eq!(start.line, 1);
+    assert_eq!(start.column, 0);
+    assert_eq!(end.line, 2);
+    assert_eq!(end.column, 3);
+
+    assert_eq!(
+        joined1.unwrap().source_file(),
+        source1[0].span().source_file()
+    );
+}
+
+#[test]
+fn no_panic() {
+    let s = str::from_utf8(b"b\'\xc2\x86  \x00\x00\x00^\"").unwrap();
+    assert!(s.parse::<TokenStream>().is_err());
+}
+
+#[test]
+fn punct_before_comment() {
+    let mut tts = TokenStream::from_str("~// comment").unwrap().into_iter();
+    match tts.next().unwrap() {
+        TokenTree::Punct(tt) => {
+            assert_eq!(tt.as_char(), '~');
+            assert_eq!(tt.spacing(), Spacing::Alone);
+        }
+        wrong => panic!("wrong token {:?}", wrong),
+    }
+}
+
+#[test]
+fn joint_last_token() {
+    // This test verifies that we match the behavior of libproc_macro *not* in
+    // the range nightly-2020-09-06 through nightly-2020-09-10, in which this
+    // behavior was temporarily broken.
+    // See https://github.com/rust-lang/rust/issues/76399
+
+    let joint_punct = Punct::new(':', Spacing::Joint);
+    let stream = TokenStream::from(TokenTree::Punct(joint_punct));
+    let punct = match stream.into_iter().next().unwrap() {
+        TokenTree::Punct(punct) => punct,
+        _ => unreachable!(),
+    };
+    assert_eq!(punct.spacing(), Spacing::Joint);
+}
+
+#[test]
+fn raw_identifier() {
+    let mut tts = TokenStream::from_str("r#dyn").unwrap().into_iter();
+    match tts.next().unwrap() {
+        TokenTree::Ident(raw) => assert_eq!("r#dyn", raw.to_string()),
+        wrong => panic!("wrong token {:?}", wrong),
+    }
+    assert!(tts.next().is_none());
+}
+
+#[test]
+fn test_debug_ident() {
+    let ident = Ident::new("proc_macro", Span::call_site());
+
+    #[cfg(not(span_locations))]
+    let expected = "Ident(proc_macro)";
+
+    #[cfg(span_locations)]
+    let expected = "Ident { sym: proc_macro }";
+
+    assert_eq!(expected, format!("{:?}", ident));
+}
+
+#[test]
+fn test_debug_tokenstream() {
+    let tts = TokenStream::from_str("[a + 1]").unwrap();
+
+    #[cfg(not(span_locations))]
+    let expected = "\
+TokenStream [
+    Group {
+        delimiter: Bracket,
+        stream: TokenStream [
+            Ident {
+                sym: a,
+            },
+            Punct {
+                char: '+',
+                spacing: Alone,
+            },
+            Literal {
+                lit: 1,
+            },
+        ],
+    },
+]\
+    ";
+
+    #[cfg(not(span_locations))]
+    let expected_before_trailing_commas = "\
+TokenStream [
+    Group {
+        delimiter: Bracket,
+        stream: TokenStream [
+            Ident {
+                sym: a
+            },
+            Punct {
+                char: '+',
+                spacing: Alone
+            },
+            Literal {
+                lit: 1
+            }
+        ]
+    }
+]\
+    ";
+
+    #[cfg(span_locations)]
+    let expected = "\
+TokenStream [
+    Group {
+        delimiter: Bracket,
+        stream: TokenStream [
+            Ident {
+                sym: a,
+                span: bytes(2..3),
+            },
+            Punct {
+                char: '+',
+                spacing: Alone,
+                span: bytes(4..5),
+            },
+            Literal {
+                lit: 1,
+                span: bytes(6..7),
+            },
+        ],
+        span: bytes(1..8),
+    },
+]\
+    ";
+
+    #[cfg(span_locations)]
+    let expected_before_trailing_commas = "\
+TokenStream [
+    Group {
+        delimiter: Bracket,
+        stream: TokenStream [
+            Ident {
+                sym: a,
+                span: bytes(2..3)
+            },
+            Punct {
+                char: '+',
+                spacing: Alone,
+                span: bytes(4..5)
+            },
+            Literal {
+                lit: 1,
+                span: bytes(6..7)
+            }
+        ],
+        span: bytes(1..8)
+    }
+]\
+    ";
+
+    let actual = format!("{:#?}", tts);
+    if actual.ends_with(",\n]") {
+        assert_eq!(expected, actual);
+    } else {
+        assert_eq!(expected_before_trailing_commas, actual);
+    }
+}
+
+#[test]
+fn default_tokenstream_is_empty() {
+    let default_token_stream = <TokenStream as Default>::default();
+
+    assert!(default_token_stream.is_empty());
+}
+
+#[test]
+fn tokenstream_size_hint() {
+    let tokens = "a b (c d) e".parse::<TokenStream>().unwrap();
+
+    assert_eq!(tokens.into_iter().size_hint(), (4, Some(4)));
+}
+
+#[test]
+fn tuple_indexing() {
+    // This behavior may change depending on https://github.com/rust-lang/rust/pull/71322
+    let mut tokens = "tuple.0.0".parse::<TokenStream>().unwrap().into_iter();
+    assert_eq!("tuple", tokens.next().unwrap().to_string());
+    assert_eq!(".", tokens.next().unwrap().to_string());
+    assert_eq!("0.0", tokens.next().unwrap().to_string());
+    assert!(tokens.next().is_none());
+}
+
+#[cfg(span_locations)]
+#[test]
+fn non_ascii_tokens() {
+    check_spans("// abc", &[]);
+    check_spans("// ábc", &[]);
+    check_spans("// abc x", &[]);
+    check_spans("// ábc x", &[]);
+    check_spans("/* abc */ x", &[(1, 10, 1, 11)]);
+    check_spans("/* ábc */ x", &[(1, 10, 1, 11)]);
+    check_spans("/* ab\nc */ x", &[(2, 5, 2, 6)]);
+    check_spans("/* áb\nc */ x", &[(2, 5, 2, 6)]);
+    check_spans("/*** abc */ x", &[(1, 12, 1, 13)]);
+    check_spans("/*** ábc */ x", &[(1, 12, 1, 13)]);
+    check_spans(r#""abc""#, &[(1, 0, 1, 5)]);
+    check_spans(r#""ábc""#, &[(1, 0, 1, 5)]);
+    check_spans(r##"r#"abc"#"##, &[(1, 0, 1, 8)]);
+    check_spans(r##"r#"ábc"#"##, &[(1, 0, 1, 8)]);
+    check_spans("r#\"a\nc\"#", &[(1, 0, 2, 3)]);
+    check_spans("r#\"á\nc\"#", &[(1, 0, 2, 3)]);
+    check_spans("'a'", &[(1, 0, 1, 3)]);
+    check_spans("'á'", &[(1, 0, 1, 3)]);
+    check_spans("//! abc", &[(1, 0, 1, 7), (1, 0, 1, 7), (1, 0, 1, 7)]);
+    check_spans("//! ábc", &[(1, 0, 1, 7), (1, 0, 1, 7), (1, 0, 1, 7)]);
+    check_spans("//! abc\n", &[(1, 0, 1, 7), (1, 0, 1, 7), (1, 0, 1, 7)]);
+    check_spans("//! ábc\n", &[(1, 0, 1, 7), (1, 0, 1, 7), (1, 0, 1, 7)]);
+    check_spans("/*! abc */", &[(1, 0, 1, 10), (1, 0, 1, 10), (1, 0, 1, 10)]);
+    check_spans("/*! ábc */", &[(1, 0, 1, 10), (1, 0, 1, 10), (1, 0, 1, 10)]);
+    check_spans("/*! a\nc */", &[(1, 0, 2, 4), (1, 0, 2, 4), (1, 0, 2, 4)]);
+    check_spans("/*! á\nc */", &[(1, 0, 2, 4), (1, 0, 2, 4), (1, 0, 2, 4)]);
+    check_spans("abc", &[(1, 0, 1, 3)]);
+    check_spans("ábc", &[(1, 0, 1, 3)]);
+    check_spans("ábć", &[(1, 0, 1, 3)]);
+    check_spans("abc// foo", &[(1, 0, 1, 3)]);
+    check_spans("ábc// foo", &[(1, 0, 1, 3)]);
+    check_spans("ábć// foo", &[(1, 0, 1, 3)]);
+    check_spans("b\"a\\\n c\"", &[(1, 0, 2, 3)]);
+}
+
+#[cfg(span_locations)]
+fn check_spans(p: &str, mut lines: &[(usize, usize, usize, usize)]) {
+    let ts = p.parse::<TokenStream>().unwrap();
+    check_spans_internal(ts, &mut lines);
+    assert!(lines.is_empty(), "leftover ranges: {:?}", lines);
+}
+
+#[cfg(span_locations)]
+fn check_spans_internal(ts: TokenStream, lines: &mut &[(usize, usize, usize, usize)]) {
+    for i in ts {
+        if let Some((&(sline, scol, eline, ecol), rest)) = lines.split_first() {
+            *lines = rest;
+
+            let start = i.span().start();
+            assert_eq!(start.line, sline, "sline did not match for {}", i);
+            assert_eq!(start.column, scol, "scol did not match for {}", i);
+
+            let end = i.span().end();
+            assert_eq!(end.line, eline, "eline did not match for {}", i);
+            assert_eq!(end.column, ecol, "ecol did not match for {}", i);
+
+            if let TokenTree::Group(g) = i {
+                check_spans_internal(g.stream().clone(), lines);
+            }
+        }
+    }
+}
+
+#[test]
+fn whitespace() {
+    // space, horizontal tab, vertical tab, form feed, carriage return, line
+    // feed, non-breaking space, left-to-right mark, right-to-left mark
+    let various_spaces = " \t\u{b}\u{c}\r\n\u{a0}\u{200e}\u{200f}";
+    let tokens = various_spaces.parse::<TokenStream>().unwrap();
+    assert_eq!(tokens.into_iter().count(), 0);
+
+    let lone_carriage_returns = " \r \r\r\n ";
+    lone_carriage_returns.parse::<TokenStream>().unwrap();
+}
+
+#[test]
+fn byte_order_mark() {
+    let string = "\u{feff}foo";
+    let tokens = string.parse::<TokenStream>().unwrap();
+    match tokens.into_iter().next().unwrap() {
+        TokenTree::Ident(ident) => assert_eq!(ident, "foo"),
+        _ => unreachable!(),
+    }
+
+    let string = "foo\u{feff}";
+    string.parse::<TokenStream>().unwrap_err();
+}
diff --git a/crates/proc-macro2/tests/test_fmt.rs b/crates/proc-macro2/tests/test_fmt.rs
new file mode 100644
index 0000000..86a4c38
--- /dev/null
+++ b/crates/proc-macro2/tests/test_fmt.rs
@@ -0,0 +1,28 @@
+#![allow(clippy::from_iter_instead_of_collect)]
+
+use proc_macro2::{Delimiter, Group, Ident, Span, TokenStream, TokenTree};
+use std::iter;
+
+#[test]
+fn test_fmt_group() {
+    let ident = Ident::new("x", Span::call_site());
+    let inner = TokenStream::from_iter(iter::once(TokenTree::Ident(ident)));
+    let parens_empty = Group::new(Delimiter::Parenthesis, TokenStream::new());
+    let parens_nonempty = Group::new(Delimiter::Parenthesis, inner.clone());
+    let brackets_empty = Group::new(Delimiter::Bracket, TokenStream::new());
+    let brackets_nonempty = Group::new(Delimiter::Bracket, inner.clone());
+    let braces_empty = Group::new(Delimiter::Brace, TokenStream::new());
+    let braces_nonempty = Group::new(Delimiter::Brace, inner.clone());
+    let none_empty = Group::new(Delimiter::None, TokenStream::new());
+    let none_nonempty = Group::new(Delimiter::None, inner);
+
+    // Matches libproc_macro.
+    assert_eq!("()", parens_empty.to_string());
+    assert_eq!("(x)", parens_nonempty.to_string());
+    assert_eq!("[]", brackets_empty.to_string());
+    assert_eq!("[x]", brackets_nonempty.to_string());
+    assert_eq!("{ }", braces_empty.to_string());
+    assert_eq!("{ x }", braces_nonempty.to_string());
+    assert_eq!("", none_empty.to_string());
+    assert_eq!("x", none_nonempty.to_string());
+}
diff --git a/crates/proc-macro2/tests/test_size.rs b/crates/proc-macro2/tests/test_size.rs
new file mode 100644
index 0000000..46e58db
--- /dev/null
+++ b/crates/proc-macro2/tests/test_size.rs
@@ -0,0 +1,42 @@
+extern crate proc_macro;
+
+use std::mem;
+
+#[rustversion::attr(before(1.32), ignore)]
+#[test]
+fn test_proc_macro_span_size() {
+    assert_eq!(mem::size_of::<proc_macro::Span>(), 4);
+    assert_eq!(mem::size_of::<Option<proc_macro::Span>>(), 4);
+}
+
+#[cfg_attr(not(all(not(wrap_proc_macro), not(span_locations))), ignore)]
+#[test]
+fn test_proc_macro2_fallback_span_size_without_locations() {
+    assert_eq!(mem::size_of::<proc_macro2::Span>(), 0);
+    assert_eq!(mem::size_of::<Option<proc_macro2::Span>>(), 1);
+}
+
+#[cfg_attr(not(all(not(wrap_proc_macro), span_locations)), ignore)]
+#[test]
+fn test_proc_macro2_fallback_span_size_with_locations() {
+    assert_eq!(mem::size_of::<proc_macro2::Span>(), 8);
+    assert_eq!(mem::size_of::<Option<proc_macro2::Span>>(), 12);
+}
+
+#[rustversion::attr(before(1.32), ignore)]
+#[rustversion::attr(
+    since(1.32),
+    cfg_attr(not(all(wrap_proc_macro, not(span_locations))), ignore)
+)]
+#[test]
+fn test_proc_macro2_wrapper_span_size_without_locations() {
+    assert_eq!(mem::size_of::<proc_macro2::Span>(), 4);
+    assert_eq!(mem::size_of::<Option<proc_macro2::Span>>(), 8);
+}
+
+#[cfg_attr(not(all(wrap_proc_macro, span_locations)), ignore)]
+#[test]
+fn test_proc_macro2_wrapper_span_size_with_locations() {
+    assert_eq!(mem::size_of::<proc_macro2::Span>(), 12);
+    assert_eq!(mem::size_of::<Option<proc_macro2::Span>>(), 12);
+}
diff --git a/crates/rand/.cargo-checksum.json b/crates/rand/.cargo-checksum.json
new file mode 100644
index 0000000..6e76c58
--- /dev/null
+++ b/crates/rand/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"CHANGELOG.md":"76b505678de234d2eef751593feec6d9debb76c20d45564a9f23c9e9783dbc63","COPYRIGHT":"90eb64f0279b0d9432accfa6023ff803bc4965212383697eee27a0f426d5f8d5","Cargo.toml":"9bb028fb3b697653beb433ddcf4c1292b3db10ea5ed27a695df6e4e604ba6d4b","LICENSE-APACHE":"35242e7a83f69875e6edeff02291e688c97caafe2f8902e4e19b49d3e78b4cab","LICENSE-MIT":"209fbbe0ad52d9235e37badf9cadfe4dbdc87203179c0899e738b39ade42177b","README.md":"ddb5a1fa9442c6cab92a3510365937e729f839c94b97e75d3f0430bf3a4dd2bd","src/distributions/bernoulli.rs":"437e61c41f73b6fffad11a65cc45d05df198ab05b37328eba687a9779b86948a","src/distributions/distribution.rs":"36086233c9682eb16874ba87bb1ec39db71559c5ce2ca618dc8c6bd9710d3b3a","src/distributions/float.rs":"ef894cbfeab9c734894468175c4553100b4a261f431047f2bbc4949aa43e2ccd","src/distributions/integer.rs":"a380e0627c97cfad0d94e0fdfb4dad73060d23073cc1d379f06c4dbd2a4fc2db","src/distributions/mod.rs":"f87a133e704e38ad554c8b4f62497d6320c74ef7d37df7871c61bde48d200b5b","src/distributions/other.rs":"e60568f8eadc0594636641a2070e53f5127fb532a74101ed4767f424a6e92622","src/distributions/slice.rs":"94f5abfe602679e980e4561bb03dcac28bbd3bb5f7bd2821f396a6293c0878db","src/distributions/uniform.rs":"9eb0769b7c268c2e4f502ede0d779cb1ab5243d70a1fb39f2f5e316bcf9586e2","src/distributions/utils.rs":"41304f5e2d74e750fc62f7871443c6e9d510a6c99be4614fb5c756682e0344d7","src/distributions/weighted.rs":"ae019d9b688e33cb912c9a04668cce3e7df86abab994db88478c6c339f98222f","src/distributions/weighted_index.rs":"874d1db2e258d9c049be08ae80b72ec2c75af0f2571f83091a26a3f6c747a6f0","src/lib.rs":"a773ff7b0dad376e5ef23661c40b7a96df4233fef90dab303db93f209aee314f","src/prelude.rs":"2f2132d74ce9f70513224baad3b161b1585a639f9136a254cdb0e7f8ffceb25b","src/rng.rs":"5d9b55069197f9f98298e8d930b13d8c65ab2701660bfbf52d83c6d7d7aff8c6","src/rngs/adapter/mod.rs":"28318871529da61dccc0fe8c0bcafa99b133c721d4bb506fa34d0831f4ca2639","src/rngs/adapter/read.rs":"b044061c46d0b8e6a4f25c69d3e8bb6f9df08cd8df9b5eae131a1d4934020e03","src/rngs/adapter/reseeding.rs":"89abebade9bca847889155ac3357c0021d2c6181dd47478332a644820ade0c6e","src/rngs/mock.rs":"0074abe04cf84b1263218f50140931fa4188f4e0a43fe3205556a00e4c36d1e9","src/rngs/mod.rs":"a6dec3d19e1726ba05f130ab9b20719d79177b8c1584cdd7b5f37b9996315ed3","src/rngs/small.rs":"a8e61c6e0bad62f06db1325e3b93eff1d4aa9e82cf0316fbfd02da2ef5b85b83","src/rngs/std.rs":"3cee48bf1fea18b84f585680a947f3aeea949b756cc37d99217291f9759be7c9","src/rngs/thread.rs":"c3cc07465bf02d08182afc47a40e50095d7c83633e09dcd071974b2a902e6fce","src/rngs/xoshiro128plusplus.rs":"deca2450a2d5ea826ca6f47cccb9ee06daeac38799a30a107b78c5dae78ae30c","src/rngs/xoshiro256plusplus.rs":"d7e214f8288041cede7ef26e829dd2196f7b4843455d7f1b9a3ef080d570bc5f","src/seq/index.rs":"5247833f7bfc8c5c11337ce7dc0a55a6979ea664ddddd70b6e2b9598058ab44d","src/seq/mod.rs":"dd97a635e89e1d50153c57ec03d8a346a063486998ef14ca4fdc60659f1612fb"},"package":"34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"}
\ No newline at end of file
diff --git a/crates/rand/Android.bp b/crates/rand/Android.bp
new file mode 100644
index 0000000..6e89990
--- /dev/null
+++ b/crates/rand/Android.bp
@@ -0,0 +1,45 @@
+// This file is generated by cargo_embargo.
+// Do not modify this file because the changes will be overridden on upgrade.
+
+package {
+    default_applicable_licenses: ["external_rust_crates_rand_license"],
+    default_team: "trendy_team_android_rust",
+}
+
+license {
+    name: "external_rust_crates_rand_license",
+    visibility: [":__subpackages__"],
+    license_kinds: ["SPDX-license-identifier-Apache-2.0"],
+    license_text: ["LICENSE"],
+}
+
+rust_library {
+    name: "librand",
+    host_supported: true,
+    crate_name: "rand",
+    cargo_env_compat: true,
+    cargo_pkg_version: "0.8.5",
+    crate_root: "src/lib.rs",
+    edition: "2018",
+    features: [
+        "alloc",
+        "default",
+        "getrandom",
+        "libc",
+        "rand_chacha",
+        "small_rng",
+        "std",
+        "std_rng",
+    ],
+    rustlibs: [
+        "liblibc",
+        "librand_chacha",
+        "librand_core",
+    ],
+    apex_available: [
+        "//apex_available:platform",
+        "//apex_available:anyapex",
+    ],
+    product_available: true,
+    vendor_available: true,
+}
diff --git a/crates/rand/CHANGELOG.md b/crates/rand/CHANGELOG.md
new file mode 100644
index 0000000..b0872af
--- /dev/null
+++ b/crates/rand/CHANGELOG.md
@@ -0,0 +1,699 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+A [separate changelog is kept for rand_core](rand_core/CHANGELOG.md).
+
+You may also find the [Upgrade Guide](https://rust-random.github.io/book/update.html) useful.
+
+## [0.8.5] - 2021-08-20
+### Fixes
+- Fix build on non-32/64-bit architectures (#1144)
+- Fix "min_const_gen" feature for `no_std` (#1173)
+- Check `libc::pthread_atfork` return value with panic on error (#1178)
+- More robust reseeding in case `ReseedingRng` is used from a fork handler (#1178)
+- Fix nightly: remove unused `slice_partition_at_index` feature (#1215)
+- Fix nightly + `simd_support`: update `packed_simd` (#1216)
+
+### Rngs
+- `StdRng`: Switch from HC128 to ChaCha12 on emscripten (#1142).
+  We now use ChaCha12 on all platforms.
+
+### Documentation
+- Added docs about rand's use of const generics (#1150)
+- Better random chars example (#1157)
+
+
+## [0.8.4] - 2021-06-15
+### Additions
+- Use const-generics to support arrays of all sizes (#1104)
+- Implement `Clone` and `Copy` for `Alphanumeric` (#1126)
+- Add `Distribution::map` to derive a distribution using a closure (#1129)
+- Add `Slice` distribution (#1107)
+- Add `DistString` trait with impls for `Standard` and `Alphanumeric` (#1133)
+
+### Other
+- Reorder asserts in `Uniform` float distributions for easier debugging of non-finite arguments
+  (#1094, #1108)
+- Add range overflow check in `Uniform` float distributions (#1108)
+- Deprecate `rngs::adapter::ReadRng` (#1130)
+
+## [0.8.3] - 2021-01-25
+### Fixes
+- Fix `no-std` + `alloc` build by gating `choose_multiple_weighted` on `std` (#1088)
+
+## [0.8.2] - 2021-01-12
+### Fixes
+- Fix panic in `UniformInt::sample_single_inclusive` and `Rng::gen_range` when
+  providing a full integer range (eg `0..=MAX`) (#1087)
+
+## [0.8.1] - 2020-12-31
+### Other
+- Enable all stable features in the playground (#1081)
+
+## [0.8.0] - 2020-12-18
+### Platform support
+- The minimum supported Rust version is now 1.36 (#1011)
+- `getrandom` updated to v0.2 (#1041)
+- Remove `wasm-bindgen` and `stdweb` feature flags. For details of WASM support,
+  see the [getrandom documentation](https://docs.rs/getrandom/latest). (#948)
+- `ReadRng::next_u32` and `next_u64` now use little-Endian conversion instead
+  of native-Endian, affecting results on Big-Endian platforms (#1061)
+- The `nightly` feature no longer implies the `simd_support` feature (#1048)
+- Fix `simd_support` feature to work on current nightlies (#1056)
+
+### Rngs
+- `ThreadRng` is no longer `Copy` to enable safe usage within thread-local destructors (#1035)
+- `gen_range(a, b)` was replaced with `gen_range(a..b)`. `gen_range(a..=b)` is
+  also supported. Note that `a` and `b` can no longer be references or SIMD types. (#744, #1003)
+- Replace `AsByteSliceMut` with `Fill` and add support for `[bool], [char], [f32], [f64]` (#940)
+- Restrict `rand::rngs::adapter` to `std` (#1027; see also #928)
+- `StdRng`: add new `std_rng` feature flag (enabled by default, but might need
+  to be used if disabling default crate features) (#948)
+- `StdRng`: Switch from ChaCha20 to ChaCha12 for better performance (#1028)
+- `SmallRng`: Replace PCG algorithm with xoshiro{128,256}++ (#1038)
+
+### Sequences
+- Add `IteratorRandom::choose_stable` as an alternative to `choose` which does
+  not depend on size hints (#1057)
+- Improve accuracy and performance of `IteratorRandom::choose` (#1059)
+- Implement `IntoIterator` for `IndexVec`, replacing the `into_iter` method (#1007)
+- Add value stability tests for `seq` module (#933)
+
+### Misc
+- Support `PartialEq` and `Eq` for `StdRng`, `SmallRng` and `StepRng` (#979)
+- Added a `serde1` feature and added Serialize/Deserialize to `UniformInt` and `WeightedIndex` (#974)
+- Drop some unsafe code (#962, #963, #1011)
+- Reduce packaged crate size (#983)
+- Migrate to GitHub Actions from Travis+AppVeyor (#1073)
+
+### Distributions
+- `Alphanumeric` samples bytes instead of chars (#935)
+- `Uniform` now supports `char`, enabling `rng.gen_range('A'..='Z')` (#1068)
+- Add `UniformSampler::sample_single_inclusive` (#1003)
+
+#### Weighted sampling
+- Implement weighted sampling without replacement (#976, #1013)
+- `rand::distributions::alias_method::WeightedIndex` was moved to `rand_distr::WeightedAliasIndex`.
+  The simpler alternative `rand::distribution::WeightedIndex` remains. (#945)
+- Improve treatment of rounding errors in `WeightedIndex::update_weights` (#956)
+- `WeightedIndex`: return error on NaN instead of panic (#1005)
+
+### Documentation
+- Document types supported by `random` (#994)
+- Document notes on password generation (#995)
+- Note that `SmallRng` may not be the best choice for performance and in some
+  other cases (#1038)
+- Use `doc(cfg)` to annotate feature-gated items (#1019)
+- Adjust README (#1065)
+
+## [0.7.3] - 2020-01-10
+### Fixes
+- The `Bernoulli` distribution constructors now reports an error on NaN and on
+  `denominator == 0`. (#925)
+- Use `std::sync::Once` to register fork handler, avoiding possible atomicity violation (#928)
+- Fix documentation on the precision of generated floating-point values
+
+### Changes
+- Unix: make libc dependency optional; only use fork protection with std feature (#928)
+
+### Additions
+- Implement `std::error::Error` for `BernoulliError` (#919)
+
+## [0.7.2] - 2019-09-16
+### Fixes
+- Fix dependency on `rand_core` 0.5.1 (#890)
+
+### Additions
+- Unit tests for value stability of distributions added (#888)
+
+## [0.7.1] - 2019-09-13
+### Yanked
+This release was yanked since it depends on `rand_core::OsRng` added in 0.5.1
+but specifies a dependency on version 0.5.0 (#890), causing a broken builds
+when updating from `rand 0.7.0` without also updating `rand_core`.
+
+### Fixes
+- Fix `no_std` behaviour, appropriately enable c2-chacha's `std` feature (#844)
+- `alloc` feature in `no_std` is available since Rust 1.36 (#856)
+- Fix or squelch issues from Clippy lints (#840)
+
+### Additions
+- Add a `no_std` target to CI to continuously evaluate `no_std` status (#844)
+- `WeightedIndex`: allow adjusting a sub-set of weights (#866)
+
+## [0.7.0] - 2019-06-28
+
+### Fixes
+- Fix incorrect pointer usages revealed by Miri testing (#780, #781)
+- Fix (tiny!) bias in `Uniform` for 8- and 16-bit ints (#809)
+
+### Crate
+- Bumped MSRV (min supported Rust version) to 1.32.0
+- Updated to Rust Edition 2018  (#823, #824)
+- Removed dependence on `rand_xorshift`, `rand_isaac`, `rand_jitter` crates (#759, #765)
+- Remove dependency on `winapi` (#724)
+- Removed all `build.rs` files (#824)
+- Removed code already deprecated in version 0.6 (#757)
+- Removed the serde1 feature (It's still available for backwards compatibility, but it does not do anything. #830)
+- Many documentation changes
+
+### rand_core
+- Updated to `rand_core` 0.5.0
+- `Error` type redesigned with new API (#800)
+- Move `from_entropy` method to `SeedableRng` and remove `FromEntropy` (#800)
+- `SeedableRng::from_rng` is now expected to be value-stable (#815)
+
+### Standard RNGs
+- OS interface moved from `rand_os` to new `getrandom` crate (#765, [getrandom](https://github.com/rust-random/getrandom))
+- Use ChaCha for `StdRng` and `ThreadRng` (#792)
+- Feature-gate `SmallRng` (#792)
+- `ThreadRng` now supports `Copy` (#758)
+- Deprecated `EntropyRng` (#765)
+- Enable fork protection of ReseedingRng without `std` (#724)
+
+### Distributions
+- Many distributions have been moved to `rand_distr` (#761)
+- `Bernoulli::new` constructor now returns a `Result` (#803)
+- `Distribution::sample_iter` adjusted for more flexibility (#758)
+- Added `distributions::weighted::alias_method::WeightedIndex` for `O(1)` sampling (#692)
+- Support sampling `NonZeroU*` types with the `Standard` distribution (#728)
+- Optimised `Binomial` distribution sampling (#735, #740, #752)
+- Optimised SIMD float sampling (#739)
+
+### Sequences
+- Make results portable across 32- and 64-bit by using `u32` samples for `usize` where possible (#809)
+
+## [0.6.5] - 2019-01-28
+### Crates
+- Update `rand_core` to 0.4 (#703)
+- Move `JitterRng` to its own crate (#685)
+- Add a wasm-bindgen test crate (#696)
+
+### Platforms
+- Fuchsia: Replaced fuchsia-zircon with fuchsia-cprng
+
+### Doc
+- Use RFC 1946 for doc links (#691)
+- Fix some doc links and notes (#711)
+
+## [0.6.4] - 2019-01-08
+### Fixes
+- Move wasm-bindgen shims to correct crate (#686)
+- Make `wasm32-unknown-unknown` compile but fail at run-time if missing bindingsg (#686)
+
+## [0.6.3] - 2019-01-04
+### Fixes
+- Make the `std` feature require the optional `rand_os` dependency (#675)
+- Re-export the optional WASM dependencies of `rand_os` from `rand` to avoid breakage (#674)
+
+## [0.6.2] - 2019-01-04
+### Additions
+- Add `Default` for `ThreadRng` (#657)
+- Move `rngs::OsRng` to `rand_os` sub-crate; clean up code; use as dependency (#643) ##BLOCKER##
+- Add `rand_xoshiro` sub-crate, plus benchmarks (#642, #668)
+
+### Fixes
+- Fix bias in `UniformInt::sample_single` (#662)
+- Use `autocfg` instead of `rustc_version` for rustc version detection (#664)
+- Disable `i128` and `u128` if the `target_os` is `emscripten` (#671: work-around Emscripten limitation)
+- CI fixes (#660, #671)
+
+### Optimisations
+- Optimise memory usage of `UnitCircle` and `UnitSphereSurface` distributions (no PR)
+
+## [0.6.1] - 2018-11-22
+- Support sampling `Duration` also for `no_std` (only since Rust 1.25) (#649)
+- Disable default features of `libc` (#647)
+
+## [0.6.0] - 2018-11-14
+
+### Project organisation
+- Rand has moved from [rust-lang-nursery](https://github.com/rust-lang-nursery/rand)
+  to [rust-random](https://github.com/rust-random/rand)! (#578)
+- Created [The Rust Random Book](https://rust-random.github.io/book/)
+  ([source](https://github.com/rust-random/book))
+- Update copyright and licence notices (#591, #611)
+- Migrate policy documentation from the wiki (#544)
+
+### Platforms
+- Add fork protection on Unix (#466)
+- Added support for wasm-bindgen. (#541, #559, #562, #600)
+- Enable `OsRng` for powerpc64, sparc and sparc64 (#609)
+- Use `syscall` from `libc` on Linux instead of redefining it (#629)
+
+### RNGs
+- Switch `SmallRng` to use PCG (#623)
+- Implement `Pcg32` and `Pcg64Mcg` generators (#632)
+- Move ISAAC RNGs to a dedicated crate (#551)
+- Move Xorshift RNG to its own crate (#557)
+- Move ChaCha and HC128 RNGs to dedicated crates (#607, #636)
+- Remove usage of `Rc` from `ThreadRng` (#615)
+
+### Sampling and distributions
+- Implement `Rng.gen_ratio()` and `Bernoulli::new_ratio()` (#491)
+- Make `Uniform` strictly respect `f32` / `f64` high/low bounds (#477)
+- Allow `gen_range` and `Uniform` to work on non-`Copy` types (#506)
+- `Uniform` supports inclusive ranges: `Uniform::from(a..=b)`. This is
+  automatically enabled for Rust >= 1.27. (#566)
+- Implement `TrustedLen` and `FusedIterator` for `DistIter` (#620)
+
+#### New distributions
+- Add the `Dirichlet` distribution (#485)
+- Added sampling from the unit sphere and circle. (#567)
+- Implement the triangular distribution (#575)
+- Implement the Weibull distribution (#576)
+- Implement the Beta distribution (#574)
+
+#### Optimisations
+
+- Optimise `Bernoulli::new` (#500)
+- Optimise `char` sampling (#519)
+- Optimise sampling of `std::time::Duration` (#583)
+
+### Sequences
+- Redesign the `seq` module (#483, #515)
+- Add `WeightedIndex` and `choose_weighted` (#518, #547)
+- Optimised and changed return type of the `sample_indices` function. (#479)
+- Use `Iterator::size_hint()` to speed up `IteratorRandom::choose` (#593)
+
+### SIMD
+- Support for generating SIMD types (#523, #542, #561, #630)
+
+### Other
+- Revise CI scripts (#632, #635)
+- Remove functionality already deprecated in 0.5 (#499)
+- Support for `i128` and `u128` is automatically enabled for Rust >= 1.26. This
+  renders the `i128_support` feature obsolete. It still exists for backwards
+  compatibility but does not have any effect. This breaks programs using Rand
+  with `i128_support` on nightlies older than Rust 1.26. (#571)
+
+
+## [0.5.5] - 2018-08-07
+### Documentation
+- Fix links in documentation (#582)
+
+
+## [0.5.4] - 2018-07-11
+### Platform support
+- Make `OsRng` work via WASM/stdweb for WebWorkers
+
+
+## [0.5.3] - 2018-06-26
+### Platform support
+- OpenBSD, Bitrig: fix compilation (broken in 0.5.1) (#530)
+
+
+## [0.5.2] - 2018-06-18
+### Platform support
+- Hide `OsRng` and `JitterRng` on unsupported platforms (#512; fixes #503).
+
+
+## [0.5.1] - 2018-06-08
+
+### New distributions
+- Added Cauchy distribution. (#474, #486)
+- Added Pareto distribution. (#495)
+
+### Platform support and `OsRng`
+- Remove blanket Unix implementation. (#484)
+- Remove Wasm unimplemented stub. (#484)
+- Dragonfly BSD: read from `/dev/random`. (#484)
+- Bitrig: use `getentropy` like OpenBSD. (#484)
+- Solaris: (untested) use `getrandom` if available, otherwise `/dev/random`. (#484)
+- Emscripten, `stdweb`: split the read up in chunks. (#484)
+- Emscripten, Haiku: don't do an extra blocking read from `/dev/random`. (#484)
+- Linux, NetBSD, Solaris: read in blocking mode on first use in `fill_bytes`. (#484)
+- Fuchsia, CloudABI: fix compilation (broken in Rand 0.5). (#484)
+
+
+## [0.5.0] - 2018-05-21
+
+### Crate features and organisation
+- Minimum Rust version update: 1.22.0. (#239)
+- Create a separate `rand_core` crate. (#288)
+- Deprecate `rand_derive`. (#256)
+- Add `prelude` (and module reorganisation). (#435)
+- Add `log` feature. Logging is now available in `JitterRng`, `OsRng`, `EntropyRng` and `ReseedingRng`. (#246)
+- Add `serde1` feature for some PRNGs. (#189)
+- `stdweb` feature for `OsRng` support on WASM via stdweb. (#272, #336)
+
+### `Rng` trait
+- Split `Rng` in `RngCore` and `Rng` extension trait.
+  `next_u32`, `next_u64` and `fill_bytes` are now part of `RngCore`. (#265)
+- Add `Rng::sample`. (#256)
+- Deprecate `Rng::gen_weighted_bool`. (#308)
+- Add `Rng::gen_bool`. (#308)
+- Remove `Rng::next_f32` and `Rng::next_f64`. (#273)
+- Add optimized `Rng::fill` and `Rng::try_fill` methods. (#247)
+- Deprecate `Rng::gen_iter`. (#286)
+- Deprecate `Rng::gen_ascii_chars`. (#279)
+
+### `rand_core` crate
+- `rand` now depends on new `rand_core` crate (#288)
+- `RngCore` and `SeedableRng` are now part of `rand_core`. (#288)
+- Add modules to help implementing RNGs `impl` and `le`. (#209, #228)
+- Add `Error` and `ErrorKind`. (#225)
+- Add `CryptoRng` marker trait. (#273)
+- Add `BlockRngCore` trait. (#281)
+- Add `BlockRng` and `BlockRng64` wrappers to help implementations. (#281, #325)
+- Revise the `SeedableRng` trait. (#233)
+- Remove default implementations for `RngCore::next_u64` and `RngCore::fill_bytes`. (#288)
+- Add `RngCore::try_fill_bytes`. (#225)
+
+### Other traits and types
+- Add `FromEntropy` trait. (#233, #375)
+- Add `SmallRng` wrapper. (#296)
+- Rewrite `ReseedingRng` to only work with `BlockRngCore` (substantial performance improvement). (#281)
+- Deprecate `weak_rng`. Use `SmallRng` instead. (#296)
+- Deprecate `AsciiGenerator`. (#279)
+
+### Random number generators
+- Switch `StdRng` and `thread_rng` to HC-128. (#277)
+- `StdRng` must now be created with `from_entropy` instead of `new`
+- Change `thread_rng` reseeding threshold to 32 MiB. (#277)
+- PRNGs no longer implement `Copy`. (#209)
+- `Debug` implementations no longer show internals. (#209)
+- Implement `Clone` for `ReseedingRng`, `JitterRng`, OsRng`. (#383, #384)
+- Implement serialization for `XorShiftRng`, `IsaacRng` and `Isaac64Rng` under the `serde1` feature. (#189)
+- Implement `BlockRngCore` for `ChaChaCore` and `Hc128Core`. (#281)
+- All PRNGs are now portable across big- and little-endian architectures. (#209)
+- `Isaac64Rng::next_u32` no longer throws away half the results. (#209)
+- Add `IsaacRng::new_from_u64` and `Isaac64Rng::new_from_u64`. (#209)
+- Add the HC-128 CSPRNG `Hc128Rng`. (#210)
+- Change ChaCha20 to have 64-bit counter and 64-bit stream. (#349)
+- Changes to `JitterRng` to get its size down from 2112 to 24 bytes. (#251)
+- Various performance improvements to all PRNGs.
+
+### Platform support and `OsRng`
+- Add support for CloudABI. (#224)
+- Remove support for NaCl. (#225)
+- WASM support for `OsRng` via stdweb, behind the `stdweb` feature. (#272, #336)
+- Use `getrandom` on more platforms for Linux, and on Android. (#338)
+- Use the `SecRandomCopyBytes` interface on macOS. (#322)
+- On systems that do not have a syscall interface, only keep a single file descriptor open for `OsRng`. (#239)
+- On Unix, first try a single read from `/dev/random`, then `/dev/urandom`. (#338)
+- Better error handling and reporting in `OsRng` (using new error type). (#225)
+- `OsRng` now uses non-blocking when available. (#225)
+- Add `EntropyRng`, which provides `OsRng`, but has `JitterRng` as a fallback. (#235)
+
+### Distributions
+- New `Distribution` trait. (#256)
+- Add `Distribution::sample_iter` and `Rng::::sample_iter`. (#361)
+- Deprecate `Rand`, `Sample` and `IndependentSample` traits. (#256)
+- Add a `Standard` distribution (replaces most `Rand` implementations). (#256)
+- Add `Binomial` and `Poisson` distributions. (#96)
+- Add `Bernoulli` dsitribution. (#411)
+- Add `Alphanumeric` distribution. (#279)
+- Remove `Closed01` distribution, add `OpenClosed01`. (#274, #420)
+- Rework `Range` type, making it possible to implement it for user types. (#274)
+- Rename `Range` to `Uniform`. (#395)
+- Add `Uniform::new_inclusive` for inclusive ranges. (#274)
+- Use widening multiply method for much faster integer range reduction. (#274)
+- `Standard` distribution for `char` uses `Uniform` internally. (#274)
+- `Standard` distribution for `bool` uses sign test. (#274)
+- Implement `Standard` distribution for `Wrapping<T>`. (#436)
+- Implement `Uniform` distribution for `Duration`. (#427)
+
+
+## [0.4.3] - 2018-08-16
+### Fixed
+- Use correct syscall number for PowerPC (#589)
+
+
+## [0.4.2] - 2018-01-06
+### Changed
+- Use `winapi` on Windows
+- Update for Fuchsia OS
+- Remove dev-dependency on `log`
+
+
+## [0.4.1] - 2017-12-17
+### Added
+- `no_std` support
+
+
+## [0.4.0-pre.0] - 2017-12-11
+### Added
+- `JitterRng` added as a high-quality alternative entropy source using the
+  system timer
+- new `seq` module with `sample_iter`, `sample_slice`, etc.
+- WASM support via dummy implementations (fail at run-time)
+- Additional benchmarks, covering generators and new seq code
+
+### Changed
+- `thread_rng` uses `JitterRng` if seeding from system time fails
+  (slower but more secure than previous method)
+
+### Deprecated
+  - `sample` function deprecated (replaced by `sample_iter`)
+
+
+## [0.3.20] - 2018-01-06
+### Changed
+- Remove dev-dependency on `log`
+- Update `fuchsia-zircon` dependency to 0.3.2
+
+
+## [0.3.19] - 2017-12-27
+### Changed
+- Require `log <= 0.3.8` for dev builds
+- Update `fuchsia-zircon` dependency to 0.3
+- Fix broken links in docs (to unblock compiler docs testing CI)
+
+
+## [0.3.18] - 2017-11-06
+### Changed
+- `thread_rng` is seeded from the system time if `OsRng` fails
+- `weak_rng` now uses `thread_rng` internally
+
+
+## [0.3.17] - 2017-10-07
+### Changed
+ - Fuchsia: Magenta was renamed Zircon
+
+## [0.3.16] - 2017-07-27
+### Added
+- Implement Debug for mote non-public types
+- implement `Rand` for (i|u)i128
+- Support for Fuchsia
+
+### Changed
+- Add inline attribute to SampleRange::construct_range.
+  This improves the benchmark for sample in 11% and for shuffle in 16%.
+- Use `RtlGenRandom` instead of `CryptGenRandom`
+
+
+## [0.3.15] - 2016-11-26
+### Added
+- Add `Rng` trait method `choose_mut`
+- Redox support
+
+### Changed
+- Use `arc4rand` for `OsRng` on FreeBSD.
+- Use `arc4random(3)` for `OsRng` on OpenBSD.
+
+### Fixed
+- Fix filling buffers 4 GiB or larger with `OsRng::fill_bytes` on Windows
+
+
+## [0.3.14] - 2016-02-13
+### Fixed
+- Inline definitions from winapi/advapi32, which decreases build times
+
+
+## [0.3.13] - 2016-01-09
+### Fixed
+- Compatible with Rust 1.7.0-nightly (needed some extra type annotations)
+
+
+## [0.3.12] - 2015-11-09
+### Changed
+- Replaced the methods in `next_f32` and `next_f64` with the technique described
+  Saito & Matsumoto at MCQMC'08. The new method should exhibit a slightly more
+  uniform distribution.
+- Depend on libc 0.2
+
+### Fixed
+- Fix iterator protocol issue in `rand::sample`
+
+
+## [0.3.11] - 2015-08-31
+### Added
+- Implement `Rand` for arrays with n <= 32
+
+
+## [0.3.10] - 2015-08-17
+### Added
+- Support for NaCl platforms
+
+### Changed
+- Allow `Rng` to be `?Sized`, impl for `&mut R` and `Box<R>` where `R: ?Sized + Rng`
+
+
+## [0.3.9] - 2015-06-18
+### Changed
+- Use `winapi` for Windows API things
+
+### Fixed
+- Fixed test on stable/nightly
+- Fix `getrandom` syscall number for aarch64-unknown-linux-gnu
+
+
+## [0.3.8] - 2015-04-23
+### Changed
+- `log` is a dev dependency
+
+### Fixed
+- Fix race condition of atomics in `is_getrandom_available`
+
+
+## [0.3.7] - 2015-04-03
+### Fixed
+- Derive Copy/Clone changes
+
+
+## [0.3.6] - 2015-04-02
+### Changed
+- Move to stable Rust!
+
+
+## [0.3.5] - 2015-04-01
+### Fixed
+- Compatible with Rust master
+
+
+## [0.3.4] - 2015-03-31
+### Added
+- Implement Clone for `Weighted`
+
+### Fixed
+- Compatible with Rust master
+
+
+## [0.3.3] - 2015-03-26
+### Fixed
+- Fix compile on Windows
+
+
+## [0.3.2] - 2015-03-26
+
+
+## [0.3.1] - 2015-03-26
+### Fixed
+- Fix compile on Windows
+
+
+## [0.3.0] - 2015-03-25
+### Changed
+- Update to use log version 0.3.x
+
+
+## [0.2.1] - 2015-03-22
+### Fixed
+- Compatible with Rust master
+- Fixed iOS compilation
+
+
+## [0.2.0] - 2015-03-06
+### Fixed
+- Compatible with Rust master (move from `old_io` to `std::io`)
+
+
+## [0.1.4] - 2015-03-04
+### Fixed
+- Compatible with Rust master (use wrapping ops)
+
+
+## [0.1.3] - 2015-02-20
+### Fixed
+- Compatible with Rust master
+
+### Removed
+- Removed Copy implementations from RNGs
+
+
+## [0.1.2] - 2015-02-03
+### Added
+- Imported functionality from `std::rand`, including:
+  - `StdRng`, `SeedableRng`, `TreadRng`, `weak_rng()`
+  - `ReaderRng`: A wrapper around any Reader to treat it as an RNG.
+- Imported documentation from `std::rand`
+- Imported tests from `std::rand`
+
+
+## [0.1.1] - 2015-02-03
+### Added
+- Migrate to a cargo-compatible directory structure.
+
+### Fixed
+- Do not use entropy during `gen_weighted_bool(1)`
+
+
+## [Rust 0.12.0] - 2014-10-09
+### Added
+- Impl Rand for tuples of arity 11 and 12
+- Include ChaCha pseudorandom generator
+- Add `next_f64` and `next_f32` to Rng
+- Implement Clone for PRNGs
+
+### Changed
+- Rename `TaskRng` to `ThreadRng` and `task_rng` to `thread_rng` (since a
+  runtime is removed from Rust).
+
+### Fixed
+- Improved performance of ISAAC and ISAAC64 by 30% and 12 % respectively, by
+  informing the optimiser that indexing is never out-of-bounds.
+
+### Removed
+- Removed the Deprecated `choose_option`
+
+
+## [Rust 0.11.0] - 2014-07-02
+### Added
+- document when to use `OSRng` in cryptographic context, and explain why we use `/dev/urandom` instead of `/dev/random`
+- `Rng::gen_iter()` which will return an infinite stream of random values
+- `Rng::gen_ascii_chars()` which will return an infinite stream of random ascii characters
+
+### Changed
+- Now only depends on libcore!
+- Remove `Rng.choose()`, rename `Rng.choose_option()` to `.choose()`
+- Rename OSRng to OsRng
+- The WeightedChoice structure is no longer built with a `Vec<Weighted<T>>`,
+  but rather a `&mut [Weighted<T>]`. This means that the WeightedChoice
+  structure now has a lifetime associated with it.
+- The `sample` method on `Rng` has been moved to a top-level function in the
+  `rand` module due to its dependence on `Vec`.
+
+### Removed
+- `Rng::gen_vec()` was removed. Previous behavior can be regained with
+  `rng.gen_iter().take(n).collect()`
+- `Rng::gen_ascii_str()` was removed. Previous behavior can be regained with
+  `rng.gen_ascii_chars().take(n).collect()`
+- {IsaacRng, Isaac64Rng, XorShiftRng}::new() have all been removed. These all
+  relied on being able to use an OSRng for seeding, but this is no longer
+  available in librand (where these types are defined). To retain the same
+  functionality, these types now implement the `Rand` trait so they can be
+  generated with a random seed from another random number generator. This allows
+  the stdlib to use an OSRng to create seeded instances of these RNGs.
+- Rand implementations for `Box<T>` and `@T` were removed. These seemed to be
+  pretty rare in the codebase, and it allows for librand to not depend on
+  liballoc.  Additionally, other pointer types like Rc<T> and Arc<T> were not
+  supported.
+- Remove a slew of old deprecated functions
+
+
+## [Rust 0.10] - 2014-04-03
+### Changed
+- replace `Rng.shuffle's` functionality with `.shuffle_mut`
+- bubble up IO errors when creating an OSRng
+
+### Fixed
+- Use `fill()` instead of `read()`
+- Rewrite OsRng in Rust for windows
+
+## [0.10-pre] - 2014-03-02
+### Added
+- Separate `rand` out of the standard library
diff --git a/crates/rand/COPYRIGHT b/crates/rand/COPYRIGHT
new file mode 100644
index 0000000..468d907
--- /dev/null
+++ b/crates/rand/COPYRIGHT
@@ -0,0 +1,12 @@
+Copyrights in the Rand project are retained by their contributors. No
+copyright assignment is required to contribute to the Rand project.
+
+For full authorship information, see the version control history.
+
+Except as otherwise noted (below and/or in individual files), Rand is
+licensed under the Apache License, Version 2.0 <LICENSE-APACHE> or
+<http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+<LICENSE-MIT> or <http://opensource.org/licenses/MIT>, at your option.
+
+The Rand project includes code from the Rust project
+published under these same licenses.
diff --git a/crates/rand/Cargo.lock b/crates/rand/Cargo.lock
new file mode 100644
index 0000000..ad031fa
--- /dev/null
+++ b/crates/rand/Cargo.lock
@@ -0,0 +1,197 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "bincode"
+version = "1.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "getrandom"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.158"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439"
+
+[[package]]
+name = "libm"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fc7aa29613bd6a620df431842069224d8bc9011086b1db4c0e0cd47fa03ec9a"
+
+[[package]]
+name = "log"
+version = "0.4.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
+
+[[package]]
+name = "packed_simd_2"
+version = "0.3.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1914cd452d8fccd6f9db48147b29fd4ae05bea9dc5d9ad578509f72415de282"
+dependencies = [
+ "cfg-if",
+ "libm",
+]
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.86"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+dependencies = [
+ "bincode",
+ "libc",
+ "log",
+ "packed_simd_2",
+ "rand_chacha",
+ "rand_core",
+ "rand_pcg",
+ "serde",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom",
+ "serde",
+]
+
+[[package]]
+name = "rand_pcg"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59cad018caf63deb318e5a4586d99a24424a364f40f1e5778c29aca23f4fc73e"
+dependencies = [
+ "rand_core",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.209"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "99fce0ffe7310761ca6bf9faf5115afbc19688edd00171d81b1bb1b116c63e09"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.209"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5831b979fd7b5439637af1752d535ff49f4860c0f341d1baeb6faf0f4242170"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.76"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "578e081a14e0cefc3279b0472138c513f37b41a08d5a3cca9b6e4e8ceb6cd525"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
+
+[[package]]
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+
+[[package]]
+name = "zerocopy"
+version = "0.7.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
+dependencies = [
+ "byteorder",
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.7.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
diff --git a/crates/rand/Cargo.toml b/crates/rand/Cargo.toml
new file mode 100644
index 0000000..3f38081
--- /dev/null
+++ b/crates/rand/Cargo.toml
@@ -0,0 +1,75 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2018"
+name = "rand"
+version = "0.8.5"
+authors = ["The Rand Project Developers", "The Rust Project Developers"]
+include = ["src/", "LICENSE-*", "README.md", "CHANGELOG.md", "COPYRIGHT"]
+autobenches = true
+description = "Random number generators and other randomness functionality.\n"
+homepage = "https://rust-random.github.io/book"
+documentation = "https://docs.rs/rand"
+readme = "README.md"
+keywords = ["random", "rng"]
+categories = ["algorithms", "no-std"]
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/rust-random/rand"
+[package.metadata.docs.rs]
+all-features = true
+rustdoc-args = ["--cfg", "doc_cfg"]
+
+[package.metadata.playground]
+features = ["small_rng", "serde1"]
+[dependencies.log]
+version = "0.4.4"
+optional = true
+
+[dependencies.packed_simd]
+version = "0.3.7"
+features = ["into_bits"]
+optional = true
+package = "packed_simd_2"
+
+[dependencies.rand_chacha]
+version = "0.3.0"
+optional = true
+default-features = false
+
+[dependencies.rand_core]
+version = "0.6.0"
+
+[dependencies.serde]
+version = "1.0.103"
+features = ["derive"]
+optional = true
+[dev-dependencies.bincode]
+version = "1.2.1"
+
+[dev-dependencies.rand_pcg]
+version = "0.3.0"
+
+[features]
+alloc = ["rand_core/alloc"]
+default = ["std", "std_rng"]
+getrandom = ["rand_core/getrandom"]
+min_const_gen = []
+nightly = []
+serde1 = ["serde", "rand_core/serde1"]
+simd_support = ["packed_simd"]
+small_rng = []
+std = ["rand_core/std", "rand_chacha/std", "alloc", "getrandom", "libc"]
+std_rng = ["rand_chacha"]
+[target."cfg(unix)".dependencies.libc]
+version = "0.2.22"
+optional = true
+default-features = false
diff --git a/crates/rand/LICENSE b/crates/rand/LICENSE
new file mode 120000
index 0000000..6b579aa
--- /dev/null
+++ b/crates/rand/LICENSE
@@ -0,0 +1 @@
+LICENSE-APACHE
\ No newline at end of file
diff --git a/crates/rand/LICENSE-APACHE b/crates/rand/LICENSE-APACHE
new file mode 100644
index 0000000..494ad3b
--- /dev/null
+++ b/crates/rand/LICENSE-APACHE
@@ -0,0 +1,176 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     https://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
diff --git a/crates/rand/LICENSE-MIT b/crates/rand/LICENSE-MIT
new file mode 100644
index 0000000..d93b5ba
--- /dev/null
+++ b/crates/rand/LICENSE-MIT
@@ -0,0 +1,26 @@
+Copyright 2018 Developers of the Rand project
+Copyright (c) 2014 The Rust Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/crates/rand/METADATA b/crates/rand/METADATA
new file mode 100644
index 0000000..2449ce5
--- /dev/null
+++ b/crates/rand/METADATA
@@ -0,0 +1,19 @@
+name: "rand"
+description: "Random number generators and other randomness functionality."
+third_party {
+  url {
+    type: HOMEPAGE
+    value: "https://crates.io/crates/rand"
+  }
+  url {
+    type: ARCHIVE
+    value: "https://static.crates.io/crates/rand/rand-0.8.5.crate"
+  }
+  version: "0.8.5"
+  license_type: NOTICE
+  last_upgrade_date {
+    year: 2022
+    month: 3
+    day: 1
+  }
+}
diff --git a/crates/rand/MODULE_LICENSE_APACHE2 b/crates/rand/MODULE_LICENSE_APACHE2
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/crates/rand/MODULE_LICENSE_APACHE2
diff --git a/crates/rand/README.md b/crates/rand/README.md
new file mode 100644
index 0000000..44c2e4d
--- /dev/null
+++ b/crates/rand/README.md
@@ -0,0 +1,158 @@
+# Rand
+
+[![Test Status](https://github.com/rust-random/rand/workflows/Tests/badge.svg?event=push)](https://github.com/rust-random/rand/actions)
+[![Crate](https://img.shields.io/crates/v/rand.svg)](https://crates.io/crates/rand)
+[![Book](https://img.shields.io/badge/book-master-yellow.svg)](https://rust-random.github.io/book/)
+[![API](https://img.shields.io/badge/api-master-yellow.svg)](https://rust-random.github.io/rand/rand)
+[![API](https://docs.rs/rand/badge.svg)](https://docs.rs/rand)
+[![Minimum rustc version](https://img.shields.io/badge/rustc-1.36+-lightgray.svg)](https://github.com/rust-random/rand#rust-version-requirements)
+
+A Rust library for random number generation, featuring:
+
+-   Easy random value generation and usage via the [`Rng`](https://docs.rs/rand/*/rand/trait.Rng.html),
+    [`SliceRandom`](https://docs.rs/rand/*/rand/seq/trait.SliceRandom.html) and
+    [`IteratorRandom`](https://docs.rs/rand/*/rand/seq/trait.IteratorRandom.html) traits
+-   Secure seeding via the [`getrandom` crate](https://crates.io/crates/getrandom)
+    and fast, convenient generation via [`thread_rng`](https://docs.rs/rand/*/rand/fn.thread_rng.html)
+-   A modular design built over [`rand_core`](https://crates.io/crates/rand_core)
+    ([see the book](https://rust-random.github.io/book/crates.html))
+-   Fast implementations of the best-in-class [cryptographic](https://rust-random.github.io/book/guide-rngs.html#cryptographically-secure-pseudo-random-number-generators-csprngs) and
+    [non-cryptographic](https://rust-random.github.io/book/guide-rngs.html#basic-pseudo-random-number-generators-prngs) generators
+-   A flexible [`distributions`](https://docs.rs/rand/*/rand/distributions/index.html) module
+-   Samplers for a large number of random number distributions via our own
+    [`rand_distr`](https://docs.rs/rand_distr) and via
+    the [`statrs`](https://docs.rs/statrs/0.13.0/statrs/)
+-   [Portably reproducible output](https://rust-random.github.io/book/portability.html)
+-   `#[no_std]` compatibility (partial)
+-   *Many* performance optimisations
+
+It's also worth pointing out what `rand` *is not*:
+
+-   Small. Most low-level crates are small, but the higher-level `rand` and
+    `rand_distr` each contain a lot of functionality.
+-   Simple (implementation). We have a strong focus on correctness, speed and flexibility, but
+    not simplicity. If you prefer a small-and-simple library, there are
+    alternatives including [fastrand](https://crates.io/crates/fastrand)
+    and [oorandom](https://crates.io/crates/oorandom).
+-   Slow. We take performance seriously, with considerations also for set-up
+    time of new distributions, commonly-used parameters, and parameters of the
+    current sampler.
+
+Documentation:
+
+-   [The Rust Rand Book](https://rust-random.github.io/book)
+-   [API reference (master branch)](https://rust-random.github.io/rand)
+-   [API reference (docs.rs)](https://docs.rs/rand)
+
+
+## Usage
+
+Add this to your `Cargo.toml`:
+
+```toml
+[dependencies]
+rand = "0.8.4"
+```
+
+To get started using Rand, see [The Book](https://rust-random.github.io/book).
+
+
+## Versions
+
+Rand is *mature* (suitable for general usage, with infrequent breaking releases
+which minimise breakage) but not yet at 1.0. We maintain compatibility with
+pinned versions of the Rust compiler (see below).
+
+Current Rand versions are:
+
+-   Version 0.7 was released in June 2019, moving most non-uniform distributions
+    to an external crate, moving `from_entropy` to `SeedableRng`, and many small
+    changes and fixes.
+-   Version 0.8 was released in December 2020 with many small changes.
+
+A detailed [changelog](CHANGELOG.md) is available for releases.
+
+When upgrading to the next minor series (especially 0.4 → 0.5), we recommend
+reading the [Upgrade Guide](https://rust-random.github.io/book/update.html).
+
+Rand has not yet reached 1.0 implying some breaking changes may arrive in the
+future ([SemVer](https://semver.org/) allows each 0.x.0 release to include
+breaking changes), but is considered *mature*: breaking changes are minimised
+and breaking releases are infrequent.
+
+Rand libs have inter-dependencies and make use of the
+[semver trick](https://github.com/dtolnay/semver-trick/) in order to make traits
+compatible across crate versions. (This is especially important for `RngCore`
+and `SeedableRng`.) A few crate releases are thus compatibility shims,
+depending on the *next* lib version (e.g. `rand_core` versions `0.2.2` and
+`0.3.1`). This means, for example, that `rand_core_0_4_0::SeedableRng` and
+`rand_core_0_3_0::SeedableRng` are distinct, incompatible traits, which can
+cause build errors. Usually, running `cargo update` is enough to fix any issues.
+
+### Yanked versions
+
+Some versions of Rand crates have been yanked ("unreleased"). Where this occurs,
+the crate's CHANGELOG *should* be updated with a rationale, and a search on the
+issue tracker with the keyword `yank` *should* uncover the motivation.
+
+### Rust version requirements
+
+Since version 0.8, Rand requires **Rustc version 1.36 or greater**.
+Rand 0.7 requires Rustc 1.32 or greater while versions 0.5 require Rustc 1.22 or
+greater, and 0.4 and 0.3 (since approx. June 2017) require Rustc version 1.15 or
+greater. Subsets of the Rand code may work with older Rust versions, but this is
+not supported.
+
+Continuous Integration (CI) will always test the minimum supported Rustc version
+(the MSRV). The current policy is that this can be updated in any
+Rand release if required, but the change must be noted in the changelog.
+
+## Crate Features
+
+Rand is built with these features enabled by default:
+
+-   `std` enables functionality dependent on the `std` lib
+-   `alloc` (implied by `std`) enables functionality requiring an allocator
+-   `getrandom` (implied by `std`) is an optional dependency providing the code
+    behind `rngs::OsRng`
+-   `std_rng` enables inclusion of `StdRng`, `thread_rng` and `random`
+    (the latter two *also* require that `std` be enabled)
+
+Optionally, the following dependencies can be enabled:
+
+-   `log` enables logging via the `log` crate
+
+Additionally, these features configure Rand:
+
+-   `small_rng` enables inclusion of the `SmallRng` PRNG
+-   `nightly` enables some optimizations requiring nightly Rust
+-   `simd_support` (experimental) enables sampling of SIMD values
+    (uniformly random SIMD integers and floats), requiring nightly Rust
+-   `min_const_gen` enables generating random arrays of 
+    any size using min-const-generics, requiring Rust ≥ 1.51.
+
+Note that nightly features are not stable and therefore not all library and
+compiler versions will be compatible. This is especially true of Rand's
+experimental `simd_support` feature.
+
+Rand supports limited functionality in `no_std` mode (enabled via
+`default-features = false`). In this case, `OsRng` and `from_entropy` are
+unavailable (unless `getrandom` is enabled), large parts of `seq` are
+unavailable (unless `alloc` is enabled), and `thread_rng` and `random` are
+unavailable.
+
+### WASM support
+
+The WASM target `wasm32-unknown-unknown` is not *automatically* supported by
+`rand` or `getrandom`. To solve this, either use a different target such as
+`wasm32-wasi` or add a direct dependency on `getrandom` with the `js` feature
+(if the target supports JavaScript). See
+[getrandom#WebAssembly support](https://docs.rs/getrandom/latest/getrandom/#webassembly-support).
+
+# License
+
+Rand is distributed under the terms of both the MIT license and the
+Apache License (Version 2.0).
+
+See [LICENSE-APACHE](LICENSE-APACHE) and [LICENSE-MIT](LICENSE-MIT), and
+[COPYRIGHT](COPYRIGHT) for details.
diff --git a/crates/rand/TEST_MAPPING b/crates/rand/TEST_MAPPING
new file mode 100644
index 0000000..836f9e6
--- /dev/null
+++ b/crates/rand/TEST_MAPPING
@@ -0,0 +1,83 @@
+// Generated by update_crate_tests.py for tests that depend on this crate.
+{
+  "imports": [
+    {
+      "path": "external/rust/crates/base64"
+    },
+    {
+      "path": "external/rust/crates/cast"
+    },
+    {
+      "path": "external/rust/crates/crc32fast"
+    },
+    {
+      "path": "external/rust/crates/crossbeam-deque"
+    },
+    {
+      "path": "external/rust/crates/crossbeam-epoch"
+    },
+    {
+      "path": "external/rust/crates/crossbeam-queue"
+    },
+    {
+      "path": "external/rust/crates/crossbeam-utils"
+    },
+    {
+      "path": "external/rust/crates/flate2"
+    },
+    {
+      "path": "external/rust/crates/hashbrown"
+    },
+    {
+      "path": "external/rust/crates/mio"
+    },
+    {
+      "path": "external/rust/crates/quickcheck"
+    },
+    {
+      "path": "external/rust/crates/regex"
+    },
+    {
+      "path": "external/rust/crates/ryu"
+    },
+    {
+      "path": "external/rust/crates/tokio"
+    },
+    {
+      "path": "external/rust/crates/zerocopy"
+    },
+    {
+      "path": "external/uwb/src"
+    },
+    {
+      "path": "packages/modules/Virtualization/apkdmverity"
+    },
+    {
+      "path": "packages/modules/Virtualization/authfs"
+    },
+    {
+      "path": "packages/modules/Virtualization/avmd"
+    },
+    {
+      "path": "packages/modules/Virtualization/libs/devicemapper"
+    },
+    {
+      "path": "packages/modules/Virtualization/microdroid_manager"
+    },
+    {
+      "path": "packages/modules/Virtualization/virtualizationmanager"
+    },
+    {
+      "path": "packages/modules/Virtualization/vm"
+    },
+    {
+      "path": "packages/modules/Virtualization/zipfuse"
+    },
+    {
+      "path": "system/security/keystore2"
+    },
+    {
+      "path": "system/security/keystore2/legacykeystore"
+    }
+  ]
+}
diff --git a/crates/rand/cargo_embargo.json b/crates/rand/cargo_embargo.json
new file mode 100644
index 0000000..957e0e9
--- /dev/null
+++ b/crates/rand/cargo_embargo.json
@@ -0,0 +1,7 @@
+{
+  "features": [
+    "default",
+    "small_rng"
+  ],
+  "run_cargo": false
+}
diff --git a/crates/rand/src/distributions/bernoulli.rs b/crates/rand/src/distributions/bernoulli.rs
new file mode 100644
index 0000000..226db79
--- /dev/null
+++ b/crates/rand/src/distributions/bernoulli.rs
@@ -0,0 +1,219 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! The Bernoulli distribution.
+
+use crate::distributions::Distribution;
+use crate::Rng;
+use core::{fmt, u64};
+
+#[cfg(feature = "serde1")]
+use serde::{Serialize, Deserialize};
+/// The Bernoulli distribution.
+///
+/// This is a special case of the Binomial distribution where `n = 1`.
+///
+/// # Example
+///
+/// ```rust
+/// use rand::distributions::{Bernoulli, Distribution};
+///
+/// let d = Bernoulli::new(0.3).unwrap();
+/// let v = d.sample(&mut rand::thread_rng());
+/// println!("{} is from a Bernoulli distribution", v);
+/// ```
+///
+/// # Precision
+///
+/// This `Bernoulli` distribution uses 64 bits from the RNG (a `u64`),
+/// so only probabilities that are multiples of 2<sup>-64</sup> can be
+/// represented.
+#[derive(Clone, Copy, Debug, PartialEq)]
+#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
+pub struct Bernoulli {
+    /// Probability of success, relative to the maximal integer.
+    p_int: u64,
+}
+
+// To sample from the Bernoulli distribution we use a method that compares a
+// random `u64` value `v < (p * 2^64)`.
+//
+// If `p == 1.0`, the integer `v` to compare against can not represented as a
+// `u64`. We manually set it to `u64::MAX` instead (2^64 - 1 instead of 2^64).
+// Note that  value of `p < 1.0` can never result in `u64::MAX`, because an
+// `f64` only has 53 bits of precision, and the next largest value of `p` will
+// result in `2^64 - 2048`.
+//
+// Also there is a 100% theoretical concern: if someone consistently wants to
+// generate `true` using the Bernoulli distribution (i.e. by using a probability
+// of `1.0`), just using `u64::MAX` is not enough. On average it would return
+// false once every 2^64 iterations. Some people apparently care about this
+// case.
+//
+// That is why we special-case `u64::MAX` to always return `true`, without using
+// the RNG, and pay the performance price for all uses that *are* reasonable.
+// Luckily, if `new()` and `sample` are close, the compiler can optimize out the
+// extra check.
+const ALWAYS_TRUE: u64 = u64::MAX;
+
+// This is just `2.0.powi(64)`, but written this way because it is not available
+// in `no_std` mode.
+const SCALE: f64 = 2.0 * (1u64 << 63) as f64;
+
+/// Error type returned from `Bernoulli::new`.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum BernoulliError {
+    /// `p < 0` or `p > 1`.
+    InvalidProbability,
+}
+
+impl fmt::Display for BernoulliError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(match self {
+            BernoulliError::InvalidProbability => "p is outside [0, 1] in Bernoulli distribution",
+        })
+    }
+}
+
+#[cfg(feature = "std")]
+impl ::std::error::Error for BernoulliError {}
+
+impl Bernoulli {
+    /// Construct a new `Bernoulli` with the given probability of success `p`.
+    ///
+    /// # Precision
+    ///
+    /// For `p = 1.0`, the resulting distribution will always generate true.
+    /// For `p = 0.0`, the resulting distribution will always generate false.
+    ///
+    /// This method is accurate for any input `p` in the range `[0, 1]` which is
+    /// a multiple of 2<sup>-64</sup>. (Note that not all multiples of
+    /// 2<sup>-64</sup> in `[0, 1]` can be represented as a `f64`.)
+    #[inline]
+    pub fn new(p: f64) -> Result<Bernoulli, BernoulliError> {
+        if !(0.0..1.0).contains(&p) {
+            if p == 1.0 {
+                return Ok(Bernoulli { p_int: ALWAYS_TRUE });
+            }
+            return Err(BernoulliError::InvalidProbability);
+        }
+        Ok(Bernoulli {
+            p_int: (p * SCALE) as u64,
+        })
+    }
+
+    /// Construct a new `Bernoulli` with the probability of success of
+    /// `numerator`-in-`denominator`. I.e. `new_ratio(2, 3)` will return
+    /// a `Bernoulli` with a 2-in-3 chance, or about 67%, of returning `true`.
+    ///
+    /// return `true`. If `numerator == 0` it will always return `false`.
+    /// For `numerator > denominator` and `denominator == 0`, this returns an
+    /// error. Otherwise, for `numerator == denominator`, samples are always
+    /// true; for `numerator == 0` samples are always false.
+    #[inline]
+    pub fn from_ratio(numerator: u32, denominator: u32) -> Result<Bernoulli, BernoulliError> {
+        if numerator > denominator || denominator == 0 {
+            return Err(BernoulliError::InvalidProbability);
+        }
+        if numerator == denominator {
+            return Ok(Bernoulli { p_int: ALWAYS_TRUE });
+        }
+        let p_int = ((f64::from(numerator) / f64::from(denominator)) * SCALE) as u64;
+        Ok(Bernoulli { p_int })
+    }
+}
+
+impl Distribution<bool> for Bernoulli {
+    #[inline]
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> bool {
+        // Make sure to always return true for p = 1.0.
+        if self.p_int == ALWAYS_TRUE {
+            return true;
+        }
+        let v: u64 = rng.gen();
+        v < self.p_int
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::Bernoulli;
+    use crate::distributions::Distribution;
+    use crate::Rng;
+
+    #[test]
+    #[cfg(feature="serde1")]
+    fn test_serializing_deserializing_bernoulli() {
+        let coin_flip = Bernoulli::new(0.5).unwrap();
+        let de_coin_flip : Bernoulli = bincode::deserialize(&bincode::serialize(&coin_flip).unwrap()).unwrap();
+
+        assert_eq!(coin_flip.p_int, de_coin_flip.p_int);
+    }
+
+    #[test]
+    fn test_trivial() {
+        // We prefer to be explicit here.
+        #![allow(clippy::bool_assert_comparison)]
+
+        let mut r = crate::test::rng(1);
+        let always_false = Bernoulli::new(0.0).unwrap();
+        let always_true = Bernoulli::new(1.0).unwrap();
+        for _ in 0..5 {
+            assert_eq!(r.sample::<bool, _>(&always_false), false);
+            assert_eq!(r.sample::<bool, _>(&always_true), true);
+            assert_eq!(Distribution::<bool>::sample(&always_false, &mut r), false);
+            assert_eq!(Distribution::<bool>::sample(&always_true, &mut r), true);
+        }
+    }
+
+    #[test]
+    #[cfg_attr(miri, ignore)] // Miri is too slow
+    fn test_average() {
+        const P: f64 = 0.3;
+        const NUM: u32 = 3;
+        const DENOM: u32 = 10;
+        let d1 = Bernoulli::new(P).unwrap();
+        let d2 = Bernoulli::from_ratio(NUM, DENOM).unwrap();
+        const N: u32 = 100_000;
+
+        let mut sum1: u32 = 0;
+        let mut sum2: u32 = 0;
+        let mut rng = crate::test::rng(2);
+        for _ in 0..N {
+            if d1.sample(&mut rng) {
+                sum1 += 1;
+            }
+            if d2.sample(&mut rng) {
+                sum2 += 1;
+            }
+        }
+        let avg1 = (sum1 as f64) / (N as f64);
+        assert!((avg1 - P).abs() < 5e-3);
+
+        let avg2 = (sum2 as f64) / (N as f64);
+        assert!((avg2 - (NUM as f64) / (DENOM as f64)).abs() < 5e-3);
+    }
+
+    #[test]
+    fn value_stability() {
+        let mut rng = crate::test::rng(3);
+        let distr = Bernoulli::new(0.4532).unwrap();
+        let mut buf = [false; 10];
+        for x in &mut buf {
+            *x = rng.sample(&distr);
+        }
+        assert_eq!(buf, [
+            true, false, false, true, false, false, true, true, true, true
+        ]);
+    }
+
+    #[test]
+    fn bernoulli_distributions_can_be_compared() {
+        assert_eq!(Bernoulli::new(1.0), Bernoulli::new(1.0));
+    }
+}
diff --git a/crates/rand/src/distributions/distribution.rs b/crates/rand/src/distributions/distribution.rs
new file mode 100644
index 0000000..c5cf6a6
--- /dev/null
+++ b/crates/rand/src/distributions/distribution.rs
@@ -0,0 +1,272 @@
+// Copyright 2018 Developers of the Rand project.
+// Copyright 2013-2017 The Rust Project Developers.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Distribution trait and associates
+
+use crate::Rng;
+use core::iter;
+#[cfg(feature = "alloc")]
+use alloc::string::String;
+
+/// Types (distributions) that can be used to create a random instance of `T`.
+///
+/// It is possible to sample from a distribution through both the
+/// `Distribution` and [`Rng`] traits, via `distr.sample(&mut rng)` and
+/// `rng.sample(distr)`. They also both offer the [`sample_iter`] method, which
+/// produces an iterator that samples from the distribution.
+///
+/// All implementations are expected to be immutable; this has the significant
+/// advantage of not needing to consider thread safety, and for most
+/// distributions efficient state-less sampling algorithms are available.
+///
+/// Implementations are typically expected to be portable with reproducible
+/// results when used with a PRNG with fixed seed; see the
+/// [portability chapter](https://rust-random.github.io/book/portability.html)
+/// of The Rust Rand Book. In some cases this does not apply, e.g. the `usize`
+/// type requires different sampling on 32-bit and 64-bit machines.
+///
+/// [`sample_iter`]: Distribution::sample_iter
+pub trait Distribution<T> {
+    /// Generate a random value of `T`, using `rng` as the source of randomness.
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> T;
+
+    /// Create an iterator that generates random values of `T`, using `rng` as
+    /// the source of randomness.
+    ///
+    /// Note that this function takes `self` by value. This works since
+    /// `Distribution<T>` is impl'd for `&D` where `D: Distribution<T>`,
+    /// however borrowing is not automatic hence `distr.sample_iter(...)` may
+    /// need to be replaced with `(&distr).sample_iter(...)` to borrow or
+    /// `(&*distr).sample_iter(...)` to reborrow an existing reference.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use rand::thread_rng;
+    /// use rand::distributions::{Distribution, Alphanumeric, Uniform, Standard};
+    ///
+    /// let mut rng = thread_rng();
+    ///
+    /// // Vec of 16 x f32:
+    /// let v: Vec<f32> = Standard.sample_iter(&mut rng).take(16).collect();
+    ///
+    /// // String:
+    /// let s: String = Alphanumeric
+    ///     .sample_iter(&mut rng)
+    ///     .take(7)
+    ///     .map(char::from)
+    ///     .collect();
+    ///
+    /// // Dice-rolling:
+    /// let die_range = Uniform::new_inclusive(1, 6);
+    /// let mut roll_die = die_range.sample_iter(&mut rng);
+    /// while roll_die.next().unwrap() != 6 {
+    ///     println!("Not a 6; rolling again!");
+    /// }
+    /// ```
+    fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>
+    where
+        R: Rng,
+        Self: Sized,
+    {
+        DistIter {
+            distr: self,
+            rng,
+            phantom: ::core::marker::PhantomData,
+        }
+    }
+
+    /// Create a distribution of values of 'S' by mapping the output of `Self`
+    /// through the closure `F`
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use rand::thread_rng;
+    /// use rand::distributions::{Distribution, Uniform};
+    ///
+    /// let mut rng = thread_rng();
+    ///
+    /// let die = Uniform::new_inclusive(1, 6);
+    /// let even_number = die.map(|num| num % 2 == 0);
+    /// while !even_number.sample(&mut rng) {
+    ///     println!("Still odd; rolling again!");
+    /// }
+    /// ```
+    fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S>
+    where
+        F: Fn(T) -> S,
+        Self: Sized,
+    {
+        DistMap {
+            distr: self,
+            func,
+            phantom: ::core::marker::PhantomData,
+        }
+    }
+}
+
+impl<'a, T, D: Distribution<T>> Distribution<T> for &'a D {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> T {
+        (*self).sample(rng)
+    }
+}
+
+/// An iterator that generates random values of `T` with distribution `D`,
+/// using `R` as the source of randomness.
+///
+/// This `struct` is created by the [`sample_iter`] method on [`Distribution`].
+/// See its documentation for more.
+///
+/// [`sample_iter`]: Distribution::sample_iter
+#[derive(Debug)]
+pub struct DistIter<D, R, T> {
+    distr: D,
+    rng: R,
+    phantom: ::core::marker::PhantomData<T>,
+}
+
+impl<D, R, T> Iterator for DistIter<D, R, T>
+where
+    D: Distribution<T>,
+    R: Rng,
+{
+    type Item = T;
+
+    #[inline(always)]
+    fn next(&mut self) -> Option<T> {
+        // Here, self.rng may be a reference, but we must take &mut anyway.
+        // Even if sample could take an R: Rng by value, we would need to do this
+        // since Rng is not copyable and we cannot enforce that this is "reborrowable".
+        Some(self.distr.sample(&mut self.rng))
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (usize::max_value(), None)
+    }
+}
+
+impl<D, R, T> iter::FusedIterator for DistIter<D, R, T>
+where
+    D: Distribution<T>,
+    R: Rng,
+{
+}
+
+#[cfg(features = "nightly")]
+impl<D, R, T> iter::TrustedLen for DistIter<D, R, T>
+where
+    D: Distribution<T>,
+    R: Rng,
+{
+}
+
+/// A distribution of values of type `S` derived from the distribution `D`
+/// by mapping its output of type `T` through the closure `F`.
+///
+/// This `struct` is created by the [`Distribution::map`] method.
+/// See its documentation for more.
+#[derive(Debug)]
+pub struct DistMap<D, F, T, S> {
+    distr: D,
+    func: F,
+    phantom: ::core::marker::PhantomData<fn(T) -> S>,
+}
+
+impl<D, F, T, S> Distribution<S> for DistMap<D, F, T, S>
+where
+    D: Distribution<T>,
+    F: Fn(T) -> S,
+{
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> S {
+        (self.func)(self.distr.sample(rng))
+    }
+}
+
+/// `String` sampler
+///
+/// Sampling a `String` of random characters is not quite the same as collecting
+/// a sequence of chars. This trait contains some helpers.
+#[cfg(feature = "alloc")]
+pub trait DistString {
+    /// Append `len` random chars to `string`
+    fn append_string<R: Rng + ?Sized>(&self, rng: &mut R, string: &mut String, len: usize);
+
+    /// Generate a `String` of `len` random chars
+    #[inline]
+    fn sample_string<R: Rng + ?Sized>(&self, rng: &mut R, len: usize) -> String {
+        let mut s = String::new();
+        self.append_string(rng, &mut s, len);
+        s
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::distributions::{Distribution, Uniform};
+    use crate::Rng;
+
+    #[test]
+    fn test_distributions_iter() {
+        use crate::distributions::Open01;
+        let mut rng = crate::test::rng(210);
+        let distr = Open01;
+        let mut iter = Distribution::<f32>::sample_iter(distr, &mut rng);
+        let mut sum: f32 = 0.;
+        for _ in 0..100 {
+            sum += iter.next().unwrap();
+        }
+        assert!(0. < sum && sum < 100.);
+    }
+
+    #[test]
+    fn test_distributions_map() {
+        let dist = Uniform::new_inclusive(0, 5).map(|val| val + 15);
+
+        let mut rng = crate::test::rng(212);
+        let val = dist.sample(&mut rng);
+        assert!((15..=20).contains(&val));
+    }
+
+    #[test]
+    fn test_make_an_iter() {
+        fn ten_dice_rolls_other_than_five<R: Rng>(
+            rng: &mut R,
+        ) -> impl Iterator<Item = i32> + '_ {
+            Uniform::new_inclusive(1, 6)
+                .sample_iter(rng)
+                .filter(|x| *x != 5)
+                .take(10)
+        }
+
+        let mut rng = crate::test::rng(211);
+        let mut count = 0;
+        for val in ten_dice_rolls_other_than_five(&mut rng) {
+            assert!((1..=6).contains(&val) && val != 5);
+            count += 1;
+        }
+        assert_eq!(count, 10);
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn test_dist_string() {
+        use core::str;
+        use crate::distributions::{Alphanumeric, DistString, Standard};
+        let mut rng = crate::test::rng(213);
+
+        let s1 = Alphanumeric.sample_string(&mut rng, 20);
+        assert_eq!(s1.len(), 20);
+        assert_eq!(str::from_utf8(s1.as_bytes()), Ok(s1.as_str()));
+
+        let s2 = Standard.sample_string(&mut rng, 20);
+        assert_eq!(s2.chars().count(), 20);
+        assert_eq!(str::from_utf8(s2.as_bytes()), Ok(s2.as_str()));
+    }
+}
diff --git a/crates/rand/src/distributions/float.rs b/crates/rand/src/distributions/float.rs
new file mode 100644
index 0000000..ce5946f
--- /dev/null
+++ b/crates/rand/src/distributions/float.rs
@@ -0,0 +1,312 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Basic floating-point number distributions
+
+use crate::distributions::utils::FloatSIMDUtils;
+use crate::distributions::{Distribution, Standard};
+use crate::Rng;
+use core::mem;
+#[cfg(feature = "simd_support")] use packed_simd::*;
+
+#[cfg(feature = "serde1")]
+use serde::{Serialize, Deserialize};
+
+/// A distribution to sample floating point numbers uniformly in the half-open
+/// interval `(0, 1]`, i.e. including 1 but not 0.
+///
+/// All values that can be generated are of the form `n * ε/2`. For `f32`
+/// the 24 most significant random bits of a `u32` are used and for `f64` the
+/// 53 most significant bits of a `u64` are used. The conversion uses the
+/// multiplicative method.
+///
+/// See also: [`Standard`] which samples from `[0, 1)`, [`Open01`]
+/// which samples from `(0, 1)` and [`Uniform`] which samples from arbitrary
+/// ranges.
+///
+/// # Example
+/// ```
+/// use rand::{thread_rng, Rng};
+/// use rand::distributions::OpenClosed01;
+///
+/// let val: f32 = thread_rng().sample(OpenClosed01);
+/// println!("f32 from (0, 1): {}", val);
+/// ```
+///
+/// [`Standard`]: crate::distributions::Standard
+/// [`Open01`]: crate::distributions::Open01
+/// [`Uniform`]: crate::distributions::uniform::Uniform
+#[derive(Clone, Copy, Debug)]
+#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
+pub struct OpenClosed01;
+
+/// A distribution to sample floating point numbers uniformly in the open
+/// interval `(0, 1)`, i.e. not including either endpoint.
+///
+/// All values that can be generated are of the form `n * ε + ε/2`. For `f32`
+/// the 23 most significant random bits of an `u32` are used, for `f64` 52 from
+/// an `u64`. The conversion uses a transmute-based method.
+///
+/// See also: [`Standard`] which samples from `[0, 1)`, [`OpenClosed01`]
+/// which samples from `(0, 1]` and [`Uniform`] which samples from arbitrary
+/// ranges.
+///
+/// # Example
+/// ```
+/// use rand::{thread_rng, Rng};
+/// use rand::distributions::Open01;
+///
+/// let val: f32 = thread_rng().sample(Open01);
+/// println!("f32 from (0, 1): {}", val);
+/// ```
+///
+/// [`Standard`]: crate::distributions::Standard
+/// [`OpenClosed01`]: crate::distributions::OpenClosed01
+/// [`Uniform`]: crate::distributions::uniform::Uniform
+#[derive(Clone, Copy, Debug)]
+#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
+pub struct Open01;
+
+
+// This trait is needed by both this lib and rand_distr hence is a hidden export
+#[doc(hidden)]
+pub trait IntoFloat {
+    type F;
+
+    /// Helper method to combine the fraction and a constant exponent into a
+    /// float.
+    ///
+    /// Only the least significant bits of `self` may be set, 23 for `f32` and
+    /// 52 for `f64`.
+    /// The resulting value will fall in a range that depends on the exponent.
+    /// As an example the range with exponent 0 will be
+    /// [2<sup>0</sup>..2<sup>1</sup>), which is [1..2).
+    fn into_float_with_exponent(self, exponent: i32) -> Self::F;
+}
+
+macro_rules! float_impls {
+    ($ty:ident, $uty:ident, $f_scalar:ident, $u_scalar:ty,
+     $fraction_bits:expr, $exponent_bias:expr) => {
+        impl IntoFloat for $uty {
+            type F = $ty;
+            #[inline(always)]
+            fn into_float_with_exponent(self, exponent: i32) -> $ty {
+                // The exponent is encoded using an offset-binary representation
+                let exponent_bits: $u_scalar =
+                    (($exponent_bias + exponent) as $u_scalar) << $fraction_bits;
+                $ty::from_bits(self | exponent_bits)
+            }
+        }
+
+        impl Distribution<$ty> for Standard {
+            fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> $ty {
+                // Multiply-based method; 24/53 random bits; [0, 1) interval.
+                // We use the most significant bits because for simple RNGs
+                // those are usually more random.
+                let float_size = mem::size_of::<$f_scalar>() as u32 * 8;
+                let precision = $fraction_bits + 1;
+                let scale = 1.0 / ((1 as $u_scalar << precision) as $f_scalar);
+
+                let value: $uty = rng.gen();
+                let value = value >> (float_size - precision);
+                scale * $ty::cast_from_int(value)
+            }
+        }
+
+        impl Distribution<$ty> for OpenClosed01 {
+            fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> $ty {
+                // Multiply-based method; 24/53 random bits; (0, 1] interval.
+                // We use the most significant bits because for simple RNGs
+                // those are usually more random.
+                let float_size = mem::size_of::<$f_scalar>() as u32 * 8;
+                let precision = $fraction_bits + 1;
+                let scale = 1.0 / ((1 as $u_scalar << precision) as $f_scalar);
+
+                let value: $uty = rng.gen();
+                let value = value >> (float_size - precision);
+                // Add 1 to shift up; will not overflow because of right-shift:
+                scale * $ty::cast_from_int(value + 1)
+            }
+        }
+
+        impl Distribution<$ty> for Open01 {
+            fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> $ty {
+                // Transmute-based method; 23/52 random bits; (0, 1) interval.
+                // We use the most significant bits because for simple RNGs
+                // those are usually more random.
+                use core::$f_scalar::EPSILON;
+                let float_size = mem::size_of::<$f_scalar>() as u32 * 8;
+
+                let value: $uty = rng.gen();
+                let fraction = value >> (float_size - $fraction_bits);
+                fraction.into_float_with_exponent(0) - (1.0 - EPSILON / 2.0)
+            }
+        }
+    }
+}
+
+float_impls! { f32, u32, f32, u32, 23, 127 }
+float_impls! { f64, u64, f64, u64, 52, 1023 }
+
+#[cfg(feature = "simd_support")]
+float_impls! { f32x2, u32x2, f32, u32, 23, 127 }
+#[cfg(feature = "simd_support")]
+float_impls! { f32x4, u32x4, f32, u32, 23, 127 }
+#[cfg(feature = "simd_support")]
+float_impls! { f32x8, u32x8, f32, u32, 23, 127 }
+#[cfg(feature = "simd_support")]
+float_impls! { f32x16, u32x16, f32, u32, 23, 127 }
+
+#[cfg(feature = "simd_support")]
+float_impls! { f64x2, u64x2, f64, u64, 52, 1023 }
+#[cfg(feature = "simd_support")]
+float_impls! { f64x4, u64x4, f64, u64, 52, 1023 }
+#[cfg(feature = "simd_support")]
+float_impls! { f64x8, u64x8, f64, u64, 52, 1023 }
+
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::rngs::mock::StepRng;
+
+    const EPSILON32: f32 = ::core::f32::EPSILON;
+    const EPSILON64: f64 = ::core::f64::EPSILON;
+
+    macro_rules! test_f32 {
+        ($fnn:ident, $ty:ident, $ZERO:expr, $EPSILON:expr) => {
+            #[test]
+            fn $fnn() {
+                // Standard
+                let mut zeros = StepRng::new(0, 0);
+                assert_eq!(zeros.gen::<$ty>(), $ZERO);
+                let mut one = StepRng::new(1 << 8 | 1 << (8 + 32), 0);
+                assert_eq!(one.gen::<$ty>(), $EPSILON / 2.0);
+                let mut max = StepRng::new(!0, 0);
+                assert_eq!(max.gen::<$ty>(), 1.0 - $EPSILON / 2.0);
+
+                // OpenClosed01
+                let mut zeros = StepRng::new(0, 0);
+                assert_eq!(zeros.sample::<$ty, _>(OpenClosed01), 0.0 + $EPSILON / 2.0);
+                let mut one = StepRng::new(1 << 8 | 1 << (8 + 32), 0);
+                assert_eq!(one.sample::<$ty, _>(OpenClosed01), $EPSILON);
+                let mut max = StepRng::new(!0, 0);
+                assert_eq!(max.sample::<$ty, _>(OpenClosed01), $ZERO + 1.0);
+
+                // Open01
+                let mut zeros = StepRng::new(0, 0);
+                assert_eq!(zeros.sample::<$ty, _>(Open01), 0.0 + $EPSILON / 2.0);
+                let mut one = StepRng::new(1 << 9 | 1 << (9 + 32), 0);
+                assert_eq!(one.sample::<$ty, _>(Open01), $EPSILON / 2.0 * 3.0);
+                let mut max = StepRng::new(!0, 0);
+                assert_eq!(max.sample::<$ty, _>(Open01), 1.0 - $EPSILON / 2.0);
+            }
+        };
+    }
+    test_f32! { f32_edge_cases, f32, 0.0, EPSILON32 }
+    #[cfg(feature = "simd_support")]
+    test_f32! { f32x2_edge_cases, f32x2, f32x2::splat(0.0), f32x2::splat(EPSILON32) }
+    #[cfg(feature = "simd_support")]
+    test_f32! { f32x4_edge_cases, f32x4, f32x4::splat(0.0), f32x4::splat(EPSILON32) }
+    #[cfg(feature = "simd_support")]
+    test_f32! { f32x8_edge_cases, f32x8, f32x8::splat(0.0), f32x8::splat(EPSILON32) }
+    #[cfg(feature = "simd_support")]
+    test_f32! { f32x16_edge_cases, f32x16, f32x16::splat(0.0), f32x16::splat(EPSILON32) }
+
+    macro_rules! test_f64 {
+        ($fnn:ident, $ty:ident, $ZERO:expr, $EPSILON:expr) => {
+            #[test]
+            fn $fnn() {
+                // Standard
+                let mut zeros = StepRng::new(0, 0);
+                assert_eq!(zeros.gen::<$ty>(), $ZERO);
+                let mut one = StepRng::new(1 << 11, 0);
+                assert_eq!(one.gen::<$ty>(), $EPSILON / 2.0);
+                let mut max = StepRng::new(!0, 0);
+                assert_eq!(max.gen::<$ty>(), 1.0 - $EPSILON / 2.0);
+
+                // OpenClosed01
+                let mut zeros = StepRng::new(0, 0);
+                assert_eq!(zeros.sample::<$ty, _>(OpenClosed01), 0.0 + $EPSILON / 2.0);
+                let mut one = StepRng::new(1 << 11, 0);
+                assert_eq!(one.sample::<$ty, _>(OpenClosed01), $EPSILON);
+                let mut max = StepRng::new(!0, 0);
+                assert_eq!(max.sample::<$ty, _>(OpenClosed01), $ZERO + 1.0);
+
+                // Open01
+                let mut zeros = StepRng::new(0, 0);
+                assert_eq!(zeros.sample::<$ty, _>(Open01), 0.0 + $EPSILON / 2.0);
+                let mut one = StepRng::new(1 << 12, 0);
+                assert_eq!(one.sample::<$ty, _>(Open01), $EPSILON / 2.0 * 3.0);
+                let mut max = StepRng::new(!0, 0);
+                assert_eq!(max.sample::<$ty, _>(Open01), 1.0 - $EPSILON / 2.0);
+            }
+        };
+    }
+    test_f64! { f64_edge_cases, f64, 0.0, EPSILON64 }
+    #[cfg(feature = "simd_support")]
+    test_f64! { f64x2_edge_cases, f64x2, f64x2::splat(0.0), f64x2::splat(EPSILON64) }
+    #[cfg(feature = "simd_support")]
+    test_f64! { f64x4_edge_cases, f64x4, f64x4::splat(0.0), f64x4::splat(EPSILON64) }
+    #[cfg(feature = "simd_support")]
+    test_f64! { f64x8_edge_cases, f64x8, f64x8::splat(0.0), f64x8::splat(EPSILON64) }
+
+    #[test]
+    fn value_stability() {
+        fn test_samples<T: Copy + core::fmt::Debug + PartialEq, D: Distribution<T>>(
+            distr: &D, zero: T, expected: &[T],
+        ) {
+            let mut rng = crate::test::rng(0x6f44f5646c2a7334);
+            let mut buf = [zero; 3];
+            for x in &mut buf {
+                *x = rng.sample(&distr);
+            }
+            assert_eq!(&buf, expected);
+        }
+
+        test_samples(&Standard, 0f32, &[0.0035963655, 0.7346052, 0.09778172]);
+        test_samples(&Standard, 0f64, &[
+            0.7346051961657583,
+            0.20298547462974248,
+            0.8166436635290655,
+        ]);
+
+        test_samples(&OpenClosed01, 0f32, &[0.003596425, 0.73460525, 0.09778178]);
+        test_samples(&OpenClosed01, 0f64, &[
+            0.7346051961657584,
+            0.2029854746297426,
+            0.8166436635290656,
+        ]);
+
+        test_samples(&Open01, 0f32, &[0.0035963655, 0.73460525, 0.09778172]);
+        test_samples(&Open01, 0f64, &[
+            0.7346051961657584,
+            0.20298547462974248,
+            0.8166436635290656,
+        ]);
+
+        #[cfg(feature = "simd_support")]
+        {
+            // We only test a sub-set of types here. Values are identical to
+            // non-SIMD types; we assume this pattern continues across all
+            // SIMD types.
+
+            test_samples(&Standard, f32x2::new(0.0, 0.0), &[
+                f32x2::new(0.0035963655, 0.7346052),
+                f32x2::new(0.09778172, 0.20298547),
+                f32x2::new(0.34296435, 0.81664366),
+            ]);
+
+            test_samples(&Standard, f64x2::new(0.0, 0.0), &[
+                f64x2::new(0.7346051961657583, 0.20298547462974248),
+                f64x2::new(0.8166436635290655, 0.7423708925400552),
+                f64x2::new(0.16387782224016323, 0.9087068770169618),
+            ]);
+        }
+    }
+}
diff --git a/crates/rand/src/distributions/integer.rs b/crates/rand/src/distributions/integer.rs
new file mode 100644
index 0000000..19ce715
--- /dev/null
+++ b/crates/rand/src/distributions/integer.rs
@@ -0,0 +1,274 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! The implementations of the `Standard` distribution for integer types.
+
+use crate::distributions::{Distribution, Standard};
+use crate::Rng;
+#[cfg(all(target_arch = "x86", feature = "simd_support"))]
+use core::arch::x86::{__m128i, __m256i};
+#[cfg(all(target_arch = "x86_64", feature = "simd_support"))]
+use core::arch::x86_64::{__m128i, __m256i};
+use core::num::{NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU8, NonZeroUsize,
+    NonZeroU128};
+#[cfg(feature = "simd_support")] use packed_simd::*;
+
+impl Distribution<u8> for Standard {
+    #[inline]
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u8 {
+        rng.next_u32() as u8
+    }
+}
+
+impl Distribution<u16> for Standard {
+    #[inline]
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u16 {
+        rng.next_u32() as u16
+    }
+}
+
+impl Distribution<u32> for Standard {
+    #[inline]
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u32 {
+        rng.next_u32()
+    }
+}
+
+impl Distribution<u64> for Standard {
+    #[inline]
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u64 {
+        rng.next_u64()
+    }
+}
+
+impl Distribution<u128> for Standard {
+    #[inline]
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u128 {
+        // Use LE; we explicitly generate one value before the next.
+        let x = u128::from(rng.next_u64());
+        let y = u128::from(rng.next_u64());
+        (y << 64) | x
+    }
+}
+
+impl Distribution<usize> for Standard {
+    #[inline]
+    #[cfg(any(target_pointer_width = "32", target_pointer_width = "16"))]
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> usize {
+        rng.next_u32() as usize
+    }
+
+    #[inline]
+    #[cfg(target_pointer_width = "64")]
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> usize {
+        rng.next_u64() as usize
+    }
+}
+
+macro_rules! impl_int_from_uint {
+    ($ty:ty, $uty:ty) => {
+        impl Distribution<$ty> for Standard {
+            #[inline]
+            fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> $ty {
+                rng.gen::<$uty>() as $ty
+            }
+        }
+    };
+}
+
+impl_int_from_uint! { i8, u8 }
+impl_int_from_uint! { i16, u16 }
+impl_int_from_uint! { i32, u32 }
+impl_int_from_uint! { i64, u64 }
+impl_int_from_uint! { i128, u128 }
+impl_int_from_uint! { isize, usize }
+
+macro_rules! impl_nzint {
+    ($ty:ty, $new:path) => {
+        impl Distribution<$ty> for Standard {
+            fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> $ty {
+                loop {
+                    if let Some(nz) = $new(rng.gen()) {
+                        break nz;
+                    }
+                }
+            }
+        }
+    };
+}
+
+impl_nzint!(NonZeroU8, NonZeroU8::new);
+impl_nzint!(NonZeroU16, NonZeroU16::new);
+impl_nzint!(NonZeroU32, NonZeroU32::new);
+impl_nzint!(NonZeroU64, NonZeroU64::new);
+impl_nzint!(NonZeroU128, NonZeroU128::new);
+impl_nzint!(NonZeroUsize, NonZeroUsize::new);
+
+#[cfg(feature = "simd_support")]
+macro_rules! simd_impl {
+    ($(($intrinsic:ident, $vec:ty),)+) => {$(
+        impl Distribution<$intrinsic> for Standard {
+            #[inline]
+            fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> $intrinsic {
+                $intrinsic::from_bits(rng.gen::<$vec>())
+            }
+        }
+    )+};
+
+    ($bits:expr,) => {};
+    ($bits:expr, $ty:ty, $($ty_more:ty,)*) => {
+        simd_impl!($bits, $($ty_more,)*);
+
+        impl Distribution<$ty> for Standard {
+            #[inline]
+            fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> $ty {
+                let mut vec: $ty = Default::default();
+                unsafe {
+                    let ptr = &mut vec;
+                    let b_ptr = &mut *(ptr as *mut $ty as *mut [u8; $bits/8]);
+                    rng.fill_bytes(b_ptr);
+                }
+                vec.to_le()
+            }
+        }
+    };
+}
+
+#[cfg(feature = "simd_support")]
+simd_impl!(16, u8x2, i8x2,);
+#[cfg(feature = "simd_support")]
+simd_impl!(32, u8x4, i8x4, u16x2, i16x2,);
+#[cfg(feature = "simd_support")]
+simd_impl!(64, u8x8, i8x8, u16x4, i16x4, u32x2, i32x2,);
+#[cfg(feature = "simd_support")]
+simd_impl!(128, u8x16, i8x16, u16x8, i16x8, u32x4, i32x4, u64x2, i64x2,);
+#[cfg(feature = "simd_support")]
+simd_impl!(256, u8x32, i8x32, u16x16, i16x16, u32x8, i32x8, u64x4, i64x4,);
+#[cfg(feature = "simd_support")]
+simd_impl!(512, u8x64, i8x64, u16x32, i16x32, u32x16, i32x16, u64x8, i64x8,);
+#[cfg(all(
+    feature = "simd_support",
+    any(target_arch = "x86", target_arch = "x86_64")
+))]
+simd_impl!((__m128i, u8x16), (__m256i, u8x32),);
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_integers() {
+        let mut rng = crate::test::rng(806);
+
+        rng.sample::<isize, _>(Standard);
+        rng.sample::<i8, _>(Standard);
+        rng.sample::<i16, _>(Standard);
+        rng.sample::<i32, _>(Standard);
+        rng.sample::<i64, _>(Standard);
+        rng.sample::<i128, _>(Standard);
+
+        rng.sample::<usize, _>(Standard);
+        rng.sample::<u8, _>(Standard);
+        rng.sample::<u16, _>(Standard);
+        rng.sample::<u32, _>(Standard);
+        rng.sample::<u64, _>(Standard);
+        rng.sample::<u128, _>(Standard);
+    }
+
+    #[test]
+    fn value_stability() {
+        fn test_samples<T: Copy + core::fmt::Debug + PartialEq>(zero: T, expected: &[T])
+        where Standard: Distribution<T> {
+            let mut rng = crate::test::rng(807);
+            let mut buf = [zero; 3];
+            for x in &mut buf {
+                *x = rng.sample(Standard);
+            }
+            assert_eq!(&buf, expected);
+        }
+
+        test_samples(0u8, &[9, 247, 111]);
+        test_samples(0u16, &[32265, 42999, 38255]);
+        test_samples(0u32, &[2220326409, 2575017975, 2018088303]);
+        test_samples(0u64, &[
+            11059617991457472009,
+            16096616328739788143,
+            1487364411147516184,
+        ]);
+        test_samples(0u128, &[
+            296930161868957086625409848350820761097,
+            145644820879247630242265036535529306392,
+            111087889832015897993126088499035356354,
+        ]);
+        #[cfg(any(target_pointer_width = "32", target_pointer_width = "16"))]
+        test_samples(0usize, &[2220326409, 2575017975, 2018088303]);
+        #[cfg(target_pointer_width = "64")]
+        test_samples(0usize, &[
+            11059617991457472009,
+            16096616328739788143,
+            1487364411147516184,
+        ]);
+
+        test_samples(0i8, &[9, -9, 111]);
+        // Skip further i* types: they are simple reinterpretation of u* samples
+
+        #[cfg(feature = "simd_support")]
+        {
+            // We only test a sub-set of types here and make assumptions about the rest.
+
+            test_samples(u8x2::default(), &[
+                u8x2::new(9, 126),
+                u8x2::new(247, 167),
+                u8x2::new(111, 149),
+            ]);
+            test_samples(u8x4::default(), &[
+                u8x4::new(9, 126, 87, 132),
+                u8x4::new(247, 167, 123, 153),
+                u8x4::new(111, 149, 73, 120),
+            ]);
+            test_samples(u8x8::default(), &[
+                u8x8::new(9, 126, 87, 132, 247, 167, 123, 153),
+                u8x8::new(111, 149, 73, 120, 68, 171, 98, 223),
+                u8x8::new(24, 121, 1, 50, 13, 46, 164, 20),
+            ]);
+
+            test_samples(i64x8::default(), &[
+                i64x8::new(
+                    -7387126082252079607,
+                    -2350127744969763473,
+                    1487364411147516184,
+                    7895421560427121838,
+                    602190064936008898,
+                    6022086574635100741,
+                    -5080089175222015595,
+                    -4066367846667249123,
+                ),
+                i64x8::new(
+                    9180885022207963908,
+                    3095981199532211089,
+                    6586075293021332726,
+                    419343203796414657,
+                    3186951873057035255,
+                    5287129228749947252,
+                    444726432079249540,
+                    -1587028029513790706,
+                ),
+                i64x8::new(
+                    6075236523189346388,
+                    1351763722368165432,
+                    -6192309979959753740,
+                    -7697775502176768592,
+                    -4482022114172078123,
+                    7522501477800909500,
+                    -1837258847956201231,
+                    -586926753024886735,
+                ),
+            ]);
+        }
+    }
+}
diff --git a/crates/rand/src/distributions/mod.rs b/crates/rand/src/distributions/mod.rs
new file mode 100644
index 0000000..05ca806
--- /dev/null
+++ b/crates/rand/src/distributions/mod.rs
@@ -0,0 +1,218 @@
+// Copyright 2018 Developers of the Rand project.
+// Copyright 2013-2017 The Rust Project Developers.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Generating random samples from probability distributions
+//!
+//! This module is the home of the [`Distribution`] trait and several of its
+//! implementations. It is the workhorse behind some of the convenient
+//! functionality of the [`Rng`] trait, e.g. [`Rng::gen`] and of course
+//! [`Rng::sample`].
+//!
+//! Abstractly, a [probability distribution] describes the probability of
+//! occurrence of each value in its sample space.
+//!
+//! More concretely, an implementation of `Distribution<T>` for type `X` is an
+//! algorithm for choosing values from the sample space (a subset of `T`)
+//! according to the distribution `X` represents, using an external source of
+//! randomness (an RNG supplied to the `sample` function).
+//!
+//! A type `X` may implement `Distribution<T>` for multiple types `T`.
+//! Any type implementing [`Distribution`] is stateless (i.e. immutable),
+//! but it may have internal parameters set at construction time (for example,
+//! [`Uniform`] allows specification of its sample space as a range within `T`).
+//!
+//!
+//! # The `Standard` distribution
+//!
+//! The [`Standard`] distribution is important to mention. This is the
+//! distribution used by [`Rng::gen`] and represents the "default" way to
+//! produce a random value for many different types, including most primitive
+//! types, tuples, arrays, and a few derived types. See the documentation of
+//! [`Standard`] for more details.
+//!
+//! Implementing `Distribution<T>` for [`Standard`] for user types `T` makes it
+//! possible to generate type `T` with [`Rng::gen`], and by extension also
+//! with the [`random`] function.
+//!
+//! ## Random characters
+//!
+//! [`Alphanumeric`] is a simple distribution to sample random letters and
+//! numbers of the `char` type; in contrast [`Standard`] may sample any valid
+//! `char`.
+//!
+//!
+//! # Uniform numeric ranges
+//!
+//! The [`Uniform`] distribution is more flexible than [`Standard`], but also
+//! more specialised: it supports fewer target types, but allows the sample
+//! space to be specified as an arbitrary range within its target type `T`.
+//! Both [`Standard`] and [`Uniform`] are in some sense uniform distributions.
+//!
+//! Values may be sampled from this distribution using [`Rng::sample(Range)`] or
+//! by creating a distribution object with [`Uniform::new`],
+//! [`Uniform::new_inclusive`] or `From<Range>`. When the range limits are not
+//! known at compile time it is typically faster to reuse an existing
+//! `Uniform` object than to call [`Rng::sample(Range)`].
+//!
+//! User types `T` may also implement `Distribution<T>` for [`Uniform`],
+//! although this is less straightforward than for [`Standard`] (see the
+//! documentation in the [`uniform`] module). Doing so enables generation of
+//! values of type `T` with  [`Rng::sample(Range)`].
+//!
+//! ## Open and half-open ranges
+//!
+//! There are surprisingly many ways to uniformly generate random floats. A
+//! range between 0 and 1 is standard, but the exact bounds (open vs closed)
+//! and accuracy differ. In addition to the [`Standard`] distribution Rand offers
+//! [`Open01`] and [`OpenClosed01`]. See "Floating point implementation" section of
+//! [`Standard`] documentation for more details.
+//!
+//! # Non-uniform sampling
+//!
+//! Sampling a simple true/false outcome with a given probability has a name:
+//! the [`Bernoulli`] distribution (this is used by [`Rng::gen_bool`]).
+//!
+//! For weighted sampling from a sequence of discrete values, use the
+//! [`WeightedIndex`] distribution.
+//!
+//! This crate no longer includes other non-uniform distributions; instead
+//! it is recommended that you use either [`rand_distr`] or [`statrs`].
+//!
+//!
+//! [probability distribution]: https://en.wikipedia.org/wiki/Probability_distribution
+//! [`rand_distr`]: https://crates.io/crates/rand_distr
+//! [`statrs`]: https://crates.io/crates/statrs
+
+//! [`random`]: crate::random
+//! [`rand_distr`]: https://crates.io/crates/rand_distr
+//! [`statrs`]: https://crates.io/crates/statrs
+
+mod bernoulli;
+mod distribution;
+mod float;
+mod integer;
+mod other;
+mod slice;
+mod utils;
+#[cfg(feature = "alloc")]
+mod weighted_index;
+
+#[doc(hidden)]
+pub mod hidden_export {
+    pub use super::float::IntoFloat; // used by rand_distr
+}
+pub mod uniform;
+#[deprecated(
+    since = "0.8.0",
+    note = "use rand::distributions::{WeightedIndex, WeightedError} instead"
+)]
+#[cfg(feature = "alloc")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
+pub mod weighted;
+
+pub use self::bernoulli::{Bernoulli, BernoulliError};
+pub use self::distribution::{Distribution, DistIter, DistMap};
+#[cfg(feature = "alloc")]
+pub use self::distribution::DistString;
+pub use self::float::{Open01, OpenClosed01};
+pub use self::other::Alphanumeric;
+pub use self::slice::Slice;
+#[doc(inline)]
+pub use self::uniform::Uniform;
+#[cfg(feature = "alloc")]
+pub use self::weighted_index::{WeightedError, WeightedIndex};
+
+#[allow(unused)]
+use crate::Rng;
+
+/// A generic random value distribution, implemented for many primitive types.
+/// Usually generates values with a numerically uniform distribution, and with a
+/// range appropriate to the type.
+///
+/// ## Provided implementations
+///
+/// Assuming the provided `Rng` is well-behaved, these implementations
+/// generate values with the following ranges and distributions:
+///
+/// * Integers (`i32`, `u32`, `isize`, `usize`, etc.): Uniformly distributed
+///   over all values of the type.
+/// * `char`: Uniformly distributed over all Unicode scalar values, i.e. all
+///   code points in the range `0...0x10_FFFF`, except for the range
+///   `0xD800...0xDFFF` (the surrogate code points). This includes
+///   unassigned/reserved code points.
+/// * `bool`: Generates `false` or `true`, each with probability 0.5.
+/// * Floating point types (`f32` and `f64`): Uniformly distributed in the
+///   half-open range `[0, 1)`. See notes below.
+/// * Wrapping integers (`Wrapping<T>`), besides the type identical to their
+///   normal integer variants.
+///
+/// The `Standard` distribution also supports generation of the following
+/// compound types where all component types are supported:
+///
+/// *   Tuples (up to 12 elements): each element is generated sequentially.
+/// *   Arrays (up to 32 elements): each element is generated sequentially;
+///     see also [`Rng::fill`] which supports arbitrary array length for integer
+///     and float types and tends to be faster for `u32` and smaller types.
+///     When using `rustc` ≥ 1.51, enable the `min_const_gen` feature to support
+///     arrays larger than 32 elements.
+///     Note that [`Rng::fill`] and `Standard`'s array support are *not* equivalent:
+///     the former is optimised for integer types (using fewer RNG calls for
+///     element types smaller than the RNG word size), while the latter supports
+///     any element type supported by `Standard`.
+/// *   `Option<T>` first generates a `bool`, and if true generates and returns
+///     `Some(value)` where `value: T`, otherwise returning `None`.
+///
+/// ## Custom implementations
+///
+/// The [`Standard`] distribution may be implemented for user types as follows:
+///
+/// ```
+/// # #![allow(dead_code)]
+/// use rand::Rng;
+/// use rand::distributions::{Distribution, Standard};
+///
+/// struct MyF32 {
+///     x: f32,
+/// }
+///
+/// impl Distribution<MyF32> for Standard {
+///     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> MyF32 {
+///         MyF32 { x: rng.gen() }
+///     }
+/// }
+/// ```
+///
+/// ## Example usage
+/// ```
+/// use rand::prelude::*;
+/// use rand::distributions::Standard;
+///
+/// let val: f32 = StdRng::from_entropy().sample(Standard);
+/// println!("f32 from [0, 1): {}", val);
+/// ```
+///
+/// # Floating point implementation
+/// The floating point implementations for `Standard` generate a random value in
+/// the half-open interval `[0, 1)`, i.e. including 0 but not 1.
+///
+/// All values that can be generated are of the form `n * ε/2`. For `f32`
+/// the 24 most significant random bits of a `u32` are used and for `f64` the
+/// 53 most significant bits of a `u64` are used. The conversion uses the
+/// multiplicative method: `(rng.gen::<$uty>() >> N) as $ty * (ε/2)`.
+///
+/// See also: [`Open01`] which samples from `(0, 1)`, [`OpenClosed01`] which
+/// samples from `(0, 1]` and `Rng::gen_range(0..1)` which also samples from
+/// `[0, 1)`. Note that `Open01` uses transmute-based methods which yield 1 bit
+/// less precision but may perform faster on some architectures (on modern Intel
+/// CPUs all methods have approximately equal performance).
+///
+/// [`Uniform`]: uniform::Uniform
+#[derive(Clone, Copy, Debug)]
+#[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]
+pub struct Standard;
diff --git a/crates/rand/src/distributions/other.rs b/crates/rand/src/distributions/other.rs
new file mode 100644
index 0000000..03802a7
--- /dev/null
+++ b/crates/rand/src/distributions/other.rs
@@ -0,0 +1,365 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! The implementations of the `Standard` distribution for other built-in types.
+
+use core::char;
+use core::num::Wrapping;
+#[cfg(feature = "alloc")]
+use alloc::string::String;
+
+use crate::distributions::{Distribution, Standard, Uniform};
+#[cfg(feature = "alloc")]
+use crate::distributions::DistString;
+use crate::Rng;
+
+#[cfg(feature = "serde1")]
+use serde::{Serialize, Deserialize};
+#[cfg(feature = "min_const_gen")]
+use core::mem::{self, MaybeUninit};
+
+
+// ----- Sampling distributions -----
+
+/// Sample a `u8`, uniformly distributed over ASCII letters and numbers:
+/// a-z, A-Z and 0-9.
+///
+/// # Example
+///
+/// ```
+/// use rand::{Rng, thread_rng};
+/// use rand::distributions::Alphanumeric;
+///
+/// let mut rng = thread_rng();
+/// let chars: String = (0..7).map(|_| rng.sample(Alphanumeric) as char).collect();
+/// println!("Random chars: {}", chars);
+/// ```
+///
+/// The [`DistString`] trait provides an easier method of generating
+/// a random `String`, and offers more efficient allocation:
+/// ```
+/// use rand::distributions::{Alphanumeric, DistString};
+/// let string = Alphanumeric.sample_string(&mut rand::thread_rng(), 16);
+/// println!("Random string: {}", string);
+/// ```
+///
+/// # Passwords
+///
+/// Users sometimes ask whether it is safe to use a string of random characters
+/// as a password. In principle, all RNGs in Rand implementing `CryptoRng` are
+/// suitable as a source of randomness for generating passwords (if they are
+/// properly seeded), but it is more conservative to only use randomness
+/// directly from the operating system via the `getrandom` crate, or the
+/// corresponding bindings of a crypto library.
+///
+/// When generating passwords or keys, it is important to consider the threat
+/// model and in some cases the memorability of the password. This is out of
+/// scope of the Rand project, and therefore we defer to the following
+/// references:
+///
+/// - [Wikipedia article on Password Strength](https://en.wikipedia.org/wiki/Password_strength)
+/// - [Diceware for generating memorable passwords](https://en.wikipedia.org/wiki/Diceware)
+#[derive(Debug, Clone, Copy)]
+#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
+pub struct Alphanumeric;
+
+
+// ----- Implementations of distributions -----
+
+impl Distribution<char> for Standard {
+    #[inline]
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> char {
+        // A valid `char` is either in the interval `[0, 0xD800)` or
+        // `(0xDFFF, 0x11_0000)`. All `char`s must therefore be in
+        // `[0, 0x11_0000)` but not in the "gap" `[0xD800, 0xDFFF]` which is
+        // reserved for surrogates. This is the size of that gap.
+        const GAP_SIZE: u32 = 0xDFFF - 0xD800 + 1;
+
+        // Uniform::new(0, 0x11_0000 - GAP_SIZE) can also be used but it
+        // seemed slower.
+        let range = Uniform::new(GAP_SIZE, 0x11_0000);
+
+        let mut n = range.sample(rng);
+        if n <= 0xDFFF {
+            n -= GAP_SIZE;
+        }
+        unsafe { char::from_u32_unchecked(n) }
+    }
+}
+
+/// Note: the `String` is potentially left with excess capacity; optionally the
+/// user may call `string.shrink_to_fit()` afterwards.
+#[cfg(feature = "alloc")]
+impl DistString for Standard {
+    fn append_string<R: Rng + ?Sized>(&self, rng: &mut R, s: &mut String, len: usize) {
+        // A char is encoded with at most four bytes, thus this reservation is
+        // guaranteed to be sufficient. We do not shrink_to_fit afterwards so
+        // that repeated usage on the same `String` buffer does not reallocate.
+        s.reserve(4 * len);
+        s.extend(Distribution::<char>::sample_iter(self, rng).take(len));
+    }
+}
+
+impl Distribution<u8> for Alphanumeric {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u8 {
+        const RANGE: u32 = 26 + 26 + 10;
+        const GEN_ASCII_STR_CHARSET: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ\
+                abcdefghijklmnopqrstuvwxyz\
+                0123456789";
+        // We can pick from 62 characters. This is so close to a power of 2, 64,
+        // that we can do better than `Uniform`. Use a simple bitshift and
+        // rejection sampling. We do not use a bitmask, because for small RNGs
+        // the most significant bits are usually of higher quality.
+        loop {
+            let var = rng.next_u32() >> (32 - 6);
+            if var < RANGE {
+                return GEN_ASCII_STR_CHARSET[var as usize];
+            }
+        }
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl DistString for Alphanumeric {
+    fn append_string<R: Rng + ?Sized>(&self, rng: &mut R, string: &mut String, len: usize) {
+        unsafe {
+            let v = string.as_mut_vec();
+            v.extend(self.sample_iter(rng).take(len));
+        }
+    }
+}
+
+impl Distribution<bool> for Standard {
+    #[inline]
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> bool {
+        // We can compare against an arbitrary bit of an u32 to get a bool.
+        // Because the least significant bits of a lower quality RNG can have
+        // simple patterns, we compare against the most significant bit. This is
+        // easiest done using a sign test.
+        (rng.next_u32() as i32) < 0
+    }
+}
+
+macro_rules! tuple_impl {
+    // use variables to indicate the arity of the tuple
+    ($($tyvar:ident),* ) => {
+        // the trailing commas are for the 1 tuple
+        impl< $( $tyvar ),* >
+            Distribution<( $( $tyvar ),* , )>
+            for Standard
+            where $( Standard: Distribution<$tyvar> ),*
+        {
+            #[inline]
+            fn sample<R: Rng + ?Sized>(&self, _rng: &mut R) -> ( $( $tyvar ),* , ) {
+                (
+                    // use the $tyvar's to get the appropriate number of
+                    // repeats (they're not actually needed)
+                    $(
+                        _rng.gen::<$tyvar>()
+                    ),*
+                    ,
+                )
+            }
+        }
+    }
+}
+
+impl Distribution<()> for Standard {
+    #[allow(clippy::unused_unit)]
+    #[inline]
+    fn sample<R: Rng + ?Sized>(&self, _: &mut R) -> () {
+        ()
+    }
+}
+tuple_impl! {A}
+tuple_impl! {A, B}
+tuple_impl! {A, B, C}
+tuple_impl! {A, B, C, D}
+tuple_impl! {A, B, C, D, E}
+tuple_impl! {A, B, C, D, E, F}
+tuple_impl! {A, B, C, D, E, F, G}
+tuple_impl! {A, B, C, D, E, F, G, H}
+tuple_impl! {A, B, C, D, E, F, G, H, I}
+tuple_impl! {A, B, C, D, E, F, G, H, I, J}
+tuple_impl! {A, B, C, D, E, F, G, H, I, J, K}
+tuple_impl! {A, B, C, D, E, F, G, H, I, J, K, L}
+
+#[cfg(feature = "min_const_gen")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "min_const_gen")))]
+impl<T, const N: usize> Distribution<[T; N]> for Standard
+where Standard: Distribution<T>
+{
+    #[inline]
+    fn sample<R: Rng + ?Sized>(&self, _rng: &mut R) -> [T; N] {
+        let mut buff: [MaybeUninit<T>; N] = unsafe { MaybeUninit::uninit().assume_init() };
+
+        for elem in &mut buff {
+            *elem = MaybeUninit::new(_rng.gen());
+        }
+
+        unsafe { mem::transmute_copy::<_, _>(&buff) }
+    }
+}
+
+#[cfg(not(feature = "min_const_gen"))]
+macro_rules! array_impl {
+    // recursive, given at least one type parameter:
+    {$n:expr, $t:ident, $($ts:ident,)*} => {
+        array_impl!{($n - 1), $($ts,)*}
+
+        impl<T> Distribution<[T; $n]> for Standard where Standard: Distribution<T> {
+            #[inline]
+            fn sample<R: Rng + ?Sized>(&self, _rng: &mut R) -> [T; $n] {
+                [_rng.gen::<$t>(), $(_rng.gen::<$ts>()),*]
+            }
+        }
+    };
+    // empty case:
+    {$n:expr,} => {
+        impl<T> Distribution<[T; $n]> for Standard {
+            fn sample<R: Rng + ?Sized>(&self, _rng: &mut R) -> [T; $n] { [] }
+        }
+    };
+}
+
+#[cfg(not(feature = "min_const_gen"))]
+array_impl! {32, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T,}
+
+impl<T> Distribution<Option<T>> for Standard
+where Standard: Distribution<T>
+{
+    #[inline]
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Option<T> {
+        // UFCS is needed here: https://github.com/rust-lang/rust/issues/24066
+        if rng.gen::<bool>() {
+            Some(rng.gen())
+        } else {
+            None
+        }
+    }
+}
+
+impl<T> Distribution<Wrapping<T>> for Standard
+where Standard: Distribution<T>
+{
+    #[inline]
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Wrapping<T> {
+        Wrapping(rng.gen())
+    }
+}
+
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::RngCore;
+    #[cfg(feature = "alloc")] use alloc::string::String;
+
+    #[test]
+    fn test_misc() {
+        let rng: &mut dyn RngCore = &mut crate::test::rng(820);
+
+        rng.sample::<char, _>(Standard);
+        rng.sample::<bool, _>(Standard);
+    }
+
+    #[cfg(feature = "alloc")]
+    #[test]
+    fn test_chars() {
+        use core::iter;
+        let mut rng = crate::test::rng(805);
+
+        // Test by generating a relatively large number of chars, so we also
+        // take the rejection sampling path.
+        let word: String = iter::repeat(())
+            .map(|()| rng.gen::<char>())
+            .take(1000)
+            .collect();
+        assert!(!word.is_empty());
+    }
+
+    #[test]
+    fn test_alphanumeric() {
+        let mut rng = crate::test::rng(806);
+
+        // Test by generating a relatively large number of chars, so we also
+        // take the rejection sampling path.
+        let mut incorrect = false;
+        for _ in 0..100 {
+            let c: char = rng.sample(Alphanumeric).into();
+            incorrect |= !(('0'..='9').contains(&c) ||
+                           ('A'..='Z').contains(&c) ||
+                           ('a'..='z').contains(&c) );
+        }
+        assert!(!incorrect);
+    }
+
+    #[test]
+    fn value_stability() {
+        fn test_samples<T: Copy + core::fmt::Debug + PartialEq, D: Distribution<T>>(
+            distr: &D, zero: T, expected: &[T],
+        ) {
+            let mut rng = crate::test::rng(807);
+            let mut buf = [zero; 5];
+            for x in &mut buf {
+                *x = rng.sample(&distr);
+            }
+            assert_eq!(&buf, expected);
+        }
+
+        test_samples(&Standard, 'a', &[
+            '\u{8cdac}',
+            '\u{a346a}',
+            '\u{80120}',
+            '\u{ed692}',
+            '\u{35888}',
+        ]);
+        test_samples(&Alphanumeric, 0, &[104, 109, 101, 51, 77]);
+        test_samples(&Standard, false, &[true, true, false, true, false]);
+        test_samples(&Standard, None as Option<bool>, &[
+            Some(true),
+            None,
+            Some(false),
+            None,
+            Some(false),
+        ]);
+        test_samples(&Standard, Wrapping(0i32), &[
+            Wrapping(-2074640887),
+            Wrapping(-1719949321),
+            Wrapping(2018088303),
+            Wrapping(-547181756),
+            Wrapping(838957336),
+        ]);
+
+        // We test only sub-sets of tuple and array impls
+        test_samples(&Standard, (), &[(), (), (), (), ()]);
+        test_samples(&Standard, (false,), &[
+            (true,),
+            (true,),
+            (false,),
+            (true,),
+            (false,),
+        ]);
+        test_samples(&Standard, (false, false), &[
+            (true, true),
+            (false, true),
+            (false, false),
+            (true, false),
+            (false, false),
+        ]);
+
+        test_samples(&Standard, [0u8; 0], &[[], [], [], [], []]);
+        test_samples(&Standard, [0u8; 3], &[
+            [9, 247, 111],
+            [68, 24, 13],
+            [174, 19, 194],
+            [172, 69, 213],
+            [149, 207, 29],
+        ]);
+    }
+}
diff --git a/crates/rand/src/distributions/slice.rs b/crates/rand/src/distributions/slice.rs
new file mode 100644
index 0000000..3302deb
--- /dev/null
+++ b/crates/rand/src/distributions/slice.rs
@@ -0,0 +1,117 @@
+// Copyright 2021 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use crate::distributions::{Distribution, Uniform};
+
+/// A distribution to sample items uniformly from a slice.
+///
+/// [`Slice::new`] constructs a distribution referencing a slice and uniformly
+/// samples references from the items in the slice. It may do extra work up
+/// front to make sampling of multiple values faster; if only one sample from
+/// the slice is required, [`SliceRandom::choose`] can be more efficient.
+///
+/// Steps are taken to avoid bias which might be present in naive
+/// implementations; for example `slice[rng.gen() % slice.len()]` samples from
+/// the slice, but may be more likely to select numbers in the low range than
+/// other values.
+///
+/// This distribution samples with replacement; each sample is independent.
+/// Sampling without replacement requires state to be retained, and therefore
+/// cannot be handled by a distribution; you should instead consider methods
+/// on [`SliceRandom`], such as [`SliceRandom::choose_multiple`].
+///
+/// # Example
+///
+/// ```
+/// use rand::Rng;
+/// use rand::distributions::Slice;
+///
+/// let vowels = ['a', 'e', 'i', 'o', 'u'];
+/// let vowels_dist = Slice::new(&vowels).unwrap();
+/// let rng = rand::thread_rng();
+///
+/// // build a string of 10 vowels
+/// let vowel_string: String = rng
+///     .sample_iter(&vowels_dist)
+///     .take(10)
+///     .collect();
+///
+/// println!("{}", vowel_string);
+/// assert_eq!(vowel_string.len(), 10);
+/// assert!(vowel_string.chars().all(|c| vowels.contains(&c)));
+/// ```
+///
+/// For a single sample, [`SliceRandom::choose`][crate::seq::SliceRandom::choose]
+/// may be preferred:
+///
+/// ```
+/// use rand::seq::SliceRandom;
+///
+/// let vowels = ['a', 'e', 'i', 'o', 'u'];
+/// let mut rng = rand::thread_rng();
+///
+/// println!("{}", vowels.choose(&mut rng).unwrap())
+/// ```
+///
+/// [`SliceRandom`]: crate::seq::SliceRandom
+/// [`SliceRandom::choose`]: crate::seq::SliceRandom::choose
+/// [`SliceRandom::choose_multiple`]: crate::seq::SliceRandom::choose_multiple
+#[derive(Debug, Clone, Copy)]
+pub struct Slice<'a, T> {
+    slice: &'a [T],
+    range: Uniform<usize>,
+}
+
+impl<'a, T> Slice<'a, T> {
+    /// Create a new `Slice` instance which samples uniformly from the slice.
+    /// Returns `Err` if the slice is empty.
+    pub fn new(slice: &'a [T]) -> Result<Self, EmptySlice> {
+        match slice.len() {
+            0 => Err(EmptySlice),
+            len => Ok(Self {
+                slice,
+                range: Uniform::new(0, len),
+            }),
+        }
+    }
+}
+
+impl<'a, T> Distribution<&'a T> for Slice<'a, T> {
+    fn sample<R: crate::Rng + ?Sized>(&self, rng: &mut R) -> &'a T {
+        let idx = self.range.sample(rng);
+
+        debug_assert!(
+            idx < self.slice.len(),
+            "Uniform::new(0, {}) somehow returned {}",
+            self.slice.len(),
+            idx
+        );
+
+        // Safety: at construction time, it was ensured that the slice was
+        // non-empty, and that the `Uniform` range produces values in range
+        // for the slice
+        unsafe { self.slice.get_unchecked(idx) }
+    }
+}
+
+/// Error type indicating that a [`Slice`] distribution was improperly
+/// constructed with an empty slice.
+#[derive(Debug, Clone, Copy)]
+pub struct EmptySlice;
+
+impl core::fmt::Display for EmptySlice {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(
+            f,
+            "Tried to create a `distributions::Slice` with an empty slice"
+        )
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for EmptySlice {}
diff --git a/crates/rand/src/distributions/uniform.rs b/crates/rand/src/distributions/uniform.rs
new file mode 100644
index 0000000..261357b
--- /dev/null
+++ b/crates/rand/src/distributions/uniform.rs
@@ -0,0 +1,1658 @@
+// Copyright 2018-2020 Developers of the Rand project.
+// Copyright 2017 The Rust Project Developers.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! A distribution uniformly sampling numbers within a given range.
+//!
+//! [`Uniform`] is the standard distribution to sample uniformly from a range;
+//! e.g. `Uniform::new_inclusive(1, 6)` can sample integers from 1 to 6, like a
+//! standard die. [`Rng::gen_range`] supports any type supported by
+//! [`Uniform`].
+//!
+//! This distribution is provided with support for several primitive types
+//! (all integer and floating-point types) as well as [`std::time::Duration`],
+//! and supports extension to user-defined types via a type-specific *back-end*
+//! implementation.
+//!
+//! The types [`UniformInt`], [`UniformFloat`] and [`UniformDuration`] are the
+//! back-ends supporting sampling from primitive integer and floating-point
+//! ranges as well as from [`std::time::Duration`]; these types do not normally
+//! need to be used directly (unless implementing a derived back-end).
+//!
+//! # Example usage
+//!
+//! ```
+//! use rand::{Rng, thread_rng};
+//! use rand::distributions::Uniform;
+//!
+//! let mut rng = thread_rng();
+//! let side = Uniform::new(-10.0, 10.0);
+//!
+//! // sample between 1 and 10 points
+//! for _ in 0..rng.gen_range(1..=10) {
+//!     // sample a point from the square with sides -10 - 10 in two dimensions
+//!     let (x, y) = (rng.sample(side), rng.sample(side));
+//!     println!("Point: {}, {}", x, y);
+//! }
+//! ```
+//!
+//! # Extending `Uniform` to support a custom type
+//!
+//! To extend [`Uniform`] to support your own types, write a back-end which
+//! implements the [`UniformSampler`] trait, then implement the [`SampleUniform`]
+//! helper trait to "register" your back-end. See the `MyF32` example below.
+//!
+//! At a minimum, the back-end needs to store any parameters needed for sampling
+//! (e.g. the target range) and implement `new`, `new_inclusive` and `sample`.
+//! Those methods should include an assert to check the range is valid (i.e.
+//! `low < high`). The example below merely wraps another back-end.
+//!
+//! The `new`, `new_inclusive` and `sample_single` functions use arguments of
+//! type SampleBorrow<X> in order to support passing in values by reference or
+//! by value. In the implementation of these functions, you can choose to
+//! simply use the reference returned by [`SampleBorrow::borrow`], or you can choose
+//! to copy or clone the value, whatever is appropriate for your type.
+//!
+//! ```
+//! use rand::prelude::*;
+//! use rand::distributions::uniform::{Uniform, SampleUniform,
+//!         UniformSampler, UniformFloat, SampleBorrow};
+//!
+//! struct MyF32(f32);
+//!
+//! #[derive(Clone, Copy, Debug)]
+//! struct UniformMyF32(UniformFloat<f32>);
+//!
+//! impl UniformSampler for UniformMyF32 {
+//!     type X = MyF32;
+//!     fn new<B1, B2>(low: B1, high: B2) -> Self
+//!         where B1: SampleBorrow<Self::X> + Sized,
+//!               B2: SampleBorrow<Self::X> + Sized
+//!     {
+//!         UniformMyF32(UniformFloat::<f32>::new(low.borrow().0, high.borrow().0))
+//!     }
+//!     fn new_inclusive<B1, B2>(low: B1, high: B2) -> Self
+//!         where B1: SampleBorrow<Self::X> + Sized,
+//!               B2: SampleBorrow<Self::X> + Sized
+//!     {
+//!         UniformMyF32(UniformFloat::<f32>::new_inclusive(
+//!             low.borrow().0,
+//!             high.borrow().0,
+//!         ))
+//!     }
+//!     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Self::X {
+//!         MyF32(self.0.sample(rng))
+//!     }
+//! }
+//!
+//! impl SampleUniform for MyF32 {
+//!     type Sampler = UniformMyF32;
+//! }
+//!
+//! let (low, high) = (MyF32(17.0f32), MyF32(22.0f32));
+//! let uniform = Uniform::new(low, high);
+//! let x = uniform.sample(&mut thread_rng());
+//! ```
+//!
+//! [`SampleUniform`]: crate::distributions::uniform::SampleUniform
+//! [`UniformSampler`]: crate::distributions::uniform::UniformSampler
+//! [`UniformInt`]: crate::distributions::uniform::UniformInt
+//! [`UniformFloat`]: crate::distributions::uniform::UniformFloat
+//! [`UniformDuration`]: crate::distributions::uniform::UniformDuration
+//! [`SampleBorrow::borrow`]: crate::distributions::uniform::SampleBorrow::borrow
+
+use core::time::Duration;
+use core::ops::{Range, RangeInclusive};
+
+use crate::distributions::float::IntoFloat;
+use crate::distributions::utils::{BoolAsSIMD, FloatAsSIMD, FloatSIMDUtils, WideningMultiply};
+use crate::distributions::Distribution;
+use crate::{Rng, RngCore};
+
+#[cfg(not(feature = "std"))]
+#[allow(unused_imports)] // rustc doesn't detect that this is actually used
+use crate::distributions::utils::Float;
+
+#[cfg(feature = "simd_support")] use packed_simd::*;
+
+#[cfg(feature = "serde1")]
+use serde::{Serialize, Deserialize};
+
+/// Sample values uniformly between two bounds.
+///
+/// [`Uniform::new`] and [`Uniform::new_inclusive`] construct a uniform
+/// distribution sampling from the given range; these functions may do extra
+/// work up front to make sampling of multiple values faster. If only one sample
+/// from the range is required, [`Rng::gen_range`] can be more efficient.
+///
+/// When sampling from a constant range, many calculations can happen at
+/// compile-time and all methods should be fast; for floating-point ranges and
+/// the full range of integer types this should have comparable performance to
+/// the `Standard` distribution.
+///
+/// Steps are taken to avoid bias which might be present in naive
+/// implementations; for example `rng.gen::<u8>() % 170` samples from the range
+/// `[0, 169]` but is twice as likely to select numbers less than 85 than other
+/// values. Further, the implementations here give more weight to the high-bits
+/// generated by the RNG than the low bits, since with some RNGs the low-bits
+/// are of lower quality than the high bits.
+///
+/// Implementations must sample in `[low, high)` range for
+/// `Uniform::new(low, high)`, i.e., excluding `high`. In particular, care must
+/// be taken to ensure that rounding never results values `< low` or `>= high`.
+///
+/// # Example
+///
+/// ```
+/// use rand::distributions::{Distribution, Uniform};
+///
+/// let between = Uniform::from(10..10000);
+/// let mut rng = rand::thread_rng();
+/// let mut sum = 0;
+/// for _ in 0..1000 {
+///     sum += between.sample(&mut rng);
+/// }
+/// println!("{}", sum);
+/// ```
+///
+/// For a single sample, [`Rng::gen_range`] may be preferred:
+///
+/// ```
+/// use rand::Rng;
+///
+/// let mut rng = rand::thread_rng();
+/// println!("{}", rng.gen_range(0..10));
+/// ```
+///
+/// [`new`]: Uniform::new
+/// [`new_inclusive`]: Uniform::new_inclusive
+/// [`Rng::gen_range`]: Rng::gen_range
+#[derive(Clone, Copy, Debug, PartialEq)]
+#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde1", serde(bound(serialize = "X::Sampler: Serialize")))]
+#[cfg_attr(feature = "serde1", serde(bound(deserialize = "X::Sampler: Deserialize<'de>")))]
+pub struct Uniform<X: SampleUniform>(X::Sampler);
+
+impl<X: SampleUniform> Uniform<X> {
+    /// Create a new `Uniform` instance which samples uniformly from the half
+    /// open range `[low, high)` (excluding `high`). Panics if `low >= high`.
+    pub fn new<B1, B2>(low: B1, high: B2) -> Uniform<X>
+    where
+        B1: SampleBorrow<X> + Sized,
+        B2: SampleBorrow<X> + Sized,
+    {
+        Uniform(X::Sampler::new(low, high))
+    }
+
+    /// Create a new `Uniform` instance which samples uniformly from the closed
+    /// range `[low, high]` (inclusive). Panics if `low > high`.
+    pub fn new_inclusive<B1, B2>(low: B1, high: B2) -> Uniform<X>
+    where
+        B1: SampleBorrow<X> + Sized,
+        B2: SampleBorrow<X> + Sized,
+    {
+        Uniform(X::Sampler::new_inclusive(low, high))
+    }
+}
+
+impl<X: SampleUniform> Distribution<X> for Uniform<X> {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> X {
+        self.0.sample(rng)
+    }
+}
+
+/// Helper trait for creating objects using the correct implementation of
+/// [`UniformSampler`] for the sampling type.
+///
+/// See the [module documentation] on how to implement [`Uniform`] range
+/// sampling for a custom type.
+///
+/// [module documentation]: crate::distributions::uniform
+pub trait SampleUniform: Sized {
+    /// The `UniformSampler` implementation supporting type `X`.
+    type Sampler: UniformSampler<X = Self>;
+}
+
+/// Helper trait handling actual uniform sampling.
+///
+/// See the [module documentation] on how to implement [`Uniform`] range
+/// sampling for a custom type.
+///
+/// Implementation of [`sample_single`] is optional, and is only useful when
+/// the implementation can be faster than `Self::new(low, high).sample(rng)`.
+///
+/// [module documentation]: crate::distributions::uniform
+/// [`sample_single`]: UniformSampler::sample_single
+pub trait UniformSampler: Sized {
+    /// The type sampled by this implementation.
+    type X;
+
+    /// Construct self, with inclusive lower bound and exclusive upper bound
+    /// `[low, high)`.
+    ///
+    /// Usually users should not call this directly but instead use
+    /// `Uniform::new`, which asserts that `low < high` before calling this.
+    fn new<B1, B2>(low: B1, high: B2) -> Self
+    where
+        B1: SampleBorrow<Self::X> + Sized,
+        B2: SampleBorrow<Self::X> + Sized;
+
+    /// Construct self, with inclusive bounds `[low, high]`.
+    ///
+    /// Usually users should not call this directly but instead use
+    /// `Uniform::new_inclusive`, which asserts that `low <= high` before
+    /// calling this.
+    fn new_inclusive<B1, B2>(low: B1, high: B2) -> Self
+    where
+        B1: SampleBorrow<Self::X> + Sized,
+        B2: SampleBorrow<Self::X> + Sized;
+
+    /// Sample a value.
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Self::X;
+
+    /// Sample a single value uniformly from a range with inclusive lower bound
+    /// and exclusive upper bound `[low, high)`.
+    ///
+    /// By default this is implemented using
+    /// `UniformSampler::new(low, high).sample(rng)`. However, for some types
+    /// more optimal implementations for single usage may be provided via this
+    /// method (which is the case for integers and floats).
+    /// Results may not be identical.
+    ///
+    /// Note that to use this method in a generic context, the type needs to be
+    /// retrieved via `SampleUniform::Sampler` as follows:
+    /// ```
+    /// use rand::{thread_rng, distributions::uniform::{SampleUniform, UniformSampler}};
+    /// # #[allow(unused)]
+    /// fn sample_from_range<T: SampleUniform>(lb: T, ub: T) -> T {
+    ///     let mut rng = thread_rng();
+    ///     <T as SampleUniform>::Sampler::sample_single(lb, ub, &mut rng)
+    /// }
+    /// ```
+    fn sample_single<R: Rng + ?Sized, B1, B2>(low: B1, high: B2, rng: &mut R) -> Self::X
+    where
+        B1: SampleBorrow<Self::X> + Sized,
+        B2: SampleBorrow<Self::X> + Sized,
+    {
+        let uniform: Self = UniformSampler::new(low, high);
+        uniform.sample(rng)
+    }
+
+    /// Sample a single value uniformly from a range with inclusive lower bound
+    /// and inclusive upper bound `[low, high]`.
+    ///
+    /// By default this is implemented using
+    /// `UniformSampler::new_inclusive(low, high).sample(rng)`. However, for
+    /// some types more optimal implementations for single usage may be provided
+    /// via this method.
+    /// Results may not be identical.
+    fn sample_single_inclusive<R: Rng + ?Sized, B1, B2>(low: B1, high: B2, rng: &mut R)
+        -> Self::X
+        where B1: SampleBorrow<Self::X> + Sized,
+              B2: SampleBorrow<Self::X> + Sized
+    {
+        let uniform: Self = UniformSampler::new_inclusive(low, high);
+        uniform.sample(rng)
+    }
+}
+
+impl<X: SampleUniform> From<Range<X>> for Uniform<X> {
+    fn from(r: ::core::ops::Range<X>) -> Uniform<X> {
+        Uniform::new(r.start, r.end)
+    }
+}
+
+impl<X: SampleUniform> From<RangeInclusive<X>> for Uniform<X> {
+    fn from(r: ::core::ops::RangeInclusive<X>) -> Uniform<X> {
+        Uniform::new_inclusive(r.start(), r.end())
+    }
+}
+
+
+/// Helper trait similar to [`Borrow`] but implemented
+/// only for SampleUniform and references to SampleUniform in
+/// order to resolve ambiguity issues.
+///
+/// [`Borrow`]: std::borrow::Borrow
+pub trait SampleBorrow<Borrowed> {
+    /// Immutably borrows from an owned value. See [`Borrow::borrow`]
+    ///
+    /// [`Borrow::borrow`]: std::borrow::Borrow::borrow
+    fn borrow(&self) -> &Borrowed;
+}
+impl<Borrowed> SampleBorrow<Borrowed> for Borrowed
+where Borrowed: SampleUniform
+{
+    #[inline(always)]
+    fn borrow(&self) -> &Borrowed {
+        self
+    }
+}
+impl<'a, Borrowed> SampleBorrow<Borrowed> for &'a Borrowed
+where Borrowed: SampleUniform
+{
+    #[inline(always)]
+    fn borrow(&self) -> &Borrowed {
+        *self
+    }
+}
+
+/// Range that supports generating a single sample efficiently.
+///
+/// Any type implementing this trait can be used to specify the sampled range
+/// for `Rng::gen_range`.
+pub trait SampleRange<T> {
+    /// Generate a sample from the given range.
+    fn sample_single<R: RngCore + ?Sized>(self, rng: &mut R) -> T;
+
+    /// Check whether the range is empty.
+    fn is_empty(&self) -> bool;
+}
+
+impl<T: SampleUniform + PartialOrd> SampleRange<T> for Range<T> {
+    #[inline]
+    fn sample_single<R: RngCore + ?Sized>(self, rng: &mut R) -> T {
+        T::Sampler::sample_single(self.start, self.end, rng)
+    }
+
+    #[inline]
+    fn is_empty(&self) -> bool {
+        !(self.start < self.end)
+    }
+}
+
+impl<T: SampleUniform + PartialOrd> SampleRange<T> for RangeInclusive<T> {
+    #[inline]
+    fn sample_single<R: RngCore + ?Sized>(self, rng: &mut R) -> T {
+        T::Sampler::sample_single_inclusive(self.start(), self.end(), rng)
+    }
+
+    #[inline]
+    fn is_empty(&self) -> bool {
+        !(self.start() <= self.end())
+    }
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+
+// What follows are all back-ends.
+
+
+/// The back-end implementing [`UniformSampler`] for integer types.
+///
+/// Unless you are implementing [`UniformSampler`] for your own type, this type
+/// should not be used directly, use [`Uniform`] instead.
+///
+/// # Implementation notes
+///
+/// For simplicity, we use the same generic struct `UniformInt<X>` for all
+/// integer types `X`. This gives us only one field type, `X`; to store unsigned
+/// values of this size, we take use the fact that these conversions are no-ops.
+///
+/// For a closed range, the number of possible numbers we should generate is
+/// `range = (high - low + 1)`. To avoid bias, we must ensure that the size of
+/// our sample space, `zone`, is a multiple of `range`; other values must be
+/// rejected (by replacing with a new random sample).
+///
+/// As a special case, we use `range = 0` to represent the full range of the
+/// result type (i.e. for `new_inclusive($ty::MIN, $ty::MAX)`).
+///
+/// The optimum `zone` is the largest product of `range` which fits in our
+/// (unsigned) target type. We calculate this by calculating how many numbers we
+/// must reject: `reject = (MAX + 1) % range = (MAX - range + 1) % range`. Any (large)
+/// product of `range` will suffice, thus in `sample_single` we multiply by a
+/// power of 2 via bit-shifting (faster but may cause more rejections).
+///
+/// The smallest integer PRNGs generate is `u32`. For 8- and 16-bit outputs we
+/// use `u32` for our `zone` and samples (because it's not slower and because
+/// it reduces the chance of having to reject a sample). In this case we cannot
+/// store `zone` in the target type since it is too large, however we know
+/// `ints_to_reject < range <= $unsigned::MAX`.
+///
+/// An alternative to using a modulus is widening multiply: After a widening
+/// multiply by `range`, the result is in the high word. Then comparing the low
+/// word against `zone` makes sure our distribution is uniform.
+#[derive(Clone, Copy, Debug, PartialEq)]
+#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
+pub struct UniformInt<X> {
+    low: X,
+    range: X,
+    z: X, // either ints_to_reject or zone depending on implementation
+}
+
+macro_rules! uniform_int_impl {
+    ($ty:ty, $unsigned:ident, $u_large:ident) => {
+        impl SampleUniform for $ty {
+            type Sampler = UniformInt<$ty>;
+        }
+
+        impl UniformSampler for UniformInt<$ty> {
+            // We play free and fast with unsigned vs signed here
+            // (when $ty is signed), but that's fine, since the
+            // contract of this macro is for $ty and $unsigned to be
+            // "bit-equal", so casting between them is a no-op.
+
+            type X = $ty;
+
+            #[inline] // if the range is constant, this helps LLVM to do the
+                      // calculations at compile-time.
+            fn new<B1, B2>(low_b: B1, high_b: B2) -> Self
+            where
+                B1: SampleBorrow<Self::X> + Sized,
+                B2: SampleBorrow<Self::X> + Sized,
+            {
+                let low = *low_b.borrow();
+                let high = *high_b.borrow();
+                assert!(low < high, "Uniform::new called with `low >= high`");
+                UniformSampler::new_inclusive(low, high - 1)
+            }
+
+            #[inline] // if the range is constant, this helps LLVM to do the
+                      // calculations at compile-time.
+            fn new_inclusive<B1, B2>(low_b: B1, high_b: B2) -> Self
+            where
+                B1: SampleBorrow<Self::X> + Sized,
+                B2: SampleBorrow<Self::X> + Sized,
+            {
+                let low = *low_b.borrow();
+                let high = *high_b.borrow();
+                assert!(
+                    low <= high,
+                    "Uniform::new_inclusive called with `low > high`"
+                );
+                let unsigned_max = ::core::$u_large::MAX;
+
+                let range = high.wrapping_sub(low).wrapping_add(1) as $unsigned;
+                let ints_to_reject = if range > 0 {
+                    let range = $u_large::from(range);
+                    (unsigned_max - range + 1) % range
+                } else {
+                    0
+                };
+
+                UniformInt {
+                    low,
+                    // These are really $unsigned values, but store as $ty:
+                    range: range as $ty,
+                    z: ints_to_reject as $unsigned as $ty,
+                }
+            }
+
+            #[inline]
+            fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Self::X {
+                let range = self.range as $unsigned as $u_large;
+                if range > 0 {
+                    let unsigned_max = ::core::$u_large::MAX;
+                    let zone = unsigned_max - (self.z as $unsigned as $u_large);
+                    loop {
+                        let v: $u_large = rng.gen();
+                        let (hi, lo) = v.wmul(range);
+                        if lo <= zone {
+                            return self.low.wrapping_add(hi as $ty);
+                        }
+                    }
+                } else {
+                    // Sample from the entire integer range.
+                    rng.gen()
+                }
+            }
+
+            #[inline]
+            fn sample_single<R: Rng + ?Sized, B1, B2>(low_b: B1, high_b: B2, rng: &mut R) -> Self::X
+            where
+                B1: SampleBorrow<Self::X> + Sized,
+                B2: SampleBorrow<Self::X> + Sized,
+            {
+                let low = *low_b.borrow();
+                let high = *high_b.borrow();
+                assert!(low < high, "UniformSampler::sample_single: low >= high");
+                Self::sample_single_inclusive(low, high - 1, rng)
+            }
+
+            #[inline]
+            fn sample_single_inclusive<R: Rng + ?Sized, B1, B2>(low_b: B1, high_b: B2, rng: &mut R) -> Self::X
+            where
+                B1: SampleBorrow<Self::X> + Sized,
+                B2: SampleBorrow<Self::X> + Sized,
+            {
+                let low = *low_b.borrow();
+                let high = *high_b.borrow();
+                assert!(low <= high, "UniformSampler::sample_single_inclusive: low > high");
+                let range = high.wrapping_sub(low).wrapping_add(1) as $unsigned as $u_large;
+                // If the above resulted in wrap-around to 0, the range is $ty::MIN..=$ty::MAX,
+                // and any integer will do.
+                if range == 0 {
+                    return rng.gen();
+                }
+
+                let zone = if ::core::$unsigned::MAX <= ::core::u16::MAX as $unsigned {
+                    // Using a modulus is faster than the approximation for
+                    // i8 and i16. I suppose we trade the cost of one
+                    // modulus for near-perfect branch prediction.
+                    let unsigned_max: $u_large = ::core::$u_large::MAX;
+                    let ints_to_reject = (unsigned_max - range + 1) % range;
+                    unsigned_max - ints_to_reject
+                } else {
+                    // conservative but fast approximation. `- 1` is necessary to allow the
+                    // same comparison without bias.
+                    (range << range.leading_zeros()).wrapping_sub(1)
+                };
+
+                loop {
+                    let v: $u_large = rng.gen();
+                    let (hi, lo) = v.wmul(range);
+                    if lo <= zone {
+                        return low.wrapping_add(hi as $ty);
+                    }
+                }
+            }
+        }
+    };
+}
+
+uniform_int_impl! { i8, u8, u32 }
+uniform_int_impl! { i16, u16, u32 }
+uniform_int_impl! { i32, u32, u32 }
+uniform_int_impl! { i64, u64, u64 }
+uniform_int_impl! { i128, u128, u128 }
+uniform_int_impl! { isize, usize, usize }
+uniform_int_impl! { u8, u8, u32 }
+uniform_int_impl! { u16, u16, u32 }
+uniform_int_impl! { u32, u32, u32 }
+uniform_int_impl! { u64, u64, u64 }
+uniform_int_impl! { usize, usize, usize }
+uniform_int_impl! { u128, u128, u128 }
+
+#[cfg(feature = "simd_support")]
+macro_rules! uniform_simd_int_impl {
+    ($ty:ident, $unsigned:ident, $u_scalar:ident) => {
+        // The "pick the largest zone that can fit in an `u32`" optimization
+        // is less useful here. Multiple lanes complicate things, we don't
+        // know the PRNG's minimal output size, and casting to a larger vector
+        // is generally a bad idea for SIMD performance. The user can still
+        // implement it manually.
+
+        // TODO: look into `Uniform::<u32x4>::new(0u32, 100)` functionality
+        //       perhaps `impl SampleUniform for $u_scalar`?
+        impl SampleUniform for $ty {
+            type Sampler = UniformInt<$ty>;
+        }
+
+        impl UniformSampler for UniformInt<$ty> {
+            type X = $ty;
+
+            #[inline] // if the range is constant, this helps LLVM to do the
+                      // calculations at compile-time.
+            fn new<B1, B2>(low_b: B1, high_b: B2) -> Self
+                where B1: SampleBorrow<Self::X> + Sized,
+                      B2: SampleBorrow<Self::X> + Sized
+            {
+                let low = *low_b.borrow();
+                let high = *high_b.borrow();
+                assert!(low.lt(high).all(), "Uniform::new called with `low >= high`");
+                UniformSampler::new_inclusive(low, high - 1)
+            }
+
+            #[inline] // if the range is constant, this helps LLVM to do the
+                      // calculations at compile-time.
+            fn new_inclusive<B1, B2>(low_b: B1, high_b: B2) -> Self
+                where B1: SampleBorrow<Self::X> + Sized,
+                      B2: SampleBorrow<Self::X> + Sized
+            {
+                let low = *low_b.borrow();
+                let high = *high_b.borrow();
+                assert!(low.le(high).all(),
+                        "Uniform::new_inclusive called with `low > high`");
+                let unsigned_max = ::core::$u_scalar::MAX;
+
+                // NOTE: these may need to be replaced with explicitly
+                // wrapping operations if `packed_simd` changes
+                let range: $unsigned = ((high - low) + 1).cast();
+                // `% 0` will panic at runtime.
+                let not_full_range = range.gt($unsigned::splat(0));
+                // replacing 0 with `unsigned_max` allows a faster `select`
+                // with bitwise OR
+                let modulo = not_full_range.select(range, $unsigned::splat(unsigned_max));
+                // wrapping addition
+                let ints_to_reject = (unsigned_max - range + 1) % modulo;
+                // When `range` is 0, `lo` of `v.wmul(range)` will always be
+                // zero which means only one sample is needed.
+                let zone = unsigned_max - ints_to_reject;
+
+                UniformInt {
+                    low,
+                    // These are really $unsigned values, but store as $ty:
+                    range: range.cast(),
+                    z: zone.cast(),
+                }
+            }
+
+            fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Self::X {
+                let range: $unsigned = self.range.cast();
+                let zone: $unsigned = self.z.cast();
+
+                // This might seem very slow, generating a whole new
+                // SIMD vector for every sample rejection. For most uses
+                // though, the chance of rejection is small and provides good
+                // general performance. With multiple lanes, that chance is
+                // multiplied. To mitigate this, we replace only the lanes of
+                // the vector which fail, iteratively reducing the chance of
+                // rejection. The replacement method does however add a little
+                // overhead. Benchmarking or calculating probabilities might
+                // reveal contexts where this replacement method is slower.
+                let mut v: $unsigned = rng.gen();
+                loop {
+                    let (hi, lo) = v.wmul(range);
+                    let mask = lo.le(zone);
+                    if mask.all() {
+                        let hi: $ty = hi.cast();
+                        // wrapping addition
+                        let result = self.low + hi;
+                        // `select` here compiles to a blend operation
+                        // When `range.eq(0).none()` the compare and blend
+                        // operations are avoided.
+                        let v: $ty = v.cast();
+                        return range.gt($unsigned::splat(0)).select(result, v);
+                    }
+                    // Replace only the failing lanes
+                    v = mask.select(v, rng.gen());
+                }
+            }
+        }
+    };
+
+    // bulk implementation
+    ($(($unsigned:ident, $signed:ident),)+ $u_scalar:ident) => {
+        $(
+            uniform_simd_int_impl!($unsigned, $unsigned, $u_scalar);
+            uniform_simd_int_impl!($signed, $unsigned, $u_scalar);
+        )+
+    };
+}
+
+#[cfg(feature = "simd_support")]
+uniform_simd_int_impl! {
+    (u64x2, i64x2),
+    (u64x4, i64x4),
+    (u64x8, i64x8),
+    u64
+}
+
+#[cfg(feature = "simd_support")]
+uniform_simd_int_impl! {
+    (u32x2, i32x2),
+    (u32x4, i32x4),
+    (u32x8, i32x8),
+    (u32x16, i32x16),
+    u32
+}
+
+#[cfg(feature = "simd_support")]
+uniform_simd_int_impl! {
+    (u16x2, i16x2),
+    (u16x4, i16x4),
+    (u16x8, i16x8),
+    (u16x16, i16x16),
+    (u16x32, i16x32),
+    u16
+}
+
+#[cfg(feature = "simd_support")]
+uniform_simd_int_impl! {
+    (u8x2, i8x2),
+    (u8x4, i8x4),
+    (u8x8, i8x8),
+    (u8x16, i8x16),
+    (u8x32, i8x32),
+    (u8x64, i8x64),
+    u8
+}
+
+impl SampleUniform for char {
+    type Sampler = UniformChar;
+}
+
+/// The back-end implementing [`UniformSampler`] for `char`.
+///
+/// Unless you are implementing [`UniformSampler`] for your own type, this type
+/// should not be used directly, use [`Uniform`] instead.
+///
+/// This differs from integer range sampling since the range `0xD800..=0xDFFF`
+/// are used for surrogate pairs in UCS and UTF-16, and consequently are not
+/// valid Unicode code points. We must therefore avoid sampling values in this
+/// range.
+#[derive(Clone, Copy, Debug)]
+#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
+pub struct UniformChar {
+    sampler: UniformInt<u32>,
+}
+
+/// UTF-16 surrogate range start
+const CHAR_SURROGATE_START: u32 = 0xD800;
+/// UTF-16 surrogate range size
+const CHAR_SURROGATE_LEN: u32 = 0xE000 - CHAR_SURROGATE_START;
+
+/// Convert `char` to compressed `u32`
+fn char_to_comp_u32(c: char) -> u32 {
+    match c as u32 {
+        c if c >= CHAR_SURROGATE_START => c - CHAR_SURROGATE_LEN,
+        c => c,
+    }
+}
+
+impl UniformSampler for UniformChar {
+    type X = char;
+
+    #[inline] // if the range is constant, this helps LLVM to do the
+              // calculations at compile-time.
+    fn new<B1, B2>(low_b: B1, high_b: B2) -> Self
+    where
+        B1: SampleBorrow<Self::X> + Sized,
+        B2: SampleBorrow<Self::X> + Sized,
+    {
+        let low = char_to_comp_u32(*low_b.borrow());
+        let high = char_to_comp_u32(*high_b.borrow());
+        let sampler = UniformInt::<u32>::new(low, high);
+        UniformChar { sampler }
+    }
+
+    #[inline] // if the range is constant, this helps LLVM to do the
+              // calculations at compile-time.
+    fn new_inclusive<B1, B2>(low_b: B1, high_b: B2) -> Self
+    where
+        B1: SampleBorrow<Self::X> + Sized,
+        B2: SampleBorrow<Self::X> + Sized,
+    {
+        let low = char_to_comp_u32(*low_b.borrow());
+        let high = char_to_comp_u32(*high_b.borrow());
+        let sampler = UniformInt::<u32>::new_inclusive(low, high);
+        UniformChar { sampler }
+    }
+
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Self::X {
+        let mut x = self.sampler.sample(rng);
+        if x >= CHAR_SURROGATE_START {
+            x += CHAR_SURROGATE_LEN;
+        }
+        // SAFETY: x must not be in surrogate range or greater than char::MAX.
+        // This relies on range constructors which accept char arguments.
+        // Validity of input char values is assumed.
+        unsafe { core::char::from_u32_unchecked(x) }
+    }
+}
+
+/// The back-end implementing [`UniformSampler`] for floating-point types.
+///
+/// Unless you are implementing [`UniformSampler`] for your own type, this type
+/// should not be used directly, use [`Uniform`] instead.
+///
+/// # Implementation notes
+///
+/// Instead of generating a float in the `[0, 1)` range using [`Standard`], the
+/// `UniformFloat` implementation converts the output of an PRNG itself. This
+/// way one or two steps can be optimized out.
+///
+/// The floats are first converted to a value in the `[1, 2)` interval using a
+/// transmute-based method, and then mapped to the expected range with a
+/// multiply and addition. Values produced this way have what equals 23 bits of
+/// random digits for an `f32`, and 52 for an `f64`.
+///
+/// [`new`]: UniformSampler::new
+/// [`new_inclusive`]: UniformSampler::new_inclusive
+/// [`Standard`]: crate::distributions::Standard
+#[derive(Clone, Copy, Debug, PartialEq)]
+#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
+pub struct UniformFloat<X> {
+    low: X,
+    scale: X,
+}
+
+macro_rules! uniform_float_impl {
+    ($ty:ty, $uty:ident, $f_scalar:ident, $u_scalar:ident, $bits_to_discard:expr) => {
+        impl SampleUniform for $ty {
+            type Sampler = UniformFloat<$ty>;
+        }
+
+        impl UniformSampler for UniformFloat<$ty> {
+            type X = $ty;
+
+            fn new<B1, B2>(low_b: B1, high_b: B2) -> Self
+            where
+                B1: SampleBorrow<Self::X> + Sized,
+                B2: SampleBorrow<Self::X> + Sized,
+            {
+                let low = *low_b.borrow();
+                let high = *high_b.borrow();
+                debug_assert!(
+                    low.all_finite(),
+                    "Uniform::new called with `low` non-finite."
+                );
+                debug_assert!(
+                    high.all_finite(),
+                    "Uniform::new called with `high` non-finite."
+                );
+                assert!(low.all_lt(high), "Uniform::new called with `low >= high`");
+                let max_rand = <$ty>::splat(
+                    (::core::$u_scalar::MAX >> $bits_to_discard).into_float_with_exponent(0) - 1.0,
+                );
+
+                let mut scale = high - low;
+                assert!(scale.all_finite(), "Uniform::new: range overflow");
+
+                loop {
+                    let mask = (scale * max_rand + low).ge_mask(high);
+                    if mask.none() {
+                        break;
+                    }
+                    scale = scale.decrease_masked(mask);
+                }
+
+                debug_assert!(<$ty>::splat(0.0).all_le(scale));
+
+                UniformFloat { low, scale }
+            }
+
+            fn new_inclusive<B1, B2>(low_b: B1, high_b: B2) -> Self
+            where
+                B1: SampleBorrow<Self::X> + Sized,
+                B2: SampleBorrow<Self::X> + Sized,
+            {
+                let low = *low_b.borrow();
+                let high = *high_b.borrow();
+                debug_assert!(
+                    low.all_finite(),
+                    "Uniform::new_inclusive called with `low` non-finite."
+                );
+                debug_assert!(
+                    high.all_finite(),
+                    "Uniform::new_inclusive called with `high` non-finite."
+                );
+                assert!(
+                    low.all_le(high),
+                    "Uniform::new_inclusive called with `low > high`"
+                );
+                let max_rand = <$ty>::splat(
+                    (::core::$u_scalar::MAX >> $bits_to_discard).into_float_with_exponent(0) - 1.0,
+                );
+
+                let mut scale = (high - low) / max_rand;
+                assert!(scale.all_finite(), "Uniform::new_inclusive: range overflow");
+
+                loop {
+                    let mask = (scale * max_rand + low).gt_mask(high);
+                    if mask.none() {
+                        break;
+                    }
+                    scale = scale.decrease_masked(mask);
+                }
+
+                debug_assert!(<$ty>::splat(0.0).all_le(scale));
+
+                UniformFloat { low, scale }
+            }
+
+            fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Self::X {
+                // Generate a value in the range [1, 2)
+                let value1_2 = (rng.gen::<$uty>() >> $bits_to_discard).into_float_with_exponent(0);
+
+                // Get a value in the range [0, 1) in order to avoid
+                // overflowing into infinity when multiplying with scale
+                let value0_1 = value1_2 - 1.0;
+
+                // We don't use `f64::mul_add`, because it is not available with
+                // `no_std`. Furthermore, it is slower for some targets (but
+                // faster for others). However, the order of multiplication and
+                // addition is important, because on some platforms (e.g. ARM)
+                // it will be optimized to a single (non-FMA) instruction.
+                value0_1 * self.scale + self.low
+            }
+
+            #[inline]
+            fn sample_single<R: Rng + ?Sized, B1, B2>(low_b: B1, high_b: B2, rng: &mut R) -> Self::X
+            where
+                B1: SampleBorrow<Self::X> + Sized,
+                B2: SampleBorrow<Self::X> + Sized,
+            {
+                let low = *low_b.borrow();
+                let high = *high_b.borrow();
+                debug_assert!(
+                    low.all_finite(),
+                    "UniformSampler::sample_single called with `low` non-finite."
+                );
+                debug_assert!(
+                    high.all_finite(),
+                    "UniformSampler::sample_single called with `high` non-finite."
+                );
+                assert!(
+                    low.all_lt(high),
+                    "UniformSampler::sample_single: low >= high"
+                );
+                let mut scale = high - low;
+                assert!(scale.all_finite(), "UniformSampler::sample_single: range overflow");
+
+                loop {
+                    // Generate a value in the range [1, 2)
+                    let value1_2 =
+                        (rng.gen::<$uty>() >> $bits_to_discard).into_float_with_exponent(0);
+
+                    // Get a value in the range [0, 1) in order to avoid
+                    // overflowing into infinity when multiplying with scale
+                    let value0_1 = value1_2 - 1.0;
+
+                    // Doing multiply before addition allows some architectures
+                    // to use a single instruction.
+                    let res = value0_1 * scale + low;
+
+                    debug_assert!(low.all_le(res) || !scale.all_finite());
+                    if res.all_lt(high) {
+                        return res;
+                    }
+
+                    // This handles a number of edge cases.
+                    // * `low` or `high` is NaN. In this case `scale` and
+                    //   `res` are going to end up as NaN.
+                    // * `low` is negative infinity and `high` is finite.
+                    //   `scale` is going to be infinite and `res` will be
+                    //   NaN.
+                    // * `high` is positive infinity and `low` is finite.
+                    //   `scale` is going to be infinite and `res` will
+                    //   be infinite or NaN (if value0_1 is 0).
+                    // * `low` is negative infinity and `high` is positive
+                    //   infinity. `scale` will be infinite and `res` will
+                    //   be NaN.
+                    // * `low` and `high` are finite, but `high - low`
+                    //   overflows to infinite. `scale` will be infinite
+                    //   and `res` will be infinite or NaN (if value0_1 is 0).
+                    // So if `high` or `low` are non-finite, we are guaranteed
+                    // to fail the `res < high` check above and end up here.
+                    //
+                    // While we technically should check for non-finite `low`
+                    // and `high` before entering the loop, by doing the checks
+                    // here instead, we allow the common case to avoid these
+                    // checks. But we are still guaranteed that if `low` or
+                    // `high` are non-finite we'll end up here and can do the
+                    // appropriate checks.
+                    //
+                    // Likewise `high - low` overflowing to infinity is also
+                    // rare, so handle it here after the common case.
+                    let mask = !scale.finite_mask();
+                    if mask.any() {
+                        assert!(
+                            low.all_finite() && high.all_finite(),
+                            "Uniform::sample_single: low and high must be finite"
+                        );
+                        scale = scale.decrease_masked(mask);
+                    }
+                }
+            }
+        }
+    };
+}
+
+uniform_float_impl! { f32, u32, f32, u32, 32 - 23 }
+uniform_float_impl! { f64, u64, f64, u64, 64 - 52 }
+
+#[cfg(feature = "simd_support")]
+uniform_float_impl! { f32x2, u32x2, f32, u32, 32 - 23 }
+#[cfg(feature = "simd_support")]
+uniform_float_impl! { f32x4, u32x4, f32, u32, 32 - 23 }
+#[cfg(feature = "simd_support")]
+uniform_float_impl! { f32x8, u32x8, f32, u32, 32 - 23 }
+#[cfg(feature = "simd_support")]
+uniform_float_impl! { f32x16, u32x16, f32, u32, 32 - 23 }
+
+#[cfg(feature = "simd_support")]
+uniform_float_impl! { f64x2, u64x2, f64, u64, 64 - 52 }
+#[cfg(feature = "simd_support")]
+uniform_float_impl! { f64x4, u64x4, f64, u64, 64 - 52 }
+#[cfg(feature = "simd_support")]
+uniform_float_impl! { f64x8, u64x8, f64, u64, 64 - 52 }
+
+
+/// The back-end implementing [`UniformSampler`] for `Duration`.
+///
+/// Unless you are implementing [`UniformSampler`] for your own types, this type
+/// should not be used directly, use [`Uniform`] instead.
+#[derive(Clone, Copy, Debug)]
+#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
+pub struct UniformDuration {
+    mode: UniformDurationMode,
+    offset: u32,
+}
+
+#[derive(Debug, Copy, Clone)]
+#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
+enum UniformDurationMode {
+    Small {
+        secs: u64,
+        nanos: Uniform<u32>,
+    },
+    Medium {
+        nanos: Uniform<u64>,
+    },
+    Large {
+        max_secs: u64,
+        max_nanos: u32,
+        secs: Uniform<u64>,
+    },
+}
+
+impl SampleUniform for Duration {
+    type Sampler = UniformDuration;
+}
+
+impl UniformSampler for UniformDuration {
+    type X = Duration;
+
+    #[inline]
+    fn new<B1, B2>(low_b: B1, high_b: B2) -> Self
+    where
+        B1: SampleBorrow<Self::X> + Sized,
+        B2: SampleBorrow<Self::X> + Sized,
+    {
+        let low = *low_b.borrow();
+        let high = *high_b.borrow();
+        assert!(low < high, "Uniform::new called with `low >= high`");
+        UniformDuration::new_inclusive(low, high - Duration::new(0, 1))
+    }
+
+    #[inline]
+    fn new_inclusive<B1, B2>(low_b: B1, high_b: B2) -> Self
+    where
+        B1: SampleBorrow<Self::X> + Sized,
+        B2: SampleBorrow<Self::X> + Sized,
+    {
+        let low = *low_b.borrow();
+        let high = *high_b.borrow();
+        assert!(
+            low <= high,
+            "Uniform::new_inclusive called with `low > high`"
+        );
+
+        let low_s = low.as_secs();
+        let low_n = low.subsec_nanos();
+        let mut high_s = high.as_secs();
+        let mut high_n = high.subsec_nanos();
+
+        if high_n < low_n {
+            high_s -= 1;
+            high_n += 1_000_000_000;
+        }
+
+        let mode = if low_s == high_s {
+            UniformDurationMode::Small {
+                secs: low_s,
+                nanos: Uniform::new_inclusive(low_n, high_n),
+            }
+        } else {
+            let max = high_s
+                .checked_mul(1_000_000_000)
+                .and_then(|n| n.checked_add(u64::from(high_n)));
+
+            if let Some(higher_bound) = max {
+                let lower_bound = low_s * 1_000_000_000 + u64::from(low_n);
+                UniformDurationMode::Medium {
+                    nanos: Uniform::new_inclusive(lower_bound, higher_bound),
+                }
+            } else {
+                // An offset is applied to simplify generation of nanoseconds
+                let max_nanos = high_n - low_n;
+                UniformDurationMode::Large {
+                    max_secs: high_s,
+                    max_nanos,
+                    secs: Uniform::new_inclusive(low_s, high_s),
+                }
+            }
+        };
+        UniformDuration {
+            mode,
+            offset: low_n,
+        }
+    }
+
+    #[inline]
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Duration {
+        match self.mode {
+            UniformDurationMode::Small { secs, nanos } => {
+                let n = nanos.sample(rng);
+                Duration::new(secs, n)
+            }
+            UniformDurationMode::Medium { nanos } => {
+                let nanos = nanos.sample(rng);
+                Duration::new(nanos / 1_000_000_000, (nanos % 1_000_000_000) as u32)
+            }
+            UniformDurationMode::Large {
+                max_secs,
+                max_nanos,
+                secs,
+            } => {
+                // constant folding means this is at least as fast as `Rng::sample(Range)`
+                let nano_range = Uniform::new(0, 1_000_000_000);
+                loop {
+                    let s = secs.sample(rng);
+                    let n = nano_range.sample(rng);
+                    if !(s == max_secs && n > max_nanos) {
+                        let sum = n + self.offset;
+                        break Duration::new(s, sum);
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::rngs::mock::StepRng;
+
+    #[test]
+    #[cfg(feature = "serde1")]
+    fn test_serialization_uniform_duration() {
+        let distr = UniformDuration::new(Duration::from_secs(10), Duration::from_secs(60));
+        let de_distr: UniformDuration = bincode::deserialize(&bincode::serialize(&distr).unwrap()).unwrap();
+        assert_eq!(
+            distr.offset, de_distr.offset
+        );
+        match (distr.mode, de_distr.mode) {
+            (UniformDurationMode::Small {secs: a_secs, nanos: a_nanos}, UniformDurationMode::Small {secs, nanos}) => {
+                assert_eq!(a_secs, secs);
+
+                assert_eq!(a_nanos.0.low, nanos.0.low);
+                assert_eq!(a_nanos.0.range, nanos.0.range);
+                assert_eq!(a_nanos.0.z, nanos.0.z);
+            }
+            (UniformDurationMode::Medium {nanos: a_nanos} , UniformDurationMode::Medium {nanos}) => {
+                assert_eq!(a_nanos.0.low, nanos.0.low);
+                assert_eq!(a_nanos.0.range, nanos.0.range);
+                assert_eq!(a_nanos.0.z, nanos.0.z);
+            }
+            (UniformDurationMode::Large {max_secs:a_max_secs, max_nanos:a_max_nanos, secs:a_secs}, UniformDurationMode::Large {max_secs, max_nanos, secs} ) => {
+                assert_eq!(a_max_secs, max_secs);
+                assert_eq!(a_max_nanos, max_nanos);
+
+                assert_eq!(a_secs.0.low, secs.0.low);
+                assert_eq!(a_secs.0.range, secs.0.range);
+                assert_eq!(a_secs.0.z, secs.0.z);
+            }
+            _ => panic!("`UniformDurationMode` was not serialized/deserialized correctly")
+        }
+    }
+    
+    #[test]
+    #[cfg(feature = "serde1")]
+    fn test_uniform_serialization() {
+        let unit_box: Uniform<i32>  = Uniform::new(-1, 1);
+        let de_unit_box: Uniform<i32> = bincode::deserialize(&bincode::serialize(&unit_box).unwrap()).unwrap();
+
+        assert_eq!(unit_box.0.low, de_unit_box.0.low);
+        assert_eq!(unit_box.0.range, de_unit_box.0.range);
+        assert_eq!(unit_box.0.z, de_unit_box.0.z);
+
+        let unit_box: Uniform<f32> = Uniform::new(-1., 1.);
+        let de_unit_box: Uniform<f32> = bincode::deserialize(&bincode::serialize(&unit_box).unwrap()).unwrap();
+
+        assert_eq!(unit_box.0.low, de_unit_box.0.low);
+        assert_eq!(unit_box.0.scale, de_unit_box.0.scale);
+    }
+
+    #[should_panic]
+    #[test]
+    fn test_uniform_bad_limits_equal_int() {
+        Uniform::new(10, 10);
+    }
+
+    #[test]
+    fn test_uniform_good_limits_equal_int() {
+        let mut rng = crate::test::rng(804);
+        let dist = Uniform::new_inclusive(10, 10);
+        for _ in 0..20 {
+            assert_eq!(rng.sample(dist), 10);
+        }
+    }
+
+    #[should_panic]
+    #[test]
+    fn test_uniform_bad_limits_flipped_int() {
+        Uniform::new(10, 5);
+    }
+
+    #[test]
+    #[cfg_attr(miri, ignore)] // Miri is too slow
+    fn test_integers() {
+        use core::{i128, u128};
+        use core::{i16, i32, i64, i8, isize};
+        use core::{u16, u32, u64, u8, usize};
+
+        let mut rng = crate::test::rng(251);
+        macro_rules! t {
+            ($ty:ident, $v:expr, $le:expr, $lt:expr) => {{
+                for &(low, high) in $v.iter() {
+                    let my_uniform = Uniform::new(low, high);
+                    for _ in 0..1000 {
+                        let v: $ty = rng.sample(my_uniform);
+                        assert!($le(low, v) && $lt(v, high));
+                    }
+
+                    let my_uniform = Uniform::new_inclusive(low, high);
+                    for _ in 0..1000 {
+                        let v: $ty = rng.sample(my_uniform);
+                        assert!($le(low, v) && $le(v, high));
+                    }
+
+                    let my_uniform = Uniform::new(&low, high);
+                    for _ in 0..1000 {
+                        let v: $ty = rng.sample(my_uniform);
+                        assert!($le(low, v) && $lt(v, high));
+                    }
+
+                    let my_uniform = Uniform::new_inclusive(&low, &high);
+                    for _ in 0..1000 {
+                        let v: $ty = rng.sample(my_uniform);
+                        assert!($le(low, v) && $le(v, high));
+                    }
+
+                    for _ in 0..1000 {
+                        let v = <$ty as SampleUniform>::Sampler::sample_single(low, high, &mut rng);
+                        assert!($le(low, v) && $lt(v, high));
+                    }
+
+                    for _ in 0..1000 {
+                        let v = <$ty as SampleUniform>::Sampler::sample_single_inclusive(low, high, &mut rng);
+                        assert!($le(low, v) && $le(v, high));
+                    }
+                }
+            }};
+
+            // scalar bulk
+            ($($ty:ident),*) => {{
+                $(t!(
+                    $ty,
+                    [(0, 10), (10, 127), ($ty::MIN, $ty::MAX)],
+                    |x, y| x <= y,
+                    |x, y| x < y
+                );)*
+            }};
+
+            // simd bulk
+            ($($ty:ident),* => $scalar:ident) => {{
+                $(t!(
+                    $ty,
+                    [
+                        ($ty::splat(0), $ty::splat(10)),
+                        ($ty::splat(10), $ty::splat(127)),
+                        ($ty::splat($scalar::MIN), $ty::splat($scalar::MAX)),
+                    ],
+                    |x: $ty, y| x.le(y).all(),
+                    |x: $ty, y| x.lt(y).all()
+                );)*
+            }};
+        }
+        t!(i8, i16, i32, i64, isize, u8, u16, u32, u64, usize, i128, u128);
+
+        #[cfg(feature = "simd_support")]
+        {
+            t!(u8x2, u8x4, u8x8, u8x16, u8x32, u8x64 => u8);
+            t!(i8x2, i8x4, i8x8, i8x16, i8x32, i8x64 => i8);
+            t!(u16x2, u16x4, u16x8, u16x16, u16x32 => u16);
+            t!(i16x2, i16x4, i16x8, i16x16, i16x32 => i16);
+            t!(u32x2, u32x4, u32x8, u32x16 => u32);
+            t!(i32x2, i32x4, i32x8, i32x16 => i32);
+            t!(u64x2, u64x4, u64x8 => u64);
+            t!(i64x2, i64x4, i64x8 => i64);
+        }
+    }
+
+    #[test]
+    #[cfg_attr(miri, ignore)] // Miri is too slow
+    fn test_char() {
+        let mut rng = crate::test::rng(891);
+        let mut max = core::char::from_u32(0).unwrap();
+        for _ in 0..100 {
+            let c = rng.gen_range('A'..='Z');
+            assert!(('A'..='Z').contains(&c));
+            max = max.max(c);
+        }
+        assert_eq!(max, 'Z');
+        let d = Uniform::new(
+            core::char::from_u32(0xD7F0).unwrap(),
+            core::char::from_u32(0xE010).unwrap(),
+        );
+        for _ in 0..100 {
+            let c = d.sample(&mut rng);
+            assert!((c as u32) < 0xD800 || (c as u32) > 0xDFFF);
+        }
+    }
+
+    #[test]
+    #[cfg_attr(miri, ignore)] // Miri is too slow
+    fn test_floats() {
+        let mut rng = crate::test::rng(252);
+        let mut zero_rng = StepRng::new(0, 0);
+        let mut max_rng = StepRng::new(0xffff_ffff_ffff_ffff, 0);
+        macro_rules! t {
+            ($ty:ty, $f_scalar:ident, $bits_shifted:expr) => {{
+                let v: &[($f_scalar, $f_scalar)] = &[
+                    (0.0, 100.0),
+                    (-1e35, -1e25),
+                    (1e-35, 1e-25),
+                    (-1e35, 1e35),
+                    (<$f_scalar>::from_bits(0), <$f_scalar>::from_bits(3)),
+                    (-<$f_scalar>::from_bits(10), -<$f_scalar>::from_bits(1)),
+                    (-<$f_scalar>::from_bits(5), 0.0),
+                    (-<$f_scalar>::from_bits(7), -0.0),
+                    (0.1 * ::core::$f_scalar::MAX, ::core::$f_scalar::MAX),
+                    (-::core::$f_scalar::MAX * 0.2, ::core::$f_scalar::MAX * 0.7),
+                ];
+                for &(low_scalar, high_scalar) in v.iter() {
+                    for lane in 0..<$ty>::lanes() {
+                        let low = <$ty>::splat(0.0 as $f_scalar).replace(lane, low_scalar);
+                        let high = <$ty>::splat(1.0 as $f_scalar).replace(lane, high_scalar);
+                        let my_uniform = Uniform::new(low, high);
+                        let my_incl_uniform = Uniform::new_inclusive(low, high);
+                        for _ in 0..100 {
+                            let v = rng.sample(my_uniform).extract(lane);
+                            assert!(low_scalar <= v && v < high_scalar);
+                            let v = rng.sample(my_incl_uniform).extract(lane);
+                            assert!(low_scalar <= v && v <= high_scalar);
+                            let v = <$ty as SampleUniform>::Sampler
+                                ::sample_single(low, high, &mut rng).extract(lane);
+                            assert!(low_scalar <= v && v < high_scalar);
+                        }
+
+                        assert_eq!(
+                            rng.sample(Uniform::new_inclusive(low, low)).extract(lane),
+                            low_scalar
+                        );
+
+                        assert_eq!(zero_rng.sample(my_uniform).extract(lane), low_scalar);
+                        assert_eq!(zero_rng.sample(my_incl_uniform).extract(lane), low_scalar);
+                        assert_eq!(<$ty as SampleUniform>::Sampler
+                            ::sample_single(low, high, &mut zero_rng)
+                            .extract(lane), low_scalar);
+                        assert!(max_rng.sample(my_uniform).extract(lane) < high_scalar);
+                        assert!(max_rng.sample(my_incl_uniform).extract(lane) <= high_scalar);
+
+                        // Don't run this test for really tiny differences between high and low
+                        // since for those rounding might result in selecting high for a very
+                        // long time.
+                        if (high_scalar - low_scalar) > 0.0001 {
+                            let mut lowering_max_rng = StepRng::new(
+                                0xffff_ffff_ffff_ffff,
+                                (-1i64 << $bits_shifted) as u64,
+                            );
+                            assert!(
+                                <$ty as SampleUniform>::Sampler
+                                    ::sample_single(low, high, &mut lowering_max_rng)
+                                    .extract(lane) < high_scalar
+                            );
+                        }
+                    }
+                }
+
+                assert_eq!(
+                    rng.sample(Uniform::new_inclusive(
+                        ::core::$f_scalar::MAX,
+                        ::core::$f_scalar::MAX
+                    )),
+                    ::core::$f_scalar::MAX
+                );
+                assert_eq!(
+                    rng.sample(Uniform::new_inclusive(
+                        -::core::$f_scalar::MAX,
+                        -::core::$f_scalar::MAX
+                    )),
+                    -::core::$f_scalar::MAX
+                );
+            }};
+        }
+
+        t!(f32, f32, 32 - 23);
+        t!(f64, f64, 64 - 52);
+        #[cfg(feature = "simd_support")]
+        {
+            t!(f32x2, f32, 32 - 23);
+            t!(f32x4, f32, 32 - 23);
+            t!(f32x8, f32, 32 - 23);
+            t!(f32x16, f32, 32 - 23);
+            t!(f64x2, f64, 64 - 52);
+            t!(f64x4, f64, 64 - 52);
+            t!(f64x8, f64, 64 - 52);
+        }
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_float_overflow() {
+        let _ = Uniform::from(::core::f64::MIN..::core::f64::MAX);
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_float_overflow_single() {
+        let mut rng = crate::test::rng(252);
+        rng.gen_range(::core::f64::MIN..::core::f64::MAX);
+    }
+
+    #[test]
+    #[cfg(all(
+        feature = "std",
+        not(target_arch = "wasm32"),
+        not(target_arch = "asmjs")
+    ))]
+    fn test_float_assertions() {
+        use super::SampleUniform;
+        use std::panic::catch_unwind;
+        fn range<T: SampleUniform>(low: T, high: T) {
+            let mut rng = crate::test::rng(253);
+            T::Sampler::sample_single(low, high, &mut rng);
+        }
+
+        macro_rules! t {
+            ($ty:ident, $f_scalar:ident) => {{
+                let v: &[($f_scalar, $f_scalar)] = &[
+                    (::std::$f_scalar::NAN, 0.0),
+                    (1.0, ::std::$f_scalar::NAN),
+                    (::std::$f_scalar::NAN, ::std::$f_scalar::NAN),
+                    (1.0, 0.5),
+                    (::std::$f_scalar::MAX, -::std::$f_scalar::MAX),
+                    (::std::$f_scalar::INFINITY, ::std::$f_scalar::INFINITY),
+                    (
+                        ::std::$f_scalar::NEG_INFINITY,
+                        ::std::$f_scalar::NEG_INFINITY,
+                    ),
+                    (::std::$f_scalar::NEG_INFINITY, 5.0),
+                    (5.0, ::std::$f_scalar::INFINITY),
+                    (::std::$f_scalar::NAN, ::std::$f_scalar::INFINITY),
+                    (::std::$f_scalar::NEG_INFINITY, ::std::$f_scalar::NAN),
+                    (::std::$f_scalar::NEG_INFINITY, ::std::$f_scalar::INFINITY),
+                ];
+                for &(low_scalar, high_scalar) in v.iter() {
+                    for lane in 0..<$ty>::lanes() {
+                        let low = <$ty>::splat(0.0 as $f_scalar).replace(lane, low_scalar);
+                        let high = <$ty>::splat(1.0 as $f_scalar).replace(lane, high_scalar);
+                        assert!(catch_unwind(|| range(low, high)).is_err());
+                        assert!(catch_unwind(|| Uniform::new(low, high)).is_err());
+                        assert!(catch_unwind(|| Uniform::new_inclusive(low, high)).is_err());
+                        assert!(catch_unwind(|| range(low, low)).is_err());
+                        assert!(catch_unwind(|| Uniform::new(low, low)).is_err());
+                    }
+                }
+            }};
+        }
+
+        t!(f32, f32);
+        t!(f64, f64);
+        #[cfg(feature = "simd_support")]
+        {
+            t!(f32x2, f32);
+            t!(f32x4, f32);
+            t!(f32x8, f32);
+            t!(f32x16, f32);
+            t!(f64x2, f64);
+            t!(f64x4, f64);
+            t!(f64x8, f64);
+        }
+    }
+
+
+    #[test]
+    #[cfg_attr(miri, ignore)] // Miri is too slow
+    fn test_durations() {
+        let mut rng = crate::test::rng(253);
+
+        let v = &[
+            (Duration::new(10, 50000), Duration::new(100, 1234)),
+            (Duration::new(0, 100), Duration::new(1, 50)),
+            (
+                Duration::new(0, 0),
+                Duration::new(u64::max_value(), 999_999_999),
+            ),
+        ];
+        for &(low, high) in v.iter() {
+            let my_uniform = Uniform::new(low, high);
+            for _ in 0..1000 {
+                let v = rng.sample(my_uniform);
+                assert!(low <= v && v < high);
+            }
+        }
+    }
+
+    #[test]
+    fn test_custom_uniform() {
+        use crate::distributions::uniform::{
+            SampleBorrow, SampleUniform, UniformFloat, UniformSampler,
+        };
+        #[derive(Clone, Copy, PartialEq, PartialOrd)]
+        struct MyF32 {
+            x: f32,
+        }
+        #[derive(Clone, Copy, Debug)]
+        struct UniformMyF32(UniformFloat<f32>);
+        impl UniformSampler for UniformMyF32 {
+            type X = MyF32;
+
+            fn new<B1, B2>(low: B1, high: B2) -> Self
+            where
+                B1: SampleBorrow<Self::X> + Sized,
+                B2: SampleBorrow<Self::X> + Sized,
+            {
+                UniformMyF32(UniformFloat::<f32>::new(low.borrow().x, high.borrow().x))
+            }
+
+            fn new_inclusive<B1, B2>(low: B1, high: B2) -> Self
+            where
+                B1: SampleBorrow<Self::X> + Sized,
+                B2: SampleBorrow<Self::X> + Sized,
+            {
+                UniformSampler::new(low, high)
+            }
+
+            fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Self::X {
+                MyF32 {
+                    x: self.0.sample(rng),
+                }
+            }
+        }
+        impl SampleUniform for MyF32 {
+            type Sampler = UniformMyF32;
+        }
+
+        let (low, high) = (MyF32 { x: 17.0f32 }, MyF32 { x: 22.0f32 });
+        let uniform = Uniform::new(low, high);
+        let mut rng = crate::test::rng(804);
+        for _ in 0..100 {
+            let x: MyF32 = rng.sample(uniform);
+            assert!(low <= x && x < high);
+        }
+    }
+
+    #[test]
+    fn test_uniform_from_std_range() {
+        let r = Uniform::from(2u32..7);
+        assert_eq!(r.0.low, 2);
+        assert_eq!(r.0.range, 5);
+        let r = Uniform::from(2.0f64..7.0);
+        assert_eq!(r.0.low, 2.0);
+        assert_eq!(r.0.scale, 5.0);
+    }
+
+    #[test]
+    fn test_uniform_from_std_range_inclusive() {
+        let r = Uniform::from(2u32..=6);
+        assert_eq!(r.0.low, 2);
+        assert_eq!(r.0.range, 5);
+        let r = Uniform::from(2.0f64..=7.0);
+        assert_eq!(r.0.low, 2.0);
+        assert!(r.0.scale > 5.0);
+        assert!(r.0.scale < 5.0 + 1e-14);
+    }
+
+    #[test]
+    fn value_stability() {
+        fn test_samples<T: SampleUniform + Copy + core::fmt::Debug + PartialEq>(
+            lb: T, ub: T, expected_single: &[T], expected_multiple: &[T],
+        ) where Uniform<T>: Distribution<T> {
+            let mut rng = crate::test::rng(897);
+            let mut buf = [lb; 3];
+
+            for x in &mut buf {
+                *x = T::Sampler::sample_single(lb, ub, &mut rng);
+            }
+            assert_eq!(&buf, expected_single);
+
+            let distr = Uniform::new(lb, ub);
+            for x in &mut buf {
+                *x = rng.sample(&distr);
+            }
+            assert_eq!(&buf, expected_multiple);
+        }
+
+        // We test on a sub-set of types; possibly we should do more.
+        // TODO: SIMD types
+
+        test_samples(11u8, 219, &[17, 66, 214], &[181, 93, 165]);
+        test_samples(11u32, 219, &[17, 66, 214], &[181, 93, 165]);
+
+        test_samples(0f32, 1e-2f32, &[0.0003070104, 0.0026630748, 0.00979833], &[
+            0.008194133,
+            0.00398172,
+            0.007428536,
+        ]);
+        test_samples(
+            -1e10f64,
+            1e10f64,
+            &[-4673848682.871551, 6388267422.932352, 4857075081.198343],
+            &[1173375212.1808167, 1917642852.109581, 2365076174.3153973],
+        );
+
+        test_samples(
+            Duration::new(2, 0),
+            Duration::new(4, 0),
+            &[
+                Duration::new(2, 532615131),
+                Duration::new(3, 638826742),
+                Duration::new(3, 485707508),
+            ],
+            &[
+                Duration::new(3, 117337521),
+                Duration::new(3, 191764285),
+                Duration::new(3, 236507617),
+            ],
+        );
+    }
+
+    #[test]
+    fn uniform_distributions_can_be_compared() {
+        assert_eq!(Uniform::new(1.0, 2.0), Uniform::new(1.0, 2.0));
+
+        // To cover UniformInt
+        assert_eq!(Uniform::new(1 as u32, 2 as u32), Uniform::new(1 as u32, 2 as u32));
+    }
+}
diff --git a/crates/rand/src/distributions/utils.rs b/crates/rand/src/distributions/utils.rs
new file mode 100644
index 0000000..89da5fd
--- /dev/null
+++ b/crates/rand/src/distributions/utils.rs
@@ -0,0 +1,429 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Math helper functions
+
+#[cfg(feature = "simd_support")] use packed_simd::*;
+
+
+pub(crate) trait WideningMultiply<RHS = Self> {
+    type Output;
+
+    fn wmul(self, x: RHS) -> Self::Output;
+}
+
+macro_rules! wmul_impl {
+    ($ty:ty, $wide:ty, $shift:expr) => {
+        impl WideningMultiply for $ty {
+            type Output = ($ty, $ty);
+
+            #[inline(always)]
+            fn wmul(self, x: $ty) -> Self::Output {
+                let tmp = (self as $wide) * (x as $wide);
+                ((tmp >> $shift) as $ty, tmp as $ty)
+            }
+        }
+    };
+
+    // simd bulk implementation
+    ($(($ty:ident, $wide:ident),)+, $shift:expr) => {
+        $(
+            impl WideningMultiply for $ty {
+                type Output = ($ty, $ty);
+
+                #[inline(always)]
+                fn wmul(self, x: $ty) -> Self::Output {
+                    // For supported vectors, this should compile to a couple
+                    // supported multiply & swizzle instructions (no actual
+                    // casting).
+                    // TODO: optimize
+                    let y: $wide = self.cast();
+                    let x: $wide = x.cast();
+                    let tmp = y * x;
+                    let hi: $ty = (tmp >> $shift).cast();
+                    let lo: $ty = tmp.cast();
+                    (hi, lo)
+                }
+            }
+        )+
+    };
+}
+wmul_impl! { u8, u16, 8 }
+wmul_impl! { u16, u32, 16 }
+wmul_impl! { u32, u64, 32 }
+wmul_impl! { u64, u128, 64 }
+
+// This code is a translation of the __mulddi3 function in LLVM's
+// compiler-rt. It is an optimised variant of the common method
+// `(a + b) * (c + d) = ac + ad + bc + bd`.
+//
+// For some reason LLVM can optimise the C version very well, but
+// keeps shuffling registers in this Rust translation.
+macro_rules! wmul_impl_large {
+    ($ty:ty, $half:expr) => {
+        impl WideningMultiply for $ty {
+            type Output = ($ty, $ty);
+
+            #[inline(always)]
+            fn wmul(self, b: $ty) -> Self::Output {
+                const LOWER_MASK: $ty = !0 >> $half;
+                let mut low = (self & LOWER_MASK).wrapping_mul(b & LOWER_MASK);
+                let mut t = low >> $half;
+                low &= LOWER_MASK;
+                t += (self >> $half).wrapping_mul(b & LOWER_MASK);
+                low += (t & LOWER_MASK) << $half;
+                let mut high = t >> $half;
+                t = low >> $half;
+                low &= LOWER_MASK;
+                t += (b >> $half).wrapping_mul(self & LOWER_MASK);
+                low += (t & LOWER_MASK) << $half;
+                high += t >> $half;
+                high += (self >> $half).wrapping_mul(b >> $half);
+
+                (high, low)
+            }
+        }
+    };
+
+    // simd bulk implementation
+    (($($ty:ty,)+) $scalar:ty, $half:expr) => {
+        $(
+            impl WideningMultiply for $ty {
+                type Output = ($ty, $ty);
+
+                #[inline(always)]
+                fn wmul(self, b: $ty) -> Self::Output {
+                    // needs wrapping multiplication
+                    const LOWER_MASK: $scalar = !0 >> $half;
+                    let mut low = (self & LOWER_MASK) * (b & LOWER_MASK);
+                    let mut t = low >> $half;
+                    low &= LOWER_MASK;
+                    t += (self >> $half) * (b & LOWER_MASK);
+                    low += (t & LOWER_MASK) << $half;
+                    let mut high = t >> $half;
+                    t = low >> $half;
+                    low &= LOWER_MASK;
+                    t += (b >> $half) * (self & LOWER_MASK);
+                    low += (t & LOWER_MASK) << $half;
+                    high += t >> $half;
+                    high += (self >> $half) * (b >> $half);
+
+                    (high, low)
+                }
+            }
+        )+
+    };
+}
+wmul_impl_large! { u128, 64 }
+
+macro_rules! wmul_impl_usize {
+    ($ty:ty) => {
+        impl WideningMultiply for usize {
+            type Output = (usize, usize);
+
+            #[inline(always)]
+            fn wmul(self, x: usize) -> Self::Output {
+                let (high, low) = (self as $ty).wmul(x as $ty);
+                (high as usize, low as usize)
+            }
+        }
+    };
+}
+#[cfg(target_pointer_width = "16")]
+wmul_impl_usize! { u16 }
+#[cfg(target_pointer_width = "32")]
+wmul_impl_usize! { u32 }
+#[cfg(target_pointer_width = "64")]
+wmul_impl_usize! { u64 }
+
+#[cfg(feature = "simd_support")]
+mod simd_wmul {
+    use super::*;
+    #[cfg(target_arch = "x86")] use core::arch::x86::*;
+    #[cfg(target_arch = "x86_64")] use core::arch::x86_64::*;
+
+    wmul_impl! {
+        (u8x2, u16x2),
+        (u8x4, u16x4),
+        (u8x8, u16x8),
+        (u8x16, u16x16),
+        (u8x32, u16x32),,
+        8
+    }
+
+    wmul_impl! { (u16x2, u32x2),, 16 }
+    wmul_impl! { (u16x4, u32x4),, 16 }
+    #[cfg(not(target_feature = "sse2"))]
+    wmul_impl! { (u16x8, u32x8),, 16 }
+    #[cfg(not(target_feature = "avx2"))]
+    wmul_impl! { (u16x16, u32x16),, 16 }
+
+    // 16-bit lane widths allow use of the x86 `mulhi` instructions, which
+    // means `wmul` can be implemented with only two instructions.
+    #[allow(unused_macros)]
+    macro_rules! wmul_impl_16 {
+        ($ty:ident, $intrinsic:ident, $mulhi:ident, $mullo:ident) => {
+            impl WideningMultiply for $ty {
+                type Output = ($ty, $ty);
+
+                #[inline(always)]
+                fn wmul(self, x: $ty) -> Self::Output {
+                    let b = $intrinsic::from_bits(x);
+                    let a = $intrinsic::from_bits(self);
+                    let hi = $ty::from_bits(unsafe { $mulhi(a, b) });
+                    let lo = $ty::from_bits(unsafe { $mullo(a, b) });
+                    (hi, lo)
+                }
+            }
+        };
+    }
+
+    #[cfg(target_feature = "sse2")]
+    wmul_impl_16! { u16x8, __m128i, _mm_mulhi_epu16, _mm_mullo_epi16 }
+    #[cfg(target_feature = "avx2")]
+    wmul_impl_16! { u16x16, __m256i, _mm256_mulhi_epu16, _mm256_mullo_epi16 }
+    // FIXME: there are no `__m512i` types in stdsimd yet, so `wmul::<u16x32>`
+    // cannot use the same implementation.
+
+    wmul_impl! {
+        (u32x2, u64x2),
+        (u32x4, u64x4),
+        (u32x8, u64x8),,
+        32
+    }
+
+    // TODO: optimize, this seems to seriously slow things down
+    wmul_impl_large! { (u8x64,) u8, 4 }
+    wmul_impl_large! { (u16x32,) u16, 8 }
+    wmul_impl_large! { (u32x16,) u32, 16 }
+    wmul_impl_large! { (u64x2, u64x4, u64x8,) u64, 32 }
+}
+
+/// Helper trait when dealing with scalar and SIMD floating point types.
+pub(crate) trait FloatSIMDUtils {
+    // `PartialOrd` for vectors compares lexicographically. We want to compare all
+    // the individual SIMD lanes instead, and get the combined result over all
+    // lanes. This is possible using something like `a.lt(b).all()`, but we
+    // implement it as a trait so we can write the same code for `f32` and `f64`.
+    // Only the comparison functions we need are implemented.
+    fn all_lt(self, other: Self) -> bool;
+    fn all_le(self, other: Self) -> bool;
+    fn all_finite(self) -> bool;
+
+    type Mask;
+    fn finite_mask(self) -> Self::Mask;
+    fn gt_mask(self, other: Self) -> Self::Mask;
+    fn ge_mask(self, other: Self) -> Self::Mask;
+
+    // Decrease all lanes where the mask is `true` to the next lower value
+    // representable by the floating-point type. At least one of the lanes
+    // must be set.
+    fn decrease_masked(self, mask: Self::Mask) -> Self;
+
+    // Convert from int value. Conversion is done while retaining the numerical
+    // value, not by retaining the binary representation.
+    type UInt;
+    fn cast_from_int(i: Self::UInt) -> Self;
+}
+
+/// Implement functions available in std builds but missing from core primitives
+#[cfg(not(std))]
+// False positive: We are following `std` here.
+#[allow(clippy::wrong_self_convention)]
+pub(crate) trait Float: Sized {
+    fn is_nan(self) -> bool;
+    fn is_infinite(self) -> bool;
+    fn is_finite(self) -> bool;
+}
+
+/// Implement functions on f32/f64 to give them APIs similar to SIMD types
+pub(crate) trait FloatAsSIMD: Sized {
+    #[inline(always)]
+    fn lanes() -> usize {
+        1
+    }
+    #[inline(always)]
+    fn splat(scalar: Self) -> Self {
+        scalar
+    }
+    #[inline(always)]
+    fn extract(self, index: usize) -> Self {
+        debug_assert_eq!(index, 0);
+        self
+    }
+    #[inline(always)]
+    fn replace(self, index: usize, new_value: Self) -> Self {
+        debug_assert_eq!(index, 0);
+        new_value
+    }
+}
+
+pub(crate) trait BoolAsSIMD: Sized {
+    fn any(self) -> bool;
+    fn all(self) -> bool;
+    fn none(self) -> bool;
+}
+
+impl BoolAsSIMD for bool {
+    #[inline(always)]
+    fn any(self) -> bool {
+        self
+    }
+
+    #[inline(always)]
+    fn all(self) -> bool {
+        self
+    }
+
+    #[inline(always)]
+    fn none(self) -> bool {
+        !self
+    }
+}
+
+macro_rules! scalar_float_impl {
+    ($ty:ident, $uty:ident) => {
+        #[cfg(not(std))]
+        impl Float for $ty {
+            #[inline]
+            fn is_nan(self) -> bool {
+                self != self
+            }
+
+            #[inline]
+            fn is_infinite(self) -> bool {
+                self == ::core::$ty::INFINITY || self == ::core::$ty::NEG_INFINITY
+            }
+
+            #[inline]
+            fn is_finite(self) -> bool {
+                !(self.is_nan() || self.is_infinite())
+            }
+        }
+
+        impl FloatSIMDUtils for $ty {
+            type Mask = bool;
+            type UInt = $uty;
+
+            #[inline(always)]
+            fn all_lt(self, other: Self) -> bool {
+                self < other
+            }
+
+            #[inline(always)]
+            fn all_le(self, other: Self) -> bool {
+                self <= other
+            }
+
+            #[inline(always)]
+            fn all_finite(self) -> bool {
+                self.is_finite()
+            }
+
+            #[inline(always)]
+            fn finite_mask(self) -> Self::Mask {
+                self.is_finite()
+            }
+
+            #[inline(always)]
+            fn gt_mask(self, other: Self) -> Self::Mask {
+                self > other
+            }
+
+            #[inline(always)]
+            fn ge_mask(self, other: Self) -> Self::Mask {
+                self >= other
+            }
+
+            #[inline(always)]
+            fn decrease_masked(self, mask: Self::Mask) -> Self {
+                debug_assert!(mask, "At least one lane must be set");
+                <$ty>::from_bits(self.to_bits() - 1)
+            }
+
+            #[inline]
+            fn cast_from_int(i: Self::UInt) -> Self {
+                i as $ty
+            }
+        }
+
+        impl FloatAsSIMD for $ty {}
+    };
+}
+
+scalar_float_impl!(f32, u32);
+scalar_float_impl!(f64, u64);
+
+
+#[cfg(feature = "simd_support")]
+macro_rules! simd_impl {
+    ($ty:ident, $f_scalar:ident, $mty:ident, $uty:ident) => {
+        impl FloatSIMDUtils for $ty {
+            type Mask = $mty;
+            type UInt = $uty;
+
+            #[inline(always)]
+            fn all_lt(self, other: Self) -> bool {
+                self.lt(other).all()
+            }
+
+            #[inline(always)]
+            fn all_le(self, other: Self) -> bool {
+                self.le(other).all()
+            }
+
+            #[inline(always)]
+            fn all_finite(self) -> bool {
+                self.finite_mask().all()
+            }
+
+            #[inline(always)]
+            fn finite_mask(self) -> Self::Mask {
+                // This can possibly be done faster by checking bit patterns
+                let neg_inf = $ty::splat(::core::$f_scalar::NEG_INFINITY);
+                let pos_inf = $ty::splat(::core::$f_scalar::INFINITY);
+                self.gt(neg_inf) & self.lt(pos_inf)
+            }
+
+            #[inline(always)]
+            fn gt_mask(self, other: Self) -> Self::Mask {
+                self.gt(other)
+            }
+
+            #[inline(always)]
+            fn ge_mask(self, other: Self) -> Self::Mask {
+                self.ge(other)
+            }
+
+            #[inline(always)]
+            fn decrease_masked(self, mask: Self::Mask) -> Self {
+                // Casting a mask into ints will produce all bits set for
+                // true, and 0 for false. Adding that to the binary
+                // representation of a float means subtracting one from
+                // the binary representation, resulting in the next lower
+                // value representable by $ty. This works even when the
+                // current value is infinity.
+                debug_assert!(mask.any(), "At least one lane must be set");
+                <$ty>::from_bits(<$uty>::from_bits(self) + <$uty>::from_bits(mask))
+            }
+
+            #[inline]
+            fn cast_from_int(i: Self::UInt) -> Self {
+                i.cast()
+            }
+        }
+    };
+}
+
+#[cfg(feature="simd_support")] simd_impl! { f32x2, f32, m32x2, u32x2 }
+#[cfg(feature="simd_support")] simd_impl! { f32x4, f32, m32x4, u32x4 }
+#[cfg(feature="simd_support")] simd_impl! { f32x8, f32, m32x8, u32x8 }
+#[cfg(feature="simd_support")] simd_impl! { f32x16, f32, m32x16, u32x16 }
+#[cfg(feature="simd_support")] simd_impl! { f64x2, f64, m64x2, u64x2 }
+#[cfg(feature="simd_support")] simd_impl! { f64x4, f64, m64x4, u64x4 }
+#[cfg(feature="simd_support")] simd_impl! { f64x8, f64, m64x8, u64x8 }
diff --git a/crates/rand/src/distributions/weighted.rs b/crates/rand/src/distributions/weighted.rs
new file mode 100644
index 0000000..846b9df
--- /dev/null
+++ b/crates/rand/src/distributions/weighted.rs
@@ -0,0 +1,47 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Weighted index sampling
+//!
+//! This module is deprecated. Use [`crate::distributions::WeightedIndex`] and
+//! [`crate::distributions::WeightedError`] instead.
+
+pub use super::{WeightedIndex, WeightedError};
+
+#[allow(missing_docs)]
+#[deprecated(since = "0.8.0", note = "moved to rand_distr crate")]
+pub mod alias_method {
+    // This module exists to provide a deprecation warning which minimises
+    // compile errors, but still fails to compile if ever used.
+    use core::marker::PhantomData;
+    use alloc::vec::Vec;
+    use super::WeightedError;
+
+    #[derive(Debug)]
+    pub struct WeightedIndex<W: Weight> {
+        _phantom: PhantomData<W>,
+    }
+    impl<W: Weight> WeightedIndex<W> {
+        pub fn new(_weights: Vec<W>) -> Result<Self, WeightedError> {
+            Err(WeightedError::NoItem)
+        }
+    }
+
+    pub trait Weight {}
+    macro_rules! impl_weight {
+        () => {};
+        ($T:ident, $($more:ident,)*) => {
+            impl Weight for $T {}
+            impl_weight!($($more,)*);
+        };
+    }
+    impl_weight!(f64, f32,);
+    impl_weight!(u8, u16, u32, u64, usize,);
+    impl_weight!(i8, i16, i32, i64, isize,);
+    impl_weight!(u128, i128,);
+}
diff --git a/crates/rand/src/distributions/weighted_index.rs b/crates/rand/src/distributions/weighted_index.rs
new file mode 100644
index 0000000..8252b17
--- /dev/null
+++ b/crates/rand/src/distributions/weighted_index.rs
@@ -0,0 +1,458 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Weighted index sampling
+
+use crate::distributions::uniform::{SampleBorrow, SampleUniform, UniformSampler};
+use crate::distributions::Distribution;
+use crate::Rng;
+use core::cmp::PartialOrd;
+use core::fmt;
+
+// Note that this whole module is only imported if feature="alloc" is enabled.
+use alloc::vec::Vec;
+
+#[cfg(feature = "serde1")]
+use serde::{Serialize, Deserialize};
+
+/// A distribution using weighted sampling of discrete items
+///
+/// Sampling a `WeightedIndex` distribution returns the index of a randomly
+/// selected element from the iterator used when the `WeightedIndex` was
+/// created. The chance of a given element being picked is proportional to the
+/// value of the element. The weights can use any type `X` for which an
+/// implementation of [`Uniform<X>`] exists.
+///
+/// # Performance
+///
+/// Time complexity of sampling from `WeightedIndex` is `O(log N)` where
+/// `N` is the number of weights. As an alternative,
+/// [`rand_distr::weighted_alias`](https://docs.rs/rand_distr/*/rand_distr/weighted_alias/index.html)
+/// supports `O(1)` sampling, but with much higher initialisation cost.
+///
+/// A `WeightedIndex<X>` contains a `Vec<X>` and a [`Uniform<X>`] and so its
+/// size is the sum of the size of those objects, possibly plus some alignment.
+///
+/// Creating a `WeightedIndex<X>` will allocate enough space to hold `N - 1`
+/// weights of type `X`, where `N` is the number of weights. However, since
+/// `Vec` doesn't guarantee a particular growth strategy, additional memory
+/// might be allocated but not used. Since the `WeightedIndex` object also
+/// contains, this might cause additional allocations, though for primitive
+/// types, [`Uniform<X>`] doesn't allocate any memory.
+///
+/// Sampling from `WeightedIndex` will result in a single call to
+/// `Uniform<X>::sample` (method of the [`Distribution`] trait), which typically
+/// will request a single value from the underlying [`RngCore`], though the
+/// exact number depends on the implementation of `Uniform<X>::sample`.
+///
+/// # Example
+///
+/// ```
+/// use rand::prelude::*;
+/// use rand::distributions::WeightedIndex;
+///
+/// let choices = ['a', 'b', 'c'];
+/// let weights = [2,   1,   1];
+/// let dist = WeightedIndex::new(&weights).unwrap();
+/// let mut rng = thread_rng();
+/// for _ in 0..100 {
+///     // 50% chance to print 'a', 25% chance to print 'b', 25% chance to print 'c'
+///     println!("{}", choices[dist.sample(&mut rng)]);
+/// }
+///
+/// let items = [('a', 0), ('b', 3), ('c', 7)];
+/// let dist2 = WeightedIndex::new(items.iter().map(|item| item.1)).unwrap();
+/// for _ in 0..100 {
+///     // 0% chance to print 'a', 30% chance to print 'b', 70% chance to print 'c'
+///     println!("{}", items[dist2.sample(&mut rng)].0);
+/// }
+/// ```
+///
+/// [`Uniform<X>`]: crate::distributions::Uniform
+/// [`RngCore`]: crate::RngCore
+#[derive(Debug, Clone, PartialEq)]
+#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
+pub struct WeightedIndex<X: SampleUniform + PartialOrd> {
+    cumulative_weights: Vec<X>,
+    total_weight: X,
+    weight_distribution: X::Sampler,
+}
+
+impl<X: SampleUniform + PartialOrd> WeightedIndex<X> {
+    /// Creates a new a `WeightedIndex` [`Distribution`] using the values
+    /// in `weights`. The weights can use any type `X` for which an
+    /// implementation of [`Uniform<X>`] exists.
+    ///
+    /// Returns an error if the iterator is empty, if any weight is `< 0`, or
+    /// if its total value is 0.
+    ///
+    /// [`Uniform<X>`]: crate::distributions::uniform::Uniform
+    pub fn new<I>(weights: I) -> Result<WeightedIndex<X>, WeightedError>
+    where
+        I: IntoIterator,
+        I::Item: SampleBorrow<X>,
+        X: for<'a> ::core::ops::AddAssign<&'a X> + Clone + Default,
+    {
+        let mut iter = weights.into_iter();
+        let mut total_weight: X = iter.next().ok_or(WeightedError::NoItem)?.borrow().clone();
+
+        let zero = <X as Default>::default();
+        if !(total_weight >= zero) {
+            return Err(WeightedError::InvalidWeight);
+        }
+
+        let mut weights = Vec::<X>::with_capacity(iter.size_hint().0);
+        for w in iter {
+            // Note that `!(w >= x)` is not equivalent to `w < x` for partially
+            // ordered types due to NaNs which are equal to nothing.
+            if !(w.borrow() >= &zero) {
+                return Err(WeightedError::InvalidWeight);
+            }
+            weights.push(total_weight.clone());
+            total_weight += w.borrow();
+        }
+
+        if total_weight == zero {
+            return Err(WeightedError::AllWeightsZero);
+        }
+        let distr = X::Sampler::new(zero, total_weight.clone());
+
+        Ok(WeightedIndex {
+            cumulative_weights: weights,
+            total_weight,
+            weight_distribution: distr,
+        })
+    }
+
+    /// Update a subset of weights, without changing the number of weights.
+    ///
+    /// `new_weights` must be sorted by the index.
+    ///
+    /// Using this method instead of `new` might be more efficient if only a small number of
+    /// weights is modified. No allocations are performed, unless the weight type `X` uses
+    /// allocation internally.
+    ///
+    /// In case of error, `self` is not modified.
+    pub fn update_weights(&mut self, new_weights: &[(usize, &X)]) -> Result<(), WeightedError>
+    where X: for<'a> ::core::ops::AddAssign<&'a X>
+            + for<'a> ::core::ops::SubAssign<&'a X>
+            + Clone
+            + Default {
+        if new_weights.is_empty() {
+            return Ok(());
+        }
+
+        let zero = <X as Default>::default();
+
+        let mut total_weight = self.total_weight.clone();
+
+        // Check for errors first, so we don't modify `self` in case something
+        // goes wrong.
+        let mut prev_i = None;
+        for &(i, w) in new_weights {
+            if let Some(old_i) = prev_i {
+                if old_i >= i {
+                    return Err(WeightedError::InvalidWeight);
+                }
+            }
+            if !(*w >= zero) {
+                return Err(WeightedError::InvalidWeight);
+            }
+            if i > self.cumulative_weights.len() {
+                return Err(WeightedError::TooMany);
+            }
+
+            let mut old_w = if i < self.cumulative_weights.len() {
+                self.cumulative_weights[i].clone()
+            } else {
+                self.total_weight.clone()
+            };
+            if i > 0 {
+                old_w -= &self.cumulative_weights[i - 1];
+            }
+
+            total_weight -= &old_w;
+            total_weight += w;
+            prev_i = Some(i);
+        }
+        if total_weight <= zero {
+            return Err(WeightedError::AllWeightsZero);
+        }
+
+        // Update the weights. Because we checked all the preconditions in the
+        // previous loop, this should never panic.
+        let mut iter = new_weights.iter();
+
+        let mut prev_weight = zero.clone();
+        let mut next_new_weight = iter.next();
+        let &(first_new_index, _) = next_new_weight.unwrap();
+        let mut cumulative_weight = if first_new_index > 0 {
+            self.cumulative_weights[first_new_index - 1].clone()
+        } else {
+            zero.clone()
+        };
+        for i in first_new_index..self.cumulative_weights.len() {
+            match next_new_weight {
+                Some(&(j, w)) if i == j => {
+                    cumulative_weight += w;
+                    next_new_weight = iter.next();
+                }
+                _ => {
+                    let mut tmp = self.cumulative_weights[i].clone();
+                    tmp -= &prev_weight; // We know this is positive.
+                    cumulative_weight += &tmp;
+                }
+            }
+            prev_weight = cumulative_weight.clone();
+            core::mem::swap(&mut prev_weight, &mut self.cumulative_weights[i]);
+        }
+
+        self.total_weight = total_weight;
+        self.weight_distribution = X::Sampler::new(zero, self.total_weight.clone());
+
+        Ok(())
+    }
+}
+
+impl<X> Distribution<usize> for WeightedIndex<X>
+where X: SampleUniform + PartialOrd
+{
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> usize {
+        use ::core::cmp::Ordering;
+        let chosen_weight = self.weight_distribution.sample(rng);
+        // Find the first item which has a weight *higher* than the chosen weight.
+        self.cumulative_weights
+            .binary_search_by(|w| {
+                if *w <= chosen_weight {
+                    Ordering::Less
+                } else {
+                    Ordering::Greater
+                }
+            })
+            .unwrap_err()
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[cfg(feature = "serde1")]
+    #[test]
+    fn test_weightedindex_serde1() {
+        let weighted_index = WeightedIndex::new(&[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]).unwrap();
+
+        let ser_weighted_index = bincode::serialize(&weighted_index).unwrap();
+        let de_weighted_index: WeightedIndex<i32> =
+            bincode::deserialize(&ser_weighted_index).unwrap();
+
+        assert_eq!(
+            de_weighted_index.cumulative_weights,
+            weighted_index.cumulative_weights
+        );
+        assert_eq!(de_weighted_index.total_weight, weighted_index.total_weight);
+    }
+
+    #[test]
+    fn test_accepting_nan(){
+        assert_eq!(
+            WeightedIndex::new(&[core::f32::NAN, 0.5]).unwrap_err(),
+            WeightedError::InvalidWeight,
+        );
+        assert_eq!(
+            WeightedIndex::new(&[core::f32::NAN]).unwrap_err(),
+            WeightedError::InvalidWeight,
+        );
+        assert_eq!(
+            WeightedIndex::new(&[0.5, core::f32::NAN]).unwrap_err(),
+            WeightedError::InvalidWeight,
+        );
+
+        assert_eq!(
+            WeightedIndex::new(&[0.5, 7.0])
+                .unwrap()
+                .update_weights(&[(0, &core::f32::NAN)])
+                .unwrap_err(),
+            WeightedError::InvalidWeight,
+        )
+    }
+
+
+    #[test]
+    #[cfg_attr(miri, ignore)] // Miri is too slow
+    fn test_weightedindex() {
+        let mut r = crate::test::rng(700);
+        const N_REPS: u32 = 5000;
+        let weights = [1u32, 2, 3, 0, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7];
+        let total_weight = weights.iter().sum::<u32>() as f32;
+
+        let verify = |result: [i32; 14]| {
+            for (i, count) in result.iter().enumerate() {
+                let exp = (weights[i] * N_REPS) as f32 / total_weight;
+                let mut err = (*count as f32 - exp).abs();
+                if err != 0.0 {
+                    err /= exp;
+                }
+                assert!(err <= 0.25);
+            }
+        };
+
+        // WeightedIndex from vec
+        let mut chosen = [0i32; 14];
+        let distr = WeightedIndex::new(weights.to_vec()).unwrap();
+        for _ in 0..N_REPS {
+            chosen[distr.sample(&mut r)] += 1;
+        }
+        verify(chosen);
+
+        // WeightedIndex from slice
+        chosen = [0i32; 14];
+        let distr = WeightedIndex::new(&weights[..]).unwrap();
+        for _ in 0..N_REPS {
+            chosen[distr.sample(&mut r)] += 1;
+        }
+        verify(chosen);
+
+        // WeightedIndex from iterator
+        chosen = [0i32; 14];
+        let distr = WeightedIndex::new(weights.iter()).unwrap();
+        for _ in 0..N_REPS {
+            chosen[distr.sample(&mut r)] += 1;
+        }
+        verify(chosen);
+
+        for _ in 0..5 {
+            assert_eq!(WeightedIndex::new(&[0, 1]).unwrap().sample(&mut r), 1);
+            assert_eq!(WeightedIndex::new(&[1, 0]).unwrap().sample(&mut r), 0);
+            assert_eq!(
+                WeightedIndex::new(&[0, 0, 0, 0, 10, 0])
+                    .unwrap()
+                    .sample(&mut r),
+                4
+            );
+        }
+
+        assert_eq!(
+            WeightedIndex::new(&[10][0..0]).unwrap_err(),
+            WeightedError::NoItem
+        );
+        assert_eq!(
+            WeightedIndex::new(&[0]).unwrap_err(),
+            WeightedError::AllWeightsZero
+        );
+        assert_eq!(
+            WeightedIndex::new(&[10, 20, -1, 30]).unwrap_err(),
+            WeightedError::InvalidWeight
+        );
+        assert_eq!(
+            WeightedIndex::new(&[-10, 20, 1, 30]).unwrap_err(),
+            WeightedError::InvalidWeight
+        );
+        assert_eq!(
+            WeightedIndex::new(&[-10]).unwrap_err(),
+            WeightedError::InvalidWeight
+        );
+    }
+
+    #[test]
+    fn test_update_weights() {
+        let data = [
+            (
+                &[10u32, 2, 3, 4][..],
+                &[(1, &100), (2, &4)][..], // positive change
+                &[10, 100, 4, 4][..],
+            ),
+            (
+                &[1u32, 2, 3, 0, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7][..],
+                &[(2, &1), (5, &1), (13, &100)][..], // negative change and last element
+                &[1u32, 2, 1, 0, 5, 1, 7, 1, 2, 3, 4, 5, 6, 100][..],
+            ),
+        ];
+
+        for (weights, update, expected_weights) in data.iter() {
+            let total_weight = weights.iter().sum::<u32>();
+            let mut distr = WeightedIndex::new(weights.to_vec()).unwrap();
+            assert_eq!(distr.total_weight, total_weight);
+
+            distr.update_weights(update).unwrap();
+            let expected_total_weight = expected_weights.iter().sum::<u32>();
+            let expected_distr = WeightedIndex::new(expected_weights.to_vec()).unwrap();
+            assert_eq!(distr.total_weight, expected_total_weight);
+            assert_eq!(distr.total_weight, expected_distr.total_weight);
+            assert_eq!(distr.cumulative_weights, expected_distr.cumulative_weights);
+        }
+    }
+
+    #[test]
+    fn value_stability() {
+        fn test_samples<X: SampleUniform + PartialOrd, I>(
+            weights: I, buf: &mut [usize], expected: &[usize],
+        ) where
+            I: IntoIterator,
+            I::Item: SampleBorrow<X>,
+            X: for<'a> ::core::ops::AddAssign<&'a X> + Clone + Default,
+        {
+            assert_eq!(buf.len(), expected.len());
+            let distr = WeightedIndex::new(weights).unwrap();
+            let mut rng = crate::test::rng(701);
+            for r in buf.iter_mut() {
+                *r = rng.sample(&distr);
+            }
+            assert_eq!(buf, expected);
+        }
+
+        let mut buf = [0; 10];
+        test_samples(&[1i32, 1, 1, 1, 1, 1, 1, 1, 1], &mut buf, &[
+            0, 6, 2, 6, 3, 4, 7, 8, 2, 5,
+        ]);
+        test_samples(&[0.7f32, 0.1, 0.1, 0.1], &mut buf, &[
+            0, 0, 0, 1, 0, 0, 2, 3, 0, 0,
+        ]);
+        test_samples(&[1.0f64, 0.999, 0.998, 0.997], &mut buf, &[
+            2, 2, 1, 3, 2, 1, 3, 3, 2, 1,
+        ]);
+    }
+
+    #[test]
+    fn weighted_index_distributions_can_be_compared() {
+        assert_eq!(WeightedIndex::new(&[1, 2]), WeightedIndex::new(&[1, 2]));
+    }
+}
+
+/// Error type returned from `WeightedIndex::new`.
+#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum WeightedError {
+    /// The provided weight collection contains no items.
+    NoItem,
+
+    /// A weight is either less than zero, greater than the supported maximum,
+    /// NaN, or otherwise invalid.
+    InvalidWeight,
+
+    /// All items in the provided weight collection are zero.
+    AllWeightsZero,
+
+    /// Too many weights are provided (length greater than `u32::MAX`)
+    TooMany,
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for WeightedError {}
+
+impl fmt::Display for WeightedError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str(match *self {
+            WeightedError::NoItem => "No weights provided in distribution",
+            WeightedError::InvalidWeight => "A weight is invalid in distribution",
+            WeightedError::AllWeightsZero => "All weights are zero in distribution",
+            WeightedError::TooMany => "Too many weights (hit u32::MAX) in distribution",
+        })
+    }
+}
diff --git a/crates/rand/src/lib.rs b/crates/rand/src/lib.rs
new file mode 100644
index 0000000..6d84718
--- /dev/null
+++ b/crates/rand/src/lib.rs
@@ -0,0 +1,214 @@
+// Copyright 2018 Developers of the Rand project.
+// Copyright 2013-2017 The Rust Project Developers.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Utilities for random number generation
+//!
+//! Rand provides utilities to generate random numbers, to convert them to
+//! useful types and distributions, and some randomness-related algorithms.
+//!
+//! # Quick Start
+//!
+//! To get you started quickly, the easiest and highest-level way to get
+//! a random value is to use [`random()`]; alternatively you can use
+//! [`thread_rng()`]. The [`Rng`] trait provides a useful API on all RNGs, while
+//! the [`distributions`] and [`seq`] modules provide further
+//! functionality on top of RNGs.
+//!
+//! ```
+//! use rand::prelude::*;
+//!
+//! if rand::random() { // generates a boolean
+//!     // Try printing a random unicode code point (probably a bad idea)!
+//!     println!("char: {}", rand::random::<char>());
+//! }
+//!
+//! let mut rng = rand::thread_rng();
+//! let y: f64 = rng.gen(); // generates a float between 0 and 1
+//!
+//! let mut nums: Vec<i32> = (1..100).collect();
+//! nums.shuffle(&mut rng);
+//! ```
+//!
+//! # The Book
+//!
+//! For the user guide and further documentation, please read
+//! [The Rust Rand Book](https://rust-random.github.io/book).
+
+#![doc(
+    html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk.png",
+    html_favicon_url = "https://www.rust-lang.org/favicon.ico",
+    html_root_url = "https://rust-random.github.io/rand/"
+)]
+#![deny(missing_docs)]
+#![deny(missing_debug_implementations)]
+#![doc(test(attr(allow(unused_variables), deny(warnings))))]
+#![no_std]
+#![cfg_attr(feature = "simd_support", feature(stdsimd))]
+#![cfg_attr(doc_cfg, feature(doc_cfg))]
+#![allow(
+    clippy::float_cmp,
+    clippy::neg_cmp_op_on_partial_ord,
+)]
+
+#[cfg(feature = "std")] extern crate std;
+#[cfg(feature = "alloc")] extern crate alloc;
+
+#[allow(unused)]
+macro_rules! trace { ($($x:tt)*) => (
+    #[cfg(feature = "log")] {
+        log::trace!($($x)*)
+    }
+) }
+#[allow(unused)]
+macro_rules! debug { ($($x:tt)*) => (
+    #[cfg(feature = "log")] {
+        log::debug!($($x)*)
+    }
+) }
+#[allow(unused)]
+macro_rules! info { ($($x:tt)*) => (
+    #[cfg(feature = "log")] {
+        log::info!($($x)*)
+    }
+) }
+#[allow(unused)]
+macro_rules! warn { ($($x:tt)*) => (
+    #[cfg(feature = "log")] {
+        log::warn!($($x)*)
+    }
+) }
+#[allow(unused)]
+macro_rules! error { ($($x:tt)*) => (
+    #[cfg(feature = "log")] {
+        log::error!($($x)*)
+    }
+) }
+
+// Re-exports from rand_core
+pub use rand_core::{CryptoRng, Error, RngCore, SeedableRng};
+
+// Public modules
+pub mod distributions;
+pub mod prelude;
+mod rng;
+pub mod rngs;
+pub mod seq;
+
+// Public exports
+#[cfg(all(feature = "std", feature = "std_rng"))]
+pub use crate::rngs::thread::thread_rng;
+pub use rng::{Fill, Rng};
+
+#[cfg(all(feature = "std", feature = "std_rng"))]
+use crate::distributions::{Distribution, Standard};
+
+/// Generates a random value using the thread-local random number generator.
+///
+/// This is simply a shortcut for `thread_rng().gen()`. See [`thread_rng`] for
+/// documentation of the entropy source and [`Standard`] for documentation of
+/// distributions and type-specific generation.
+///
+/// # Provided implementations
+///
+/// The following types have provided implementations that
+/// generate values with the following ranges and distributions:
+///
+/// * Integers (`i32`, `u32`, `isize`, `usize`, etc.): Uniformly distributed
+///   over all values of the type.
+/// * `char`: Uniformly distributed over all Unicode scalar values, i.e. all
+///   code points in the range `0...0x10_FFFF`, except for the range
+///   `0xD800...0xDFFF` (the surrogate code points). This includes
+///   unassigned/reserved code points.
+/// * `bool`: Generates `false` or `true`, each with probability 0.5.
+/// * Floating point types (`f32` and `f64`): Uniformly distributed in the
+///   half-open range `[0, 1)`. See notes below.
+/// * Wrapping integers (`Wrapping<T>`), besides the type identical to their
+///   normal integer variants.
+///
+/// Also supported is the generation of the following
+/// compound types where all component types are supported:
+///
+/// *   Tuples (up to 12 elements): each element is generated sequentially.
+/// *   Arrays (up to 32 elements): each element is generated sequentially;
+///     see also [`Rng::fill`] which supports arbitrary array length for integer
+///     types and tends to be faster for `u32` and smaller types.
+/// *   `Option<T>` first generates a `bool`, and if true generates and returns
+///     `Some(value)` where `value: T`, otherwise returning `None`.
+///
+/// # Examples
+///
+/// ```
+/// let x = rand::random::<u8>();
+/// println!("{}", x);
+///
+/// let y = rand::random::<f64>();
+/// println!("{}", y);
+///
+/// if rand::random() { // generates a boolean
+///     println!("Better lucky than good!");
+/// }
+/// ```
+///
+/// If you're calling `random()` in a loop, caching the generator as in the
+/// following example can increase performance.
+///
+/// ```
+/// use rand::Rng;
+///
+/// let mut v = vec![1, 2, 3];
+///
+/// for x in v.iter_mut() {
+///     *x = rand::random()
+/// }
+///
+/// // can be made faster by caching thread_rng
+///
+/// let mut rng = rand::thread_rng();
+///
+/// for x in v.iter_mut() {
+///     *x = rng.gen();
+/// }
+/// ```
+///
+/// [`Standard`]: distributions::Standard
+#[cfg(all(feature = "std", feature = "std_rng"))]
+#[cfg_attr(doc_cfg, doc(cfg(all(feature = "std", feature = "std_rng"))))]
+#[inline]
+pub fn random<T>() -> T
+where Standard: Distribution<T> {
+    thread_rng().gen()
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    /// Construct a deterministic RNG with the given seed
+    pub fn rng(seed: u64) -> impl RngCore {
+        // For tests, we want a statistically good, fast, reproducible RNG.
+        // PCG32 will do fine, and will be easy to embed if we ever need to.
+        const INC: u64 = 11634580027462260723;
+        rand_pcg::Pcg32::new(seed, INC)
+    }
+
+    #[test]
+    #[cfg(all(feature = "std", feature = "std_rng"))]
+    fn test_random() {
+        let _n: usize = random();
+        let _f: f32 = random();
+        let _o: Option<Option<i8>> = random();
+        #[allow(clippy::type_complexity)]
+        let _many: (
+            (),
+            (usize, isize, Option<(u32, (bool,))>),
+            (u8, i8, u16, i16, u32, i32, u64, i64),
+            (f32, (f64, (f64,))),
+        ) = random();
+    }
+}
diff --git a/crates/rand/src/prelude.rs b/crates/rand/src/prelude.rs
new file mode 100644
index 0000000..51c457e
--- /dev/null
+++ b/crates/rand/src/prelude.rs
@@ -0,0 +1,34 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Convenience re-export of common members
+//!
+//! Like the standard library's prelude, this module simplifies importing of
+//! common items. Unlike the standard prelude, the contents of this module must
+//! be imported manually:
+//!
+//! ```
+//! use rand::prelude::*;
+//! # let mut r = StdRng::from_rng(thread_rng()).unwrap();
+//! # let _: f32 = r.gen();
+//! ```
+
+#[doc(no_inline)] pub use crate::distributions::Distribution;
+#[cfg(feature = "small_rng")]
+#[doc(no_inline)]
+pub use crate::rngs::SmallRng;
+#[cfg(feature = "std_rng")]
+#[doc(no_inline)] pub use crate::rngs::StdRng;
+#[doc(no_inline)]
+#[cfg(all(feature = "std", feature = "std_rng"))]
+pub use crate::rngs::ThreadRng;
+#[doc(no_inline)] pub use crate::seq::{IteratorRandom, SliceRandom};
+#[doc(no_inline)]
+#[cfg(all(feature = "std", feature = "std_rng"))]
+pub use crate::{random, thread_rng};
+#[doc(no_inline)] pub use crate::{CryptoRng, Rng, RngCore, SeedableRng};
diff --git a/crates/rand/src/rng.rs b/crates/rand/src/rng.rs
new file mode 100644
index 0000000..79a9fbf
--- /dev/null
+++ b/crates/rand/src/rng.rs
@@ -0,0 +1,600 @@
+// Copyright 2018 Developers of the Rand project.
+// Copyright 2013-2017 The Rust Project Developers.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! [`Rng`] trait
+
+use rand_core::{Error, RngCore};
+use crate::distributions::uniform::{SampleRange, SampleUniform};
+use crate::distributions::{self, Distribution, Standard};
+use core::num::Wrapping;
+use core::{mem, slice};
+
+/// An automatically-implemented extension trait on [`RngCore`] providing high-level
+/// generic methods for sampling values and other convenience methods.
+///
+/// This is the primary trait to use when generating random values.
+///
+/// # Generic usage
+///
+/// The basic pattern is `fn foo<R: Rng + ?Sized>(rng: &mut R)`. Some
+/// things are worth noting here:
+///
+/// - Since `Rng: RngCore` and every `RngCore` implements `Rng`, it makes no
+///   difference whether we use `R: Rng` or `R: RngCore`.
+/// - The `+ ?Sized` un-bounding allows functions to be called directly on
+///   type-erased references; i.e. `foo(r)` where `r: &mut dyn RngCore`. Without
+///   this it would be necessary to write `foo(&mut r)`.
+///
+/// An alternative pattern is possible: `fn foo<R: Rng>(rng: R)`. This has some
+/// trade-offs. It allows the argument to be consumed directly without a `&mut`
+/// (which is how `from_rng(thread_rng())` works); also it still works directly
+/// on references (including type-erased references). Unfortunately within the
+/// function `foo` it is not known whether `rng` is a reference type or not,
+/// hence many uses of `rng` require an extra reference, either explicitly
+/// (`distr.sample(&mut rng)`) or implicitly (`rng.gen()`); one may hope the
+/// optimiser can remove redundant references later.
+///
+/// Example:
+///
+/// ```
+/// # use rand::thread_rng;
+/// use rand::Rng;
+///
+/// fn foo<R: Rng + ?Sized>(rng: &mut R) -> f32 {
+///     rng.gen()
+/// }
+///
+/// # let v = foo(&mut thread_rng());
+/// ```
+pub trait Rng: RngCore {
+    /// Return a random value supporting the [`Standard`] distribution.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use rand::{thread_rng, Rng};
+    ///
+    /// let mut rng = thread_rng();
+    /// let x: u32 = rng.gen();
+    /// println!("{}", x);
+    /// println!("{:?}", rng.gen::<(f64, bool)>());
+    /// ```
+    ///
+    /// # Arrays and tuples
+    ///
+    /// The `rng.gen()` method is able to generate arrays (up to 32 elements)
+    /// and tuples (up to 12 elements), so long as all element types can be
+    /// generated.
+    /// When using `rustc` ≥ 1.51, enable the `min_const_gen` feature to support
+    /// arrays larger than 32 elements.
+    ///
+    /// For arrays of integers, especially for those with small element types
+    /// (< 64 bit), it will likely be faster to instead use [`Rng::fill`].
+    ///
+    /// ```
+    /// use rand::{thread_rng, Rng};
+    ///
+    /// let mut rng = thread_rng();
+    /// let tuple: (u8, i32, char) = rng.gen(); // arbitrary tuple support
+    ///
+    /// let arr1: [f32; 32] = rng.gen();        // array construction
+    /// let mut arr2 = [0u8; 128];
+    /// rng.fill(&mut arr2);                    // array fill
+    /// ```
+    ///
+    /// [`Standard`]: distributions::Standard
+    #[inline]
+    fn gen<T>(&mut self) -> T
+    where Standard: Distribution<T> {
+        Standard.sample(self)
+    }
+
+    /// Generate a random value in the given range.
+    ///
+    /// This function is optimised for the case that only a single sample is
+    /// made from the given range. See also the [`Uniform`] distribution
+    /// type which may be faster if sampling from the same range repeatedly.
+    ///
+    /// Only `gen_range(low..high)` and `gen_range(low..=high)` are supported.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the range is empty.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use rand::{thread_rng, Rng};
+    ///
+    /// let mut rng = thread_rng();
+    ///
+    /// // Exclusive range
+    /// let n: u32 = rng.gen_range(0..10);
+    /// println!("{}", n);
+    /// let m: f64 = rng.gen_range(-40.0..1.3e5);
+    /// println!("{}", m);
+    ///
+    /// // Inclusive range
+    /// let n: u32 = rng.gen_range(0..=10);
+    /// println!("{}", n);
+    /// ```
+    ///
+    /// [`Uniform`]: distributions::uniform::Uniform
+    fn gen_range<T, R>(&mut self, range: R) -> T
+    where
+        T: SampleUniform,
+        R: SampleRange<T>
+    {
+        assert!(!range.is_empty(), "cannot sample empty range");
+        range.sample_single(self)
+    }
+
+    /// Sample a new value, using the given distribution.
+    ///
+    /// ### Example
+    ///
+    /// ```
+    /// use rand::{thread_rng, Rng};
+    /// use rand::distributions::Uniform;
+    ///
+    /// let mut rng = thread_rng();
+    /// let x = rng.sample(Uniform::new(10u32, 15));
+    /// // Type annotation requires two types, the type and distribution; the
+    /// // distribution can be inferred.
+    /// let y = rng.sample::<u16, _>(Uniform::new(10, 15));
+    /// ```
+    fn sample<T, D: Distribution<T>>(&mut self, distr: D) -> T {
+        distr.sample(self)
+    }
+
+    /// Create an iterator that generates values using the given distribution.
+    ///
+    /// Note that this function takes its arguments by value. This works since
+    /// `(&mut R): Rng where R: Rng` and
+    /// `(&D): Distribution where D: Distribution`,
+    /// however borrowing is not automatic hence `rng.sample_iter(...)` may
+    /// need to be replaced with `(&mut rng).sample_iter(...)`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use rand::{thread_rng, Rng};
+    /// use rand::distributions::{Alphanumeric, Uniform, Standard};
+    ///
+    /// let mut rng = thread_rng();
+    ///
+    /// // Vec of 16 x f32:
+    /// let v: Vec<f32> = (&mut rng).sample_iter(Standard).take(16).collect();
+    ///
+    /// // String:
+    /// let s: String = (&mut rng).sample_iter(Alphanumeric)
+    ///     .take(7)
+    ///     .map(char::from)
+    ///     .collect();
+    ///
+    /// // Combined values
+    /// println!("{:?}", (&mut rng).sample_iter(Standard).take(5)
+    ///                              .collect::<Vec<(f64, bool)>>());
+    ///
+    /// // Dice-rolling:
+    /// let die_range = Uniform::new_inclusive(1, 6);
+    /// let mut roll_die = (&mut rng).sample_iter(die_range);
+    /// while roll_die.next().unwrap() != 6 {
+    ///     println!("Not a 6; rolling again!");
+    /// }
+    /// ```
+    fn sample_iter<T, D>(self, distr: D) -> distributions::DistIter<D, Self, T>
+    where
+        D: Distribution<T>,
+        Self: Sized,
+    {
+        distr.sample_iter(self)
+    }
+
+    /// Fill any type implementing [`Fill`] with random data
+    ///
+    /// The distribution is expected to be uniform with portable results, but
+    /// this cannot be guaranteed for third-party implementations.
+    ///
+    /// This is identical to [`try_fill`] except that it panics on error.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use rand::{thread_rng, Rng};
+    ///
+    /// let mut arr = [0i8; 20];
+    /// thread_rng().fill(&mut arr[..]);
+    /// ```
+    ///
+    /// [`fill_bytes`]: RngCore::fill_bytes
+    /// [`try_fill`]: Rng::try_fill
+    fn fill<T: Fill + ?Sized>(&mut self, dest: &mut T) {
+        dest.try_fill(self).unwrap_or_else(|_| panic!("Rng::fill failed"))
+    }
+
+    /// Fill any type implementing [`Fill`] with random data
+    ///
+    /// The distribution is expected to be uniform with portable results, but
+    /// this cannot be guaranteed for third-party implementations.
+    ///
+    /// This is identical to [`fill`] except that it forwards errors.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use rand::Error;
+    /// use rand::{thread_rng, Rng};
+    ///
+    /// # fn try_inner() -> Result<(), Error> {
+    /// let mut arr = [0u64; 4];
+    /// thread_rng().try_fill(&mut arr[..])?;
+    /// # Ok(())
+    /// # }
+    ///
+    /// # try_inner().unwrap()
+    /// ```
+    ///
+    /// [`try_fill_bytes`]: RngCore::try_fill_bytes
+    /// [`fill`]: Rng::fill
+    fn try_fill<T: Fill + ?Sized>(&mut self, dest: &mut T) -> Result<(), Error> {
+        dest.try_fill(self)
+    }
+
+    /// Return a bool with a probability `p` of being true.
+    ///
+    /// See also the [`Bernoulli`] distribution, which may be faster if
+    /// sampling from the same probability repeatedly.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use rand::{thread_rng, Rng};
+    ///
+    /// let mut rng = thread_rng();
+    /// println!("{}", rng.gen_bool(1.0 / 3.0));
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// If `p < 0` or `p > 1`.
+    ///
+    /// [`Bernoulli`]: distributions::Bernoulli
+    #[inline]
+    fn gen_bool(&mut self, p: f64) -> bool {
+        let d = distributions::Bernoulli::new(p).unwrap();
+        self.sample(d)
+    }
+
+    /// Return a bool with a probability of `numerator/denominator` of being
+    /// true. I.e. `gen_ratio(2, 3)` has chance of 2 in 3, or about 67%, of
+    /// returning true. If `numerator == denominator`, then the returned value
+    /// is guaranteed to be `true`. If `numerator == 0`, then the returned
+    /// value is guaranteed to be `false`.
+    ///
+    /// See also the [`Bernoulli`] distribution, which may be faster if
+    /// sampling from the same `numerator` and `denominator` repeatedly.
+    ///
+    /// # Panics
+    ///
+    /// If `denominator == 0` or `numerator > denominator`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use rand::{thread_rng, Rng};
+    ///
+    /// let mut rng = thread_rng();
+    /// println!("{}", rng.gen_ratio(2, 3));
+    /// ```
+    ///
+    /// [`Bernoulli`]: distributions::Bernoulli
+    #[inline]
+    fn gen_ratio(&mut self, numerator: u32, denominator: u32) -> bool {
+        let d = distributions::Bernoulli::from_ratio(numerator, denominator).unwrap();
+        self.sample(d)
+    }
+}
+
+impl<R: RngCore + ?Sized> Rng for R {}
+
+/// Types which may be filled with random data
+///
+/// This trait allows arrays to be efficiently filled with random data.
+///
+/// Implementations are expected to be portable across machines unless
+/// clearly documented otherwise (see the
+/// [Chapter on Portability](https://rust-random.github.io/book/portability.html)).
+pub trait Fill {
+    /// Fill self with random data
+    fn try_fill<R: Rng + ?Sized>(&mut self, rng: &mut R) -> Result<(), Error>;
+}
+
+macro_rules! impl_fill_each {
+    () => {};
+    ($t:ty) => {
+        impl Fill for [$t] {
+            fn try_fill<R: Rng + ?Sized>(&mut self, rng: &mut R) -> Result<(), Error> {
+                for elt in self.iter_mut() {
+                    *elt = rng.gen();
+                }
+                Ok(())
+            }
+        }
+    };
+    ($t:ty, $($tt:ty,)*) => {
+        impl_fill_each!($t);
+        impl_fill_each!($($tt,)*);
+    };
+}
+
+impl_fill_each!(bool, char, f32, f64,);
+
+impl Fill for [u8] {
+    fn try_fill<R: Rng + ?Sized>(&mut self, rng: &mut R) -> Result<(), Error> {
+        rng.try_fill_bytes(self)
+    }
+}
+
+macro_rules! impl_fill {
+    () => {};
+    ($t:ty) => {
+        impl Fill for [$t] {
+            #[inline(never)] // in micro benchmarks, this improves performance
+            fn try_fill<R: Rng + ?Sized>(&mut self, rng: &mut R) -> Result<(), Error> {
+                if self.len() > 0 {
+                    rng.try_fill_bytes(unsafe {
+                        slice::from_raw_parts_mut(self.as_mut_ptr()
+                            as *mut u8,
+                            self.len() * mem::size_of::<$t>()
+                        )
+                    })?;
+                    for x in self {
+                        *x = x.to_le();
+                    }
+                }
+                Ok(())
+            }
+        }
+
+        impl Fill for [Wrapping<$t>] {
+            #[inline(never)]
+            fn try_fill<R: Rng + ?Sized>(&mut self, rng: &mut R) -> Result<(), Error> {
+                if self.len() > 0 {
+                    rng.try_fill_bytes(unsafe {
+                        slice::from_raw_parts_mut(self.as_mut_ptr()
+                            as *mut u8,
+                            self.len() * mem::size_of::<$t>()
+                        )
+                    })?;
+                    for x in self {
+                    *x = Wrapping(x.0.to_le());
+                    }
+                }
+                Ok(())
+            }
+        }
+    };
+    ($t:ty, $($tt:ty,)*) => {
+        impl_fill!($t);
+        // TODO: this could replace above impl once Rust #32463 is fixed
+        // impl_fill!(Wrapping<$t>);
+        impl_fill!($($tt,)*);
+    }
+}
+
+impl_fill!(u16, u32, u64, usize, u128,);
+impl_fill!(i8, i16, i32, i64, isize, i128,);
+
+#[cfg_attr(doc_cfg, doc(cfg(feature = "min_const_gen")))]
+#[cfg(feature = "min_const_gen")]
+impl<T, const N: usize> Fill for [T; N]
+where [T]: Fill
+{
+    fn try_fill<R: Rng + ?Sized>(&mut self, rng: &mut R) -> Result<(), Error> {
+        self[..].try_fill(rng)
+    }
+}
+
+#[cfg(not(feature = "min_const_gen"))]
+macro_rules! impl_fill_arrays {
+    ($n:expr,) => {};
+    ($n:expr, $N:ident) => {
+        impl<T> Fill for [T; $n] where [T]: Fill {
+            fn try_fill<R: Rng + ?Sized>(&mut self, rng: &mut R) -> Result<(), Error> {
+                self[..].try_fill(rng)
+            }
+        }
+    };
+    ($n:expr, $N:ident, $($NN:ident,)*) => {
+        impl_fill_arrays!($n, $N);
+        impl_fill_arrays!($n - 1, $($NN,)*);
+    };
+    (!div $n:expr,) => {};
+    (!div $n:expr, $N:ident, $($NN:ident,)*) => {
+        impl_fill_arrays!($n, $N);
+        impl_fill_arrays!(!div $n / 2, $($NN,)*);
+    };
+}
+#[cfg(not(feature = "min_const_gen"))]
+#[rustfmt::skip]
+impl_fill_arrays!(32, N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,);
+#[cfg(not(feature = "min_const_gen"))]
+impl_fill_arrays!(!div 4096, N,N,N,N,N,N,N,);
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::test::rng;
+    use crate::rngs::mock::StepRng;
+    #[cfg(feature = "alloc")] use alloc::boxed::Box;
+
+    #[test]
+    fn test_fill_bytes_default() {
+        let mut r = StepRng::new(0x11_22_33_44_55_66_77_88, 0);
+
+        // check every remainder mod 8, both in small and big vectors.
+        let lengths = [0, 1, 2, 3, 4, 5, 6, 7, 80, 81, 82, 83, 84, 85, 86, 87];
+        for &n in lengths.iter() {
+            let mut buffer = [0u8; 87];
+            let v = &mut buffer[0..n];
+            r.fill_bytes(v);
+
+            // use this to get nicer error messages.
+            for (i, &byte) in v.iter().enumerate() {
+                if byte == 0 {
+                    panic!("byte {} of {} is zero", i, n)
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn test_fill() {
+        let x = 9041086907909331047; // a random u64
+        let mut rng = StepRng::new(x, 0);
+
+        // Convert to byte sequence and back to u64; byte-swap twice if BE.
+        let mut array = [0u64; 2];
+        rng.fill(&mut array[..]);
+        assert_eq!(array, [x, x]);
+        assert_eq!(rng.next_u64(), x);
+
+        // Convert to bytes then u32 in LE order
+        let mut array = [0u32; 2];
+        rng.fill(&mut array[..]);
+        assert_eq!(array, [x as u32, (x >> 32) as u32]);
+        assert_eq!(rng.next_u32(), x as u32);
+
+        // Check equivalence using wrapped arrays
+        let mut warray = [Wrapping(0u32); 2];
+        rng.fill(&mut warray[..]);
+        assert_eq!(array[0], warray[0].0);
+        assert_eq!(array[1], warray[1].0);
+
+        // Check equivalence for generated floats
+        let mut array = [0f32; 2];
+        rng.fill(&mut array);
+        let gen: [f32; 2] = rng.gen();
+        assert_eq!(array, gen);
+    }
+
+    #[test]
+    fn test_fill_empty() {
+        let mut array = [0u32; 0];
+        let mut rng = StepRng::new(0, 1);
+        rng.fill(&mut array);
+        rng.fill(&mut array[..]);
+    }
+
+    #[test]
+    fn test_gen_range_int() {
+        let mut r = rng(101);
+        for _ in 0..1000 {
+            let a = r.gen_range(-4711..17);
+            assert!((-4711..17).contains(&a));
+            let a: i8 = r.gen_range(-3..42);
+            assert!((-3..42).contains(&a));
+            let a: u16 = r.gen_range(10..99);
+            assert!((10..99).contains(&a));
+            let a: i32 = r.gen_range(-100..2000);
+            assert!((-100..2000).contains(&a));
+            let a: u32 = r.gen_range(12..=24);
+            assert!((12..=24).contains(&a));
+
+            assert_eq!(r.gen_range(0u32..1), 0u32);
+            assert_eq!(r.gen_range(-12i64..-11), -12i64);
+            assert_eq!(r.gen_range(3_000_000..3_000_001), 3_000_000);
+        }
+    }
+
+    #[test]
+    fn test_gen_range_float() {
+        let mut r = rng(101);
+        for _ in 0..1000 {
+            let a = r.gen_range(-4.5..1.7);
+            assert!((-4.5..1.7).contains(&a));
+            let a = r.gen_range(-1.1..=-0.3);
+            assert!((-1.1..=-0.3).contains(&a));
+
+            assert_eq!(r.gen_range(0.0f32..=0.0), 0.);
+            assert_eq!(r.gen_range(-11.0..=-11.0), -11.);
+            assert_eq!(r.gen_range(3_000_000.0..=3_000_000.0), 3_000_000.);
+        }
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_gen_range_panic_int() {
+        #![allow(clippy::reversed_empty_ranges)]
+        let mut r = rng(102);
+        r.gen_range(5..-2);
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_gen_range_panic_usize() {
+        #![allow(clippy::reversed_empty_ranges)]
+        let mut r = rng(103);
+        r.gen_range(5..2);
+    }
+
+    #[test]
+    fn test_gen_bool() {
+        #![allow(clippy::bool_assert_comparison)]
+
+        let mut r = rng(105);
+        for _ in 0..5 {
+            assert_eq!(r.gen_bool(0.0), false);
+            assert_eq!(r.gen_bool(1.0), true);
+        }
+    }
+
+    #[test]
+    fn test_rng_trait_object() {
+        use crate::distributions::{Distribution, Standard};
+        let mut rng = rng(109);
+        let mut r = &mut rng as &mut dyn RngCore;
+        r.next_u32();
+        r.gen::<i32>();
+        assert_eq!(r.gen_range(0..1), 0);
+        let _c: u8 = Standard.sample(&mut r);
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn test_rng_boxed_trait() {
+        use crate::distributions::{Distribution, Standard};
+        let rng = rng(110);
+        let mut r = Box::new(rng) as Box<dyn RngCore>;
+        r.next_u32();
+        r.gen::<i32>();
+        assert_eq!(r.gen_range(0..1), 0);
+        let _c: u8 = Standard.sample(&mut r);
+    }
+
+    #[test]
+    #[cfg_attr(miri, ignore)] // Miri is too slow
+    fn test_gen_ratio_average() {
+        const NUM: u32 = 3;
+        const DENOM: u32 = 10;
+        const N: u32 = 100_000;
+
+        let mut sum: u32 = 0;
+        let mut rng = rng(111);
+        for _ in 0..N {
+            if rng.gen_ratio(NUM, DENOM) {
+                sum += 1;
+            }
+        }
+        // Have Binomial(N, NUM/DENOM) distribution
+        let expected = (NUM * N) / DENOM; // exact integer
+        assert!(((sum - expected) as i32).abs() < 500);
+    }
+}
diff --git a/crates/rand/src/rngs/adapter/mod.rs b/crates/rand/src/rngs/adapter/mod.rs
new file mode 100644
index 0000000..bd1d294
--- /dev/null
+++ b/crates/rand/src/rngs/adapter/mod.rs
@@ -0,0 +1,16 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Wrappers / adapters forming RNGs
+
+mod read;
+mod reseeding;
+
+#[allow(deprecated)]
+pub use self::read::{ReadError, ReadRng};
+pub use self::reseeding::ReseedingRng;
diff --git a/crates/rand/src/rngs/adapter/read.rs b/crates/rand/src/rngs/adapter/read.rs
new file mode 100644
index 0000000..25a9ca7
--- /dev/null
+++ b/crates/rand/src/rngs/adapter/read.rs
@@ -0,0 +1,150 @@
+// Copyright 2018 Developers of the Rand project.
+// Copyright 2013 The Rust Project Developers.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! A wrapper around any Read to treat it as an RNG.
+
+#![allow(deprecated)]
+
+use std::fmt;
+use std::io::Read;
+
+use rand_core::{impls, Error, RngCore};
+
+
+/// An RNG that reads random bytes straight from any type supporting
+/// [`std::io::Read`], for example files.
+///
+/// This will work best with an infinite reader, but that is not required.
+///
+/// This can be used with `/dev/urandom` on Unix but it is recommended to use
+/// [`OsRng`] instead.
+///
+/// # Panics
+///
+/// `ReadRng` uses [`std::io::Read::read_exact`], which retries on interrupts.
+/// All other errors from the underlying reader, including when it does not
+/// have enough data, will only be reported through [`try_fill_bytes`].
+/// The other [`RngCore`] methods will panic in case of an error.
+///
+/// [`OsRng`]: crate::rngs::OsRng
+/// [`try_fill_bytes`]: RngCore::try_fill_bytes
+#[derive(Debug)]
+#[deprecated(since="0.8.4", note="removal due to lack of usage")]
+pub struct ReadRng<R> {
+    reader: R,
+}
+
+impl<R: Read> ReadRng<R> {
+    /// Create a new `ReadRng` from a `Read`.
+    pub fn new(r: R) -> ReadRng<R> {
+        ReadRng { reader: r }
+    }
+}
+
+impl<R: Read> RngCore for ReadRng<R> {
+    fn next_u32(&mut self) -> u32 {
+        impls::next_u32_via_fill(self)
+    }
+
+    fn next_u64(&mut self) -> u64 {
+        impls::next_u64_via_fill(self)
+    }
+
+    fn fill_bytes(&mut self, dest: &mut [u8]) {
+        self.try_fill_bytes(dest).unwrap_or_else(|err| {
+            panic!(
+                "reading random bytes from Read implementation failed; error: {}",
+                err
+            )
+        });
+    }
+
+    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
+        if dest.is_empty() {
+            return Ok(());
+        }
+        // Use `std::io::read_exact`, which retries on `ErrorKind::Interrupted`.
+        self.reader
+            .read_exact(dest)
+            .map_err(|e| Error::new(ReadError(e)))
+    }
+}
+
+/// `ReadRng` error type
+#[derive(Debug)]
+#[deprecated(since="0.8.4")]
+pub struct ReadError(std::io::Error);
+
+impl fmt::Display for ReadError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "ReadError: {}", self.0)
+    }
+}
+
+impl std::error::Error for ReadError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        Some(&self.0)
+    }
+}
+
+
+#[cfg(test)]
+mod test {
+    use std::println;
+
+    use super::ReadRng;
+    use crate::RngCore;
+
+    #[test]
+    fn test_reader_rng_u64() {
+        // transmute from the target to avoid endianness concerns.
+        #[rustfmt::skip]
+        let v = [0u8, 0, 0, 0, 0, 0, 0, 1,
+                 0,   4, 0, 0, 3, 0, 0, 2,
+                 5,   0, 0, 0, 0, 0, 0, 0];
+        let mut rng = ReadRng::new(&v[..]);
+
+        assert_eq!(rng.next_u64(), 1 << 56);
+        assert_eq!(rng.next_u64(), (2 << 56) + (3 << 32) + (4 << 8));
+        assert_eq!(rng.next_u64(), 5);
+    }
+
+    #[test]
+    fn test_reader_rng_u32() {
+        let v = [0u8, 0, 0, 1, 0, 0, 2, 0, 3, 0, 0, 0];
+        let mut rng = ReadRng::new(&v[..]);
+
+        assert_eq!(rng.next_u32(), 1 << 24);
+        assert_eq!(rng.next_u32(), 2 << 16);
+        assert_eq!(rng.next_u32(), 3);
+    }
+
+    #[test]
+    fn test_reader_rng_fill_bytes() {
+        let v = [1u8, 2, 3, 4, 5, 6, 7, 8];
+        let mut w = [0u8; 8];
+
+        let mut rng = ReadRng::new(&v[..]);
+        rng.fill_bytes(&mut w);
+
+        assert!(v == w);
+    }
+
+    #[test]
+    fn test_reader_rng_insufficient_bytes() {
+        let v = [1u8, 2, 3, 4, 5, 6, 7, 8];
+        let mut w = [0u8; 9];
+
+        let mut rng = ReadRng::new(&v[..]);
+
+        let result = rng.try_fill_bytes(&mut w);
+        assert!(result.is_err());
+        println!("Error: {}", result.unwrap_err());
+    }
+}
diff --git a/crates/rand/src/rngs/adapter/reseeding.rs b/crates/rand/src/rngs/adapter/reseeding.rs
new file mode 100644
index 0000000..ae3fcbb
--- /dev/null
+++ b/crates/rand/src/rngs/adapter/reseeding.rs
@@ -0,0 +1,386 @@
+// Copyright 2018 Developers of the Rand project.
+// Copyright 2013 The Rust Project Developers.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! A wrapper around another PRNG that reseeds it after it
+//! generates a certain number of random bytes.
+
+use core::mem::size_of;
+
+use rand_core::block::{BlockRng, BlockRngCore};
+use rand_core::{CryptoRng, Error, RngCore, SeedableRng};
+
+/// A wrapper around any PRNG that implements [`BlockRngCore`], that adds the
+/// ability to reseed it.
+///
+/// `ReseedingRng` reseeds the underlying PRNG in the following cases:
+///
+/// - On a manual call to [`reseed()`].
+/// - After `clone()`, the clone will be reseeded on first use.
+/// - When a process is forked on UNIX, the RNGs in both the parent and child
+///   processes will be reseeded just before the next call to
+///   [`BlockRngCore::generate`], i.e. "soon". For ChaCha and Hc128 this is a
+///   maximum of fifteen `u32` values before reseeding.
+/// - After the PRNG has generated a configurable number of random bytes.
+///
+/// # When should reseeding after a fixed number of generated bytes be used?
+///
+/// Reseeding after a fixed number of generated bytes is never strictly
+/// *necessary*. Cryptographic PRNGs don't have a limited number of bytes they
+/// can output, or at least not a limit reachable in any practical way. There is
+/// no such thing as 'running out of entropy'.
+///
+/// Occasionally reseeding can be seen as some form of 'security in depth'. Even
+/// if in the future a cryptographic weakness is found in the CSPRNG being used,
+/// or a flaw in the implementation, occasionally reseeding should make
+/// exploiting it much more difficult or even impossible.
+///
+/// Use [`ReseedingRng::new`] with a `threshold` of `0` to disable reseeding
+/// after a fixed number of generated bytes.
+///
+/// # Limitations
+///
+/// It is recommended that a `ReseedingRng` (including `ThreadRng`) not be used
+/// from a fork handler.
+/// Use `OsRng` or `getrandom`, or defer your use of the RNG until later.
+///
+/// # Error handling
+///
+/// Although unlikely, reseeding the wrapped PRNG can fail. `ReseedingRng` will
+/// never panic but try to handle the error intelligently through some
+/// combination of retrying and delaying reseeding until later.
+/// If handling the source error fails `ReseedingRng` will continue generating
+/// data from the wrapped PRNG without reseeding.
+///
+/// Manually calling [`reseed()`] will not have this retry or delay logic, but
+/// reports the error.
+///
+/// # Example
+///
+/// ```
+/// use rand::prelude::*;
+/// use rand_chacha::ChaCha20Core; // Internal part of ChaChaRng that
+///                              // implements BlockRngCore
+/// use rand::rngs::OsRng;
+/// use rand::rngs::adapter::ReseedingRng;
+///
+/// let prng = ChaCha20Core::from_entropy();
+/// let mut reseeding_rng = ReseedingRng::new(prng, 0, OsRng);
+///
+/// println!("{}", reseeding_rng.gen::<u64>());
+///
+/// let mut cloned_rng = reseeding_rng.clone();
+/// assert!(reseeding_rng.gen::<u64>() != cloned_rng.gen::<u64>());
+/// ```
+///
+/// [`BlockRngCore`]: rand_core::block::BlockRngCore
+/// [`ReseedingRng::new`]: ReseedingRng::new
+/// [`reseed()`]: ReseedingRng::reseed
+#[derive(Debug)]
+pub struct ReseedingRng<R, Rsdr>(BlockRng<ReseedingCore<R, Rsdr>>)
+where
+    R: BlockRngCore + SeedableRng,
+    Rsdr: RngCore;
+
+impl<R, Rsdr> ReseedingRng<R, Rsdr>
+where
+    R: BlockRngCore + SeedableRng,
+    Rsdr: RngCore,
+{
+    /// Create a new `ReseedingRng` from an existing PRNG, combined with a RNG
+    /// to use as reseeder.
+    ///
+    /// `threshold` sets the number of generated bytes after which to reseed the
+    /// PRNG. Set it to zero to never reseed based on the number of generated
+    /// values.
+    pub fn new(rng: R, threshold: u64, reseeder: Rsdr) -> Self {
+        ReseedingRng(BlockRng::new(ReseedingCore::new(rng, threshold, reseeder)))
+    }
+
+    /// Reseed the internal PRNG.
+    pub fn reseed(&mut self) -> Result<(), Error> {
+        self.0.core.reseed()
+    }
+}
+
+// TODO: this should be implemented for any type where the inner type
+// implements RngCore, but we can't specify that because ReseedingCore is private
+impl<R, Rsdr: RngCore> RngCore for ReseedingRng<R, Rsdr>
+where
+    R: BlockRngCore<Item = u32> + SeedableRng,
+    <R as BlockRngCore>::Results: AsRef<[u32]> + AsMut<[u32]>,
+{
+    #[inline(always)]
+    fn next_u32(&mut self) -> u32 {
+        self.0.next_u32()
+    }
+
+    #[inline(always)]
+    fn next_u64(&mut self) -> u64 {
+        self.0.next_u64()
+    }
+
+    fn fill_bytes(&mut self, dest: &mut [u8]) {
+        self.0.fill_bytes(dest)
+    }
+
+    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
+        self.0.try_fill_bytes(dest)
+    }
+}
+
+impl<R, Rsdr> Clone for ReseedingRng<R, Rsdr>
+where
+    R: BlockRngCore + SeedableRng + Clone,
+    Rsdr: RngCore + Clone,
+{
+    fn clone(&self) -> ReseedingRng<R, Rsdr> {
+        // Recreating `BlockRng` seems easier than cloning it and resetting
+        // the index.
+        ReseedingRng(BlockRng::new(self.0.core.clone()))
+    }
+}
+
+impl<R, Rsdr> CryptoRng for ReseedingRng<R, Rsdr>
+where
+    R: BlockRngCore + SeedableRng + CryptoRng,
+    Rsdr: RngCore + CryptoRng,
+{
+}
+
+#[derive(Debug)]
+struct ReseedingCore<R, Rsdr> {
+    inner: R,
+    reseeder: Rsdr,
+    threshold: i64,
+    bytes_until_reseed: i64,
+    fork_counter: usize,
+}
+
+impl<R, Rsdr> BlockRngCore for ReseedingCore<R, Rsdr>
+where
+    R: BlockRngCore + SeedableRng,
+    Rsdr: RngCore,
+{
+    type Item = <R as BlockRngCore>::Item;
+    type Results = <R as BlockRngCore>::Results;
+
+    fn generate(&mut self, results: &mut Self::Results) {
+        let global_fork_counter = fork::get_fork_counter();
+        if self.bytes_until_reseed <= 0 || self.is_forked(global_fork_counter) {
+            // We get better performance by not calling only `reseed` here
+            // and continuing with the rest of the function, but by directly
+            // returning from a non-inlined function.
+            return self.reseed_and_generate(results, global_fork_counter);
+        }
+        let num_bytes = results.as_ref().len() * size_of::<Self::Item>();
+        self.bytes_until_reseed -= num_bytes as i64;
+        self.inner.generate(results);
+    }
+}
+
+impl<R, Rsdr> ReseedingCore<R, Rsdr>
+where
+    R: BlockRngCore + SeedableRng,
+    Rsdr: RngCore,
+{
+    /// Create a new `ReseedingCore`.
+    fn new(rng: R, threshold: u64, reseeder: Rsdr) -> Self {
+        use ::core::i64::MAX;
+        fork::register_fork_handler();
+
+        // Because generating more values than `i64::MAX` takes centuries on
+        // current hardware, we just clamp to that value.
+        // Also we set a threshold of 0, which indicates no limit, to that
+        // value.
+        let threshold = if threshold == 0 {
+            MAX
+        } else if threshold <= MAX as u64 {
+            threshold as i64
+        } else {
+            MAX
+        };
+
+        ReseedingCore {
+            inner: rng,
+            reseeder,
+            threshold: threshold as i64,
+            bytes_until_reseed: threshold as i64,
+            fork_counter: 0,
+        }
+    }
+
+    /// Reseed the internal PRNG.
+    fn reseed(&mut self) -> Result<(), Error> {
+        R::from_rng(&mut self.reseeder).map(|result| {
+            self.bytes_until_reseed = self.threshold;
+            self.inner = result
+        })
+    }
+
+    fn is_forked(&self, global_fork_counter: usize) -> bool {
+        // In theory, on 32-bit platforms, it is possible for
+        // `global_fork_counter` to wrap around after ~4e9 forks.
+        //
+        // This check will detect a fork in the normal case where
+        // `fork_counter < global_fork_counter`, and also when the difference
+        // between both is greater than `isize::MAX` (wrapped around).
+        //
+        // It will still fail to detect a fork if there have been more than
+        // `isize::MAX` forks, without any reseed in between. Seems unlikely
+        // enough.
+        (self.fork_counter.wrapping_sub(global_fork_counter) as isize) < 0
+    }
+
+    #[inline(never)]
+    fn reseed_and_generate(
+        &mut self, results: &mut <Self as BlockRngCore>::Results, global_fork_counter: usize,
+    ) {
+        #![allow(clippy::if_same_then_else)] // false positive
+        if self.is_forked(global_fork_counter) {
+            info!("Fork detected, reseeding RNG");
+        } else {
+            trace!("Reseeding RNG (periodic reseed)");
+        }
+
+        let num_bytes = results.as_ref().len() * size_of::<<R as BlockRngCore>::Item>();
+
+        if let Err(e) = self.reseed() {
+            warn!("Reseeding RNG failed: {}", e);
+            let _ = e;
+        }
+        self.fork_counter = global_fork_counter;
+
+        self.bytes_until_reseed = self.threshold - num_bytes as i64;
+        self.inner.generate(results);
+    }
+}
+
+impl<R, Rsdr> Clone for ReseedingCore<R, Rsdr>
+where
+    R: BlockRngCore + SeedableRng + Clone,
+    Rsdr: RngCore + Clone,
+{
+    fn clone(&self) -> ReseedingCore<R, Rsdr> {
+        ReseedingCore {
+            inner: self.inner.clone(),
+            reseeder: self.reseeder.clone(),
+            threshold: self.threshold,
+            bytes_until_reseed: 0, // reseed clone on first use
+            fork_counter: self.fork_counter,
+        }
+    }
+}
+
+impl<R, Rsdr> CryptoRng for ReseedingCore<R, Rsdr>
+where
+    R: BlockRngCore + SeedableRng + CryptoRng,
+    Rsdr: RngCore + CryptoRng,
+{
+}
+
+
+#[cfg(all(unix, not(target_os = "emscripten")))]
+mod fork {
+    use core::sync::atomic::{AtomicUsize, Ordering};
+    use std::sync::Once;
+
+    // Fork protection
+    //
+    // We implement fork protection on Unix using `pthread_atfork`.
+    // When the process is forked, we increment `RESEEDING_RNG_FORK_COUNTER`.
+    // Every `ReseedingRng` stores the last known value of the static in
+    // `fork_counter`. If the cached `fork_counter` is less than
+    // `RESEEDING_RNG_FORK_COUNTER`, it is time to reseed this RNG.
+    //
+    // If reseeding fails, we don't deal with this by setting a delay, but just
+    // don't update `fork_counter`, so a reseed is attempted as soon as
+    // possible.
+
+    static RESEEDING_RNG_FORK_COUNTER: AtomicUsize = AtomicUsize::new(0);
+
+    pub fn get_fork_counter() -> usize {
+        RESEEDING_RNG_FORK_COUNTER.load(Ordering::Relaxed)
+    }
+
+    extern "C" fn fork_handler() {
+        // Note: fetch_add is defined to wrap on overflow
+        // (which is what we want).
+        RESEEDING_RNG_FORK_COUNTER.fetch_add(1, Ordering::Relaxed);
+    }
+
+    pub fn register_fork_handler() {
+        static REGISTER: Once = Once::new();
+        REGISTER.call_once(|| {
+            // Bump the counter before and after forking (see #1169):
+            let ret = unsafe { libc::pthread_atfork(
+                Some(fork_handler),
+                Some(fork_handler),
+                Some(fork_handler),
+            ) };
+            if ret != 0 {
+                panic!("libc::pthread_atfork failed with code {}", ret);
+            }
+        });
+    }
+}
+
+#[cfg(not(all(unix, not(target_os = "emscripten"))))]
+mod fork {
+    pub fn get_fork_counter() -> usize {
+        0
+    }
+    pub fn register_fork_handler() {}
+}
+
+
+#[cfg(feature = "std_rng")]
+#[cfg(test)]
+mod test {
+    use super::ReseedingRng;
+    use crate::rngs::mock::StepRng;
+    use crate::rngs::std::Core;
+    use crate::{Rng, SeedableRng};
+
+    #[test]
+    fn test_reseeding() {
+        let mut zero = StepRng::new(0, 0);
+        let rng = Core::from_rng(&mut zero).unwrap();
+        let thresh = 1; // reseed every time the buffer is exhausted
+        let mut reseeding = ReseedingRng::new(rng, thresh, zero);
+
+        // RNG buffer size is [u32; 64]
+        // Debug is only implemented up to length 32 so use two arrays
+        let mut buf = ([0u32; 32], [0u32; 32]);
+        reseeding.fill(&mut buf.0);
+        reseeding.fill(&mut buf.1);
+        let seq = buf;
+        for _ in 0..10 {
+            reseeding.fill(&mut buf.0);
+            reseeding.fill(&mut buf.1);
+            assert_eq!(buf, seq);
+        }
+    }
+
+    #[test]
+    fn test_clone_reseeding() {
+        #![allow(clippy::redundant_clone)]
+
+        let mut zero = StepRng::new(0, 0);
+        let rng = Core::from_rng(&mut zero).unwrap();
+        let mut rng1 = ReseedingRng::new(rng, 32 * 4, zero);
+
+        let first: u32 = rng1.gen();
+        for _ in 0..10 {
+            let _ = rng1.gen::<u32>();
+        }
+
+        let mut rng2 = rng1.clone();
+        assert_eq!(first, rng2.gen::<u32>());
+    }
+}
diff --git a/crates/rand/src/rngs/mock.rs b/crates/rand/src/rngs/mock.rs
new file mode 100644
index 0000000..a1745a4
--- /dev/null
+++ b/crates/rand/src/rngs/mock.rs
@@ -0,0 +1,87 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Mock random number generator
+
+use rand_core::{impls, Error, RngCore};
+
+#[cfg(feature = "serde1")]
+use serde::{Serialize, Deserialize};
+
+/// A simple implementation of `RngCore` for testing purposes.
+///
+/// This generates an arithmetic sequence (i.e. adds a constant each step)
+/// over a `u64` number, using wrapping arithmetic. If the increment is 0
+/// the generator yields a constant.
+///
+/// ```
+/// use rand::Rng;
+/// use rand::rngs::mock::StepRng;
+///
+/// let mut my_rng = StepRng::new(2, 1);
+/// let sample: [u64; 3] = my_rng.gen();
+/// assert_eq!(sample, [2, 3, 4]);
+/// ```
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
+pub struct StepRng {
+    v: u64,
+    a: u64,
+}
+
+impl StepRng {
+    /// Create a `StepRng`, yielding an arithmetic sequence starting with
+    /// `initial` and incremented by `increment` each time.
+    pub fn new(initial: u64, increment: u64) -> Self {
+        StepRng {
+            v: initial,
+            a: increment,
+        }
+    }
+}
+
+impl RngCore for StepRng {
+    #[inline]
+    fn next_u32(&mut self) -> u32 {
+        self.next_u64() as u32
+    }
+
+    #[inline]
+    fn next_u64(&mut self) -> u64 {
+        let result = self.v;
+        self.v = self.v.wrapping_add(self.a);
+        result
+    }
+
+    #[inline]
+    fn fill_bytes(&mut self, dest: &mut [u8]) {
+        impls::fill_bytes_via_next(self, dest);
+    }
+
+    #[inline]
+    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
+        self.fill_bytes(dest);
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    #[cfg(feature = "serde1")]
+    fn test_serialization_step_rng() {
+        use super::StepRng;
+
+        let some_rng = StepRng::new(42, 7);
+        let de_some_rng: StepRng =
+            bincode::deserialize(&bincode::serialize(&some_rng).unwrap()).unwrap();
+        assert_eq!(some_rng.v, de_some_rng.v);
+        assert_eq!(some_rng.a, de_some_rng.a);
+
+    }
+}
diff --git a/crates/rand/src/rngs/mod.rs b/crates/rand/src/rngs/mod.rs
new file mode 100644
index 0000000..ac3c2c5
--- /dev/null
+++ b/crates/rand/src/rngs/mod.rs
@@ -0,0 +1,119 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Random number generators and adapters
+//!
+//! ## Background: Random number generators (RNGs)
+//!
+//! Computers cannot produce random numbers from nowhere. We classify
+//! random number generators as follows:
+//!
+//! -   "True" random number generators (TRNGs) use hard-to-predict data sources
+//!     (e.g. the high-resolution parts of event timings and sensor jitter) to
+//!     harvest random bit-sequences, apply algorithms to remove bias and
+//!     estimate available entropy, then combine these bits into a byte-sequence
+//!     or an entropy pool. This job is usually done by the operating system or
+//!     a hardware generator (HRNG).
+//! -   "Pseudo"-random number generators (PRNGs) use algorithms to transform a
+//!     seed into a sequence of pseudo-random numbers. These generators can be
+//!     fast and produce well-distributed unpredictable random numbers (or not).
+//!     They are usually deterministic: given algorithm and seed, the output
+//!     sequence can be reproduced. They have finite period and eventually loop;
+//!     with many algorithms this period is fixed and can be proven sufficiently
+//!     long, while others are chaotic and the period depends on the seed.
+//! -   "Cryptographically secure" pseudo-random number generators (CSPRNGs)
+//!     are the sub-set of PRNGs which are secure. Security of the generator
+//!     relies both on hiding the internal state and using a strong algorithm.
+//!
+//! ## Traits and functionality
+//!
+//! All RNGs implement the [`RngCore`] trait, as a consequence of which the
+//! [`Rng`] extension trait is automatically implemented. Secure RNGs may
+//! additionally implement the [`CryptoRng`] trait.
+//!
+//! All PRNGs require a seed to produce their random number sequence. The
+//! [`SeedableRng`] trait provides three ways of constructing PRNGs:
+//!
+//! -   `from_seed` accepts a type specific to the PRNG
+//! -   `from_rng` allows a PRNG to be seeded from any other RNG
+//! -   `seed_from_u64` allows any PRNG to be seeded from a `u64` insecurely
+//! -   `from_entropy` securely seeds a PRNG from fresh entropy
+//!
+//! Use the [`rand_core`] crate when implementing your own RNGs.
+//!
+//! ## Our generators
+//!
+//! This crate provides several random number generators:
+//!
+//! -   [`OsRng`] is an interface to the operating system's random number
+//!     source. Typically the operating system uses a CSPRNG with entropy
+//!     provided by a TRNG and some type of on-going re-seeding.
+//! -   [`ThreadRng`], provided by the [`thread_rng`] function, is a handle to a
+//!     thread-local CSPRNG with periodic seeding from [`OsRng`]. Because this
+//!     is local, it is typically much faster than [`OsRng`]. It should be
+//!     secure, though the paranoid may prefer [`OsRng`].
+//! -   [`StdRng`] is a CSPRNG chosen for good performance and trust of security
+//!     (based on reviews, maturity and usage). The current algorithm is ChaCha12,
+//!     which is well established and rigorously analysed.
+//!     [`StdRng`] provides the algorithm used by [`ThreadRng`] but without
+//!     periodic reseeding.
+//! -   [`SmallRng`] is an **insecure** PRNG designed to be fast, simple, require
+//!     little memory, and have good output quality.
+//!
+//! The algorithms selected for [`StdRng`] and [`SmallRng`] may change in any
+//! release and may be platform-dependent, therefore they should be considered
+//! **not reproducible**.
+//!
+//! ## Additional generators
+//!
+//! **TRNGs**: The [`rdrand`] crate provides an interface to the RDRAND and
+//! RDSEED instructions available in modern Intel and AMD CPUs.
+//! The [`rand_jitter`] crate provides a user-space implementation of
+//! entropy harvesting from CPU timer jitter, but is very slow and has
+//! [security issues](https://github.com/rust-random/rand/issues/699).
+//!
+//! **PRNGs**: Several companion crates are available, providing individual or
+//! families of PRNG algorithms. These provide the implementations behind
+//! [`StdRng`] and [`SmallRng`] but can also be used directly, indeed *should*
+//! be used directly when **reproducibility** matters.
+//! Some suggestions are: [`rand_chacha`], [`rand_pcg`], [`rand_xoshiro`].
+//! A full list can be found by searching for crates with the [`rng` tag].
+//!
+//! [`Rng`]: crate::Rng
+//! [`RngCore`]: crate::RngCore
+//! [`CryptoRng`]: crate::CryptoRng
+//! [`SeedableRng`]: crate::SeedableRng
+//! [`thread_rng`]: crate::thread_rng
+//! [`rdrand`]: https://crates.io/crates/rdrand
+//! [`rand_jitter`]: https://crates.io/crates/rand_jitter
+//! [`rand_chacha`]: https://crates.io/crates/rand_chacha
+//! [`rand_pcg`]: https://crates.io/crates/rand_pcg
+//! [`rand_xoshiro`]: https://crates.io/crates/rand_xoshiro
+//! [`rng` tag]: https://crates.io/keywords/rng
+
+#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
+#[cfg(feature = "std")] pub mod adapter;
+
+pub mod mock; // Public so we don't export `StepRng` directly, making it a bit
+              // more clear it is intended for testing.
+
+#[cfg(all(feature = "small_rng", target_pointer_width = "64"))]
+mod xoshiro256plusplus;
+#[cfg(all(feature = "small_rng", not(target_pointer_width = "64")))]
+mod xoshiro128plusplus;
+#[cfg(feature = "small_rng")] mod small;
+
+#[cfg(feature = "std_rng")] mod std;
+#[cfg(all(feature = "std", feature = "std_rng"))] pub(crate) mod thread;
+
+#[cfg(feature = "small_rng")] pub use self::small::SmallRng;
+#[cfg(feature = "std_rng")] pub use self::std::StdRng;
+#[cfg(all(feature = "std", feature = "std_rng"))] pub use self::thread::ThreadRng;
+
+#[cfg_attr(doc_cfg, doc(cfg(feature = "getrandom")))]
+#[cfg(feature = "getrandom")] pub use rand_core::OsRng;
diff --git a/crates/rand/src/rngs/small.rs b/crates/rand/src/rngs/small.rs
new file mode 100644
index 0000000..fb0e0d1
--- /dev/null
+++ b/crates/rand/src/rngs/small.rs
@@ -0,0 +1,117 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! A small fast RNG
+
+use rand_core::{Error, RngCore, SeedableRng};
+
+#[cfg(target_pointer_width = "64")]
+type Rng = super::xoshiro256plusplus::Xoshiro256PlusPlus;
+#[cfg(not(target_pointer_width = "64"))]
+type Rng = super::xoshiro128plusplus::Xoshiro128PlusPlus;
+
+/// A small-state, fast non-crypto PRNG
+///
+/// `SmallRng` may be a good choice when a PRNG with small state, cheap
+/// initialization, good statistical quality and good performance are required.
+/// Note that depending on the application, [`StdRng`] may be faster on many
+/// modern platforms while providing higher-quality randomness. Furthermore,
+/// `SmallRng` is **not** a good choice when:
+/// - Security against prediction is important. Use [`StdRng`] instead.
+/// - Seeds with many zeros are provided. In such cases, it takes `SmallRng`
+///   about 10 samples to produce 0 and 1 bits with equal probability. Either
+///   provide seeds with an approximately equal number of 0 and 1 (for example
+///   by using [`SeedableRng::from_entropy`] or [`SeedableRng::seed_from_u64`]),
+///   or use [`StdRng`] instead.
+///
+/// The algorithm is deterministic but should not be considered reproducible
+/// due to dependence on platform and possible replacement in future
+/// library versions. For a reproducible generator, use a named PRNG from an
+/// external crate, e.g. [rand_xoshiro] or [rand_chacha].
+/// Refer also to [The Book](https://rust-random.github.io/book/guide-rngs.html).
+///
+/// The PRNG algorithm in `SmallRng` is chosen to be efficient on the current
+/// platform, without consideration for cryptography or security. The size of
+/// its state is much smaller than [`StdRng`]. The current algorithm is
+/// `Xoshiro256PlusPlus` on 64-bit platforms and `Xoshiro128PlusPlus` on 32-bit
+/// platforms. Both are also implemented by the [rand_xoshiro] crate.
+///
+/// # Examples
+///
+/// Initializing `SmallRng` with a random seed can be done using [`SeedableRng::from_entropy`]:
+///
+/// ```
+/// use rand::{Rng, SeedableRng};
+/// use rand::rngs::SmallRng;
+///
+/// // Create small, cheap to initialize and fast RNG with a random seed.
+/// // The randomness is supplied by the operating system.
+/// let mut small_rng = SmallRng::from_entropy();
+/// # let v: u32 = small_rng.gen();
+/// ```
+///
+/// When initializing a lot of `SmallRng`'s, using [`thread_rng`] can be more
+/// efficient:
+///
+/// ```
+/// use rand::{SeedableRng, thread_rng};
+/// use rand::rngs::SmallRng;
+///
+/// // Create a big, expensive to initialize and slower, but unpredictable RNG.
+/// // This is cached and done only once per thread.
+/// let mut thread_rng = thread_rng();
+/// // Create small, cheap to initialize and fast RNGs with random seeds.
+/// // One can generally assume this won't fail.
+/// let rngs: Vec<SmallRng> = (0..10)
+///     .map(|_| SmallRng::from_rng(&mut thread_rng).unwrap())
+///     .collect();
+/// ```
+///
+/// [`StdRng`]: crate::rngs::StdRng
+/// [`thread_rng`]: crate::thread_rng
+/// [rand_chacha]: https://crates.io/crates/rand_chacha
+/// [rand_xoshiro]: https://crates.io/crates/rand_xoshiro
+#[cfg_attr(doc_cfg, doc(cfg(feature = "small_rng")))]
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct SmallRng(Rng);
+
+impl RngCore for SmallRng {
+    #[inline(always)]
+    fn next_u32(&mut self) -> u32 {
+        self.0.next_u32()
+    }
+
+    #[inline(always)]
+    fn next_u64(&mut self) -> u64 {
+        self.0.next_u64()
+    }
+
+    #[inline(always)]
+    fn fill_bytes(&mut self, dest: &mut [u8]) {
+        self.0.fill_bytes(dest);
+    }
+
+    #[inline(always)]
+    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
+        self.0.try_fill_bytes(dest)
+    }
+}
+
+impl SeedableRng for SmallRng {
+    type Seed = <Rng as SeedableRng>::Seed;
+
+    #[inline(always)]
+    fn from_seed(seed: Self::Seed) -> Self {
+        SmallRng(Rng::from_seed(seed))
+    }
+
+    #[inline(always)]
+    fn from_rng<R: RngCore>(rng: R) -> Result<Self, Error> {
+        Rng::from_rng(rng).map(SmallRng)
+    }
+}
diff --git a/crates/rand/src/rngs/std.rs b/crates/rand/src/rngs/std.rs
new file mode 100644
index 0000000..cdae8fa
--- /dev/null
+++ b/crates/rand/src/rngs/std.rs
@@ -0,0 +1,98 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! The standard RNG
+
+use crate::{CryptoRng, Error, RngCore, SeedableRng};
+
+pub(crate) use rand_chacha::ChaCha12Core as Core;
+
+use rand_chacha::ChaCha12Rng as Rng;
+
+/// The standard RNG. The PRNG algorithm in `StdRng` is chosen to be efficient
+/// on the current platform, to be statistically strong and unpredictable
+/// (meaning a cryptographically secure PRNG).
+///
+/// The current algorithm used is the ChaCha block cipher with 12 rounds. Please
+/// see this relevant [rand issue] for the discussion. This may change as new 
+/// evidence of cipher security and performance becomes available.
+///
+/// The algorithm is deterministic but should not be considered reproducible
+/// due to dependence on configuration and possible replacement in future
+/// library versions. For a secure reproducible generator, we recommend use of
+/// the [rand_chacha] crate directly.
+///
+/// [rand_chacha]: https://crates.io/crates/rand_chacha
+/// [rand issue]: https://github.com/rust-random/rand/issues/932
+#[cfg_attr(doc_cfg, doc(cfg(feature = "std_rng")))]
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct StdRng(Rng);
+
+impl RngCore for StdRng {
+    #[inline(always)]
+    fn next_u32(&mut self) -> u32 {
+        self.0.next_u32()
+    }
+
+    #[inline(always)]
+    fn next_u64(&mut self) -> u64 {
+        self.0.next_u64()
+    }
+
+    #[inline(always)]
+    fn fill_bytes(&mut self, dest: &mut [u8]) {
+        self.0.fill_bytes(dest);
+    }
+
+    #[inline(always)]
+    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
+        self.0.try_fill_bytes(dest)
+    }
+}
+
+impl SeedableRng for StdRng {
+    type Seed = <Rng as SeedableRng>::Seed;
+
+    #[inline(always)]
+    fn from_seed(seed: Self::Seed) -> Self {
+        StdRng(Rng::from_seed(seed))
+    }
+
+    #[inline(always)]
+    fn from_rng<R: RngCore>(rng: R) -> Result<Self, Error> {
+        Rng::from_rng(rng).map(StdRng)
+    }
+}
+
+impl CryptoRng for StdRng {}
+
+
+#[cfg(test)]
+mod test {
+    use crate::rngs::StdRng;
+    use crate::{RngCore, SeedableRng};
+
+    #[test]
+    fn test_stdrng_construction() {
+        // Test value-stability of StdRng. This is expected to break any time
+        // the algorithm is changed.
+        #[rustfmt::skip]
+        let seed = [1,0,0,0, 23,0,0,0, 200,1,0,0, 210,30,0,0,
+                    0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0];
+
+        let target = [10719222850664546238, 14064965282130556830];
+
+        let mut rng0 = StdRng::from_seed(seed);
+        let x0 = rng0.next_u64();
+
+        let mut rng1 = StdRng::from_rng(rng0).unwrap();
+        let x1 = rng1.next_u64();
+
+        assert_eq!([x0, x1], target);
+    }
+}
diff --git a/crates/rand/src/rngs/thread.rs b/crates/rand/src/rngs/thread.rs
new file mode 100644
index 0000000..baebb1d
--- /dev/null
+++ b/crates/rand/src/rngs/thread.rs
@@ -0,0 +1,143 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Thread-local random number generator
+
+use core::cell::UnsafeCell;
+use std::rc::Rc;
+use std::thread_local;
+
+use super::std::Core;
+use crate::rngs::adapter::ReseedingRng;
+use crate::rngs::OsRng;
+use crate::{CryptoRng, Error, RngCore, SeedableRng};
+
+// Rationale for using `UnsafeCell` in `ThreadRng`:
+//
+// Previously we used a `RefCell`, with an overhead of ~15%. There will only
+// ever be one mutable reference to the interior of the `UnsafeCell`, because
+// we only have such a reference inside `next_u32`, `next_u64`, etc. Within a
+// single thread (which is the definition of `ThreadRng`), there will only ever
+// be one of these methods active at a time.
+//
+// A possible scenario where there could be multiple mutable references is if
+// `ThreadRng` is used inside `next_u32` and co. But the implementation is
+// completely under our control. We just have to ensure none of them use
+// `ThreadRng` internally, which is nonsensical anyway. We should also never run
+// `ThreadRng` in destructors of its implementation, which is also nonsensical.
+
+
+// Number of generated bytes after which to reseed `ThreadRng`.
+// According to benchmarks, reseeding has a noticeable impact with thresholds
+// of 32 kB and less. We choose 64 kB to avoid significant overhead.
+const THREAD_RNG_RESEED_THRESHOLD: u64 = 1024 * 64;
+
+/// A reference to the thread-local generator
+///
+/// An instance can be obtained via [`thread_rng`] or via `ThreadRng::default()`.
+/// This handle is safe to use everywhere (including thread-local destructors),
+/// though it is recommended not to use inside a fork handler.
+/// The handle cannot be passed between threads (is not `Send` or `Sync`).
+///
+/// `ThreadRng` uses the same PRNG as [`StdRng`] for security and performance
+/// and is automatically seeded from [`OsRng`].
+///
+/// Unlike `StdRng`, `ThreadRng` uses the  [`ReseedingRng`] wrapper to reseed
+/// the PRNG from fresh entropy every 64 kiB of random data as well as after a
+/// fork on Unix (though not quite immediately; see documentation of
+/// [`ReseedingRng`]).
+/// Note that the reseeding is done as an extra precaution against side-channel
+/// attacks and mis-use (e.g. if somehow weak entropy were supplied initially).
+/// The PRNG algorithms used are assumed to be secure.
+///
+/// [`ReseedingRng`]: crate::rngs::adapter::ReseedingRng
+/// [`StdRng`]: crate::rngs::StdRng
+#[cfg_attr(doc_cfg, doc(cfg(all(feature = "std", feature = "std_rng"))))]
+#[derive(Clone, Debug)]
+pub struct ThreadRng {
+    // Rc is explicitly !Send and !Sync
+    rng: Rc<UnsafeCell<ReseedingRng<Core, OsRng>>>,
+}
+
+thread_local!(
+    // We require Rc<..> to avoid premature freeing when thread_rng is used
+    // within thread-local destructors. See #968.
+    static THREAD_RNG_KEY: Rc<UnsafeCell<ReseedingRng<Core, OsRng>>> = {
+        let r = Core::from_rng(OsRng).unwrap_or_else(|err|
+                panic!("could not initialize thread_rng: {}", err));
+        let rng = ReseedingRng::new(r,
+                                    THREAD_RNG_RESEED_THRESHOLD,
+                                    OsRng);
+        Rc::new(UnsafeCell::new(rng))
+    }
+);
+
+/// Retrieve the lazily-initialized thread-local random number generator,
+/// seeded by the system. Intended to be used in method chaining style,
+/// e.g. `thread_rng().gen::<i32>()`, or cached locally, e.g.
+/// `let mut rng = thread_rng();`.  Invoked by the `Default` trait, making
+/// `ThreadRng::default()` equivalent.
+///
+/// For more information see [`ThreadRng`].
+#[cfg_attr(doc_cfg, doc(cfg(all(feature = "std", feature = "std_rng"))))]
+pub fn thread_rng() -> ThreadRng {
+    let rng = THREAD_RNG_KEY.with(|t| t.clone());
+    ThreadRng { rng }
+}
+
+impl Default for ThreadRng {
+    fn default() -> ThreadRng {
+        crate::prelude::thread_rng()
+    }
+}
+
+impl RngCore for ThreadRng {
+    #[inline(always)]
+    fn next_u32(&mut self) -> u32 {
+        // SAFETY: We must make sure to stop using `rng` before anyone else
+        // creates another mutable reference
+        let rng = unsafe { &mut *self.rng.get() };
+        rng.next_u32()
+    }
+
+    #[inline(always)]
+    fn next_u64(&mut self) -> u64 {
+        // SAFETY: We must make sure to stop using `rng` before anyone else
+        // creates another mutable reference
+        let rng = unsafe { &mut *self.rng.get() };
+        rng.next_u64()
+    }
+
+    fn fill_bytes(&mut self, dest: &mut [u8]) {
+        // SAFETY: We must make sure to stop using `rng` before anyone else
+        // creates another mutable reference
+        let rng = unsafe { &mut *self.rng.get() };
+        rng.fill_bytes(dest)
+    }
+
+    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
+        // SAFETY: We must make sure to stop using `rng` before anyone else
+        // creates another mutable reference
+        let rng = unsafe { &mut *self.rng.get() };
+        rng.try_fill_bytes(dest)
+    }
+}
+
+impl CryptoRng for ThreadRng {}
+
+
+#[cfg(test)]
+mod test {
+    #[test]
+    fn test_thread_rng() {
+        use crate::Rng;
+        let mut r = crate::thread_rng();
+        r.gen::<i32>();
+        assert_eq!(r.gen_range(0..1), 0);
+    }
+}
diff --git a/crates/rand/src/rngs/xoshiro128plusplus.rs b/crates/rand/src/rngs/xoshiro128plusplus.rs
new file mode 100644
index 0000000..ece98fa
--- /dev/null
+++ b/crates/rand/src/rngs/xoshiro128plusplus.rs
@@ -0,0 +1,118 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[cfg(feature="serde1")] use serde::{Serialize, Deserialize};
+use rand_core::impls::{next_u64_via_u32, fill_bytes_via_next};
+use rand_core::le::read_u32_into;
+use rand_core::{SeedableRng, RngCore, Error};
+
+/// A xoshiro128++ random number generator.
+///
+/// The xoshiro128++ algorithm is not suitable for cryptographic purposes, but
+/// is very fast and has excellent statistical properties.
+///
+/// The algorithm used here is translated from [the `xoshiro128plusplus.c`
+/// reference source code](http://xoshiro.di.unimi.it/xoshiro128plusplus.c) by
+/// David Blackman and Sebastiano Vigna.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature="serde1", derive(Serialize, Deserialize))]
+pub struct Xoshiro128PlusPlus {
+    s: [u32; 4],
+}
+
+impl SeedableRng for Xoshiro128PlusPlus {
+    type Seed = [u8; 16];
+
+    /// Create a new `Xoshiro128PlusPlus`.  If `seed` is entirely 0, it will be
+    /// mapped to a different seed.
+    #[inline]
+    fn from_seed(seed: [u8; 16]) -> Xoshiro128PlusPlus {
+        if seed.iter().all(|&x| x == 0) {
+            return Self::seed_from_u64(0);
+        }
+        let mut state = [0; 4];
+        read_u32_into(&seed, &mut state);
+        Xoshiro128PlusPlus { s: state }
+    }
+
+    /// Create a new `Xoshiro128PlusPlus` from a `u64` seed.
+    ///
+    /// This uses the SplitMix64 generator internally.
+    fn seed_from_u64(mut state: u64) -> Self {
+        const PHI: u64 = 0x9e3779b97f4a7c15;
+        let mut seed = Self::Seed::default();
+        for chunk in seed.as_mut().chunks_mut(8) {
+            state = state.wrapping_add(PHI);
+            let mut z = state;
+            z = (z ^ (z >> 30)).wrapping_mul(0xbf58476d1ce4e5b9);
+            z = (z ^ (z >> 27)).wrapping_mul(0x94d049bb133111eb);
+            z = z ^ (z >> 31);
+            chunk.copy_from_slice(&z.to_le_bytes());
+        }
+        Self::from_seed(seed)
+    }
+}
+
+impl RngCore for Xoshiro128PlusPlus {
+    #[inline]
+    fn next_u32(&mut self) -> u32 {
+        let result_starstar = self.s[0]
+            .wrapping_add(self.s[3])
+            .rotate_left(7)
+            .wrapping_add(self.s[0]);
+
+        let t = self.s[1] << 9;
+
+        self.s[2] ^= self.s[0];
+        self.s[3] ^= self.s[1];
+        self.s[1] ^= self.s[2];
+        self.s[0] ^= self.s[3];
+
+        self.s[2] ^= t;
+
+        self.s[3] = self.s[3].rotate_left(11);
+
+        result_starstar
+    }
+
+    #[inline]
+    fn next_u64(&mut self) -> u64 {
+        next_u64_via_u32(self)
+    }
+
+    #[inline]
+    fn fill_bytes(&mut self, dest: &mut [u8]) {
+        fill_bytes_via_next(self, dest);
+    }
+
+    #[inline]
+    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
+        self.fill_bytes(dest);
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn reference() {
+        let mut rng = Xoshiro128PlusPlus::from_seed(
+            [1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 4, 0, 0, 0]);
+        // These values were produced with the reference implementation:
+        // http://xoshiro.di.unimi.it/xoshiro128plusplus.c
+        let expected = [
+            641, 1573767, 3222811527, 3517856514, 836907274, 4247214768,
+            3867114732, 1355841295, 495546011, 621204420,
+        ];
+        for &e in &expected {
+            assert_eq!(rng.next_u32(), e);
+        }
+    }
+}
diff --git a/crates/rand/src/rngs/xoshiro256plusplus.rs b/crates/rand/src/rngs/xoshiro256plusplus.rs
new file mode 100644
index 0000000..8ffb18b
--- /dev/null
+++ b/crates/rand/src/rngs/xoshiro256plusplus.rs
@@ -0,0 +1,122 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[cfg(feature="serde1")] use serde::{Serialize, Deserialize};
+use rand_core::impls::fill_bytes_via_next;
+use rand_core::le::read_u64_into;
+use rand_core::{SeedableRng, RngCore, Error};
+
+/// A xoshiro256++ random number generator.
+///
+/// The xoshiro256++ algorithm is not suitable for cryptographic purposes, but
+/// is very fast and has excellent statistical properties.
+///
+/// The algorithm used here is translated from [the `xoshiro256plusplus.c`
+/// reference source code](http://xoshiro.di.unimi.it/xoshiro256plusplus.c) by
+/// David Blackman and Sebastiano Vigna.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature="serde1", derive(Serialize, Deserialize))]
+pub struct Xoshiro256PlusPlus {
+    s: [u64; 4],
+}
+
+impl SeedableRng for Xoshiro256PlusPlus {
+    type Seed = [u8; 32];
+
+    /// Create a new `Xoshiro256PlusPlus`.  If `seed` is entirely 0, it will be
+    /// mapped to a different seed.
+    #[inline]
+    fn from_seed(seed: [u8; 32]) -> Xoshiro256PlusPlus {
+        if seed.iter().all(|&x| x == 0) {
+            return Self::seed_from_u64(0);
+        }
+        let mut state = [0; 4];
+        read_u64_into(&seed, &mut state);
+        Xoshiro256PlusPlus { s: state }
+    }
+
+    /// Create a new `Xoshiro256PlusPlus` from a `u64` seed.
+    ///
+    /// This uses the SplitMix64 generator internally.
+    fn seed_from_u64(mut state: u64) -> Self {
+        const PHI: u64 = 0x9e3779b97f4a7c15;
+        let mut seed = Self::Seed::default();
+        for chunk in seed.as_mut().chunks_mut(8) {
+            state = state.wrapping_add(PHI);
+            let mut z = state;
+            z = (z ^ (z >> 30)).wrapping_mul(0xbf58476d1ce4e5b9);
+            z = (z ^ (z >> 27)).wrapping_mul(0x94d049bb133111eb);
+            z = z ^ (z >> 31);
+            chunk.copy_from_slice(&z.to_le_bytes());
+        }
+        Self::from_seed(seed)
+    }
+}
+
+impl RngCore for Xoshiro256PlusPlus {
+    #[inline]
+    fn next_u32(&mut self) -> u32 {
+        // The lowest bits have some linear dependencies, so we use the
+        // upper bits instead.
+        (self.next_u64() >> 32) as u32
+    }
+
+    #[inline]
+    fn next_u64(&mut self) -> u64 {
+        let result_plusplus = self.s[0]
+            .wrapping_add(self.s[3])
+            .rotate_left(23)
+            .wrapping_add(self.s[0]);
+
+        let t = self.s[1] << 17;
+
+        self.s[2] ^= self.s[0];
+        self.s[3] ^= self.s[1];
+        self.s[1] ^= self.s[2];
+        self.s[0] ^= self.s[3];
+
+        self.s[2] ^= t;
+
+        self.s[3] = self.s[3].rotate_left(45);
+
+        result_plusplus
+    }
+
+    #[inline]
+    fn fill_bytes(&mut self, dest: &mut [u8]) {
+        fill_bytes_via_next(self, dest);
+    }
+
+    #[inline]
+    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
+        self.fill_bytes(dest);
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn reference() {
+        let mut rng = Xoshiro256PlusPlus::from_seed(
+            [1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0,
+             3, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0]);
+        // These values were produced with the reference implementation:
+        // http://xoshiro.di.unimi.it/xoshiro256plusplus.c
+        let expected = [
+            41943041, 58720359, 3588806011781223, 3591011842654386,
+            9228616714210784205, 9973669472204895162, 14011001112246962877,
+            12406186145184390807, 15849039046786891736, 10450023813501588000,
+        ];
+        for &e in &expected {
+            assert_eq!(rng.next_u64(), e);
+        }
+    }
+}
diff --git a/crates/rand/src/seq/index.rs b/crates/rand/src/seq/index.rs
new file mode 100644
index 0000000..b38e464
--- /dev/null
+++ b/crates/rand/src/seq/index.rs
@@ -0,0 +1,678 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Low-level API for sampling indices
+
+#[cfg(feature = "alloc")] use core::slice;
+
+#[cfg(feature = "alloc")] use alloc::vec::{self, Vec};
+// BTreeMap is not as fast in tests, but better than nothing.
+#[cfg(all(feature = "alloc", not(feature = "std")))]
+use alloc::collections::BTreeSet;
+#[cfg(feature = "std")] use std::collections::HashSet;
+
+#[cfg(feature = "std")]
+use crate::distributions::WeightedError;
+
+#[cfg(feature = "alloc")]
+use crate::{Rng, distributions::{uniform::SampleUniform, Distribution, Uniform}};
+
+#[cfg(feature = "serde1")]
+use serde::{Serialize, Deserialize};
+
+/// A vector of indices.
+///
+/// Multiple internal representations are possible.
+#[derive(Clone, Debug)]
+#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
+pub enum IndexVec {
+    #[doc(hidden)]
+    U32(Vec<u32>),
+    #[doc(hidden)]
+    USize(Vec<usize>),
+}
+
+impl IndexVec {
+    /// Returns the number of indices
+    #[inline]
+    pub fn len(&self) -> usize {
+        match *self {
+            IndexVec::U32(ref v) => v.len(),
+            IndexVec::USize(ref v) => v.len(),
+        }
+    }
+
+    /// Returns `true` if the length is 0.
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        match *self {
+            IndexVec::U32(ref v) => v.is_empty(),
+            IndexVec::USize(ref v) => v.is_empty(),
+        }
+    }
+
+    /// Return the value at the given `index`.
+    ///
+    /// (Note: we cannot implement [`std::ops::Index`] because of lifetime
+    /// restrictions.)
+    #[inline]
+    pub fn index(&self, index: usize) -> usize {
+        match *self {
+            IndexVec::U32(ref v) => v[index] as usize,
+            IndexVec::USize(ref v) => v[index],
+        }
+    }
+
+    /// Return result as a `Vec<usize>`. Conversion may or may not be trivial.
+    #[inline]
+    pub fn into_vec(self) -> Vec<usize> {
+        match self {
+            IndexVec::U32(v) => v.into_iter().map(|i| i as usize).collect(),
+            IndexVec::USize(v) => v,
+        }
+    }
+
+    /// Iterate over the indices as a sequence of `usize` values
+    #[inline]
+    pub fn iter(&self) -> IndexVecIter<'_> {
+        match *self {
+            IndexVec::U32(ref v) => IndexVecIter::U32(v.iter()),
+            IndexVec::USize(ref v) => IndexVecIter::USize(v.iter()),
+        }
+    }
+}
+
+impl IntoIterator for IndexVec {
+    type Item = usize;
+    type IntoIter = IndexVecIntoIter;
+
+    /// Convert into an iterator over the indices as a sequence of `usize` values
+    #[inline]
+    fn into_iter(self) -> IndexVecIntoIter {
+        match self {
+            IndexVec::U32(v) => IndexVecIntoIter::U32(v.into_iter()),
+            IndexVec::USize(v) => IndexVecIntoIter::USize(v.into_iter()),
+        }
+    }
+}
+
+impl PartialEq for IndexVec {
+    fn eq(&self, other: &IndexVec) -> bool {
+        use self::IndexVec::*;
+        match (self, other) {
+            (&U32(ref v1), &U32(ref v2)) => v1 == v2,
+            (&USize(ref v1), &USize(ref v2)) => v1 == v2,
+            (&U32(ref v1), &USize(ref v2)) => {
+                (v1.len() == v2.len()) && (v1.iter().zip(v2.iter()).all(|(x, y)| *x as usize == *y))
+            }
+            (&USize(ref v1), &U32(ref v2)) => {
+                (v1.len() == v2.len()) && (v1.iter().zip(v2.iter()).all(|(x, y)| *x == *y as usize))
+            }
+        }
+    }
+}
+
+impl From<Vec<u32>> for IndexVec {
+    #[inline]
+    fn from(v: Vec<u32>) -> Self {
+        IndexVec::U32(v)
+    }
+}
+
+impl From<Vec<usize>> for IndexVec {
+    #[inline]
+    fn from(v: Vec<usize>) -> Self {
+        IndexVec::USize(v)
+    }
+}
+
+/// Return type of `IndexVec::iter`.
+#[derive(Debug)]
+pub enum IndexVecIter<'a> {
+    #[doc(hidden)]
+    U32(slice::Iter<'a, u32>),
+    #[doc(hidden)]
+    USize(slice::Iter<'a, usize>),
+}
+
+impl<'a> Iterator for IndexVecIter<'a> {
+    type Item = usize;
+
+    #[inline]
+    fn next(&mut self) -> Option<usize> {
+        use self::IndexVecIter::*;
+        match *self {
+            U32(ref mut iter) => iter.next().map(|i| *i as usize),
+            USize(ref mut iter) => iter.next().cloned(),
+        }
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        match *self {
+            IndexVecIter::U32(ref v) => v.size_hint(),
+            IndexVecIter::USize(ref v) => v.size_hint(),
+        }
+    }
+}
+
+impl<'a> ExactSizeIterator for IndexVecIter<'a> {}
+
+/// Return type of `IndexVec::into_iter`.
+#[derive(Clone, Debug)]
+pub enum IndexVecIntoIter {
+    #[doc(hidden)]
+    U32(vec::IntoIter<u32>),
+    #[doc(hidden)]
+    USize(vec::IntoIter<usize>),
+}
+
+impl Iterator for IndexVecIntoIter {
+    type Item = usize;
+
+    #[inline]
+    fn next(&mut self) -> Option<Self::Item> {
+        use self::IndexVecIntoIter::*;
+        match *self {
+            U32(ref mut v) => v.next().map(|i| i as usize),
+            USize(ref mut v) => v.next(),
+        }
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        use self::IndexVecIntoIter::*;
+        match *self {
+            U32(ref v) => v.size_hint(),
+            USize(ref v) => v.size_hint(),
+        }
+    }
+}
+
+impl ExactSizeIterator for IndexVecIntoIter {}
+
+
+/// Randomly sample exactly `amount` distinct indices from `0..length`, and
+/// return them in random order (fully shuffled).
+///
+/// This method is used internally by the slice sampling methods, but it can
+/// sometimes be useful to have the indices themselves so this is provided as
+/// an alternative.
+///
+/// The implementation used is not specified; we automatically select the
+/// fastest available algorithm for the `length` and `amount` parameters
+/// (based on detailed profiling on an Intel Haswell CPU). Roughly speaking,
+/// complexity is `O(amount)`, except that when `amount` is small, performance
+/// is closer to `O(amount^2)`, and when `length` is close to `amount` then
+/// `O(length)`.
+///
+/// Note that performance is significantly better over `u32` indices than over
+/// `u64` indices. Because of this we hide the underlying type behind an
+/// abstraction, `IndexVec`.
+///
+/// If an allocation-free `no_std` function is required, it is suggested
+/// to adapt the internal `sample_floyd` implementation.
+///
+/// Panics if `amount > length`.
+pub fn sample<R>(rng: &mut R, length: usize, amount: usize) -> IndexVec
+where R: Rng + ?Sized {
+    if amount > length {
+        panic!("`amount` of samples must be less than or equal to `length`");
+    }
+    if length > (::core::u32::MAX as usize) {
+        // We never want to use inplace here, but could use floyd's alg
+        // Lazy version: always use the cache alg.
+        return sample_rejection(rng, length, amount);
+    }
+    let amount = amount as u32;
+    let length = length as u32;
+
+    // Choice of algorithm here depends on both length and amount. See:
+    // https://github.com/rust-random/rand/pull/479
+    // We do some calculations with f32. Accuracy is not very important.
+
+    if amount < 163 {
+        const C: [[f32; 2]; 2] = [[1.6, 8.0 / 45.0], [10.0, 70.0 / 9.0]];
+        let j = if length < 500_000 { 0 } else { 1 };
+        let amount_fp = amount as f32;
+        let m4 = C[0][j] * amount_fp;
+        // Short-cut: when amount < 12, floyd's is always faster
+        if amount > 11 && (length as f32) < (C[1][j] + m4) * amount_fp {
+            sample_inplace(rng, length, amount)
+        } else {
+            sample_floyd(rng, length, amount)
+        }
+    } else {
+        const C: [f32; 2] = [270.0, 330.0 / 9.0];
+        let j = if length < 500_000 { 0 } else { 1 };
+        if (length as f32) < C[j] * (amount as f32) {
+            sample_inplace(rng, length, amount)
+        } else {
+            sample_rejection(rng, length, amount)
+        }
+    }
+}
+
+/// Randomly sample exactly `amount` distinct indices from `0..length`, and
+/// return them in an arbitrary order (there is no guarantee of shuffling or
+/// ordering). The weights are to be provided by the input function `weights`,
+/// which will be called once for each index.
+///
+/// This method is used internally by the slice sampling methods, but it can
+/// sometimes be useful to have the indices themselves so this is provided as
+/// an alternative.
+///
+/// This implementation uses `O(length + amount)` space and `O(length)` time
+/// if the "nightly" feature is enabled, or `O(length)` space and
+/// `O(length + amount * log length)` time otherwise.
+///
+/// Panics if `amount > length`.
+#[cfg(feature = "std")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
+pub fn sample_weighted<R, F, X>(
+    rng: &mut R, length: usize, weight: F, amount: usize,
+) -> Result<IndexVec, WeightedError>
+where
+    R: Rng + ?Sized,
+    F: Fn(usize) -> X,
+    X: Into<f64>,
+{
+    if length > (core::u32::MAX as usize) {
+        sample_efraimidis_spirakis(rng, length, weight, amount)
+    } else {
+        assert!(amount <= core::u32::MAX as usize);
+        let amount = amount as u32;
+        let length = length as u32;
+        sample_efraimidis_spirakis(rng, length, weight, amount)
+    }
+}
+
+
+/// Randomly sample exactly `amount` distinct indices from `0..length`, and
+/// return them in an arbitrary order (there is no guarantee of shuffling or
+/// ordering). The weights are to be provided by the input function `weights`,
+/// which will be called once for each index.
+///
+/// This implementation uses the algorithm described by Efraimidis and Spirakis
+/// in this paper: https://doi.org/10.1016/j.ipl.2005.11.003
+/// It uses `O(length + amount)` space and `O(length)` time if the
+/// "nightly" feature is enabled, or `O(length)` space and `O(length
+/// + amount * log length)` time otherwise.
+///
+/// Panics if `amount > length`.
+#[cfg(feature = "std")]
+fn sample_efraimidis_spirakis<R, F, X, N>(
+    rng: &mut R, length: N, weight: F, amount: N,
+) -> Result<IndexVec, WeightedError>
+where
+    R: Rng + ?Sized,
+    F: Fn(usize) -> X,
+    X: Into<f64>,
+    N: UInt,
+    IndexVec: From<Vec<N>>,
+{
+    if amount == N::zero() {
+        return Ok(IndexVec::U32(Vec::new()));
+    }
+
+    if amount > length {
+        panic!("`amount` of samples must be less than or equal to `length`");
+    }
+
+    struct Element<N> {
+        index: N,
+        key: f64,
+    }
+    impl<N> PartialOrd for Element<N> {
+        fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
+            self.key.partial_cmp(&other.key)
+        }
+    }
+    impl<N> Ord for Element<N> {
+        fn cmp(&self, other: &Self) -> core::cmp::Ordering {
+             // partial_cmp will always produce a value,
+             // because we check that the weights are not nan
+            self.partial_cmp(other).unwrap()
+        }
+    }
+    impl<N> PartialEq for Element<N> {
+        fn eq(&self, other: &Self) -> bool {
+            self.key == other.key
+        }
+    }
+    impl<N> Eq for Element<N> {}
+
+    #[cfg(feature = "nightly")]
+    {
+        let mut candidates = Vec::with_capacity(length.as_usize());
+        let mut index = N::zero();
+        while index < length {
+            let weight = weight(index.as_usize()).into();
+            if !(weight >= 0.) {
+                return Err(WeightedError::InvalidWeight);
+            }
+
+            let key = rng.gen::<f64>().powf(1.0 / weight);
+            candidates.push(Element { index, key });
+
+            index += N::one();
+        }
+
+        // Partially sort the array to find the `amount` elements with the greatest
+        // keys. Do this by using `select_nth_unstable` to put the elements with
+        // the *smallest* keys at the beginning of the list in `O(n)` time, which
+        // provides equivalent information about the elements with the *greatest* keys.
+        let (_, mid, greater)
+            = candidates.select_nth_unstable(length.as_usize() - amount.as_usize());
+
+        let mut result: Vec<N> = Vec::with_capacity(amount.as_usize());
+        result.push(mid.index);
+        for element in greater {
+            result.push(element.index);
+        }
+        Ok(IndexVec::from(result))
+    }
+
+    #[cfg(not(feature = "nightly"))]
+    {
+        use alloc::collections::BinaryHeap;
+
+        // Partially sort the array such that the `amount` elements with the largest
+        // keys are first using a binary max heap.
+        let mut candidates = BinaryHeap::with_capacity(length.as_usize());
+        let mut index = N::zero();
+        while index < length {
+            let weight = weight(index.as_usize()).into();
+            if !(weight >= 0.) {
+                return Err(WeightedError::InvalidWeight);
+            }
+
+            let key = rng.gen::<f64>().powf(1.0 / weight);
+            candidates.push(Element { index, key });
+
+            index += N::one();
+        }
+
+        let mut result: Vec<N> = Vec::with_capacity(amount.as_usize());
+        while result.len() < amount.as_usize() {
+            result.push(candidates.pop().unwrap().index);
+        }
+        Ok(IndexVec::from(result))
+    }
+}
+
+/// Randomly sample exactly `amount` indices from `0..length`, using Floyd's
+/// combination algorithm.
+///
+/// The output values are fully shuffled. (Overhead is under 50%.)
+///
+/// This implementation uses `O(amount)` memory and `O(amount^2)` time.
+fn sample_floyd<R>(rng: &mut R, length: u32, amount: u32) -> IndexVec
+where R: Rng + ?Sized {
+    // For small amount we use Floyd's fully-shuffled variant. For larger
+    // amounts this is slow due to Vec::insert performance, so we shuffle
+    // afterwards. Benchmarks show little overhead from extra logic.
+    let floyd_shuffle = amount < 50;
+
+    debug_assert!(amount <= length);
+    let mut indices = Vec::with_capacity(amount as usize);
+    for j in length - amount..length {
+        let t = rng.gen_range(0..=j);
+        if floyd_shuffle {
+            if let Some(pos) = indices.iter().position(|&x| x == t) {
+                indices.insert(pos, j);
+                continue;
+            }
+        } else if indices.contains(&t) {
+            indices.push(j);
+            continue;
+        }
+        indices.push(t);
+    }
+    if !floyd_shuffle {
+        // Reimplement SliceRandom::shuffle with smaller indices
+        for i in (1..amount).rev() {
+            // invariant: elements with index > i have been locked in place.
+            indices.swap(i as usize, rng.gen_range(0..=i) as usize);
+        }
+    }
+    IndexVec::from(indices)
+}
+
+/// Randomly sample exactly `amount` indices from `0..length`, using an inplace
+/// partial Fisher-Yates method.
+/// Sample an amount of indices using an inplace partial fisher yates method.
+///
+/// This allocates the entire `length` of indices and randomizes only the first `amount`.
+/// It then truncates to `amount` and returns.
+///
+/// This method is not appropriate for large `length` and potentially uses a lot
+/// of memory; because of this we only implement for `u32` index (which improves
+/// performance in all cases).
+///
+/// Set-up is `O(length)` time and memory and shuffling is `O(amount)` time.
+fn sample_inplace<R>(rng: &mut R, length: u32, amount: u32) -> IndexVec
+where R: Rng + ?Sized {
+    debug_assert!(amount <= length);
+    let mut indices: Vec<u32> = Vec::with_capacity(length as usize);
+    indices.extend(0..length);
+    for i in 0..amount {
+        let j: u32 = rng.gen_range(i..length);
+        indices.swap(i as usize, j as usize);
+    }
+    indices.truncate(amount as usize);
+    debug_assert_eq!(indices.len(), amount as usize);
+    IndexVec::from(indices)
+}
+
+trait UInt: Copy + PartialOrd + Ord + PartialEq + Eq + SampleUniform
+    + core::hash::Hash + core::ops::AddAssign {
+    fn zero() -> Self;
+    fn one() -> Self;
+    fn as_usize(self) -> usize;
+}
+impl UInt for u32 {
+    #[inline]
+    fn zero() -> Self {
+        0
+    }
+
+    #[inline]
+    fn one() -> Self {
+        1
+    }
+
+    #[inline]
+    fn as_usize(self) -> usize {
+        self as usize
+    }
+}
+impl UInt for usize {
+    #[inline]
+    fn zero() -> Self {
+        0
+    }
+
+    #[inline]
+    fn one() -> Self {
+        1
+    }
+
+    #[inline]
+    fn as_usize(self) -> usize {
+        self
+    }
+}
+
+/// Randomly sample exactly `amount` indices from `0..length`, using rejection
+/// sampling.
+///
+/// Since `amount <<< length` there is a low chance of a random sample in
+/// `0..length` being a duplicate. We test for duplicates and resample where
+/// necessary. The algorithm is `O(amount)` time and memory.
+///
+/// This function  is generic over X primarily so that results are value-stable
+/// over 32-bit and 64-bit platforms.
+fn sample_rejection<X: UInt, R>(rng: &mut R, length: X, amount: X) -> IndexVec
+where
+    R: Rng + ?Sized,
+    IndexVec: From<Vec<X>>,
+{
+    debug_assert!(amount < length);
+    #[cfg(feature = "std")]
+    let mut cache = HashSet::with_capacity(amount.as_usize());
+    #[cfg(not(feature = "std"))]
+    let mut cache = BTreeSet::new();
+    let distr = Uniform::new(X::zero(), length);
+    let mut indices = Vec::with_capacity(amount.as_usize());
+    for _ in 0..amount.as_usize() {
+        let mut pos = distr.sample(rng);
+        while !cache.insert(pos) {
+            pos = distr.sample(rng);
+        }
+        indices.push(pos);
+    }
+
+    debug_assert_eq!(indices.len(), amount.as_usize());
+    IndexVec::from(indices)
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    #[cfg(feature = "serde1")]
+    fn test_serialization_index_vec() {
+        let some_index_vec = IndexVec::from(vec![254_usize, 234, 2, 1]);
+        let de_some_index_vec: IndexVec = bincode::deserialize(&bincode::serialize(&some_index_vec).unwrap()).unwrap();
+        match (some_index_vec, de_some_index_vec) {
+            (IndexVec::U32(a), IndexVec::U32(b)) => {
+                assert_eq!(a, b);
+            },
+            (IndexVec::USize(a), IndexVec::USize(b)) => {
+                assert_eq!(a, b);
+            },
+            _ => {panic!("failed to seralize/deserialize `IndexVec`")}
+        }
+    }
+
+    #[cfg(feature = "alloc")] use alloc::vec;
+
+    #[test]
+    fn test_sample_boundaries() {
+        let mut r = crate::test::rng(404);
+
+        assert_eq!(sample_inplace(&mut r, 0, 0).len(), 0);
+        assert_eq!(sample_inplace(&mut r, 1, 0).len(), 0);
+        assert_eq!(sample_inplace(&mut r, 1, 1).into_vec(), vec![0]);
+
+        assert_eq!(sample_rejection(&mut r, 1u32, 0).len(), 0);
+
+        assert_eq!(sample_floyd(&mut r, 0, 0).len(), 0);
+        assert_eq!(sample_floyd(&mut r, 1, 0).len(), 0);
+        assert_eq!(sample_floyd(&mut r, 1, 1).into_vec(), vec![0]);
+
+        // These algorithms should be fast with big numbers. Test average.
+        let sum: usize = sample_rejection(&mut r, 1 << 25, 10u32).into_iter().sum();
+        assert!(1 << 25 < sum && sum < (1 << 25) * 25);
+
+        let sum: usize = sample_floyd(&mut r, 1 << 25, 10).into_iter().sum();
+        assert!(1 << 25 < sum && sum < (1 << 25) * 25);
+    }
+
+    #[test]
+    #[cfg_attr(miri, ignore)] // Miri is too slow
+    fn test_sample_alg() {
+        let seed_rng = crate::test::rng;
+
+        // We can't test which algorithm is used directly, but Floyd's alg
+        // should produce different results from the others. (Also, `inplace`
+        // and `cached` currently use different sizes thus produce different results.)
+
+        // A small length and relatively large amount should use inplace
+        let (length, amount): (usize, usize) = (100, 50);
+        let v1 = sample(&mut seed_rng(420), length, amount);
+        let v2 = sample_inplace(&mut seed_rng(420), length as u32, amount as u32);
+        assert!(v1.iter().all(|e| e < length));
+        assert_eq!(v1, v2);
+
+        // Test Floyd's alg does produce different results
+        let v3 = sample_floyd(&mut seed_rng(420), length as u32, amount as u32);
+        assert!(v1 != v3);
+
+        // A large length and small amount should use Floyd
+        let (length, amount): (usize, usize) = (1 << 20, 50);
+        let v1 = sample(&mut seed_rng(421), length, amount);
+        let v2 = sample_floyd(&mut seed_rng(421), length as u32, amount as u32);
+        assert!(v1.iter().all(|e| e < length));
+        assert_eq!(v1, v2);
+
+        // A large length and larger amount should use cache
+        let (length, amount): (usize, usize) = (1 << 20, 600);
+        let v1 = sample(&mut seed_rng(422), length, amount);
+        let v2 = sample_rejection(&mut seed_rng(422), length as u32, amount as u32);
+        assert!(v1.iter().all(|e| e < length));
+        assert_eq!(v1, v2);
+    }
+
+    #[cfg(feature = "std")]
+    #[test]
+    fn test_sample_weighted() {
+        let seed_rng = crate::test::rng;
+        for &(amount, len) in &[(0, 10), (5, 10), (10, 10)] {
+            let v = sample_weighted(&mut seed_rng(423), len, |i| i as f64, amount).unwrap();
+            match v {
+                IndexVec::U32(mut indices) => {
+                    assert_eq!(indices.len(), amount);
+                    indices.sort_unstable();
+                    indices.dedup();
+                    assert_eq!(indices.len(), amount);
+                    for &i in &indices {
+                        assert!((i as usize) < len);
+                    }
+                },
+                IndexVec::USize(_) => panic!("expected `IndexVec::U32`"),
+            }
+        }
+    }
+
+    #[test]
+    fn value_stability_sample() {
+        let do_test = |length, amount, values: &[u32]| {
+            let mut buf = [0u32; 8];
+            let mut rng = crate::test::rng(410);
+
+            let res = sample(&mut rng, length, amount);
+            let len = res.len().min(buf.len());
+            for (x, y) in res.into_iter().zip(buf.iter_mut()) {
+                *y = x as u32;
+            }
+            assert_eq!(
+                &buf[0..len],
+                values,
+                "failed sampling {}, {}",
+                length,
+                amount
+            );
+        };
+
+        do_test(10, 6, &[8, 0, 3, 5, 9, 6]); // floyd
+        do_test(25, 10, &[18, 15, 14, 9, 0, 13, 5, 24]); // floyd
+        do_test(300, 8, &[30, 283, 150, 1, 73, 13, 285, 35]); // floyd
+        do_test(300, 80, &[31, 289, 248, 154, 5, 78, 19, 286]); // inplace
+        do_test(300, 180, &[31, 289, 248, 154, 5, 78, 19, 286]); // inplace
+
+        do_test(1_000_000, 8, &[
+            103717, 963485, 826422, 509101, 736394, 807035, 5327, 632573,
+        ]); // floyd
+        do_test(1_000_000, 180, &[
+            103718, 963490, 826426, 509103, 736396, 807036, 5327, 632573,
+        ]); // rejection
+    }
+}
diff --git a/crates/rand/src/seq/mod.rs b/crates/rand/src/seq/mod.rs
new file mode 100644
index 0000000..069e9e6
--- /dev/null
+++ b/crates/rand/src/seq/mod.rs
@@ -0,0 +1,1356 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Sequence-related functionality
+//!
+//! This module provides:
+//!
+//! *   [`SliceRandom`] slice sampling and mutation
+//! *   [`IteratorRandom`] iterator sampling
+//! *   [`index::sample`] low-level API to choose multiple indices from
+//!     `0..length`
+//!
+//! Also see:
+//!
+//! *   [`crate::distributions::WeightedIndex`] distribution which provides
+//!     weighted index sampling.
+//!
+//! In order to make results reproducible across 32-64 bit architectures, all
+//! `usize` indices are sampled as a `u32` where possible (also providing a
+//! small performance boost in some cases).
+
+
+#[cfg(feature = "alloc")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
+pub mod index;
+
+#[cfg(feature = "alloc")] use core::ops::Index;
+
+#[cfg(feature = "alloc")] use alloc::vec::Vec;
+
+#[cfg(feature = "alloc")]
+use crate::distributions::uniform::{SampleBorrow, SampleUniform};
+#[cfg(feature = "alloc")] use crate::distributions::WeightedError;
+use crate::Rng;
+
+/// Extension trait on slices, providing random mutation and sampling methods.
+///
+/// This trait is implemented on all `[T]` slice types, providing several
+/// methods for choosing and shuffling elements. You must `use` this trait:
+///
+/// ```
+/// use rand::seq::SliceRandom;
+///
+/// let mut rng = rand::thread_rng();
+/// let mut bytes = "Hello, random!".to_string().into_bytes();
+/// bytes.shuffle(&mut rng);
+/// let str = String::from_utf8(bytes).unwrap();
+/// println!("{}", str);
+/// ```
+/// Example output (non-deterministic):
+/// ```none
+/// l,nmroHado !le
+/// ```
+pub trait SliceRandom {
+    /// The element type.
+    type Item;
+
+    /// Returns a reference to one random element of the slice, or `None` if the
+    /// slice is empty.
+    ///
+    /// For slices, complexity is `O(1)`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use rand::thread_rng;
+    /// use rand::seq::SliceRandom;
+    ///
+    /// let choices = [1, 2, 4, 8, 16, 32];
+    /// let mut rng = thread_rng();
+    /// println!("{:?}", choices.choose(&mut rng));
+    /// assert_eq!(choices[..0].choose(&mut rng), None);
+    /// ```
+    fn choose<R>(&self, rng: &mut R) -> Option<&Self::Item>
+    where R: Rng + ?Sized;
+
+    /// Returns a mutable reference to one random element of the slice, or
+    /// `None` if the slice is empty.
+    ///
+    /// For slices, complexity is `O(1)`.
+    fn choose_mut<R>(&mut self, rng: &mut R) -> Option<&mut Self::Item>
+    where R: Rng + ?Sized;
+
+    /// Chooses `amount` elements from the slice at random, without repetition,
+    /// and in random order. The returned iterator is appropriate both for
+    /// collection into a `Vec` and filling an existing buffer (see example).
+    ///
+    /// In case this API is not sufficiently flexible, use [`index::sample`].
+    ///
+    /// For slices, complexity is the same as [`index::sample`].
+    ///
+    /// # Example
+    /// ```
+    /// use rand::seq::SliceRandom;
+    ///
+    /// let mut rng = &mut rand::thread_rng();
+    /// let sample = "Hello, audience!".as_bytes();
+    ///
+    /// // collect the results into a vector:
+    /// let v: Vec<u8> = sample.choose_multiple(&mut rng, 3).cloned().collect();
+    ///
+    /// // store in a buffer:
+    /// let mut buf = [0u8; 5];
+    /// for (b, slot) in sample.choose_multiple(&mut rng, buf.len()).zip(buf.iter_mut()) {
+    ///     *slot = *b;
+    /// }
+    /// ```
+    #[cfg(feature = "alloc")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
+    fn choose_multiple<R>(&self, rng: &mut R, amount: usize) -> SliceChooseIter<Self, Self::Item>
+    where R: Rng + ?Sized;
+
+    /// Similar to [`choose`], but where the likelihood of each outcome may be
+    /// specified.
+    ///
+    /// The specified function `weight` maps each item `x` to a relative
+    /// likelihood `weight(x)`. The probability of each item being selected is
+    /// therefore `weight(x) / s`, where `s` is the sum of all `weight(x)`.
+    ///
+    /// For slices of length `n`, complexity is `O(n)`.
+    /// See also [`choose_weighted_mut`], [`distributions::weighted`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use rand::prelude::*;
+    ///
+    /// let choices = [('a', 2), ('b', 1), ('c', 1)];
+    /// let mut rng = thread_rng();
+    /// // 50% chance to print 'a', 25% chance to print 'b', 25% chance to print 'c'
+    /// println!("{:?}", choices.choose_weighted(&mut rng, |item| item.1).unwrap().0);
+    /// ```
+    /// [`choose`]: SliceRandom::choose
+    /// [`choose_weighted_mut`]: SliceRandom::choose_weighted_mut
+    /// [`distributions::weighted`]: crate::distributions::weighted
+    #[cfg(feature = "alloc")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
+    fn choose_weighted<R, F, B, X>(
+        &self, rng: &mut R, weight: F,
+    ) -> Result<&Self::Item, WeightedError>
+    where
+        R: Rng + ?Sized,
+        F: Fn(&Self::Item) -> B,
+        B: SampleBorrow<X>,
+        X: SampleUniform
+            + for<'a> ::core::ops::AddAssign<&'a X>
+            + ::core::cmp::PartialOrd<X>
+            + Clone
+            + Default;
+
+    /// Similar to [`choose_mut`], but where the likelihood of each outcome may
+    /// be specified.
+    ///
+    /// The specified function `weight` maps each item `x` to a relative
+    /// likelihood `weight(x)`. The probability of each item being selected is
+    /// therefore `weight(x) / s`, where `s` is the sum of all `weight(x)`.
+    ///
+    /// For slices of length `n`, complexity is `O(n)`.
+    /// See also [`choose_weighted`], [`distributions::weighted`].
+    ///
+    /// [`choose_mut`]: SliceRandom::choose_mut
+    /// [`choose_weighted`]: SliceRandom::choose_weighted
+    /// [`distributions::weighted`]: crate::distributions::weighted
+    #[cfg(feature = "alloc")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
+    fn choose_weighted_mut<R, F, B, X>(
+        &mut self, rng: &mut R, weight: F,
+    ) -> Result<&mut Self::Item, WeightedError>
+    where
+        R: Rng + ?Sized,
+        F: Fn(&Self::Item) -> B,
+        B: SampleBorrow<X>,
+        X: SampleUniform
+            + for<'a> ::core::ops::AddAssign<&'a X>
+            + ::core::cmp::PartialOrd<X>
+            + Clone
+            + Default;
+
+    /// Similar to [`choose_multiple`], but where the likelihood of each element's
+    /// inclusion in the output may be specified. The elements are returned in an
+    /// arbitrary, unspecified order.
+    ///
+    /// The specified function `weight` maps each item `x` to a relative
+    /// likelihood `weight(x)`. The probability of each item being selected is
+    /// therefore `weight(x) / s`, where `s` is the sum of all `weight(x)`.
+    ///
+    /// If all of the weights are equal, even if they are all zero, each element has
+    /// an equal likelihood of being selected.
+    ///
+    /// The complexity of this method depends on the feature `partition_at_index`.
+    /// If the feature is enabled, then for slices of length `n`, the complexity
+    /// is `O(n)` space and `O(n)` time. Otherwise, the complexity is `O(n)` space and
+    /// `O(n * log amount)` time.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use rand::prelude::*;
+    ///
+    /// let choices = [('a', 2), ('b', 1), ('c', 1)];
+    /// let mut rng = thread_rng();
+    /// // First Draw * Second Draw = total odds
+    /// // -----------------------
+    /// // (50% * 50%) + (25% * 67%) = 41.7% chance that the output is `['a', 'b']` in some order.
+    /// // (50% * 50%) + (25% * 67%) = 41.7% chance that the output is `['a', 'c']` in some order.
+    /// // (25% * 33%) + (25% * 33%) = 16.6% chance that the output is `['b', 'c']` in some order.
+    /// println!("{:?}", choices.choose_multiple_weighted(&mut rng, 2, |item| item.1).unwrap().collect::<Vec<_>>());
+    /// ```
+    /// [`choose_multiple`]: SliceRandom::choose_multiple
+    //
+    // Note: this is feature-gated on std due to usage of f64::powf.
+    // If necessary, we may use alloc+libm as an alternative (see PR #1089).
+    #[cfg(feature = "std")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
+    fn choose_multiple_weighted<R, F, X>(
+        &self, rng: &mut R, amount: usize, weight: F,
+    ) -> Result<SliceChooseIter<Self, Self::Item>, WeightedError>
+    where
+        R: Rng + ?Sized,
+        F: Fn(&Self::Item) -> X,
+        X: Into<f64>;
+
+    /// Shuffle a mutable slice in place.
+    ///
+    /// For slices of length `n`, complexity is `O(n)`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use rand::seq::SliceRandom;
+    /// use rand::thread_rng;
+    ///
+    /// let mut rng = thread_rng();
+    /// let mut y = [1, 2, 3, 4, 5];
+    /// println!("Unshuffled: {:?}", y);
+    /// y.shuffle(&mut rng);
+    /// println!("Shuffled:   {:?}", y);
+    /// ```
+    fn shuffle<R>(&mut self, rng: &mut R)
+    where R: Rng + ?Sized;
+
+    /// Shuffle a slice in place, but exit early.
+    ///
+    /// Returns two mutable slices from the source slice. The first contains
+    /// `amount` elements randomly permuted. The second has the remaining
+    /// elements that are not fully shuffled.
+    ///
+    /// This is an efficient method to select `amount` elements at random from
+    /// the slice, provided the slice may be mutated.
+    ///
+    /// If you only need to choose elements randomly and `amount > self.len()/2`
+    /// then you may improve performance by taking
+    /// `amount = values.len() - amount` and using only the second slice.
+    ///
+    /// If `amount` is greater than the number of elements in the slice, this
+    /// will perform a full shuffle.
+    ///
+    /// For slices, complexity is `O(m)` where `m = amount`.
+    fn partial_shuffle<R>(
+        &mut self, rng: &mut R, amount: usize,
+    ) -> (&mut [Self::Item], &mut [Self::Item])
+    where R: Rng + ?Sized;
+}
+
+/// Extension trait on iterators, providing random sampling methods.
+///
+/// This trait is implemented on all iterators `I` where `I: Iterator + Sized`
+/// and provides methods for
+/// choosing one or more elements. You must `use` this trait:
+///
+/// ```
+/// use rand::seq::IteratorRandom;
+///
+/// let mut rng = rand::thread_rng();
+///
+/// let faces = "😀😎😐😕😠😢";
+/// println!("I am {}!", faces.chars().choose(&mut rng).unwrap());
+/// ```
+/// Example output (non-deterministic):
+/// ```none
+/// I am 😀!
+/// ```
+pub trait IteratorRandom: Iterator + Sized {
+    /// Choose one element at random from the iterator.
+    ///
+    /// Returns `None` if and only if the iterator is empty.
+    ///
+    /// This method uses [`Iterator::size_hint`] for optimisation. With an
+    /// accurate hint and where [`Iterator::nth`] is a constant-time operation
+    /// this method can offer `O(1)` performance. Where no size hint is
+    /// available, complexity is `O(n)` where `n` is the iterator length.
+    /// Partial hints (where `lower > 0`) also improve performance.
+    ///
+    /// Note that the output values and the number of RNG samples used
+    /// depends on size hints. In particular, `Iterator` combinators that don't
+    /// change the values yielded but change the size hints may result in
+    /// `choose` returning different elements. If you want consistent results
+    /// and RNG usage consider using [`IteratorRandom::choose_stable`].
+    fn choose<R>(mut self, rng: &mut R) -> Option<Self::Item>
+    where R: Rng + ?Sized {
+        let (mut lower, mut upper) = self.size_hint();
+        let mut consumed = 0;
+        let mut result = None;
+
+        // Handling for this condition outside the loop allows the optimizer to eliminate the loop
+        // when the Iterator is an ExactSizeIterator. This has a large performance impact on e.g.
+        // seq_iter_choose_from_1000.
+        if upper == Some(lower) {
+            return if lower == 0 {
+                None
+            } else {
+                self.nth(gen_index(rng, lower))
+            };
+        }
+
+        // Continue until the iterator is exhausted
+        loop {
+            if lower > 1 {
+                let ix = gen_index(rng, lower + consumed);
+                let skip = if ix < lower {
+                    result = self.nth(ix);
+                    lower - (ix + 1)
+                } else {
+                    lower
+                };
+                if upper == Some(lower) {
+                    return result;
+                }
+                consumed += lower;
+                if skip > 0 {
+                    self.nth(skip - 1);
+                }
+            } else {
+                let elem = self.next();
+                if elem.is_none() {
+                    return result;
+                }
+                consumed += 1;
+                if gen_index(rng, consumed) == 0 {
+                    result = elem;
+                }
+            }
+
+            let hint = self.size_hint();
+            lower = hint.0;
+            upper = hint.1;
+        }
+    }
+
+    /// Choose one element at random from the iterator.
+    ///
+    /// Returns `None` if and only if the iterator is empty.
+    ///
+    /// This method is very similar to [`choose`] except that the result
+    /// only depends on the length of the iterator and the values produced by
+    /// `rng`. Notably for any iterator of a given length this will make the
+    /// same requests to `rng` and if the same sequence of values are produced
+    /// the same index will be selected from `self`. This may be useful if you
+    /// need consistent results no matter what type of iterator you are working
+    /// with. If you do not need this stability prefer [`choose`].
+    ///
+    /// Note that this method still uses [`Iterator::size_hint`] to skip
+    /// constructing elements where possible, however the selection and `rng`
+    /// calls are the same in the face of this optimization. If you want to
+    /// force every element to be created regardless call `.inspect(|e| ())`.
+    ///
+    /// [`choose`]: IteratorRandom::choose
+    fn choose_stable<R>(mut self, rng: &mut R) -> Option<Self::Item>
+    where R: Rng + ?Sized {
+        let mut consumed = 0;
+        let mut result = None;
+
+        loop {
+            // Currently the only way to skip elements is `nth()`. So we need to
+            // store what index to access next here.
+            // This should be replaced by `advance_by()` once it is stable:
+            // https://github.com/rust-lang/rust/issues/77404
+            let mut next = 0;
+
+            let (lower, _) = self.size_hint();
+            if lower >= 2 {
+                let highest_selected = (0..lower)
+                    .filter(|ix| gen_index(rng, consumed+ix+1) == 0)
+                    .last();
+
+                consumed += lower;
+                next = lower;
+
+                if let Some(ix) = highest_selected {
+                    result = self.nth(ix);
+                    next -= ix + 1;
+                    debug_assert!(result.is_some(), "iterator shorter than size_hint().0");
+                }
+            }
+
+            let elem = self.nth(next);
+            if elem.is_none() {
+                return result
+            }
+
+            if gen_index(rng, consumed+1) == 0 {
+                result = elem;
+            }
+            consumed += 1;
+        }
+    }
+
+    /// Collects values at random from the iterator into a supplied buffer
+    /// until that buffer is filled.
+    ///
+    /// Although the elements are selected randomly, the order of elements in
+    /// the buffer is neither stable nor fully random. If random ordering is
+    /// desired, shuffle the result.
+    ///
+    /// Returns the number of elements added to the buffer. This equals the length
+    /// of the buffer unless the iterator contains insufficient elements, in which
+    /// case this equals the number of elements available.
+    ///
+    /// Complexity is `O(n)` where `n` is the length of the iterator.
+    /// For slices, prefer [`SliceRandom::choose_multiple`].
+    fn choose_multiple_fill<R>(mut self, rng: &mut R, buf: &mut [Self::Item]) -> usize
+    where R: Rng + ?Sized {
+        let amount = buf.len();
+        let mut len = 0;
+        while len < amount {
+            if let Some(elem) = self.next() {
+                buf[len] = elem;
+                len += 1;
+            } else {
+                // Iterator exhausted; stop early
+                return len;
+            }
+        }
+
+        // Continue, since the iterator was not exhausted
+        for (i, elem) in self.enumerate() {
+            let k = gen_index(rng, i + 1 + amount);
+            if let Some(slot) = buf.get_mut(k) {
+                *slot = elem;
+            }
+        }
+        len
+    }
+
+    /// Collects `amount` values at random from the iterator into a vector.
+    ///
+    /// This is equivalent to `choose_multiple_fill` except for the result type.
+    ///
+    /// Although the elements are selected randomly, the order of elements in
+    /// the buffer is neither stable nor fully random. If random ordering is
+    /// desired, shuffle the result.
+    ///
+    /// The length of the returned vector equals `amount` unless the iterator
+    /// contains insufficient elements, in which case it equals the number of
+    /// elements available.
+    ///
+    /// Complexity is `O(n)` where `n` is the length of the iterator.
+    /// For slices, prefer [`SliceRandom::choose_multiple`].
+    #[cfg(feature = "alloc")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
+    fn choose_multiple<R>(mut self, rng: &mut R, amount: usize) -> Vec<Self::Item>
+    where R: Rng + ?Sized {
+        let mut reservoir = Vec::with_capacity(amount);
+        reservoir.extend(self.by_ref().take(amount));
+
+        // Continue unless the iterator was exhausted
+        //
+        // note: this prevents iterators that "restart" from causing problems.
+        // If the iterator stops once, then so do we.
+        if reservoir.len() == amount {
+            for (i, elem) in self.enumerate() {
+                let k = gen_index(rng, i + 1 + amount);
+                if let Some(slot) = reservoir.get_mut(k) {
+                    *slot = elem;
+                }
+            }
+        } else {
+            // Don't hang onto extra memory. There is a corner case where
+            // `amount` was much less than `self.len()`.
+            reservoir.shrink_to_fit();
+        }
+        reservoir
+    }
+}
+
+
+impl<T> SliceRandom for [T] {
+    type Item = T;
+
+    fn choose<R>(&self, rng: &mut R) -> Option<&Self::Item>
+    where R: Rng + ?Sized {
+        if self.is_empty() {
+            None
+        } else {
+            Some(&self[gen_index(rng, self.len())])
+        }
+    }
+
+    fn choose_mut<R>(&mut self, rng: &mut R) -> Option<&mut Self::Item>
+    where R: Rng + ?Sized {
+        if self.is_empty() {
+            None
+        } else {
+            let len = self.len();
+            Some(&mut self[gen_index(rng, len)])
+        }
+    }
+
+    #[cfg(feature = "alloc")]
+    fn choose_multiple<R>(&self, rng: &mut R, amount: usize) -> SliceChooseIter<Self, Self::Item>
+    where R: Rng + ?Sized {
+        let amount = ::core::cmp::min(amount, self.len());
+        SliceChooseIter {
+            slice: self,
+            _phantom: Default::default(),
+            indices: index::sample(rng, self.len(), amount).into_iter(),
+        }
+    }
+
+    #[cfg(feature = "alloc")]
+    fn choose_weighted<R, F, B, X>(
+        &self, rng: &mut R, weight: F,
+    ) -> Result<&Self::Item, WeightedError>
+    where
+        R: Rng + ?Sized,
+        F: Fn(&Self::Item) -> B,
+        B: SampleBorrow<X>,
+        X: SampleUniform
+            + for<'a> ::core::ops::AddAssign<&'a X>
+            + ::core::cmp::PartialOrd<X>
+            + Clone
+            + Default,
+    {
+        use crate::distributions::{Distribution, WeightedIndex};
+        let distr = WeightedIndex::new(self.iter().map(weight))?;
+        Ok(&self[distr.sample(rng)])
+    }
+
+    #[cfg(feature = "alloc")]
+    fn choose_weighted_mut<R, F, B, X>(
+        &mut self, rng: &mut R, weight: F,
+    ) -> Result<&mut Self::Item, WeightedError>
+    where
+        R: Rng + ?Sized,
+        F: Fn(&Self::Item) -> B,
+        B: SampleBorrow<X>,
+        X: SampleUniform
+            + for<'a> ::core::ops::AddAssign<&'a X>
+            + ::core::cmp::PartialOrd<X>
+            + Clone
+            + Default,
+    {
+        use crate::distributions::{Distribution, WeightedIndex};
+        let distr = WeightedIndex::new(self.iter().map(weight))?;
+        Ok(&mut self[distr.sample(rng)])
+    }
+
+    #[cfg(feature = "std")]
+    fn choose_multiple_weighted<R, F, X>(
+        &self, rng: &mut R, amount: usize, weight: F,
+    ) -> Result<SliceChooseIter<Self, Self::Item>, WeightedError>
+    where
+        R: Rng + ?Sized,
+        F: Fn(&Self::Item) -> X,
+        X: Into<f64>,
+    {
+        let amount = ::core::cmp::min(amount, self.len());
+        Ok(SliceChooseIter {
+            slice: self,
+            _phantom: Default::default(),
+            indices: index::sample_weighted(
+                rng,
+                self.len(),
+                |idx| weight(&self[idx]).into(),
+                amount,
+            )?
+            .into_iter(),
+        })
+    }
+
+    fn shuffle<R>(&mut self, rng: &mut R)
+    where R: Rng + ?Sized {
+        for i in (1..self.len()).rev() {
+            // invariant: elements with index > i have been locked in place.
+            self.swap(i, gen_index(rng, i + 1));
+        }
+    }
+
+    fn partial_shuffle<R>(
+        &mut self, rng: &mut R, amount: usize,
+    ) -> (&mut [Self::Item], &mut [Self::Item])
+    where R: Rng + ?Sized {
+        // This applies Durstenfeld's algorithm for the
+        // [Fisher–Yates shuffle](https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle#The_modern_algorithm)
+        // for an unbiased permutation, but exits early after choosing `amount`
+        // elements.
+
+        let len = self.len();
+        let end = if amount >= len { 0 } else { len - amount };
+
+        for i in (end..len).rev() {
+            // invariant: elements with index > i have been locked in place.
+            self.swap(i, gen_index(rng, i + 1));
+        }
+        let r = self.split_at_mut(end);
+        (r.1, r.0)
+    }
+}
+
+impl<I> IteratorRandom for I where I: Iterator + Sized {}
+
+
+/// An iterator over multiple slice elements.
+///
+/// This struct is created by
+/// [`SliceRandom::choose_multiple`](trait.SliceRandom.html#tymethod.choose_multiple).
+#[cfg(feature = "alloc")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
+#[derive(Debug)]
+pub struct SliceChooseIter<'a, S: ?Sized + 'a, T: 'a> {
+    slice: &'a S,
+    _phantom: ::core::marker::PhantomData<T>,
+    indices: index::IndexVecIntoIter,
+}
+
+#[cfg(feature = "alloc")]
+impl<'a, S: Index<usize, Output = T> + ?Sized + 'a, T: 'a> Iterator for SliceChooseIter<'a, S, T> {
+    type Item = &'a T;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        // TODO: investigate using SliceIndex::get_unchecked when stable
+        self.indices.next().map(|i| &self.slice[i as usize])
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (self.indices.len(), Some(self.indices.len()))
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl<'a, S: Index<usize, Output = T> + ?Sized + 'a, T: 'a> ExactSizeIterator
+    for SliceChooseIter<'a, S, T>
+{
+    fn len(&self) -> usize {
+        self.indices.len()
+    }
+}
+
+
+// Sample a number uniformly between 0 and `ubound`. Uses 32-bit sampling where
+// possible, primarily in order to produce the same output on 32-bit and 64-bit
+// platforms.
+#[inline]
+fn gen_index<R: Rng + ?Sized>(rng: &mut R, ubound: usize) -> usize {
+    if ubound <= (core::u32::MAX as usize) {
+        rng.gen_range(0..ubound as u32) as usize
+    } else {
+        rng.gen_range(0..ubound)
+    }
+}
+
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    #[cfg(feature = "alloc")] use crate::Rng;
+    #[cfg(all(feature = "alloc", not(feature = "std")))] use alloc::vec::Vec;
+
+    #[test]
+    fn test_slice_choose() {
+        let mut r = crate::test::rng(107);
+        let chars = [
+            'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
+        ];
+        let mut chosen = [0i32; 14];
+        // The below all use a binomial distribution with n=1000, p=1/14.
+        // binocdf(40, 1000, 1/14) ~= 2e-5; 1-binocdf(106, ..) ~= 2e-5
+        for _ in 0..1000 {
+            let picked = *chars.choose(&mut r).unwrap();
+            chosen[(picked as usize) - ('a' as usize)] += 1;
+        }
+        for count in chosen.iter() {
+            assert!(40 < *count && *count < 106);
+        }
+
+        chosen.iter_mut().for_each(|x| *x = 0);
+        for _ in 0..1000 {
+            *chosen.choose_mut(&mut r).unwrap() += 1;
+        }
+        for count in chosen.iter() {
+            assert!(40 < *count && *count < 106);
+        }
+
+        let mut v: [isize; 0] = [];
+        assert_eq!(v.choose(&mut r), None);
+        assert_eq!(v.choose_mut(&mut r), None);
+    }
+
+    #[test]
+    fn value_stability_slice() {
+        let mut r = crate::test::rng(413);
+        let chars = [
+            'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
+        ];
+        let mut nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
+
+        assert_eq!(chars.choose(&mut r), Some(&'l'));
+        assert_eq!(nums.choose_mut(&mut r), Some(&mut 10));
+
+        #[cfg(feature = "alloc")]
+        assert_eq!(
+            &chars
+                .choose_multiple(&mut r, 8)
+                .cloned()
+                .collect::<Vec<char>>(),
+            &['d', 'm', 'b', 'n', 'c', 'k', 'h', 'e']
+        );
+
+        #[cfg(feature = "alloc")]
+        assert_eq!(chars.choose_weighted(&mut r, |_| 1), Ok(&'f'));
+        #[cfg(feature = "alloc")]
+        assert_eq!(nums.choose_weighted_mut(&mut r, |_| 1), Ok(&mut 5));
+
+        let mut r = crate::test::rng(414);
+        nums.shuffle(&mut r);
+        assert_eq!(nums, [9, 5, 3, 10, 7, 12, 8, 11, 6, 4, 0, 2, 1]);
+        nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
+        let res = nums.partial_shuffle(&mut r, 6);
+        assert_eq!(res.0, &mut [7, 4, 8, 6, 9, 3]);
+        assert_eq!(res.1, &mut [0, 1, 2, 12, 11, 5, 10]);
+    }
+
+    #[derive(Clone)]
+    struct UnhintedIterator<I: Iterator + Clone> {
+        iter: I,
+    }
+    impl<I: Iterator + Clone> Iterator for UnhintedIterator<I> {
+        type Item = I::Item;
+
+        fn next(&mut self) -> Option<Self::Item> {
+            self.iter.next()
+        }
+    }
+
+    #[derive(Clone)]
+    struct ChunkHintedIterator<I: ExactSizeIterator + Iterator + Clone> {
+        iter: I,
+        chunk_remaining: usize,
+        chunk_size: usize,
+        hint_total_size: bool,
+    }
+    impl<I: ExactSizeIterator + Iterator + Clone> Iterator for ChunkHintedIterator<I> {
+        type Item = I::Item;
+
+        fn next(&mut self) -> Option<Self::Item> {
+            if self.chunk_remaining == 0 {
+                self.chunk_remaining = ::core::cmp::min(self.chunk_size, self.iter.len());
+            }
+            self.chunk_remaining = self.chunk_remaining.saturating_sub(1);
+
+            self.iter.next()
+        }
+
+        fn size_hint(&self) -> (usize, Option<usize>) {
+            (
+                self.chunk_remaining,
+                if self.hint_total_size {
+                    Some(self.iter.len())
+                } else {
+                    None
+                },
+            )
+        }
+    }
+
+    #[derive(Clone)]
+    struct WindowHintedIterator<I: ExactSizeIterator + Iterator + Clone> {
+        iter: I,
+        window_size: usize,
+        hint_total_size: bool,
+    }
+    impl<I: ExactSizeIterator + Iterator + Clone> Iterator for WindowHintedIterator<I> {
+        type Item = I::Item;
+
+        fn next(&mut self) -> Option<Self::Item> {
+            self.iter.next()
+        }
+
+        fn size_hint(&self) -> (usize, Option<usize>) {
+            (
+                ::core::cmp::min(self.iter.len(), self.window_size),
+                if self.hint_total_size {
+                    Some(self.iter.len())
+                } else {
+                    None
+                },
+            )
+        }
+    }
+
+    #[test]
+    #[cfg_attr(miri, ignore)] // Miri is too slow
+    fn test_iterator_choose() {
+        let r = &mut crate::test::rng(109);
+        fn test_iter<R: Rng + ?Sized, Iter: Iterator<Item = usize> + Clone>(r: &mut R, iter: Iter) {
+            let mut chosen = [0i32; 9];
+            for _ in 0..1000 {
+                let picked = iter.clone().choose(r).unwrap();
+                chosen[picked] += 1;
+            }
+            for count in chosen.iter() {
+                // Samples should follow Binomial(1000, 1/9)
+                // Octave: binopdf(x, 1000, 1/9) gives the prob of *count == x
+                // Note: have seen 153, which is unlikely but not impossible.
+                assert!(
+                    72 < *count && *count < 154,
+                    "count not close to 1000/9: {}",
+                    count
+                );
+            }
+        }
+
+        test_iter(r, 0..9);
+        test_iter(r, [0, 1, 2, 3, 4, 5, 6, 7, 8].iter().cloned());
+        #[cfg(feature = "alloc")]
+        test_iter(r, (0..9).collect::<Vec<_>>().into_iter());
+        test_iter(r, UnhintedIterator { iter: 0..9 });
+        test_iter(r, ChunkHintedIterator {
+            iter: 0..9,
+            chunk_size: 4,
+            chunk_remaining: 4,
+            hint_total_size: false,
+        });
+        test_iter(r, ChunkHintedIterator {
+            iter: 0..9,
+            chunk_size: 4,
+            chunk_remaining: 4,
+            hint_total_size: true,
+        });
+        test_iter(r, WindowHintedIterator {
+            iter: 0..9,
+            window_size: 2,
+            hint_total_size: false,
+        });
+        test_iter(r, WindowHintedIterator {
+            iter: 0..9,
+            window_size: 2,
+            hint_total_size: true,
+        });
+
+        assert_eq!((0..0).choose(r), None);
+        assert_eq!(UnhintedIterator { iter: 0..0 }.choose(r), None);
+    }
+
+    #[test]
+    #[cfg_attr(miri, ignore)] // Miri is too slow
+    fn test_iterator_choose_stable() {
+        let r = &mut crate::test::rng(109);
+        fn test_iter<R: Rng + ?Sized, Iter: Iterator<Item = usize> + Clone>(r: &mut R, iter: Iter) {
+            let mut chosen = [0i32; 9];
+            for _ in 0..1000 {
+                let picked = iter.clone().choose_stable(r).unwrap();
+                chosen[picked] += 1;
+            }
+            for count in chosen.iter() {
+                // Samples should follow Binomial(1000, 1/9)
+                // Octave: binopdf(x, 1000, 1/9) gives the prob of *count == x
+                // Note: have seen 153, which is unlikely but not impossible.
+                assert!(
+                    72 < *count && *count < 154,
+                    "count not close to 1000/9: {}",
+                    count
+                );
+            }
+        }
+
+        test_iter(r, 0..9);
+        test_iter(r, [0, 1, 2, 3, 4, 5, 6, 7, 8].iter().cloned());
+        #[cfg(feature = "alloc")]
+        test_iter(r, (0..9).collect::<Vec<_>>().into_iter());
+        test_iter(r, UnhintedIterator { iter: 0..9 });
+        test_iter(r, ChunkHintedIterator {
+            iter: 0..9,
+            chunk_size: 4,
+            chunk_remaining: 4,
+            hint_total_size: false,
+        });
+        test_iter(r, ChunkHintedIterator {
+            iter: 0..9,
+            chunk_size: 4,
+            chunk_remaining: 4,
+            hint_total_size: true,
+        });
+        test_iter(r, WindowHintedIterator {
+            iter: 0..9,
+            window_size: 2,
+            hint_total_size: false,
+        });
+        test_iter(r, WindowHintedIterator {
+            iter: 0..9,
+            window_size: 2,
+            hint_total_size: true,
+        });
+
+        assert_eq!((0..0).choose(r), None);
+        assert_eq!(UnhintedIterator { iter: 0..0 }.choose(r), None);
+    }
+
+    #[test]
+    #[cfg_attr(miri, ignore)] // Miri is too slow
+    fn test_iterator_choose_stable_stability() {
+        fn test_iter(iter: impl Iterator<Item = usize> + Clone) -> [i32; 9] {
+            let r = &mut crate::test::rng(109);
+            let mut chosen = [0i32; 9];
+            for _ in 0..1000 {
+                let picked = iter.clone().choose_stable(r).unwrap();
+                chosen[picked] += 1;
+            }
+            chosen
+        }
+
+        let reference = test_iter(0..9);
+        assert_eq!(test_iter([0, 1, 2, 3, 4, 5, 6, 7, 8].iter().cloned()), reference);
+
+        #[cfg(feature = "alloc")]
+        assert_eq!(test_iter((0..9).collect::<Vec<_>>().into_iter()), reference);
+        assert_eq!(test_iter(UnhintedIterator { iter: 0..9 }), reference);
+        assert_eq!(test_iter(ChunkHintedIterator {
+            iter: 0..9,
+            chunk_size: 4,
+            chunk_remaining: 4,
+            hint_total_size: false,
+        }), reference);
+        assert_eq!(test_iter(ChunkHintedIterator {
+            iter: 0..9,
+            chunk_size: 4,
+            chunk_remaining: 4,
+            hint_total_size: true,
+        }), reference);
+        assert_eq!(test_iter(WindowHintedIterator {
+            iter: 0..9,
+            window_size: 2,
+            hint_total_size: false,
+        }), reference);
+        assert_eq!(test_iter(WindowHintedIterator {
+            iter: 0..9,
+            window_size: 2,
+            hint_total_size: true,
+        }), reference);
+    }
+
+    #[test]
+    #[cfg_attr(miri, ignore)] // Miri is too slow
+    fn test_shuffle() {
+        let mut r = crate::test::rng(108);
+        let empty: &mut [isize] = &mut [];
+        empty.shuffle(&mut r);
+        let mut one = [1];
+        one.shuffle(&mut r);
+        let b: &[_] = &[1];
+        assert_eq!(one, b);
+
+        let mut two = [1, 2];
+        two.shuffle(&mut r);
+        assert!(two == [1, 2] || two == [2, 1]);
+
+        fn move_last(slice: &mut [usize], pos: usize) {
+            // use slice[pos..].rotate_left(1); once we can use that
+            let last_val = slice[pos];
+            for i in pos..slice.len() - 1 {
+                slice[i] = slice[i + 1];
+            }
+            *slice.last_mut().unwrap() = last_val;
+        }
+        let mut counts = [0i32; 24];
+        for _ in 0..10000 {
+            let mut arr: [usize; 4] = [0, 1, 2, 3];
+            arr.shuffle(&mut r);
+            let mut permutation = 0usize;
+            let mut pos_value = counts.len();
+            for i in 0..4 {
+                pos_value /= 4 - i;
+                let pos = arr.iter().position(|&x| x == i).unwrap();
+                assert!(pos < (4 - i));
+                permutation += pos * pos_value;
+                move_last(&mut arr, pos);
+                assert_eq!(arr[3], i);
+            }
+            for (i, &a) in arr.iter().enumerate() {
+                assert_eq!(a, i);
+            }
+            counts[permutation] += 1;
+        }
+        for count in counts.iter() {
+            // Binomial(10000, 1/24) with average 416.667
+            // Octave: binocdf(n, 10000, 1/24)
+            // 99.9% chance samples lie within this range:
+            assert!(352 <= *count && *count <= 483, "count: {}", count);
+        }
+    }
+
+    #[test]
+    fn test_partial_shuffle() {
+        let mut r = crate::test::rng(118);
+
+        let mut empty: [u32; 0] = [];
+        let res = empty.partial_shuffle(&mut r, 10);
+        assert_eq!((res.0.len(), res.1.len()), (0, 0));
+
+        let mut v = [1, 2, 3, 4, 5];
+        let res = v.partial_shuffle(&mut r, 2);
+        assert_eq!((res.0.len(), res.1.len()), (2, 3));
+        assert!(res.0[0] != res.0[1]);
+        // First elements are only modified if selected, so at least one isn't modified:
+        assert!(res.1[0] == 1 || res.1[1] == 2 || res.1[2] == 3);
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn test_sample_iter() {
+        let min_val = 1;
+        let max_val = 100;
+
+        let mut r = crate::test::rng(401);
+        let vals = (min_val..max_val).collect::<Vec<i32>>();
+        let small_sample = vals.iter().choose_multiple(&mut r, 5);
+        let large_sample = vals.iter().choose_multiple(&mut r, vals.len() + 5);
+
+        assert_eq!(small_sample.len(), 5);
+        assert_eq!(large_sample.len(), vals.len());
+        // no randomization happens when amount >= len
+        assert_eq!(large_sample, vals.iter().collect::<Vec<_>>());
+
+        assert!(small_sample
+            .iter()
+            .all(|e| { **e >= min_val && **e <= max_val }));
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    #[cfg_attr(miri, ignore)] // Miri is too slow
+    fn test_weighted() {
+        let mut r = crate::test::rng(406);
+        const N_REPS: u32 = 3000;
+        let weights = [1u32, 2, 3, 0, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7];
+        let total_weight = weights.iter().sum::<u32>() as f32;
+
+        let verify = |result: [i32; 14]| {
+            for (i, count) in result.iter().enumerate() {
+                let exp = (weights[i] * N_REPS) as f32 / total_weight;
+                let mut err = (*count as f32 - exp).abs();
+                if err != 0.0 {
+                    err /= exp;
+                }
+                assert!(err <= 0.25);
+            }
+        };
+
+        // choose_weighted
+        fn get_weight<T>(item: &(u32, T)) -> u32 {
+            item.0
+        }
+        let mut chosen = [0i32; 14];
+        let mut items = [(0u32, 0usize); 14]; // (weight, index)
+        for (i, item) in items.iter_mut().enumerate() {
+            *item = (weights[i], i);
+        }
+        for _ in 0..N_REPS {
+            let item = items.choose_weighted(&mut r, get_weight).unwrap();
+            chosen[item.1] += 1;
+        }
+        verify(chosen);
+
+        // choose_weighted_mut
+        let mut items = [(0u32, 0i32); 14]; // (weight, count)
+        for (i, item) in items.iter_mut().enumerate() {
+            *item = (weights[i], 0);
+        }
+        for _ in 0..N_REPS {
+            items.choose_weighted_mut(&mut r, get_weight).unwrap().1 += 1;
+        }
+        for (ch, item) in chosen.iter_mut().zip(items.iter()) {
+            *ch = item.1;
+        }
+        verify(chosen);
+
+        // Check error cases
+        let empty_slice = &mut [10][0..0];
+        assert_eq!(
+            empty_slice.choose_weighted(&mut r, |_| 1),
+            Err(WeightedError::NoItem)
+        );
+        assert_eq!(
+            empty_slice.choose_weighted_mut(&mut r, |_| 1),
+            Err(WeightedError::NoItem)
+        );
+        assert_eq!(
+            ['x'].choose_weighted_mut(&mut r, |_| 0),
+            Err(WeightedError::AllWeightsZero)
+        );
+        assert_eq!(
+            [0, -1].choose_weighted_mut(&mut r, |x| *x),
+            Err(WeightedError::InvalidWeight)
+        );
+        assert_eq!(
+            [-1, 0].choose_weighted_mut(&mut r, |x| *x),
+            Err(WeightedError::InvalidWeight)
+        );
+    }
+
+    #[test]
+    fn value_stability_choose() {
+        fn choose<I: Iterator<Item = u32>>(iter: I) -> Option<u32> {
+            let mut rng = crate::test::rng(411);
+            iter.choose(&mut rng)
+        }
+
+        assert_eq!(choose([].iter().cloned()), None);
+        assert_eq!(choose(0..100), Some(33));
+        assert_eq!(choose(UnhintedIterator { iter: 0..100 }), Some(40));
+        assert_eq!(
+            choose(ChunkHintedIterator {
+                iter: 0..100,
+                chunk_size: 32,
+                chunk_remaining: 32,
+                hint_total_size: false,
+            }),
+            Some(39)
+        );
+        assert_eq!(
+            choose(ChunkHintedIterator {
+                iter: 0..100,
+                chunk_size: 32,
+                chunk_remaining: 32,
+                hint_total_size: true,
+            }),
+            Some(39)
+        );
+        assert_eq!(
+            choose(WindowHintedIterator {
+                iter: 0..100,
+                window_size: 32,
+                hint_total_size: false,
+            }),
+            Some(90)
+        );
+        assert_eq!(
+            choose(WindowHintedIterator {
+                iter: 0..100,
+                window_size: 32,
+                hint_total_size: true,
+            }),
+            Some(90)
+        );
+    }
+
+    #[test]
+    fn value_stability_choose_stable() {
+        fn choose<I: Iterator<Item = u32>>(iter: I) -> Option<u32> {
+            let mut rng = crate::test::rng(411);
+            iter.choose_stable(&mut rng)
+        }
+
+        assert_eq!(choose([].iter().cloned()), None);
+        assert_eq!(choose(0..100), Some(40));
+        assert_eq!(choose(UnhintedIterator { iter: 0..100 }), Some(40));
+        assert_eq!(
+            choose(ChunkHintedIterator {
+                iter: 0..100,
+                chunk_size: 32,
+                chunk_remaining: 32,
+                hint_total_size: false,
+            }),
+            Some(40)
+        );
+        assert_eq!(
+            choose(ChunkHintedIterator {
+                iter: 0..100,
+                chunk_size: 32,
+                chunk_remaining: 32,
+                hint_total_size: true,
+            }),
+            Some(40)
+        );
+        assert_eq!(
+            choose(WindowHintedIterator {
+                iter: 0..100,
+                window_size: 32,
+                hint_total_size: false,
+            }),
+            Some(40)
+        );
+        assert_eq!(
+            choose(WindowHintedIterator {
+                iter: 0..100,
+                window_size: 32,
+                hint_total_size: true,
+            }),
+            Some(40)
+        );
+    }
+
+    #[test]
+    fn value_stability_choose_multiple() {
+        fn do_test<I: Iterator<Item = u32>>(iter: I, v: &[u32]) {
+            let mut rng = crate::test::rng(412);
+            let mut buf = [0u32; 8];
+            assert_eq!(iter.choose_multiple_fill(&mut rng, &mut buf), v.len());
+            assert_eq!(&buf[0..v.len()], v);
+        }
+
+        do_test(0..4, &[0, 1, 2, 3]);
+        do_test(0..8, &[0, 1, 2, 3, 4, 5, 6, 7]);
+        do_test(0..100, &[58, 78, 80, 92, 43, 8, 96, 7]);
+
+        #[cfg(feature = "alloc")]
+        {
+            fn do_test<I: Iterator<Item = u32>>(iter: I, v: &[u32]) {
+                let mut rng = crate::test::rng(412);
+                assert_eq!(iter.choose_multiple(&mut rng, v.len()), v);
+            }
+
+            do_test(0..4, &[0, 1, 2, 3]);
+            do_test(0..8, &[0, 1, 2, 3, 4, 5, 6, 7]);
+            do_test(0..100, &[58, 78, 80, 92, 43, 8, 96, 7]);
+        }
+    }
+
+    #[test]
+    #[cfg(feature = "std")]
+    fn test_multiple_weighted_edge_cases() {
+        use super::*;
+
+        let mut rng = crate::test::rng(413);
+
+        // Case 1: One of the weights is 0
+        let choices = [('a', 2), ('b', 1), ('c', 0)];
+        for _ in 0..100 {
+            let result = choices
+                .choose_multiple_weighted(&mut rng, 2, |item| item.1)
+                .unwrap()
+                .collect::<Vec<_>>();
+
+            assert_eq!(result.len(), 2);
+            assert!(!result.iter().any(|val| val.0 == 'c'));
+        }
+
+        // Case 2: All of the weights are 0
+        let choices = [('a', 0), ('b', 0), ('c', 0)];
+
+        assert_eq!(choices
+            .choose_multiple_weighted(&mut rng, 2, |item| item.1)
+            .unwrap().count(), 2);
+
+        // Case 3: Negative weights
+        let choices = [('a', -1), ('b', 1), ('c', 1)];
+        assert_eq!(
+            choices
+                .choose_multiple_weighted(&mut rng, 2, |item| item.1)
+                .unwrap_err(),
+            WeightedError::InvalidWeight
+        );
+
+        // Case 4: Empty list
+        let choices = [];
+        assert_eq!(choices
+            .choose_multiple_weighted(&mut rng, 0, |_: &()| 0)
+            .unwrap().count(), 0);
+
+        // Case 5: NaN weights
+        let choices = [('a', core::f64::NAN), ('b', 1.0), ('c', 1.0)];
+        assert_eq!(
+            choices
+                .choose_multiple_weighted(&mut rng, 2, |item| item.1)
+                .unwrap_err(),
+            WeightedError::InvalidWeight
+        );
+
+        // Case 6: +infinity weights
+        let choices = [('a', core::f64::INFINITY), ('b', 1.0), ('c', 1.0)];
+        for _ in 0..100 {
+            let result = choices
+                .choose_multiple_weighted(&mut rng, 2, |item| item.1)
+                .unwrap()
+                .collect::<Vec<_>>();
+            assert_eq!(result.len(), 2);
+            assert!(result.iter().any(|val| val.0 == 'a'));
+        }
+
+        // Case 7: -infinity weights
+        let choices = [('a', core::f64::NEG_INFINITY), ('b', 1.0), ('c', 1.0)];
+        assert_eq!(
+            choices
+                .choose_multiple_weighted(&mut rng, 2, |item| item.1)
+                .unwrap_err(),
+            WeightedError::InvalidWeight
+        );
+
+        // Case 8: -0 weights
+        let choices = [('a', -0.0), ('b', 1.0), ('c', 1.0)];
+        assert!(choices
+            .choose_multiple_weighted(&mut rng, 2, |item| item.1)
+            .is_ok());
+    }
+
+    #[test]
+    #[cfg(feature = "std")]
+    fn test_multiple_weighted_distributions() {
+        use super::*;
+
+        // The theoretical probabilities of the different outcomes are:
+        // AB: 0.5  * 0.5  = 0.250
+        // AC: 0.5  * 0.5  = 0.250
+        // BA: 0.25 * 0.67 = 0.167
+        // BC: 0.25 * 0.33 = 0.082
+        // CA: 0.25 * 0.67 = 0.167
+        // CB: 0.25 * 0.33 = 0.082
+        let choices = [('a', 2), ('b', 1), ('c', 1)];
+        let mut rng = crate::test::rng(414);
+
+        let mut results = [0i32; 3];
+        let expected_results = [4167, 4167, 1666];
+        for _ in 0..10000 {
+            let result = choices
+                .choose_multiple_weighted(&mut rng, 2, |item| item.1)
+                .unwrap()
+                .collect::<Vec<_>>();
+
+            assert_eq!(result.len(), 2);
+
+            match (result[0].0, result[1].0) {
+                ('a', 'b') | ('b', 'a') => {
+                    results[0] += 1;
+                }
+                ('a', 'c') | ('c', 'a') => {
+                    results[1] += 1;
+                }
+                ('b', 'c') | ('c', 'b') => {
+                    results[2] += 1;
+                }
+                (_, _) => panic!("unexpected result"),
+            }
+        }
+
+        let mut diffs = results
+            .iter()
+            .zip(&expected_results)
+            .map(|(a, b)| (a - b).abs());
+        assert!(!diffs.any(|deviation| deviation > 100));
+    }
+}
diff --git a/crates/rand_chacha/.cargo-checksum.json b/crates/rand_chacha/.cargo-checksum.json
new file mode 100644
index 0000000..a7100e9
--- /dev/null
+++ b/crates/rand_chacha/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"CHANGELOG.md":"deb20cd6e8be14e767b7fdea0e503ddd8226afd1253a5221aacc28a23d45db20","COPYRIGHT":"90eb64f0279b0d9432accfa6023ff803bc4965212383697eee27a0f426d5f8d5","Cargo.toml":"e2ef45f3c9d6f013da266b76ca1e1f664ad5fa1d526b46580a77fb311c659fd8","LICENSE-APACHE":"aaff376532ea30a0cd5330b9502ad4a4c8bf769c539c87ffe78819d188a18ebf","LICENSE-MIT":"209fbbe0ad52d9235e37badf9cadfe4dbdc87203179c0899e738b39ade42177b","README.md":"f4221f35b7086649fa77807e826af020b57eb65b19cb693482d4a7e1e4d80537","src/chacha.rs":"dfd79ed4762e8267148d1776381c71b898808014a4069cfafbc78177247d5fe9","src/guts.rs":"898fd129897fb44d15053044227307ee2bf416970adb8e63b4f5eabb7431aa1e","src/lib.rs":"a27fe2bff676a764d43d604a20cf30a41dc1c5ef4053eb41129d2479f5ae83fe"},"package":"e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"}
\ No newline at end of file
diff --git a/crates/rand_chacha/Android.bp b/crates/rand_chacha/Android.bp
new file mode 100644
index 0000000..8e9fbba
--- /dev/null
+++ b/crates/rand_chacha/Android.bp
@@ -0,0 +1,62 @@
+// This file is generated by cargo_embargo.
+// Do not modify this file because the changes will be overridden on upgrade.
+
+package {
+    default_applicable_licenses: ["external_rust_crates_rand_chacha_license"],
+    default_team: "trendy_team_android_rust",
+}
+
+license {
+    name: "external_rust_crates_rand_chacha_license",
+    visibility: [":__subpackages__"],
+    license_kinds: ["SPDX-license-identifier-Apache-2.0"],
+    license_text: ["LICENSE"],
+}
+
+rust_library {
+    name: "librand_chacha",
+    host_supported: true,
+    crate_name: "rand_chacha",
+    cargo_env_compat: true,
+    cargo_pkg_version: "0.3.1",
+    crate_root: "src/lib.rs",
+    edition: "2018",
+    features: [
+        "default",
+        "std",
+    ],
+    rustlibs: [
+        "libppv_lite86",
+        "librand_core",
+    ],
+    apex_available: [
+        "//apex_available:platform",
+        "//apex_available:anyapex",
+    ],
+    product_available: true,
+    vendor_available: true,
+}
+
+rust_test {
+    name: "rand_chacha_test_src_lib",
+    host_supported: true,
+    crate_name: "rand_chacha",
+    cargo_env_compat: true,
+    cargo_pkg_version: "0.3.1",
+    crate_root: "src/lib.rs",
+    test_suites: ["general-tests"],
+    auto_gen_config: true,
+    test_options: {
+        unit_test: true,
+    },
+    edition: "2018",
+    features: [
+        "default",
+        "std",
+    ],
+    rustlibs: [
+        "libppv_lite86",
+        "librand_core",
+        "libserde_json",
+    ],
+}
diff --git a/crates/rand_chacha/CHANGELOG.md b/crates/rand_chacha/CHANGELOG.md
new file mode 100644
index 0000000..a598bb7
--- /dev/null
+++ b/crates/rand_chacha/CHANGELOG.md
@@ -0,0 +1,35 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.3.1] - 2021-06-09
+- add getters corresponding to existing setters: `get_seed`, `get_stream` (#1124)
+- add serde support, gated by the `serde1` feature (#1124)
+- ensure expected layout via `repr(transparent)` (#1120)
+
+## [0.3.0] - 2020-12-08
+- Bump `rand_core` version to 0.6.0
+- Bump MSRV to 1.36 (#1011)
+- Remove usage of deprecated feature "simd" of `ppv-lite86` (#979), then revert
+  this change (#1023) since SIMD is only enabled by default from `ppv-lite86 v0.2.10`
+- impl PartialEq+Eq for ChaChaXRng and ChaChaXCore (#979)
+- Fix panic on block counter wrap that was occurring in debug builds (#980)
+
+## [0.2.2] - 2020-03-09
+- Integrate `c2-chacha`, reducing dependency count (#931)
+- Add CryptoRng to ChaChaXCore (#944)
+
+## [0.2.1] - 2019-07-22
+- Force enable the `simd` feature of `c2-chacha` (#845)
+
+## [0.2.0] - 2019-06-06
+- Rewrite based on the much faster `c2-chacha` crate (#789)
+
+## [0.1.1] - 2019-01-04
+- Disable `i128` and `u128` if the `target_os` is `emscripten` (#671: work-around Emscripten limitation)
+- Update readme and doc links
+
+## [0.1.0] - 2018-10-17
+- Pulled out of the Rand crate
diff --git a/crates/rand_chacha/COPYRIGHT b/crates/rand_chacha/COPYRIGHT
new file mode 100644
index 0000000..468d907
--- /dev/null
+++ b/crates/rand_chacha/COPYRIGHT
@@ -0,0 +1,12 @@
+Copyrights in the Rand project are retained by their contributors. No
+copyright assignment is required to contribute to the Rand project.
+
+For full authorship information, see the version control history.
+
+Except as otherwise noted (below and/or in individual files), Rand is
+licensed under the Apache License, Version 2.0 <LICENSE-APACHE> or
+<http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+<LICENSE-MIT> or <http://opensource.org/licenses/MIT>, at your option.
+
+The Rand project includes code from the Rust project
+published under these same licenses.
diff --git a/crates/rand_chacha/Cargo.lock b/crates/rand_chacha/Cargo.lock
new file mode 100644
index 0000000..f019d6c
--- /dev/null
+++ b/crates/rand_chacha/Cargo.lock
@@ -0,0 +1,140 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "itoa"
+version = "1.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
+
+[[package]]
+name = "memchr"
+version = "2.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.86"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+
+[[package]]
+name = "ryu"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
+
+[[package]]
+name = "serde"
+version = "1.0.209"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "99fce0ffe7310761ca6bf9faf5115afbc19688edd00171d81b1bb1b116c63e09"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.209"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5831b979fd7b5439637af1752d535ff49f4860c0f341d1baeb6faf0f4242170"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.127"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8043c06d9f82bd7271361ed64f415fe5e12a77fdb52e573e7f06a516dea329ad"
+dependencies = [
+ "itoa",
+ "memchr",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.76"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "578e081a14e0cefc3279b0472138c513f37b41a08d5a3cca9b6e4e8ceb6cd525"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
+
+[[package]]
+name = "zerocopy"
+version = "0.7.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
+dependencies = [
+ "byteorder",
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.7.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
diff --git a/crates/rand_chacha/Cargo.toml b/crates/rand_chacha/Cargo.toml
new file mode 100644
index 0000000..c907ae9
--- /dev/null
+++ b/crates/rand_chacha/Cargo.toml
@@ -0,0 +1,45 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies
+#
+# If you believe there's an error in this file please file an
+# issue against the rust-lang/cargo repository. If you're
+# editing this file be aware that the upstream Cargo.toml
+# will likely look very different (and much more reasonable)
+
+[package]
+edition = "2018"
+name = "rand_chacha"
+version = "0.3.1"
+authors = ["The Rand Project Developers", "The Rust Project Developers", "The CryptoCorrosion Contributors"]
+description = "ChaCha random number generator\n"
+homepage = "https://rust-random.github.io/book"
+documentation = "https://docs.rs/rand_chacha"
+readme = "README.md"
+keywords = ["random", "rng", "chacha"]
+categories = ["algorithms", "no-std"]
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/rust-random/rand"
+[dependencies.ppv-lite86]
+version = "0.2.8"
+features = ["simd"]
+default-features = false
+
+[dependencies.rand_core]
+version = "0.6.0"
+
+[dependencies.serde]
+version = "1.0"
+features = ["derive"]
+optional = true
+[dev-dependencies.serde_json]
+version = "1.0"
+
+[features]
+default = ["std"]
+serde1 = ["serde"]
+simd = []
+std = ["ppv-lite86/std"]
diff --git a/crates/rand_chacha/LICENSE b/crates/rand_chacha/LICENSE
new file mode 120000
index 0000000..6b579aa
--- /dev/null
+++ b/crates/rand_chacha/LICENSE
@@ -0,0 +1 @@
+LICENSE-APACHE
\ No newline at end of file
diff --git a/crates/rand_chacha/LICENSE-APACHE b/crates/rand_chacha/LICENSE-APACHE
new file mode 100644
index 0000000..17d7468
--- /dev/null
+++ b/crates/rand_chacha/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     https://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	https://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/crates/rand_chacha/LICENSE-MIT b/crates/rand_chacha/LICENSE-MIT
new file mode 100644
index 0000000..d93b5ba
--- /dev/null
+++ b/crates/rand_chacha/LICENSE-MIT
@@ -0,0 +1,26 @@
+Copyright 2018 Developers of the Rand project
+Copyright (c) 2014 The Rust Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/crates/rand_chacha/METADATA b/crates/rand_chacha/METADATA
new file mode 100644
index 0000000..72cd107
--- /dev/null
+++ b/crates/rand_chacha/METADATA
@@ -0,0 +1,19 @@
+name: "rand_chacha"
+description: "ChaCha random number generator"
+third_party {
+  url {
+    type: HOMEPAGE
+    value: "https://crates.io/crates/rand_chacha"
+  }
+  url {
+    type: ARCHIVE
+    value: "https://static.crates.io/crates/rand_chacha/rand_chacha-0.3.1.crate"
+  }
+  version: "0.3.1"
+  license_type: NOTICE
+  last_upgrade_date {
+    year: 2021
+    month: 6
+    day: 21
+  }
+}
diff --git a/crates/rand_chacha/MODULE_LICENSE_APACHE2 b/crates/rand_chacha/MODULE_LICENSE_APACHE2
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/crates/rand_chacha/MODULE_LICENSE_APACHE2
diff --git a/crates/rand_chacha/README.md b/crates/rand_chacha/README.md
new file mode 100644
index 0000000..edd754d
--- /dev/null
+++ b/crates/rand_chacha/README.md
@@ -0,0 +1,48 @@
+# rand_chacha
+
+[![Test Status](https://github.com/rust-random/rand/workflows/Tests/badge.svg?event=push)](https://github.com/rust-random/rand/actions)
+[![Latest version](https://img.shields.io/crates/v/rand_chacha.svg)](https://crates.io/crates/rand_chacha)
+[![Book](https://img.shields.io/badge/book-master-yellow.svg)](https://rust-random.github.io/book/)
+[![API](https://img.shields.io/badge/api-master-yellow.svg)](https://rust-random.github.io/rand/rand_chacha)
+[![API](https://docs.rs/rand_chacha/badge.svg)](https://docs.rs/rand_chacha)
+[![Minimum rustc version](https://img.shields.io/badge/rustc-1.36+-lightgray.svg)](https://github.com/rust-random/rand#rust-version-requirements)
+
+A cryptographically secure random number generator that uses the ChaCha
+algorithm.
+
+ChaCha is a stream cipher designed by Daniel J. Bernstein[^1], that we use
+as an RNG. It is an improved variant of the Salsa20 cipher family, which was
+selected as one of the "stream ciphers suitable for widespread adoption" by
+eSTREAM[^2].
+
+The RNGs provided by this crate are implemented via the fast stream ciphers of
+the [`c2-chacha`](https://crates.io/crates/c2-chacha) crate.
+
+Links:
+
+-   [API documentation (master)](https://rust-random.github.io/rand/rand_chacha)
+-   [API documentation (docs.rs)](https://docs.rs/rand_chacha)
+-   [Changelog](https://github.com/rust-random/rand/blob/master/rand_chacha/CHANGELOG.md)
+
+[rand]: https://crates.io/crates/rand
+[^1]: D. J. Bernstein, [*ChaCha, a variant of Salsa20*](
+      https://cr.yp.to/chacha.html)
+
+[^2]: [eSTREAM: the ECRYPT Stream Cipher Project](
+      http://www.ecrypt.eu.org/stream/)
+
+
+## Crate Features
+
+`rand_chacha` is `no_std` compatible when disabling default features; the `std`
+feature can be explicitly required to re-enable `std` support. Using `std`
+allows detection of CPU features and thus better optimisation.
+
+
+# License
+
+`rand_chacha` is distributed under the terms of both the MIT license and the
+Apache License (Version 2.0).
+
+See [LICENSE-APACHE](LICENSE-APACHE) and [LICENSE-MIT](LICENSE-MIT), and
+[COPYRIGHT](COPYRIGHT) for details.
diff --git a/crates/rand_chacha/TEST_MAPPING b/crates/rand_chacha/TEST_MAPPING
new file mode 100644
index 0000000..7c1613b
--- /dev/null
+++ b/crates/rand_chacha/TEST_MAPPING
@@ -0,0 +1,93 @@
+// Generated by update_crate_tests.py for tests that depend on this crate.
+{
+  "imports": [
+    {
+      "path": "external/rust/crates/base64"
+    },
+    {
+      "path": "external/rust/crates/cast"
+    },
+    {
+      "path": "external/rust/crates/crc32fast"
+    },
+    {
+      "path": "external/rust/crates/crossbeam-deque"
+    },
+    {
+      "path": "external/rust/crates/crossbeam-epoch"
+    },
+    {
+      "path": "external/rust/crates/crossbeam-queue"
+    },
+    {
+      "path": "external/rust/crates/crossbeam-utils"
+    },
+    {
+      "path": "external/rust/crates/flate2"
+    },
+    {
+      "path": "external/rust/crates/hashbrown"
+    },
+    {
+      "path": "external/rust/crates/mio"
+    },
+    {
+      "path": "external/rust/crates/quickcheck"
+    },
+    {
+      "path": "external/rust/crates/regex"
+    },
+    {
+      "path": "external/rust/crates/ryu"
+    },
+    {
+      "path": "external/rust/crates/tokio"
+    },
+    {
+      "path": "external/rust/crates/zerocopy"
+    },
+    {
+      "path": "external/uwb/src"
+    },
+    {
+      "path": "packages/modules/Virtualization/apkdmverity"
+    },
+    {
+      "path": "packages/modules/Virtualization/authfs"
+    },
+    {
+      "path": "packages/modules/Virtualization/avmd"
+    },
+    {
+      "path": "packages/modules/Virtualization/libs/devicemapper"
+    },
+    {
+      "path": "packages/modules/Virtualization/microdroid_manager"
+    },
+    {
+      "path": "packages/modules/Virtualization/virtualizationmanager"
+    },
+    {
+      "path": "packages/modules/Virtualization/vm"
+    },
+    {
+      "path": "packages/modules/Virtualization/zipfuse"
+    },
+    {
+      "path": "system/security/keystore2"
+    },
+    {
+      "path": "system/security/keystore2/legacykeystore"
+    }
+  ],
+  "presubmit": [
+    {
+      "name": "rand_chacha_test_src_lib"
+    }
+  ],
+  "presubmit-rust": [
+    {
+      "name": "rand_chacha_test_src_lib"
+    }
+  ]
+}
diff --git a/crates/rand_chacha/cargo_embargo.json b/crates/rand_chacha/cargo_embargo.json
new file mode 100644
index 0000000..c8842d1
--- /dev/null
+++ b/crates/rand_chacha/cargo_embargo.json
@@ -0,0 +1,4 @@
+{
+  "run_cargo": false,
+  "tests": true
+}
diff --git a/crates/rand_chacha/src/chacha.rs b/crates/rand_chacha/src/chacha.rs
new file mode 100644
index 0000000..50da81b
--- /dev/null
+++ b/crates/rand_chacha/src/chacha.rs
@@ -0,0 +1,632 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! The ChaCha random number generator.
+
+#[cfg(not(feature = "std"))] use core;
+#[cfg(feature = "std")] use std as core;
+
+use self::core::fmt;
+use crate::guts::ChaCha;
+use rand_core::block::{BlockRng, BlockRngCore};
+use rand_core::{CryptoRng, Error, RngCore, SeedableRng};
+
+#[cfg(feature = "serde1")] use serde::{Serialize, Deserialize, Serializer, Deserializer};
+
+// NB. this must remain consistent with some currently hard-coded numbers in this module
+const BUF_BLOCKS: u8 = 4;
+// number of 32-bit words per ChaCha block (fixed by algorithm definition)
+const BLOCK_WORDS: u8 = 16;
+
+#[repr(transparent)]
+pub struct Array64<T>([T; 64]);
+impl<T> Default for Array64<T>
+where T: Default
+{
+    #[rustfmt::skip]
+    fn default() -> Self {
+        Self([
+            T::default(), T::default(), T::default(), T::default(), T::default(), T::default(), T::default(), T::default(),
+            T::default(), T::default(), T::default(), T::default(), T::default(), T::default(), T::default(), T::default(),
+            T::default(), T::default(), T::default(), T::default(), T::default(), T::default(), T::default(), T::default(),
+            T::default(), T::default(), T::default(), T::default(), T::default(), T::default(), T::default(), T::default(),
+            T::default(), T::default(), T::default(), T::default(), T::default(), T::default(), T::default(), T::default(),
+            T::default(), T::default(), T::default(), T::default(), T::default(), T::default(), T::default(), T::default(),
+            T::default(), T::default(), T::default(), T::default(), T::default(), T::default(), T::default(), T::default(),
+            T::default(), T::default(), T::default(), T::default(), T::default(), T::default(), T::default(), T::default(),
+        ])
+    }
+}
+impl<T> AsRef<[T]> for Array64<T> {
+    fn as_ref(&self) -> &[T] {
+        &self.0
+    }
+}
+impl<T> AsMut<[T]> for Array64<T> {
+    fn as_mut(&mut self) -> &mut [T] {
+        &mut self.0
+    }
+}
+impl<T> Clone for Array64<T>
+where T: Copy + Default
+{
+    fn clone(&self) -> Self {
+        let mut new = Self::default();
+        new.0.copy_from_slice(&self.0);
+        new
+    }
+}
+impl<T> fmt::Debug for Array64<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "Array64 {{}}")
+    }
+}
+
+macro_rules! chacha_impl {
+    ($ChaChaXCore:ident, $ChaChaXRng:ident, $rounds:expr, $doc:expr, $abst:ident) => {
+        #[doc=$doc]
+        #[derive(Clone, PartialEq, Eq)]
+        pub struct $ChaChaXCore {
+            state: ChaCha,
+        }
+
+        // Custom Debug implementation that does not expose the internal state
+        impl fmt::Debug for $ChaChaXCore {
+            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                write!(f, "ChaChaXCore {{}}")
+            }
+        }
+
+        impl BlockRngCore for $ChaChaXCore {
+            type Item = u32;
+            type Results = Array64<u32>;
+            #[inline]
+            fn generate(&mut self, r: &mut Self::Results) {
+                // Fill slice of words by writing to equivalent slice of bytes, then fixing endianness.
+                self.state.refill4($rounds, unsafe {
+                    &mut *(&mut *r as *mut Array64<u32> as *mut [u8; 256])
+                });
+                for x in r.as_mut() {
+                    *x = x.to_le();
+                }
+            }
+        }
+
+        impl SeedableRng for $ChaChaXCore {
+            type Seed = [u8; 32];
+            #[inline]
+            fn from_seed(seed: Self::Seed) -> Self {
+                $ChaChaXCore { state: ChaCha::new(&seed, &[0u8; 8]) }
+            }
+        }
+
+        impl CryptoRng for $ChaChaXCore {}
+
+        /// A cryptographically secure random number generator that uses the ChaCha algorithm.
+        ///
+        /// ChaCha is a stream cipher designed by Daniel J. Bernstein[^1], that we use as an RNG. It is
+        /// an improved variant of the Salsa20 cipher family, which was selected as one of the "stream
+        /// ciphers suitable for widespread adoption" by eSTREAM[^2].
+        ///
+        /// ChaCha uses add-rotate-xor (ARX) operations as its basis. These are safe against timing
+        /// attacks, although that is mostly a concern for ciphers and not for RNGs. We provide a SIMD
+        /// implementation to support high throughput on a variety of common hardware platforms.
+        ///
+        /// With the ChaCha algorithm it is possible to choose the number of rounds the core algorithm
+        /// should run. The number of rounds is a tradeoff between performance and security, where 8
+        /// rounds is the minimum potentially secure configuration, and 20 rounds is widely used as a
+        /// conservative choice.
+        ///
+        /// We use a 64-bit counter and 64-bit stream identifier as in Bernstein's implementation[^1]
+        /// except that we use a stream identifier in place of a nonce. A 64-bit counter over 64-byte
+        /// (16 word) blocks allows 1 ZiB of output before cycling, and the stream identifier allows
+        /// 2<sup>64</sup> unique streams of output per seed. Both counter and stream are initialized
+        /// to zero but may be set via the `set_word_pos` and `set_stream` methods.
+        ///
+        /// The word layout is:
+        ///
+        /// ```text
+        /// constant  constant  constant  constant
+        /// seed      seed      seed      seed
+        /// seed      seed      seed      seed
+        /// counter   counter   stream_id stream_id
+        /// ```
+        ///
+        /// This implementation uses an output buffer of sixteen `u32` words, and uses
+        /// [`BlockRng`] to implement the [`RngCore`] methods.
+        ///
+        /// [^1]: D. J. Bernstein, [*ChaCha, a variant of Salsa20*](
+        ///       https://cr.yp.to/chacha.html)
+        ///
+        /// [^2]: [eSTREAM: the ECRYPT Stream Cipher Project](
+        ///       http://www.ecrypt.eu.org/stream/)
+        #[derive(Clone, Debug)]
+        pub struct $ChaChaXRng {
+            rng: BlockRng<$ChaChaXCore>,
+        }
+
+        impl SeedableRng for $ChaChaXRng {
+            type Seed = [u8; 32];
+            #[inline]
+            fn from_seed(seed: Self::Seed) -> Self {
+                let core = $ChaChaXCore::from_seed(seed);
+                Self {
+                    rng: BlockRng::new(core),
+                }
+            }
+        }
+
+        impl RngCore for $ChaChaXRng {
+            #[inline]
+            fn next_u32(&mut self) -> u32 {
+                self.rng.next_u32()
+            }
+            #[inline]
+            fn next_u64(&mut self) -> u64 {
+                self.rng.next_u64()
+            }
+            #[inline]
+            fn fill_bytes(&mut self, bytes: &mut [u8]) {
+                self.rng.fill_bytes(bytes)
+            }
+            #[inline]
+            fn try_fill_bytes(&mut self, bytes: &mut [u8]) -> Result<(), Error> {
+                self.rng.try_fill_bytes(bytes)
+            }
+        }
+
+        impl $ChaChaXRng {
+            // The buffer is a 4-block window, i.e. it is always at a block-aligned position in the
+            // stream but if the stream has been seeked it may not be self-aligned.
+
+            /// Get the offset from the start of the stream, in 32-bit words.
+            ///
+            /// Since the generated blocks are 16 words (2<sup>4</sup>) long and the
+            /// counter is 64-bits, the offset is a 68-bit number. Sub-word offsets are
+            /// not supported, hence the result can simply be multiplied by 4 to get a
+            /// byte-offset.
+            #[inline]
+            pub fn get_word_pos(&self) -> u128 {
+                let buf_start_block = {
+                    let buf_end_block = self.rng.core.state.get_block_pos();
+                    u64::wrapping_sub(buf_end_block, BUF_BLOCKS.into())
+                };
+                let (buf_offset_blocks, block_offset_words) = {
+                    let buf_offset_words = self.rng.index() as u64;
+                    let blocks_part = buf_offset_words / u64::from(BLOCK_WORDS);
+                    let words_part = buf_offset_words % u64::from(BLOCK_WORDS);
+                    (blocks_part, words_part)
+                };
+                let pos_block = u64::wrapping_add(buf_start_block, buf_offset_blocks);
+                let pos_block_words = u128::from(pos_block) * u128::from(BLOCK_WORDS);
+                pos_block_words + u128::from(block_offset_words)
+            }
+
+            /// Set the offset from the start of the stream, in 32-bit words.
+            ///
+            /// As with `get_word_pos`, we use a 68-bit number. Since the generator
+            /// simply cycles at the end of its period (1 ZiB), we ignore the upper
+            /// 60 bits.
+            #[inline]
+            pub fn set_word_pos(&mut self, word_offset: u128) {
+                let block = (word_offset / u128::from(BLOCK_WORDS)) as u64;
+                self.rng
+                    .core
+                    .state
+                    .set_block_pos(block);
+                self.rng.generate_and_set((word_offset % u128::from(BLOCK_WORDS)) as usize);
+            }
+
+            /// Set the stream number.
+            ///
+            /// This is initialized to zero; 2<sup>64</sup> unique streams of output
+            /// are available per seed/key.
+            ///
+            /// Note that in order to reproduce ChaCha output with a specific 64-bit
+            /// nonce, one can convert that nonce to a `u64` in little-endian fashion
+            /// and pass to this function. In theory a 96-bit nonce can be used by
+            /// passing the last 64-bits to this function and using the first 32-bits as
+            /// the most significant half of the 64-bit counter (which may be set
+            /// indirectly via `set_word_pos`), but this is not directly supported.
+            #[inline]
+            pub fn set_stream(&mut self, stream: u64) {
+                self.rng
+                    .core
+                    .state
+                    .set_nonce(stream);
+                if self.rng.index() != 64 {
+                    let wp = self.get_word_pos();
+                    self.set_word_pos(wp);
+                }
+            }
+
+            /// Get the stream number.
+            #[inline]
+            pub fn get_stream(&self) -> u64 {
+                self.rng
+                    .core
+                    .state
+                    .get_nonce()
+            }
+
+            /// Get the seed.
+            #[inline]
+            pub fn get_seed(&self) -> [u8; 32] {
+                self.rng
+                    .core
+                    .state
+                    .get_seed()
+            }
+        }
+
+        impl CryptoRng for $ChaChaXRng {}
+
+        impl From<$ChaChaXCore> for $ChaChaXRng {
+            fn from(core: $ChaChaXCore) -> Self {
+                $ChaChaXRng {
+                    rng: BlockRng::new(core),
+                }
+            }
+        }
+
+        impl PartialEq<$ChaChaXRng> for $ChaChaXRng {
+            fn eq(&self, rhs: &$ChaChaXRng) -> bool {
+                let a: $abst::$ChaChaXRng = self.into();
+                let b: $abst::$ChaChaXRng = rhs.into();
+                a == b
+            }
+        }
+        impl Eq for $ChaChaXRng {}
+
+        #[cfg(feature = "serde1")]
+        impl Serialize for $ChaChaXRng {
+            fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
+            where S: Serializer {
+                $abst::$ChaChaXRng::from(self).serialize(s)
+            }
+        }
+        #[cfg(feature = "serde1")]
+        impl<'de> Deserialize<'de> for $ChaChaXRng {
+            fn deserialize<D>(d: D) -> Result<Self, D::Error> where D: Deserializer<'de> {
+                $abst::$ChaChaXRng::deserialize(d).map(|x| Self::from(&x))
+            }
+        }
+
+        mod $abst {
+            #[cfg(feature = "serde1")] use serde::{Serialize, Deserialize};
+
+            // The abstract state of a ChaCha stream, independent of implementation choices. The
+            // comparison and serialization of this object is considered a semver-covered part of
+            // the API.
+            #[derive(Debug, PartialEq, Eq)]
+            #[cfg_attr(
+                feature = "serde1",
+                derive(Serialize, Deserialize),
+            )]
+            pub(crate) struct $ChaChaXRng {
+                seed: [u8; 32],
+                stream: u64,
+                word_pos: u128,
+            }
+
+            impl From<&super::$ChaChaXRng> for $ChaChaXRng {
+                // Forget all information about the input except what is necessary to determine the
+                // outputs of any sequence of pub API calls.
+                fn from(r: &super::$ChaChaXRng) -> Self {
+                    Self {
+                        seed: r.get_seed(),
+                        stream: r.get_stream(),
+                        word_pos: r.get_word_pos(),
+                    }
+                }
+            }
+
+            impl From<&$ChaChaXRng> for super::$ChaChaXRng {
+                // Construct one of the possible concrete RNGs realizing an abstract state.
+                fn from(a: &$ChaChaXRng) -> Self {
+                    use rand_core::SeedableRng;
+                    let mut r = Self::from_seed(a.seed);
+                    r.set_stream(a.stream);
+                    r.set_word_pos(a.word_pos);
+                    r
+                }
+            }
+        }
+    }
+}
+
+chacha_impl!(ChaCha20Core, ChaCha20Rng, 10, "ChaCha with 20 rounds", abstract20);
+chacha_impl!(ChaCha12Core, ChaCha12Rng, 6, "ChaCha with 12 rounds", abstract12);
+chacha_impl!(ChaCha8Core, ChaCha8Rng, 4, "ChaCha with 8 rounds", abstract8);
+
+#[cfg(test)]
+mod test {
+    use rand_core::{RngCore, SeedableRng};
+
+    #[cfg(feature = "serde1")] use super::{ChaCha20Rng, ChaCha12Rng, ChaCha8Rng};
+
+    type ChaChaRng = super::ChaCha20Rng;
+
+    #[cfg(feature = "serde1")]
+    #[test]
+    fn test_chacha_serde_roundtrip() {
+        let seed = [
+            1, 0, 52, 0, 0, 0, 0, 0, 1, 0, 10, 0, 22, 32, 0, 0, 2, 0, 55, 49, 0, 11, 0, 0, 3, 0, 0, 0, 0,
+            0, 2, 92,
+        ];
+        let mut rng1 = ChaCha20Rng::from_seed(seed);
+        let mut rng2 = ChaCha12Rng::from_seed(seed);
+        let mut rng3 = ChaCha8Rng::from_seed(seed);
+
+        let encoded1 = serde_json::to_string(&rng1).unwrap();
+        let encoded2 = serde_json::to_string(&rng2).unwrap();
+        let encoded3 = serde_json::to_string(&rng3).unwrap();
+
+        let mut decoded1: ChaCha20Rng = serde_json::from_str(&encoded1).unwrap();
+        let mut decoded2: ChaCha12Rng = serde_json::from_str(&encoded2).unwrap();
+        let mut decoded3: ChaCha8Rng = serde_json::from_str(&encoded3).unwrap();
+
+        assert_eq!(rng1, decoded1);
+        assert_eq!(rng2, decoded2);
+        assert_eq!(rng3, decoded3);
+
+        assert_eq!(rng1.next_u32(), decoded1.next_u32());
+        assert_eq!(rng2.next_u32(), decoded2.next_u32());
+        assert_eq!(rng3.next_u32(), decoded3.next_u32());
+    }
+
+    // This test validates that:
+    // 1. a hard-coded serialization demonstrating the format at time of initial release can still
+    //    be deserialized to a ChaChaRng
+    // 2. re-serializing the resultant object produces exactly the original string
+    //
+    // Condition 2 is stronger than necessary: an equivalent serialization (e.g. with field order
+    // permuted, or whitespace differences) would also be admissible, but would fail this test.
+    // However testing for equivalence of serialized data is difficult, and there shouldn't be any
+    // reason we need to violate the stronger-than-needed condition, e.g. by changing the field
+    // definition order.
+    #[cfg(feature = "serde1")]
+    #[test]
+    fn test_chacha_serde_format_stability() {
+        let j = r#"{"seed":[4,8,15,16,23,42,4,8,15,16,23,42,4,8,15,16,23,42,4,8,15,16,23,42,4,8,15,16,23,42,4,8],"stream":27182818284,"word_pos":314159265359}"#;
+        let r: ChaChaRng = serde_json::from_str(&j).unwrap();
+        let j1 = serde_json::to_string(&r).unwrap();
+        assert_eq!(j, j1);
+    }
+
+    #[test]
+    fn test_chacha_construction() {
+        let seed = [
+            0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0,
+            0, 0, 0,
+        ];
+        let mut rng1 = ChaChaRng::from_seed(seed);
+        assert_eq!(rng1.next_u32(), 137206642);
+
+        let mut rng2 = ChaChaRng::from_rng(rng1).unwrap();
+        assert_eq!(rng2.next_u32(), 1325750369);
+    }
+
+    #[test]
+    fn test_chacha_true_values_a() {
+        // Test vectors 1 and 2 from
+        // https://tools.ietf.org/html/draft-nir-cfrg-chacha20-poly1305-04
+        let seed = [0u8; 32];
+        let mut rng = ChaChaRng::from_seed(seed);
+
+        let mut results = [0u32; 16];
+        for i in results.iter_mut() {
+            *i = rng.next_u32();
+        }
+        let expected = [
+            0xade0b876, 0x903df1a0, 0xe56a5d40, 0x28bd8653, 0xb819d2bd, 0x1aed8da0, 0xccef36a8,
+            0xc70d778b, 0x7c5941da, 0x8d485751, 0x3fe02477, 0x374ad8b8, 0xf4b8436a, 0x1ca11815,
+            0x69b687c3, 0x8665eeb2,
+        ];
+        assert_eq!(results, expected);
+
+        for i in results.iter_mut() {
+            *i = rng.next_u32();
+        }
+        let expected = [
+            0xbee7079f, 0x7a385155, 0x7c97ba98, 0x0d082d73, 0xa0290fcb, 0x6965e348, 0x3e53c612,
+            0xed7aee32, 0x7621b729, 0x434ee69c, 0xb03371d5, 0xd539d874, 0x281fed31, 0x45fb0a51,
+            0x1f0ae1ac, 0x6f4d794b,
+        ];
+        assert_eq!(results, expected);
+    }
+
+    #[test]
+    fn test_chacha_true_values_b() {
+        // Test vector 3 from
+        // https://tools.ietf.org/html/draft-nir-cfrg-chacha20-poly1305-04
+        let seed = [
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 1,
+        ];
+        let mut rng = ChaChaRng::from_seed(seed);
+
+        // Skip block 0
+        for _ in 0..16 {
+            rng.next_u32();
+        }
+
+        let mut results = [0u32; 16];
+        for i in results.iter_mut() {
+            *i = rng.next_u32();
+        }
+        let expected = [
+            0x2452eb3a, 0x9249f8ec, 0x8d829d9b, 0xddd4ceb1, 0xe8252083, 0x60818b01, 0xf38422b8,
+            0x5aaa49c9, 0xbb00ca8e, 0xda3ba7b4, 0xc4b592d1, 0xfdf2732f, 0x4436274e, 0x2561b3c8,
+            0xebdd4aa6, 0xa0136c00,
+        ];
+        assert_eq!(results, expected);
+    }
+
+    #[test]
+    fn test_chacha_true_values_c() {
+        // Test vector 4 from
+        // https://tools.ietf.org/html/draft-nir-cfrg-chacha20-poly1305-04
+        let seed = [
+            0, 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0,
+        ];
+        let expected = [
+            0xfb4dd572, 0x4bc42ef1, 0xdf922636, 0x327f1394, 0xa78dea8f, 0x5e269039, 0xa1bebbc1,
+            0xcaf09aae, 0xa25ab213, 0x48a6b46c, 0x1b9d9bcb, 0x092c5be6, 0x546ca624, 0x1bec45d5,
+            0x87f47473, 0x96f0992e,
+        ];
+        let expected_end = 3 * 16;
+        let mut results = [0u32; 16];
+
+        // Test block 2 by skipping block 0 and 1
+        let mut rng1 = ChaChaRng::from_seed(seed);
+        for _ in 0..32 {
+            rng1.next_u32();
+        }
+        for i in results.iter_mut() {
+            *i = rng1.next_u32();
+        }
+        assert_eq!(results, expected);
+        assert_eq!(rng1.get_word_pos(), expected_end);
+
+        // Test block 2 by using `set_word_pos`
+        let mut rng2 = ChaChaRng::from_seed(seed);
+        rng2.set_word_pos(2 * 16);
+        for i in results.iter_mut() {
+            *i = rng2.next_u32();
+        }
+        assert_eq!(results, expected);
+        assert_eq!(rng2.get_word_pos(), expected_end);
+
+        // Test skipping behaviour with other types
+        let mut buf = [0u8; 32];
+        rng2.fill_bytes(&mut buf[..]);
+        assert_eq!(rng2.get_word_pos(), expected_end + 8);
+        rng2.fill_bytes(&mut buf[0..25]);
+        assert_eq!(rng2.get_word_pos(), expected_end + 15);
+        rng2.next_u64();
+        assert_eq!(rng2.get_word_pos(), expected_end + 17);
+        rng2.next_u32();
+        rng2.next_u64();
+        assert_eq!(rng2.get_word_pos(), expected_end + 20);
+        rng2.fill_bytes(&mut buf[0..1]);
+        assert_eq!(rng2.get_word_pos(), expected_end + 21);
+    }
+
+    #[test]
+    fn test_chacha_multiple_blocks() {
+        let seed = [
+            0, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 4, 0, 0, 0, 5, 0, 0, 0, 6, 0, 0, 0, 7,
+            0, 0, 0,
+        ];
+        let mut rng = ChaChaRng::from_seed(seed);
+
+        // Store the 17*i-th 32-bit word,
+        // i.e., the i-th word of the i-th 16-word block
+        let mut results = [0u32; 16];
+        for i in results.iter_mut() {
+            *i = rng.next_u32();
+            for _ in 0..16 {
+                rng.next_u32();
+            }
+        }
+        let expected = [
+            0xf225c81a, 0x6ab1be57, 0x04d42951, 0x70858036, 0x49884684, 0x64efec72, 0x4be2d186,
+            0x3615b384, 0x11cfa18e, 0xd3c50049, 0x75c775f6, 0x434c6530, 0x2c5bad8f, 0x898881dc,
+            0x5f1c86d9, 0xc1f8e7f4,
+        ];
+        assert_eq!(results, expected);
+    }
+
+    #[test]
+    fn test_chacha_true_bytes() {
+        let seed = [0u8; 32];
+        let mut rng = ChaChaRng::from_seed(seed);
+        let mut results = [0u8; 32];
+        rng.fill_bytes(&mut results);
+        let expected = [
+            118, 184, 224, 173, 160, 241, 61, 144, 64, 93, 106, 229, 83, 134, 189, 40, 189, 210,
+            25, 184, 160, 141, 237, 26, 168, 54, 239, 204, 139, 119, 13, 199,
+        ];
+        assert_eq!(results, expected);
+    }
+
+    #[test]
+    fn test_chacha_nonce() {
+        // Test vector 5 from
+        // https://tools.ietf.org/html/draft-nir-cfrg-chacha20-poly1305-04
+        // Although we do not support setting a nonce, we try it here anyway so
+        // we can use this test vector.
+        let seed = [0u8; 32];
+        let mut rng = ChaChaRng::from_seed(seed);
+        // 96-bit nonce in LE order is: 0,0,0,0, 0,0,0,0, 0,0,0,2
+        rng.set_stream(2u64 << (24 + 32));
+
+        let mut results = [0u32; 16];
+        for i in results.iter_mut() {
+            *i = rng.next_u32();
+        }
+        let expected = [
+            0x374dc6c2, 0x3736d58c, 0xb904e24a, 0xcd3f93ef, 0x88228b1a, 0x96a4dfb3, 0x5b76ab72,
+            0xc727ee54, 0x0e0e978a, 0xf3145c95, 0x1b748ea8, 0xf786c297, 0x99c28f5f, 0x628314e8,
+            0x398a19fa, 0x6ded1b53,
+        ];
+        assert_eq!(results, expected);
+    }
+
+    #[test]
+    fn test_chacha_clone_streams() {
+        let seed = [
+            0, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 4, 0, 0, 0, 5, 0, 0, 0, 6, 0, 0, 0, 7,
+            0, 0, 0,
+        ];
+        let mut rng = ChaChaRng::from_seed(seed);
+        let mut clone = rng.clone();
+        for _ in 0..16 {
+            assert_eq!(rng.next_u64(), clone.next_u64());
+        }
+
+        rng.set_stream(51);
+        for _ in 0..7 {
+            assert!(rng.next_u32() != clone.next_u32());
+        }
+        clone.set_stream(51); // switch part way through block
+        for _ in 7..16 {
+            assert_eq!(rng.next_u32(), clone.next_u32());
+        }
+    }
+
+    #[test]
+    fn test_chacha_word_pos_wrap_exact() {
+        use super::{BUF_BLOCKS, BLOCK_WORDS};
+        let mut rng = ChaChaRng::from_seed(Default::default());
+        // refilling the buffer in set_word_pos will wrap the block counter to 0
+        let last_block = (1 << 68) - u128::from(BUF_BLOCKS * BLOCK_WORDS);
+        rng.set_word_pos(last_block);
+        assert_eq!(rng.get_word_pos(), last_block);
+    }
+
+    #[test]
+    fn test_chacha_word_pos_wrap_excess() {
+        use super::BLOCK_WORDS;
+        let mut rng = ChaChaRng::from_seed(Default::default());
+        // refilling the buffer in set_word_pos will wrap the block counter past 0
+        let last_block = (1 << 68) - u128::from(BLOCK_WORDS);
+        rng.set_word_pos(last_block);
+        assert_eq!(rng.get_word_pos(), last_block);
+    }
+
+    #[test]
+    fn test_chacha_word_pos_zero() {
+        let mut rng = ChaChaRng::from_seed(Default::default());
+        assert_eq!(rng.get_word_pos(), 0);
+        rng.set_word_pos(0);
+        assert_eq!(rng.get_word_pos(), 0);
+    }
+}
diff --git a/crates/rand_chacha/src/guts.rs b/crates/rand_chacha/src/guts.rs
new file mode 100644
index 0000000..cee8cf7
--- /dev/null
+++ b/crates/rand_chacha/src/guts.rs
@@ -0,0 +1,273 @@
+// Copyright 2019 The CryptoCorrosion Contributors
+// Copyright 2020 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! The ChaCha random number generator.
+
+use ppv_lite86::{dispatch, dispatch_light128};
+
+pub use ppv_lite86::Machine;
+use ppv_lite86::{vec128_storage, ArithOps, BitOps32, LaneWords4, MultiLane, StoreBytes, Vec4};
+
+pub(crate) const BLOCK: usize = 64;
+pub(crate) const BLOCK64: u64 = BLOCK as u64;
+const LOG2_BUFBLOCKS: u64 = 2;
+const BUFBLOCKS: u64 = 1 << LOG2_BUFBLOCKS;
+pub(crate) const BUFSZ64: u64 = BLOCK64 * BUFBLOCKS;
+pub(crate) const BUFSZ: usize = BUFSZ64 as usize;
+
+const STREAM_PARAM_NONCE: u32 = 1;
+const STREAM_PARAM_BLOCK: u32 = 0;
+
+#[derive(Clone, PartialEq, Eq)]
+pub struct ChaCha {
+    pub(crate) b: vec128_storage,
+    pub(crate) c: vec128_storage,
+    pub(crate) d: vec128_storage,
+}
+
+#[derive(Clone)]
+pub struct State<V> {
+    pub(crate) a: V,
+    pub(crate) b: V,
+    pub(crate) c: V,
+    pub(crate) d: V,
+}
+
+#[inline(always)]
+pub(crate) fn round<V: ArithOps + BitOps32>(mut x: State<V>) -> State<V> {
+    x.a += x.b;
+    x.d = (x.d ^ x.a).rotate_each_word_right16();
+    x.c += x.d;
+    x.b = (x.b ^ x.c).rotate_each_word_right20();
+    x.a += x.b;
+    x.d = (x.d ^ x.a).rotate_each_word_right24();
+    x.c += x.d;
+    x.b = (x.b ^ x.c).rotate_each_word_right25();
+    x
+}
+
+#[inline(always)]
+pub(crate) fn diagonalize<V: LaneWords4>(mut x: State<V>) -> State<V> {
+    x.b = x.b.shuffle_lane_words3012();
+    x.c = x.c.shuffle_lane_words2301();
+    x.d = x.d.shuffle_lane_words1230();
+    x
+}
+#[inline(always)]
+pub(crate) fn undiagonalize<V: LaneWords4>(mut x: State<V>) -> State<V> {
+    x.b = x.b.shuffle_lane_words1230();
+    x.c = x.c.shuffle_lane_words2301();
+    x.d = x.d.shuffle_lane_words3012();
+    x
+}
+
+impl ChaCha {
+    #[inline(always)]
+    pub fn new(key: &[u8; 32], nonce: &[u8]) -> Self {
+        init_chacha(key, nonce)
+    }
+
+    #[inline(always)]
+    fn pos64<M: Machine>(&self, m: M) -> u64 {
+        let d: M::u32x4 = m.unpack(self.d);
+        ((d.extract(1) as u64) << 32) | d.extract(0) as u64
+    }
+
+    /// Produce 4 blocks of output, advancing the state
+    #[inline(always)]
+    pub fn refill4(&mut self, drounds: u32, out: &mut [u8; BUFSZ]) {
+        refill_wide(self, drounds, out)
+    }
+
+    #[inline(always)]
+    pub fn set_block_pos(&mut self, value: u64) {
+        set_stream_param(self, STREAM_PARAM_BLOCK, value)
+    }
+
+    #[inline(always)]
+    pub fn get_block_pos(&self) -> u64 {
+        get_stream_param(self, STREAM_PARAM_BLOCK)
+    }
+
+    #[inline(always)]
+    pub fn set_nonce(&mut self, value: u64) {
+        set_stream_param(self, STREAM_PARAM_NONCE, value)
+    }
+
+    #[inline(always)]
+    pub fn get_nonce(&self) -> u64 {
+        get_stream_param(self, STREAM_PARAM_NONCE)
+    }
+
+    #[inline(always)]
+    pub fn get_seed(&self) -> [u8; 32] {
+        get_seed(self)
+    }
+}
+
+#[allow(clippy::many_single_char_names)]
+#[inline(always)]
+fn refill_wide_impl<Mach: Machine>(
+    m: Mach, state: &mut ChaCha, drounds: u32, out: &mut [u8; BUFSZ],
+) {
+    let k = m.vec([0x6170_7865, 0x3320_646e, 0x7962_2d32, 0x6b20_6574]);
+    let mut pos = state.pos64(m);
+    let d0: Mach::u32x4 = m.unpack(state.d);
+    pos = pos.wrapping_add(1);
+    let d1 = d0.insert((pos >> 32) as u32, 1).insert(pos as u32, 0);
+    pos = pos.wrapping_add(1);
+    let d2 = d0.insert((pos >> 32) as u32, 1).insert(pos as u32, 0);
+    pos = pos.wrapping_add(1);
+    let d3 = d0.insert((pos >> 32) as u32, 1).insert(pos as u32, 0);
+
+    let b = m.unpack(state.b);
+    let c = m.unpack(state.c);
+    let mut x = State {
+        a: Mach::u32x4x4::from_lanes([k, k, k, k]),
+        b: Mach::u32x4x4::from_lanes([b, b, b, b]),
+        c: Mach::u32x4x4::from_lanes([c, c, c, c]),
+        d: m.unpack(Mach::u32x4x4::from_lanes([d0, d1, d2, d3]).into()),
+    };
+    for _ in 0..drounds {
+        x = round(x);
+        x = undiagonalize(round(diagonalize(x)));
+    }
+    let mut pos = state.pos64(m);
+    let d0: Mach::u32x4 = m.unpack(state.d);
+    pos = pos.wrapping_add(1);
+    let d1 = d0.insert((pos >> 32) as u32, 1).insert(pos as u32, 0);
+    pos = pos.wrapping_add(1);
+    let d2 = d0.insert((pos >> 32) as u32, 1).insert(pos as u32, 0);
+    pos = pos.wrapping_add(1);
+    let d3 = d0.insert((pos >> 32) as u32, 1).insert(pos as u32, 0);
+    pos = pos.wrapping_add(1);
+    let d4 = d0.insert((pos >> 32) as u32, 1).insert(pos as u32, 0);
+
+    let (a, b, c, d) = (
+        x.a.to_lanes(),
+        x.b.to_lanes(),
+        x.c.to_lanes(),
+        x.d.to_lanes(),
+    );
+    let sb = m.unpack(state.b);
+    let sc = m.unpack(state.c);
+    let sd = [m.unpack(state.d), d1, d2, d3];
+    state.d = d4.into();
+    let mut words = out.chunks_exact_mut(16);
+    for ((((&a, &b), &c), &d), &sd) in a.iter().zip(&b).zip(&c).zip(&d).zip(&sd) {
+        (a + k).write_le(words.next().unwrap());
+        (b + sb).write_le(words.next().unwrap());
+        (c + sc).write_le(words.next().unwrap());
+        (d + sd).write_le(words.next().unwrap());
+    }
+}
+
+dispatch!(m, Mach, {
+    fn refill_wide(state: &mut ChaCha, drounds: u32, out: &mut [u8; BUFSZ]) {
+        refill_wide_impl(m, state, drounds, out);
+    }
+});
+
+// Single-block, rounds-only; shared by try_apply_keystream for tails shorter than BUFSZ
+// and XChaCha's setup step.
+dispatch!(m, Mach, {
+    fn refill_narrow_rounds(state: &mut ChaCha, drounds: u32) -> State<vec128_storage> {
+        let k: Mach::u32x4 = m.vec([0x6170_7865, 0x3320_646e, 0x7962_2d32, 0x6b20_6574]);
+        let mut x = State {
+            a: k,
+            b: m.unpack(state.b),
+            c: m.unpack(state.c),
+            d: m.unpack(state.d),
+        };
+        for _ in 0..drounds {
+            x = round(x);
+            x = undiagonalize(round(diagonalize(x)));
+        }
+        State {
+            a: x.a.into(),
+            b: x.b.into(),
+            c: x.c.into(),
+            d: x.d.into(),
+        }
+    }
+});
+
+dispatch_light128!(m, Mach, {
+    fn set_stream_param(state: &mut ChaCha, param: u32, value: u64) {
+        let d: Mach::u32x4 = m.unpack(state.d);
+        state.d = d
+            .insert((value >> 32) as u32, (param << 1) | 1)
+            .insert(value as u32, param << 1)
+            .into();
+    }
+});
+
+dispatch_light128!(m, Mach, {
+    fn get_stream_param(state: &ChaCha, param: u32) -> u64 {
+        let d: Mach::u32x4 = m.unpack(state.d);
+        ((d.extract((param << 1) | 1) as u64) << 32) | d.extract(param << 1) as u64
+    }
+});
+
+dispatch_light128!(m, Mach, {
+    fn get_seed(state: &ChaCha) -> [u8; 32] {
+        let b: Mach::u32x4 = m.unpack(state.b);
+        let c: Mach::u32x4 = m.unpack(state.c);
+        let mut key = [0u8; 32];
+        b.write_le(&mut key[..16]);
+        c.write_le(&mut key[16..]);
+        key
+    }
+});
+
+fn read_u32le(xs: &[u8]) -> u32 {
+    assert_eq!(xs.len(), 4);
+    u32::from(xs[0]) | (u32::from(xs[1]) << 8) | (u32::from(xs[2]) << 16) | (u32::from(xs[3]) << 24)
+}
+
+dispatch_light128!(m, Mach, {
+    fn init_chacha(key: &[u8; 32], nonce: &[u8]) -> ChaCha {
+        let ctr_nonce = [
+            0,
+            if nonce.len() == 12 {
+                read_u32le(&nonce[0..4])
+            } else {
+                0
+            },
+            read_u32le(&nonce[nonce.len() - 8..nonce.len() - 4]),
+            read_u32le(&nonce[nonce.len() - 4..]),
+        ];
+        let key0: Mach::u32x4 = m.read_le(&key[..16]);
+        let key1: Mach::u32x4 = m.read_le(&key[16..]);
+        ChaCha {
+            b: key0.into(),
+            c: key1.into(),
+            d: ctr_nonce.into(),
+        }
+    }
+});
+
+dispatch_light128!(m, Mach, {
+    fn init_chacha_x(key: &[u8; 32], nonce: &[u8; 24], rounds: u32) -> ChaCha {
+        let key0: Mach::u32x4 = m.read_le(&key[..16]);
+        let key1: Mach::u32x4 = m.read_le(&key[16..]);
+        let nonce0: Mach::u32x4 = m.read_le(&nonce[..16]);
+        let mut state = ChaCha {
+            b: key0.into(),
+            c: key1.into(),
+            d: nonce0.into(),
+        };
+        let x = refill_narrow_rounds(&mut state, rounds);
+        let ctr_nonce1 = [0, 0, read_u32le(&nonce[16..20]), read_u32le(&nonce[20..24])];
+        state.b = x.a;
+        state.c = x.d;
+        state.d = ctr_nonce1.into();
+        state
+    }
+});
diff --git a/crates/rand_chacha/src/lib.rs b/crates/rand_chacha/src/lib.rs
new file mode 100644
index 0000000..24125b4
--- /dev/null
+++ b/crates/rand_chacha/src/lib.rs
@@ -0,0 +1,33 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! The ChaCha random number generator.
+
+#![doc(
+    html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk.png",
+    html_favicon_url = "https://www.rust-lang.org/favicon.ico",
+    html_root_url = "https://rust-random.github.io/rand/"
+)]
+#![deny(missing_docs)]
+#![deny(missing_debug_implementations)]
+#![doc(test(attr(allow(unused_variables), deny(warnings))))]
+#![cfg_attr(not(feature = "std"), no_std)]
+
+pub use rand_core;
+
+mod chacha;
+mod guts;
+
+pub use crate::chacha::{
+    ChaCha12Core, ChaCha12Rng, ChaCha20Core, ChaCha20Rng, ChaCha8Core, ChaCha8Rng,
+};
+
+/// ChaCha with 20 rounds
+pub type ChaChaRng = ChaCha20Rng;
+/// ChaCha with 20 rounds, low-level interface
+pub type ChaChaCore = ChaCha20Core;
diff --git a/crates/rand_core/.cargo-checksum.json b/crates/rand_core/.cargo-checksum.json
new file mode 100644
index 0000000..067463e
--- /dev/null
+++ b/crates/rand_core/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"CHANGELOG.md":"a33a4318dd822ef757ec79c5e6027d50d9feee5c40f85d9aadf0f598eb7ef1b7","COPYRIGHT":"90eb64f0279b0d9432accfa6023ff803bc4965212383697eee27a0f426d5f8d5","Cargo.toml":"4a6762f8364d1a60f1436f4ba7d710de22465722340d2028101fcbd68e89396f","LICENSE-APACHE":"6df43f6f4b5d4587f3d8d71e45532c688fd168afa5fe89d571cb32fa09c4ef51","LICENSE-MIT":"209fbbe0ad52d9235e37badf9cadfe4dbdc87203179c0899e738b39ade42177b","README.md":"bb3bd3831adc9eaabbcea108ab7f02f5837e9d2f81e872ffd7d340ad466df4de","src/block.rs":"c0b606dc404a1f4b25eebf388e9c0da583ee571214cdcb0bac1b592450d6b4fa","src/error.rs":"c34af905a9ffbae65970f508a9e74480b56747128d05ad350475150898fc6452","src/impls.rs":"b861532f8a3500de6bd0e926b3677a15261df4b12d253e4a8fd6acc5e64f1d36","src/le.rs":"f302239d09cc8d915aa8d4fe46c32c8981900cb20d42b12eef9c34e2e820bc88","src/lib.rs":"df270489b859465fce144098d5e709b318d9f3b703a92f4a28e5f74334119107","src/os.rs":"47849479e19c43dd01259eb14be7b4daf8474d23567dc32a1547c10b108b7069"},"package":"ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"}
\ No newline at end of file
diff --git a/crates/rand_core/Android.bp b/crates/rand_core/Android.bp
new file mode 100644
index 0000000..ca8fdc1
--- /dev/null
+++ b/crates/rand_core/Android.bp
@@ -0,0 +1,57 @@
+// This file is generated by cargo_embargo.
+// Do not modify this file because the changes will be overridden on upgrade.
+
+package {
+    default_applicable_licenses: ["external_rust_crates_rand_core_license"],
+    default_team: "trendy_team_android_rust",
+}
+
+license {
+    name: "external_rust_crates_rand_core_license",
+    visibility: [":__subpackages__"],
+    license_kinds: ["SPDX-license-identifier-Apache-2.0"],
+    license_text: ["LICENSE"],
+}
+
+rust_library {
+    name: "librand_core",
+    host_supported: true,
+    crate_name: "rand_core",
+    cargo_env_compat: true,
+    cargo_pkg_version: "0.6.4",
+    crate_root: "src/lib.rs",
+    edition: "2018",
+    features: [
+        "alloc",
+        "getrandom",
+        "std",
+    ],
+    rustlibs: ["libgetrandom"],
+    apex_available: [
+        "//apex_available:platform",
+        "//apex_available:anyapex",
+    ],
+    product_available: true,
+    vendor_available: true,
+}
+
+rust_test {
+    name: "rand_core_test_src_lib",
+    host_supported: true,
+    crate_name: "rand_core",
+    cargo_env_compat: true,
+    cargo_pkg_version: "0.6.4",
+    crate_root: "src/lib.rs",
+    test_suites: ["general-tests"],
+    auto_gen_config: true,
+    test_options: {
+        unit_test: true,
+    },
+    edition: "2018",
+    features: [
+        "alloc",
+        "getrandom",
+        "std",
+    ],
+    rustlibs: ["libgetrandom"],
+}
diff --git a/crates/rand_core/CHANGELOG.md b/crates/rand_core/CHANGELOG.md
new file mode 100644
index 0000000..75fcbc6
--- /dev/null
+++ b/crates/rand_core/CHANGELOG.md
@@ -0,0 +1,94 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.6.4] - 2022-09-15
+- Fix unsoundness in `<BlockRng64 as RngCore>::next_u32` (#1160)
+- Reduce use of `unsafe` and improve gen_bytes performance (#1180)
+- Add `CryptoRngCore` trait (#1187, #1230)
+
+## [0.6.3] - 2021-06-15
+### Changed
+- Improved bound for `serde` impls on `BlockRng` (#1130)
+- Minor doc additions (#1118)
+
+## [0.6.2] - 2021-02-12
+### Fixed
+- Fixed assertions in `le::read_u32_into` and `le::read_u64_into` which could
+  have allowed buffers not to be fully populated (#1096)
+
+## [0.6.1] - 2021-01-03
+### Fixed
+- Avoid panic when using `RngCore::seed_from_u64` with a seed which is not a
+  multiple of four (#1082)
+### Other
+- Enable all stable features in the playground (#1081)
+
+## [0.6.0] - 2020-12-08
+### Breaking changes
+- Bump MSRV to 1.36, various code improvements (#1011)
+- Update to getrandom v0.2 (#1041)
+- Fix: `next_u32_via_fill` and `next_u64_via_fill` now use LE as documented (#1061)
+
+### Other
+- Reduce usage of `unsafe` (#962, #963, #1011)
+- Annotate feature-gates in documentation (#1019)
+- Document available error codes (#1061)
+- Various documentation tweaks
+- Fix some clippy warnings (#1036)
+- Apply rustfmt (#926)
+
+## [0.5.1] - 2019-08-28
+- `OsRng` added to `rand_core` (#863)
+- `Error::INTERNAL_START` and `Error::CUSTOM_START` constants (#864)
+- `Error::raw_os_error` method (#864)
+- `Debug` and `Display` formatting for `getrandom` error codes without `std` (#864)
+### Changed
+- `alloc` feature in `no_std` is available since Rust 1.36 (#856)
+- Added `#[inline]` to `Error` conversion methods (#864)
+
+## [0.5.0] - 2019-06-06
+### Changed
+- Enable testing with Miri and fix incorrect pointer usages (#779, #780, #781, #783, #784)
+- Rewrite `Error` type and adjust API (#800)
+- Adjust usage of `#[inline]` for `BlockRng` and `BlockRng64`
+
+## [0.4.0] - 2019-01-24
+### Changed
+- Disable the `std` feature by default (#702)
+
+## [0.3.0] - 2018-09-24
+### Added
+- Add `SeedableRng::seed_from_u64` for convenient seeding. (#537)
+
+## [0.2.1] - 2018-06-08
+### Added
+- References to a `CryptoRng` now also implement `CryptoRng`. (#470)
+
+## [0.2.0] - 2018-05-21
+### Changed
+- Enable the `std` feature by default. (#409)
+- Remove `BlockRng{64}::inner` and `BlockRng::inner_mut`; instead making `core` public
+- Change `BlockRngCore::Results` bound to also require `AsMut<[Self::Item]>`. (#419)
+### Added
+- Add `BlockRng{64}::index` and `BlockRng{64}::generate_and_set`. (#374, #419)
+- Implement `std::io::Read` for RngCore. (#434)
+
+## [0.1.0] - 2018-04-17
+(Split out of the Rand crate, changes here are relative to rand 0.4.2.)
+### Added
+- `RngCore` and `SeedableRng` are now part of `rand_core`. (#288)
+- Add modules to help implementing RNGs `impl` and `le`. (#209, #228)
+- Add `Error` and `ErrorKind`. (#225)
+- Add `CryptoRng` marker trait. (#273)
+- Add `BlockRngCore` trait. (#281)
+- Add `BlockRng` and `BlockRng64` wrappers to help implementations. (#281, #325)
+- Add `RngCore::try_fill_bytes`. (#225)
+### Changed
+- Revise the `SeedableRng` trait. (#233)
+- Remove default implementations for `RngCore::next_u64` and `RngCore::fill_bytes`. (#288)
+
+## [0.0.1] - 2017-09-14 (yanked)
+Experimental version as part of the rand crate refactor.
diff --git a/crates/rand_core/COPYRIGHT b/crates/rand_core/COPYRIGHT
new file mode 100644
index 0000000..468d907
--- /dev/null
+++ b/crates/rand_core/COPYRIGHT
@@ -0,0 +1,12 @@
+Copyrights in the Rand project are retained by their contributors. No
+copyright assignment is required to contribute to the Rand project.
+
+For full authorship information, see the version control history.
+
+Except as otherwise noted (below and/or in individual files), Rand is
+licensed under the Apache License, Version 2.0 <LICENSE-APACHE> or
+<http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+<LICENSE-MIT> or <http://opensource.org/licenses/MIT>, at your option.
+
+The Rand project includes code from the Rust project
+published under these same licenses.
diff --git a/crates/rand_core/Cargo.lock b/crates/rand_core/Cargo.lock
new file mode 100644
index 0000000..bac295e
--- /dev/null
+++ b/crates/rand_core/Cargo.lock
@@ -0,0 +1,95 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "getrandom"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.158"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.86"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+dependencies = [
+ "getrandom",
+ "serde",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.209"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "99fce0ffe7310761ca6bf9faf5115afbc19688edd00171d81b1bb1b116c63e09"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.209"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5831b979fd7b5439637af1752d535ff49f4860c0f341d1baeb6faf0f4242170"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.76"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "578e081a14e0cefc3279b0472138c513f37b41a08d5a3cca9b6e4e8ceb6cd525"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
+
+[[package]]
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
diff --git a/crates/rand_core/Cargo.toml b/crates/rand_core/Cargo.toml
new file mode 100644
index 0000000..fd8c96d
--- /dev/null
+++ b/crates/rand_core/Cargo.toml
@@ -0,0 +1,63 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2018"
+name = "rand_core"
+version = "0.6.4"
+authors = [
+    "The Rand Project Developers",
+    "The Rust Project Developers",
+]
+description = """
+Core random number generator traits and tools for implementation.
+"""
+homepage = "https://rust-random.github.io/book"
+documentation = "https://docs.rs/rand_core"
+readme = "README.md"
+keywords = [
+    "random",
+    "rng",
+]
+categories = [
+    "algorithms",
+    "no-std",
+]
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/rust-random/rand"
+
+[package.metadata.docs.rs]
+all-features = true
+rustdoc-args = [
+    "--cfg",
+    "doc_cfg",
+]
+
+[package.metadata.playground]
+all-features = true
+
+[dependencies.getrandom]
+version = "0.2"
+optional = true
+
+[dependencies.serde]
+version = "1"
+features = ["derive"]
+optional = true
+
+[features]
+alloc = []
+serde1 = ["serde"]
+std = [
+    "alloc",
+    "getrandom",
+    "getrandom/std",
+]
diff --git a/crates/rand_core/LICENSE b/crates/rand_core/LICENSE
new file mode 120000
index 0000000..6b579aa
--- /dev/null
+++ b/crates/rand_core/LICENSE
@@ -0,0 +1 @@
+LICENSE-APACHE
\ No newline at end of file
diff --git a/crates/rand_core/LICENSE-APACHE b/crates/rand_core/LICENSE-APACHE
new file mode 100644
index 0000000..455787c
--- /dev/null
+++ b/crates/rand_core/LICENSE-APACHE
@@ -0,0 +1,187 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     https://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.
diff --git a/crates/rand_core/LICENSE-MIT b/crates/rand_core/LICENSE-MIT
new file mode 100644
index 0000000..d93b5ba
--- /dev/null
+++ b/crates/rand_core/LICENSE-MIT
@@ -0,0 +1,26 @@
+Copyright 2018 Developers of the Rand project
+Copyright (c) 2014 The Rust Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/crates/rand_core/METADATA b/crates/rand_core/METADATA
new file mode 100644
index 0000000..88a399e
--- /dev/null
+++ b/crates/rand_core/METADATA
@@ -0,0 +1,23 @@
+# This project was upgraded with external_updater.
+# Usage: tools/external_updater/updater.sh update rust/crates/rand_core
+# For more info, check https://cs.android.com/android/platform/superproject/+/master:tools/external_updater/README.md
+
+name: "rand_core"
+description: "Core random number generator traits and tools for implementation."
+third_party {
+  url {
+    type: HOMEPAGE
+    value: "https://crates.io/crates/rand_core"
+  }
+  url {
+    type: ARCHIVE
+    value: "https://static.crates.io/crates/rand_core/rand_core-0.6.4.crate"
+  }
+  version: "0.6.4"
+  license_type: NOTICE
+  last_upgrade_date {
+    year: 2022
+    month: 12
+    day: 13
+  }
+}
diff --git a/crates/rand_core/MODULE_LICENSE_APACHE2 b/crates/rand_core/MODULE_LICENSE_APACHE2
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/crates/rand_core/MODULE_LICENSE_APACHE2
diff --git a/crates/rand_core/README.md b/crates/rand_core/README.md
new file mode 100644
index 0000000..d32dd68
--- /dev/null
+++ b/crates/rand_core/README.md
@@ -0,0 +1,81 @@
+# rand_core
+
+[![Test Status](https://github.com/rust-random/rand/workflows/Tests/badge.svg?event=push)](https://github.com/rust-random/rand/actions)
+[![Latest version](https://img.shields.io/crates/v/rand_core.svg)](https://crates.io/crates/rand_core)
+[![Book](https://img.shields.io/badge/book-master-yellow.svg)](https://rust-random.github.io/book/)
+[![API](https://img.shields.io/badge/api-master-yellow.svg)](https://rust-random.github.io/rand/rand_core)
+[![API](https://docs.rs/rand_core/badge.svg)](https://docs.rs/rand_core)
+[![Minimum rustc version](https://img.shields.io/badge/rustc-1.36+-lightgray.svg)](https://github.com/rust-random/rand#rust-version-requirements)
+
+Core traits and error types of the [rand] library, plus tools for implementing
+RNGs.
+
+This crate is intended for use when implementing the core trait, `RngCore`; it
+defines the core traits to be implemented as well as several small functions to
+aid in their implementation and types required for error handling.
+
+The main [rand] crate re-exports most items defined in this crate, along with
+tools to convert the integer samples generated by `RngCore` to many different
+applications (including sampling from restricted ranges, conversion to floating
+point, list permutations and secure initialisation of RNGs). Most users should
+prefer to use the main [rand] crate.
+
+Links:
+
+-   [API documentation (master)](https://rust-random.github.io/rand/rand_core)
+-   [API documentation (docs.rs)](https://docs.rs/rand_core)
+-   [Changelog](https://github.com/rust-random/rand/blob/master/rand_core/CHANGELOG.md)
+
+[rand]: https://crates.io/crates/rand
+
+
+## Functionality
+
+The `rand_core` crate provides:
+
+-   base random number generator traits
+-   error-reporting types
+-   functionality to aid implementation of RNGs
+
+The traits and error types are also available via `rand`.
+
+## Versions
+
+The current version is:
+```
+rand_core = "0.6.0"
+```
+
+Rand libs have inter-dependencies and make use of the
+[semver trick](https://github.com/dtolnay/semver-trick/) in order to make traits
+compatible across crate versions. (This is especially important for `RngCore`
+and `SeedableRng`.) A few crate releases are thus compatibility shims,
+depending on the *next* lib version (e.g. `rand_core` versions `0.2.2` and
+`0.3.1`). This means, for example, that `rand_core_0_4_0::SeedableRng` and
+`rand_core_0_3_0::SeedableRng` are distinct, incompatible traits, which can
+cause build errors. Usually, running `cargo update` is enough to fix any issues.
+
+## Crate Features
+
+`rand_core` supports `no_std` and `alloc`-only configurations, as well as full
+`std` functionality. The differences between `no_std` and full `std` are small,
+comprising `RngCore` support for `Box<R>` types where `R: RngCore`,
+`std::io::Read` support for types supporting `RngCore`, and
+extensions to the `Error` type's functionality.
+
+The `std` feature is *not enabled by default*. This is primarily to avoid build
+problems where one crate implicitly requires `rand_core` with `std` support and
+another crate requires `rand` *without* `std` support. However, the `rand` crate
+continues to enable `std` support by default, both for itself and `rand_core`.
+
+The `serde1` feature can be used to derive `Serialize` and `Deserialize` for RNG
+implementations that use the `BlockRng` or `BlockRng64` wrappers.
+
+
+# License
+
+`rand_core` is distributed under the terms of both the MIT license and the
+Apache License (Version 2.0).
+
+See [LICENSE-APACHE](LICENSE-APACHE) and [LICENSE-MIT](LICENSE-MIT), and
+[COPYRIGHT](COPYRIGHT) for details.
diff --git a/crates/rand_core/TEST_MAPPING b/crates/rand_core/TEST_MAPPING
new file mode 100644
index 0000000..05d9335
--- /dev/null
+++ b/crates/rand_core/TEST_MAPPING
@@ -0,0 +1,99 @@
+// Generated by update_crate_tests.py for tests that depend on this crate.
+{
+  "imports": [
+    {
+      "path": "external/rust/crates/base64"
+    },
+    {
+      "path": "external/rust/crates/cast"
+    },
+    {
+      "path": "external/rust/crates/crc32fast"
+    },
+    {
+      "path": "external/rust/crates/crossbeam-deque"
+    },
+    {
+      "path": "external/rust/crates/crossbeam-epoch"
+    },
+    {
+      "path": "external/rust/crates/crossbeam-queue"
+    },
+    {
+      "path": "external/rust/crates/crossbeam-utils"
+    },
+    {
+      "path": "external/rust/crates/flate2"
+    },
+    {
+      "path": "external/rust/crates/hashbrown"
+    },
+    {
+      "path": "external/rust/crates/mio"
+    },
+    {
+      "path": "external/rust/crates/quickcheck"
+    },
+    {
+      "path": "external/rust/crates/rand_chacha"
+    },
+    {
+      "path": "external/rust/crates/rand_xorshift"
+    },
+    {
+      "path": "external/rust/crates/regex"
+    },
+    {
+      "path": "external/rust/crates/ryu"
+    },
+    {
+      "path": "external/rust/crates/tokio"
+    },
+    {
+      "path": "external/rust/crates/zerocopy"
+    },
+    {
+      "path": "external/uwb/src"
+    },
+    {
+      "path": "packages/modules/Virtualization/apkdmverity"
+    },
+    {
+      "path": "packages/modules/Virtualization/authfs"
+    },
+    {
+      "path": "packages/modules/Virtualization/avmd"
+    },
+    {
+      "path": "packages/modules/Virtualization/libs/devicemapper"
+    },
+    {
+      "path": "packages/modules/Virtualization/microdroid_manager"
+    },
+    {
+      "path": "packages/modules/Virtualization/virtualizationmanager"
+    },
+    {
+      "path": "packages/modules/Virtualization/vm"
+    },
+    {
+      "path": "packages/modules/Virtualization/zipfuse"
+    },
+    {
+      "path": "system/security/keystore2"
+    },
+    {
+      "path": "system/security/keystore2/legacykeystore"
+    }
+  ],
+  "presubmit": [
+    {
+      "name": "rand_core_test_src_lib"
+    }
+  ],
+  "presubmit-rust": [
+    {
+      "name": "rand_core_test_src_lib"
+    }
+  ]
+}
diff --git a/crates/rand_core/cargo_embargo.json b/crates/rand_core/cargo_embargo.json
new file mode 100644
index 0000000..1bf2d8d
--- /dev/null
+++ b/crates/rand_core/cargo_embargo.json
@@ -0,0 +1,7 @@
+{
+  "features": [
+    "std"
+  ],
+  "run_cargo": false,
+  "tests": true
+}
diff --git a/crates/rand_core/src/block.rs b/crates/rand_core/src/block.rs
new file mode 100644
index 0000000..d311b68
--- /dev/null
+++ b/crates/rand_core/src/block.rs
@@ -0,0 +1,539 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! The `BlockRngCore` trait and implementation helpers
+//!
+//! The [`BlockRngCore`] trait exists to assist in the implementation of RNGs
+//! which generate a block of data in a cache instead of returning generated
+//! values directly.
+//!
+//! Usage of this trait is optional, but provides two advantages:
+//! implementations only need to concern themselves with generation of the
+//! block, not the various [`RngCore`] methods (especially [`fill_bytes`], where
+//! the optimal implementations are not trivial), and this allows
+//! `ReseedingRng` (see [`rand`](https://docs.rs/rand) crate) perform periodic
+//! reseeding with very low overhead.
+//!
+//! # Example
+//!
+//! ```no_run
+//! use rand_core::{RngCore, SeedableRng};
+//! use rand_core::block::{BlockRngCore, BlockRng};
+//!
+//! struct MyRngCore;
+//!
+//! impl BlockRngCore for MyRngCore {
+//!     type Item = u32;
+//!     type Results = [u32; 16];
+//!
+//!     fn generate(&mut self, results: &mut Self::Results) {
+//!         unimplemented!()
+//!     }
+//! }
+//!
+//! impl SeedableRng for MyRngCore {
+//!     type Seed = [u8; 32];
+//!     fn from_seed(seed: Self::Seed) -> Self {
+//!         unimplemented!()
+//!     }
+//! }
+//!
+//! // optionally, also implement CryptoRng for MyRngCore
+//!
+//! // Final RNG.
+//! let mut rng = BlockRng::<MyRngCore>::seed_from_u64(0);
+//! println!("First value: {}", rng.next_u32());
+//! ```
+//!
+//! [`BlockRngCore`]: crate::block::BlockRngCore
+//! [`fill_bytes`]: RngCore::fill_bytes
+
+use crate::impls::{fill_via_u32_chunks, fill_via_u64_chunks};
+use crate::{CryptoRng, Error, RngCore, SeedableRng};
+use core::convert::AsRef;
+use core::fmt;
+#[cfg(feature = "serde1")]
+use serde::{Deserialize, Serialize};
+
+/// A trait for RNGs which do not generate random numbers individually, but in
+/// blocks (typically `[u32; N]`). This technique is commonly used by
+/// cryptographic RNGs to improve performance.
+///
+/// See the [module][crate::block] documentation for details.
+pub trait BlockRngCore {
+    /// Results element type, e.g. `u32`.
+    type Item;
+
+    /// Results type. This is the 'block' an RNG implementing `BlockRngCore`
+    /// generates, which will usually be an array like `[u32; 16]`.
+    type Results: AsRef<[Self::Item]> + AsMut<[Self::Item]> + Default;
+
+    /// Generate a new block of results.
+    fn generate(&mut self, results: &mut Self::Results);
+}
+
+/// A wrapper type implementing [`RngCore`] for some type implementing
+/// [`BlockRngCore`] with `u32` array buffer; i.e. this can be used to implement
+/// a full RNG from just a `generate` function.
+///
+/// The `core` field may be accessed directly but the results buffer may not.
+/// PRNG implementations can simply use a type alias
+/// (`pub type MyRng = BlockRng<MyRngCore>;`) but might prefer to use a
+/// wrapper type (`pub struct MyRng(BlockRng<MyRngCore>);`); the latter must
+/// re-implement `RngCore` but hides the implementation details and allows
+/// extra functionality to be defined on the RNG
+/// (e.g. `impl MyRng { fn set_stream(...){...} }`).
+///
+/// `BlockRng` has heavily optimized implementations of the [`RngCore`] methods
+/// reading values from the results buffer, as well as
+/// calling [`BlockRngCore::generate`] directly on the output array when
+/// [`fill_bytes`] / [`try_fill_bytes`] is called on a large array. These methods
+/// also handle the bookkeeping of when to generate a new batch of values.
+///
+/// No whole generated `u32` values are thrown away and all values are consumed
+/// in-order. [`next_u32`] simply takes the next available `u32` value.
+/// [`next_u64`] is implemented by combining two `u32` values, least
+/// significant first. [`fill_bytes`] and [`try_fill_bytes`] consume a whole
+/// number of `u32` values, converting each `u32` to a byte slice in
+/// little-endian order. If the requested byte length is not a multiple of 4,
+/// some bytes will be discarded.
+///
+/// See also [`BlockRng64`] which uses `u64` array buffers. Currently there is
+/// no direct support for other buffer types.
+///
+/// For easy initialization `BlockRng` also implements [`SeedableRng`].
+///
+/// [`next_u32`]: RngCore::next_u32
+/// [`next_u64`]: RngCore::next_u64
+/// [`fill_bytes`]: RngCore::fill_bytes
+/// [`try_fill_bytes`]: RngCore::try_fill_bytes
+#[derive(Clone)]
+#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
+#[cfg_attr(
+    feature = "serde1",
+    serde(
+        bound = "for<'x> R: Serialize + Deserialize<'x> + Sized, for<'x> R::Results: Serialize + Deserialize<'x>"
+    )
+)]
+pub struct BlockRng<R: BlockRngCore + ?Sized> {
+    results: R::Results,
+    index: usize,
+    /// The *core* part of the RNG, implementing the `generate` function.
+    pub core: R,
+}
+
+// Custom Debug implementation that does not expose the contents of `results`.
+impl<R: BlockRngCore + fmt::Debug> fmt::Debug for BlockRng<R> {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.debug_struct("BlockRng")
+            .field("core", &self.core)
+            .field("result_len", &self.results.as_ref().len())
+            .field("index", &self.index)
+            .finish()
+    }
+}
+
+impl<R: BlockRngCore> BlockRng<R> {
+    /// Create a new `BlockRng` from an existing RNG implementing
+    /// `BlockRngCore`. Results will be generated on first use.
+    #[inline]
+    pub fn new(core: R) -> BlockRng<R> {
+        let results_empty = R::Results::default();
+        BlockRng {
+            core,
+            index: results_empty.as_ref().len(),
+            results: results_empty,
+        }
+    }
+
+    /// Get the index into the result buffer.
+    ///
+    /// If this is equal to or larger than the size of the result buffer then
+    /// the buffer is "empty" and `generate()` must be called to produce new
+    /// results.
+    #[inline(always)]
+    pub fn index(&self) -> usize {
+        self.index
+    }
+
+    /// Reset the number of available results.
+    /// This will force a new set of results to be generated on next use.
+    #[inline]
+    pub fn reset(&mut self) {
+        self.index = self.results.as_ref().len();
+    }
+
+    /// Generate a new set of results immediately, setting the index to the
+    /// given value.
+    #[inline]
+    pub fn generate_and_set(&mut self, index: usize) {
+        assert!(index < self.results.as_ref().len());
+        self.core.generate(&mut self.results);
+        self.index = index;
+    }
+}
+
+impl<R: BlockRngCore<Item = u32>> RngCore for BlockRng<R>
+where
+    <R as BlockRngCore>::Results: AsRef<[u32]> + AsMut<[u32]>,
+{
+    #[inline]
+    fn next_u32(&mut self) -> u32 {
+        if self.index >= self.results.as_ref().len() {
+            self.generate_and_set(0);
+        }
+
+        let value = self.results.as_ref()[self.index];
+        self.index += 1;
+        value
+    }
+
+    #[inline]
+    fn next_u64(&mut self) -> u64 {
+        let read_u64 = |results: &[u32], index| {
+            let data = &results[index..=index + 1];
+            u64::from(data[1]) << 32 | u64::from(data[0])
+        };
+
+        let len = self.results.as_ref().len();
+
+        let index = self.index;
+        if index < len - 1 {
+            self.index += 2;
+            // Read an u64 from the current index
+            read_u64(self.results.as_ref(), index)
+        } else if index >= len {
+            self.generate_and_set(2);
+            read_u64(self.results.as_ref(), 0)
+        } else {
+            let x = u64::from(self.results.as_ref()[len - 1]);
+            self.generate_and_set(1);
+            let y = u64::from(self.results.as_ref()[0]);
+            (y << 32) | x
+        }
+    }
+
+    #[inline]
+    fn fill_bytes(&mut self, dest: &mut [u8]) {
+        let mut read_len = 0;
+        while read_len < dest.len() {
+            if self.index >= self.results.as_ref().len() {
+                self.generate_and_set(0);
+            }
+            let (consumed_u32, filled_u8) =
+                fill_via_u32_chunks(&self.results.as_ref()[self.index..], &mut dest[read_len..]);
+
+            self.index += consumed_u32;
+            read_len += filled_u8;
+        }
+    }
+
+    #[inline(always)]
+    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
+        self.fill_bytes(dest);
+        Ok(())
+    }
+}
+
+impl<R: BlockRngCore + SeedableRng> SeedableRng for BlockRng<R> {
+    type Seed = R::Seed;
+
+    #[inline(always)]
+    fn from_seed(seed: Self::Seed) -> Self {
+        Self::new(R::from_seed(seed))
+    }
+
+    #[inline(always)]
+    fn seed_from_u64(seed: u64) -> Self {
+        Self::new(R::seed_from_u64(seed))
+    }
+
+    #[inline(always)]
+    fn from_rng<S: RngCore>(rng: S) -> Result<Self, Error> {
+        Ok(Self::new(R::from_rng(rng)?))
+    }
+}
+
+/// A wrapper type implementing [`RngCore`] for some type implementing
+/// [`BlockRngCore`] with `u64` array buffer; i.e. this can be used to implement
+/// a full RNG from just a `generate` function.
+///
+/// This is similar to [`BlockRng`], but specialized for algorithms that operate
+/// on `u64` values.
+///
+/// No whole generated `u64` values are thrown away and all values are consumed
+/// in-order. [`next_u64`] simply takes the next available `u64` value.
+/// [`next_u32`] is however a bit special: half of a `u64` is consumed, leaving
+/// the other half in the buffer. If the next function called is [`next_u32`]
+/// then the other half is then consumed, however both [`next_u64`] and
+/// [`fill_bytes`] discard the rest of any half-consumed `u64`s when called.
+///
+/// [`fill_bytes`] and [`try_fill_bytes`] consume a whole number of `u64`
+/// values. If the requested length is not a multiple of 8, some bytes will be
+/// discarded.
+///
+/// [`next_u32`]: RngCore::next_u32
+/// [`next_u64`]: RngCore::next_u64
+/// [`fill_bytes`]: RngCore::fill_bytes
+/// [`try_fill_bytes`]: RngCore::try_fill_bytes
+#[derive(Clone)]
+#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
+pub struct BlockRng64<R: BlockRngCore + ?Sized> {
+    results: R::Results,
+    index: usize,
+    half_used: bool, // true if only half of the previous result is used
+    /// The *core* part of the RNG, implementing the `generate` function.
+    pub core: R,
+}
+
+// Custom Debug implementation that does not expose the contents of `results`.
+impl<R: BlockRngCore + fmt::Debug> fmt::Debug for BlockRng64<R> {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.debug_struct("BlockRng64")
+            .field("core", &self.core)
+            .field("result_len", &self.results.as_ref().len())
+            .field("index", &self.index)
+            .field("half_used", &self.half_used)
+            .finish()
+    }
+}
+
+impl<R: BlockRngCore> BlockRng64<R> {
+    /// Create a new `BlockRng` from an existing RNG implementing
+    /// `BlockRngCore`. Results will be generated on first use.
+    #[inline]
+    pub fn new(core: R) -> BlockRng64<R> {
+        let results_empty = R::Results::default();
+        BlockRng64 {
+            core,
+            index: results_empty.as_ref().len(),
+            half_used: false,
+            results: results_empty,
+        }
+    }
+
+    /// Get the index into the result buffer.
+    ///
+    /// If this is equal to or larger than the size of the result buffer then
+    /// the buffer is "empty" and `generate()` must be called to produce new
+    /// results.
+    #[inline(always)]
+    pub fn index(&self) -> usize {
+        self.index
+    }
+
+    /// Reset the number of available results.
+    /// This will force a new set of results to be generated on next use.
+    #[inline]
+    pub fn reset(&mut self) {
+        self.index = self.results.as_ref().len();
+        self.half_used = false;
+    }
+
+    /// Generate a new set of results immediately, setting the index to the
+    /// given value.
+    #[inline]
+    pub fn generate_and_set(&mut self, index: usize) {
+        assert!(index < self.results.as_ref().len());
+        self.core.generate(&mut self.results);
+        self.index = index;
+        self.half_used = false;
+    }
+}
+
+impl<R: BlockRngCore<Item = u64>> RngCore for BlockRng64<R>
+where
+    <R as BlockRngCore>::Results: AsRef<[u64]> + AsMut<[u64]>,
+{
+    #[inline]
+    fn next_u32(&mut self) -> u32 {
+        let mut index = self.index - self.half_used as usize;
+        if index >= self.results.as_ref().len() {
+            self.core.generate(&mut self.results);
+            self.index = 0;
+            index = 0;
+            // `self.half_used` is by definition `false`
+            self.half_used = false;
+        }
+
+        let shift = 32 * (self.half_used as usize);
+
+        self.half_used = !self.half_used;
+        self.index += self.half_used as usize;
+
+        (self.results.as_ref()[index] >> shift) as u32
+    }
+
+    #[inline]
+    fn next_u64(&mut self) -> u64 {
+        if self.index >= self.results.as_ref().len() {
+            self.core.generate(&mut self.results);
+            self.index = 0;
+        }
+
+        let value = self.results.as_ref()[self.index];
+        self.index += 1;
+        self.half_used = false;
+        value
+    }
+
+    #[inline]
+    fn fill_bytes(&mut self, dest: &mut [u8]) {
+        let mut read_len = 0;
+        self.half_used = false;
+        while read_len < dest.len() {
+            if self.index as usize >= self.results.as_ref().len() {
+                self.core.generate(&mut self.results);
+                self.index = 0;
+            }
+
+            let (consumed_u64, filled_u8) = fill_via_u64_chunks(
+                &self.results.as_ref()[self.index as usize..],
+                &mut dest[read_len..],
+            );
+
+            self.index += consumed_u64;
+            read_len += filled_u8;
+        }
+    }
+
+    #[inline(always)]
+    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
+        self.fill_bytes(dest);
+        Ok(())
+    }
+}
+
+impl<R: BlockRngCore + SeedableRng> SeedableRng for BlockRng64<R> {
+    type Seed = R::Seed;
+
+    #[inline(always)]
+    fn from_seed(seed: Self::Seed) -> Self {
+        Self::new(R::from_seed(seed))
+    }
+
+    #[inline(always)]
+    fn seed_from_u64(seed: u64) -> Self {
+        Self::new(R::seed_from_u64(seed))
+    }
+
+    #[inline(always)]
+    fn from_rng<S: RngCore>(rng: S) -> Result<Self, Error> {
+        Ok(Self::new(R::from_rng(rng)?))
+    }
+}
+
+impl<R: BlockRngCore + CryptoRng> CryptoRng for BlockRng<R> {}
+
+#[cfg(test)]
+mod test {
+    use crate::{SeedableRng, RngCore};
+    use crate::block::{BlockRng, BlockRng64, BlockRngCore};
+
+    #[derive(Debug, Clone)]
+    struct DummyRng {
+        counter: u32,
+    }
+
+    impl BlockRngCore for DummyRng {
+        type Item = u32;
+
+        type Results = [u32; 16];
+
+        fn generate(&mut self, results: &mut Self::Results) {
+            for r in results {
+                *r = self.counter;
+                self.counter = self.counter.wrapping_add(3511615421);
+            }
+        }
+    }
+
+    impl SeedableRng for DummyRng {
+        type Seed = [u8; 4];
+
+        fn from_seed(seed: Self::Seed) -> Self {
+            DummyRng { counter: u32::from_le_bytes(seed) }
+        }
+    }
+
+    #[test]
+    fn blockrng_next_u32_vs_next_u64() {
+        let mut rng1 = BlockRng::<DummyRng>::from_seed([1, 2, 3, 4]);
+        let mut rng2 = rng1.clone();
+        let mut rng3 = rng1.clone();
+
+        let mut a = [0; 16];
+        (&mut a[..4]).copy_from_slice(&rng1.next_u32().to_le_bytes());
+        (&mut a[4..12]).copy_from_slice(&rng1.next_u64().to_le_bytes());
+        (&mut a[12..]).copy_from_slice(&rng1.next_u32().to_le_bytes());
+
+        let mut b = [0; 16];
+        (&mut b[..4]).copy_from_slice(&rng2.next_u32().to_le_bytes());
+        (&mut b[4..8]).copy_from_slice(&rng2.next_u32().to_le_bytes());
+        (&mut b[8..]).copy_from_slice(&rng2.next_u64().to_le_bytes());
+        assert_eq!(a, b);
+
+        let mut c = [0; 16];
+        (&mut c[..8]).copy_from_slice(&rng3.next_u64().to_le_bytes());
+        (&mut c[8..12]).copy_from_slice(&rng3.next_u32().to_le_bytes());
+        (&mut c[12..]).copy_from_slice(&rng3.next_u32().to_le_bytes());
+        assert_eq!(a, c);
+    }
+
+    #[derive(Debug, Clone)]
+    struct DummyRng64 {
+        counter: u64,
+    }
+
+    impl BlockRngCore for DummyRng64 {
+        type Item = u64;
+
+        type Results = [u64; 8];
+
+        fn generate(&mut self, results: &mut Self::Results) {
+            for r in results {
+                *r = self.counter;
+                self.counter = self.counter.wrapping_add(2781463553396133981);
+            }
+        }
+    }
+
+    impl SeedableRng for DummyRng64 {
+        type Seed = [u8; 8];
+
+        fn from_seed(seed: Self::Seed) -> Self {
+            DummyRng64 { counter: u64::from_le_bytes(seed) }
+        }
+    }
+
+    #[test]
+    fn blockrng64_next_u32_vs_next_u64() {
+        let mut rng1 = BlockRng64::<DummyRng64>::from_seed([1, 2, 3, 4, 5, 6, 7, 8]);
+        let mut rng2 = rng1.clone();
+        let mut rng3 = rng1.clone();
+
+        let mut a = [0; 16];
+        (&mut a[..4]).copy_from_slice(&rng1.next_u32().to_le_bytes());
+        (&mut a[4..12]).copy_from_slice(&rng1.next_u64().to_le_bytes());
+        (&mut a[12..]).copy_from_slice(&rng1.next_u32().to_le_bytes());
+
+        let mut b = [0; 16];
+        (&mut b[..4]).copy_from_slice(&rng2.next_u32().to_le_bytes());
+        (&mut b[4..8]).copy_from_slice(&rng2.next_u32().to_le_bytes());
+        (&mut b[8..]).copy_from_slice(&rng2.next_u64().to_le_bytes());
+        assert_ne!(a, b);
+        assert_eq!(&a[..4], &b[..4]);
+        assert_eq!(&a[4..12], &b[8..]);
+
+        let mut c = [0; 16];
+        (&mut c[..8]).copy_from_slice(&rng3.next_u64().to_le_bytes());
+        (&mut c[8..12]).copy_from_slice(&rng3.next_u32().to_le_bytes());
+        (&mut c[12..]).copy_from_slice(&rng3.next_u32().to_le_bytes());
+        assert_eq!(b, c);
+    }
+}
diff --git a/crates/rand_core/src/error.rs b/crates/rand_core/src/error.rs
new file mode 100644
index 0000000..411896f
--- /dev/null
+++ b/crates/rand_core/src/error.rs
@@ -0,0 +1,228 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Error types
+
+use core::fmt;
+use core::num::NonZeroU32;
+
+#[cfg(feature = "std")] use std::boxed::Box;
+
+/// Error type of random number generators
+///
+/// In order to be compatible with `std` and `no_std`, this type has two
+/// possible implementations: with `std` a boxed `Error` trait object is stored,
+/// while with `no_std` we merely store an error code.
+pub struct Error {
+    #[cfg(feature = "std")]
+    inner: Box<dyn std::error::Error + Send + Sync + 'static>,
+    #[cfg(not(feature = "std"))]
+    code: NonZeroU32,
+}
+
+impl Error {
+    /// Codes at or above this point can be used by users to define their own
+    /// custom errors.
+    ///
+    /// This has a fixed value of `(1 << 31) + (1 << 30) = 0xC000_0000`,
+    /// therefore the number of values available for custom codes is `1 << 30`.
+    ///
+    /// This is identical to [`getrandom::Error::CUSTOM_START`](https://docs.rs/getrandom/latest/getrandom/struct.Error.html#associatedconstant.CUSTOM_START).
+    pub const CUSTOM_START: u32 = (1 << 31) + (1 << 30);
+    /// Codes below this point represent OS Errors (i.e. positive i32 values).
+    /// Codes at or above this point, but below [`Error::CUSTOM_START`] are
+    /// reserved for use by the `rand` and `getrandom` crates.
+    ///
+    /// This is identical to [`getrandom::Error::INTERNAL_START`](https://docs.rs/getrandom/latest/getrandom/struct.Error.html#associatedconstant.INTERNAL_START).
+    pub const INTERNAL_START: u32 = 1 << 31;
+
+    /// Construct from any type supporting `std::error::Error`
+    ///
+    /// Available only when configured with `std`.
+    ///
+    /// See also `From<NonZeroU32>`, which is available with and without `std`.
+    #[cfg(feature = "std")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
+    #[inline]
+    pub fn new<E>(err: E) -> Self
+    where
+        E: Into<Box<dyn std::error::Error + Send + Sync + 'static>>,
+    {
+        Error { inner: err.into() }
+    }
+
+    /// Reference the inner error (`std` only)
+    ///
+    /// When configured with `std`, this is a trivial operation and never
+    /// panics. Without `std`, this method is simply unavailable.
+    #[cfg(feature = "std")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
+    #[inline]
+    pub fn inner(&self) -> &(dyn std::error::Error + Send + Sync + 'static) {
+        &*self.inner
+    }
+
+    /// Unwrap the inner error (`std` only)
+    ///
+    /// When configured with `std`, this is a trivial operation and never
+    /// panics. Without `std`, this method is simply unavailable.
+    #[cfg(feature = "std")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
+    #[inline]
+    pub fn take_inner(self) -> Box<dyn std::error::Error + Send + Sync + 'static> {
+        self.inner
+    }
+
+    /// Extract the raw OS error code (if this error came from the OS)
+    ///
+    /// This method is identical to `std::io::Error::raw_os_error()`, except
+    /// that it works in `no_std` contexts. If this method returns `None`, the
+    /// error value can still be formatted via the `Display` implementation.
+    #[inline]
+    pub fn raw_os_error(&self) -> Option<i32> {
+        #[cfg(feature = "std")]
+        {
+            if let Some(e) = self.inner.downcast_ref::<std::io::Error>() {
+                return e.raw_os_error();
+            }
+        }
+        match self.code() {
+            Some(code) if u32::from(code) < Self::INTERNAL_START => Some(u32::from(code) as i32),
+            _ => None,
+        }
+    }
+
+    /// Retrieve the error code, if any.
+    ///
+    /// If this `Error` was constructed via `From<NonZeroU32>`, then this method
+    /// will return this `NonZeroU32` code (for `no_std` this is always the
+    /// case). Otherwise, this method will return `None`.
+    #[inline]
+    pub fn code(&self) -> Option<NonZeroU32> {
+        #[cfg(feature = "std")]
+        {
+            self.inner.downcast_ref::<ErrorCode>().map(|c| c.0)
+        }
+        #[cfg(not(feature = "std"))]
+        {
+            Some(self.code)
+        }
+    }
+}
+
+impl fmt::Debug for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        #[cfg(feature = "std")]
+        {
+            write!(f, "Error {{ inner: {:?} }}", self.inner)
+        }
+        #[cfg(all(feature = "getrandom", not(feature = "std")))]
+        {
+            getrandom::Error::from(self.code).fmt(f)
+        }
+        #[cfg(not(feature = "getrandom"))]
+        {
+            write!(f, "Error {{ code: {} }}", self.code)
+        }
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        #[cfg(feature = "std")]
+        {
+            write!(f, "{}", self.inner)
+        }
+        #[cfg(all(feature = "getrandom", not(feature = "std")))]
+        {
+            getrandom::Error::from(self.code).fmt(f)
+        }
+        #[cfg(not(feature = "getrandom"))]
+        {
+            write!(f, "error code {}", self.code)
+        }
+    }
+}
+
+impl From<NonZeroU32> for Error {
+    #[inline]
+    fn from(code: NonZeroU32) -> Self {
+        #[cfg(feature = "std")]
+        {
+            Error {
+                inner: Box::new(ErrorCode(code)),
+            }
+        }
+        #[cfg(not(feature = "std"))]
+        {
+            Error { code }
+        }
+    }
+}
+
+#[cfg(feature = "getrandom")]
+impl From<getrandom::Error> for Error {
+    #[inline]
+    fn from(error: getrandom::Error) -> Self {
+        #[cfg(feature = "std")]
+        {
+            Error {
+                inner: Box::new(error),
+            }
+        }
+        #[cfg(not(feature = "std"))]
+        {
+            Error { code: error.code() }
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for Error {
+    #[inline]
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        self.inner.source()
+    }
+}
+
+#[cfg(feature = "std")]
+impl From<Error> for std::io::Error {
+    #[inline]
+    fn from(error: Error) -> Self {
+        if let Some(code) = error.raw_os_error() {
+            std::io::Error::from_raw_os_error(code)
+        } else {
+            std::io::Error::new(std::io::ErrorKind::Other, error)
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+#[derive(Debug, Copy, Clone)]
+struct ErrorCode(NonZeroU32);
+
+#[cfg(feature = "std")]
+impl fmt::Display for ErrorCode {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "error code {}", self.0)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for ErrorCode {}
+
+#[cfg(test)]
+mod test {
+    #[cfg(feature = "getrandom")]
+    #[test]
+    fn test_error_codes() {
+        // Make sure the values are the same as in `getrandom`.
+        assert_eq!(super::Error::CUSTOM_START, getrandom::Error::CUSTOM_START);
+        assert_eq!(super::Error::INTERNAL_START, getrandom::Error::INTERNAL_START);
+    }
+}
diff --git a/crates/rand_core/src/impls.rs b/crates/rand_core/src/impls.rs
new file mode 100644
index 0000000..4b7688c
--- /dev/null
+++ b/crates/rand_core/src/impls.rs
@@ -0,0 +1,207 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Helper functions for implementing `RngCore` functions.
+//!
+//! For cross-platform reproducibility, these functions all use Little Endian:
+//! least-significant part first. For example, `next_u64_via_u32` takes `u32`
+//! values `x, y`, then outputs `(y << 32) | x`. To implement `next_u32`
+//! from `next_u64` in little-endian order, one should use `next_u64() as u32`.
+//!
+//! Byte-swapping (like the std `to_le` functions) is only needed to convert
+//! to/from byte sequences, and since its purpose is reproducibility,
+//! non-reproducible sources (e.g. `OsRng`) need not bother with it.
+
+use crate::RngCore;
+use core::cmp::min;
+
+/// Implement `next_u64` via `next_u32`, little-endian order.
+pub fn next_u64_via_u32<R: RngCore + ?Sized>(rng: &mut R) -> u64 {
+    // Use LE; we explicitly generate one value before the next.
+    let x = u64::from(rng.next_u32());
+    let y = u64::from(rng.next_u32());
+    (y << 32) | x
+}
+
+/// Implement `fill_bytes` via `next_u64` and `next_u32`, little-endian order.
+///
+/// The fastest way to fill a slice is usually to work as long as possible with
+/// integers. That is why this method mostly uses `next_u64`, and only when
+/// there are 4 or less bytes remaining at the end of the slice it uses
+/// `next_u32` once.
+pub fn fill_bytes_via_next<R: RngCore + ?Sized>(rng: &mut R, dest: &mut [u8]) {
+    let mut left = dest;
+    while left.len() >= 8 {
+        let (l, r) = { left }.split_at_mut(8);
+        left = r;
+        let chunk: [u8; 8] = rng.next_u64().to_le_bytes();
+        l.copy_from_slice(&chunk);
+    }
+    let n = left.len();
+    if n > 4 {
+        let chunk: [u8; 8] = rng.next_u64().to_le_bytes();
+        left.copy_from_slice(&chunk[..n]);
+    } else if n > 0 {
+        let chunk: [u8; 4] = rng.next_u32().to_le_bytes();
+        left.copy_from_slice(&chunk[..n]);
+    }
+}
+
+trait Observable: Copy {
+    type Bytes: AsRef<[u8]>;
+    fn to_le_bytes(self) -> Self::Bytes;
+
+    // Contract: observing self is memory-safe (implies no uninitialised padding)
+    fn as_byte_slice(x: &[Self]) -> &[u8];
+}
+impl Observable for u32 {
+    type Bytes = [u8; 4];
+    fn to_le_bytes(self) -> Self::Bytes {
+        self.to_le_bytes()
+    }
+    fn as_byte_slice(x: &[Self]) -> &[u8] {
+        let ptr = x.as_ptr() as *const u8;
+        let len = x.len() * core::mem::size_of::<Self>();
+        unsafe { core::slice::from_raw_parts(ptr, len) }
+    }
+}
+impl Observable for u64 {
+    type Bytes = [u8; 8];
+    fn to_le_bytes(self) -> Self::Bytes {
+        self.to_le_bytes()
+    }
+    fn as_byte_slice(x: &[Self]) -> &[u8] {
+        let ptr = x.as_ptr() as *const u8;
+        let len = x.len() * core::mem::size_of::<Self>();
+        unsafe { core::slice::from_raw_parts(ptr, len) }
+    }
+}
+
+fn fill_via_chunks<T: Observable>(src: &[T], dest: &mut [u8]) -> (usize, usize) {
+    let size = core::mem::size_of::<T>();
+    let byte_len = min(src.len() * size, dest.len());
+    let num_chunks = (byte_len + size - 1) / size;
+
+    if cfg!(target_endian = "little") {
+        // On LE we can do a simple copy, which is 25-50% faster:
+        dest[..byte_len].copy_from_slice(&T::as_byte_slice(&src[..num_chunks])[..byte_len]);
+    } else {
+        // This code is valid on all arches, but slower than the above:
+        let mut i = 0;
+        let mut iter = dest[..byte_len].chunks_exact_mut(size);
+        for chunk in &mut iter {
+            chunk.copy_from_slice(src[i].to_le_bytes().as_ref());
+            i += 1;
+        }
+        let chunk = iter.into_remainder();
+        if !chunk.is_empty() {
+            chunk.copy_from_slice(&src[i].to_le_bytes().as_ref()[..chunk.len()]);
+        }
+    }
+
+    (num_chunks, byte_len)
+}
+
+/// Implement `fill_bytes` by reading chunks from the output buffer of a block
+/// based RNG.
+///
+/// The return values are `(consumed_u32, filled_u8)`.
+///
+/// `filled_u8` is the number of filled bytes in `dest`, which may be less than
+/// the length of `dest`.
+/// `consumed_u32` is the number of words consumed from `src`, which is the same
+/// as `filled_u8 / 4` rounded up.
+///
+/// # Example
+/// (from `IsaacRng`)
+///
+/// ```ignore
+/// fn fill_bytes(&mut self, dest: &mut [u8]) {
+///     let mut read_len = 0;
+///     while read_len < dest.len() {
+///         if self.index >= self.rsl.len() {
+///             self.isaac();
+///         }
+///
+///         let (consumed_u32, filled_u8) =
+///             impls::fill_via_u32_chunks(&mut self.rsl[self.index..],
+///                                        &mut dest[read_len..]);
+///
+///         self.index += consumed_u32;
+///         read_len += filled_u8;
+///     }
+/// }
+/// ```
+pub fn fill_via_u32_chunks(src: &[u32], dest: &mut [u8]) -> (usize, usize) {
+    fill_via_chunks(src, dest)
+}
+
+/// Implement `fill_bytes` by reading chunks from the output buffer of a block
+/// based RNG.
+///
+/// The return values are `(consumed_u64, filled_u8)`.
+/// `filled_u8` is the number of filled bytes in `dest`, which may be less than
+/// the length of `dest`.
+/// `consumed_u64` is the number of words consumed from `src`, which is the same
+/// as `filled_u8 / 8` rounded up.
+///
+/// See `fill_via_u32_chunks` for an example.
+pub fn fill_via_u64_chunks(src: &[u64], dest: &mut [u8]) -> (usize, usize) {
+    fill_via_chunks(src, dest)
+}
+
+/// Implement `next_u32` via `fill_bytes`, little-endian order.
+pub fn next_u32_via_fill<R: RngCore + ?Sized>(rng: &mut R) -> u32 {
+    let mut buf = [0; 4];
+    rng.fill_bytes(&mut buf);
+    u32::from_le_bytes(buf)
+}
+
+/// Implement `next_u64` via `fill_bytes`, little-endian order.
+pub fn next_u64_via_fill<R: RngCore + ?Sized>(rng: &mut R) -> u64 {
+    let mut buf = [0; 8];
+    rng.fill_bytes(&mut buf);
+    u64::from_le_bytes(buf)
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_fill_via_u32_chunks() {
+        let src = [1, 2, 3];
+        let mut dst = [0u8; 11];
+        assert_eq!(fill_via_u32_chunks(&src, &mut dst), (3, 11));
+        assert_eq!(dst, [1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0]);
+
+        let mut dst = [0u8; 13];
+        assert_eq!(fill_via_u32_chunks(&src, &mut dst), (3, 12));
+        assert_eq!(dst, [1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 0]);
+
+        let mut dst = [0u8; 5];
+        assert_eq!(fill_via_u32_chunks(&src, &mut dst), (2, 5));
+        assert_eq!(dst, [1, 0, 0, 0, 2]);
+    }
+
+    #[test]
+    fn test_fill_via_u64_chunks() {
+        let src = [1, 2];
+        let mut dst = [0u8; 11];
+        assert_eq!(fill_via_u64_chunks(&src, &mut dst), (2, 11));
+        assert_eq!(dst, [1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0]);
+
+        let mut dst = [0u8; 17];
+        assert_eq!(fill_via_u64_chunks(&src, &mut dst), (2, 16));
+        assert_eq!(dst, [1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0]);
+
+        let mut dst = [0u8; 5];
+        assert_eq!(fill_via_u64_chunks(&src, &mut dst), (1, 5));
+        assert_eq!(dst, [1, 0, 0, 0, 0]);
+    }
+}
diff --git a/crates/rand_core/src/le.rs b/crates/rand_core/src/le.rs
new file mode 100644
index 0000000..ed42e57
--- /dev/null
+++ b/crates/rand_core/src/le.rs
@@ -0,0 +1,56 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Little-Endian utilities
+//!
+//! Little-Endian order has been chosen for internal usage; this makes some
+//! useful functions available.
+
+use core::convert::TryInto;
+
+/// Reads unsigned 32 bit integers from `src` into `dst`.
+#[inline]
+pub fn read_u32_into(src: &[u8], dst: &mut [u32]) {
+    assert!(src.len() >= 4 * dst.len());
+    for (out, chunk) in dst.iter_mut().zip(src.chunks_exact(4)) {
+        *out = u32::from_le_bytes(chunk.try_into().unwrap());
+    }
+}
+
+/// Reads unsigned 64 bit integers from `src` into `dst`.
+#[inline]
+pub fn read_u64_into(src: &[u8], dst: &mut [u64]) {
+    assert!(src.len() >= 8 * dst.len());
+    for (out, chunk) in dst.iter_mut().zip(src.chunks_exact(8)) {
+        *out = u64::from_le_bytes(chunk.try_into().unwrap());
+    }
+}
+
+#[test]
+fn test_read() {
+    let bytes = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
+
+    let mut buf = [0u32; 4];
+    read_u32_into(&bytes, &mut buf);
+    assert_eq!(buf[0], 0x04030201);
+    assert_eq!(buf[3], 0x100F0E0D);
+
+    let mut buf = [0u32; 3];
+    read_u32_into(&bytes[1..13], &mut buf); // unaligned
+    assert_eq!(buf[0], 0x05040302);
+    assert_eq!(buf[2], 0x0D0C0B0A);
+
+    let mut buf = [0u64; 2];
+    read_u64_into(&bytes, &mut buf);
+    assert_eq!(buf[0], 0x0807060504030201);
+    assert_eq!(buf[1], 0x100F0E0D0C0B0A09);
+
+    let mut buf = [0u64; 1];
+    read_u64_into(&bytes[7..15], &mut buf); // unaligned
+    assert_eq!(buf[0], 0x0F0E0D0C0B0A0908);
+}
diff --git a/crates/rand_core/src/lib.rs b/crates/rand_core/src/lib.rs
new file mode 100644
index 0000000..1234a56
--- /dev/null
+++ b/crates/rand_core/src/lib.rs
@@ -0,0 +1,531 @@
+// Copyright 2018 Developers of the Rand project.
+// Copyright 2017-2018 The Rust Project Developers.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Random number generation traits
+//!
+//! This crate is mainly of interest to crates publishing implementations of
+//! [`RngCore`]. Other users are encouraged to use the [`rand`] crate instead
+//! which re-exports the main traits and error types.
+//!
+//! [`RngCore`] is the core trait implemented by algorithmic pseudo-random number
+//! generators and external random-number sources.
+//!
+//! [`SeedableRng`] is an extension trait for construction from fixed seeds and
+//! other random number generators.
+//!
+//! [`Error`] is provided for error-handling. It is safe to use in `no_std`
+//! environments.
+//!
+//! The [`impls`] and [`le`] sub-modules include a few small functions to assist
+//! implementation of [`RngCore`].
+//!
+//! [`rand`]: https://docs.rs/rand
+
+#![doc(
+    html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk.png",
+    html_favicon_url = "https://www.rust-lang.org/favicon.ico",
+    html_root_url = "https://rust-random.github.io/rand/"
+)]
+#![deny(missing_docs)]
+#![deny(missing_debug_implementations)]
+#![doc(test(attr(allow(unused_variables), deny(warnings))))]
+#![cfg_attr(doc_cfg, feature(doc_cfg))]
+#![no_std]
+
+use core::convert::AsMut;
+use core::default::Default;
+
+#[cfg(feature = "std")] extern crate std;
+#[cfg(feature = "alloc")] extern crate alloc;
+#[cfg(feature = "alloc")] use alloc::boxed::Box;
+
+pub use error::Error;
+#[cfg(feature = "getrandom")] pub use os::OsRng;
+
+
+pub mod block;
+mod error;
+pub mod impls;
+pub mod le;
+#[cfg(feature = "getrandom")] mod os;
+
+
+/// The core of a random number generator.
+///
+/// This trait encapsulates the low-level functionality common to all
+/// generators, and is the "back end", to be implemented by generators.
+/// End users should normally use the `Rng` trait from the [`rand`] crate,
+/// which is automatically implemented for every type implementing `RngCore`.
+///
+/// Three different methods for generating random data are provided since the
+/// optimal implementation of each is dependent on the type of generator. There
+/// is no required relationship between the output of each; e.g. many
+/// implementations of [`fill_bytes`] consume a whole number of `u32` or `u64`
+/// values and drop any remaining unused bytes. The same can happen with the
+/// [`next_u32`] and [`next_u64`] methods, implementations may discard some
+/// random bits for efficiency.
+///
+/// The [`try_fill_bytes`] method is a variant of [`fill_bytes`] allowing error
+/// handling; it is not deemed sufficiently useful to add equivalents for
+/// [`next_u32`] or [`next_u64`] since the latter methods are almost always used
+/// with algorithmic generators (PRNGs), which are normally infallible.
+///
+/// Implementers should produce bits uniformly. Pathological RNGs (e.g. always
+/// returning the same value, or never setting certain bits) can break rejection
+/// sampling used by random distributions, and also break other RNGs when
+/// seeding them via [`SeedableRng::from_rng`].
+///
+/// Algorithmic generators implementing [`SeedableRng`] should normally have
+/// *portable, reproducible* output, i.e. fix Endianness when converting values
+/// to avoid platform differences, and avoid making any changes which affect
+/// output (except by communicating that the release has breaking changes).
+///
+/// Typically an RNG will implement only one of the methods available
+/// in this trait directly, then use the helper functions from the
+/// [`impls`] module to implement the other methods.
+///
+/// It is recommended that implementations also implement:
+///
+/// - `Debug` with a custom implementation which *does not* print any internal
+///   state (at least, [`CryptoRng`]s should not risk leaking state through
+///   `Debug`).
+/// - `Serialize` and `Deserialize` (from Serde), preferably making Serde
+///   support optional at the crate level in PRNG libs.
+/// - `Clone`, if possible.
+/// - *never* implement `Copy` (accidental copies may cause repeated values).
+/// - *do not* implement `Default` for pseudorandom generators, but instead
+///   implement [`SeedableRng`], to guide users towards proper seeding.
+///   External / hardware RNGs can choose to implement `Default`.
+/// - `Eq` and `PartialEq` could be implemented, but are probably not useful.
+///
+/// # Example
+///
+/// A simple example, obviously not generating very *random* output:
+///
+/// ```
+/// #![allow(dead_code)]
+/// use rand_core::{RngCore, Error, impls};
+///
+/// struct CountingRng(u64);
+///
+/// impl RngCore for CountingRng {
+///     fn next_u32(&mut self) -> u32 {
+///         self.next_u64() as u32
+///     }
+///
+///     fn next_u64(&mut self) -> u64 {
+///         self.0 += 1;
+///         self.0
+///     }
+///
+///     fn fill_bytes(&mut self, dest: &mut [u8]) {
+///         impls::fill_bytes_via_next(self, dest)
+///     }
+///
+///     fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
+///         Ok(self.fill_bytes(dest))
+///     }
+/// }
+/// ```
+///
+/// [`rand`]: https://docs.rs/rand
+/// [`try_fill_bytes`]: RngCore::try_fill_bytes
+/// [`fill_bytes`]: RngCore::fill_bytes
+/// [`next_u32`]: RngCore::next_u32
+/// [`next_u64`]: RngCore::next_u64
+pub trait RngCore {
+    /// Return the next random `u32`.
+    ///
+    /// RNGs must implement at least one method from this trait directly. In
+    /// the case this method is not implemented directly, it can be implemented
+    /// using `self.next_u64() as u32` or via [`impls::next_u32_via_fill`].
+    fn next_u32(&mut self) -> u32;
+
+    /// Return the next random `u64`.
+    ///
+    /// RNGs must implement at least one method from this trait directly. In
+    /// the case this method is not implemented directly, it can be implemented
+    /// via [`impls::next_u64_via_u32`] or via [`impls::next_u64_via_fill`].
+    fn next_u64(&mut self) -> u64;
+
+    /// Fill `dest` with random data.
+    ///
+    /// RNGs must implement at least one method from this trait directly. In
+    /// the case this method is not implemented directly, it can be implemented
+    /// via [`impls::fill_bytes_via_next`] or
+    /// via [`RngCore::try_fill_bytes`]; if this generator can
+    /// fail the implementation must choose how best to handle errors here
+    /// (e.g. panic with a descriptive message or log a warning and retry a few
+    /// times).
+    ///
+    /// This method should guarantee that `dest` is entirely filled
+    /// with new data, and may panic if this is impossible
+    /// (e.g. reading past the end of a file that is being used as the
+    /// source of randomness).
+    fn fill_bytes(&mut self, dest: &mut [u8]);
+
+    /// Fill `dest` entirely with random data.
+    ///
+    /// This is the only method which allows an RNG to report errors while
+    /// generating random data thus making this the primary method implemented
+    /// by external (true) RNGs (e.g. `OsRng`) which can fail. It may be used
+    /// directly to generate keys and to seed (infallible) PRNGs.
+    ///
+    /// Other than error handling, this method is identical to [`RngCore::fill_bytes`];
+    /// thus this may be implemented using `Ok(self.fill_bytes(dest))` or
+    /// `fill_bytes` may be implemented with
+    /// `self.try_fill_bytes(dest).unwrap()` or more specific error handling.
+    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error>;
+}
+
+/// A marker trait used to indicate that an [`RngCore`] or [`BlockRngCore`]
+/// implementation is supposed to be cryptographically secure.
+///
+/// *Cryptographically secure generators*, also known as *CSPRNGs*, should
+/// satisfy an additional properties over other generators: given the first
+/// *k* bits of an algorithm's output
+/// sequence, it should not be possible using polynomial-time algorithms to
+/// predict the next bit with probability significantly greater than 50%.
+///
+/// Some generators may satisfy an additional property, however this is not
+/// required by this trait: if the CSPRNG's state is revealed, it should not be
+/// computationally-feasible to reconstruct output prior to this. Some other
+/// generators allow backwards-computation and are considered *reversible*.
+///
+/// Note that this trait is provided for guidance only and cannot guarantee
+/// suitability for cryptographic applications. In general it should only be
+/// implemented for well-reviewed code implementing well-regarded algorithms.
+///
+/// Note also that use of a `CryptoRng` does not protect against other
+/// weaknesses such as seeding from a weak entropy source or leaking state.
+///
+/// [`BlockRngCore`]: block::BlockRngCore
+pub trait CryptoRng {}
+
+/// An extension trait that is automatically implemented for any type
+/// implementing [`RngCore`] and [`CryptoRng`].
+///
+/// It may be used as a trait object, and supports upcasting to [`RngCore`] via
+/// the [`CryptoRngCore::as_rngcore`] method.
+///
+/// # Example
+///
+/// ```
+/// use rand_core::CryptoRngCore;
+///
+/// #[allow(unused)]
+/// fn make_token(rng: &mut dyn CryptoRngCore) -> [u8; 32] {
+///     let mut buf = [0u8; 32];
+///     rng.fill_bytes(&mut buf);
+///     buf
+/// }
+/// ```
+pub trait CryptoRngCore: CryptoRng + RngCore {
+    /// Upcast to an [`RngCore`] trait object.
+    fn as_rngcore(&mut self) -> &mut dyn RngCore;
+}
+
+impl<T: CryptoRng + RngCore> CryptoRngCore for T {
+    fn as_rngcore(&mut self) -> &mut dyn RngCore {
+        self
+    }
+}
+
+/// A random number generator that can be explicitly seeded.
+///
+/// This trait encapsulates the low-level functionality common to all
+/// pseudo-random number generators (PRNGs, or algorithmic generators).
+///
+/// [`rand`]: https://docs.rs/rand
+pub trait SeedableRng: Sized {
+    /// Seed type, which is restricted to types mutably-dereferenceable as `u8`
+    /// arrays (we recommend `[u8; N]` for some `N`).
+    ///
+    /// It is recommended to seed PRNGs with a seed of at least circa 100 bits,
+    /// which means an array of `[u8; 12]` or greater to avoid picking RNGs with
+    /// partially overlapping periods.
+    ///
+    /// For cryptographic RNG's a seed of 256 bits is recommended, `[u8; 32]`.
+    ///
+    ///
+    /// # Implementing `SeedableRng` for RNGs with large seeds
+    ///
+    /// Note that the required traits `core::default::Default` and
+    /// `core::convert::AsMut<u8>` are not implemented for large arrays
+    /// `[u8; N]` with `N` > 32. To be able to implement the traits required by
+    /// `SeedableRng` for RNGs with such large seeds, the newtype pattern can be
+    /// used:
+    ///
+    /// ```
+    /// use rand_core::SeedableRng;
+    ///
+    /// const N: usize = 64;
+    /// pub struct MyRngSeed(pub [u8; N]);
+    /// pub struct MyRng(MyRngSeed);
+    ///
+    /// impl Default for MyRngSeed {
+    ///     fn default() -> MyRngSeed {
+    ///         MyRngSeed([0; N])
+    ///     }
+    /// }
+    ///
+    /// impl AsMut<[u8]> for MyRngSeed {
+    ///     fn as_mut(&mut self) -> &mut [u8] {
+    ///         &mut self.0
+    ///     }
+    /// }
+    ///
+    /// impl SeedableRng for MyRng {
+    ///     type Seed = MyRngSeed;
+    ///
+    ///     fn from_seed(seed: MyRngSeed) -> MyRng {
+    ///         MyRng(seed)
+    ///     }
+    /// }
+    /// ```
+    type Seed: Sized + Default + AsMut<[u8]>;
+
+    /// Create a new PRNG using the given seed.
+    ///
+    /// PRNG implementations are allowed to assume that bits in the seed are
+    /// well distributed. That means usually that the number of one and zero
+    /// bits are roughly equal, and values like 0, 1 and (size - 1) are unlikely.
+    /// Note that many non-cryptographic PRNGs will show poor quality output
+    /// if this is not adhered to. If you wish to seed from simple numbers, use
+    /// `seed_from_u64` instead.
+    ///
+    /// All PRNG implementations should be reproducible unless otherwise noted:
+    /// given a fixed `seed`, the same sequence of output should be produced
+    /// on all runs, library versions and architectures (e.g. check endianness).
+    /// Any "value-breaking" changes to the generator should require bumping at
+    /// least the minor version and documentation of the change.
+    ///
+    /// It is not required that this function yield the same state as a
+    /// reference implementation of the PRNG given equivalent seed; if necessary
+    /// another constructor replicating behaviour from a reference
+    /// implementation can be added.
+    ///
+    /// PRNG implementations should make sure `from_seed` never panics. In the
+    /// case that some special values (like an all zero seed) are not viable
+    /// seeds it is preferable to map these to alternative constant value(s),
+    /// for example `0xBAD5EEDu32` or `0x0DDB1A5E5BAD5EEDu64` ("odd biases? bad
+    /// seed"). This is assuming only a small number of values must be rejected.
+    fn from_seed(seed: Self::Seed) -> Self;
+
+    /// Create a new PRNG using a `u64` seed.
+    ///
+    /// This is a convenience-wrapper around `from_seed` to allow construction
+    /// of any `SeedableRng` from a simple `u64` value. It is designed such that
+    /// low Hamming Weight numbers like 0 and 1 can be used and should still
+    /// result in good, independent seeds to the PRNG which is returned.
+    ///
+    /// This **is not suitable for cryptography**, as should be clear given that
+    /// the input size is only 64 bits.
+    ///
+    /// Implementations for PRNGs *may* provide their own implementations of
+    /// this function, but the default implementation should be good enough for
+    /// all purposes. *Changing* the implementation of this function should be
+    /// considered a value-breaking change.
+    fn seed_from_u64(mut state: u64) -> Self {
+        // We use PCG32 to generate a u32 sequence, and copy to the seed
+        fn pcg32(state: &mut u64) -> [u8; 4] {
+            const MUL: u64 = 6364136223846793005;
+            const INC: u64 = 11634580027462260723;
+
+            // We advance the state first (to get away from the input value,
+            // in case it has low Hamming Weight).
+            *state = state.wrapping_mul(MUL).wrapping_add(INC);
+            let state = *state;
+
+            // Use PCG output function with to_le to generate x:
+            let xorshifted = (((state >> 18) ^ state) >> 27) as u32;
+            let rot = (state >> 59) as u32;
+            let x = xorshifted.rotate_right(rot);
+            x.to_le_bytes()
+        }
+
+        let mut seed = Self::Seed::default();
+        let mut iter = seed.as_mut().chunks_exact_mut(4);
+        for chunk in &mut iter {
+            chunk.copy_from_slice(&pcg32(&mut state));
+        }
+        let rem = iter.into_remainder();
+        if !rem.is_empty() {
+            rem.copy_from_slice(&pcg32(&mut state)[..rem.len()]);
+        }
+
+        Self::from_seed(seed)
+    }
+
+    /// Create a new PRNG seeded from another `Rng`.
+    ///
+    /// This may be useful when needing to rapidly seed many PRNGs from a master
+    /// PRNG, and to allow forking of PRNGs. It may be considered deterministic.
+    ///
+    /// The master PRNG should be at least as high quality as the child PRNGs.
+    /// When seeding non-cryptographic child PRNGs, we recommend using a
+    /// different algorithm for the master PRNG (ideally a CSPRNG) to avoid
+    /// correlations between the child PRNGs. If this is not possible (e.g.
+    /// forking using small non-crypto PRNGs) ensure that your PRNG has a good
+    /// mixing function on the output or consider use of a hash function with
+    /// `from_seed`.
+    ///
+    /// Note that seeding `XorShiftRng` from another `XorShiftRng` provides an
+    /// extreme example of what can go wrong: the new PRNG will be a clone
+    /// of the parent.
+    ///
+    /// PRNG implementations are allowed to assume that a good RNG is provided
+    /// for seeding, and that it is cryptographically secure when appropriate.
+    /// As of `rand` 0.7 / `rand_core` 0.5, implementations overriding this
+    /// method should ensure the implementation satisfies reproducibility
+    /// (in prior versions this was not required).
+    ///
+    /// [`rand`]: https://docs.rs/rand
+    fn from_rng<R: RngCore>(mut rng: R) -> Result<Self, Error> {
+        let mut seed = Self::Seed::default();
+        rng.try_fill_bytes(seed.as_mut())?;
+        Ok(Self::from_seed(seed))
+    }
+
+    /// Creates a new instance of the RNG seeded via [`getrandom`].
+    ///
+    /// This method is the recommended way to construct non-deterministic PRNGs
+    /// since it is convenient and secure.
+    ///
+    /// In case the overhead of using [`getrandom`] to seed *many* PRNGs is an
+    /// issue, one may prefer to seed from a local PRNG, e.g.
+    /// `from_rng(thread_rng()).unwrap()`.
+    ///
+    /// # Panics
+    ///
+    /// If [`getrandom`] is unable to provide secure entropy this method will panic.
+    ///
+    /// [`getrandom`]: https://docs.rs/getrandom
+    #[cfg(feature = "getrandom")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "getrandom")))]
+    fn from_entropy() -> Self {
+        let mut seed = Self::Seed::default();
+        if let Err(err) = getrandom::getrandom(seed.as_mut()) {
+            panic!("from_entropy failed: {}", err);
+        }
+        Self::from_seed(seed)
+    }
+}
+
+// Implement `RngCore` for references to an `RngCore`.
+// Force inlining all functions, so that it is up to the `RngCore`
+// implementation and the optimizer to decide on inlining.
+impl<'a, R: RngCore + ?Sized> RngCore for &'a mut R {
+    #[inline(always)]
+    fn next_u32(&mut self) -> u32 {
+        (**self).next_u32()
+    }
+
+    #[inline(always)]
+    fn next_u64(&mut self) -> u64 {
+        (**self).next_u64()
+    }
+
+    #[inline(always)]
+    fn fill_bytes(&mut self, dest: &mut [u8]) {
+        (**self).fill_bytes(dest)
+    }
+
+    #[inline(always)]
+    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
+        (**self).try_fill_bytes(dest)
+    }
+}
+
+// Implement `RngCore` for boxed references to an `RngCore`.
+// Force inlining all functions, so that it is up to the `RngCore`
+// implementation and the optimizer to decide on inlining.
+#[cfg(feature = "alloc")]
+impl<R: RngCore + ?Sized> RngCore for Box<R> {
+    #[inline(always)]
+    fn next_u32(&mut self) -> u32 {
+        (**self).next_u32()
+    }
+
+    #[inline(always)]
+    fn next_u64(&mut self) -> u64 {
+        (**self).next_u64()
+    }
+
+    #[inline(always)]
+    fn fill_bytes(&mut self, dest: &mut [u8]) {
+        (**self).fill_bytes(dest)
+    }
+
+    #[inline(always)]
+    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
+        (**self).try_fill_bytes(dest)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::io::Read for dyn RngCore {
+    fn read(&mut self, buf: &mut [u8]) -> Result<usize, std::io::Error> {
+        self.try_fill_bytes(buf)?;
+        Ok(buf.len())
+    }
+}
+
+// Implement `CryptoRng` for references to a `CryptoRng`.
+impl<'a, R: CryptoRng + ?Sized> CryptoRng for &'a mut R {}
+
+// Implement `CryptoRng` for boxed references to a `CryptoRng`.
+#[cfg(feature = "alloc")]
+impl<R: CryptoRng + ?Sized> CryptoRng for Box<R> {}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_seed_from_u64() {
+        struct SeedableNum(u64);
+        impl SeedableRng for SeedableNum {
+            type Seed = [u8; 8];
+
+            fn from_seed(seed: Self::Seed) -> Self {
+                let mut x = [0u64; 1];
+                le::read_u64_into(&seed, &mut x);
+                SeedableNum(x[0])
+            }
+        }
+
+        const N: usize = 8;
+        const SEEDS: [u64; N] = [0u64, 1, 2, 3, 4, 8, 16, -1i64 as u64];
+        let mut results = [0u64; N];
+        for (i, seed) in SEEDS.iter().enumerate() {
+            let SeedableNum(x) = SeedableNum::seed_from_u64(*seed);
+            results[i] = x;
+        }
+
+        for (i1, r1) in results.iter().enumerate() {
+            let weight = r1.count_ones();
+            // This is the binomial distribution B(64, 0.5), so chance of
+            // weight < 20 is binocdf(19, 64, 0.5) = 7.8e-4, and same for
+            // weight > 44.
+            assert!((20..=44).contains(&weight));
+
+            for (i2, r2) in results.iter().enumerate() {
+                if i1 == i2 {
+                    continue;
+                }
+                let diff_weight = (r1 ^ r2).count_ones();
+                assert!(diff_weight >= 20);
+            }
+        }
+
+        // value-breakage test:
+        assert_eq!(results[0], 5029875928683246316);
+    }
+}
diff --git a/crates/rand_core/src/os.rs b/crates/rand_core/src/os.rs
new file mode 100644
index 0000000..6cd1b9c
--- /dev/null
+++ b/crates/rand_core/src/os.rs
@@ -0,0 +1,85 @@
+// Copyright 2019 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Interface to the random number generator of the operating system.
+
+use crate::{impls, CryptoRng, Error, RngCore};
+use getrandom::getrandom;
+
+/// A random number generator that retrieves randomness from the
+/// operating system.
+///
+/// This is a zero-sized struct. It can be freely constructed with `OsRng`.
+///
+/// The implementation is provided by the [getrandom] crate. Refer to
+/// [getrandom] documentation for details.
+///
+/// This struct is only available when specifying the crate feature `getrandom`
+/// or `std`. When using the `rand` lib, it is also available as `rand::rngs::OsRng`.
+///
+/// # Blocking and error handling
+///
+/// It is possible that when used during early boot the first call to `OsRng`
+/// will block until the system's RNG is initialised. It is also possible
+/// (though highly unlikely) for `OsRng` to fail on some platforms, most
+/// likely due to system mis-configuration.
+///
+/// After the first successful call, it is highly unlikely that failures or
+/// significant delays will occur (although performance should be expected to
+/// be much slower than a user-space PRNG).
+///
+/// # Usage example
+/// ```
+/// use rand_core::{RngCore, OsRng};
+///
+/// let mut key = [0u8; 16];
+/// OsRng.fill_bytes(&mut key);
+/// let random_u64 = OsRng.next_u64();
+/// ```
+///
+/// [getrandom]: https://crates.io/crates/getrandom
+#[cfg_attr(doc_cfg, doc(cfg(feature = "getrandom")))]
+#[derive(Clone, Copy, Debug, Default)]
+pub struct OsRng;
+
+impl CryptoRng for OsRng {}
+
+impl RngCore for OsRng {
+    fn next_u32(&mut self) -> u32 {
+        impls::next_u32_via_fill(self)
+    }
+
+    fn next_u64(&mut self) -> u64 {
+        impls::next_u64_via_fill(self)
+    }
+
+    fn fill_bytes(&mut self, dest: &mut [u8]) {
+        if let Err(e) = self.try_fill_bytes(dest) {
+            panic!("Error: {}", e);
+        }
+    }
+
+    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
+        getrandom(dest)?;
+        Ok(())
+    }
+}
+
+#[test]
+fn test_os_rng() {
+    let x = OsRng.next_u64();
+    let y = OsRng.next_u64();
+    assert!(x != 0);
+    assert!(x != y);
+}
+
+#[test]
+fn test_construction() {
+    let mut rng = OsRng::default();
+    assert!(rng.next_u64() != 0);
+}
diff --git a/crates/rand_xorshift/.cargo-checksum.json b/crates/rand_xorshift/.cargo-checksum.json
new file mode 100644
index 0000000..d23b040
--- /dev/null
+++ b/crates/rand_xorshift/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"CHANGELOG.md":"76d4654c4bf382be2e970861545722323436a9ea1c9a239c293e055a67a38109","COPYRIGHT":"90eb64f0279b0d9432accfa6023ff803bc4965212383697eee27a0f426d5f8d5","Cargo.toml":"8831fe280bfa28371000e6b6b4b65db57f904def97eee8c1ba3e9607db2571c8","LICENSE-APACHE":"aaff376532ea30a0cd5330b9502ad4a4c8bf769c539c87ffe78819d188a18ebf","LICENSE-MIT":"209fbbe0ad52d9235e37badf9cadfe4dbdc87203179c0899e738b39ade42177b","README.md":"66b98cefe946383e7e82c2ffeb89a28dc50ee0c09ae8d16c18f0b69e06dba92c","src/lib.rs":"b3737134f16ae788b130ae80a06400af79a3655b92ca8935efa5083959dc963b","tests/mod.rs":"aaea1940ccb26ab48d4c404a94bc694a94b06b29f214a42b0f13b147f82b6fc5"},"package":"d25bf25ec5ae4a3f1b92f929810509a2f53d7dca2f50b794ff57e3face536c8f"}
\ No newline at end of file
diff --git a/crates/rand_xorshift/Android.bp b/crates/rand_xorshift/Android.bp
new file mode 100644
index 0000000..9d99bb0
--- /dev/null
+++ b/crates/rand_xorshift/Android.bp
@@ -0,0 +1,51 @@
+// This file is generated by cargo_embargo.
+// Do not modify this file because the changes will be overridden on upgrade.
+
+package {
+    default_applicable_licenses: ["external_rust_crates_rand_xorshift_license"],
+    default_team: "trendy_team_android_rust",
+}
+
+license {
+    name: "external_rust_crates_rand_xorshift_license",
+    visibility: [":__subpackages__"],
+    license_kinds: ["SPDX-license-identifier-Apache-2.0"],
+    license_text: ["LICENSE"],
+}
+
+rust_library {
+    name: "librand_xorshift",
+    host_supported: true,
+    crate_name: "rand_xorshift",
+    cargo_env_compat: true,
+    cargo_pkg_version: "0.3.0",
+    crate_root: "src/lib.rs",
+    edition: "2018",
+    rustlibs: ["librand_core"],
+    apex_available: [
+        "//apex_available:platform",
+        "//apex_available:anyapex",
+    ],
+    product_available: true,
+    vendor_available: true,
+}
+
+rust_test {
+    name: "rand_xorshift_test_tests_mod",
+    host_supported: true,
+    crate_name: "mod",
+    cargo_env_compat: true,
+    cargo_pkg_version: "0.3.0",
+    crate_root: "tests/mod.rs",
+    test_suites: ["general-tests"],
+    auto_gen_config: true,
+    test_options: {
+        unit_test: true,
+    },
+    edition: "2018",
+    rustlibs: [
+        "libbincode",
+        "librand_core",
+        "librand_xorshift",
+    ],
+}
diff --git a/crates/rand_xorshift/CHANGELOG.md b/crates/rand_xorshift/CHANGELOG.md
new file mode 100644
index 0000000..52367bd
--- /dev/null
+++ b/crates/rand_xorshift/CHANGELOG.md
@@ -0,0 +1,24 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.3.0] - 2020-12-18
+- Bump `rand_core` version to 0.6 (#17)
+- Derive PartialEq+Eq for XorShiftRng (#6)
+- Bump serde to 1.0.118 so that `serde1` feature can also be no-std (#12)
+
+## [0.2.0] - 2019-06-12
+- Bump minor crate version since rand_core bump is a breaking change
+- Switch to Edition 2018
+
+## [0.1.2] - 2019-06-06 - yanked
+- Bump `rand_core` version
+- Make XorShiftRng::from_rng portable by enforcing Endianness (#815)
+
+## [0.1.1] - 2019-01-04
+- Reorganise code and tests; tweak doc
+
+## [0.1.0] - 2018-07-16
+- Pulled out of the Rand crate
diff --git a/crates/rand_xorshift/COPYRIGHT b/crates/rand_xorshift/COPYRIGHT
new file mode 100644
index 0000000..468d907
--- /dev/null
+++ b/crates/rand_xorshift/COPYRIGHT
@@ -0,0 +1,12 @@
+Copyrights in the Rand project are retained by their contributors. No
+copyright assignment is required to contribute to the Rand project.
+
+For full authorship information, see the version control history.
+
+Except as otherwise noted (below and/or in individual files), Rand is
+licensed under the Apache License, Version 2.0 <LICENSE-APACHE> or
+<http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+<LICENSE-MIT> or <http://opensource.org/licenses/MIT>, at your option.
+
+The Rand project includes code from the Rust project
+published under these same licenses.
diff --git a/crates/rand_xorshift/Cargo.lock b/crates/rand_xorshift/Cargo.lock
new file mode 100644
index 0000000..885c204
--- /dev/null
+++ b/crates/rand_xorshift/Cargo.lock
@@ -0,0 +1,82 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "bincode"
+version = "1.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.86"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+
+[[package]]
+name = "rand_xorshift"
+version = "0.3.0"
+dependencies = [
+ "bincode",
+ "rand_core",
+ "serde",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.209"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "99fce0ffe7310761ca6bf9faf5115afbc19688edd00171d81b1bb1b116c63e09"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.209"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5831b979fd7b5439637af1752d535ff49f4860c0f341d1baeb6faf0f4242170"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.76"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "578e081a14e0cefc3279b0472138c513f37b41a08d5a3cca9b6e4e8ceb6cd525"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
diff --git a/crates/rand_xorshift/Cargo.toml b/crates/rand_xorshift/Cargo.toml
new file mode 100644
index 0000000..335c5d1
--- /dev/null
+++ b/crates/rand_xorshift/Cargo.toml
@@ -0,0 +1,38 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies
+#
+# If you believe there's an error in this file please file an
+# issue against the rust-lang/cargo repository. If you're
+# editing this file be aware that the upstream Cargo.toml
+# will likely look very different (and much more reasonable)
+
+[package]
+edition = "2018"
+name = "rand_xorshift"
+version = "0.3.0"
+authors = ["The Rand Project Developers", "The Rust Project Developers"]
+description = "Xorshift random number generator\n"
+homepage = "https://rust-random.github.io/book"
+documentation = "https://docs.rs/rand_xorshift"
+readme = "README.md"
+keywords = ["random", "rng", "xorshift"]
+categories = ["algorithms", "no-std"]
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/rust-random/rngs"
+[dependencies.rand_core]
+version = "0.6"
+
+[dependencies.serde]
+version = "1.0.118"
+features = ["derive"]
+optional = true
+default-features = false
+[dev-dependencies.bincode]
+version = "1"
+
+[features]
+serde1 = ["serde"]
diff --git a/crates/rand_xorshift/LICENSE b/crates/rand_xorshift/LICENSE
new file mode 120000
index 0000000..6b579aa
--- /dev/null
+++ b/crates/rand_xorshift/LICENSE
@@ -0,0 +1 @@
+LICENSE-APACHE
\ No newline at end of file
diff --git a/crates/rand_xorshift/LICENSE-APACHE b/crates/rand_xorshift/LICENSE-APACHE
new file mode 100644
index 0000000..17d7468
--- /dev/null
+++ b/crates/rand_xorshift/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     https://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	https://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/crates/rand_xorshift/LICENSE-MIT b/crates/rand_xorshift/LICENSE-MIT
new file mode 100644
index 0000000..d93b5ba
--- /dev/null
+++ b/crates/rand_xorshift/LICENSE-MIT
@@ -0,0 +1,26 @@
+Copyright 2018 Developers of the Rand project
+Copyright (c) 2014 The Rust Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/crates/rand_xorshift/METADATA b/crates/rand_xorshift/METADATA
new file mode 100644
index 0000000..f53f05c
--- /dev/null
+++ b/crates/rand_xorshift/METADATA
@@ -0,0 +1,19 @@
+name: "rand_xorshift"
+description: "Xorshift random number generator"
+third_party {
+  url {
+    type: HOMEPAGE
+    value: "https://crates.io/crates/rand_xorshift"
+  }
+  url {
+    type: ARCHIVE
+    value: "https://static.crates.io/crates/rand_xorshift/rand_xorshift-0.3.0.crate"
+  }
+  version: "0.3.0"
+  license_type: NOTICE
+  last_upgrade_date {
+    year: 2020
+    month: 12
+    day: 18
+  }
+}
diff --git a/crates/rand_xorshift/MODULE_LICENSE_APACHE2 b/crates/rand_xorshift/MODULE_LICENSE_APACHE2
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/crates/rand_xorshift/MODULE_LICENSE_APACHE2
diff --git a/crates/rand_xorshift/README.md b/crates/rand_xorshift/README.md
new file mode 100644
index 0000000..df7fa33
--- /dev/null
+++ b/crates/rand_xorshift/README.md
@@ -0,0 +1,45 @@
+# rand_xorshift
+
+[![Build Status](https://travis-ci.org/rust-random/rngs.svg)](https://travis-ci.org/rust-random/rngs)
+[![Build Status](https://ci.appveyor.com/api/projects/status/github/rust-random/rngs?svg=true)](https://ci.appveyor.com/project/rust-random/rngs)
+[![Latest version](https://img.shields.io/crates/v/rand_xorshift.svg)](https://crates.io/crates/rand_xorshift)
+[![Book](https://img.shields.io/badge/book-master-yellow.svg)](https://rust-random.github.io/book/)
+[![API](https://img.shields.io/badge/api-master-yellow.svg)](https://rust-random.github.io/rand/rand_xorshift)
+[![API](https://docs.rs/rand_xorshift/badge.svg)](https://docs.rs/rand_xorshift)
+[![Minimum rustc version](https://img.shields.io/badge/rustc-1.32+-lightgray.svg)](https://github.com/rust-random/rngs#rust-version-requirements)
+
+Implements the Xorshift random number generator.
+
+The Xorshift[^1] algorithm is not suitable for cryptographic purposes
+but is very fast. If you do not know for sure that it fits your
+requirements, use a more secure one such as `StdRng` or `OsRng`.
+
+[^1]: Marsaglia, George (July 2003).
+      ["Xorshift RNGs"](https://www.jstatsoft.org/v08/i14/paper).
+      *Journal of Statistical Software*. Vol. 8 (Issue 14).
+
+Links:
+
+-   [API documentation (master)](https://rust-random.github.io/rand/rand_xorshift)
+-   [API documentation (docs.rs)](https://docs.rs/rand_xorshift)
+-   [Changelog](https://github.com/rust-random/rngs/blob/master/rand_xorshift/CHANGELOG.md)
+
+[rand]: https://crates.io/crates/rand
+
+
+## Crate Features
+
+`rand_xorshift` is `no_std` compatible. It does not require any functionality
+outside of the `core` lib, thus there are no features to configure.
+
+The `serde1` feature includes implementations of `Serialize` and `Deserialize`
+for the included RNGs.
+
+
+## License
+
+`rand_xorshift` is distributed under the terms of both the MIT license and the
+Apache License (Version 2.0).
+
+See [LICENSE-APACHE](LICENSE-APACHE) and [LICENSE-MIT](LICENSE-MIT), and
+[COPYRIGHT](COPYRIGHT) for details.
diff --git a/crates/rand_xorshift/TEST_MAPPING b/crates/rand_xorshift/TEST_MAPPING
new file mode 100644
index 0000000..ae94940
--- /dev/null
+++ b/crates/rand_xorshift/TEST_MAPPING
@@ -0,0 +1,18 @@
+// Generated by update_crate_tests.py for tests that depend on this crate.
+{
+  "imports": [
+    {
+      "path": "external/rust/crates/ryu"
+    }
+  ],
+  "presubmit": [
+    {
+      "name": "rand_xorshift_test_tests_mod"
+    }
+  ],
+  "presubmit-rust": [
+    {
+      "name": "rand_xorshift_test_tests_mod"
+    }
+  ]
+}
diff --git a/crates/rand_xorshift/cargo_embargo.json b/crates/rand_xorshift/cargo_embargo.json
new file mode 100644
index 0000000..9a0a579
--- /dev/null
+++ b/crates/rand_xorshift/cargo_embargo.json
@@ -0,0 +1,3 @@
+{
+  "tests": true
+}
diff --git a/crates/rand_xorshift/src/lib.rs b/crates/rand_xorshift/src/lib.rs
new file mode 100644
index 0000000..7fb59a4
--- /dev/null
+++ b/crates/rand_xorshift/src/lib.rs
@@ -0,0 +1,117 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! The xorshift random number generator.
+
+#![doc(html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk.png",
+       html_favicon_url = "https://www.rust-lang.org/favicon.ico",
+       html_root_url = "https://docs.rs/rand_xorshift/0.3.0")]
+
+#![deny(missing_docs)]
+#![deny(missing_debug_implementations)]
+
+#![no_std]
+
+use core::num::Wrapping as w;
+use core::fmt;
+use rand_core::{RngCore, SeedableRng, Error, impls, le};
+#[cfg(feature="serde1")] use serde::{Serialize, Deserialize};
+
+/// An Xorshift random number generator.
+///
+/// The Xorshift[^1] algorithm is not suitable for cryptographic purposes
+/// but is very fast. If you do not know for sure that it fits your
+/// requirements, use a more secure one such as `StdRng` or `OsRng`.
+///
+/// [^1]: Marsaglia, George (July 2003).
+///       ["Xorshift RNGs"](https://www.jstatsoft.org/v08/i14/paper).
+///       *Journal of Statistical Software*. Vol. 8 (Issue 14).
+#[derive(Clone, PartialEq, Eq)]
+#[cfg_attr(feature="serde1", derive(Serialize,Deserialize))]
+pub struct XorShiftRng {
+    x: w<u32>,
+    y: w<u32>,
+    z: w<u32>,
+    w: w<u32>,
+}
+
+// Custom Debug implementation that does not expose the internal state
+impl fmt::Debug for XorShiftRng {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "XorShiftRng {{}}")
+    }
+}
+
+impl RngCore for XorShiftRng {
+    #[inline]
+    fn next_u32(&mut self) -> u32 {
+        let x = self.x;
+        let t = x ^ (x << 11);
+        self.x = self.y;
+        self.y = self.z;
+        self.z = self.w;
+        let w_ = self.w;
+        self.w = w_ ^ (w_ >> 19) ^ (t ^ (t >> 8));
+        self.w.0
+    }
+
+    #[inline]
+    fn next_u64(&mut self) -> u64 {
+        impls::next_u64_via_u32(self)
+    }
+
+    #[inline]
+    fn fill_bytes(&mut self, dest: &mut [u8]) {
+        impls::fill_bytes_via_next(self, dest)
+    }
+
+    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
+        self.fill_bytes(dest);
+        Ok(())
+    }
+}
+
+impl SeedableRng for XorShiftRng {
+    type Seed = [u8; 16];
+
+    fn from_seed(seed: Self::Seed) -> Self {
+        let mut seed_u32 = [0u32; 4];
+        le::read_u32_into(&seed, &mut seed_u32);
+
+        // Xorshift cannot be seeded with 0 and we cannot return an Error, but
+        // also do not wish to panic (because a random seed can legitimately be
+        // 0); our only option is therefore to use a preset value.
+        if seed_u32.iter().all(|&x| x == 0) {
+            seed_u32 = [0xBAD_5EED, 0xBAD_5EED, 0xBAD_5EED, 0xBAD_5EED];
+        }
+
+        XorShiftRng {
+            x: w(seed_u32[0]),
+            y: w(seed_u32[1]),
+            z: w(seed_u32[2]),
+            w: w(seed_u32[3]),
+        }
+    }
+
+    fn from_rng<R: RngCore>(mut rng: R) -> Result<Self, Error> {
+        let mut b = [0u8; 16];
+        loop {
+            rng.try_fill_bytes(&mut b[..])?;
+            if !b.iter().all(|&x| x == 0) {
+                break;
+            }
+        }
+
+        Ok(XorShiftRng {
+            x: w(u32::from_le_bytes([b[0], b[1], b[2], b[3]])),
+            y: w(u32::from_le_bytes([b[4], b[5], b[6], b[7]])),
+            z: w(u32::from_le_bytes([b[8], b[9], b[10], b[11]])),
+            w: w(u32::from_le_bytes([b[12], b[13], b[14], b[15]])),
+        })
+    }
+}
diff --git a/crates/rand_xorshift/tests/mod.rs b/crates/rand_xorshift/tests/mod.rs
new file mode 100644
index 0000000..7ecdeae
--- /dev/null
+++ b/crates/rand_xorshift/tests/mod.rs
@@ -0,0 +1,89 @@
+use rand_core::{RngCore, SeedableRng};
+use rand_xorshift::XorShiftRng;
+
+#[test]
+fn test_xorshift_construction() {
+    // Test that various construction techniques produce a working RNG.
+    let seed = [1,2,3,4, 5,6,7,8, 9,10,11,12, 13,14,15,16];
+    let mut rng1 = XorShiftRng::from_seed(seed);
+    assert_eq!(rng1.next_u64(), 4325440999699518727);
+
+    let mut rng2 = XorShiftRng::from_rng(&mut rng1).unwrap();
+    // Yes, this makes rng2 a clone of rng1!
+    assert_eq!(rng1.next_u64(), 15614385950550801700);
+    assert_eq!(rng2.next_u64(), 15614385950550801700);
+}
+
+#[test]
+fn test_xorshift_true_values() {
+    let seed = [16,15,14,13, 12,11,10,9, 8,7,6,5, 4,3,2,1];
+    let mut rng = XorShiftRng::from_seed(seed);
+
+    let mut results = [0u32; 9];
+    for i in results.iter_mut() { *i = rng.next_u32(); }
+    let expected: [u32; 9] = [
+        2081028795, 620940381, 269070770, 16943764, 854422573, 29242889,
+        1550291885, 1227154591, 271695242];
+    assert_eq!(results, expected);
+
+    let mut results = [0u64; 9];
+    for i in results.iter_mut() { *i = rng.next_u64(); }
+    let expected: [u64; 9] = [
+        9247529084182843387, 8321512596129439293, 14104136531997710878,
+        6848554330849612046, 343577296533772213, 17828467390962600268,
+        9847333257685787782, 7717352744383350108, 1133407547287910111];
+    assert_eq!(results, expected);
+
+    let mut results = [0u8; 32];
+    rng.fill_bytes(&mut results);
+    let expected = [102, 57, 212, 16, 233, 130, 49, 183,
+                    158, 187, 44, 203, 63, 149, 45, 17,
+                    117, 129, 131, 160, 70, 121, 158, 155,
+                    224, 209, 192, 53, 10, 62, 57, 72];
+    assert_eq!(results, expected);
+}
+
+#[test]
+fn test_xorshift_zero_seed() {
+    // Xorshift does not work with an all zero seed.
+    // Assert it does not panic.
+    let seed = [0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0];
+    let mut rng = XorShiftRng::from_seed(seed);
+    let a = rng.next_u64();
+    let b = rng.next_u64();
+    assert!(a != 0);
+    assert!(b != a);
+}
+
+#[test]
+fn test_xorshift_clone() {
+    let seed = [1,2,3,4, 5,5,7,8, 8,7,6,5, 4,3,2,1];
+    let mut rng1 = XorShiftRng::from_seed(seed);
+    let mut rng2 = rng1.clone();
+    for _ in 0..16 {
+        assert_eq!(rng1.next_u64(), rng2.next_u64());
+    }
+}
+
+#[cfg(feature="serde1")]
+#[test]
+fn test_xorshift_serde() {
+    use bincode;
+    use std::io::{BufWriter, BufReader};
+
+    let seed = [1,2,3,4, 5,6,7,8, 9,10,11,12, 13,14,15,16];
+    let mut rng = XorShiftRng::from_seed(seed);
+
+    let buf: Vec<u8> = Vec::new();
+    let mut buf = BufWriter::new(buf);
+    bincode::serialize_into(&mut buf, &rng).expect("Could not serialize");
+
+    let buf = buf.into_inner().unwrap();
+    let mut read = BufReader::new(&buf[..]);
+    let mut deserialized: XorShiftRng = bincode::deserialize_from(&mut read)
+        .expect("Could not deserialize");
+
+    for _ in 0..16 {
+        assert_eq!(rng.next_u64(), deserialized.next_u64());
+    }
+}
diff --git a/crates/rayon-core/.cargo-checksum.json b/crates/rayon-core/.cargo-checksum.json
new file mode 100644
index 0000000..16769ab
--- /dev/null
+++ b/crates/rayon-core/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"60f04aab82c6489c779cf19535fddf0ec1a673edc07f523c66c10996806d2fbe","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"0621878e61f0d0fda054bcbe02df75192c28bde1ecc8289cbd86aeba2dd72720","README.md":"7281273bea1d5fdc57731513cf9f0e3b911d06ac9905b03a8375a1324951c35b","build.rs":"fa31cb198b772600d100a7c403ddedccef637d2e6b2da431fa7f02ca41307fc6","src/broadcast/mod.rs":"2c9a84e7e6e5e8d8e23e28d6f2703825d7d6af59f0a16bc6125d5f0d25bd7598","src/broadcast/test.rs":"fe50fc868e67d855a9f71e078b0c3a7780e789652abb4b586accb4ccf035e872","src/compile_fail/mod.rs":"4d70256295bd64691a8c1994b323559cda1888e85f0b45ca55711541c257dcb6","src/compile_fail/quicksort_race1.rs":"35f498cda38f4eb6e00117f78ed68e0fe5a3fa61c25303d9c08a19bda345bc6c","src/compile_fail/quicksort_race2.rs":"cbb40030c7867cae34bb373b6ec5d97c2ac6de39bc917f47879b30eb423924bc","src/compile_fail/quicksort_race3.rs":"8403643e64c969306b1a9b1243378e6ccdd313b57e1878dbd31393618082fd35","src/compile_fail/rc_return.rs":"197894803d8df58fc8005d90c86b90cd98f1972f1a4b57438516a565df35903f","src/compile_fail/rc_upvar.rs":"42d110429621f407ef0dada1306dab116583d2c782a99894204dd8e0ccd2312f","src/compile_fail/scope_join_bad.rs":"892959949f77cadfc07458473e7a290301182027ca64428df5a8ce887be0892b","src/job.rs":"06de0c2add2e303b6383bf11f5f0d75775c1efe6aa7bc16de3992117f1012f09","src/join/mod.rs":"7638c0fc1da1a2d2b14673c8a2e0f87d26c24232cebee26fd334bdc2caa80886","src/join/test.rs":"157db5306e8df89a8eea19dbba499f26c2f44d9803cb36a796c852a9a695821e","src/latch.rs":"3f5c73cc6998d7cea177c19a3c7ce0d4a5667c65d77f744a2159872f09e8fba6","src/lib.rs":"d34f6cbaba40293d3b3e095bd2eae989cce3467fe686835a37e80652ca8133df","src/private.rs":"152f6d65ce4741616a1dec796b9442f78a018d38bb040f76c4cd85008333a3bb","src/registry.rs":"bcfedc6d51eade2bedc30271ab8b21e98700e45f74bd8967d02ae6fe17f73a94","src/scope/mod.rs":"421a5561093928b1d0081d34c2bff78377055d8f6de0689088f52fe476d3a56a","src/scope/test.rs":"d4f068cae4ee4483b41bd3054582d96e74ced46eb57361e7510ef62d4318d340","src/sleep/README.md":"e1ac1a5556cf257f38b7654feb0615c208d9186fefbe52a584d4fe6545d7c373","src/sleep/counters.rs":"e9eccc7d76d17415156c12d30cc7bf89a5c64ca5742965bb4e6c1ce23c2782e9","src/sleep/mod.rs":"7576bc0a54c30f35b10c63a6fd23f2e33774ba994352634ea1ca7865818fb2a4","src/spawn/mod.rs":"087d2a3e5fd5dd22a780c14d71509f9eea0bac92ccfa35d9933c0b39b3e269e1","src/spawn/test.rs":"a28f8943f28a4cef642b6429c538b1df879c9eb1db9927ce69b97c686bf81173","src/test.rs":"7d0dee06fcf41bddf77449a85cece44133f966a0622a31cf3ed110fbe83e094e","src/thread_pool/mod.rs":"4c85b46eb8ba05631b658996f0d6c64247a05575c89621e0a54a1fc056cc447f","src/thread_pool/test.rs":"657b1938993eb98fb5f3fd1d02a77728e37d0e833390b4ba82926b9107ce3170","src/unwind.rs":"7baa4511467d008b14856ea8de7ced92b9251c9df4854f69c81f7efc3cf0cd6c","tests/double_init_fail.rs":"8c208ce45e83ab1dfc5890353d5b2f06fc8005684ae622827a65d05abb35a072","tests/init_zero_threads.rs":"5c7f7e0e13e9ead3733253e30d6b52ac5ee66fd6c105999d096bdf31cfccaf95","tests/scope_join.rs":"56f570c4b6a01704aacf93e7f17f89fe0f40f46ed6f9ede517abfe9adaf91f83","tests/scoped_threadpool.rs":"24d1293fe65ad5f194bbff9d1ef0486c3440d0a3783f04eaaaae4929adef5cb8","tests/simple_panic.rs":"916d40d36c1a0fad3e1dfb31550f0672641feab4b03d480f039143dbe2f2445f","tests/stack_overflow_crash.rs":"87b962c66f301ac44f808d992d4e8b861305db0c282f256761a5075c9f018243","tests/use_current_thread.rs":"fe1b981e77e422e616c09502731a70fb2f1c023d2386ef32c9d47e5a6f5bc162"},"package":"1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2"}
\ No newline at end of file
diff --git a/crates/rayon-core/Android.bp b/crates/rayon-core/Android.bp
new file mode 100644
index 0000000..2652f01
--- /dev/null
+++ b/crates/rayon-core/Android.bp
@@ -0,0 +1,34 @@
+// This file is generated by cargo_embargo.
+// Do not modify this file because the changes will be overridden on upgrade.
+
+package {
+    default_applicable_licenses: ["external_rust_crates_rayon-core_license"],
+    default_team: "trendy_team_android_rust",
+}
+
+license {
+    name: "external_rust_crates_rayon-core_license",
+    visibility: [":__subpackages__"],
+    license_kinds: ["SPDX-license-identifier-Apache-2.0"],
+    license_text: ["LICENSE"],
+}
+
+rust_library {
+    name: "librayon_core",
+    host_supported: true,
+    crate_name: "rayon_core",
+    cargo_env_compat: true,
+    cargo_pkg_version: "1.12.1",
+    crate_root: "src/lib.rs",
+    edition: "2021",
+    rustlibs: [
+        "libcrossbeam_deque",
+        "libcrossbeam_utils",
+    ],
+    apex_available: [
+        "//apex_available:platform",
+        "//apex_available:anyapex",
+    ],
+    product_available: true,
+    vendor_available: true,
+}
diff --git a/crates/rayon-core/Cargo.lock b/crates/rayon-core/Cargo.lock
new file mode 100644
index 0000000..9d200b1
--- /dev/null
+++ b/crates/rayon-core/Cargo.lock
@@ -0,0 +1,289 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "bumpalo"
+version = "3.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c"
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "613f8cc01fe9cf1a3eb3d7f488fd2fa8388403e97039e2f73692932e291a770d"
+dependencies = [
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22ec99545bb0ed0ea7bb9b8e1e9122ea386ff8a48c0922e43f36d45ab09e0e80"
+
+[[package]]
+name = "getrandom"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "js-sys"
+version = "0.3.70"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1868808506b929d7b0cfa8f75951347aa71bb21144b7791bae35d9bccfcfe37a"
+dependencies = [
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.158"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439"
+
+[[package]]
+name = "log"
+version = "0.4.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
+
+[[package]]
+name = "once_cell"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.86"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "rand_xorshift"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d25bf25ec5ae4a3f1b92f929810509a2f53d7dca2f50b794ff57e3face536c8f"
+dependencies = [
+ "rand_core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.12.1"
+dependencies = [
+ "crossbeam-deque",
+ "crossbeam-utils",
+ "libc",
+ "rand",
+ "rand_xorshift",
+ "scoped-tls",
+ "wasm_sync",
+]
+
+[[package]]
+name = "scoped-tls"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294"
+
+[[package]]
+name = "syn"
+version = "2.0.76"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "578e081a14e0cefc3279b0472138c513f37b41a08d5a3cca9b6e4e8ceb6cd525"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
+
+[[package]]
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.93"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a82edfc16a6c469f5f44dc7b571814045d60404b55a0ee849f9bcfa2e63dd9b5"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "wasm-bindgen-macro",
+]
+
+[[package]]
+name = "wasm-bindgen-backend"
+version = "0.2.93"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9de396da306523044d3302746f1208fa71d7532227f15e347e2d93e4145dd77b"
+dependencies = [
+ "bumpalo",
+ "log",
+ "once_cell",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.93"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "585c4c91a46b072c92e908d99cb1dcdf95c5218eeb6f3bf1efa991ee7a68cccf"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.93"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "afc340c74d9005395cf9dd098506f7f44e38f2b4a21c6aaacf9a105ea5e1e836"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-backend",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.93"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c62a0a307cb4a311d3a07867860911ca130c3494e8c2719593806c08bc5d0484"
+
+[[package]]
+name = "wasm_sync"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cff360cade7fec41ff0e9d2cda57fe58258c5f16def0e21302394659e6bbb0ea"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "web-sys"
+version = "0.3.70"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26fdeaafd9bd129f65e7c031593c24d62186301e0c72c8978fa1678be7d532c0"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.7.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
+dependencies = [
+ "byteorder",
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.7.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
diff --git a/crates/rayon-core/Cargo.toml b/crates/rayon-core/Cargo.toml
new file mode 100644
index 0000000..a3a11c2
--- /dev/null
+++ b/crates/rayon-core/Cargo.toml
@@ -0,0 +1,88 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2021"
+rust-version = "1.63"
+name = "rayon-core"
+version = "1.12.1"
+authors = [
+    "Niko Matsakis <niko@alum.mit.edu>",
+    "Josh Stone <cuviper@gmail.com>",
+]
+build = "build.rs"
+links = "rayon-core"
+description = "Core APIs for Rayon"
+documentation = "https://docs.rs/rayon/"
+readme = "README.md"
+keywords = [
+    "parallel",
+    "thread",
+    "concurrency",
+    "join",
+    "performance",
+]
+categories = ["concurrency"]
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/rayon-rs/rayon"
+
+[[test]]
+name = "stack_overflow_crash"
+path = "tests/stack_overflow_crash.rs"
+
+[[test]]
+name = "double_init_fail"
+path = "tests/double_init_fail.rs"
+
+[[test]]
+name = "init_zero_threads"
+path = "tests/init_zero_threads.rs"
+
+[[test]]
+name = "scope_join"
+path = "tests/scope_join.rs"
+
+[[test]]
+name = "simple_panic"
+path = "tests/simple_panic.rs"
+
+[[test]]
+name = "scoped_threadpool"
+path = "tests/scoped_threadpool.rs"
+
+[[test]]
+name = "use_current_thread"
+path = "tests/use_current_thread.rs"
+
+[dependencies.crossbeam-deque]
+version = "0.8.1"
+
+[dependencies.crossbeam-utils]
+version = "0.8.0"
+
+[dependencies.wasm_sync]
+version = "0.1.0"
+optional = true
+
+[dev-dependencies.rand]
+version = "0.8"
+
+[dev-dependencies.rand_xorshift]
+version = "0.3"
+
+[dev-dependencies.scoped-tls]
+version = "1.0"
+
+[features]
+web_spin_lock = ["dep:wasm_sync"]
+
+[target."cfg(unix)".dev-dependencies.libc]
+version = "0.2"
diff --git a/crates/rayon-core/LICENSE b/crates/rayon-core/LICENSE
new file mode 120000
index 0000000..6b579aa
--- /dev/null
+++ b/crates/rayon-core/LICENSE
@@ -0,0 +1 @@
+LICENSE-APACHE
\ No newline at end of file
diff --git a/crates/rayon-core/LICENSE-APACHE b/crates/rayon-core/LICENSE-APACHE
new file mode 100644
index 0000000..16fe87b
--- /dev/null
+++ b/crates/rayon-core/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/crates/rayon-core/LICENSE-MIT b/crates/rayon-core/LICENSE-MIT
new file mode 100644
index 0000000..25597d5
--- /dev/null
+++ b/crates/rayon-core/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2010 The Rust Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/crates/rayon-core/METADATA b/crates/rayon-core/METADATA
new file mode 100644
index 0000000..1eb7dcd
--- /dev/null
+++ b/crates/rayon-core/METADATA
@@ -0,0 +1,20 @@
+# This project was upgraded with external_updater.
+# Usage: tools/external_updater/updater.sh update external/rust/crates/rayon-core
+# For more info, check https://cs.android.com/android/platform/superproject/+/main:tools/external_updater/README.md
+
+name: "rayon-core"
+description: "Core APIs for Rayon"
+third_party {
+  license_type: NOTICE
+  last_upgrade_date {
+    year: 2024
+    month: 2
+    day: 6
+  }
+  homepage: "https://crates.io/crates/rayon-core"
+  identifier {
+    type: "Archive"
+    value: "https://static.crates.io/crates/rayon-core/rayon-core-1.12.1.crate"
+    version: "1.12.1"
+  }
+}
diff --git a/crates/rayon-core/MODULE_LICENSE_APACHE2 b/crates/rayon-core/MODULE_LICENSE_APACHE2
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/crates/rayon-core/MODULE_LICENSE_APACHE2
diff --git a/crates/rayon-core/README.md b/crates/rayon-core/README.md
new file mode 100644
index 0000000..6e2ebe2
--- /dev/null
+++ b/crates/rayon-core/README.md
@@ -0,0 +1,11 @@
+Rayon-core represents the "core, stable" APIs of Rayon: join, scope, and so forth, as well as the ability to create custom thread-pools with ThreadPool.
+
+Maybe worth mentioning: users are not necessarily intended to directly access rayon-core; all its APIs are mirror in the rayon crate. To that end, the examples in the docs use rayon::join and so forth rather than rayon_core::join.
+
+rayon-core aims to never, or almost never, have a breaking change to its API, because each revision of rayon-core also houses the global thread-pool (and hence if you have two simultaneous versions of rayon-core, you have two thread-pools).
+
+Please see [Rayon Docs] for details about using Rayon.
+
+[Rayon Docs]: https://docs.rs/rayon/
+
+Rayon-core currently requires `rustc 1.63.0` or greater.
diff --git a/crates/rayon-core/TEST_MAPPING b/crates/rayon-core/TEST_MAPPING
new file mode 100644
index 0000000..55384f0
--- /dev/null
+++ b/crates/rayon-core/TEST_MAPPING
@@ -0,0 +1,20 @@
+// Generated by update_crate_tests.py for tests that depend on this crate.
+{
+  "imports": [
+    {
+      "path": "external/rust/crates/base64"
+    },
+    {
+      "path": "external/rust/crates/hashbrown"
+    },
+    {
+      "path": "external/rust/crates/tinytemplate"
+    },
+    {
+      "path": "external/rust/crates/tinyvec"
+    },
+    {
+      "path": "external/rust/crates/unicode-xid"
+    }
+  ]
+}
diff --git a/crates/rayon-core/build.rs b/crates/rayon-core/build.rs
new file mode 100644
index 0000000..8771b63
--- /dev/null
+++ b/crates/rayon-core/build.rs
@@ -0,0 +1,7 @@
+// We need a build script to use `link = "rayon-core"`.  But we're not
+// *actually* linking to anything, just making sure that we're the only
+// rayon-core in use.
+fn main() {
+    // we don't need to rebuild for anything else
+    println!("cargo:rerun-if-changed=build.rs");
+}
diff --git a/crates/rayon-core/cargo_embargo.json b/crates/rayon-core/cargo_embargo.json
new file mode 100644
index 0000000..cb908d7
--- /dev/null
+++ b/crates/rayon-core/cargo_embargo.json
@@ -0,0 +1,3 @@
+{
+  "run_cargo": false
+}
diff --git a/crates/rayon-core/src/broadcast/mod.rs b/crates/rayon-core/src/broadcast/mod.rs
new file mode 100644
index 0000000..96611e4
--- /dev/null
+++ b/crates/rayon-core/src/broadcast/mod.rs
@@ -0,0 +1,150 @@
+use crate::job::{ArcJob, StackJob};
+use crate::latch::{CountLatch, LatchRef};
+use crate::registry::{Registry, WorkerThread};
+use std::fmt;
+use std::marker::PhantomData;
+use std::sync::Arc;
+
+mod test;
+
+/// Executes `op` within every thread in the current threadpool. If this is
+/// called from a non-Rayon thread, it will execute in the global threadpool.
+/// Any attempts to use `join`, `scope`, or parallel iterators will then operate
+/// within that threadpool. When the call has completed on each thread, returns
+/// a vector containing all of their return values.
+///
+/// For more information, see the [`ThreadPool::broadcast()`][m] method.
+///
+/// [m]: struct.ThreadPool.html#method.broadcast
+pub fn broadcast<OP, R>(op: OP) -> Vec<R>
+where
+    OP: Fn(BroadcastContext<'_>) -> R + Sync,
+    R: Send,
+{
+    // We assert that current registry has not terminated.
+    unsafe { broadcast_in(op, &Registry::current()) }
+}
+
+/// Spawns an asynchronous task on every thread in this thread-pool. This task
+/// will run in the implicit, global scope, which means that it may outlast the
+/// current stack frame -- therefore, it cannot capture any references onto the
+/// stack (you will likely need a `move` closure).
+///
+/// For more information, see the [`ThreadPool::spawn_broadcast()`][m] method.
+///
+/// [m]: struct.ThreadPool.html#method.spawn_broadcast
+pub fn spawn_broadcast<OP>(op: OP)
+where
+    OP: Fn(BroadcastContext<'_>) + Send + Sync + 'static,
+{
+    // We assert that current registry has not terminated.
+    unsafe { spawn_broadcast_in(op, &Registry::current()) }
+}
+
+/// Provides context to a closure called by `broadcast`.
+pub struct BroadcastContext<'a> {
+    worker: &'a WorkerThread,
+
+    /// Make sure to prevent auto-traits like `Send` and `Sync`.
+    _marker: PhantomData<&'a mut dyn Fn()>,
+}
+
+impl<'a> BroadcastContext<'a> {
+    pub(super) fn with<R>(f: impl FnOnce(BroadcastContext<'_>) -> R) -> R {
+        let worker_thread = WorkerThread::current();
+        assert!(!worker_thread.is_null());
+        f(BroadcastContext {
+            worker: unsafe { &*worker_thread },
+            _marker: PhantomData,
+        })
+    }
+
+    /// Our index amongst the broadcast threads (ranges from `0..self.num_threads()`).
+    #[inline]
+    pub fn index(&self) -> usize {
+        self.worker.index()
+    }
+
+    /// The number of threads receiving the broadcast in the thread pool.
+    ///
+    /// # Future compatibility note
+    ///
+    /// Future versions of Rayon might vary the number of threads over time, but
+    /// this method will always return the number of threads which are actually
+    /// receiving your particular `broadcast` call.
+    #[inline]
+    pub fn num_threads(&self) -> usize {
+        self.worker.registry().num_threads()
+    }
+}
+
+impl<'a> fmt::Debug for BroadcastContext<'a> {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt.debug_struct("BroadcastContext")
+            .field("index", &self.index())
+            .field("num_threads", &self.num_threads())
+            .field("pool_id", &self.worker.registry().id())
+            .finish()
+    }
+}
+
+/// Execute `op` on every thread in the pool. It will be executed on each
+/// thread when they have nothing else to do locally, before they try to
+/// steal work from other threads. This function will not return until all
+/// threads have completed the `op`.
+///
+/// Unsafe because `registry` must not yet have terminated.
+pub(super) unsafe fn broadcast_in<OP, R>(op: OP, registry: &Arc<Registry>) -> Vec<R>
+where
+    OP: Fn(BroadcastContext<'_>) -> R + Sync,
+    R: Send,
+{
+    let f = move |injected: bool| {
+        debug_assert!(injected);
+        BroadcastContext::with(&op)
+    };
+
+    let n_threads = registry.num_threads();
+    let current_thread = WorkerThread::current().as_ref();
+    let latch = CountLatch::with_count(n_threads, current_thread);
+    let jobs: Vec<_> = (0..n_threads)
+        .map(|_| StackJob::new(&f, LatchRef::new(&latch)))
+        .collect();
+    let job_refs = jobs.iter().map(|job| job.as_job_ref());
+
+    registry.inject_broadcast(job_refs);
+
+    // Wait for all jobs to complete, then collect the results, maybe propagating a panic.
+    latch.wait(current_thread);
+    jobs.into_iter().map(|job| job.into_result()).collect()
+}
+
+/// Execute `op` on every thread in the pool. It will be executed on each
+/// thread when they have nothing else to do locally, before they try to
+/// steal work from other threads. This function returns immediately after
+/// injecting the jobs.
+///
+/// Unsafe because `registry` must not yet have terminated.
+pub(super) unsafe fn spawn_broadcast_in<OP>(op: OP, registry: &Arc<Registry>)
+where
+    OP: Fn(BroadcastContext<'_>) + Send + Sync + 'static,
+{
+    let job = ArcJob::new({
+        let registry = Arc::clone(registry);
+        move || {
+            registry.catch_unwind(|| BroadcastContext::with(&op));
+            registry.terminate(); // (*) permit registry to terminate now
+        }
+    });
+
+    let n_threads = registry.num_threads();
+    let job_refs = (0..n_threads).map(|_| {
+        // Ensure that registry cannot terminate until this job has executed
+        // on each thread. This ref is decremented at the (*) above.
+        registry.increment_terminate_count();
+
+        ArcJob::as_static_job_ref(&job)
+    });
+
+    registry.inject_broadcast(job_refs);
+}
diff --git a/crates/rayon-core/src/broadcast/test.rs b/crates/rayon-core/src/broadcast/test.rs
new file mode 100644
index 0000000..00ab4ad
--- /dev/null
+++ b/crates/rayon-core/src/broadcast/test.rs
@@ -0,0 +1,263 @@
+#![cfg(test)]
+
+use crate::ThreadPoolBuilder;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::mpsc::channel;
+use std::sync::Arc;
+use std::{thread, time};
+
+#[test]
+fn broadcast_global() {
+    let v = crate::broadcast(|ctx| ctx.index());
+    assert!(v.into_iter().eq(0..crate::current_num_threads()));
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn spawn_broadcast_global() {
+    let (tx, rx) = channel();
+    crate::spawn_broadcast(move |ctx| tx.send(ctx.index()).unwrap());
+
+    let mut v: Vec<_> = rx.into_iter().collect();
+    v.sort_unstable();
+    assert!(v.into_iter().eq(0..crate::current_num_threads()));
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn broadcast_pool() {
+    let pool = ThreadPoolBuilder::new().num_threads(7).build().unwrap();
+    let v = pool.broadcast(|ctx| ctx.index());
+    assert!(v.into_iter().eq(0..7));
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn spawn_broadcast_pool() {
+    let (tx, rx) = channel();
+    let pool = ThreadPoolBuilder::new().num_threads(7).build().unwrap();
+    pool.spawn_broadcast(move |ctx| tx.send(ctx.index()).unwrap());
+
+    let mut v: Vec<_> = rx.into_iter().collect();
+    v.sort_unstable();
+    assert!(v.into_iter().eq(0..7));
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn broadcast_self() {
+    let pool = ThreadPoolBuilder::new().num_threads(7).build().unwrap();
+    let v = pool.install(|| crate::broadcast(|ctx| ctx.index()));
+    assert!(v.into_iter().eq(0..7));
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn spawn_broadcast_self() {
+    let (tx, rx) = channel();
+    let pool = ThreadPoolBuilder::new().num_threads(7).build().unwrap();
+    pool.spawn(|| crate::spawn_broadcast(move |ctx| tx.send(ctx.index()).unwrap()));
+
+    let mut v: Vec<_> = rx.into_iter().collect();
+    v.sort_unstable();
+    assert!(v.into_iter().eq(0..7));
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn broadcast_mutual() {
+    let count = AtomicUsize::new(0);
+    let pool1 = ThreadPoolBuilder::new().num_threads(3).build().unwrap();
+    let pool2 = ThreadPoolBuilder::new().num_threads(7).build().unwrap();
+    pool1.install(|| {
+        pool2.broadcast(|_| {
+            pool1.broadcast(|_| {
+                count.fetch_add(1, Ordering::Relaxed);
+            })
+        })
+    });
+    assert_eq!(count.into_inner(), 3 * 7);
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn spawn_broadcast_mutual() {
+    let (tx, rx) = channel();
+    let pool1 = Arc::new(ThreadPoolBuilder::new().num_threads(3).build().unwrap());
+    let pool2 = ThreadPoolBuilder::new().num_threads(7).build().unwrap();
+    pool1.spawn({
+        let pool1 = Arc::clone(&pool1);
+        move || {
+            pool2.spawn_broadcast(move |_| {
+                let tx = tx.clone();
+                pool1.spawn_broadcast(move |_| tx.send(()).unwrap())
+            })
+        }
+    });
+    assert_eq!(rx.into_iter().count(), 3 * 7);
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn broadcast_mutual_sleepy() {
+    let count = AtomicUsize::new(0);
+    let pool1 = ThreadPoolBuilder::new().num_threads(3).build().unwrap();
+    let pool2 = ThreadPoolBuilder::new().num_threads(7).build().unwrap();
+    pool1.install(|| {
+        thread::sleep(time::Duration::from_secs(1));
+        pool2.broadcast(|_| {
+            thread::sleep(time::Duration::from_secs(1));
+            pool1.broadcast(|_| {
+                thread::sleep(time::Duration::from_millis(100));
+                count.fetch_add(1, Ordering::Relaxed);
+            })
+        })
+    });
+    assert_eq!(count.into_inner(), 3 * 7);
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn spawn_broadcast_mutual_sleepy() {
+    let (tx, rx) = channel();
+    let pool1 = Arc::new(ThreadPoolBuilder::new().num_threads(3).build().unwrap());
+    let pool2 = ThreadPoolBuilder::new().num_threads(7).build().unwrap();
+    pool1.spawn({
+        let pool1 = Arc::clone(&pool1);
+        move || {
+            thread::sleep(time::Duration::from_secs(1));
+            pool2.spawn_broadcast(move |_| {
+                let tx = tx.clone();
+                thread::sleep(time::Duration::from_secs(1));
+                pool1.spawn_broadcast(move |_| {
+                    thread::sleep(time::Duration::from_millis(100));
+                    tx.send(()).unwrap();
+                })
+            })
+        }
+    });
+    assert_eq!(rx.into_iter().count(), 3 * 7);
+}
+
+#[test]
+#[cfg_attr(not(panic = "unwind"), ignore)]
+fn broadcast_panic_one() {
+    let count = AtomicUsize::new(0);
+    let pool = ThreadPoolBuilder::new().num_threads(7).build().unwrap();
+    let result = crate::unwind::halt_unwinding(|| {
+        pool.broadcast(|ctx| {
+            count.fetch_add(1, Ordering::Relaxed);
+            if ctx.index() == 3 {
+                panic!("Hello, world!");
+            }
+        })
+    });
+    assert_eq!(count.into_inner(), 7);
+    assert!(result.is_err(), "broadcast panic should propagate!");
+}
+
+#[test]
+#[cfg_attr(not(panic = "unwind"), ignore)]
+fn spawn_broadcast_panic_one() {
+    let (tx, rx) = channel();
+    let (panic_tx, panic_rx) = channel();
+    let pool = ThreadPoolBuilder::new()
+        .num_threads(7)
+        .panic_handler(move |e| panic_tx.send(e).unwrap())
+        .build()
+        .unwrap();
+    pool.spawn_broadcast(move |ctx| {
+        tx.send(()).unwrap();
+        if ctx.index() == 3 {
+            panic!("Hello, world!");
+        }
+    });
+    drop(pool); // including panic_tx
+    assert_eq!(rx.into_iter().count(), 7);
+    assert_eq!(panic_rx.into_iter().count(), 1);
+}
+
+#[test]
+#[cfg_attr(not(panic = "unwind"), ignore)]
+fn broadcast_panic_many() {
+    let count = AtomicUsize::new(0);
+    let pool = ThreadPoolBuilder::new().num_threads(7).build().unwrap();
+    let result = crate::unwind::halt_unwinding(|| {
+        pool.broadcast(|ctx| {
+            count.fetch_add(1, Ordering::Relaxed);
+            if ctx.index() % 2 == 0 {
+                panic!("Hello, world!");
+            }
+        })
+    });
+    assert_eq!(count.into_inner(), 7);
+    assert!(result.is_err(), "broadcast panic should propagate!");
+}
+
+#[test]
+#[cfg_attr(not(panic = "unwind"), ignore)]
+fn spawn_broadcast_panic_many() {
+    let (tx, rx) = channel();
+    let (panic_tx, panic_rx) = channel();
+    let pool = ThreadPoolBuilder::new()
+        .num_threads(7)
+        .panic_handler(move |e| panic_tx.send(e).unwrap())
+        .build()
+        .unwrap();
+    pool.spawn_broadcast(move |ctx| {
+        tx.send(()).unwrap();
+        if ctx.index() % 2 == 0 {
+            panic!("Hello, world!");
+        }
+    });
+    drop(pool); // including panic_tx
+    assert_eq!(rx.into_iter().count(), 7);
+    assert_eq!(panic_rx.into_iter().count(), 4);
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn broadcast_sleep_race() {
+    let test_duration = time::Duration::from_secs(1);
+    let pool = ThreadPoolBuilder::new().num_threads(7).build().unwrap();
+    let start = time::Instant::now();
+    while start.elapsed() < test_duration {
+        pool.broadcast(|ctx| {
+            // A slight spread of sleep duration increases the chance that one
+            // of the threads will race in the pool's idle sleep afterward.
+            thread::sleep(time::Duration::from_micros(ctx.index() as u64));
+        });
+    }
+}
+
+#[test]
+fn broadcast_after_spawn_broadcast() {
+    let (tx, rx) = channel();
+
+    // Queue a non-blocking spawn_broadcast.
+    crate::spawn_broadcast(move |ctx| tx.send(ctx.index()).unwrap());
+
+    // This blocking broadcast runs after all prior broadcasts.
+    crate::broadcast(|_| {});
+
+    // The spawn_broadcast **must** have run by now on all threads.
+    let mut v: Vec<_> = rx.try_iter().collect();
+    v.sort_unstable();
+    assert!(v.into_iter().eq(0..crate::current_num_threads()));
+}
+
+#[test]
+fn broadcast_after_spawn() {
+    let (tx, rx) = channel();
+
+    // Queue a regular spawn on a thread-local deque.
+    crate::registry::in_worker(move |_, _| {
+        crate::spawn(move || tx.send(22).unwrap());
+    });
+
+    // Broadcast runs after the local deque is empty.
+    crate::broadcast(|_| {});
+
+    // The spawn **must** have run by now.
+    assert_eq!(22, rx.try_recv().unwrap());
+}
diff --git a/crates/rayon-core/src/compile_fail/mod.rs b/crates/rayon-core/src/compile_fail/mod.rs
new file mode 100644
index 0000000..f2ec646
--- /dev/null
+++ b/crates/rayon-core/src/compile_fail/mod.rs
@@ -0,0 +1,7 @@
+// These modules contain `compile_fail` doc tests.
+mod quicksort_race1;
+mod quicksort_race2;
+mod quicksort_race3;
+mod rc_return;
+mod rc_upvar;
+mod scope_join_bad;
diff --git a/crates/rayon-core/src/compile_fail/quicksort_race1.rs b/crates/rayon-core/src/compile_fail/quicksort_race1.rs
new file mode 100644
index 0000000..5615033
--- /dev/null
+++ b/crates/rayon-core/src/compile_fail/quicksort_race1.rs
@@ -0,0 +1,28 @@
+/*! ```compile_fail,E0524
+
+fn quick_sort<T:PartialOrd+Send>(v: &mut [T]) {
+    if v.len() <= 1 {
+        return;
+    }
+
+    let mid = partition(v);
+    let (lo, _hi) = v.split_at_mut(mid);
+    rayon_core::join(|| quick_sort(lo), || quick_sort(lo)); //~ ERROR
+}
+
+fn partition<T:PartialOrd+Send>(v: &mut [T]) -> usize {
+    let pivot = v.len() - 1;
+    let mut i = 0;
+    for j in 0..pivot {
+        if v[j] <= v[pivot] {
+            v.swap(i, j);
+            i += 1;
+        }
+    }
+    v.swap(i, pivot);
+    i
+}
+
+fn main() { }
+
+``` */
diff --git a/crates/rayon-core/src/compile_fail/quicksort_race2.rs b/crates/rayon-core/src/compile_fail/quicksort_race2.rs
new file mode 100644
index 0000000..020589c
--- /dev/null
+++ b/crates/rayon-core/src/compile_fail/quicksort_race2.rs
@@ -0,0 +1,28 @@
+/*! ```compile_fail,E0500
+
+fn quick_sort<T:PartialOrd+Send>(v: &mut [T]) {
+    if v.len() <= 1 {
+        return;
+    }
+
+    let mid = partition(v);
+    let (lo, _hi) = v.split_at_mut(mid);
+    rayon_core::join(|| quick_sort(lo), || quick_sort(v)); //~ ERROR
+}
+
+fn partition<T:PartialOrd+Send>(v: &mut [T]) -> usize {
+    let pivot = v.len() - 1;
+    let mut i = 0;
+    for j in 0..pivot {
+        if v[j] <= v[pivot] {
+            v.swap(i, j);
+            i += 1;
+        }
+    }
+    v.swap(i, pivot);
+    i
+}
+
+fn main() { }
+
+``` */
diff --git a/crates/rayon-core/src/compile_fail/quicksort_race3.rs b/crates/rayon-core/src/compile_fail/quicksort_race3.rs
new file mode 100644
index 0000000..16fbf3b
--- /dev/null
+++ b/crates/rayon-core/src/compile_fail/quicksort_race3.rs
@@ -0,0 +1,28 @@
+/*! ```compile_fail,E0524
+
+fn quick_sort<T:PartialOrd+Send>(v: &mut [T]) {
+    if v.len() <= 1 {
+        return;
+    }
+
+    let mid = partition(v);
+    let (_lo, hi) = v.split_at_mut(mid);
+    rayon_core::join(|| quick_sort(hi), || quick_sort(hi)); //~ ERROR
+}
+
+fn partition<T:PartialOrd+Send>(v: &mut [T]) -> usize {
+    let pivot = v.len() - 1;
+    let mut i = 0;
+    for j in 0..pivot {
+        if v[j] <= v[pivot] {
+            v.swap(i, j);
+            i += 1;
+        }
+    }
+    v.swap(i, pivot);
+    i
+}
+
+fn main() { }
+
+``` */
diff --git a/crates/rayon-core/src/compile_fail/rc_return.rs b/crates/rayon-core/src/compile_fail/rc_return.rs
new file mode 100644
index 0000000..93e3a60
--- /dev/null
+++ b/crates/rayon-core/src/compile_fail/rc_return.rs
@@ -0,0 +1,17 @@
+/** ```compile_fail,E0277
+
+use std::rc::Rc;
+
+rayon_core::join(|| Rc::new(22), || ()); //~ ERROR
+
+``` */
+mod left {}
+
+/** ```compile_fail,E0277
+
+use std::rc::Rc;
+
+rayon_core::join(|| (), || Rc::new(23)); //~ ERROR
+
+``` */
+mod right {}
diff --git a/crates/rayon-core/src/compile_fail/rc_upvar.rs b/crates/rayon-core/src/compile_fail/rc_upvar.rs
new file mode 100644
index 0000000..d8aebcf
--- /dev/null
+++ b/crates/rayon-core/src/compile_fail/rc_upvar.rs
@@ -0,0 +1,9 @@
+/*! ```compile_fail,E0277
+
+use std::rc::Rc;
+
+let r = Rc::new(22);
+rayon_core::join(|| r.clone(), || r.clone());
+//~^ ERROR
+
+``` */
diff --git a/crates/rayon-core/src/compile_fail/scope_join_bad.rs b/crates/rayon-core/src/compile_fail/scope_join_bad.rs
new file mode 100644
index 0000000..75e4c5c
--- /dev/null
+++ b/crates/rayon-core/src/compile_fail/scope_join_bad.rs
@@ -0,0 +1,24 @@
+/*! ```compile_fail,E0373
+
+fn bad_scope<F>(f: F)
+    where F: FnOnce(&i32) + Send,
+{
+    rayon_core::scope(|s| {
+        let x = 22;
+        s.spawn(|_| f(&x)); //~ ERROR `x` does not live long enough
+    });
+}
+
+fn good_scope<F>(f: F)
+    where F: FnOnce(&i32) + Send,
+{
+    let x = 22;
+    rayon_core::scope(|s| {
+        s.spawn(|_| f(&x));
+    });
+}
+
+fn main() {
+}
+
+``` */
diff --git a/crates/rayon-core/src/job.rs b/crates/rayon-core/src/job.rs
new file mode 100644
index 0000000..5664bb3
--- /dev/null
+++ b/crates/rayon-core/src/job.rs
@@ -0,0 +1,270 @@
+use crate::latch::Latch;
+use crate::unwind;
+use crossbeam_deque::{Injector, Steal};
+use std::any::Any;
+use std::cell::UnsafeCell;
+use std::mem;
+use std::sync::Arc;
+
+pub(super) enum JobResult<T> {
+    None,
+    Ok(T),
+    Panic(Box<dyn Any + Send>),
+}
+
+/// A `Job` is used to advertise work for other threads that they may
+/// want to steal. In accordance with time honored tradition, jobs are
+/// arranged in a deque, so that thieves can take from the top of the
+/// deque while the main worker manages the bottom of the deque. This
+/// deque is managed by the `thread_pool` module.
+pub(super) trait Job {
+    /// Unsafe: this may be called from a different thread than the one
+    /// which scheduled the job, so the implementer must ensure the
+    /// appropriate traits are met, whether `Send`, `Sync`, or both.
+    unsafe fn execute(this: *const ());
+}
+
+/// Effectively a Job trait object. Each JobRef **must** be executed
+/// exactly once, or else data may leak.
+///
+/// Internally, we store the job's data in a `*const ()` pointer.  The
+/// true type is something like `*const StackJob<...>`, but we hide
+/// it. We also carry the "execute fn" from the `Job` trait.
+pub(super) struct JobRef {
+    pointer: *const (),
+    execute_fn: unsafe fn(*const ()),
+}
+
+unsafe impl Send for JobRef {}
+unsafe impl Sync for JobRef {}
+
+impl JobRef {
+    /// Unsafe: caller asserts that `data` will remain valid until the
+    /// job is executed.
+    pub(super) unsafe fn new<T>(data: *const T) -> JobRef
+    where
+        T: Job,
+    {
+        // erase types:
+        JobRef {
+            pointer: data as *const (),
+            execute_fn: <T as Job>::execute,
+        }
+    }
+
+    /// Returns an opaque handle that can be saved and compared,
+    /// without making `JobRef` itself `Copy + Eq`.
+    #[inline]
+    pub(super) fn id(&self) -> impl Eq {
+        (self.pointer, self.execute_fn)
+    }
+
+    #[inline]
+    pub(super) unsafe fn execute(self) {
+        (self.execute_fn)(self.pointer)
+    }
+}
+
+/// A job that will be owned by a stack slot. This means that when it
+/// executes it need not free any heap data, the cleanup occurs when
+/// the stack frame is later popped.  The function parameter indicates
+/// `true` if the job was stolen -- executed on a different thread.
+pub(super) struct StackJob<L, F, R>
+where
+    L: Latch + Sync,
+    F: FnOnce(bool) -> R + Send,
+    R: Send,
+{
+    pub(super) latch: L,
+    func: UnsafeCell<Option<F>>,
+    result: UnsafeCell<JobResult<R>>,
+}
+
+impl<L, F, R> StackJob<L, F, R>
+where
+    L: Latch + Sync,
+    F: FnOnce(bool) -> R + Send,
+    R: Send,
+{
+    pub(super) fn new(func: F, latch: L) -> StackJob<L, F, R> {
+        StackJob {
+            latch,
+            func: UnsafeCell::new(Some(func)),
+            result: UnsafeCell::new(JobResult::None),
+        }
+    }
+
+    pub(super) unsafe fn as_job_ref(&self) -> JobRef {
+        JobRef::new(self)
+    }
+
+    pub(super) unsafe fn run_inline(self, stolen: bool) -> R {
+        self.func.into_inner().unwrap()(stolen)
+    }
+
+    pub(super) unsafe fn into_result(self) -> R {
+        self.result.into_inner().into_return_value()
+    }
+}
+
+impl<L, F, R> Job for StackJob<L, F, R>
+where
+    L: Latch + Sync,
+    F: FnOnce(bool) -> R + Send,
+    R: Send,
+{
+    unsafe fn execute(this: *const ()) {
+        let this = &*(this as *const Self);
+        let abort = unwind::AbortIfPanic;
+        let func = (*this.func.get()).take().unwrap();
+        (*this.result.get()) = JobResult::call(func);
+        Latch::set(&this.latch);
+        mem::forget(abort);
+    }
+}
+
+/// Represents a job stored in the heap. Used to implement
+/// `scope`. Unlike `StackJob`, when executed, `HeapJob` simply
+/// invokes a closure, which then triggers the appropriate logic to
+/// signal that the job executed.
+///
+/// (Probably `StackJob` should be refactored in a similar fashion.)
+pub(super) struct HeapJob<BODY>
+where
+    BODY: FnOnce() + Send,
+{
+    job: BODY,
+}
+
+impl<BODY> HeapJob<BODY>
+where
+    BODY: FnOnce() + Send,
+{
+    pub(super) fn new(job: BODY) -> Box<Self> {
+        Box::new(HeapJob { job })
+    }
+
+    /// Creates a `JobRef` from this job -- note that this hides all
+    /// lifetimes, so it is up to you to ensure that this JobRef
+    /// doesn't outlive any data that it closes over.
+    pub(super) unsafe fn into_job_ref(self: Box<Self>) -> JobRef {
+        JobRef::new(Box::into_raw(self))
+    }
+
+    /// Creates a static `JobRef` from this job.
+    pub(super) fn into_static_job_ref(self: Box<Self>) -> JobRef
+    where
+        BODY: 'static,
+    {
+        unsafe { self.into_job_ref() }
+    }
+}
+
+impl<BODY> Job for HeapJob<BODY>
+where
+    BODY: FnOnce() + Send,
+{
+    unsafe fn execute(this: *const ()) {
+        let this = Box::from_raw(this as *mut Self);
+        (this.job)();
+    }
+}
+
+/// Represents a job stored in an `Arc` -- like `HeapJob`, but may
+/// be turned into multiple `JobRef`s and called multiple times.
+pub(super) struct ArcJob<BODY>
+where
+    BODY: Fn() + Send + Sync,
+{
+    job: BODY,
+}
+
+impl<BODY> ArcJob<BODY>
+where
+    BODY: Fn() + Send + Sync,
+{
+    pub(super) fn new(job: BODY) -> Arc<Self> {
+        Arc::new(ArcJob { job })
+    }
+
+    /// Creates a `JobRef` from this job -- note that this hides all
+    /// lifetimes, so it is up to you to ensure that this JobRef
+    /// doesn't outlive any data that it closes over.
+    pub(super) unsafe fn as_job_ref(this: &Arc<Self>) -> JobRef {
+        JobRef::new(Arc::into_raw(Arc::clone(this)))
+    }
+
+    /// Creates a static `JobRef` from this job.
+    pub(super) fn as_static_job_ref(this: &Arc<Self>) -> JobRef
+    where
+        BODY: 'static,
+    {
+        unsafe { Self::as_job_ref(this) }
+    }
+}
+
+impl<BODY> Job for ArcJob<BODY>
+where
+    BODY: Fn() + Send + Sync,
+{
+    unsafe fn execute(this: *const ()) {
+        let this = Arc::from_raw(this as *mut Self);
+        (this.job)();
+    }
+}
+
+impl<T> JobResult<T> {
+    fn call(func: impl FnOnce(bool) -> T) -> Self {
+        match unwind::halt_unwinding(|| func(true)) {
+            Ok(x) => JobResult::Ok(x),
+            Err(x) => JobResult::Panic(x),
+        }
+    }
+
+    /// Convert the `JobResult` for a job that has finished (and hence
+    /// its JobResult is populated) into its return value.
+    ///
+    /// NB. This will panic if the job panicked.
+    pub(super) fn into_return_value(self) -> T {
+        match self {
+            JobResult::None => unreachable!(),
+            JobResult::Ok(x) => x,
+            JobResult::Panic(x) => unwind::resume_unwinding(x),
+        }
+    }
+}
+
+/// Indirect queue to provide FIFO job priority.
+pub(super) struct JobFifo {
+    inner: Injector<JobRef>,
+}
+
+impl JobFifo {
+    pub(super) fn new() -> Self {
+        JobFifo {
+            inner: Injector::new(),
+        }
+    }
+
+    pub(super) unsafe fn push(&self, job_ref: JobRef) -> JobRef {
+        // A little indirection ensures that spawns are always prioritized in FIFO order.  The
+        // jobs in a thread's deque may be popped from the back (LIFO) or stolen from the front
+        // (FIFO), but either way they will end up popping from the front of this queue.
+        self.inner.push(job_ref);
+        JobRef::new(self)
+    }
+}
+
+impl Job for JobFifo {
+    unsafe fn execute(this: *const ()) {
+        // We "execute" a queue by executing its first job, FIFO.
+        let this = &*(this as *const Self);
+        loop {
+            match this.inner.steal() {
+                Steal::Success(job_ref) => break job_ref.execute(),
+                Steal::Empty => panic!("FIFO is empty"),
+                Steal::Retry => {}
+            }
+        }
+    }
+}
diff --git a/crates/rayon-core/src/join/mod.rs b/crates/rayon-core/src/join/mod.rs
new file mode 100644
index 0000000..5ab9f6b
--- /dev/null
+++ b/crates/rayon-core/src/join/mod.rs
@@ -0,0 +1,188 @@
+use crate::job::StackJob;
+use crate::latch::SpinLatch;
+use crate::registry::{self, WorkerThread};
+use crate::unwind;
+use std::any::Any;
+
+use crate::FnContext;
+
+#[cfg(test)]
+mod test;
+
+/// Takes two closures and *potentially* runs them in parallel. It
+/// returns a pair of the results from those closures.
+///
+/// Conceptually, calling `join()` is similar to spawning two threads,
+/// one executing each of the two closures. However, the
+/// implementation is quite different and incurs very low
+/// overhead. The underlying technique is called "work stealing": the
+/// Rayon runtime uses a fixed pool of worker threads and attempts to
+/// only execute code in parallel when there are idle CPUs to handle
+/// it.
+///
+/// When `join` is called from outside the thread pool, the calling
+/// thread will block while the closures execute in the pool.  When
+/// `join` is called within the pool, the calling thread still actively
+/// participates in the thread pool. It will begin by executing closure
+/// A (on the current thread). While it is doing that, it will advertise
+/// closure B as being available for other threads to execute. Once closure A
+/// has completed, the current thread will try to execute closure B;
+/// if however closure B has been stolen, then it will look for other work
+/// while waiting for the thief to fully execute closure B. (This is the
+/// typical work-stealing strategy).
+///
+/// # Examples
+///
+/// This example uses join to perform a quick-sort (note this is not a
+/// particularly optimized implementation: if you **actually** want to
+/// sort for real, you should prefer [the `par_sort` method] offered
+/// by Rayon).
+///
+/// [the `par_sort` method]: ../rayon/slice/trait.ParallelSliceMut.html#method.par_sort
+///
+/// ```rust
+/// # use rayon_core as rayon;
+/// let mut v = vec![5, 1, 8, 22, 0, 44];
+/// quick_sort(&mut v);
+/// assert_eq!(v, vec![0, 1, 5, 8, 22, 44]);
+///
+/// fn quick_sort<T:PartialOrd+Send>(v: &mut [T]) {
+///    if v.len() > 1 {
+///        let mid = partition(v);
+///        let (lo, hi) = v.split_at_mut(mid);
+///        rayon::join(|| quick_sort(lo),
+///                    || quick_sort(hi));
+///    }
+/// }
+///
+/// // Partition rearranges all items `<=` to the pivot
+/// // item (arbitrary selected to be the last item in the slice)
+/// // to the first half of the slice. It then returns the
+/// // "dividing point" where the pivot is placed.
+/// fn partition<T:PartialOrd+Send>(v: &mut [T]) -> usize {
+///     let pivot = v.len() - 1;
+///     let mut i = 0;
+///     for j in 0..pivot {
+///         if v[j] <= v[pivot] {
+///             v.swap(i, j);
+///             i += 1;
+///         }
+///     }
+///     v.swap(i, pivot);
+///     i
+/// }
+/// ```
+///
+/// # Warning about blocking I/O
+///
+/// The assumption is that the closures given to `join()` are
+/// CPU-bound tasks that do not perform I/O or other blocking
+/// operations. If you do perform I/O, and that I/O should block
+/// (e.g., waiting for a network request), the overall performance may
+/// be poor.  Moreover, if you cause one closure to be blocked waiting
+/// on another (for example, using a channel), that could lead to a
+/// deadlock.
+///
+/// # Panics
+///
+/// No matter what happens, both closures will always be executed.  If
+/// a single closure panics, whether it be the first or second
+/// closure, that panic will be propagated and hence `join()` will
+/// panic with the same panic value. If both closures panic, `join()`
+/// will panic with the panic value from the first closure.
+pub fn join<A, B, RA, RB>(oper_a: A, oper_b: B) -> (RA, RB)
+where
+    A: FnOnce() -> RA + Send,
+    B: FnOnce() -> RB + Send,
+    RA: Send,
+    RB: Send,
+{
+    #[inline]
+    fn call<R>(f: impl FnOnce() -> R) -> impl FnOnce(FnContext) -> R {
+        move |_| f()
+    }
+
+    join_context(call(oper_a), call(oper_b))
+}
+
+/// Identical to `join`, except that the closures have a parameter
+/// that provides context for the way the closure has been called,
+/// especially indicating whether they're executing on a different
+/// thread than where `join_context` was called.  This will occur if
+/// the second job is stolen by a different thread, or if
+/// `join_context` was called from outside the thread pool to begin
+/// with.
+pub fn join_context<A, B, RA, RB>(oper_a: A, oper_b: B) -> (RA, RB)
+where
+    A: FnOnce(FnContext) -> RA + Send,
+    B: FnOnce(FnContext) -> RB + Send,
+    RA: Send,
+    RB: Send,
+{
+    #[inline]
+    fn call_a<R>(f: impl FnOnce(FnContext) -> R, injected: bool) -> impl FnOnce() -> R {
+        move || f(FnContext::new(injected))
+    }
+
+    #[inline]
+    fn call_b<R>(f: impl FnOnce(FnContext) -> R) -> impl FnOnce(bool) -> R {
+        move |migrated| f(FnContext::new(migrated))
+    }
+
+    registry::in_worker(|worker_thread, injected| unsafe {
+        // Create virtual wrapper for task b; this all has to be
+        // done here so that the stack frame can keep it all live
+        // long enough.
+        let job_b = StackJob::new(call_b(oper_b), SpinLatch::new(worker_thread));
+        let job_b_ref = job_b.as_job_ref();
+        let job_b_id = job_b_ref.id();
+        worker_thread.push(job_b_ref);
+
+        // Execute task a; hopefully b gets stolen in the meantime.
+        let status_a = unwind::halt_unwinding(call_a(oper_a, injected));
+        let result_a = match status_a {
+            Ok(v) => v,
+            Err(err) => join_recover_from_panic(worker_thread, &job_b.latch, err),
+        };
+
+        // Now that task A has finished, try to pop job B from the
+        // local stack.  It may already have been popped by job A; it
+        // may also have been stolen. There may also be some tasks
+        // pushed on top of it in the stack, and we will have to pop
+        // those off to get to it.
+        while !job_b.latch.probe() {
+            if let Some(job) = worker_thread.take_local_job() {
+                if job_b_id == job.id() {
+                    // Found it! Let's run it.
+                    //
+                    // Note that this could panic, but it's ok if we unwind here.
+                    let result_b = job_b.run_inline(injected);
+                    return (result_a, result_b);
+                } else {
+                    worker_thread.execute(job);
+                }
+            } else {
+                // Local deque is empty. Time to steal from other
+                // threads.
+                worker_thread.wait_until(&job_b.latch);
+                debug_assert!(job_b.latch.probe());
+                break;
+            }
+        }
+
+        (result_a, job_b.into_result())
+    })
+}
+
+/// If job A panics, we still cannot return until we are sure that job
+/// B is complete. This is because it may contain references into the
+/// enclosing stack frame(s).
+#[cold] // cold path
+unsafe fn join_recover_from_panic(
+    worker_thread: &WorkerThread,
+    job_b_latch: &SpinLatch<'_>,
+    err: Box<dyn Any + Send>,
+) -> ! {
+    worker_thread.wait_until(job_b_latch);
+    unwind::resume_unwinding(err)
+}
diff --git a/crates/rayon-core/src/join/test.rs b/crates/rayon-core/src/join/test.rs
new file mode 100644
index 0000000..b303dbc
--- /dev/null
+++ b/crates/rayon-core/src/join/test.rs
@@ -0,0 +1,151 @@
+//! Tests for the join code.
+
+use crate::join::*;
+use crate::unwind;
+use crate::ThreadPoolBuilder;
+use rand::distributions::Standard;
+use rand::{Rng, SeedableRng};
+use rand_xorshift::XorShiftRng;
+
+fn quick_sort<T: PartialOrd + Send>(v: &mut [T]) {
+    if v.len() <= 1 {
+        return;
+    }
+
+    let mid = partition(v);
+    let (lo, hi) = v.split_at_mut(mid);
+    join(|| quick_sort(lo), || quick_sort(hi));
+}
+
+fn partition<T: PartialOrd + Send>(v: &mut [T]) -> usize {
+    let pivot = v.len() - 1;
+    let mut i = 0;
+    for j in 0..pivot {
+        if v[j] <= v[pivot] {
+            v.swap(i, j);
+            i += 1;
+        }
+    }
+    v.swap(i, pivot);
+    i
+}
+
+fn seeded_rng() -> XorShiftRng {
+    let mut seed = <XorShiftRng as SeedableRng>::Seed::default();
+    (0..).zip(seed.as_mut()).for_each(|(i, x)| *x = i);
+    XorShiftRng::from_seed(seed)
+}
+
+#[test]
+fn sort() {
+    let rng = seeded_rng();
+    let mut data: Vec<u32> = rng.sample_iter(&Standard).take(6 * 1024).collect();
+    let mut sorted_data = data.clone();
+    sorted_data.sort();
+    quick_sort(&mut data);
+    assert_eq!(data, sorted_data);
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn sort_in_pool() {
+    let rng = seeded_rng();
+    let mut data: Vec<u32> = rng.sample_iter(&Standard).take(12 * 1024).collect();
+
+    let pool = ThreadPoolBuilder::new().build().unwrap();
+    let mut sorted_data = data.clone();
+    sorted_data.sort();
+    pool.install(|| quick_sort(&mut data));
+    assert_eq!(data, sorted_data);
+}
+
+#[test]
+#[should_panic(expected = "Hello, world!")]
+fn panic_propagate_a() {
+    join(|| panic!("Hello, world!"), || ());
+}
+
+#[test]
+#[should_panic(expected = "Hello, world!")]
+fn panic_propagate_b() {
+    join(|| (), || panic!("Hello, world!"));
+}
+
+#[test]
+#[should_panic(expected = "Hello, world!")]
+fn panic_propagate_both() {
+    join(|| panic!("Hello, world!"), || panic!("Goodbye, world!"));
+}
+
+#[test]
+#[cfg_attr(not(panic = "unwind"), ignore)]
+fn panic_b_still_executes() {
+    let mut x = false;
+    match unwind::halt_unwinding(|| join(|| panic!("Hello, world!"), || x = true)) {
+        Ok(_) => panic!("failed to propagate panic from closure A,"),
+        Err(_) => assert!(x, "closure b failed to execute"),
+    }
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn join_context_both() {
+    // If we're not in a pool, both should be marked stolen as they're injected.
+    let (a_migrated, b_migrated) = join_context(|a| a.migrated(), |b| b.migrated());
+    assert!(a_migrated);
+    assert!(b_migrated);
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn join_context_neither() {
+    // If we're already in a 1-thread pool, neither job should be stolen.
+    let pool = ThreadPoolBuilder::new().num_threads(1).build().unwrap();
+    let (a_migrated, b_migrated) =
+        pool.install(|| join_context(|a| a.migrated(), |b| b.migrated()));
+    assert!(!a_migrated);
+    assert!(!b_migrated);
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn join_context_second() {
+    use std::sync::Barrier;
+
+    // If we're already in a 2-thread pool, the second job should be stolen.
+    let barrier = Barrier::new(2);
+    let pool = ThreadPoolBuilder::new().num_threads(2).build().unwrap();
+    let (a_migrated, b_migrated) = pool.install(|| {
+        join_context(
+            |a| {
+                barrier.wait();
+                a.migrated()
+            },
+            |b| {
+                barrier.wait();
+                b.migrated()
+            },
+        )
+    });
+    assert!(!a_migrated);
+    assert!(b_migrated);
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn join_counter_overflow() {
+    const MAX: u32 = 500_000;
+
+    let mut i = 0;
+    let mut j = 0;
+    let pool = ThreadPoolBuilder::new().num_threads(2).build().unwrap();
+
+    // Hammer on join a bunch of times -- used to hit overflow debug-assertions
+    // in JEC on 32-bit targets: https://github.com/rayon-rs/rayon/issues/797
+    for _ in 0..MAX {
+        pool.join(|| i += 1, || j += 1);
+    }
+
+    assert_eq!(i, MAX);
+    assert_eq!(j, MAX);
+}
diff --git a/crates/rayon-core/src/latch.rs b/crates/rayon-core/src/latch.rs
new file mode 100644
index 0000000..6c2e4fe
--- /dev/null
+++ b/crates/rayon-core/src/latch.rs
@@ -0,0 +1,461 @@
+use std::marker::PhantomData;
+use std::ops::Deref;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::Arc;
+use std::usize;
+
+use crate::registry::{Registry, WorkerThread};
+use crate::sync::{Condvar, Mutex};
+
+/// We define various kinds of latches, which are all a primitive signaling
+/// mechanism. A latch starts as false. Eventually someone calls `set()` and
+/// it becomes true. You can test if it has been set by calling `probe()`.
+///
+/// Some kinds of latches, but not all, support a `wait()` operation
+/// that will wait until the latch is set, blocking efficiently. That
+/// is not part of the trait since it is not possibly to do with all
+/// latches.
+///
+/// The intention is that `set()` is called once, but `probe()` may be
+/// called any number of times. Once `probe()` returns true, the memory
+/// effects that occurred before `set()` become visible.
+///
+/// It'd probably be better to refactor the API into two paired types,
+/// but that's a bit of work, and this is not a public API.
+///
+/// ## Memory ordering
+///
+/// Latches need to guarantee two things:
+///
+/// - Once `probe()` returns true, all memory effects from the `set()`
+///   are visible (in other words, the set should synchronize-with
+///   the probe).
+/// - Once `set()` occurs, the next `probe()` *will* observe it.  This
+///   typically requires a seq-cst ordering. See [the "tickle-then-get-sleepy" scenario in the sleep
+///   README](/src/sleep/README.md#tickle-then-get-sleepy) for details.
+pub(super) trait Latch {
+    /// Set the latch, signalling others.
+    ///
+    /// # WARNING
+    ///
+    /// Setting a latch triggers other threads to wake up and (in some
+    /// cases) complete. This may, in turn, cause memory to be
+    /// deallocated and so forth. One must be very careful about this,
+    /// and it's typically better to read all the fields you will need
+    /// to access *before* a latch is set!
+    ///
+    /// This function operates on `*const Self` instead of `&self` to allow it
+    /// to become dangling during this call. The caller must ensure that the
+    /// pointer is valid upon entry, and not invalidated during the call by any
+    /// actions other than `set` itself.
+    unsafe fn set(this: *const Self);
+}
+
+pub(super) trait AsCoreLatch {
+    fn as_core_latch(&self) -> &CoreLatch;
+}
+
+/// Latch is not set, owning thread is awake
+const UNSET: usize = 0;
+
+/// Latch is not set, owning thread is going to sleep on this latch
+/// (but has not yet fallen asleep).
+const SLEEPY: usize = 1;
+
+/// Latch is not set, owning thread is asleep on this latch and
+/// must be awoken.
+const SLEEPING: usize = 2;
+
+/// Latch is set.
+const SET: usize = 3;
+
+/// Spin latches are the simplest, most efficient kind, but they do
+/// not support a `wait()` operation. They just have a boolean flag
+/// that becomes true when `set()` is called.
+#[derive(Debug)]
+pub(super) struct CoreLatch {
+    state: AtomicUsize,
+}
+
+impl CoreLatch {
+    #[inline]
+    fn new() -> Self {
+        Self {
+            state: AtomicUsize::new(0),
+        }
+    }
+
+    /// Invoked by owning thread as it prepares to sleep. Returns true
+    /// if the owning thread may proceed to fall asleep, false if the
+    /// latch was set in the meantime.
+    #[inline]
+    pub(super) fn get_sleepy(&self) -> bool {
+        self.state
+            .compare_exchange(UNSET, SLEEPY, Ordering::SeqCst, Ordering::Relaxed)
+            .is_ok()
+    }
+
+    /// Invoked by owning thread as it falls asleep sleep. Returns
+    /// true if the owning thread should block, or false if the latch
+    /// was set in the meantime.
+    #[inline]
+    pub(super) fn fall_asleep(&self) -> bool {
+        self.state
+            .compare_exchange(SLEEPY, SLEEPING, Ordering::SeqCst, Ordering::Relaxed)
+            .is_ok()
+    }
+
+    /// Invoked by owning thread as it falls asleep sleep. Returns
+    /// true if the owning thread should block, or false if the latch
+    /// was set in the meantime.
+    #[inline]
+    pub(super) fn wake_up(&self) {
+        if !self.probe() {
+            let _ =
+                self.state
+                    .compare_exchange(SLEEPING, UNSET, Ordering::SeqCst, Ordering::Relaxed);
+        }
+    }
+
+    /// Set the latch. If this returns true, the owning thread was sleeping
+    /// and must be awoken.
+    ///
+    /// This is private because, typically, setting a latch involves
+    /// doing some wakeups; those are encapsulated in the surrounding
+    /// latch code.
+    #[inline]
+    unsafe fn set(this: *const Self) -> bool {
+        let old_state = (*this).state.swap(SET, Ordering::AcqRel);
+        old_state == SLEEPING
+    }
+
+    /// Test if this latch has been set.
+    #[inline]
+    pub(super) fn probe(&self) -> bool {
+        self.state.load(Ordering::Acquire) == SET
+    }
+}
+
+impl AsCoreLatch for CoreLatch {
+    #[inline]
+    fn as_core_latch(&self) -> &CoreLatch {
+        self
+    }
+}
+
+/// Spin latches are the simplest, most efficient kind, but they do
+/// not support a `wait()` operation. They just have a boolean flag
+/// that becomes true when `set()` is called.
+pub(super) struct SpinLatch<'r> {
+    core_latch: CoreLatch,
+    registry: &'r Arc<Registry>,
+    target_worker_index: usize,
+    cross: bool,
+}
+
+impl<'r> SpinLatch<'r> {
+    /// Creates a new spin latch that is owned by `thread`. This means
+    /// that `thread` is the only thread that should be blocking on
+    /// this latch -- it also means that when the latch is set, we
+    /// will wake `thread` if it is sleeping.
+    #[inline]
+    pub(super) fn new(thread: &'r WorkerThread) -> SpinLatch<'r> {
+        SpinLatch {
+            core_latch: CoreLatch::new(),
+            registry: thread.registry(),
+            target_worker_index: thread.index(),
+            cross: false,
+        }
+    }
+
+    /// Creates a new spin latch for cross-threadpool blocking.  Notably, we
+    /// need to make sure the registry is kept alive after setting, so we can
+    /// safely call the notification.
+    #[inline]
+    pub(super) fn cross(thread: &'r WorkerThread) -> SpinLatch<'r> {
+        SpinLatch {
+            cross: true,
+            ..SpinLatch::new(thread)
+        }
+    }
+
+    #[inline]
+    pub(super) fn probe(&self) -> bool {
+        self.core_latch.probe()
+    }
+}
+
+impl<'r> AsCoreLatch for SpinLatch<'r> {
+    #[inline]
+    fn as_core_latch(&self) -> &CoreLatch {
+        &self.core_latch
+    }
+}
+
+impl<'r> Latch for SpinLatch<'r> {
+    #[inline]
+    unsafe fn set(this: *const Self) {
+        let cross_registry;
+
+        let registry: &Registry = if (*this).cross {
+            // Ensure the registry stays alive while we notify it.
+            // Otherwise, it would be possible that we set the spin
+            // latch and the other thread sees it and exits, causing
+            // the registry to be deallocated, all before we get a
+            // chance to invoke `registry.notify_worker_latch_is_set`.
+            cross_registry = Arc::clone((*this).registry);
+            &cross_registry
+        } else {
+            // If this is not a "cross-registry" spin-latch, then the
+            // thread which is performing `set` is itself ensuring
+            // that the registry stays alive. However, that doesn't
+            // include this *particular* `Arc` handle if the waiting
+            // thread then exits, so we must completely dereference it.
+            (*this).registry
+        };
+        let target_worker_index = (*this).target_worker_index;
+
+        // NOTE: Once we `set`, the target may proceed and invalidate `this`!
+        if CoreLatch::set(&(*this).core_latch) {
+            // Subtle: at this point, we can no longer read from
+            // `self`, because the thread owning this spin latch may
+            // have awoken and deallocated the latch. Therefore, we
+            // only use fields whose values we already read.
+            registry.notify_worker_latch_is_set(target_worker_index);
+        }
+    }
+}
+
+/// A Latch starts as false and eventually becomes true. You can block
+/// until it becomes true.
+#[derive(Debug)]
+pub(super) struct LockLatch {
+    m: Mutex<bool>,
+    v: Condvar,
+}
+
+impl LockLatch {
+    #[inline]
+    pub(super) fn new() -> LockLatch {
+        LockLatch {
+            m: Mutex::new(false),
+            v: Condvar::new(),
+        }
+    }
+
+    /// Block until latch is set, then resets this lock latch so it can be reused again.
+    pub(super) fn wait_and_reset(&self) {
+        let mut guard = self.m.lock().unwrap();
+        while !*guard {
+            guard = self.v.wait(guard).unwrap();
+        }
+        *guard = false;
+    }
+
+    /// Block until latch is set.
+    pub(super) fn wait(&self) {
+        let mut guard = self.m.lock().unwrap();
+        while !*guard {
+            guard = self.v.wait(guard).unwrap();
+        }
+    }
+}
+
+impl Latch for LockLatch {
+    #[inline]
+    unsafe fn set(this: *const Self) {
+        let mut guard = (*this).m.lock().unwrap();
+        *guard = true;
+        (*this).v.notify_all();
+    }
+}
+
+/// Once latches are used to implement one-time blocking, primarily
+/// for the termination flag of the threads in the pool.
+///
+/// Note: like a `SpinLatch`, once-latches are always associated with
+/// some registry that is probing them, which must be tickled when
+/// they are set. *Unlike* a `SpinLatch`, they don't themselves hold a
+/// reference to that registry. This is because in some cases the
+/// registry owns the once-latch, and that would create a cycle. So a
+/// `OnceLatch` must be given a reference to its owning registry when
+/// it is set. For this reason, it does not implement the `Latch`
+/// trait (but it doesn't have to, as it is not used in those generic
+/// contexts).
+#[derive(Debug)]
+pub(super) struct OnceLatch {
+    core_latch: CoreLatch,
+}
+
+impl OnceLatch {
+    #[inline]
+    pub(super) fn new() -> OnceLatch {
+        Self {
+            core_latch: CoreLatch::new(),
+        }
+    }
+
+    /// Set the latch, then tickle the specific worker thread,
+    /// which should be the one that owns this latch.
+    #[inline]
+    pub(super) unsafe fn set_and_tickle_one(
+        this: *const Self,
+        registry: &Registry,
+        target_worker_index: usize,
+    ) {
+        if CoreLatch::set(&(*this).core_latch) {
+            registry.notify_worker_latch_is_set(target_worker_index);
+        }
+    }
+}
+
+impl AsCoreLatch for OnceLatch {
+    #[inline]
+    fn as_core_latch(&self) -> &CoreLatch {
+        &self.core_latch
+    }
+}
+
+/// Counting latches are used to implement scopes. They track a
+/// counter. Unlike other latches, calling `set()` does not
+/// necessarily make the latch be considered `set()`; instead, it just
+/// decrements the counter. The latch is only "set" (in the sense that
+/// `probe()` returns true) once the counter reaches zero.
+#[derive(Debug)]
+pub(super) struct CountLatch {
+    counter: AtomicUsize,
+    kind: CountLatchKind,
+}
+
+enum CountLatchKind {
+    /// A latch for scopes created on a rayon thread which will participate in work-
+    /// stealing while it waits for completion. This thread is not necessarily part
+    /// of the same registry as the scope itself!
+    Stealing {
+        latch: CoreLatch,
+        /// If a worker thread in registry A calls `in_place_scope` on a ThreadPool
+        /// with registry B, when a job completes in a thread of registry B, we may
+        /// need to call `notify_worker_latch_is_set()` to wake the thread in registry A.
+        /// That means we need a reference to registry A (since at that point we will
+        /// only have a reference to registry B), so we stash it here.
+        registry: Arc<Registry>,
+        /// The index of the worker to wake in `registry`
+        worker_index: usize,
+    },
+
+    /// A latch for scopes created on a non-rayon thread which will block to wait.
+    Blocking { latch: LockLatch },
+}
+
+impl std::fmt::Debug for CountLatchKind {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            CountLatchKind::Stealing { latch, .. } => {
+                f.debug_tuple("Stealing").field(latch).finish()
+            }
+            CountLatchKind::Blocking { latch, .. } => {
+                f.debug_tuple("Blocking").field(latch).finish()
+            }
+        }
+    }
+}
+
+impl CountLatch {
+    pub(super) fn new(owner: Option<&WorkerThread>) -> Self {
+        Self::with_count(1, owner)
+    }
+
+    pub(super) fn with_count(count: usize, owner: Option<&WorkerThread>) -> Self {
+        Self {
+            counter: AtomicUsize::new(count),
+            kind: match owner {
+                Some(owner) => CountLatchKind::Stealing {
+                    latch: CoreLatch::new(),
+                    registry: Arc::clone(owner.registry()),
+                    worker_index: owner.index(),
+                },
+                None => CountLatchKind::Blocking {
+                    latch: LockLatch::new(),
+                },
+            },
+        }
+    }
+
+    #[inline]
+    pub(super) fn increment(&self) {
+        let old_counter = self.counter.fetch_add(1, Ordering::Relaxed);
+        debug_assert!(old_counter != 0);
+    }
+
+    pub(super) fn wait(&self, owner: Option<&WorkerThread>) {
+        match &self.kind {
+            CountLatchKind::Stealing {
+                latch,
+                registry,
+                worker_index,
+            } => unsafe {
+                let owner = owner.expect("owner thread");
+                debug_assert_eq!(registry.id(), owner.registry().id());
+                debug_assert_eq!(*worker_index, owner.index());
+                owner.wait_until(latch);
+            },
+            CountLatchKind::Blocking { latch } => latch.wait(),
+        }
+    }
+}
+
+impl Latch for CountLatch {
+    #[inline]
+    unsafe fn set(this: *const Self) {
+        if (*this).counter.fetch_sub(1, Ordering::SeqCst) == 1 {
+            // NOTE: Once we call `set` on the internal `latch`,
+            // the target may proceed and invalidate `this`!
+            match (*this).kind {
+                CountLatchKind::Stealing {
+                    ref latch,
+                    ref registry,
+                    worker_index,
+                } => {
+                    let registry = Arc::clone(registry);
+                    if CoreLatch::set(latch) {
+                        registry.notify_worker_latch_is_set(worker_index);
+                    }
+                }
+                CountLatchKind::Blocking { ref latch } => LockLatch::set(latch),
+            }
+        }
+    }
+}
+
+/// `&L` without any implication of `dereferenceable` for `Latch::set`
+pub(super) struct LatchRef<'a, L> {
+    inner: *const L,
+    marker: PhantomData<&'a L>,
+}
+
+impl<L> LatchRef<'_, L> {
+    pub(super) fn new(inner: &L) -> LatchRef<'_, L> {
+        LatchRef {
+            inner,
+            marker: PhantomData,
+        }
+    }
+}
+
+unsafe impl<L: Sync> Sync for LatchRef<'_, L> {}
+
+impl<L> Deref for LatchRef<'_, L> {
+    type Target = L;
+
+    fn deref(&self) -> &L {
+        // SAFETY: if we have &self, the inner latch is still alive
+        unsafe { &*self.inner }
+    }
+}
+
+impl<L: Latch> Latch for LatchRef<'_, L> {
+    #[inline]
+    unsafe fn set(this: *const Self) {
+        L::set((*this).inner);
+    }
+}
diff --git a/crates/rayon-core/src/lib.rs b/crates/rayon-core/src/lib.rs
new file mode 100644
index 0000000..39df8a2
--- /dev/null
+++ b/crates/rayon-core/src/lib.rs
@@ -0,0 +1,875 @@
+//! Rayon-core houses the core stable APIs of Rayon.
+//!
+//! These APIs have been mirrored in the Rayon crate and it is recommended to use these from there.
+//!
+//! [`join`] is used to take two closures and potentially run them in parallel.
+//!   - It will run in parallel if task B gets stolen before task A can finish.
+//!   - It will run sequentially if task A finishes before task B is stolen and can continue on task B.
+//!
+//! [`scope`] creates a scope in which you can run any number of parallel tasks.
+//! These tasks can spawn nested tasks and scopes, but given the nature of work stealing, the order of execution can not be guaranteed.
+//! The scope will exist until all tasks spawned within the scope have been completed.
+//!
+//! [`spawn`] add a task into the 'static' or 'global' scope, or a local scope created by the [`scope()`] function.
+//!
+//! [`ThreadPool`] can be used to create your own thread pools (using [`ThreadPoolBuilder`]) or to customize the global one.
+//! Tasks spawned within the pool (using [`install()`], [`join()`], etc.) will be added to a deque,
+//! where it becomes available for work stealing from other threads in the local threadpool.
+//!
+//! [`join`]: fn.join.html
+//! [`scope`]: fn.scope.html
+//! [`scope()`]: fn.scope.html
+//! [`spawn`]: fn.spawn.html
+//! [`ThreadPool`]: struct.threadpool.html
+//! [`install()`]: struct.ThreadPool.html#method.install
+//! [`spawn()`]: struct.ThreadPool.html#method.spawn
+//! [`join()`]: struct.ThreadPool.html#method.join
+//! [`ThreadPoolBuilder`]: struct.ThreadPoolBuilder.html
+//!
+//! # Global fallback when threading is unsupported
+//!
+//! Rayon uses `std` APIs for threading, but some targets have incomplete implementations that
+//! always return `Unsupported` errors. The WebAssembly `wasm32-unknown-unknown` and `wasm32-wasi`
+//! targets are notable examples of this. Rather than panicking on the unsupported error when
+//! creating the implicit global threadpool, Rayon configures a fallback mode instead.
+//!
+//! This fallback mode mostly functions as if it were using a single-threaded "pool", like setting
+//! `RAYON_NUM_THREADS=1`. For example, `join` will execute its two closures sequentially, since
+//! there is no other thread to share the work. However, since the pool is not running independent
+//! of the main thread, non-blocking calls like `spawn` may not execute at all, unless a lower-
+//! priority call like `broadcast` gives them an opening. The fallback mode does not try to emulate
+//! anything like thread preemption or `async` task switching, but `yield_now` or `yield_local`
+//! can also volunteer execution time.
+//!
+//! Explicit `ThreadPoolBuilder` methods always report their error without any fallback.
+//!
+//! # Restricting multiple versions
+//!
+//! In order to ensure proper coordination between threadpools, and especially
+//! to make sure there's only one global threadpool, `rayon-core` is actively
+//! restricted from building multiple versions of itself into a single target.
+//! You may see a build error like this in violation:
+//!
+//! ```text
+//! error: native library `rayon-core` is being linked to by more
+//! than one package, and can only be linked to by one package
+//! ```
+//!
+//! While we strive to keep `rayon-core` semver-compatible, it's still
+//! possible to arrive at this situation if different crates have overly
+//! restrictive tilde or inequality requirements for `rayon-core`.  The
+//! conflicting requirements will need to be resolved before the build will
+//! succeed.
+
+#![deny(missing_debug_implementations)]
+#![deny(missing_docs)]
+#![deny(unreachable_pub)]
+#![warn(rust_2018_idioms)]
+
+use std::any::Any;
+use std::env;
+use std::error::Error;
+use std::fmt;
+use std::io;
+use std::marker::PhantomData;
+use std::str::FromStr;
+use std::thread;
+
+#[macro_use]
+mod private;
+
+mod broadcast;
+mod job;
+mod join;
+mod latch;
+mod registry;
+mod scope;
+mod sleep;
+mod spawn;
+mod thread_pool;
+mod unwind;
+
+mod compile_fail;
+mod test;
+
+pub use self::broadcast::{broadcast, spawn_broadcast, BroadcastContext};
+pub use self::join::{join, join_context};
+pub use self::registry::ThreadBuilder;
+pub use self::scope::{in_place_scope, scope, Scope};
+pub use self::scope::{in_place_scope_fifo, scope_fifo, ScopeFifo};
+pub use self::spawn::{spawn, spawn_fifo};
+pub use self::thread_pool::current_thread_has_pending_tasks;
+pub use self::thread_pool::current_thread_index;
+pub use self::thread_pool::ThreadPool;
+pub use self::thread_pool::{yield_local, yield_now, Yield};
+
+#[cfg(not(feature = "web_spin_lock"))]
+use std::sync;
+
+#[cfg(feature = "web_spin_lock")]
+use wasm_sync as sync;
+
+use self::registry::{CustomSpawn, DefaultSpawn, ThreadSpawn};
+
+/// Returns the maximum number of threads that Rayon supports in a single thread-pool.
+///
+/// If a higher thread count is requested by calling `ThreadPoolBuilder::num_threads` or by setting
+/// the `RAYON_NUM_THREADS` environment variable, then it will be reduced to this maximum.
+///
+/// The value may vary between different targets, and is subject to change in new Rayon versions.
+pub fn max_num_threads() -> usize {
+    // We are limited by the bits available in the sleep counter's `AtomicUsize`.
+    crate::sleep::THREADS_MAX
+}
+
+/// Returns the number of threads in the current registry. If this
+/// code is executing within a Rayon thread-pool, then this will be
+/// the number of threads for the thread-pool of the current
+/// thread. Otherwise, it will be the number of threads for the global
+/// thread-pool.
+///
+/// This can be useful when trying to judge how many times to split
+/// parallel work (the parallel iterator traits use this value
+/// internally for this purpose).
+///
+/// # Future compatibility note
+///
+/// Note that unless this thread-pool was created with a
+/// builder that specifies the number of threads, then this
+/// number may vary over time in future versions (see [the
+/// `num_threads()` method for details][snt]).
+///
+/// [snt]: struct.ThreadPoolBuilder.html#method.num_threads
+pub fn current_num_threads() -> usize {
+    crate::registry::Registry::current_num_threads()
+}
+
+/// Error when initializing a thread pool.
+#[derive(Debug)]
+pub struct ThreadPoolBuildError {
+    kind: ErrorKind,
+}
+
+#[derive(Debug)]
+enum ErrorKind {
+    GlobalPoolAlreadyInitialized,
+    CurrentThreadAlreadyInPool,
+    IOError(io::Error),
+}
+
+/// Used to create a new [`ThreadPool`] or to configure the global rayon thread pool.
+/// ## Creating a ThreadPool
+/// The following creates a thread pool with 22 threads.
+///
+/// ```rust
+/// # use rayon_core as rayon;
+/// let pool = rayon::ThreadPoolBuilder::new().num_threads(22).build().unwrap();
+/// ```
+///
+/// To instead configure the global thread pool, use [`build_global()`]:
+///
+/// ```rust
+/// # use rayon_core as rayon;
+/// rayon::ThreadPoolBuilder::new().num_threads(22).build_global().unwrap();
+/// ```
+///
+/// [`ThreadPool`]: struct.ThreadPool.html
+/// [`build_global()`]: struct.ThreadPoolBuilder.html#method.build_global
+pub struct ThreadPoolBuilder<S = DefaultSpawn> {
+    /// The number of threads in the rayon thread pool.
+    /// If zero will use the RAYON_NUM_THREADS environment variable.
+    /// If RAYON_NUM_THREADS is invalid or zero will use the default.
+    num_threads: usize,
+
+    /// The thread we're building *from* will also be part of the pool.
+    use_current_thread: bool,
+
+    /// Custom closure, if any, to handle a panic that we cannot propagate
+    /// anywhere else.
+    panic_handler: Option<Box<PanicHandler>>,
+
+    /// Closure to compute the name of a thread.
+    get_thread_name: Option<Box<dyn FnMut(usize) -> String>>,
+
+    /// The stack size for the created worker threads
+    stack_size: Option<usize>,
+
+    /// Closure invoked on worker thread start.
+    start_handler: Option<Box<StartHandler>>,
+
+    /// Closure invoked on worker thread exit.
+    exit_handler: Option<Box<ExitHandler>>,
+
+    /// Closure invoked to spawn threads.
+    spawn_handler: S,
+
+    /// If false, worker threads will execute spawned jobs in a
+    /// "depth-first" fashion. If true, they will do a "breadth-first"
+    /// fashion. Depth-first is the default.
+    breadth_first: bool,
+}
+
+/// Contains the rayon thread pool configuration. Use [`ThreadPoolBuilder`] instead.
+///
+/// [`ThreadPoolBuilder`]: struct.ThreadPoolBuilder.html
+#[deprecated(note = "Use `ThreadPoolBuilder`")]
+#[derive(Default)]
+pub struct Configuration {
+    builder: ThreadPoolBuilder,
+}
+
+/// The type for a panic handling closure. Note that this same closure
+/// may be invoked multiple times in parallel.
+type PanicHandler = dyn Fn(Box<dyn Any + Send>) + Send + Sync;
+
+/// The type for a closure that gets invoked when a thread starts. The
+/// closure is passed the index of the thread on which it is invoked.
+/// Note that this same closure may be invoked multiple times in parallel.
+type StartHandler = dyn Fn(usize) + Send + Sync;
+
+/// The type for a closure that gets invoked when a thread exits. The
+/// closure is passed the index of the thread on which is is invoked.
+/// Note that this same closure may be invoked multiple times in parallel.
+type ExitHandler = dyn Fn(usize) + Send + Sync;
+
+// NB: We can't `#[derive(Default)]` because `S` is left ambiguous.
+impl Default for ThreadPoolBuilder {
+    fn default() -> Self {
+        ThreadPoolBuilder {
+            num_threads: 0,
+            use_current_thread: false,
+            panic_handler: None,
+            get_thread_name: None,
+            stack_size: None,
+            start_handler: None,
+            exit_handler: None,
+            spawn_handler: DefaultSpawn,
+            breadth_first: false,
+        }
+    }
+}
+
+impl ThreadPoolBuilder {
+    /// Creates and returns a valid rayon thread pool builder, but does not initialize it.
+    pub fn new() -> Self {
+        Self::default()
+    }
+}
+
+/// Note: the `S: ThreadSpawn` constraint is an internal implementation detail for the
+/// default spawn and those set by [`spawn_handler`](#method.spawn_handler).
+impl<S> ThreadPoolBuilder<S>
+where
+    S: ThreadSpawn,
+{
+    /// Creates a new `ThreadPool` initialized using this configuration.
+    pub fn build(self) -> Result<ThreadPool, ThreadPoolBuildError> {
+        ThreadPool::build(self)
+    }
+
+    /// Initializes the global thread pool. This initialization is
+    /// **optional**.  If you do not call this function, the thread pool
+    /// will be automatically initialized with the default
+    /// configuration. Calling `build_global` is not recommended, except
+    /// in two scenarios:
+    ///
+    /// - You wish to change the default configuration.
+    /// - You are running a benchmark, in which case initializing may
+    ///   yield slightly more consistent results, since the worker threads
+    ///   will already be ready to go even in the first iteration.  But
+    ///   this cost is minimal.
+    ///
+    /// Initialization of the global thread pool happens exactly
+    /// once. Once started, the configuration cannot be
+    /// changed. Therefore, if you call `build_global` a second time, it
+    /// will return an error. An `Ok` result indicates that this
+    /// is the first initialization of the thread pool.
+    pub fn build_global(self) -> Result<(), ThreadPoolBuildError> {
+        let registry = registry::init_global_registry(self)?;
+        registry.wait_until_primed();
+        Ok(())
+    }
+}
+
+impl ThreadPoolBuilder {
+    /// Creates a scoped `ThreadPool` initialized using this configuration.
+    ///
+    /// This is a convenience function for building a pool using [`std::thread::scope`]
+    /// to spawn threads in a [`spawn_handler`](#method.spawn_handler).
+    /// The threads in this pool will start by calling `wrapper`, which should
+    /// do initialization and continue by calling `ThreadBuilder::run()`.
+    ///
+    /// [`std::thread::scope`]: https://doc.rust-lang.org/std/thread/fn.scope.html
+    ///
+    /// # Examples
+    ///
+    /// A scoped pool may be useful in combination with scoped thread-local variables.
+    ///
+    /// ```
+    /// # use rayon_core as rayon;
+    ///
+    /// scoped_tls::scoped_thread_local!(static POOL_DATA: Vec<i32>);
+    ///
+    /// fn main() -> Result<(), rayon::ThreadPoolBuildError> {
+    ///     let pool_data = vec![1, 2, 3];
+    ///
+    ///     // We haven't assigned any TLS data yet.
+    ///     assert!(!POOL_DATA.is_set());
+    ///
+    ///     rayon::ThreadPoolBuilder::new()
+    ///         .build_scoped(
+    ///             // Borrow `pool_data` in TLS for each thread.
+    ///             |thread| POOL_DATA.set(&pool_data, || thread.run()),
+    ///             // Do some work that needs the TLS data.
+    ///             |pool| pool.install(|| assert!(POOL_DATA.is_set())),
+    ///         )?;
+    ///
+    ///     // Once we've returned, `pool_data` is no longer borrowed.
+    ///     drop(pool_data);
+    ///     Ok(())
+    /// }
+    /// ```
+    pub fn build_scoped<W, F, R>(self, wrapper: W, with_pool: F) -> Result<R, ThreadPoolBuildError>
+    where
+        W: Fn(ThreadBuilder) + Sync, // expected to call `run()`
+        F: FnOnce(&ThreadPool) -> R,
+    {
+        std::thread::scope(|scope| {
+            let pool = self
+                .spawn_handler(|thread| {
+                    let mut builder = std::thread::Builder::new();
+                    if let Some(name) = thread.name() {
+                        builder = builder.name(name.to_string());
+                    }
+                    if let Some(size) = thread.stack_size() {
+                        builder = builder.stack_size(size);
+                    }
+                    builder.spawn_scoped(scope, || wrapper(thread))?;
+                    Ok(())
+                })
+                .build()?;
+            Ok(with_pool(&pool))
+        })
+    }
+}
+
+impl<S> ThreadPoolBuilder<S> {
+    /// Sets a custom function for spawning threads.
+    ///
+    /// Note that the threads will not exit until after the pool is dropped. It
+    /// is up to the caller to wait for thread termination if that is important
+    /// for any invariants. For instance, threads created in [`std::thread::scope`]
+    /// will be joined before that scope returns, and this will block indefinitely
+    /// if the pool is leaked. Furthermore, the global thread pool doesn't terminate
+    /// until the entire process exits!
+    ///
+    /// # Examples
+    ///
+    /// A minimal spawn handler just needs to call `run()` from an independent thread.
+    ///
+    /// ```
+    /// # use rayon_core as rayon;
+    /// fn main() -> Result<(), rayon::ThreadPoolBuildError> {
+    ///     let pool = rayon::ThreadPoolBuilder::new()
+    ///         .spawn_handler(|thread| {
+    ///             std::thread::spawn(|| thread.run());
+    ///             Ok(())
+    ///         })
+    ///         .build()?;
+    ///
+    ///     pool.install(|| println!("Hello from my custom thread!"));
+    ///     Ok(())
+    /// }
+    /// ```
+    ///
+    /// The default spawn handler sets the name and stack size if given, and propagates
+    /// any errors from the thread builder.
+    ///
+    /// ```
+    /// # use rayon_core as rayon;
+    /// fn main() -> Result<(), rayon::ThreadPoolBuildError> {
+    ///     let pool = rayon::ThreadPoolBuilder::new()
+    ///         .spawn_handler(|thread| {
+    ///             let mut b = std::thread::Builder::new();
+    ///             if let Some(name) = thread.name() {
+    ///                 b = b.name(name.to_owned());
+    ///             }
+    ///             if let Some(stack_size) = thread.stack_size() {
+    ///                 b = b.stack_size(stack_size);
+    ///             }
+    ///             b.spawn(|| thread.run())?;
+    ///             Ok(())
+    ///         })
+    ///         .build()?;
+    ///
+    ///     pool.install(|| println!("Hello from my fully custom thread!"));
+    ///     Ok(())
+    /// }
+    /// ```
+    ///
+    /// This can also be used for a pool of scoped threads like [`crossbeam::scope`],
+    /// or [`std::thread::scope`] introduced in Rust 1.63, which is encapsulated in
+    /// [`build_scoped`](#method.build_scoped).
+    ///
+    /// [`crossbeam::scope`]: https://docs.rs/crossbeam/0.8/crossbeam/fn.scope.html
+    /// [`std::thread::scope`]: https://doc.rust-lang.org/std/thread/fn.scope.html
+    ///
+    /// ```
+    /// # use rayon_core as rayon;
+    /// fn main() -> Result<(), rayon::ThreadPoolBuildError> {
+    ///     std::thread::scope(|scope| {
+    ///         let pool = rayon::ThreadPoolBuilder::new()
+    ///             .spawn_handler(|thread| {
+    ///                 let mut builder = std::thread::Builder::new();
+    ///                 if let Some(name) = thread.name() {
+    ///                     builder = builder.name(name.to_string());
+    ///                 }
+    ///                 if let Some(size) = thread.stack_size() {
+    ///                     builder = builder.stack_size(size);
+    ///                 }
+    ///                 builder.spawn_scoped(scope, || {
+    ///                     // Add any scoped initialization here, then run!
+    ///                     thread.run()
+    ///                 })?;
+    ///                 Ok(())
+    ///             })
+    ///             .build()?;
+    ///
+    ///         pool.install(|| println!("Hello from my custom scoped thread!"));
+    ///         Ok(())
+    ///     })
+    /// }
+    /// ```
+    pub fn spawn_handler<F>(self, spawn: F) -> ThreadPoolBuilder<CustomSpawn<F>>
+    where
+        F: FnMut(ThreadBuilder) -> io::Result<()>,
+    {
+        ThreadPoolBuilder {
+            spawn_handler: CustomSpawn::new(spawn),
+            // ..self
+            num_threads: self.num_threads,
+            use_current_thread: self.use_current_thread,
+            panic_handler: self.panic_handler,
+            get_thread_name: self.get_thread_name,
+            stack_size: self.stack_size,
+            start_handler: self.start_handler,
+            exit_handler: self.exit_handler,
+            breadth_first: self.breadth_first,
+        }
+    }
+
+    /// Returns a reference to the current spawn handler.
+    fn get_spawn_handler(&mut self) -> &mut S {
+        &mut self.spawn_handler
+    }
+
+    /// Get the number of threads that will be used for the thread
+    /// pool. See `num_threads()` for more information.
+    fn get_num_threads(&self) -> usize {
+        if self.num_threads > 0 {
+            self.num_threads
+        } else {
+            let default = || {
+                thread::available_parallelism()
+                    .map(|n| n.get())
+                    .unwrap_or(1)
+            };
+
+            match env::var("RAYON_NUM_THREADS")
+                .ok()
+                .and_then(|s| usize::from_str(&s).ok())
+            {
+                Some(x @ 1..) => return x,
+                Some(0) => return default(),
+                _ => {}
+            }
+
+            // Support for deprecated `RAYON_RS_NUM_CPUS`.
+            match env::var("RAYON_RS_NUM_CPUS")
+                .ok()
+                .and_then(|s| usize::from_str(&s).ok())
+            {
+                Some(x @ 1..) => x,
+                _ => default(),
+            }
+        }
+    }
+
+    /// Get the thread name for the thread with the given index.
+    fn get_thread_name(&mut self, index: usize) -> Option<String> {
+        let f = self.get_thread_name.as_mut()?;
+        Some(f(index))
+    }
+
+    /// Sets a closure which takes a thread index and returns
+    /// the thread's name.
+    pub fn thread_name<F>(mut self, closure: F) -> Self
+    where
+        F: FnMut(usize) -> String + 'static,
+    {
+        self.get_thread_name = Some(Box::new(closure));
+        self
+    }
+
+    /// Sets the number of threads to be used in the rayon threadpool.
+    ///
+    /// If you specify a non-zero number of threads using this
+    /// function, then the resulting thread-pools are guaranteed to
+    /// start at most this number of threads.
+    ///
+    /// If `num_threads` is 0, or you do not call this function, then
+    /// the Rayon runtime will select the number of threads
+    /// automatically. At present, this is based on the
+    /// `RAYON_NUM_THREADS` environment variable (if set),
+    /// or the number of logical CPUs (otherwise).
+    /// In the future, however, the default behavior may
+    /// change to dynamically add or remove threads as needed.
+    ///
+    /// **Future compatibility warning:** Given the default behavior
+    /// may change in the future, if you wish to rely on a fixed
+    /// number of threads, you should use this function to specify
+    /// that number. To reproduce the current default behavior, you
+    /// may wish to use [`std::thread::available_parallelism`]
+    /// to query the number of CPUs dynamically.
+    ///
+    /// **Old environment variable:** `RAYON_NUM_THREADS` is a one-to-one
+    /// replacement of the now deprecated `RAYON_RS_NUM_CPUS` environment
+    /// variable. If both variables are specified, `RAYON_NUM_THREADS` will
+    /// be preferred.
+    pub fn num_threads(mut self, num_threads: usize) -> Self {
+        self.num_threads = num_threads;
+        self
+    }
+
+    /// Use the current thread as one of the threads in the pool.
+    ///
+    /// The current thread is guaranteed to be at index 0, and since the thread is not managed by
+    /// rayon, the spawn and exit handlers do not run for that thread.
+    ///
+    /// Note that the current thread won't run the main work-stealing loop, so jobs spawned into
+    /// the thread-pool will generally not be picked up automatically by this thread unless you
+    /// yield to rayon in some way, like via [`yield_now()`], [`yield_local()`], or [`scope()`].
+    ///
+    /// # Local thread-pools
+    ///
+    /// Using this in a local thread-pool means the registry will be leaked. In future versions
+    /// there might be a way of cleaning up the current-thread state.
+    pub fn use_current_thread(mut self) -> Self {
+        self.use_current_thread = true;
+        self
+    }
+
+    /// Returns a copy of the current panic handler.
+    fn take_panic_handler(&mut self) -> Option<Box<PanicHandler>> {
+        self.panic_handler.take()
+    }
+
+    /// Normally, whenever Rayon catches a panic, it tries to
+    /// propagate it to someplace sensible, to try and reflect the
+    /// semantics of sequential execution. But in some cases,
+    /// particularly with the `spawn()` APIs, there is no
+    /// obvious place where we should propagate the panic to.
+    /// In that case, this panic handler is invoked.
+    ///
+    /// If no panic handler is set, the default is to abort the
+    /// process, under the principle that panics should not go
+    /// unobserved.
+    ///
+    /// If the panic handler itself panics, this will abort the
+    /// process. To prevent this, wrap the body of your panic handler
+    /// in a call to `std::panic::catch_unwind()`.
+    pub fn panic_handler<H>(mut self, panic_handler: H) -> Self
+    where
+        H: Fn(Box<dyn Any + Send>) + Send + Sync + 'static,
+    {
+        self.panic_handler = Some(Box::new(panic_handler));
+        self
+    }
+
+    /// Get the stack size of the worker threads
+    fn get_stack_size(&self) -> Option<usize> {
+        self.stack_size
+    }
+
+    /// Sets the stack size of the worker threads
+    pub fn stack_size(mut self, stack_size: usize) -> Self {
+        self.stack_size = Some(stack_size);
+        self
+    }
+
+    /// **(DEPRECATED)** Suggest to worker threads that they execute
+    /// spawned jobs in a "breadth-first" fashion.
+    ///
+    /// Typically, when a worker thread is idle or blocked, it will
+    /// attempt to execute the job from the *top* of its local deque of
+    /// work (i.e., the job most recently spawned). If this flag is set
+    /// to true, however, workers will prefer to execute in a
+    /// *breadth-first* fashion -- that is, they will search for jobs at
+    /// the *bottom* of their local deque. (At present, workers *always*
+    /// steal from the bottom of other workers' deques, regardless of
+    /// the setting of this flag.)
+    ///
+    /// If you think of the tasks as a tree, where a parent task
+    /// spawns its children in the tree, then this flag loosely
+    /// corresponds to doing a breadth-first traversal of the tree,
+    /// whereas the default would be to do a depth-first traversal.
+    ///
+    /// **Note that this is an "execution hint".** Rayon's task
+    /// execution is highly dynamic and the precise order in which
+    /// independent tasks are executed is not intended to be
+    /// guaranteed.
+    ///
+    /// This `breadth_first()` method is now deprecated per [RFC #1],
+    /// and in the future its effect may be removed. Consider using
+    /// [`scope_fifo()`] for a similar effect.
+    ///
+    /// [RFC #1]: https://github.com/rayon-rs/rfcs/blob/master/accepted/rfc0001-scope-scheduling.md
+    /// [`scope_fifo()`]: fn.scope_fifo.html
+    #[deprecated(note = "use `scope_fifo` and `spawn_fifo` for similar effect")]
+    pub fn breadth_first(mut self) -> Self {
+        self.breadth_first = true;
+        self
+    }
+
+    fn get_breadth_first(&self) -> bool {
+        self.breadth_first
+    }
+
+    /// Takes the current thread start callback, leaving `None`.
+    fn take_start_handler(&mut self) -> Option<Box<StartHandler>> {
+        self.start_handler.take()
+    }
+
+    /// Sets a callback to be invoked on thread start.
+    ///
+    /// The closure is passed the index of the thread on which it is invoked.
+    /// Note that this same closure may be invoked multiple times in parallel.
+    /// If this closure panics, the panic will be passed to the panic handler.
+    /// If that handler returns, then startup will continue normally.
+    pub fn start_handler<H>(mut self, start_handler: H) -> Self
+    where
+        H: Fn(usize) + Send + Sync + 'static,
+    {
+        self.start_handler = Some(Box::new(start_handler));
+        self
+    }
+
+    /// Returns a current thread exit callback, leaving `None`.
+    fn take_exit_handler(&mut self) -> Option<Box<ExitHandler>> {
+        self.exit_handler.take()
+    }
+
+    /// Sets a callback to be invoked on thread exit.
+    ///
+    /// The closure is passed the index of the thread on which it is invoked.
+    /// Note that this same closure may be invoked multiple times in parallel.
+    /// If this closure panics, the panic will be passed to the panic handler.
+    /// If that handler returns, then the thread will exit normally.
+    pub fn exit_handler<H>(mut self, exit_handler: H) -> Self
+    where
+        H: Fn(usize) + Send + Sync + 'static,
+    {
+        self.exit_handler = Some(Box::new(exit_handler));
+        self
+    }
+}
+
+#[allow(deprecated)]
+impl Configuration {
+    /// Creates and return a valid rayon thread pool configuration, but does not initialize it.
+    pub fn new() -> Configuration {
+        Configuration {
+            builder: ThreadPoolBuilder::new(),
+        }
+    }
+
+    /// Deprecated in favor of `ThreadPoolBuilder::build`.
+    pub fn build(self) -> Result<ThreadPool, Box<dyn Error + 'static>> {
+        self.builder.build().map_err(Box::from)
+    }
+
+    /// Deprecated in favor of `ThreadPoolBuilder::thread_name`.
+    pub fn thread_name<F>(mut self, closure: F) -> Self
+    where
+        F: FnMut(usize) -> String + 'static,
+    {
+        self.builder = self.builder.thread_name(closure);
+        self
+    }
+
+    /// Deprecated in favor of `ThreadPoolBuilder::num_threads`.
+    pub fn num_threads(mut self, num_threads: usize) -> Configuration {
+        self.builder = self.builder.num_threads(num_threads);
+        self
+    }
+
+    /// Deprecated in favor of `ThreadPoolBuilder::panic_handler`.
+    pub fn panic_handler<H>(mut self, panic_handler: H) -> Configuration
+    where
+        H: Fn(Box<dyn Any + Send>) + Send + Sync + 'static,
+    {
+        self.builder = self.builder.panic_handler(panic_handler);
+        self
+    }
+
+    /// Deprecated in favor of `ThreadPoolBuilder::stack_size`.
+    pub fn stack_size(mut self, stack_size: usize) -> Self {
+        self.builder = self.builder.stack_size(stack_size);
+        self
+    }
+
+    /// Deprecated in favor of `ThreadPoolBuilder::breadth_first`.
+    pub fn breadth_first(mut self) -> Self {
+        self.builder = self.builder.breadth_first();
+        self
+    }
+
+    /// Deprecated in favor of `ThreadPoolBuilder::start_handler`.
+    pub fn start_handler<H>(mut self, start_handler: H) -> Configuration
+    where
+        H: Fn(usize) + Send + Sync + 'static,
+    {
+        self.builder = self.builder.start_handler(start_handler);
+        self
+    }
+
+    /// Deprecated in favor of `ThreadPoolBuilder::exit_handler`.
+    pub fn exit_handler<H>(mut self, exit_handler: H) -> Configuration
+    where
+        H: Fn(usize) + Send + Sync + 'static,
+    {
+        self.builder = self.builder.exit_handler(exit_handler);
+        self
+    }
+
+    /// Returns a ThreadPoolBuilder with identical parameters.
+    fn into_builder(self) -> ThreadPoolBuilder {
+        self.builder
+    }
+}
+
+impl ThreadPoolBuildError {
+    fn new(kind: ErrorKind) -> ThreadPoolBuildError {
+        ThreadPoolBuildError { kind }
+    }
+
+    fn is_unsupported(&self) -> bool {
+        matches!(&self.kind, ErrorKind::IOError(e) if e.kind() == io::ErrorKind::Unsupported)
+    }
+}
+
+const GLOBAL_POOL_ALREADY_INITIALIZED: &str =
+    "The global thread pool has already been initialized.";
+
+const CURRENT_THREAD_ALREADY_IN_POOL: &str =
+    "The current thread is already part of another thread pool.";
+
+impl Error for ThreadPoolBuildError {
+    #[allow(deprecated)]
+    fn description(&self) -> &str {
+        match self.kind {
+            ErrorKind::GlobalPoolAlreadyInitialized => GLOBAL_POOL_ALREADY_INITIALIZED,
+            ErrorKind::CurrentThreadAlreadyInPool => CURRENT_THREAD_ALREADY_IN_POOL,
+            ErrorKind::IOError(ref e) => e.description(),
+        }
+    }
+
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        match &self.kind {
+            ErrorKind::GlobalPoolAlreadyInitialized | ErrorKind::CurrentThreadAlreadyInPool => None,
+            ErrorKind::IOError(e) => Some(e),
+        }
+    }
+}
+
+impl fmt::Display for ThreadPoolBuildError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match &self.kind {
+            ErrorKind::CurrentThreadAlreadyInPool => CURRENT_THREAD_ALREADY_IN_POOL.fmt(f),
+            ErrorKind::GlobalPoolAlreadyInitialized => GLOBAL_POOL_ALREADY_INITIALIZED.fmt(f),
+            ErrorKind::IOError(e) => e.fmt(f),
+        }
+    }
+}
+
+/// Deprecated in favor of `ThreadPoolBuilder::build_global`.
+#[deprecated(note = "use `ThreadPoolBuilder::build_global`")]
+#[allow(deprecated)]
+pub fn initialize(config: Configuration) -> Result<(), Box<dyn Error>> {
+    config.into_builder().build_global().map_err(Box::from)
+}
+
+impl<S> fmt::Debug for ThreadPoolBuilder<S> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let ThreadPoolBuilder {
+            ref num_threads,
+            ref use_current_thread,
+            ref get_thread_name,
+            ref panic_handler,
+            ref stack_size,
+            ref start_handler,
+            ref exit_handler,
+            spawn_handler: _,
+            ref breadth_first,
+        } = *self;
+
+        // Just print `Some(<closure>)` or `None` to the debug
+        // output.
+        struct ClosurePlaceholder;
+        impl fmt::Debug for ClosurePlaceholder {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                f.write_str("<closure>")
+            }
+        }
+        let get_thread_name = get_thread_name.as_ref().map(|_| ClosurePlaceholder);
+        let panic_handler = panic_handler.as_ref().map(|_| ClosurePlaceholder);
+        let start_handler = start_handler.as_ref().map(|_| ClosurePlaceholder);
+        let exit_handler = exit_handler.as_ref().map(|_| ClosurePlaceholder);
+
+        f.debug_struct("ThreadPoolBuilder")
+            .field("num_threads", num_threads)
+            .field("use_current_thread", use_current_thread)
+            .field("get_thread_name", &get_thread_name)
+            .field("panic_handler", &panic_handler)
+            .field("stack_size", &stack_size)
+            .field("start_handler", &start_handler)
+            .field("exit_handler", &exit_handler)
+            .field("breadth_first", &breadth_first)
+            .finish()
+    }
+}
+
+#[allow(deprecated)]
+impl fmt::Debug for Configuration {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.builder.fmt(f)
+    }
+}
+
+/// Provides the calling context to a closure called by `join_context`.
+#[derive(Debug)]
+pub struct FnContext {
+    migrated: bool,
+
+    /// disable `Send` and `Sync`, just for a little future-proofing.
+    _marker: PhantomData<*mut ()>,
+}
+
+impl FnContext {
+    #[inline]
+    fn new(migrated: bool) -> Self {
+        FnContext {
+            migrated,
+            _marker: PhantomData,
+        }
+    }
+}
+
+impl FnContext {
+    /// Returns `true` if the closure was called from a different thread
+    /// than it was provided from.
+    #[inline]
+    pub fn migrated(&self) -> bool {
+        self.migrated
+    }
+}
diff --git a/crates/rayon-core/src/private.rs b/crates/rayon-core/src/private.rs
new file mode 100644
index 0000000..c85e77b
--- /dev/null
+++ b/crates/rayon-core/src/private.rs
@@ -0,0 +1,26 @@
+//! The public parts of this private module are used to create traits
+//! that cannot be implemented outside of our own crate.  This way we
+//! can feel free to extend those traits without worrying about it
+//! being a breaking change for other implementations.
+
+/// If this type is pub but not publicly reachable, third parties
+/// can't name it and can't implement traits using it.
+#[allow(missing_debug_implementations)]
+pub struct PrivateMarker;
+
+macro_rules! private_decl {
+    () => {
+        /// This trait is private; this method exists to make it
+        /// impossible to implement outside the crate.
+        #[doc(hidden)]
+        fn __rayon_private__(&self) -> crate::private::PrivateMarker;
+    };
+}
+
+macro_rules! private_impl {
+    () => {
+        fn __rayon_private__(&self) -> crate::private::PrivateMarker {
+            crate::private::PrivateMarker
+        }
+    };
+}
diff --git a/crates/rayon-core/src/registry.rs b/crates/rayon-core/src/registry.rs
new file mode 100644
index 0000000..46cd22b
--- /dev/null
+++ b/crates/rayon-core/src/registry.rs
@@ -0,0 +1,996 @@
+use crate::job::{JobFifo, JobRef, StackJob};
+use crate::latch::{AsCoreLatch, CoreLatch, Latch, LatchRef, LockLatch, OnceLatch, SpinLatch};
+use crate::sleep::Sleep;
+use crate::sync::Mutex;
+use crate::unwind;
+use crate::{
+    ErrorKind, ExitHandler, PanicHandler, StartHandler, ThreadPoolBuildError, ThreadPoolBuilder,
+    Yield,
+};
+use crossbeam_deque::{Injector, Steal, Stealer, Worker};
+use std::cell::Cell;
+use std::collections::hash_map::DefaultHasher;
+use std::fmt;
+use std::hash::Hasher;
+use std::io;
+use std::mem;
+use std::ptr;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::{Arc, Once};
+use std::thread;
+use std::usize;
+
+/// Thread builder used for customization via
+/// [`ThreadPoolBuilder::spawn_handler`](struct.ThreadPoolBuilder.html#method.spawn_handler).
+pub struct ThreadBuilder {
+    name: Option<String>,
+    stack_size: Option<usize>,
+    worker: Worker<JobRef>,
+    stealer: Stealer<JobRef>,
+    registry: Arc<Registry>,
+    index: usize,
+}
+
+impl ThreadBuilder {
+    /// Gets the index of this thread in the pool, within `0..num_threads`.
+    pub fn index(&self) -> usize {
+        self.index
+    }
+
+    /// Gets the string that was specified by `ThreadPoolBuilder::name()`.
+    pub fn name(&self) -> Option<&str> {
+        self.name.as_deref()
+    }
+
+    /// Gets the value that was specified by `ThreadPoolBuilder::stack_size()`.
+    pub fn stack_size(&self) -> Option<usize> {
+        self.stack_size
+    }
+
+    /// Executes the main loop for this thread. This will not return until the
+    /// thread pool is dropped.
+    pub fn run(self) {
+        unsafe { main_loop(self) }
+    }
+}
+
+impl fmt::Debug for ThreadBuilder {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("ThreadBuilder")
+            .field("pool", &self.registry.id())
+            .field("index", &self.index)
+            .field("name", &self.name)
+            .field("stack_size", &self.stack_size)
+            .finish()
+    }
+}
+
+/// Generalized trait for spawning a thread in the `Registry`.
+///
+/// This trait is pub-in-private -- E0445 forces us to make it public,
+/// but we don't actually want to expose these details in the API.
+pub trait ThreadSpawn {
+    private_decl! {}
+
+    /// Spawn a thread with the `ThreadBuilder` parameters, and then
+    /// call `ThreadBuilder::run()`.
+    fn spawn(&mut self, thread: ThreadBuilder) -> io::Result<()>;
+}
+
+/// Spawns a thread in the "normal" way with `std::thread::Builder`.
+///
+/// This type is pub-in-private -- E0445 forces us to make it public,
+/// but we don't actually want to expose these details in the API.
+#[derive(Debug, Default)]
+pub struct DefaultSpawn;
+
+impl ThreadSpawn for DefaultSpawn {
+    private_impl! {}
+
+    fn spawn(&mut self, thread: ThreadBuilder) -> io::Result<()> {
+        let mut b = thread::Builder::new();
+        if let Some(name) = thread.name() {
+            b = b.name(name.to_owned());
+        }
+        if let Some(stack_size) = thread.stack_size() {
+            b = b.stack_size(stack_size);
+        }
+        b.spawn(|| thread.run())?;
+        Ok(())
+    }
+}
+
+/// Spawns a thread with a user's custom callback.
+///
+/// This type is pub-in-private -- E0445 forces us to make it public,
+/// but we don't actually want to expose these details in the API.
+#[derive(Debug)]
+pub struct CustomSpawn<F>(F);
+
+impl<F> CustomSpawn<F>
+where
+    F: FnMut(ThreadBuilder) -> io::Result<()>,
+{
+    pub(super) fn new(spawn: F) -> Self {
+        CustomSpawn(spawn)
+    }
+}
+
+impl<F> ThreadSpawn for CustomSpawn<F>
+where
+    F: FnMut(ThreadBuilder) -> io::Result<()>,
+{
+    private_impl! {}
+
+    #[inline]
+    fn spawn(&mut self, thread: ThreadBuilder) -> io::Result<()> {
+        (self.0)(thread)
+    }
+}
+
+pub(super) struct Registry {
+    thread_infos: Vec<ThreadInfo>,
+    sleep: Sleep,
+    injected_jobs: Injector<JobRef>,
+    broadcasts: Mutex<Vec<Worker<JobRef>>>,
+    panic_handler: Option<Box<PanicHandler>>,
+    start_handler: Option<Box<StartHandler>>,
+    exit_handler: Option<Box<ExitHandler>>,
+
+    // When this latch reaches 0, it means that all work on this
+    // registry must be complete. This is ensured in the following ways:
+    //
+    // - if this is the global registry, there is a ref-count that never
+    //   gets released.
+    // - if this is a user-created thread-pool, then so long as the thread-pool
+    //   exists, it holds a reference.
+    // - when we inject a "blocking job" into the registry with `ThreadPool::install()`,
+    //   no adjustment is needed; the `ThreadPool` holds the reference, and since we won't
+    //   return until the blocking job is complete, that ref will continue to be held.
+    // - when `join()` or `scope()` is invoked, similarly, no adjustments are needed.
+    //   These are always owned by some other job (e.g., one injected by `ThreadPool::install()`)
+    //   and that job will keep the pool alive.
+    terminate_count: AtomicUsize,
+}
+
+/// ////////////////////////////////////////////////////////////////////////
+/// Initialization
+
+static mut THE_REGISTRY: Option<Arc<Registry>> = None;
+static THE_REGISTRY_SET: Once = Once::new();
+
+/// Starts the worker threads (if that has not already happened). If
+/// initialization has not already occurred, use the default
+/// configuration.
+pub(super) fn global_registry() -> &'static Arc<Registry> {
+    set_global_registry(default_global_registry)
+        .or_else(|err| unsafe { THE_REGISTRY.as_ref().ok_or(err) })
+        .expect("The global thread pool has not been initialized.")
+}
+
+/// Starts the worker threads (if that has not already happened) with
+/// the given builder.
+pub(super) fn init_global_registry<S>(
+    builder: ThreadPoolBuilder<S>,
+) -> Result<&'static Arc<Registry>, ThreadPoolBuildError>
+where
+    S: ThreadSpawn,
+{
+    set_global_registry(|| Registry::new(builder))
+}
+
+/// Starts the worker threads (if that has not already happened)
+/// by creating a registry with the given callback.
+fn set_global_registry<F>(registry: F) -> Result<&'static Arc<Registry>, ThreadPoolBuildError>
+where
+    F: FnOnce() -> Result<Arc<Registry>, ThreadPoolBuildError>,
+{
+    let mut result = Err(ThreadPoolBuildError::new(
+        ErrorKind::GlobalPoolAlreadyInitialized,
+    ));
+
+    THE_REGISTRY_SET.call_once(|| {
+        result = registry()
+            .map(|registry: Arc<Registry>| unsafe { &*THE_REGISTRY.get_or_insert(registry) })
+    });
+
+    result
+}
+
+fn default_global_registry() -> Result<Arc<Registry>, ThreadPoolBuildError> {
+    let result = Registry::new(ThreadPoolBuilder::new());
+
+    // If we're running in an environment that doesn't support threads at all, we can fall back to
+    // using the current thread alone. This is crude, and probably won't work for non-blocking
+    // calls like `spawn` or `broadcast_spawn`, but a lot of stuff does work fine.
+    //
+    // Notably, this allows current WebAssembly targets to work even though their threading support
+    // is stubbed out, and we won't have to change anything if they do add real threading.
+    let unsupported = matches!(&result, Err(e) if e.is_unsupported());
+    if unsupported && WorkerThread::current().is_null() {
+        let builder = ThreadPoolBuilder::new().num_threads(1).use_current_thread();
+        let fallback_result = Registry::new(builder);
+        if fallback_result.is_ok() {
+            return fallback_result;
+        }
+    }
+
+    result
+}
+
+struct Terminator<'a>(&'a Arc<Registry>);
+
+impl<'a> Drop for Terminator<'a> {
+    fn drop(&mut self) {
+        self.0.terminate()
+    }
+}
+
+impl Registry {
+    pub(super) fn new<S>(
+        mut builder: ThreadPoolBuilder<S>,
+    ) -> Result<Arc<Self>, ThreadPoolBuildError>
+    where
+        S: ThreadSpawn,
+    {
+        // Soft-limit the number of threads that we can actually support.
+        let n_threads = Ord::min(builder.get_num_threads(), crate::max_num_threads());
+
+        let breadth_first = builder.get_breadth_first();
+
+        let (workers, stealers): (Vec<_>, Vec<_>) = (0..n_threads)
+            .map(|_| {
+                let worker = if breadth_first {
+                    Worker::new_fifo()
+                } else {
+                    Worker::new_lifo()
+                };
+
+                let stealer = worker.stealer();
+                (worker, stealer)
+            })
+            .unzip();
+
+        let (broadcasts, broadcast_stealers): (Vec<_>, Vec<_>) = (0..n_threads)
+            .map(|_| {
+                let worker = Worker::new_fifo();
+                let stealer = worker.stealer();
+                (worker, stealer)
+            })
+            .unzip();
+
+        let registry = Arc::new(Registry {
+            thread_infos: stealers.into_iter().map(ThreadInfo::new).collect(),
+            sleep: Sleep::new(n_threads),
+            injected_jobs: Injector::new(),
+            broadcasts: Mutex::new(broadcasts),
+            terminate_count: AtomicUsize::new(1),
+            panic_handler: builder.take_panic_handler(),
+            start_handler: builder.take_start_handler(),
+            exit_handler: builder.take_exit_handler(),
+        });
+
+        // If we return early or panic, make sure to terminate existing threads.
+        let t1000 = Terminator(&registry);
+
+        for (index, (worker, stealer)) in workers.into_iter().zip(broadcast_stealers).enumerate() {
+            let thread = ThreadBuilder {
+                name: builder.get_thread_name(index),
+                stack_size: builder.get_stack_size(),
+                registry: Arc::clone(&registry),
+                worker,
+                stealer,
+                index,
+            };
+
+            if index == 0 && builder.use_current_thread {
+                if !WorkerThread::current().is_null() {
+                    return Err(ThreadPoolBuildError::new(
+                        ErrorKind::CurrentThreadAlreadyInPool,
+                    ));
+                }
+                // Rather than starting a new thread, we're just taking over the current thread
+                // *without* running the main loop, so we can still return from here.
+                // The WorkerThread is leaked, but we never shutdown the global pool anyway.
+                let worker_thread = Box::into_raw(Box::new(WorkerThread::from(thread)));
+
+                unsafe {
+                    WorkerThread::set_current(worker_thread);
+                    Latch::set(&registry.thread_infos[index].primed);
+                }
+                continue;
+            }
+
+            if let Err(e) = builder.get_spawn_handler().spawn(thread) {
+                return Err(ThreadPoolBuildError::new(ErrorKind::IOError(e)));
+            }
+        }
+
+        // Returning normally now, without termination.
+        mem::forget(t1000);
+
+        Ok(registry)
+    }
+
+    pub(super) fn current() -> Arc<Registry> {
+        unsafe {
+            let worker_thread = WorkerThread::current();
+            let registry = if worker_thread.is_null() {
+                global_registry()
+            } else {
+                &(*worker_thread).registry
+            };
+            Arc::clone(registry)
+        }
+    }
+
+    /// Returns the number of threads in the current registry.  This
+    /// is better than `Registry::current().num_threads()` because it
+    /// avoids incrementing the `Arc`.
+    pub(super) fn current_num_threads() -> usize {
+        unsafe {
+            let worker_thread = WorkerThread::current();
+            if worker_thread.is_null() {
+                global_registry().num_threads()
+            } else {
+                (*worker_thread).registry.num_threads()
+            }
+        }
+    }
+
+    /// Returns the current `WorkerThread` if it's part of this `Registry`.
+    pub(super) fn current_thread(&self) -> Option<&WorkerThread> {
+        unsafe {
+            let worker = WorkerThread::current().as_ref()?;
+            if worker.registry().id() == self.id() {
+                Some(worker)
+            } else {
+                None
+            }
+        }
+    }
+
+    /// Returns an opaque identifier for this registry.
+    pub(super) fn id(&self) -> RegistryId {
+        // We can rely on `self` not to change since we only ever create
+        // registries that are boxed up in an `Arc` (see `new()` above).
+        RegistryId {
+            addr: self as *const Self as usize,
+        }
+    }
+
+    pub(super) fn num_threads(&self) -> usize {
+        self.thread_infos.len()
+    }
+
+    pub(super) fn catch_unwind(&self, f: impl FnOnce()) {
+        if let Err(err) = unwind::halt_unwinding(f) {
+            // If there is no handler, or if that handler itself panics, then we abort.
+            let abort_guard = unwind::AbortIfPanic;
+            if let Some(ref handler) = self.panic_handler {
+                handler(err);
+                mem::forget(abort_guard);
+            }
+        }
+    }
+
+    /// Waits for the worker threads to get up and running.  This is
+    /// meant to be used for benchmarking purposes, primarily, so that
+    /// you can get more consistent numbers by having everything
+    /// "ready to go".
+    pub(super) fn wait_until_primed(&self) {
+        for info in &self.thread_infos {
+            info.primed.wait();
+        }
+    }
+
+    /// Waits for the worker threads to stop. This is used for testing
+    /// -- so we can check that termination actually works.
+    #[cfg(test)]
+    pub(super) fn wait_until_stopped(&self) {
+        for info in &self.thread_infos {
+            info.stopped.wait();
+        }
+    }
+
+    /// ////////////////////////////////////////////////////////////////////////
+    /// MAIN LOOP
+    ///
+    /// So long as all of the worker threads are hanging out in their
+    /// top-level loop, there is no work to be done.
+
+    /// Push a job into the given `registry`. If we are running on a
+    /// worker thread for the registry, this will push onto the
+    /// deque. Else, it will inject from the outside (which is slower).
+    pub(super) fn inject_or_push(&self, job_ref: JobRef) {
+        let worker_thread = WorkerThread::current();
+        unsafe {
+            if !worker_thread.is_null() && (*worker_thread).registry().id() == self.id() {
+                (*worker_thread).push(job_ref);
+            } else {
+                self.inject(job_ref);
+            }
+        }
+    }
+
+    /// Push a job into the "external jobs" queue; it will be taken by
+    /// whatever worker has nothing to do. Use this if you know that
+    /// you are not on a worker of this registry.
+    pub(super) fn inject(&self, injected_job: JobRef) {
+        // It should not be possible for `state.terminate` to be true
+        // here. It is only set to true when the user creates (and
+        // drops) a `ThreadPool`; and, in that case, they cannot be
+        // calling `inject()` later, since they dropped their
+        // `ThreadPool`.
+        debug_assert_ne!(
+            self.terminate_count.load(Ordering::Acquire),
+            0,
+            "inject() sees state.terminate as true"
+        );
+
+        let queue_was_empty = self.injected_jobs.is_empty();
+
+        self.injected_jobs.push(injected_job);
+        self.sleep.new_injected_jobs(1, queue_was_empty);
+    }
+
+    fn has_injected_job(&self) -> bool {
+        !self.injected_jobs.is_empty()
+    }
+
+    fn pop_injected_job(&self) -> Option<JobRef> {
+        loop {
+            match self.injected_jobs.steal() {
+                Steal::Success(job) => return Some(job),
+                Steal::Empty => return None,
+                Steal::Retry => {}
+            }
+        }
+    }
+
+    /// Push a job into each thread's own "external jobs" queue; it will be
+    /// executed only on that thread, when it has nothing else to do locally,
+    /// before it tries to steal other work.
+    ///
+    /// **Panics** if not given exactly as many jobs as there are threads.
+    pub(super) fn inject_broadcast(&self, injected_jobs: impl ExactSizeIterator<Item = JobRef>) {
+        assert_eq!(self.num_threads(), injected_jobs.len());
+        {
+            let broadcasts = self.broadcasts.lock().unwrap();
+
+            // It should not be possible for `state.terminate` to be true
+            // here. It is only set to true when the user creates (and
+            // drops) a `ThreadPool`; and, in that case, they cannot be
+            // calling `inject_broadcast()` later, since they dropped their
+            // `ThreadPool`.
+            debug_assert_ne!(
+                self.terminate_count.load(Ordering::Acquire),
+                0,
+                "inject_broadcast() sees state.terminate as true"
+            );
+
+            assert_eq!(broadcasts.len(), injected_jobs.len());
+            for (worker, job_ref) in broadcasts.iter().zip(injected_jobs) {
+                worker.push(job_ref);
+            }
+        }
+        for i in 0..self.num_threads() {
+            self.sleep.notify_worker_latch_is_set(i);
+        }
+    }
+
+    /// If already in a worker-thread of this registry, just execute `op`.
+    /// Otherwise, inject `op` in this thread-pool. Either way, block until `op`
+    /// completes and return its return value. If `op` panics, that panic will
+    /// be propagated as well.  The second argument indicates `true` if injection
+    /// was performed, `false` if executed directly.
+    pub(super) fn in_worker<OP, R>(&self, op: OP) -> R
+    where
+        OP: FnOnce(&WorkerThread, bool) -> R + Send,
+        R: Send,
+    {
+        unsafe {
+            let worker_thread = WorkerThread::current();
+            if worker_thread.is_null() {
+                self.in_worker_cold(op)
+            } else if (*worker_thread).registry().id() != self.id() {
+                self.in_worker_cross(&*worker_thread, op)
+            } else {
+                // Perfectly valid to give them a `&T`: this is the
+                // current thread, so we know the data structure won't be
+                // invalidated until we return.
+                op(&*worker_thread, false)
+            }
+        }
+    }
+
+    #[cold]
+    unsafe fn in_worker_cold<OP, R>(&self, op: OP) -> R
+    where
+        OP: FnOnce(&WorkerThread, bool) -> R + Send,
+        R: Send,
+    {
+        thread_local!(static LOCK_LATCH: LockLatch = LockLatch::new());
+
+        LOCK_LATCH.with(|l| {
+            // This thread isn't a member of *any* thread pool, so just block.
+            debug_assert!(WorkerThread::current().is_null());
+            let job = StackJob::new(
+                |injected| {
+                    let worker_thread = WorkerThread::current();
+                    assert!(injected && !worker_thread.is_null());
+                    op(&*worker_thread, true)
+                },
+                LatchRef::new(l),
+            );
+            self.inject(job.as_job_ref());
+            job.latch.wait_and_reset(); // Make sure we can use the same latch again next time.
+
+            job.into_result()
+        })
+    }
+
+    #[cold]
+    unsafe fn in_worker_cross<OP, R>(&self, current_thread: &WorkerThread, op: OP) -> R
+    where
+        OP: FnOnce(&WorkerThread, bool) -> R + Send,
+        R: Send,
+    {
+        // This thread is a member of a different pool, so let it process
+        // other work while waiting for this `op` to complete.
+        debug_assert!(current_thread.registry().id() != self.id());
+        let latch = SpinLatch::cross(current_thread);
+        let job = StackJob::new(
+            |injected| {
+                let worker_thread = WorkerThread::current();
+                assert!(injected && !worker_thread.is_null());
+                op(&*worker_thread, true)
+            },
+            latch,
+        );
+        self.inject(job.as_job_ref());
+        current_thread.wait_until(&job.latch);
+        job.into_result()
+    }
+
+    /// Increments the terminate counter. This increment should be
+    /// balanced by a call to `terminate`, which will decrement. This
+    /// is used when spawning asynchronous work, which needs to
+    /// prevent the registry from terminating so long as it is active.
+    ///
+    /// Note that blocking functions such as `join` and `scope` do not
+    /// need to concern themselves with this fn; their context is
+    /// responsible for ensuring the current thread-pool will not
+    /// terminate until they return.
+    ///
+    /// The global thread-pool always has an outstanding reference
+    /// (the initial one). Custom thread-pools have one outstanding
+    /// reference that is dropped when the `ThreadPool` is dropped:
+    /// since installing the thread-pool blocks until any joins/scopes
+    /// complete, this ensures that joins/scopes are covered.
+    ///
+    /// The exception is `::spawn()`, which can create a job outside
+    /// of any blocking scope. In that case, the job itself holds a
+    /// terminate count and is responsible for invoking `terminate()`
+    /// when finished.
+    pub(super) fn increment_terminate_count(&self) {
+        let previous = self.terminate_count.fetch_add(1, Ordering::AcqRel);
+        debug_assert!(previous != 0, "registry ref count incremented from zero");
+        assert!(
+            previous != std::usize::MAX,
+            "overflow in registry ref count"
+        );
+    }
+
+    /// Signals that the thread-pool which owns this registry has been
+    /// dropped. The worker threads will gradually terminate, once any
+    /// extant work is completed.
+    pub(super) fn terminate(&self) {
+        if self.terminate_count.fetch_sub(1, Ordering::AcqRel) == 1 {
+            for (i, thread_info) in self.thread_infos.iter().enumerate() {
+                unsafe { OnceLatch::set_and_tickle_one(&thread_info.terminate, self, i) };
+            }
+        }
+    }
+
+    /// Notify the worker that the latch they are sleeping on has been "set".
+    pub(super) fn notify_worker_latch_is_set(&self, target_worker_index: usize) {
+        self.sleep.notify_worker_latch_is_set(target_worker_index);
+    }
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub(super) struct RegistryId {
+    addr: usize,
+}
+
+struct ThreadInfo {
+    /// Latch set once thread has started and we are entering into the
+    /// main loop. Used to wait for worker threads to become primed,
+    /// primarily of interest for benchmarking.
+    primed: LockLatch,
+
+    /// Latch is set once worker thread has completed. Used to wait
+    /// until workers have stopped; only used for tests.
+    stopped: LockLatch,
+
+    /// The latch used to signal that terminated has been requested.
+    /// This latch is *set* by the `terminate` method on the
+    /// `Registry`, once the registry's main "terminate" counter
+    /// reaches zero.
+    terminate: OnceLatch,
+
+    /// the "stealer" half of the worker's deque
+    stealer: Stealer<JobRef>,
+}
+
+impl ThreadInfo {
+    fn new(stealer: Stealer<JobRef>) -> ThreadInfo {
+        ThreadInfo {
+            primed: LockLatch::new(),
+            stopped: LockLatch::new(),
+            terminate: OnceLatch::new(),
+            stealer,
+        }
+    }
+}
+
+/// ////////////////////////////////////////////////////////////////////////
+/// WorkerThread identifiers
+
+pub(super) struct WorkerThread {
+    /// the "worker" half of our local deque
+    worker: Worker<JobRef>,
+
+    /// the "stealer" half of the worker's broadcast deque
+    stealer: Stealer<JobRef>,
+
+    /// local queue used for `spawn_fifo` indirection
+    fifo: JobFifo,
+
+    index: usize,
+
+    /// A weak random number generator.
+    rng: XorShift64Star,
+
+    registry: Arc<Registry>,
+}
+
+// This is a bit sketchy, but basically: the WorkerThread is
+// allocated on the stack of the worker on entry and stored into this
+// thread local variable. So it will remain valid at least until the
+// worker is fully unwound. Using an unsafe pointer avoids the need
+// for a RefCell<T> etc.
+thread_local! {
+    static WORKER_THREAD_STATE: Cell<*const WorkerThread> = const { Cell::new(ptr::null()) };
+}
+
+impl From<ThreadBuilder> for WorkerThread {
+    fn from(thread: ThreadBuilder) -> Self {
+        Self {
+            worker: thread.worker,
+            stealer: thread.stealer,
+            fifo: JobFifo::new(),
+            index: thread.index,
+            rng: XorShift64Star::new(),
+            registry: thread.registry,
+        }
+    }
+}
+
+impl Drop for WorkerThread {
+    fn drop(&mut self) {
+        // Undo `set_current`
+        WORKER_THREAD_STATE.with(|t| {
+            assert!(t.get().eq(&(self as *const _)));
+            t.set(ptr::null());
+        });
+    }
+}
+
+impl WorkerThread {
+    /// Gets the `WorkerThread` index for the current thread; returns
+    /// NULL if this is not a worker thread. This pointer is valid
+    /// anywhere on the current thread.
+    #[inline]
+    pub(super) fn current() -> *const WorkerThread {
+        WORKER_THREAD_STATE.with(Cell::get)
+    }
+
+    /// Sets `self` as the worker thread index for the current thread.
+    /// This is done during worker thread startup.
+    unsafe fn set_current(thread: *const WorkerThread) {
+        WORKER_THREAD_STATE.with(|t| {
+            assert!(t.get().is_null());
+            t.set(thread);
+        });
+    }
+
+    /// Returns the registry that owns this worker thread.
+    #[inline]
+    pub(super) fn registry(&self) -> &Arc<Registry> {
+        &self.registry
+    }
+
+    /// Our index amongst the worker threads (ranges from `0..self.num_threads()`).
+    #[inline]
+    pub(super) fn index(&self) -> usize {
+        self.index
+    }
+
+    #[inline]
+    pub(super) unsafe fn push(&self, job: JobRef) {
+        let queue_was_empty = self.worker.is_empty();
+        self.worker.push(job);
+        self.registry.sleep.new_internal_jobs(1, queue_was_empty);
+    }
+
+    #[inline]
+    pub(super) unsafe fn push_fifo(&self, job: JobRef) {
+        self.push(self.fifo.push(job));
+    }
+
+    #[inline]
+    pub(super) fn local_deque_is_empty(&self) -> bool {
+        self.worker.is_empty()
+    }
+
+    /// Attempts to obtain a "local" job -- typically this means
+    /// popping from the top of the stack, though if we are configured
+    /// for breadth-first execution, it would mean dequeuing from the
+    /// bottom.
+    #[inline]
+    pub(super) fn take_local_job(&self) -> Option<JobRef> {
+        let popped_job = self.worker.pop();
+
+        if popped_job.is_some() {
+            return popped_job;
+        }
+
+        loop {
+            match self.stealer.steal() {
+                Steal::Success(job) => return Some(job),
+                Steal::Empty => return None,
+                Steal::Retry => {}
+            }
+        }
+    }
+
+    fn has_injected_job(&self) -> bool {
+        !self.stealer.is_empty() || self.registry.has_injected_job()
+    }
+
+    /// Wait until the latch is set. Try to keep busy by popping and
+    /// stealing tasks as necessary.
+    #[inline]
+    pub(super) unsafe fn wait_until<L: AsCoreLatch + ?Sized>(&self, latch: &L) {
+        let latch = latch.as_core_latch();
+        if !latch.probe() {
+            self.wait_until_cold(latch);
+        }
+    }
+
+    #[cold]
+    unsafe fn wait_until_cold(&self, latch: &CoreLatch) {
+        // the code below should swallow all panics and hence never
+        // unwind; but if something does wrong, we want to abort,
+        // because otherwise other code in rayon may assume that the
+        // latch has been signaled, and that can lead to random memory
+        // accesses, which would be *very bad*
+        let abort_guard = unwind::AbortIfPanic;
+
+        'outer: while !latch.probe() {
+            // Check for local work *before* we start marking ourself idle,
+            // especially to avoid modifying shared sleep state.
+            if let Some(job) = self.take_local_job() {
+                self.execute(job);
+                continue;
+            }
+
+            let mut idle_state = self.registry.sleep.start_looking(self.index);
+            while !latch.probe() {
+                if let Some(job) = self.find_work() {
+                    self.registry.sleep.work_found();
+                    self.execute(job);
+                    // The job might have injected local work, so go back to the outer loop.
+                    continue 'outer;
+                } else {
+                    self.registry
+                        .sleep
+                        .no_work_found(&mut idle_state, latch, || self.has_injected_job())
+                }
+            }
+
+            // If we were sleepy, we are not anymore. We "found work" --
+            // whatever the surrounding thread was doing before it had to wait.
+            self.registry.sleep.work_found();
+            break;
+        }
+
+        mem::forget(abort_guard); // successful execution, do not abort
+    }
+
+    unsafe fn wait_until_out_of_work(&self) {
+        debug_assert_eq!(self as *const _, WorkerThread::current());
+        let registry = &*self.registry;
+        let index = self.index;
+
+        self.wait_until(&registry.thread_infos[index].terminate);
+
+        // Should not be any work left in our queue.
+        debug_assert!(self.take_local_job().is_none());
+
+        // Let registry know we are done
+        Latch::set(&registry.thread_infos[index].stopped);
+    }
+
+    fn find_work(&self) -> Option<JobRef> {
+        // Try to find some work to do. We give preference first
+        // to things in our local deque, then in other workers
+        // deques, and finally to injected jobs from the
+        // outside. The idea is to finish what we started before
+        // we take on something new.
+        self.take_local_job()
+            .or_else(|| self.steal())
+            .or_else(|| self.registry.pop_injected_job())
+    }
+
+    pub(super) fn yield_now(&self) -> Yield {
+        match self.find_work() {
+            Some(job) => unsafe {
+                self.execute(job);
+                Yield::Executed
+            },
+            None => Yield::Idle,
+        }
+    }
+
+    pub(super) fn yield_local(&self) -> Yield {
+        match self.take_local_job() {
+            Some(job) => unsafe {
+                self.execute(job);
+                Yield::Executed
+            },
+            None => Yield::Idle,
+        }
+    }
+
+    #[inline]
+    pub(super) unsafe fn execute(&self, job: JobRef) {
+        job.execute();
+    }
+
+    /// Try to steal a single job and return it.
+    ///
+    /// This should only be done as a last resort, when there is no
+    /// local work to do.
+    fn steal(&self) -> Option<JobRef> {
+        // we only steal when we don't have any work to do locally
+        debug_assert!(self.local_deque_is_empty());
+
+        // otherwise, try to steal
+        let thread_infos = &self.registry.thread_infos.as_slice();
+        let num_threads = thread_infos.len();
+        if num_threads <= 1 {
+            return None;
+        }
+
+        loop {
+            let mut retry = false;
+            let start = self.rng.next_usize(num_threads);
+            let job = (start..num_threads)
+                .chain(0..start)
+                .filter(move |&i| i != self.index)
+                .find_map(|victim_index| {
+                    let victim = &thread_infos[victim_index];
+                    match victim.stealer.steal() {
+                        Steal::Success(job) => Some(job),
+                        Steal::Empty => None,
+                        Steal::Retry => {
+                            retry = true;
+                            None
+                        }
+                    }
+                });
+            if job.is_some() || !retry {
+                return job;
+            }
+        }
+    }
+}
+
+/// ////////////////////////////////////////////////////////////////////////
+
+unsafe fn main_loop(thread: ThreadBuilder) {
+    let worker_thread = &WorkerThread::from(thread);
+    WorkerThread::set_current(worker_thread);
+    let registry = &*worker_thread.registry;
+    let index = worker_thread.index;
+
+    // let registry know we are ready to do work
+    Latch::set(&registry.thread_infos[index].primed);
+
+    // Worker threads should not panic. If they do, just abort, as the
+    // internal state of the threadpool is corrupted. Note that if
+    // **user code** panics, we should catch that and redirect.
+    let abort_guard = unwind::AbortIfPanic;
+
+    // Inform a user callback that we started a thread.
+    if let Some(ref handler) = registry.start_handler {
+        registry.catch_unwind(|| handler(index));
+    }
+
+    worker_thread.wait_until_out_of_work();
+
+    // Normal termination, do not abort.
+    mem::forget(abort_guard);
+
+    // Inform a user callback that we exited a thread.
+    if let Some(ref handler) = registry.exit_handler {
+        registry.catch_unwind(|| handler(index));
+        // We're already exiting the thread, there's nothing else to do.
+    }
+}
+
+/// If already in a worker-thread, just execute `op`.  Otherwise,
+/// execute `op` in the default thread-pool. Either way, block until
+/// `op` completes and return its return value. If `op` panics, that
+/// panic will be propagated as well.  The second argument indicates
+/// `true` if injection was performed, `false` if executed directly.
+pub(super) fn in_worker<OP, R>(op: OP) -> R
+where
+    OP: FnOnce(&WorkerThread, bool) -> R + Send,
+    R: Send,
+{
+    unsafe {
+        let owner_thread = WorkerThread::current();
+        if !owner_thread.is_null() {
+            // Perfectly valid to give them a `&T`: this is the
+            // current thread, so we know the data structure won't be
+            // invalidated until we return.
+            op(&*owner_thread, false)
+        } else {
+            global_registry().in_worker(op)
+        }
+    }
+}
+
+/// [xorshift*] is a fast pseudorandom number generator which will
+/// even tolerate weak seeding, as long as it's not zero.
+///
+/// [xorshift*]: https://en.wikipedia.org/wiki/Xorshift#xorshift*
+struct XorShift64Star {
+    state: Cell<u64>,
+}
+
+impl XorShift64Star {
+    fn new() -> Self {
+        // Any non-zero seed will do -- this uses the hash of a global counter.
+        let mut seed = 0;
+        while seed == 0 {
+            let mut hasher = DefaultHasher::new();
+            static COUNTER: AtomicUsize = AtomicUsize::new(0);
+            hasher.write_usize(COUNTER.fetch_add(1, Ordering::Relaxed));
+            seed = hasher.finish();
+        }
+
+        XorShift64Star {
+            state: Cell::new(seed),
+        }
+    }
+
+    fn next(&self) -> u64 {
+        let mut x = self.state.get();
+        debug_assert_ne!(x, 0);
+        x ^= x >> 12;
+        x ^= x << 25;
+        x ^= x >> 27;
+        self.state.set(x);
+        x.wrapping_mul(0x2545_f491_4f6c_dd1d)
+    }
+
+    /// Return a value from `0..n`.
+    fn next_usize(&self, n: usize) -> usize {
+        (self.next() % n as u64) as usize
+    }
+}
diff --git a/crates/rayon-core/src/scope/mod.rs b/crates/rayon-core/src/scope/mod.rs
new file mode 100644
index 0000000..b7163d1
--- /dev/null
+++ b/crates/rayon-core/src/scope/mod.rs
@@ -0,0 +1,769 @@
+//! Methods for custom fork-join scopes, created by the [`scope()`]
+//! and [`in_place_scope()`] functions. These are a more flexible alternative to [`join()`].
+//!
+//! [`scope()`]: fn.scope.html
+//! [`in_place_scope()`]: fn.in_place_scope.html
+//! [`join()`]: ../join/join.fn.html
+
+use crate::broadcast::BroadcastContext;
+use crate::job::{ArcJob, HeapJob, JobFifo, JobRef};
+use crate::latch::{CountLatch, Latch};
+use crate::registry::{global_registry, in_worker, Registry, WorkerThread};
+use crate::unwind;
+use std::any::Any;
+use std::fmt;
+use std::marker::PhantomData;
+use std::mem::ManuallyDrop;
+use std::ptr;
+use std::sync::atomic::{AtomicPtr, Ordering};
+use std::sync::Arc;
+
+#[cfg(test)]
+mod test;
+
+/// Represents a fork-join scope which can be used to spawn any number of tasks.
+/// See [`scope()`] for more information.
+///
+///[`scope()`]: fn.scope.html
+pub struct Scope<'scope> {
+    base: ScopeBase<'scope>,
+}
+
+/// Represents a fork-join scope which can be used to spawn any number of tasks.
+/// Those spawned from the same thread are prioritized in relative FIFO order.
+/// See [`scope_fifo()`] for more information.
+///
+///[`scope_fifo()`]: fn.scope_fifo.html
+pub struct ScopeFifo<'scope> {
+    base: ScopeBase<'scope>,
+    fifos: Vec<JobFifo>,
+}
+
+struct ScopeBase<'scope> {
+    /// thread registry where `scope()` was executed or where `in_place_scope()`
+    /// should spawn jobs.
+    registry: Arc<Registry>,
+
+    /// if some job panicked, the error is stored here; it will be
+    /// propagated to the one who created the scope
+    panic: AtomicPtr<Box<dyn Any + Send + 'static>>,
+
+    /// latch to track job counts
+    job_completed_latch: CountLatch,
+
+    /// You can think of a scope as containing a list of closures to execute,
+    /// all of which outlive `'scope`.  They're not actually required to be
+    /// `Sync`, but it's still safe to let the `Scope` implement `Sync` because
+    /// the closures are only *moved* across threads to be executed.
+    marker: PhantomData<Box<dyn FnOnce(&Scope<'scope>) + Send + Sync + 'scope>>,
+}
+
+/// Creates a "fork-join" scope `s` and invokes the closure with a
+/// reference to `s`. This closure can then spawn asynchronous tasks
+/// into `s`. Those tasks may run asynchronously with respect to the
+/// closure; they may themselves spawn additional tasks into `s`. When
+/// the closure returns, it will block until all tasks that have been
+/// spawned into `s` complete.
+///
+/// `scope()` is a more flexible building block compared to `join()`,
+/// since a loop can be used to spawn any number of tasks without
+/// recursing. However, that flexibility comes at a performance price:
+/// tasks spawned using `scope()` must be allocated onto the heap,
+/// whereas `join()` can make exclusive use of the stack. **Prefer
+/// `join()` (or, even better, parallel iterators) where possible.**
+///
+/// # Example
+///
+/// The Rayon `join()` function launches two closures and waits for them
+/// to stop. One could implement `join()` using a scope like so, although
+/// it would be less efficient than the real implementation:
+///
+/// ```rust
+/// # use rayon_core as rayon;
+/// pub fn join<A,B,RA,RB>(oper_a: A, oper_b: B) -> (RA, RB)
+///     where A: FnOnce() -> RA + Send,
+///           B: FnOnce() -> RB + Send,
+///           RA: Send,
+///           RB: Send,
+/// {
+///     let mut result_a: Option<RA> = None;
+///     let mut result_b: Option<RB> = None;
+///     rayon::scope(|s| {
+///         s.spawn(|_| result_a = Some(oper_a()));
+///         s.spawn(|_| result_b = Some(oper_b()));
+///     });
+///     (result_a.unwrap(), result_b.unwrap())
+/// }
+/// ```
+///
+/// # A note on threading
+///
+/// The closure given to `scope()` executes in the Rayon thread-pool,
+/// as do those given to `spawn()`. This means that you can't access
+/// thread-local variables (well, you can, but they may have
+/// unexpected values).
+///
+/// # Task execution
+///
+/// Task execution potentially starts as soon as `spawn()` is called.
+/// The task will end sometime before `scope()` returns. Note that the
+/// *closure* given to scope may return much earlier. In general
+/// the lifetime of a scope created like `scope(body)` goes something like this:
+///
+/// - Scope begins when `scope(body)` is called
+/// - Scope body `body()` is invoked
+///     - Scope tasks may be spawned
+/// - Scope body returns
+/// - Scope tasks execute, possibly spawning more tasks
+/// - Once all tasks are done, scope ends and `scope()` returns
+///
+/// To see how and when tasks are joined, consider this example:
+///
+/// ```rust
+/// # use rayon_core as rayon;
+/// // point start
+/// rayon::scope(|s| {
+///     s.spawn(|s| { // task s.1
+///         s.spawn(|s| { // task s.1.1
+///             rayon::scope(|t| {
+///                 t.spawn(|_| ()); // task t.1
+///                 t.spawn(|_| ()); // task t.2
+///             });
+///         });
+///     });
+///     s.spawn(|s| { // task s.2
+///     });
+///     // point mid
+/// });
+/// // point end
+/// ```
+///
+/// The various tasks that are run will execute roughly like so:
+///
+/// ```notrust
+/// | (start)
+/// |
+/// | (scope `s` created)
+/// +-----------------------------------------------+ (task s.2)
+/// +-------+ (task s.1)                            |
+/// |       |                                       |
+/// |       +---+ (task s.1.1)                      |
+/// |       |   |                                   |
+/// |       |   | (scope `t` created)               |
+/// |       |   +----------------+ (task t.2)       |
+/// |       |   +---+ (task t.1) |                  |
+/// | (mid) |   |   |            |                  |
+/// :       |   + <-+------------+ (scope `t` ends) |
+/// :       |   |                                   |
+/// |<------+---+-----------------------------------+ (scope `s` ends)
+/// |
+/// | (end)
+/// ```
+///
+/// The point here is that everything spawned into scope `s` will
+/// terminate (at latest) at the same point -- right before the
+/// original call to `rayon::scope` returns. This includes new
+/// subtasks created by other subtasks (e.g., task `s.1.1`). If a new
+/// scope is created (such as `t`), the things spawned into that scope
+/// will be joined before that scope returns, which in turn occurs
+/// before the creating task (task `s.1.1` in this case) finishes.
+///
+/// There is no guaranteed order of execution for spawns in a scope,
+/// given that other threads may steal tasks at any time. However, they
+/// are generally prioritized in a LIFO order on the thread from which
+/// they were spawned. So in this example, absent any stealing, we can
+/// expect `s.2` to execute before `s.1`, and `t.2` before `t.1`. Other
+/// threads always steal from the other end of the deque, like FIFO
+/// order.  The idea is that "recent" tasks are most likely to be fresh
+/// in the local CPU's cache, while other threads can steal older
+/// "stale" tasks.  For an alternate approach, consider
+/// [`scope_fifo()`] instead.
+///
+/// [`scope_fifo()`]: fn.scope_fifo.html
+///
+/// # Accessing stack data
+///
+/// In general, spawned tasks may access stack data in place that
+/// outlives the scope itself. Other data must be fully owned by the
+/// spawned task.
+///
+/// ```rust
+/// # use rayon_core as rayon;
+/// let ok: Vec<i32> = vec![1, 2, 3];
+/// rayon::scope(|s| {
+///     let bad: Vec<i32> = vec![4, 5, 6];
+///     s.spawn(|_| {
+///         // We can access `ok` because outlives the scope `s`.
+///         println!("ok: {:?}", ok);
+///
+///         // If we just try to use `bad` here, the closure will borrow `bad`
+///         // (because we are just printing it out, and that only requires a
+///         // borrow), which will result in a compilation error. Read on
+///         // for options.
+///         // println!("bad: {:?}", bad);
+///    });
+/// });
+/// ```
+///
+/// As the comments example above suggest, to reference `bad` we must
+/// take ownership of it. One way to do this is to detach the closure
+/// from the surrounding stack frame, using the `move` keyword. This
+/// will cause it to take ownership of *all* the variables it touches,
+/// in this case including both `ok` *and* `bad`:
+///
+/// ```rust
+/// # use rayon_core as rayon;
+/// let ok: Vec<i32> = vec![1, 2, 3];
+/// rayon::scope(|s| {
+///     let bad: Vec<i32> = vec![4, 5, 6];
+///     s.spawn(move |_| {
+///         println!("ok: {:?}", ok);
+///         println!("bad: {:?}", bad);
+///     });
+///
+///     // That closure is fine, but now we can't use `ok` anywhere else,
+///     // since it is owned by the previous task:
+///     // s.spawn(|_| println!("ok: {:?}", ok));
+/// });
+/// ```
+///
+/// While this works, it could be a problem if we want to use `ok` elsewhere.
+/// There are two choices. We can keep the closure as a `move` closure, but
+/// instead of referencing the variable `ok`, we create a shadowed variable that
+/// is a borrow of `ok` and capture *that*:
+///
+/// ```rust
+/// # use rayon_core as rayon;
+/// let ok: Vec<i32> = vec![1, 2, 3];
+/// rayon::scope(|s| {
+///     let bad: Vec<i32> = vec![4, 5, 6];
+///     let ok: &Vec<i32> = &ok; // shadow the original `ok`
+///     s.spawn(move |_| {
+///         println!("ok: {:?}", ok); // captures the shadowed version
+///         println!("bad: {:?}", bad);
+///     });
+///
+///     // Now we too can use the shadowed `ok`, since `&Vec<i32>` references
+///     // can be shared freely. Note that we need a `move` closure here though,
+///     // because otherwise we'd be trying to borrow the shadowed `ok`,
+///     // and that doesn't outlive `scope`.
+///     s.spawn(move |_| println!("ok: {:?}", ok));
+/// });
+/// ```
+///
+/// Another option is not to use the `move` keyword but instead to take ownership
+/// of individual variables:
+///
+/// ```rust
+/// # use rayon_core as rayon;
+/// let ok: Vec<i32> = vec![1, 2, 3];
+/// rayon::scope(|s| {
+///     let bad: Vec<i32> = vec![4, 5, 6];
+///     s.spawn(|_| {
+///         // Transfer ownership of `bad` into a local variable (also named `bad`).
+///         // This will force the closure to take ownership of `bad` from the environment.
+///         let bad = bad;
+///         println!("ok: {:?}", ok); // `ok` is only borrowed.
+///         println!("bad: {:?}", bad); // refers to our local variable, above.
+///     });
+///
+///     s.spawn(|_| println!("ok: {:?}", ok)); // we too can borrow `ok`
+/// });
+/// ```
+///
+/// # Panics
+///
+/// If a panic occurs, either in the closure given to `scope()` or in
+/// any of the spawned jobs, that panic will be propagated and the
+/// call to `scope()` will panic. If multiple panics occurs, it is
+/// non-deterministic which of their panic values will propagate.
+/// Regardless, once a task is spawned using `scope.spawn()`, it will
+/// execute, even if the spawning task should later panic. `scope()`
+/// returns once all spawned jobs have completed, and any panics are
+/// propagated at that point.
+pub fn scope<'scope, OP, R>(op: OP) -> R
+where
+    OP: FnOnce(&Scope<'scope>) -> R + Send,
+    R: Send,
+{
+    in_worker(|owner_thread, _| {
+        let scope = Scope::<'scope>::new(Some(owner_thread), None);
+        scope.base.complete(Some(owner_thread), || op(&scope))
+    })
+}
+
+/// Creates a "fork-join" scope `s` with FIFO order, and invokes the
+/// closure with a reference to `s`. This closure can then spawn
+/// asynchronous tasks into `s`. Those tasks may run asynchronously with
+/// respect to the closure; they may themselves spawn additional tasks
+/// into `s`. When the closure returns, it will block until all tasks
+/// that have been spawned into `s` complete.
+///
+/// # Task execution
+///
+/// Tasks in a `scope_fifo()` run similarly to [`scope()`], but there's a
+/// difference in the order of execution. Consider a similar example:
+///
+/// [`scope()`]: fn.scope.html
+///
+/// ```rust
+/// # use rayon_core as rayon;
+/// // point start
+/// rayon::scope_fifo(|s| {
+///     s.spawn_fifo(|s| { // task s.1
+///         s.spawn_fifo(|s| { // task s.1.1
+///             rayon::scope_fifo(|t| {
+///                 t.spawn_fifo(|_| ()); // task t.1
+///                 t.spawn_fifo(|_| ()); // task t.2
+///             });
+///         });
+///     });
+///     s.spawn_fifo(|s| { // task s.2
+///     });
+///     // point mid
+/// });
+/// // point end
+/// ```
+///
+/// The various tasks that are run will execute roughly like so:
+///
+/// ```notrust
+/// | (start)
+/// |
+/// | (FIFO scope `s` created)
+/// +--------------------+ (task s.1)
+/// +-------+ (task s.2) |
+/// |       |            +---+ (task s.1.1)
+/// |       |            |   |
+/// |       |            |   | (FIFO scope `t` created)
+/// |       |            |   +----------------+ (task t.1)
+/// |       |            |   +---+ (task t.2) |
+/// | (mid) |            |   |   |            |
+/// :       |            |   + <-+------------+ (scope `t` ends)
+/// :       |            |   |
+/// |<------+------------+---+ (scope `s` ends)
+/// |
+/// | (end)
+/// ```
+///
+/// Under `scope_fifo()`, the spawns are prioritized in a FIFO order on
+/// the thread from which they were spawned, as opposed to `scope()`'s
+/// LIFO.  So in this example, we can expect `s.1` to execute before
+/// `s.2`, and `t.1` before `t.2`. Other threads also steal tasks in
+/// FIFO order, as usual. Overall, this has roughly the same order as
+/// the now-deprecated [`breadth_first`] option, except the effect is
+/// isolated to a particular scope. If spawns are intermingled from any
+/// combination of `scope()` and `scope_fifo()`, or from different
+/// threads, their order is only specified with respect to spawns in the
+/// same scope and thread.
+///
+/// For more details on this design, see Rayon [RFC #1].
+///
+/// [`breadth_first`]: struct.ThreadPoolBuilder.html#method.breadth_first
+/// [RFC #1]: https://github.com/rayon-rs/rfcs/blob/master/accepted/rfc0001-scope-scheduling.md
+///
+/// # Panics
+///
+/// If a panic occurs, either in the closure given to `scope_fifo()` or
+/// in any of the spawned jobs, that panic will be propagated and the
+/// call to `scope_fifo()` will panic. If multiple panics occurs, it is
+/// non-deterministic which of their panic values will propagate.
+/// Regardless, once a task is spawned using `scope.spawn_fifo()`, it
+/// will execute, even if the spawning task should later panic.
+/// `scope_fifo()` returns once all spawned jobs have completed, and any
+/// panics are propagated at that point.
+pub fn scope_fifo<'scope, OP, R>(op: OP) -> R
+where
+    OP: FnOnce(&ScopeFifo<'scope>) -> R + Send,
+    R: Send,
+{
+    in_worker(|owner_thread, _| {
+        let scope = ScopeFifo::<'scope>::new(Some(owner_thread), None);
+        scope.base.complete(Some(owner_thread), || op(&scope))
+    })
+}
+
+/// Creates a "fork-join" scope `s` and invokes the closure with a
+/// reference to `s`. This closure can then spawn asynchronous tasks
+/// into `s`. Those tasks may run asynchronously with respect to the
+/// closure; they may themselves spawn additional tasks into `s`. When
+/// the closure returns, it will block until all tasks that have been
+/// spawned into `s` complete.
+///
+/// This is just like `scope()` except the closure runs on the same thread
+/// that calls `in_place_scope()`. Only work that it spawns runs in the
+/// thread pool.
+///
+/// # Panics
+///
+/// If a panic occurs, either in the closure given to `in_place_scope()` or in
+/// any of the spawned jobs, that panic will be propagated and the
+/// call to `in_place_scope()` will panic. If multiple panics occurs, it is
+/// non-deterministic which of their panic values will propagate.
+/// Regardless, once a task is spawned using `scope.spawn()`, it will
+/// execute, even if the spawning task should later panic. `in_place_scope()`
+/// returns once all spawned jobs have completed, and any panics are
+/// propagated at that point.
+pub fn in_place_scope<'scope, OP, R>(op: OP) -> R
+where
+    OP: FnOnce(&Scope<'scope>) -> R,
+{
+    do_in_place_scope(None, op)
+}
+
+pub(crate) fn do_in_place_scope<'scope, OP, R>(registry: Option<&Arc<Registry>>, op: OP) -> R
+where
+    OP: FnOnce(&Scope<'scope>) -> R,
+{
+    let thread = unsafe { WorkerThread::current().as_ref() };
+    let scope = Scope::<'scope>::new(thread, registry);
+    scope.base.complete(thread, || op(&scope))
+}
+
+/// Creates a "fork-join" scope `s` with FIFO order, and invokes the
+/// closure with a reference to `s`. This closure can then spawn
+/// asynchronous tasks into `s`. Those tasks may run asynchronously with
+/// respect to the closure; they may themselves spawn additional tasks
+/// into `s`. When the closure returns, it will block until all tasks
+/// that have been spawned into `s` complete.
+///
+/// This is just like `scope_fifo()` except the closure runs on the same thread
+/// that calls `in_place_scope_fifo()`. Only work that it spawns runs in the
+/// thread pool.
+///
+/// # Panics
+///
+/// If a panic occurs, either in the closure given to `in_place_scope_fifo()` or in
+/// any of the spawned jobs, that panic will be propagated and the
+/// call to `in_place_scope_fifo()` will panic. If multiple panics occurs, it is
+/// non-deterministic which of their panic values will propagate.
+/// Regardless, once a task is spawned using `scope.spawn_fifo()`, it will
+/// execute, even if the spawning task should later panic. `in_place_scope_fifo()`
+/// returns once all spawned jobs have completed, and any panics are
+/// propagated at that point.
+pub fn in_place_scope_fifo<'scope, OP, R>(op: OP) -> R
+where
+    OP: FnOnce(&ScopeFifo<'scope>) -> R,
+{
+    do_in_place_scope_fifo(None, op)
+}
+
+pub(crate) fn do_in_place_scope_fifo<'scope, OP, R>(registry: Option<&Arc<Registry>>, op: OP) -> R
+where
+    OP: FnOnce(&ScopeFifo<'scope>) -> R,
+{
+    let thread = unsafe { WorkerThread::current().as_ref() };
+    let scope = ScopeFifo::<'scope>::new(thread, registry);
+    scope.base.complete(thread, || op(&scope))
+}
+
+impl<'scope> Scope<'scope> {
+    fn new(owner: Option<&WorkerThread>, registry: Option<&Arc<Registry>>) -> Self {
+        let base = ScopeBase::new(owner, registry);
+        Scope { base }
+    }
+
+    /// Spawns a job into the fork-join scope `self`. This job will
+    /// execute sometime before the fork-join scope completes.  The
+    /// job is specified as a closure, and this closure receives its
+    /// own reference to the scope `self` as argument. This can be
+    /// used to inject new jobs into `self`.
+    ///
+    /// # Returns
+    ///
+    /// Nothing. The spawned closures cannot pass back values to the
+    /// caller directly, though they can write to local variables on
+    /// the stack (if those variables outlive the scope) or
+    /// communicate through shared channels.
+    ///
+    /// (The intention is to eventually integrate with Rust futures to
+    /// support spawns of functions that compute a value.)
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # use rayon_core as rayon;
+    /// let mut value_a = None;
+    /// let mut value_b = None;
+    /// let mut value_c = None;
+    /// rayon::scope(|s| {
+    ///     s.spawn(|s1| {
+    ///           // ^ this is the same scope as `s`; this handle `s1`
+    ///           //   is intended for use by the spawned task,
+    ///           //   since scope handles cannot cross thread boundaries.
+    ///
+    ///         value_a = Some(22);
+    ///
+    ///         // the scope `s` will not end until all these tasks are done
+    ///         s1.spawn(|_| {
+    ///             value_b = Some(44);
+    ///         });
+    ///     });
+    ///
+    ///     s.spawn(|_| {
+    ///         value_c = Some(66);
+    ///     });
+    /// });
+    /// assert_eq!(value_a, Some(22));
+    /// assert_eq!(value_b, Some(44));
+    /// assert_eq!(value_c, Some(66));
+    /// ```
+    ///
+    /// # See also
+    ///
+    /// The [`scope` function] has more extensive documentation about
+    /// task spawning.
+    ///
+    /// [`scope` function]: fn.scope.html
+    pub fn spawn<BODY>(&self, body: BODY)
+    where
+        BODY: FnOnce(&Scope<'scope>) + Send + 'scope,
+    {
+        let scope_ptr = ScopePtr(self);
+        let job = HeapJob::new(move || unsafe {
+            // SAFETY: this job will execute before the scope ends.
+            let scope = scope_ptr.as_ref();
+            ScopeBase::execute_job(&scope.base, move || body(scope))
+        });
+        let job_ref = self.base.heap_job_ref(job);
+
+        // Since `Scope` implements `Sync`, we can't be sure that we're still in a
+        // thread of this pool, so we can't just push to the local worker thread.
+        // Also, this might be an in-place scope.
+        self.base.registry.inject_or_push(job_ref);
+    }
+
+    /// Spawns a job into every thread of the fork-join scope `self`. This job will
+    /// execute on each thread sometime before the fork-join scope completes.  The
+    /// job is specified as a closure, and this closure receives its own reference
+    /// to the scope `self` as argument, as well as a `BroadcastContext`.
+    pub fn spawn_broadcast<BODY>(&self, body: BODY)
+    where
+        BODY: Fn(&Scope<'scope>, BroadcastContext<'_>) + Send + Sync + 'scope,
+    {
+        let scope_ptr = ScopePtr(self);
+        let job = ArcJob::new(move || unsafe {
+            // SAFETY: this job will execute before the scope ends.
+            let scope = scope_ptr.as_ref();
+            let body = &body;
+            let func = move || BroadcastContext::with(move |ctx| body(scope, ctx));
+            ScopeBase::execute_job(&scope.base, func)
+        });
+        self.base.inject_broadcast(job)
+    }
+}
+
+impl<'scope> ScopeFifo<'scope> {
+    fn new(owner: Option<&WorkerThread>, registry: Option<&Arc<Registry>>) -> Self {
+        let base = ScopeBase::new(owner, registry);
+        let num_threads = base.registry.num_threads();
+        let fifos = (0..num_threads).map(|_| JobFifo::new()).collect();
+        ScopeFifo { base, fifos }
+    }
+
+    /// Spawns a job into the fork-join scope `self`. This job will
+    /// execute sometime before the fork-join scope completes.  The
+    /// job is specified as a closure, and this closure receives its
+    /// own reference to the scope `self` as argument. This can be
+    /// used to inject new jobs into `self`.
+    ///
+    /// # See also
+    ///
+    /// This method is akin to [`Scope::spawn()`], but with a FIFO
+    /// priority.  The [`scope_fifo` function] has more details about
+    /// this distinction.
+    ///
+    /// [`Scope::spawn()`]: struct.Scope.html#method.spawn
+    /// [`scope_fifo` function]: fn.scope_fifo.html
+    pub fn spawn_fifo<BODY>(&self, body: BODY)
+    where
+        BODY: FnOnce(&ScopeFifo<'scope>) + Send + 'scope,
+    {
+        let scope_ptr = ScopePtr(self);
+        let job = HeapJob::new(move || unsafe {
+            // SAFETY: this job will execute before the scope ends.
+            let scope = scope_ptr.as_ref();
+            ScopeBase::execute_job(&scope.base, move || body(scope))
+        });
+        let job_ref = self.base.heap_job_ref(job);
+
+        // If we're in the pool, use our scope's private fifo for this thread to execute
+        // in a locally-FIFO order. Otherwise, just use the pool's global injector.
+        match self.base.registry.current_thread() {
+            Some(worker) => {
+                let fifo = &self.fifos[worker.index()];
+                // SAFETY: this job will execute before the scope ends.
+                unsafe { worker.push(fifo.push(job_ref)) };
+            }
+            None => self.base.registry.inject(job_ref),
+        }
+    }
+
+    /// Spawns a job into every thread of the fork-join scope `self`. This job will
+    /// execute on each thread sometime before the fork-join scope completes.  The
+    /// job is specified as a closure, and this closure receives its own reference
+    /// to the scope `self` as argument, as well as a `BroadcastContext`.
+    pub fn spawn_broadcast<BODY>(&self, body: BODY)
+    where
+        BODY: Fn(&ScopeFifo<'scope>, BroadcastContext<'_>) + Send + Sync + 'scope,
+    {
+        let scope_ptr = ScopePtr(self);
+        let job = ArcJob::new(move || unsafe {
+            // SAFETY: this job will execute before the scope ends.
+            let scope = scope_ptr.as_ref();
+            let body = &body;
+            let func = move || BroadcastContext::with(move |ctx| body(scope, ctx));
+            ScopeBase::execute_job(&scope.base, func)
+        });
+        self.base.inject_broadcast(job)
+    }
+}
+
+impl<'scope> ScopeBase<'scope> {
+    /// Creates the base of a new scope for the given registry
+    fn new(owner: Option<&WorkerThread>, registry: Option<&Arc<Registry>>) -> Self {
+        let registry = registry.unwrap_or_else(|| match owner {
+            Some(owner) => owner.registry(),
+            None => global_registry(),
+        });
+
+        ScopeBase {
+            registry: Arc::clone(registry),
+            panic: AtomicPtr::new(ptr::null_mut()),
+            job_completed_latch: CountLatch::new(owner),
+            marker: PhantomData,
+        }
+    }
+
+    fn heap_job_ref<FUNC>(&self, job: Box<HeapJob<FUNC>>) -> JobRef
+    where
+        FUNC: FnOnce() + Send + 'scope,
+    {
+        unsafe {
+            self.job_completed_latch.increment();
+            job.into_job_ref()
+        }
+    }
+
+    fn inject_broadcast<FUNC>(&self, job: Arc<ArcJob<FUNC>>)
+    where
+        FUNC: Fn() + Send + Sync + 'scope,
+    {
+        let n_threads = self.registry.num_threads();
+        let job_refs = (0..n_threads).map(|_| unsafe {
+            self.job_completed_latch.increment();
+            ArcJob::as_job_ref(&job)
+        });
+
+        self.registry.inject_broadcast(job_refs);
+    }
+
+    /// Executes `func` as a job, either aborting or executing as
+    /// appropriate.
+    fn complete<FUNC, R>(&self, owner: Option<&WorkerThread>, func: FUNC) -> R
+    where
+        FUNC: FnOnce() -> R,
+    {
+        let result = unsafe { Self::execute_job_closure(self, func) };
+        self.job_completed_latch.wait(owner);
+        self.maybe_propagate_panic();
+        result.unwrap() // only None if `op` panicked, and that would have been propagated
+    }
+
+    /// Executes `func` as a job, either aborting or executing as
+    /// appropriate.
+    unsafe fn execute_job<FUNC>(this: *const Self, func: FUNC)
+    where
+        FUNC: FnOnce(),
+    {
+        let _: Option<()> = Self::execute_job_closure(this, func);
+    }
+
+    /// Executes `func` as a job in scope. Adjusts the "job completed"
+    /// counters and also catches any panic and stores it into
+    /// `scope`.
+    unsafe fn execute_job_closure<FUNC, R>(this: *const Self, func: FUNC) -> Option<R>
+    where
+        FUNC: FnOnce() -> R,
+    {
+        let result = match unwind::halt_unwinding(func) {
+            Ok(r) => Some(r),
+            Err(err) => {
+                (*this).job_panicked(err);
+                None
+            }
+        };
+        Latch::set(&(*this).job_completed_latch);
+        result
+    }
+
+    fn job_panicked(&self, err: Box<dyn Any + Send + 'static>) {
+        // capture the first error we see, free the rest
+        if self.panic.load(Ordering::Relaxed).is_null() {
+            let nil = ptr::null_mut();
+            let mut err = ManuallyDrop::new(Box::new(err)); // box up the fat ptr
+            let err_ptr: *mut Box<dyn Any + Send + 'static> = &mut **err;
+            if self
+                .panic
+                .compare_exchange(nil, err_ptr, Ordering::Release, Ordering::Relaxed)
+                .is_ok()
+            {
+                // ownership now transferred into self.panic
+            } else {
+                // another panic raced in ahead of us, so drop ours
+                let _: Box<Box<_>> = ManuallyDrop::into_inner(err);
+            }
+        }
+    }
+
+    fn maybe_propagate_panic(&self) {
+        // propagate panic, if any occurred; at this point, all
+        // outstanding jobs have completed, so we can use a relaxed
+        // ordering:
+        let panic = self.panic.swap(ptr::null_mut(), Ordering::Relaxed);
+        if !panic.is_null() {
+            let value = unsafe { Box::from_raw(panic) };
+            unwind::resume_unwinding(*value);
+        }
+    }
+}
+
+impl<'scope> fmt::Debug for Scope<'scope> {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt.debug_struct("Scope")
+            .field("pool_id", &self.base.registry.id())
+            .field("panic", &self.base.panic)
+            .field("job_completed_latch", &self.base.job_completed_latch)
+            .finish()
+    }
+}
+
+impl<'scope> fmt::Debug for ScopeFifo<'scope> {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt.debug_struct("ScopeFifo")
+            .field("num_fifos", &self.fifos.len())
+            .field("pool_id", &self.base.registry.id())
+            .field("panic", &self.base.panic)
+            .field("job_completed_latch", &self.base.job_completed_latch)
+            .finish()
+    }
+}
+
+/// Used to capture a scope `&Self` pointer in jobs, without faking a lifetime.
+///
+/// Unsafe code is still required to dereference the pointer, but that's fine in
+/// scope jobs that are guaranteed to execute before the scope ends.
+struct ScopePtr<T>(*const T);
+
+// SAFETY: !Send for raw pointers is not for safety, just as a lint
+unsafe impl<T: Sync> Send for ScopePtr<T> {}
+
+// SAFETY: !Sync for raw pointers is not for safety, just as a lint
+unsafe impl<T: Sync> Sync for ScopePtr<T> {}
+
+impl<T> ScopePtr<T> {
+    // Helper to avoid disjoint captures of `scope_ptr.0`
+    unsafe fn as_ref(&self) -> &T {
+        &*self.0
+    }
+}
diff --git a/crates/rayon-core/src/scope/test.rs b/crates/rayon-core/src/scope/test.rs
new file mode 100644
index 0000000..ad8c4af
--- /dev/null
+++ b/crates/rayon-core/src/scope/test.rs
@@ -0,0 +1,619 @@
+use crate::unwind;
+use crate::ThreadPoolBuilder;
+use crate::{scope, scope_fifo, Scope, ScopeFifo};
+use rand::{Rng, SeedableRng};
+use rand_xorshift::XorShiftRng;
+use std::cmp;
+use std::iter::once;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::{Barrier, Mutex};
+use std::vec;
+
+#[test]
+fn scope_empty() {
+    scope(|_| {});
+}
+
+#[test]
+fn scope_result() {
+    let x = scope(|_| 22);
+    assert_eq!(x, 22);
+}
+
+#[test]
+fn scope_two() {
+    let counter = &AtomicUsize::new(0);
+    scope(|s| {
+        s.spawn(move |_| {
+            counter.fetch_add(1, Ordering::SeqCst);
+        });
+        s.spawn(move |_| {
+            counter.fetch_add(10, Ordering::SeqCst);
+        });
+    });
+
+    let v = counter.load(Ordering::SeqCst);
+    assert_eq!(v, 11);
+}
+
+#[test]
+fn scope_divide_and_conquer() {
+    let counter_p = &AtomicUsize::new(0);
+    scope(|s| s.spawn(move |s| divide_and_conquer(s, counter_p, 1024)));
+
+    let counter_s = &AtomicUsize::new(0);
+    divide_and_conquer_seq(counter_s, 1024);
+
+    let p = counter_p.load(Ordering::SeqCst);
+    let s = counter_s.load(Ordering::SeqCst);
+    assert_eq!(p, s);
+}
+
+fn divide_and_conquer<'scope>(scope: &Scope<'scope>, counter: &'scope AtomicUsize, size: usize) {
+    if size > 1 {
+        scope.spawn(move |scope| divide_and_conquer(scope, counter, size / 2));
+        scope.spawn(move |scope| divide_and_conquer(scope, counter, size / 2));
+    } else {
+        // count the leaves
+        counter.fetch_add(1, Ordering::SeqCst);
+    }
+}
+
+fn divide_and_conquer_seq(counter: &AtomicUsize, size: usize) {
+    if size > 1 {
+        divide_and_conquer_seq(counter, size / 2);
+        divide_and_conquer_seq(counter, size / 2);
+    } else {
+        // count the leaves
+        counter.fetch_add(1, Ordering::SeqCst);
+    }
+}
+
+struct Tree<T: Send> {
+    value: T,
+    children: Vec<Tree<T>>,
+}
+
+impl<T: Send> Tree<T> {
+    fn iter(&self) -> vec::IntoIter<&T> {
+        once(&self.value)
+            .chain(self.children.iter().flat_map(Tree::iter))
+            .collect::<Vec<_>>() // seems like it shouldn't be needed... but prevents overflow
+            .into_iter()
+    }
+
+    fn update<OP>(&mut self, op: OP)
+    where
+        OP: Fn(&mut T) + Sync,
+        T: Send,
+    {
+        scope(|s| self.update_in_scope(&op, s));
+    }
+
+    fn update_in_scope<'scope, OP>(&'scope mut self, op: &'scope OP, scope: &Scope<'scope>)
+    where
+        OP: Fn(&mut T) + Sync,
+    {
+        let Tree {
+            ref mut value,
+            ref mut children,
+        } = *self;
+        scope.spawn(move |scope| {
+            for child in children {
+                scope.spawn(move |scope| child.update_in_scope(op, scope));
+            }
+        });
+
+        op(value);
+    }
+}
+
+fn random_tree(depth: usize) -> Tree<u32> {
+    assert!(depth > 0);
+    let mut seed = <XorShiftRng as SeedableRng>::Seed::default();
+    (0..).zip(seed.as_mut()).for_each(|(i, x)| *x = i);
+    let mut rng = XorShiftRng::from_seed(seed);
+    random_tree1(depth, &mut rng)
+}
+
+fn random_tree1(depth: usize, rng: &mut XorShiftRng) -> Tree<u32> {
+    let children = if depth == 0 {
+        vec![]
+    } else {
+        (0..rng.gen_range(0..4)) // somewhere between 0 and 3 children at each level
+            .map(|_| random_tree1(depth - 1, rng))
+            .collect()
+    };
+
+    Tree {
+        value: rng.gen_range(0..1_000_000),
+        children,
+    }
+}
+
+#[test]
+fn update_tree() {
+    let mut tree: Tree<u32> = random_tree(10);
+    let values: Vec<u32> = tree.iter().cloned().collect();
+    tree.update(|v| *v += 1);
+    let new_values: Vec<u32> = tree.iter().cloned().collect();
+    assert_eq!(values.len(), new_values.len());
+    for (&i, &j) in values.iter().zip(&new_values) {
+        assert_eq!(i + 1, j);
+    }
+}
+
+/// Check that if you have a chain of scoped tasks where T0 spawns T1
+/// spawns T2 and so forth down to Tn, the stack space should not grow
+/// linearly with N. We test this by some unsafe hackery and
+/// permitting an approx 10% change with a 10x input change.
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn linear_stack_growth() {
+    let builder = ThreadPoolBuilder::new().num_threads(1);
+    let pool = builder.build().unwrap();
+    pool.install(|| {
+        let mut max_diff = Mutex::new(0);
+        let bottom_of_stack = 0;
+        scope(|s| the_final_countdown(s, &bottom_of_stack, &max_diff, 5));
+        let diff_when_5 = *max_diff.get_mut().unwrap() as f64;
+
+        scope(|s| the_final_countdown(s, &bottom_of_stack, &max_diff, 500));
+        let diff_when_500 = *max_diff.get_mut().unwrap() as f64;
+
+        let ratio = diff_when_5 / diff_when_500;
+        assert!(
+            ratio > 0.9 && ratio < 1.1,
+            "stack usage ratio out of bounds: {}",
+            ratio
+        );
+    });
+}
+
+fn the_final_countdown<'scope>(
+    s: &Scope<'scope>,
+    bottom_of_stack: &'scope i32,
+    max: &'scope Mutex<usize>,
+    n: usize,
+) {
+    let top_of_stack = 0;
+    let p = bottom_of_stack as *const i32 as usize;
+    let q = &top_of_stack as *const i32 as usize;
+    let diff = if p > q { p - q } else { q - p };
+
+    let mut data = max.lock().unwrap();
+    *data = cmp::max(diff, *data);
+
+    if n > 0 {
+        s.spawn(move |s| the_final_countdown(s, bottom_of_stack, max, n - 1));
+    }
+}
+
+#[test]
+#[should_panic(expected = "Hello, world!")]
+fn panic_propagate_scope() {
+    scope(|_| panic!("Hello, world!"));
+}
+
+#[test]
+#[should_panic(expected = "Hello, world!")]
+fn panic_propagate_spawn() {
+    scope(|s| s.spawn(|_| panic!("Hello, world!")));
+}
+
+#[test]
+#[should_panic(expected = "Hello, world!")]
+fn panic_propagate_nested_spawn() {
+    scope(|s| s.spawn(|s| s.spawn(|s| s.spawn(|_| panic!("Hello, world!")))));
+}
+
+#[test]
+#[should_panic(expected = "Hello, world!")]
+fn panic_propagate_nested_scope_spawn() {
+    scope(|s| s.spawn(|_| scope(|s| s.spawn(|_| panic!("Hello, world!")))));
+}
+
+#[test]
+#[cfg_attr(not(panic = "unwind"), ignore)]
+fn panic_propagate_still_execute_1() {
+    let mut x = false;
+    match unwind::halt_unwinding(|| {
+        scope(|s| {
+            s.spawn(|_| panic!("Hello, world!")); // job A
+            s.spawn(|_| x = true); // job B, should still execute even though A panics
+        });
+    }) {
+        Ok(_) => panic!("failed to propagate panic"),
+        Err(_) => assert!(x, "job b failed to execute"),
+    }
+}
+
+#[test]
+#[cfg_attr(not(panic = "unwind"), ignore)]
+fn panic_propagate_still_execute_2() {
+    let mut x = false;
+    match unwind::halt_unwinding(|| {
+        scope(|s| {
+            s.spawn(|_| x = true); // job B, should still execute even though A panics
+            s.spawn(|_| panic!("Hello, world!")); // job A
+        });
+    }) {
+        Ok(_) => panic!("failed to propagate panic"),
+        Err(_) => assert!(x, "job b failed to execute"),
+    }
+}
+
+#[test]
+#[cfg_attr(not(panic = "unwind"), ignore)]
+fn panic_propagate_still_execute_3() {
+    let mut x = false;
+    match unwind::halt_unwinding(|| {
+        scope(|s| {
+            s.spawn(|_| x = true); // spawned job should still execute despite later panic
+            panic!("Hello, world!");
+        });
+    }) {
+        Ok(_) => panic!("failed to propagate panic"),
+        Err(_) => assert!(x, "panic after spawn, spawn failed to execute"),
+    }
+}
+
+#[test]
+#[cfg_attr(not(panic = "unwind"), ignore)]
+fn panic_propagate_still_execute_4() {
+    let mut x = false;
+    match unwind::halt_unwinding(|| {
+        scope(|s| {
+            s.spawn(|_| panic!("Hello, world!"));
+            x = true;
+        });
+    }) {
+        Ok(_) => panic!("failed to propagate panic"),
+        Err(_) => assert!(x, "panic in spawn tainted scope"),
+    }
+}
+
+macro_rules! test_order {
+    ($scope:ident => $spawn:ident) => {{
+        let builder = ThreadPoolBuilder::new().num_threads(1);
+        let pool = builder.build().unwrap();
+        pool.install(|| {
+            let vec = Mutex::new(vec![]);
+            $scope(|scope| {
+                let vec = &vec;
+                for i in 0..10 {
+                    scope.$spawn(move |scope| {
+                        for j in 0..10 {
+                            scope.$spawn(move |_| {
+                                vec.lock().unwrap().push(i * 10 + j);
+                            });
+                        }
+                    });
+                }
+            });
+            vec.into_inner().unwrap()
+        })
+    }};
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn lifo_order() {
+    // In the absence of stealing, `scope()` runs its `spawn()` jobs in LIFO order.
+    let vec = test_order!(scope => spawn);
+    let expected: Vec<i32> = (0..100).rev().collect(); // LIFO -> reversed
+    assert_eq!(vec, expected);
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn fifo_order() {
+    // In the absence of stealing, `scope_fifo()` runs its `spawn_fifo()` jobs in FIFO order.
+    let vec = test_order!(scope_fifo => spawn_fifo);
+    let expected: Vec<i32> = (0..100).collect(); // FIFO -> natural order
+    assert_eq!(vec, expected);
+}
+
+macro_rules! test_nested_order {
+    ($outer_scope:ident => $outer_spawn:ident,
+     $inner_scope:ident => $inner_spawn:ident) => {{
+        let builder = ThreadPoolBuilder::new().num_threads(1);
+        let pool = builder.build().unwrap();
+        pool.install(|| {
+            let vec = Mutex::new(vec![]);
+            $outer_scope(|scope| {
+                let vec = &vec;
+                for i in 0..10 {
+                    scope.$outer_spawn(move |_| {
+                        $inner_scope(|scope| {
+                            for j in 0..10 {
+                                scope.$inner_spawn(move |_| {
+                                    vec.lock().unwrap().push(i * 10 + j);
+                                });
+                            }
+                        });
+                    });
+                }
+            });
+            vec.into_inner().unwrap()
+        })
+    }};
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn nested_lifo_order() {
+    // In the absence of stealing, `scope()` runs its `spawn()` jobs in LIFO order.
+    let vec = test_nested_order!(scope => spawn, scope => spawn);
+    let expected: Vec<i32> = (0..100).rev().collect(); // LIFO -> reversed
+    assert_eq!(vec, expected);
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn nested_fifo_order() {
+    // In the absence of stealing, `scope_fifo()` runs its `spawn_fifo()` jobs in FIFO order.
+    let vec = test_nested_order!(scope_fifo => spawn_fifo, scope_fifo => spawn_fifo);
+    let expected: Vec<i32> = (0..100).collect(); // FIFO -> natural order
+    assert_eq!(vec, expected);
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn nested_lifo_fifo_order() {
+    // LIFO on the outside, FIFO on the inside
+    let vec = test_nested_order!(scope => spawn, scope_fifo => spawn_fifo);
+    let expected: Vec<i32> = (0..10)
+        .rev()
+        .flat_map(|i| (0..10).map(move |j| i * 10 + j))
+        .collect();
+    assert_eq!(vec, expected);
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn nested_fifo_lifo_order() {
+    // FIFO on the outside, LIFO on the inside
+    let vec = test_nested_order!(scope_fifo => spawn_fifo, scope => spawn);
+    let expected: Vec<i32> = (0..10)
+        .flat_map(|i| (0..10).rev().map(move |j| i * 10 + j))
+        .collect();
+    assert_eq!(vec, expected);
+}
+
+macro_rules! spawn_push {
+    ($scope:ident . $spawn:ident, $vec:ident, $i:expr) => {{
+        $scope.$spawn(move |_| $vec.lock().unwrap().push($i));
+    }};
+}
+
+/// Test spawns pushing a series of numbers, interleaved
+/// such that negative values are using an inner scope.
+macro_rules! test_mixed_order {
+    ($outer_scope:ident => $outer_spawn:ident,
+     $inner_scope:ident => $inner_spawn:ident) => {{
+        let builder = ThreadPoolBuilder::new().num_threads(1);
+        let pool = builder.build().unwrap();
+        pool.install(|| {
+            let vec = Mutex::new(vec![]);
+            $outer_scope(|outer_scope| {
+                let vec = &vec;
+                spawn_push!(outer_scope.$outer_spawn, vec, 0);
+                $inner_scope(|inner_scope| {
+                    spawn_push!(inner_scope.$inner_spawn, vec, -1);
+                    spawn_push!(outer_scope.$outer_spawn, vec, 1);
+                    spawn_push!(inner_scope.$inner_spawn, vec, -2);
+                    spawn_push!(outer_scope.$outer_spawn, vec, 2);
+                    spawn_push!(inner_scope.$inner_spawn, vec, -3);
+                });
+                spawn_push!(outer_scope.$outer_spawn, vec, 3);
+            });
+            vec.into_inner().unwrap()
+        })
+    }};
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn mixed_lifo_order() {
+    // NB: the end of the inner scope makes us execute some of the outer scope
+    // before they've all been spawned, so they're not perfectly LIFO.
+    let vec = test_mixed_order!(scope => spawn, scope => spawn);
+    let expected = vec![-3, 2, -2, 1, -1, 3, 0];
+    assert_eq!(vec, expected);
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn mixed_fifo_order() {
+    let vec = test_mixed_order!(scope_fifo => spawn_fifo, scope_fifo => spawn_fifo);
+    let expected = vec![-1, 0, -2, 1, -3, 2, 3];
+    assert_eq!(vec, expected);
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn mixed_lifo_fifo_order() {
+    // NB: the end of the inner scope makes us execute some of the outer scope
+    // before they've all been spawned, so they're not perfectly LIFO.
+    let vec = test_mixed_order!(scope => spawn, scope_fifo => spawn_fifo);
+    let expected = vec![-1, 2, -2, 1, -3, 3, 0];
+    assert_eq!(vec, expected);
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn mixed_fifo_lifo_order() {
+    let vec = test_mixed_order!(scope_fifo => spawn_fifo, scope => spawn);
+    let expected = vec![-3, 0, -2, 1, -1, 2, 3];
+    assert_eq!(vec, expected);
+}
+
+#[test]
+fn static_scope() {
+    static COUNTER: AtomicUsize = AtomicUsize::new(0);
+
+    let mut range = 0..100;
+    let sum = range.clone().sum();
+    let iter = &mut range;
+
+    COUNTER.store(0, Ordering::Relaxed);
+    scope(|s: &Scope<'static>| {
+        // While we're allowed the locally borrowed iterator,
+        // the spawns must be static.
+        for i in iter {
+            s.spawn(move |_| {
+                COUNTER.fetch_add(i, Ordering::Relaxed);
+            });
+        }
+    });
+
+    assert_eq!(COUNTER.load(Ordering::Relaxed), sum);
+}
+
+#[test]
+fn static_scope_fifo() {
+    static COUNTER: AtomicUsize = AtomicUsize::new(0);
+
+    let mut range = 0..100;
+    let sum = range.clone().sum();
+    let iter = &mut range;
+
+    COUNTER.store(0, Ordering::Relaxed);
+    scope_fifo(|s: &ScopeFifo<'static>| {
+        // While we're allowed the locally borrowed iterator,
+        // the spawns must be static.
+        for i in iter {
+            s.spawn_fifo(move |_| {
+                COUNTER.fetch_add(i, Ordering::Relaxed);
+            });
+        }
+    });
+
+    assert_eq!(COUNTER.load(Ordering::Relaxed), sum);
+}
+
+#[test]
+fn mixed_lifetime_scope() {
+    fn increment<'slice, 'counter>(counters: &'slice [&'counter AtomicUsize]) {
+        scope(move |s: &Scope<'counter>| {
+            // We can borrow 'slice here, but the spawns can only borrow 'counter.
+            for &c in counters {
+                s.spawn(move |_| {
+                    c.fetch_add(1, Ordering::Relaxed);
+                });
+            }
+        });
+    }
+
+    let counter = AtomicUsize::new(0);
+    increment(&[&counter; 100]);
+    assert_eq!(counter.into_inner(), 100);
+}
+
+#[test]
+fn mixed_lifetime_scope_fifo() {
+    fn increment<'slice, 'counter>(counters: &'slice [&'counter AtomicUsize]) {
+        scope_fifo(move |s: &ScopeFifo<'counter>| {
+            // We can borrow 'slice here, but the spawns can only borrow 'counter.
+            for &c in counters {
+                s.spawn_fifo(move |_| {
+                    c.fetch_add(1, Ordering::Relaxed);
+                });
+            }
+        });
+    }
+
+    let counter = AtomicUsize::new(0);
+    increment(&[&counter; 100]);
+    assert_eq!(counter.into_inner(), 100);
+}
+
+#[test]
+fn scope_spawn_broadcast() {
+    let sum = AtomicUsize::new(0);
+    let n = scope(|s| {
+        s.spawn_broadcast(|_, ctx| {
+            sum.fetch_add(ctx.index(), Ordering::Relaxed);
+        });
+        crate::current_num_threads()
+    });
+    assert_eq!(sum.into_inner(), n * (n - 1) / 2);
+}
+
+#[test]
+fn scope_fifo_spawn_broadcast() {
+    let sum = AtomicUsize::new(0);
+    let n = scope_fifo(|s| {
+        s.spawn_broadcast(|_, ctx| {
+            sum.fetch_add(ctx.index(), Ordering::Relaxed);
+        });
+        crate::current_num_threads()
+    });
+    assert_eq!(sum.into_inner(), n * (n - 1) / 2);
+}
+
+#[test]
+fn scope_spawn_broadcast_nested() {
+    let sum = AtomicUsize::new(0);
+    let n = scope(|s| {
+        s.spawn_broadcast(|s, _| {
+            s.spawn_broadcast(|_, ctx| {
+                sum.fetch_add(ctx.index(), Ordering::Relaxed);
+            });
+        });
+        crate::current_num_threads()
+    });
+    assert_eq!(sum.into_inner(), n * n * (n - 1) / 2);
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn scope_spawn_broadcast_barrier() {
+    let barrier = Barrier::new(8);
+    let pool = ThreadPoolBuilder::new().num_threads(7).build().unwrap();
+    pool.in_place_scope(|s| {
+        s.spawn_broadcast(|_, _| {
+            barrier.wait();
+        });
+        barrier.wait();
+    });
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn scope_spawn_broadcast_panic_one() {
+    let count = AtomicUsize::new(0);
+    let pool = ThreadPoolBuilder::new().num_threads(7).build().unwrap();
+    let result = crate::unwind::halt_unwinding(|| {
+        pool.scope(|s| {
+            s.spawn_broadcast(|_, ctx| {
+                count.fetch_add(1, Ordering::Relaxed);
+                if ctx.index() == 3 {
+                    panic!("Hello, world!");
+                }
+            });
+        });
+    });
+    assert_eq!(count.into_inner(), 7);
+    assert!(result.is_err(), "broadcast panic should propagate!");
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn scope_spawn_broadcast_panic_many() {
+    let count = AtomicUsize::new(0);
+    let pool = ThreadPoolBuilder::new().num_threads(7).build().unwrap();
+    let result = crate::unwind::halt_unwinding(|| {
+        pool.scope(|s| {
+            s.spawn_broadcast(|_, ctx| {
+                count.fetch_add(1, Ordering::Relaxed);
+                if ctx.index() % 2 == 0 {
+                    panic!("Hello, world!");
+                }
+            });
+        });
+    });
+    assert_eq!(count.into_inner(), 7);
+    assert!(result.is_err(), "broadcast panic should propagate!");
+}
diff --git a/crates/rayon-core/src/sleep/README.md b/crates/rayon-core/src/sleep/README.md
new file mode 100644
index 0000000..55426c8
--- /dev/null
+++ b/crates/rayon-core/src/sleep/README.md
@@ -0,0 +1,219 @@
+# Introduction: the sleep module
+
+The code in this module governs when worker threads should go to
+sleep. The system used in this code was introduced in [Rayon RFC #5].
+There is also a [video walkthrough] available. Both of those may be
+valuable resources to understanding the code, though naturally they
+will also grow stale over time. The comments in this file are
+extracted from the RFC and meant to be kept up to date.
+
+[Rayon RFC #5]: https://github.com/rayon-rs/rfcs/pull/5
+[video walkthrough]: https://youtu.be/HvmQsE5M4cY
+
+# The `Sleep` struct
+
+The `Sleep` struct is embedded into each registry. It performs several functions:
+
+* It tracks when workers are awake or asleep.
+* It decides how long a worker should look for work before it goes to sleep,
+  via a callback that is invoked periodically from the worker's search loop.
+* It is notified when latches are set, jobs are published, or other
+  events occur, and it will go and wake the appropriate threads if
+  they are sleeping.
+
+# Thread states
+
+There are three main thread states:
+
+* An **active** thread is one that is actively executing a job.
+* An **idle** thread is one that is searching for work to do. It will be
+  trying to steal work or pop work from the global injector queue.
+* A **sleeping** thread is one that is blocked on a condition variable,
+  waiting to be awoken.
+
+We sometimes refer to the final two states collectively as **inactive**.
+Threads begin as idle but transition to idle and finally sleeping when
+they're unable to find work to do.
+
+## Sleepy threads
+
+There is one other special state worth mentioning. During the idle state,
+threads can get **sleepy**. A sleepy thread is still idle, in that it is still
+searching for work, but it is *about* to go to sleep after it does one more
+search (or some other number, potentially). When a thread enters the sleepy
+state, it signals (via the **jobs event counter**, described below) that it is
+about to go to sleep. If new work is published, this will lead to the counter
+being adjusted. When the thread actually goes to sleep, it will (hopefully, but
+not guaranteed) see that the counter has changed and elect not to sleep, but
+instead to search again. See the section on the **jobs event counter** for more
+details.
+
+# The counters
+
+One of the key structs in the sleep module is `AtomicCounters`, found in
+`counters.rs`. It packs three counters into one atomically managed value:
+
+* Two **thread counters**, which track the number of threads in a particular state.
+* The **jobs event counter**, which is used to signal when new work is available.
+  It (sort of) tracks the number of jobs posted, but not quite, and it can rollover.
+
+## Thread counters
+
+There are two thread counters, one that tracks **inactive** threads and one that
+tracks **sleeping** threads. From this, one can deduce the number of threads
+that are idle by subtracting sleeping threads from inactive threads. We track
+the counters in this way because it permits simpler atomic operations. One can
+increment the number of sleeping threads (and thus decrease the number of idle
+threads) simply by doing one atomic increment, for example. Similarly, one can
+decrease the number of sleeping threads (and increase the number of idle
+threads) through one atomic decrement.
+
+These counters are adjusted as follows:
+
+* When a thread enters the idle state: increment the inactive thread counter.
+* When a thread enters the sleeping state: increment the sleeping thread counter.
+* When a thread awakens a sleeping thread: decrement the sleeping thread counter.
+  * Subtle point: the thread that *awakens* the sleeping thread decrements the
+    counter, not the thread that is *sleeping*. This is because there is a delay
+    between signaling a thread to wake and the thread actually waking:
+    decrementing the counter when awakening the thread means that other threads
+    that may be posting work will see the up-to-date value that much faster.
+* When a thread finds work, exiting the idle state: decrement the inactive
+  thread counter.
+
+## Jobs event counter
+
+The final counter is the **jobs event counter**. The role of this counter is to
+help sleepy threads detect when new work is posted in a lightweight fashion. In
+its simplest form, we would simply have a counter that gets incremented each
+time a new job is posted. This way, when a thread gets sleepy, it could read the
+counter, and then compare to see if the value has changed before it actually
+goes to sleep. But this [turns out to be too expensive] in practice, so we use a
+somewhat more complex scheme.
+
+[turns out to be too expensive]: https://github.com/rayon-rs/rayon/pull/746#issuecomment-624802747
+
+The idea is that the counter toggles between two states, depending on whether
+its value is even or odd (or, equivalently, on the value of its low bit):
+
+* Even -- If the low bit is zero, then it means that there has been no new work
+  since the last thread got sleepy.
+* Odd -- If the low bit is one, then it means that new work was posted since
+  the last thread got sleepy.
+
+### New work is posted
+
+When new work is posted, we check the value of the counter: if it is even,
+then we increment it by one, so that it becomes odd.
+
+### Worker thread gets sleepy
+
+When a worker thread gets sleepy, it will read the value of the counter. If the
+counter is odd, it will increment the counter so that it is even. Either way, it
+remembers the final value of the counter. The final value will be used later,
+when the thread is going to sleep. If at that time the counter has not changed,
+then we can assume no new jobs have been posted (though note the remote
+possibility of rollover, discussed in detail below).
+
+# Protocol for a worker thread to post work
+
+The full protocol for a thread to post work is as follows
+
+* If the work is posted into the injection queue, then execute a seq-cst fence (see below).
+* Load the counters, incrementing the JEC if it is even so that it is odd.
+* Check if there are idle threads available to handle this new job. If not,
+  and there are sleeping threads, then wake one or more threads.
+
+# Protocol for a worker thread to fall asleep
+
+The full protocol for a thread to fall asleep is as follows:
+
+* After completing all its jobs, the worker goes idle and begins to
+  search for work. As it searches, it counts "rounds". In each round,
+  it searches all other work threads' queues, plus the 'injector queue' for
+  work injected from the outside. If work is found in this search, the thread
+  becomes active again and hence restarts this protocol from the top.
+* After a certain number of rounds, the thread "gets sleepy" and executes `get_sleepy`
+  above, remembering the `final_value` of the JEC. It does one more search for work.
+* If no work is found, the thread atomically:
+  * Checks the JEC to see that it has not changed from `final_value`.
+    * If it has, then the thread goes back to searching for work. We reset to
+      just before we got sleepy, so that we will do one more search
+      before attending to sleep again (rather than searching for many rounds).
+  * Increments the number of sleeping threads by 1.
+* The thread then executes a seq-cst fence operation (see below).
+* The thread then does one final check for injected jobs (see below). If any
+  are available, it returns to the 'pre-sleepy' state as if the JEC had changed.
+* The thread waits to be signaled. Once signaled, it returns to the idle state.
+
+# The jobs event counter and deadlock
+
+As described in the section on the JEC, the main concern around going to sleep
+is avoiding a race condition wherein:
+
+* Thread A looks for work, finds none.
+* Thread B posts work but sees no sleeping threads.
+* Thread A goes to sleep.
+
+The JEC protocol largely prevents this, but due to rollover, this prevention is
+not complete. It is possible -- if unlikely -- that enough activity occurs for
+Thread A to observe the same JEC value that it saw when getting sleepy. If the
+new work being published came from *inside* the thread-pool, then this race
+condition isn't too harmful. It means that we have fewer workers processing the
+work then we should, but we won't deadlock. This seems like an acceptable risk
+given that this is unlikely in practice.
+
+However, if the work was posted as an *external* job, that is a problem. In that
+case, it's possible that all of our workers could go to sleep, and the external
+job would never get processed. To prevent that, the sleeping protocol includes
+one final check to see if the injector queue is empty before fully falling
+asleep. Note that this final check occurs **after** the number of sleeping
+threads has been incremented. We are not concerned therefore with races against
+injections that occur after that increment, only before.
+
+Unfortunately, there is one rather subtle point concerning this final check:
+we wish to avoid the possibility that:
+
+* work is pushed into the injection queue by an outside thread X,
+* the sleepy thread S sees the JEC but it has rolled over and is equal
+* the sleepy thread S reads the injection queue but does not see the work posted by X.
+
+This is possible because the C++ memory model typically offers guarantees of the
+form "if you see the access A, then you must see those other accesses" -- but it
+doesn't guarantee that you will see the access A (i.e., if you think of
+processors with independent caches, you may be operating on very out of date
+cache state). 
+
+## Using seq-cst fences to prevent deadlock
+
+To overcome this problem, we have inserted two sequentially consistent fence
+operations into the protocols above:
+
+* One fence occurs after work is posted into the injection queue, but before the
+  counters are read (including the number of sleeping threads).
+  * Note that no fence is needed for work posted to internal queues, since it is ok
+    to overlook work in that case.
+* One fence occurs after the number of sleeping threads is incremented, but
+  before the injection queue is read.
+
+### Proof sketch
+
+What follows is a "proof sketch" that the protocol is deadlock free. We model
+two relevant bits of memory, the job injector queue J and the atomic counters C.
+
+Consider the actions of the injecting thread:
+
+* PushJob: Job is injected, which can be modeled as an atomic write to J with release semantics.
+* PushFence: A sequentially consistent fence is executed.
+* ReadSleepers: The counters C are read (they may also be incremented, but we just consider the read that comes first).
+
+Meanwhile, the sleepy thread does the following:
+
+* IncSleepers: The number of sleeping threads is incremented, which is atomic exchange to C.
+* SleepFence: A sequentially consistent fence is executed.
+* ReadJob: We look to see if the queue is empty, which is a read of J with acquire semantics.
+
+Either PushFence or SleepFence must come first:
+
+* If PushFence comes first, then PushJob must be visible to ReadJob.
+* If SleepFence comes first, then IncSleepers is visible to ReadSleepers.
\ No newline at end of file
diff --git a/crates/rayon-core/src/sleep/counters.rs b/crates/rayon-core/src/sleep/counters.rs
new file mode 100644
index 0000000..53d2c55
--- /dev/null
+++ b/crates/rayon-core/src/sleep/counters.rs
@@ -0,0 +1,277 @@
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+pub(super) struct AtomicCounters {
+    /// Packs together a number of counters. The counters are ordered as
+    /// follows, from least to most significant bits (here, we assuming
+    /// that [`THREADS_BITS`] is equal to 10):
+    ///
+    /// * Bits 0..10: Stores the number of **sleeping threads**
+    /// * Bits 10..20: Stores the number of **inactive threads**
+    /// * Bits 20..: Stores the **job event counter** (JEC)
+    ///
+    /// This uses 10 bits ([`THREADS_BITS`]) to encode the number of threads. Note
+    /// that the total number of bits (and hence the number of bits used for the
+    /// JEC) will depend on whether we are using a 32- or 64-bit architecture.
+    value: AtomicUsize,
+}
+
+#[derive(Copy, Clone)]
+pub(super) struct Counters {
+    word: usize,
+}
+
+/// A value read from the **Jobs Event Counter**.
+/// See the [`README.md`](README.md) for more
+/// coverage of how the jobs event counter works.
+#[derive(Copy, Clone, Debug, PartialEq, PartialOrd)]
+pub(super) struct JobsEventCounter(usize);
+
+impl JobsEventCounter {
+    pub(super) const DUMMY: JobsEventCounter = JobsEventCounter(std::usize::MAX);
+
+    #[inline]
+    pub(super) fn as_usize(self) -> usize {
+        self.0
+    }
+
+    /// The JEC "is sleepy" if the last thread to increment it was in the
+    /// process of becoming sleepy. This is indicated by its value being *even*.
+    /// When new jobs are posted, they check if the JEC is sleepy, and if so
+    /// they incremented it.
+    #[inline]
+    pub(super) fn is_sleepy(self) -> bool {
+        (self.as_usize() & 1) == 0
+    }
+
+    /// The JEC "is active" if the last thread to increment it was posting new
+    /// work. This is indicated by its value being *odd*. When threads get
+    /// sleepy, they will check if the JEC is active, and increment it.
+    #[inline]
+    pub(super) fn is_active(self) -> bool {
+        !self.is_sleepy()
+    }
+}
+
+/// Number of bits used for the thread counters.
+#[cfg(target_pointer_width = "64")]
+const THREADS_BITS: usize = 16;
+
+#[cfg(target_pointer_width = "32")]
+const THREADS_BITS: usize = 8;
+
+/// Bits to shift to select the sleeping threads
+/// (used with `select_bits`).
+#[allow(clippy::erasing_op)]
+const SLEEPING_SHIFT: usize = 0 * THREADS_BITS;
+
+/// Bits to shift to select the inactive threads
+/// (used with `select_bits`).
+#[allow(clippy::identity_op)]
+const INACTIVE_SHIFT: usize = 1 * THREADS_BITS;
+
+/// Bits to shift to select the JEC
+/// (use JOBS_BITS).
+const JEC_SHIFT: usize = 2 * THREADS_BITS;
+
+/// Max value for the thread counters.
+pub(crate) const THREADS_MAX: usize = (1 << THREADS_BITS) - 1;
+
+/// Constant that can be added to add one sleeping thread.
+const ONE_SLEEPING: usize = 1;
+
+/// Constant that can be added to add one inactive thread.
+/// An inactive thread is either idle, sleepy, or sleeping.
+const ONE_INACTIVE: usize = 1 << INACTIVE_SHIFT;
+
+/// Constant that can be added to add one to the JEC.
+const ONE_JEC: usize = 1 << JEC_SHIFT;
+
+impl AtomicCounters {
+    #[inline]
+    pub(super) fn new() -> AtomicCounters {
+        AtomicCounters {
+            value: AtomicUsize::new(0),
+        }
+    }
+
+    /// Load and return the current value of the various counters.
+    /// This value can then be given to other method which will
+    /// attempt to update the counters via compare-and-swap.
+    #[inline]
+    pub(super) fn load(&self, ordering: Ordering) -> Counters {
+        Counters::new(self.value.load(ordering))
+    }
+
+    #[inline]
+    fn try_exchange(&self, old_value: Counters, new_value: Counters, ordering: Ordering) -> bool {
+        self.value
+            .compare_exchange(old_value.word, new_value.word, ordering, Ordering::Relaxed)
+            .is_ok()
+    }
+
+    /// Adds an inactive thread. This cannot fail.
+    ///
+    /// This should be invoked when a thread enters its idle loop looking
+    /// for work. It is decremented when work is found. Note that it is
+    /// not decremented if the thread transitions from idle to sleepy or sleeping;
+    /// so the number of inactive threads is always greater-than-or-equal
+    /// to the number of sleeping threads.
+    #[inline]
+    pub(super) fn add_inactive_thread(&self) {
+        self.value.fetch_add(ONE_INACTIVE, Ordering::SeqCst);
+    }
+
+    /// Increments the jobs event counter if `increment_when`, when applied to
+    /// the current value, is true. Used to toggle the JEC from even (sleepy) to
+    /// odd (active) or vice versa. Returns the final value of the counters, for
+    /// which `increment_when` is guaranteed to return false.
+    pub(super) fn increment_jobs_event_counter_if(
+        &self,
+        increment_when: impl Fn(JobsEventCounter) -> bool,
+    ) -> Counters {
+        loop {
+            let old_value = self.load(Ordering::SeqCst);
+            if increment_when(old_value.jobs_counter()) {
+                let new_value = old_value.increment_jobs_counter();
+                if self.try_exchange(old_value, new_value, Ordering::SeqCst) {
+                    return new_value;
+                }
+            } else {
+                return old_value;
+            }
+        }
+    }
+
+    /// Subtracts an inactive thread. This cannot fail. It is invoked
+    /// when a thread finds work and hence becomes active. It returns the
+    /// number of sleeping threads to wake up (if any).
+    ///
+    /// See `add_inactive_thread`.
+    #[inline]
+    pub(super) fn sub_inactive_thread(&self) -> usize {
+        let old_value = Counters::new(self.value.fetch_sub(ONE_INACTIVE, Ordering::SeqCst));
+        debug_assert!(
+            old_value.inactive_threads() > 0,
+            "sub_inactive_thread: old_value {:?} has no inactive threads",
+            old_value,
+        );
+        debug_assert!(
+            old_value.sleeping_threads() <= old_value.inactive_threads(),
+            "sub_inactive_thread: old_value {:?} had {} sleeping threads and {} inactive threads",
+            old_value,
+            old_value.sleeping_threads(),
+            old_value.inactive_threads(),
+        );
+
+        // Current heuristic: whenever an inactive thread goes away, if
+        // there are any sleeping threads, wake 'em up.
+        let sleeping_threads = old_value.sleeping_threads();
+        std::cmp::min(sleeping_threads, 2)
+    }
+
+    /// Subtracts a sleeping thread. This cannot fail, but it is only
+    /// safe to do if you you know the number of sleeping threads is
+    /// non-zero (i.e., because you have just awoken a sleeping
+    /// thread).
+    #[inline]
+    pub(super) fn sub_sleeping_thread(&self) {
+        let old_value = Counters::new(self.value.fetch_sub(ONE_SLEEPING, Ordering::SeqCst));
+        debug_assert!(
+            old_value.sleeping_threads() > 0,
+            "sub_sleeping_thread: old_value {:?} had no sleeping threads",
+            old_value,
+        );
+        debug_assert!(
+            old_value.sleeping_threads() <= old_value.inactive_threads(),
+            "sub_sleeping_thread: old_value {:?} had {} sleeping threads and {} inactive threads",
+            old_value,
+            old_value.sleeping_threads(),
+            old_value.inactive_threads(),
+        );
+    }
+
+    #[inline]
+    pub(super) fn try_add_sleeping_thread(&self, old_value: Counters) -> bool {
+        debug_assert!(
+            old_value.inactive_threads() > 0,
+            "try_add_sleeping_thread: old_value {:?} has no inactive threads",
+            old_value,
+        );
+        debug_assert!(
+            old_value.sleeping_threads() < THREADS_MAX,
+            "try_add_sleeping_thread: old_value {:?} has too many sleeping threads",
+            old_value,
+        );
+
+        let mut new_value = old_value;
+        new_value.word += ONE_SLEEPING;
+
+        self.try_exchange(old_value, new_value, Ordering::SeqCst)
+    }
+}
+
+#[inline]
+fn select_thread(word: usize, shift: usize) -> usize {
+    (word >> shift) & THREADS_MAX
+}
+
+#[inline]
+fn select_jec(word: usize) -> usize {
+    word >> JEC_SHIFT
+}
+
+impl Counters {
+    #[inline]
+    fn new(word: usize) -> Counters {
+        Counters { word }
+    }
+
+    #[inline]
+    fn increment_jobs_counter(self) -> Counters {
+        // We can freely add to JEC because it occupies the most significant bits.
+        // Thus it doesn't overflow into the other counters, just wraps itself.
+        Counters {
+            word: self.word.wrapping_add(ONE_JEC),
+        }
+    }
+
+    #[inline]
+    pub(super) fn jobs_counter(self) -> JobsEventCounter {
+        JobsEventCounter(select_jec(self.word))
+    }
+
+    /// The number of threads that are not actively
+    /// executing work. They may be idle, sleepy, or asleep.
+    #[inline]
+    pub(super) fn inactive_threads(self) -> usize {
+        select_thread(self.word, INACTIVE_SHIFT)
+    }
+
+    #[inline]
+    pub(super) fn awake_but_idle_threads(self) -> usize {
+        debug_assert!(
+            self.sleeping_threads() <= self.inactive_threads(),
+            "sleeping threads: {} > raw idle threads {}",
+            self.sleeping_threads(),
+            self.inactive_threads()
+        );
+        self.inactive_threads() - self.sleeping_threads()
+    }
+
+    #[inline]
+    pub(super) fn sleeping_threads(self) -> usize {
+        select_thread(self.word, SLEEPING_SHIFT)
+    }
+}
+
+impl std::fmt::Debug for Counters {
+    fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let word = format!("{:016x}", self.word);
+        fmt.debug_struct("Counters")
+            .field("word", &word)
+            .field("jobs", &self.jobs_counter().0)
+            .field("inactive", &self.inactive_threads())
+            .field("sleeping", &self.sleeping_threads())
+            .finish()
+    }
+}
diff --git a/crates/rayon-core/src/sleep/mod.rs b/crates/rayon-core/src/sleep/mod.rs
new file mode 100644
index 0000000..fa1f7be
--- /dev/null
+++ b/crates/rayon-core/src/sleep/mod.rs
@@ -0,0 +1,325 @@
+//! Code that decides when workers should go to sleep. See README.md
+//! for an overview.
+
+use crate::latch::CoreLatch;
+use crate::sync::{Condvar, Mutex};
+use crossbeam_utils::CachePadded;
+use std::sync::atomic::Ordering;
+use std::thread;
+use std::usize;
+
+mod counters;
+pub(crate) use self::counters::THREADS_MAX;
+use self::counters::{AtomicCounters, JobsEventCounter};
+
+/// The `Sleep` struct is embedded into each registry. It governs the waking and sleeping
+/// of workers. It has callbacks that are invoked periodically at significant events,
+/// such as when workers are looping and looking for work, when latches are set, or when
+/// jobs are published, and it either blocks threads or wakes them in response to these
+/// events. See the [`README.md`] in this module for more details.
+///
+/// [`README.md`] README.md
+pub(super) struct Sleep {
+    /// One "sleep state" per worker. Used to track if a worker is sleeping and to have
+    /// them block.
+    worker_sleep_states: Vec<CachePadded<WorkerSleepState>>,
+
+    counters: AtomicCounters,
+}
+
+/// An instance of this struct is created when a thread becomes idle.
+/// It is consumed when the thread finds work, and passed by `&mut`
+/// reference for operations that preserve the idle state. (In other
+/// words, producing one of these structs is evidence the thread is
+/// idle.) It tracks state such as how long the thread has been idle.
+pub(super) struct IdleState {
+    /// What is worker index of the idle thread?
+    worker_index: usize,
+
+    /// How many rounds have we been circling without sleeping?
+    rounds: u32,
+
+    /// Once we become sleepy, what was the sleepy counter value?
+    /// Set to `INVALID_SLEEPY_COUNTER` otherwise.
+    jobs_counter: JobsEventCounter,
+}
+
+/// The "sleep state" for an individual worker.
+#[derive(Default)]
+struct WorkerSleepState {
+    /// Set to true when the worker goes to sleep; set to false when
+    /// the worker is notified or when it wakes.
+    is_blocked: Mutex<bool>,
+
+    condvar: Condvar,
+}
+
+const ROUNDS_UNTIL_SLEEPY: u32 = 32;
+const ROUNDS_UNTIL_SLEEPING: u32 = ROUNDS_UNTIL_SLEEPY + 1;
+
+impl Sleep {
+    pub(super) fn new(n_threads: usize) -> Sleep {
+        assert!(n_threads <= THREADS_MAX);
+        Sleep {
+            worker_sleep_states: (0..n_threads).map(|_| Default::default()).collect(),
+            counters: AtomicCounters::new(),
+        }
+    }
+
+    #[inline]
+    pub(super) fn start_looking(&self, worker_index: usize) -> IdleState {
+        self.counters.add_inactive_thread();
+
+        IdleState {
+            worker_index,
+            rounds: 0,
+            jobs_counter: JobsEventCounter::DUMMY,
+        }
+    }
+
+    #[inline]
+    pub(super) fn work_found(&self) {
+        // If we were the last idle thread and other threads are still sleeping,
+        // then we should wake up another thread.
+        let threads_to_wake = self.counters.sub_inactive_thread();
+        self.wake_any_threads(threads_to_wake as u32);
+    }
+
+    #[inline]
+    pub(super) fn no_work_found(
+        &self,
+        idle_state: &mut IdleState,
+        latch: &CoreLatch,
+        has_injected_jobs: impl FnOnce() -> bool,
+    ) {
+        if idle_state.rounds < ROUNDS_UNTIL_SLEEPY {
+            thread::yield_now();
+            idle_state.rounds += 1;
+        } else if idle_state.rounds == ROUNDS_UNTIL_SLEEPY {
+            idle_state.jobs_counter = self.announce_sleepy();
+            idle_state.rounds += 1;
+            thread::yield_now();
+        } else if idle_state.rounds < ROUNDS_UNTIL_SLEEPING {
+            idle_state.rounds += 1;
+            thread::yield_now();
+        } else {
+            debug_assert_eq!(idle_state.rounds, ROUNDS_UNTIL_SLEEPING);
+            self.sleep(idle_state, latch, has_injected_jobs);
+        }
+    }
+
+    #[cold]
+    fn announce_sleepy(&self) -> JobsEventCounter {
+        self.counters
+            .increment_jobs_event_counter_if(JobsEventCounter::is_active)
+            .jobs_counter()
+    }
+
+    #[cold]
+    fn sleep(
+        &self,
+        idle_state: &mut IdleState,
+        latch: &CoreLatch,
+        has_injected_jobs: impl FnOnce() -> bool,
+    ) {
+        let worker_index = idle_state.worker_index;
+
+        if !latch.get_sleepy() {
+            return;
+        }
+
+        let sleep_state = &self.worker_sleep_states[worker_index];
+        let mut is_blocked = sleep_state.is_blocked.lock().unwrap();
+        debug_assert!(!*is_blocked);
+
+        // Our latch was signalled. We should wake back up fully as we
+        // will have some stuff to do.
+        if !latch.fall_asleep() {
+            idle_state.wake_fully();
+            return;
+        }
+
+        loop {
+            let counters = self.counters.load(Ordering::SeqCst);
+
+            // Check if the JEC has changed since we got sleepy.
+            debug_assert!(idle_state.jobs_counter.is_sleepy());
+            if counters.jobs_counter() != idle_state.jobs_counter {
+                // JEC has changed, so a new job was posted, but for some reason
+                // we didn't see it. We should return to just before the SLEEPY
+                // state so we can do another search and (if we fail to find
+                // work) go back to sleep.
+                idle_state.wake_partly();
+                latch.wake_up();
+                return;
+            }
+
+            // Otherwise, let's move from IDLE to SLEEPING.
+            if self.counters.try_add_sleeping_thread(counters) {
+                break;
+            }
+        }
+
+        // Successfully registered as asleep.
+
+        // We have one last check for injected jobs to do. This protects against
+        // deadlock in the very unlikely event that
+        //
+        // - an external job is being injected while we are sleepy
+        // - that job triggers the rollover over the JEC such that we don't see it
+        // - we are the last active worker thread
+        std::sync::atomic::fence(Ordering::SeqCst);
+        if has_injected_jobs() {
+            // If we see an externally injected job, then we have to 'wake
+            // ourselves up'. (Ordinarily, `sub_sleeping_thread` is invoked by
+            // the one that wakes us.)
+            self.counters.sub_sleeping_thread();
+        } else {
+            // If we don't see an injected job (the normal case), then flag
+            // ourselves as asleep and wait till we are notified.
+            //
+            // (Note that `is_blocked` is held under a mutex and the mutex was
+            // acquired *before* we incremented the "sleepy counter". This means
+            // that whomever is coming to wake us will have to wait until we
+            // release the mutex in the call to `wait`, so they will see this
+            // boolean as true.)
+            *is_blocked = true;
+            while *is_blocked {
+                is_blocked = sleep_state.condvar.wait(is_blocked).unwrap();
+            }
+        }
+
+        // Update other state:
+        idle_state.wake_fully();
+        latch.wake_up();
+    }
+
+    /// Notify the given thread that it should wake up (if it is
+    /// sleeping).  When this method is invoked, we typically know the
+    /// thread is asleep, though in rare cases it could have been
+    /// awoken by (e.g.) new work having been posted.
+    pub(super) fn notify_worker_latch_is_set(&self, target_worker_index: usize) {
+        self.wake_specific_thread(target_worker_index);
+    }
+
+    /// Signals that `num_jobs` new jobs were injected into the thread
+    /// pool from outside. This function will ensure that there are
+    /// threads available to process them, waking threads from sleep
+    /// if necessary.
+    ///
+    /// # Parameters
+    ///
+    /// - `num_jobs` -- lower bound on number of jobs available for stealing.
+    ///   We'll try to get at least one thread per job.
+    #[inline]
+    pub(super) fn new_injected_jobs(&self, num_jobs: u32, queue_was_empty: bool) {
+        // This fence is needed to guarantee that threads
+        // as they are about to fall asleep, observe any
+        // new jobs that may have been injected.
+        std::sync::atomic::fence(Ordering::SeqCst);
+
+        self.new_jobs(num_jobs, queue_was_empty)
+    }
+
+    /// Signals that `num_jobs` new jobs were pushed onto a thread's
+    /// local deque. This function will try to ensure that there are
+    /// threads available to process them, waking threads from sleep
+    /// if necessary. However, this is not guaranteed: under certain
+    /// race conditions, the function may fail to wake any new
+    /// threads; in that case the existing thread should eventually
+    /// pop the job.
+    ///
+    /// # Parameters
+    ///
+    /// - `num_jobs` -- lower bound on number of jobs available for stealing.
+    ///   We'll try to get at least one thread per job.
+    #[inline]
+    pub(super) fn new_internal_jobs(&self, num_jobs: u32, queue_was_empty: bool) {
+        self.new_jobs(num_jobs, queue_was_empty)
+    }
+
+    /// Common helper for `new_injected_jobs` and `new_internal_jobs`.
+    #[inline]
+    fn new_jobs(&self, num_jobs: u32, queue_was_empty: bool) {
+        // Read the counters and -- if sleepy workers have announced themselves
+        // -- announce that there is now work available. The final value of `counters`
+        // with which we exit the loop thus corresponds to a state when
+        let counters = self
+            .counters
+            .increment_jobs_event_counter_if(JobsEventCounter::is_sleepy);
+        let num_awake_but_idle = counters.awake_but_idle_threads();
+        let num_sleepers = counters.sleeping_threads();
+
+        if num_sleepers == 0 {
+            // nobody to wake
+            return;
+        }
+
+        // Promote from u16 to u32 so we can interoperate with
+        // num_jobs more easily.
+        let num_awake_but_idle = num_awake_but_idle as u32;
+        let num_sleepers = num_sleepers as u32;
+
+        // If the queue is non-empty, then we always wake up a worker
+        // -- clearly the existing idle jobs aren't enough. Otherwise,
+        // check to see if we have enough idle workers.
+        if !queue_was_empty {
+            let num_to_wake = std::cmp::min(num_jobs, num_sleepers);
+            self.wake_any_threads(num_to_wake);
+        } else if num_awake_but_idle < num_jobs {
+            let num_to_wake = std::cmp::min(num_jobs - num_awake_but_idle, num_sleepers);
+            self.wake_any_threads(num_to_wake);
+        }
+    }
+
+    #[cold]
+    fn wake_any_threads(&self, mut num_to_wake: u32) {
+        if num_to_wake > 0 {
+            for i in 0..self.worker_sleep_states.len() {
+                if self.wake_specific_thread(i) {
+                    num_to_wake -= 1;
+                    if num_to_wake == 0 {
+                        return;
+                    }
+                }
+            }
+        }
+    }
+
+    fn wake_specific_thread(&self, index: usize) -> bool {
+        let sleep_state = &self.worker_sleep_states[index];
+
+        let mut is_blocked = sleep_state.is_blocked.lock().unwrap();
+        if *is_blocked {
+            *is_blocked = false;
+            sleep_state.condvar.notify_one();
+
+            // When the thread went to sleep, it will have incremented
+            // this value. When we wake it, its our job to decrement
+            // it. We could have the thread do it, but that would
+            // introduce a delay between when the thread was
+            // *notified* and when this counter was decremented. That
+            // might mislead people with new work into thinking that
+            // there are sleeping threads that they should try to
+            // wake, when in fact there is nothing left for them to
+            // do.
+            self.counters.sub_sleeping_thread();
+
+            true
+        } else {
+            false
+        }
+    }
+}
+
+impl IdleState {
+    fn wake_fully(&mut self) {
+        self.rounds = 0;
+        self.jobs_counter = JobsEventCounter::DUMMY;
+    }
+
+    fn wake_partly(&mut self) {
+        self.rounds = ROUNDS_UNTIL_SLEEPY;
+        self.jobs_counter = JobsEventCounter::DUMMY;
+    }
+}
diff --git a/crates/rayon-core/src/spawn/mod.rs b/crates/rayon-core/src/spawn/mod.rs
new file mode 100644
index 0000000..22c5898
--- /dev/null
+++ b/crates/rayon-core/src/spawn/mod.rs
@@ -0,0 +1,163 @@
+use crate::job::*;
+use crate::registry::Registry;
+use crate::unwind;
+use std::mem;
+use std::sync::Arc;
+
+/// Puts the task into the Rayon threadpool's job queue in the "static"
+/// or "global" scope. Just like a standard thread, this task is not
+/// tied to the current stack frame, and hence it cannot hold any
+/// references other than those with `'static` lifetime. If you want
+/// to spawn a task that references stack data, use [the `scope()`
+/// function][scope] to create a scope.
+///
+/// [scope]: fn.scope.html
+///
+/// Since tasks spawned with this function cannot hold references into
+/// the enclosing stack frame, you almost certainly want to use a
+/// `move` closure as their argument (otherwise, the closure will
+/// typically hold references to any variables from the enclosing
+/// function that you happen to use).
+///
+/// This API assumes that the closure is executed purely for its
+/// side-effects (i.e., it might send messages, modify data protected
+/// by a mutex, or some such thing).
+///
+/// There is no guaranteed order of execution for spawns, given that
+/// other threads may steal tasks at any time. However, they are
+/// generally prioritized in a LIFO order on the thread from which
+/// they were spawned. Other threads always steal from the other end of
+/// the deque, like FIFO order.  The idea is that "recent" tasks are
+/// most likely to be fresh in the local CPU's cache, while other
+/// threads can steal older "stale" tasks.  For an alternate approach,
+/// consider [`spawn_fifo()`] instead.
+///
+/// [`spawn_fifo()`]: fn.spawn_fifo.html
+///
+/// # Panic handling
+///
+/// If this closure should panic, the resulting panic will be
+/// propagated to the panic handler registered in the `ThreadPoolBuilder`,
+/// if any.  See [`ThreadPoolBuilder::panic_handler()`][ph] for more
+/// details.
+///
+/// [ph]: struct.ThreadPoolBuilder.html#method.panic_handler
+///
+/// # Examples
+///
+/// This code creates a Rayon task that increments a global counter.
+///
+/// ```rust
+/// # use rayon_core as rayon;
+/// use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};
+///
+/// static GLOBAL_COUNTER: AtomicUsize = ATOMIC_USIZE_INIT;
+///
+/// rayon::spawn(move || {
+///     GLOBAL_COUNTER.fetch_add(1, Ordering::SeqCst);
+/// });
+/// ```
+pub fn spawn<F>(func: F)
+where
+    F: FnOnce() + Send + 'static,
+{
+    // We assert that current registry has not terminated.
+    unsafe { spawn_in(func, &Registry::current()) }
+}
+
+/// Spawns an asynchronous job in `registry.`
+///
+/// Unsafe because `registry` must not yet have terminated.
+pub(super) unsafe fn spawn_in<F>(func: F, registry: &Arc<Registry>)
+where
+    F: FnOnce() + Send + 'static,
+{
+    // We assert that this does not hold any references (we know
+    // this because of the `'static` bound in the interface);
+    // moreover, we assert that the code below is not supposed to
+    // be able to panic, and hence the data won't leak but will be
+    // enqueued into some deque for later execution.
+    let abort_guard = unwind::AbortIfPanic; // just in case we are wrong, and code CAN panic
+    let job_ref = spawn_job(func, registry);
+    registry.inject_or_push(job_ref);
+    mem::forget(abort_guard);
+}
+
+unsafe fn spawn_job<F>(func: F, registry: &Arc<Registry>) -> JobRef
+where
+    F: FnOnce() + Send + 'static,
+{
+    // Ensure that registry cannot terminate until this job has
+    // executed. This ref is decremented at the (*) below.
+    registry.increment_terminate_count();
+
+    HeapJob::new({
+        let registry = Arc::clone(registry);
+        move || {
+            registry.catch_unwind(func);
+            registry.terminate(); // (*) permit registry to terminate now
+        }
+    })
+    .into_static_job_ref()
+}
+
+/// Fires off a task into the Rayon threadpool in the "static" or
+/// "global" scope.  Just like a standard thread, this task is not
+/// tied to the current stack frame, and hence it cannot hold any
+/// references other than those with `'static` lifetime. If you want
+/// to spawn a task that references stack data, use [the `scope_fifo()`
+/// function](fn.scope_fifo.html) to create a scope.
+///
+/// The behavior is essentially the same as [the `spawn`
+/// function](fn.spawn.html), except that calls from the same thread
+/// will be prioritized in FIFO order. This is similar to the now-
+/// deprecated [`breadth_first`] option, except the effect is isolated
+/// to relative `spawn_fifo` calls, not all threadpool tasks.
+///
+/// For more details on this design, see Rayon [RFC #1].
+///
+/// [`breadth_first`]: struct.ThreadPoolBuilder.html#method.breadth_first
+/// [RFC #1]: https://github.com/rayon-rs/rfcs/blob/master/accepted/rfc0001-scope-scheduling.md
+///
+/// # Panic handling
+///
+/// If this closure should panic, the resulting panic will be
+/// propagated to the panic handler registered in the `ThreadPoolBuilder`,
+/// if any.  See [`ThreadPoolBuilder::panic_handler()`][ph] for more
+/// details.
+///
+/// [ph]: struct.ThreadPoolBuilder.html#method.panic_handler
+pub fn spawn_fifo<F>(func: F)
+where
+    F: FnOnce() + Send + 'static,
+{
+    // We assert that current registry has not terminated.
+    unsafe { spawn_fifo_in(func, &Registry::current()) }
+}
+
+/// Spawns an asynchronous FIFO job in `registry.`
+///
+/// Unsafe because `registry` must not yet have terminated.
+pub(super) unsafe fn spawn_fifo_in<F>(func: F, registry: &Arc<Registry>)
+where
+    F: FnOnce() + Send + 'static,
+{
+    // We assert that this does not hold any references (we know
+    // this because of the `'static` bound in the interface);
+    // moreover, we assert that the code below is not supposed to
+    // be able to panic, and hence the data won't leak but will be
+    // enqueued into some deque for later execution.
+    let abort_guard = unwind::AbortIfPanic; // just in case we are wrong, and code CAN panic
+    let job_ref = spawn_job(func, registry);
+
+    // If we're in the pool, use our thread's private fifo for this thread to execute
+    // in a locally-FIFO order.  Otherwise, just use the pool's global injector.
+    match registry.current_thread() {
+        Some(worker) => worker.push_fifo(job_ref),
+        None => registry.inject(job_ref),
+    }
+    mem::forget(abort_guard);
+}
+
+#[cfg(test)]
+mod test;
diff --git a/crates/rayon-core/src/spawn/test.rs b/crates/rayon-core/src/spawn/test.rs
new file mode 100644
index 0000000..b7a0535
--- /dev/null
+++ b/crates/rayon-core/src/spawn/test.rs
@@ -0,0 +1,255 @@
+use crate::scope;
+use std::any::Any;
+use std::sync::mpsc::channel;
+use std::sync::Mutex;
+
+use super::{spawn, spawn_fifo};
+use crate::ThreadPoolBuilder;
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn spawn_then_join_in_worker() {
+    let (tx, rx) = channel();
+    scope(move |_| {
+        spawn(move || tx.send(22).unwrap());
+    });
+    assert_eq!(22, rx.recv().unwrap());
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn spawn_then_join_outside_worker() {
+    let (tx, rx) = channel();
+    spawn(move || tx.send(22).unwrap());
+    assert_eq!(22, rx.recv().unwrap());
+}
+
+#[test]
+#[cfg_attr(not(panic = "unwind"), ignore)]
+fn panic_fwd() {
+    let (tx, rx) = channel();
+
+    let tx = Mutex::new(tx);
+    let panic_handler = move |err: Box<dyn Any + Send>| {
+        let tx = tx.lock().unwrap();
+        if let Some(&msg) = err.downcast_ref::<&str>() {
+            if msg == "Hello, world!" {
+                tx.send(1).unwrap();
+            } else {
+                tx.send(2).unwrap();
+            }
+        } else {
+            tx.send(3).unwrap();
+        }
+    };
+
+    let builder = ThreadPoolBuilder::new().panic_handler(panic_handler);
+
+    builder
+        .build()
+        .unwrap()
+        .spawn(move || panic!("Hello, world!"));
+
+    assert_eq!(1, rx.recv().unwrap());
+}
+
+/// Test what happens when the thread-pool is dropped but there are
+/// still active asynchronous tasks. We expect the thread-pool to stay
+/// alive and executing until those threads are complete.
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn termination_while_things_are_executing() {
+    let (tx0, rx0) = channel();
+    let (tx1, rx1) = channel();
+
+    // Create a thread-pool and spawn some code in it, but then drop
+    // our reference to it.
+    {
+        let thread_pool = ThreadPoolBuilder::new().build().unwrap();
+        thread_pool.spawn(move || {
+            let data = rx0.recv().unwrap();
+
+            // At this point, we know the "main" reference to the
+            // `ThreadPool` has been dropped, but there are still
+            // active threads. Launch one more.
+            spawn(move || {
+                tx1.send(data).unwrap();
+            });
+        });
+    }
+
+    tx0.send(22).unwrap();
+    let v = rx1.recv().unwrap();
+    assert_eq!(v, 22);
+}
+
+#[test]
+#[cfg_attr(not(panic = "unwind"), ignore)]
+fn custom_panic_handler_and_spawn() {
+    let (tx, rx) = channel();
+
+    // Create a parallel closure that will send panics on the
+    // channel; since the closure is potentially executed in parallel
+    // with itself, we have to wrap `tx` in a mutex.
+    let tx = Mutex::new(tx);
+    let panic_handler = move |e: Box<dyn Any + Send>| {
+        tx.lock().unwrap().send(e).unwrap();
+    };
+
+    // Execute an async that will panic.
+    let builder = ThreadPoolBuilder::new().panic_handler(panic_handler);
+    builder.build().unwrap().spawn(move || {
+        panic!("Hello, world!");
+    });
+
+    // Check that we got back the panic we expected.
+    let error = rx.recv().unwrap();
+    if let Some(&msg) = error.downcast_ref::<&str>() {
+        assert_eq!(msg, "Hello, world!");
+    } else {
+        panic!("did not receive a string from panic handler");
+    }
+}
+
+#[test]
+#[cfg_attr(not(panic = "unwind"), ignore)]
+fn custom_panic_handler_and_nested_spawn() {
+    let (tx, rx) = channel();
+
+    // Create a parallel closure that will send panics on the
+    // channel; since the closure is potentially executed in parallel
+    // with itself, we have to wrap `tx` in a mutex.
+    let tx = Mutex::new(tx);
+    let panic_handler = move |e| {
+        tx.lock().unwrap().send(e).unwrap();
+    };
+
+    // Execute an async that will (eventually) panic.
+    const PANICS: usize = 3;
+    let builder = ThreadPoolBuilder::new().panic_handler(panic_handler);
+    builder.build().unwrap().spawn(move || {
+        // launch 3 nested spawn-asyncs; these should be in the same
+        // thread-pool and hence inherit the same panic handler
+        for _ in 0..PANICS {
+            spawn(move || {
+                panic!("Hello, world!");
+            });
+        }
+    });
+
+    // Check that we get back the panics we expected.
+    for _ in 0..PANICS {
+        let error = rx.recv().unwrap();
+        if let Some(&msg) = error.downcast_ref::<&str>() {
+            assert_eq!(msg, "Hello, world!");
+        } else {
+            panic!("did not receive a string from panic handler");
+        }
+    }
+}
+
+macro_rules! test_order {
+    ($outer_spawn:ident, $inner_spawn:ident) => {{
+        let builder = ThreadPoolBuilder::new().num_threads(1);
+        let pool = builder.build().unwrap();
+        let (tx, rx) = channel();
+        pool.install(move || {
+            for i in 0..10 {
+                let tx = tx.clone();
+                $outer_spawn(move || {
+                    for j in 0..10 {
+                        let tx = tx.clone();
+                        $inner_spawn(move || {
+                            tx.send(i * 10 + j).unwrap();
+                        });
+                    }
+                });
+            }
+        });
+        rx.iter().collect::<Vec<i32>>()
+    }};
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn lifo_order() {
+    // In the absence of stealing, `spawn()` jobs on a thread will run in LIFO order.
+    let vec = test_order!(spawn, spawn);
+    let expected: Vec<i32> = (0..100).rev().collect(); // LIFO -> reversed
+    assert_eq!(vec, expected);
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn fifo_order() {
+    // In the absence of stealing, `spawn_fifo()` jobs on a thread will run in FIFO order.
+    let vec = test_order!(spawn_fifo, spawn_fifo);
+    let expected: Vec<i32> = (0..100).collect(); // FIFO -> natural order
+    assert_eq!(vec, expected);
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn lifo_fifo_order() {
+    // LIFO on the outside, FIFO on the inside
+    let vec = test_order!(spawn, spawn_fifo);
+    let expected: Vec<i32> = (0..10)
+        .rev()
+        .flat_map(|i| (0..10).map(move |j| i * 10 + j))
+        .collect();
+    assert_eq!(vec, expected);
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn fifo_lifo_order() {
+    // FIFO on the outside, LIFO on the inside
+    let vec = test_order!(spawn_fifo, spawn);
+    let expected: Vec<i32> = (0..10)
+        .flat_map(|i| (0..10).rev().map(move |j| i * 10 + j))
+        .collect();
+    assert_eq!(vec, expected);
+}
+
+macro_rules! spawn_send {
+    ($spawn:ident, $tx:ident, $i:expr) => {{
+        let tx = $tx.clone();
+        $spawn(move || tx.send($i).unwrap());
+    }};
+}
+
+/// Test mixed spawns pushing a series of numbers, interleaved such
+/// such that negative values are using the second kind of spawn.
+macro_rules! test_mixed_order {
+    ($pos_spawn:ident, $neg_spawn:ident) => {{
+        let builder = ThreadPoolBuilder::new().num_threads(1);
+        let pool = builder.build().unwrap();
+        let (tx, rx) = channel();
+        pool.install(move || {
+            spawn_send!($pos_spawn, tx, 0);
+            spawn_send!($neg_spawn, tx, -1);
+            spawn_send!($pos_spawn, tx, 1);
+            spawn_send!($neg_spawn, tx, -2);
+            spawn_send!($pos_spawn, tx, 2);
+            spawn_send!($neg_spawn, tx, -3);
+            spawn_send!($pos_spawn, tx, 3);
+        });
+        rx.iter().collect::<Vec<i32>>()
+    }};
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn mixed_lifo_fifo_order() {
+    let vec = test_mixed_order!(spawn, spawn_fifo);
+    let expected = vec![3, -1, 2, -2, 1, -3, 0];
+    assert_eq!(vec, expected);
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn mixed_fifo_lifo_order() {
+    let vec = test_mixed_order!(spawn_fifo, spawn);
+    let expected = vec![0, -3, 1, -2, 2, -1, 3];
+    assert_eq!(vec, expected);
+}
diff --git a/crates/rayon-core/src/test.rs b/crates/rayon-core/src/test.rs
new file mode 100644
index 0000000..25b8487
--- /dev/null
+++ b/crates/rayon-core/src/test.rs
@@ -0,0 +1,200 @@
+#![cfg(test)]
+
+use crate::{ThreadPoolBuildError, ThreadPoolBuilder};
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::{Arc, Barrier};
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn worker_thread_index() {
+    let pool = ThreadPoolBuilder::new().num_threads(22).build().unwrap();
+    assert_eq!(pool.current_num_threads(), 22);
+    assert_eq!(pool.current_thread_index(), None);
+    let index = pool.install(|| pool.current_thread_index().unwrap());
+    assert!(index < 22);
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn start_callback_called() {
+    let n_threads = 16;
+    let n_called = Arc::new(AtomicUsize::new(0));
+    // Wait for all the threads in the pool plus the one running tests.
+    let barrier = Arc::new(Barrier::new(n_threads + 1));
+
+    let b = Arc::clone(&barrier);
+    let nc = Arc::clone(&n_called);
+    let start_handler = move |_| {
+        nc.fetch_add(1, Ordering::SeqCst);
+        b.wait();
+    };
+
+    let conf = ThreadPoolBuilder::new()
+        .num_threads(n_threads)
+        .start_handler(start_handler);
+    let _ = conf.build().unwrap();
+
+    // Wait for all the threads to have been scheduled to run.
+    barrier.wait();
+
+    // The handler must have been called on every started thread.
+    assert_eq!(n_called.load(Ordering::SeqCst), n_threads);
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn exit_callback_called() {
+    let n_threads = 16;
+    let n_called = Arc::new(AtomicUsize::new(0));
+    // Wait for all the threads in the pool plus the one running tests.
+    let barrier = Arc::new(Barrier::new(n_threads + 1));
+
+    let b = Arc::clone(&barrier);
+    let nc = Arc::clone(&n_called);
+    let exit_handler = move |_| {
+        nc.fetch_add(1, Ordering::SeqCst);
+        b.wait();
+    };
+
+    let conf = ThreadPoolBuilder::new()
+        .num_threads(n_threads)
+        .exit_handler(exit_handler);
+    {
+        let _ = conf.build().unwrap();
+        // Drop the pool so it stops the running threads.
+    }
+
+    // Wait for all the threads to have been scheduled to run.
+    barrier.wait();
+
+    // The handler must have been called on every exiting thread.
+    assert_eq!(n_called.load(Ordering::SeqCst), n_threads);
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn handler_panics_handled_correctly() {
+    let n_threads = 16;
+    let n_called = Arc::new(AtomicUsize::new(0));
+    // Wait for all the threads in the pool plus the one running tests.
+    let start_barrier = Arc::new(Barrier::new(n_threads + 1));
+    let exit_barrier = Arc::new(Barrier::new(n_threads + 1));
+
+    let start_handler = move |_| {
+        panic!("ensure panic handler is called when starting");
+    };
+    let exit_handler = move |_| {
+        panic!("ensure panic handler is called when exiting");
+    };
+
+    let sb = Arc::clone(&start_barrier);
+    let eb = Arc::clone(&exit_barrier);
+    let nc = Arc::clone(&n_called);
+    let panic_handler = move |_| {
+        let val = nc.fetch_add(1, Ordering::SeqCst);
+        if val < n_threads {
+            sb.wait();
+        } else {
+            eb.wait();
+        }
+    };
+
+    let conf = ThreadPoolBuilder::new()
+        .num_threads(n_threads)
+        .start_handler(start_handler)
+        .exit_handler(exit_handler)
+        .panic_handler(panic_handler);
+    {
+        let _ = conf.build().unwrap();
+
+        // Wait for all the threads to start, panic in the start handler,
+        // and been taken care of by the panic handler.
+        start_barrier.wait();
+
+        // Drop the pool so it stops the running threads.
+    }
+
+    // Wait for all the threads to exit, panic in the exit handler,
+    // and been taken care of by the panic handler.
+    exit_barrier.wait();
+
+    // The panic handler must have been called twice on every thread.
+    assert_eq!(n_called.load(Ordering::SeqCst), 2 * n_threads);
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn check_config_build() {
+    let pool = ThreadPoolBuilder::new().num_threads(22).build().unwrap();
+    assert_eq!(pool.current_num_threads(), 22);
+}
+
+/// Helper used by check_error_send_sync to ensure ThreadPoolBuildError is Send + Sync
+fn _send_sync<T: Send + Sync>() {}
+
+#[test]
+fn check_error_send_sync() {
+    _send_sync::<ThreadPoolBuildError>();
+}
+
+#[allow(deprecated)]
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn configuration() {
+    let start_handler = move |_| {};
+    let exit_handler = move |_| {};
+    let panic_handler = move |_| {};
+    let thread_name = move |i| format!("thread_name_{}", i);
+
+    // Ensure we can call all public methods on Configuration
+    crate::Configuration::new()
+        .thread_name(thread_name)
+        .num_threads(5)
+        .panic_handler(panic_handler)
+        .stack_size(4e6 as usize)
+        .breadth_first()
+        .start_handler(start_handler)
+        .exit_handler(exit_handler)
+        .build()
+        .unwrap();
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn default_pool() {
+    ThreadPoolBuilder::default().build().unwrap();
+}
+
+/// Test that custom spawned threads get their `WorkerThread` cleared once
+/// the pool is done with them, allowing them to be used with rayon again
+/// later. e.g. WebAssembly want to have their own pool of available threads.
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn cleared_current_thread() -> Result<(), ThreadPoolBuildError> {
+    let n_threads = 5;
+    let mut handles = vec![];
+    let pool = ThreadPoolBuilder::new()
+        .num_threads(n_threads)
+        .spawn_handler(|thread| {
+            let handle = std::thread::spawn(move || {
+                thread.run();
+
+                // Afterward, the current thread shouldn't be set anymore.
+                assert_eq!(crate::current_thread_index(), None);
+            });
+            handles.push(handle);
+            Ok(())
+        })
+        .build()?;
+    assert_eq!(handles.len(), n_threads);
+
+    pool.install(|| assert!(crate::current_thread_index().is_some()));
+    drop(pool);
+
+    // Wait for all threads to make their assertions and exit
+    for handle in handles {
+        handle.join().unwrap();
+    }
+
+    Ok(())
+}
diff --git a/crates/rayon-core/src/thread_pool/mod.rs b/crates/rayon-core/src/thread_pool/mod.rs
new file mode 100644
index 0000000..5ae6e0f
--- /dev/null
+++ b/crates/rayon-core/src/thread_pool/mod.rs
@@ -0,0 +1,508 @@
+//! Contains support for user-managed thread pools, represented by the
+//! the [`ThreadPool`] type (see that struct for details).
+//!
+//! [`ThreadPool`]: struct.ThreadPool.html
+
+use crate::broadcast::{self, BroadcastContext};
+use crate::join;
+use crate::registry::{Registry, ThreadSpawn, WorkerThread};
+use crate::scope::{do_in_place_scope, do_in_place_scope_fifo};
+use crate::spawn;
+use crate::{scope, Scope};
+use crate::{scope_fifo, ScopeFifo};
+use crate::{ThreadPoolBuildError, ThreadPoolBuilder};
+use std::error::Error;
+use std::fmt;
+use std::sync::Arc;
+
+mod test;
+
+/// Represents a user created [thread-pool].
+///
+/// Use a [`ThreadPoolBuilder`] to specify the number and/or names of threads
+/// in the pool. After calling [`ThreadPoolBuilder::build()`], you can then
+/// execute functions explicitly within this [`ThreadPool`] using
+/// [`ThreadPool::install()`]. By contrast, top level rayon functions
+/// (like `join()`) will execute implicitly within the current thread-pool.
+///
+///
+/// ## Creating a ThreadPool
+///
+/// ```rust
+/// # use rayon_core as rayon;
+/// let pool = rayon::ThreadPoolBuilder::new().num_threads(8).build().unwrap();
+/// ```
+///
+/// [`install()`][`ThreadPool::install()`] executes a closure in one of the `ThreadPool`'s
+/// threads. In addition, any other rayon operations called inside of `install()` will also
+/// execute in the context of the `ThreadPool`.
+///
+/// When the `ThreadPool` is dropped, that's a signal for the threads it manages to terminate,
+/// they will complete executing any remaining work that you have spawned, and automatically
+/// terminate.
+///
+///
+/// [thread-pool]: https://en.wikipedia.org/wiki/Thread_pool
+/// [`ThreadPool`]: struct.ThreadPool.html
+/// [`ThreadPool::new()`]: struct.ThreadPool.html#method.new
+/// [`ThreadPoolBuilder`]: struct.ThreadPoolBuilder.html
+/// [`ThreadPoolBuilder::build()`]: struct.ThreadPoolBuilder.html#method.build
+/// [`ThreadPool::install()`]: struct.ThreadPool.html#method.install
+pub struct ThreadPool {
+    registry: Arc<Registry>,
+}
+
+impl ThreadPool {
+    #[deprecated(note = "Use `ThreadPoolBuilder::build`")]
+    #[allow(deprecated)]
+    /// Deprecated in favor of `ThreadPoolBuilder::build`.
+    pub fn new(configuration: crate::Configuration) -> Result<ThreadPool, Box<dyn Error>> {
+        Self::build(configuration.into_builder()).map_err(Box::from)
+    }
+
+    pub(super) fn build<S>(
+        builder: ThreadPoolBuilder<S>,
+    ) -> Result<ThreadPool, ThreadPoolBuildError>
+    where
+        S: ThreadSpawn,
+    {
+        let registry = Registry::new(builder)?;
+        Ok(ThreadPool { registry })
+    }
+
+    /// Executes `op` within the threadpool. Any attempts to use
+    /// `join`, `scope`, or parallel iterators will then operate
+    /// within that threadpool.
+    ///
+    /// # Warning: thread-local data
+    ///
+    /// Because `op` is executing within the Rayon thread-pool,
+    /// thread-local data from the current thread will not be
+    /// accessible.
+    ///
+    /// # Warning: execution order
+    ///
+    /// If the current thread is part of a different thread pool, it will try to
+    /// keep busy while the `op` completes in its target pool, similar to
+    /// calling [`ThreadPool::yield_now()`] in a loop. Therefore, it may
+    /// potentially schedule other tasks to run on the current thread in the
+    /// meantime. For example
+    ///
+    /// ```rust
+    /// # use rayon_core as rayon;
+    /// fn main() {
+    ///     rayon::ThreadPoolBuilder::new().num_threads(1).build_global().unwrap();
+    ///     let pool = rayon_core::ThreadPoolBuilder::default().build().unwrap();
+    ///     let do_it = || {
+    ///         print!("one ");
+    ///         pool.install(||{});
+    ///         print!("two ");
+    ///     };
+    ///     rayon::join(|| do_it(), || do_it());
+    /// }
+    /// ```
+    ///
+    /// Since we configured just one thread in the global pool, one might
+    /// expect `do_it()` to run sequentially, producing:
+    ///
+    /// ```ascii
+    /// one two one two
+    /// ```
+    ///
+    /// However each call to `install()` yields implicitly, allowing rayon to
+    /// run multiple instances of `do_it()` concurrently on the single, global
+    /// thread. The following output would be equally valid:
+    ///
+    /// ```ascii
+    /// one one two two
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// If `op` should panic, that panic will be propagated.
+    ///
+    /// ## Using `install()`
+    ///
+    /// ```rust
+    ///    # use rayon_core as rayon;
+    ///    fn main() {
+    ///         let pool = rayon::ThreadPoolBuilder::new().num_threads(8).build().unwrap();
+    ///         let n = pool.install(|| fib(20));
+    ///         println!("{}", n);
+    ///    }
+    ///
+    ///    fn fib(n: usize) -> usize {
+    ///         if n == 0 || n == 1 {
+    ///             return n;
+    ///         }
+    ///         let (a, b) = rayon::join(|| fib(n - 1), || fib(n - 2)); // runs inside of `pool`
+    ///         return a + b;
+    ///     }
+    /// ```
+    pub fn install<OP, R>(&self, op: OP) -> R
+    where
+        OP: FnOnce() -> R + Send,
+        R: Send,
+    {
+        self.registry.in_worker(|_, _| op())
+    }
+
+    /// Executes `op` within every thread in the threadpool. Any attempts to use
+    /// `join`, `scope`, or parallel iterators will then operate within that
+    /// threadpool.
+    ///
+    /// Broadcasts are executed on each thread after they have exhausted their
+    /// local work queue, before they attempt work-stealing from other threads.
+    /// The goal of that strategy is to run everywhere in a timely manner
+    /// *without* being too disruptive to current work. There may be alternative
+    /// broadcast styles added in the future for more or less aggressive
+    /// injection, if the need arises.
+    ///
+    /// # Warning: thread-local data
+    ///
+    /// Because `op` is executing within the Rayon thread-pool,
+    /// thread-local data from the current thread will not be
+    /// accessible.
+    ///
+    /// # Panics
+    ///
+    /// If `op` should panic on one or more threads, exactly one panic
+    /// will be propagated, only after all threads have completed
+    /// (or panicked) their own `op`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    ///    # use rayon_core as rayon;
+    ///    use std::sync::atomic::{AtomicUsize, Ordering};
+    ///
+    ///    fn main() {
+    ///         let pool = rayon::ThreadPoolBuilder::new().num_threads(5).build().unwrap();
+    ///
+    ///         // The argument gives context, including the index of each thread.
+    ///         let v: Vec<usize> = pool.broadcast(|ctx| ctx.index() * ctx.index());
+    ///         assert_eq!(v, &[0, 1, 4, 9, 16]);
+    ///
+    ///         // The closure can reference the local stack
+    ///         let count = AtomicUsize::new(0);
+    ///         pool.broadcast(|_| count.fetch_add(1, Ordering::Relaxed));
+    ///         assert_eq!(count.into_inner(), 5);
+    ///    }
+    /// ```
+    pub fn broadcast<OP, R>(&self, op: OP) -> Vec<R>
+    where
+        OP: Fn(BroadcastContext<'_>) -> R + Sync,
+        R: Send,
+    {
+        // We assert that `self.registry` has not terminated.
+        unsafe { broadcast::broadcast_in(op, &self.registry) }
+    }
+
+    /// Returns the (current) number of threads in the thread pool.
+    ///
+    /// # Future compatibility note
+    ///
+    /// Note that unless this thread-pool was created with a
+    /// [`ThreadPoolBuilder`] that specifies the number of threads,
+    /// then this number may vary over time in future versions (see [the
+    /// `num_threads()` method for details][snt]).
+    ///
+    /// [snt]: struct.ThreadPoolBuilder.html#method.num_threads
+    /// [`ThreadPoolBuilder`]: struct.ThreadPoolBuilder.html
+    #[inline]
+    pub fn current_num_threads(&self) -> usize {
+        self.registry.num_threads()
+    }
+
+    /// If called from a Rayon worker thread in this thread-pool,
+    /// returns the index of that thread; if not called from a Rayon
+    /// thread, or called from a Rayon thread that belongs to a
+    /// different thread-pool, returns `None`.
+    ///
+    /// The index for a given thread will not change over the thread's
+    /// lifetime. However, multiple threads may share the same index if
+    /// they are in distinct thread-pools.
+    ///
+    /// # Future compatibility note
+    ///
+    /// Currently, every thread-pool (including the global
+    /// thread-pool) has a fixed number of threads, but this may
+    /// change in future Rayon versions (see [the `num_threads()` method
+    /// for details][snt]). In that case, the index for a
+    /// thread would not change during its lifetime, but thread
+    /// indices may wind up being reused if threads are terminated and
+    /// restarted.
+    ///
+    /// [snt]: struct.ThreadPoolBuilder.html#method.num_threads
+    #[inline]
+    pub fn current_thread_index(&self) -> Option<usize> {
+        let curr = self.registry.current_thread()?;
+        Some(curr.index())
+    }
+
+    /// Returns true if the current worker thread currently has "local
+    /// tasks" pending. This can be useful as part of a heuristic for
+    /// deciding whether to spawn a new task or execute code on the
+    /// current thread, particularly in breadth-first
+    /// schedulers. However, keep in mind that this is an inherently
+    /// racy check, as other worker threads may be actively "stealing"
+    /// tasks from our local deque.
+    ///
+    /// **Background:** Rayon's uses a [work-stealing] scheduler. The
+    /// key idea is that each thread has its own [deque] of
+    /// tasks. Whenever a new task is spawned -- whether through
+    /// `join()`, `Scope::spawn()`, or some other means -- that new
+    /// task is pushed onto the thread's *local* deque. Worker threads
+    /// have a preference for executing their own tasks; if however
+    /// they run out of tasks, they will go try to "steal" tasks from
+    /// other threads. This function therefore has an inherent race
+    /// with other active worker threads, which may be removing items
+    /// from the local deque.
+    ///
+    /// [work-stealing]: https://en.wikipedia.org/wiki/Work_stealing
+    /// [deque]: https://en.wikipedia.org/wiki/Double-ended_queue
+    #[inline]
+    pub fn current_thread_has_pending_tasks(&self) -> Option<bool> {
+        let curr = self.registry.current_thread()?;
+        Some(!curr.local_deque_is_empty())
+    }
+
+    /// Execute `oper_a` and `oper_b` in the thread-pool and return
+    /// the results. Equivalent to `self.install(|| join(oper_a,
+    /// oper_b))`.
+    pub fn join<A, B, RA, RB>(&self, oper_a: A, oper_b: B) -> (RA, RB)
+    where
+        A: FnOnce() -> RA + Send,
+        B: FnOnce() -> RB + Send,
+        RA: Send,
+        RB: Send,
+    {
+        self.install(|| join(oper_a, oper_b))
+    }
+
+    /// Creates a scope that executes within this thread-pool.
+    /// Equivalent to `self.install(|| scope(...))`.
+    ///
+    /// See also: [the `scope()` function][scope].
+    ///
+    /// [scope]: fn.scope.html
+    pub fn scope<'scope, OP, R>(&self, op: OP) -> R
+    where
+        OP: FnOnce(&Scope<'scope>) -> R + Send,
+        R: Send,
+    {
+        self.install(|| scope(op))
+    }
+
+    /// Creates a scope that executes within this thread-pool.
+    /// Spawns from the same thread are prioritized in relative FIFO order.
+    /// Equivalent to `self.install(|| scope_fifo(...))`.
+    ///
+    /// See also: [the `scope_fifo()` function][scope_fifo].
+    ///
+    /// [scope_fifo]: fn.scope_fifo.html
+    pub fn scope_fifo<'scope, OP, R>(&self, op: OP) -> R
+    where
+        OP: FnOnce(&ScopeFifo<'scope>) -> R + Send,
+        R: Send,
+    {
+        self.install(|| scope_fifo(op))
+    }
+
+    /// Creates a scope that spawns work into this thread-pool.
+    ///
+    /// See also: [the `in_place_scope()` function][in_place_scope].
+    ///
+    /// [in_place_scope]: fn.in_place_scope.html
+    pub fn in_place_scope<'scope, OP, R>(&self, op: OP) -> R
+    where
+        OP: FnOnce(&Scope<'scope>) -> R,
+    {
+        do_in_place_scope(Some(&self.registry), op)
+    }
+
+    /// Creates a scope that spawns work into this thread-pool in FIFO order.
+    ///
+    /// See also: [the `in_place_scope_fifo()` function][in_place_scope_fifo].
+    ///
+    /// [in_place_scope_fifo]: fn.in_place_scope_fifo.html
+    pub fn in_place_scope_fifo<'scope, OP, R>(&self, op: OP) -> R
+    where
+        OP: FnOnce(&ScopeFifo<'scope>) -> R,
+    {
+        do_in_place_scope_fifo(Some(&self.registry), op)
+    }
+
+    /// Spawns an asynchronous task in this thread-pool. This task will
+    /// run in the implicit, global scope, which means that it may outlast
+    /// the current stack frame -- therefore, it cannot capture any references
+    /// onto the stack (you will likely need a `move` closure).
+    ///
+    /// See also: [the `spawn()` function defined on scopes][spawn].
+    ///
+    /// [spawn]: struct.Scope.html#method.spawn
+    pub fn spawn<OP>(&self, op: OP)
+    where
+        OP: FnOnce() + Send + 'static,
+    {
+        // We assert that `self.registry` has not terminated.
+        unsafe { spawn::spawn_in(op, &self.registry) }
+    }
+
+    /// Spawns an asynchronous task in this thread-pool. This task will
+    /// run in the implicit, global scope, which means that it may outlast
+    /// the current stack frame -- therefore, it cannot capture any references
+    /// onto the stack (you will likely need a `move` closure).
+    ///
+    /// See also: [the `spawn_fifo()` function defined on scopes][spawn_fifo].
+    ///
+    /// [spawn_fifo]: struct.ScopeFifo.html#method.spawn_fifo
+    pub fn spawn_fifo<OP>(&self, op: OP)
+    where
+        OP: FnOnce() + Send + 'static,
+    {
+        // We assert that `self.registry` has not terminated.
+        unsafe { spawn::spawn_fifo_in(op, &self.registry) }
+    }
+
+    /// Spawns an asynchronous task on every thread in this thread-pool. This task
+    /// will run in the implicit, global scope, which means that it may outlast the
+    /// current stack frame -- therefore, it cannot capture any references onto the
+    /// stack (you will likely need a `move` closure).
+    pub fn spawn_broadcast<OP>(&self, op: OP)
+    where
+        OP: Fn(BroadcastContext<'_>) + Send + Sync + 'static,
+    {
+        // We assert that `self.registry` has not terminated.
+        unsafe { broadcast::spawn_broadcast_in(op, &self.registry) }
+    }
+
+    /// Cooperatively yields execution to Rayon.
+    ///
+    /// This is similar to the general [`yield_now()`], but only if the current
+    /// thread is part of *this* thread pool.
+    ///
+    /// Returns `Some(Yield::Executed)` if anything was executed, `Some(Yield::Idle)` if
+    /// nothing was available, or `None` if the current thread is not part this pool.
+    pub fn yield_now(&self) -> Option<Yield> {
+        let curr = self.registry.current_thread()?;
+        Some(curr.yield_now())
+    }
+
+    /// Cooperatively yields execution to local Rayon work.
+    ///
+    /// This is similar to the general [`yield_local()`], but only if the current
+    /// thread is part of *this* thread pool.
+    ///
+    /// Returns `Some(Yield::Executed)` if anything was executed, `Some(Yield::Idle)` if
+    /// nothing was available, or `None` if the current thread is not part this pool.
+    pub fn yield_local(&self) -> Option<Yield> {
+        let curr = self.registry.current_thread()?;
+        Some(curr.yield_local())
+    }
+}
+
+impl Drop for ThreadPool {
+    fn drop(&mut self) {
+        self.registry.terminate();
+    }
+}
+
+impl fmt::Debug for ThreadPool {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt.debug_struct("ThreadPool")
+            .field("num_threads", &self.current_num_threads())
+            .field("id", &self.registry.id())
+            .finish()
+    }
+}
+
+/// If called from a Rayon worker thread, returns the index of that
+/// thread within its current pool; if not called from a Rayon thread,
+/// returns `None`.
+///
+/// The index for a given thread will not change over the thread's
+/// lifetime. However, multiple threads may share the same index if
+/// they are in distinct thread-pools.
+///
+/// See also: [the `ThreadPool::current_thread_index()` method].
+///
+/// [m]: struct.ThreadPool.html#method.current_thread_index
+///
+/// # Future compatibility note
+///
+/// Currently, every thread-pool (including the global
+/// thread-pool) has a fixed number of threads, but this may
+/// change in future Rayon versions (see [the `num_threads()` method
+/// for details][snt]). In that case, the index for a
+/// thread would not change during its lifetime, but thread
+/// indices may wind up being reused if threads are terminated and
+/// restarted.
+///
+/// [snt]: struct.ThreadPoolBuilder.html#method.num_threads
+#[inline]
+pub fn current_thread_index() -> Option<usize> {
+    unsafe {
+        let curr = WorkerThread::current().as_ref()?;
+        Some(curr.index())
+    }
+}
+
+/// If called from a Rayon worker thread, indicates whether that
+/// thread's local deque still has pending tasks. Otherwise, returns
+/// `None`. For more information, see [the
+/// `ThreadPool::current_thread_has_pending_tasks()` method][m].
+///
+/// [m]: struct.ThreadPool.html#method.current_thread_has_pending_tasks
+#[inline]
+pub fn current_thread_has_pending_tasks() -> Option<bool> {
+    unsafe {
+        let curr = WorkerThread::current().as_ref()?;
+        Some(!curr.local_deque_is_empty())
+    }
+}
+
+/// Cooperatively yields execution to Rayon.
+///
+/// If the current thread is part of a rayon thread pool, this looks for a
+/// single unit of pending work in the pool, then executes it. Completion of
+/// that work might include nested work or further work stealing.
+///
+/// This is similar to [`std::thread::yield_now()`], but does not literally make
+/// that call. If you are implementing a polling loop, you may want to also
+/// yield to the OS scheduler yourself if no Rayon work was found.
+///
+/// Returns `Some(Yield::Executed)` if anything was executed, `Some(Yield::Idle)` if
+/// nothing was available, or `None` if this thread is not part of any pool at all.
+pub fn yield_now() -> Option<Yield> {
+    unsafe {
+        let thread = WorkerThread::current().as_ref()?;
+        Some(thread.yield_now())
+    }
+}
+
+/// Cooperatively yields execution to local Rayon work.
+///
+/// If the current thread is part of a rayon thread pool, this looks for a
+/// single unit of pending work in this thread's queue, then executes it.
+/// Completion of that work might include nested work or further work stealing.
+///
+/// This is similar to [`yield_now()`], but does not steal from other threads.
+///
+/// Returns `Some(Yield::Executed)` if anything was executed, `Some(Yield::Idle)` if
+/// nothing was available, or `None` if this thread is not part of any pool at all.
+pub fn yield_local() -> Option<Yield> {
+    unsafe {
+        let thread = WorkerThread::current().as_ref()?;
+        Some(thread.yield_local())
+    }
+}
+
+/// Result of [`yield_now()`] or [`yield_local()`].
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Yield {
+    /// Work was found and executed.
+    Executed,
+    /// No available work was found.
+    Idle,
+}
diff --git a/crates/rayon-core/src/thread_pool/test.rs b/crates/rayon-core/src/thread_pool/test.rs
new file mode 100644
index 0000000..88b3628
--- /dev/null
+++ b/crates/rayon-core/src/thread_pool/test.rs
@@ -0,0 +1,418 @@
+#![cfg(test)]
+
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::mpsc::channel;
+use std::sync::{Arc, Mutex};
+
+use crate::{join, Scope, ScopeFifo, ThreadPool, ThreadPoolBuilder};
+
+#[test]
+#[should_panic(expected = "Hello, world!")]
+fn panic_propagate() {
+    let thread_pool = ThreadPoolBuilder::new().build().unwrap();
+    thread_pool.install(|| {
+        panic!("Hello, world!");
+    });
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn workers_stop() {
+    let registry;
+
+    {
+        // once we exit this block, thread-pool will be dropped
+        let thread_pool = ThreadPoolBuilder::new().num_threads(22).build().unwrap();
+        registry = thread_pool.install(|| {
+            // do some work on these threads
+            join_a_lot(22);
+
+            Arc::clone(&thread_pool.registry)
+        });
+        assert_eq!(registry.num_threads(), 22);
+    }
+
+    // once thread-pool is dropped, registry should terminate, which
+    // should lead to worker threads stopping
+    registry.wait_until_stopped();
+}
+
+fn join_a_lot(n: usize) {
+    if n > 0 {
+        join(|| join_a_lot(n - 1), || join_a_lot(n - 1));
+    }
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn sleeper_stop() {
+    use std::{thread, time};
+
+    let registry;
+
+    {
+        // once we exit this block, thread-pool will be dropped
+        let thread_pool = ThreadPoolBuilder::new().num_threads(22).build().unwrap();
+        registry = Arc::clone(&thread_pool.registry);
+
+        // Give time for at least some of the thread pool to fall asleep.
+        thread::sleep(time::Duration::from_secs(1));
+    }
+
+    // once thread-pool is dropped, registry should terminate, which
+    // should lead to worker threads stopping
+    registry.wait_until_stopped();
+}
+
+/// Creates a start/exit handler that increments an atomic counter.
+fn count_handler() -> (Arc<AtomicUsize>, impl Fn(usize)) {
+    let count = Arc::new(AtomicUsize::new(0));
+    (Arc::clone(&count), move |_| {
+        count.fetch_add(1, Ordering::SeqCst);
+    })
+}
+
+/// Wait until a counter is no longer shared, then return its value.
+fn wait_for_counter(mut counter: Arc<AtomicUsize>) -> usize {
+    use std::{thread, time};
+
+    for _ in 0..60 {
+        counter = match Arc::try_unwrap(counter) {
+            Ok(counter) => return counter.into_inner(),
+            Err(counter) => {
+                thread::sleep(time::Duration::from_secs(1));
+                counter
+            }
+        };
+    }
+
+    // That's too long!
+    panic!("Counter is still shared!");
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn failed_thread_stack() {
+    // Note: we first tried to force failure with a `usize::MAX` stack, but
+    // macOS and Windows weren't fazed, or at least didn't fail the way we want.
+    // They work with `isize::MAX`, but 32-bit platforms may feasibly allocate a
+    // 2GB stack, so it might not fail until the second thread.
+    let stack_size = ::std::isize::MAX as usize;
+
+    let (start_count, start_handler) = count_handler();
+    let (exit_count, exit_handler) = count_handler();
+    let builder = ThreadPoolBuilder::new()
+        .num_threads(10)
+        .stack_size(stack_size)
+        .start_handler(start_handler)
+        .exit_handler(exit_handler);
+
+    let pool = builder.build();
+    assert!(pool.is_err(), "thread stack should have failed!");
+
+    // With such a huge stack, 64-bit will probably fail on the first thread;
+    // 32-bit might manage the first 2GB, but certainly fail the second.
+    let start_count = wait_for_counter(start_count);
+    assert!(start_count <= 1);
+    assert_eq!(start_count, wait_for_counter(exit_count));
+}
+
+#[test]
+#[cfg_attr(not(panic = "unwind"), ignore)]
+fn panic_thread_name() {
+    let (start_count, start_handler) = count_handler();
+    let (exit_count, exit_handler) = count_handler();
+    let builder = ThreadPoolBuilder::new()
+        .num_threads(10)
+        .start_handler(start_handler)
+        .exit_handler(exit_handler)
+        .thread_name(|i| {
+            if i >= 5 {
+                panic!();
+            }
+            format!("panic_thread_name#{}", i)
+        });
+
+    let pool = crate::unwind::halt_unwinding(|| builder.build());
+    assert!(pool.is_err(), "thread-name panic should propagate!");
+
+    // Assuming they're created in order, threads 0 through 4 should have
+    // been started already, and then terminated by the panic.
+    assert_eq!(5, wait_for_counter(start_count));
+    assert_eq!(5, wait_for_counter(exit_count));
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn self_install() {
+    let pool = ThreadPoolBuilder::new().num_threads(1).build().unwrap();
+
+    // If the inner `install` blocks, then nothing will actually run it!
+    assert!(pool.install(|| pool.install(|| true)));
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn mutual_install() {
+    let pool1 = ThreadPoolBuilder::new().num_threads(1).build().unwrap();
+    let pool2 = ThreadPoolBuilder::new().num_threads(1).build().unwrap();
+
+    let ok = pool1.install(|| {
+        // This creates a dependency from `pool1` -> `pool2`
+        pool2.install(|| {
+            // This creates a dependency from `pool2` -> `pool1`
+            pool1.install(|| {
+                // If they blocked on inter-pool installs, there would be no
+                // threads left to run this!
+                true
+            })
+        })
+    });
+    assert!(ok);
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn mutual_install_sleepy() {
+    use std::{thread, time};
+
+    let pool1 = ThreadPoolBuilder::new().num_threads(1).build().unwrap();
+    let pool2 = ThreadPoolBuilder::new().num_threads(1).build().unwrap();
+
+    let ok = pool1.install(|| {
+        // This creates a dependency from `pool1` -> `pool2`
+        pool2.install(|| {
+            // Give `pool1` time to fall asleep.
+            thread::sleep(time::Duration::from_secs(1));
+
+            // This creates a dependency from `pool2` -> `pool1`
+            pool1.install(|| {
+                // Give `pool2` time to fall asleep.
+                thread::sleep(time::Duration::from_secs(1));
+
+                // If they blocked on inter-pool installs, there would be no
+                // threads left to run this!
+                true
+            })
+        })
+    });
+    assert!(ok);
+}
+
+#[test]
+#[allow(deprecated)]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn check_thread_pool_new() {
+    let pool = ThreadPool::new(crate::Configuration::new().num_threads(22)).unwrap();
+    assert_eq!(pool.current_num_threads(), 22);
+}
+
+macro_rules! test_scope_order {
+    ($scope:ident => $spawn:ident) => {{
+        let builder = ThreadPoolBuilder::new().num_threads(1);
+        let pool = builder.build().unwrap();
+        pool.install(|| {
+            let vec = Mutex::new(vec![]);
+            pool.$scope(|scope| {
+                let vec = &vec;
+                for i in 0..10 {
+                    scope.$spawn(move |_| {
+                        vec.lock().unwrap().push(i);
+                    });
+                }
+            });
+            vec.into_inner().unwrap()
+        })
+    }};
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn scope_lifo_order() {
+    let vec = test_scope_order!(scope => spawn);
+    let expected: Vec<i32> = (0..10).rev().collect(); // LIFO -> reversed
+    assert_eq!(vec, expected);
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn scope_fifo_order() {
+    let vec = test_scope_order!(scope_fifo => spawn_fifo);
+    let expected: Vec<i32> = (0..10).collect(); // FIFO -> natural order
+    assert_eq!(vec, expected);
+}
+
+macro_rules! test_spawn_order {
+    ($spawn:ident) => {{
+        let builder = ThreadPoolBuilder::new().num_threads(1);
+        let pool = &builder.build().unwrap();
+        let (tx, rx) = channel();
+        pool.install(move || {
+            for i in 0..10 {
+                let tx = tx.clone();
+                pool.$spawn(move || {
+                    tx.send(i).unwrap();
+                });
+            }
+        });
+        rx.iter().collect::<Vec<i32>>()
+    }};
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn spawn_lifo_order() {
+    let vec = test_spawn_order!(spawn);
+    let expected: Vec<i32> = (0..10).rev().collect(); // LIFO -> reversed
+    assert_eq!(vec, expected);
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn spawn_fifo_order() {
+    let vec = test_spawn_order!(spawn_fifo);
+    let expected: Vec<i32> = (0..10).collect(); // FIFO -> natural order
+    assert_eq!(vec, expected);
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn nested_scopes() {
+    // Create matching scopes for every thread pool.
+    fn nest<'scope, OP>(pools: &[ThreadPool], scopes: Vec<&Scope<'scope>>, op: OP)
+    where
+        OP: FnOnce(&[&Scope<'scope>]) + Send,
+    {
+        if let Some((pool, tail)) = pools.split_first() {
+            pool.scope(move |s| {
+                // This move reduces the reference lifetimes by variance to match s,
+                // but the actual scopes are still tied to the invariant 'scope.
+                let mut scopes = scopes;
+                scopes.push(s);
+                nest(tail, scopes, op)
+            })
+        } else {
+            (op)(&scopes)
+        }
+    }
+
+    let pools: Vec<_> = (0..10)
+        .map(|_| ThreadPoolBuilder::new().num_threads(1).build().unwrap())
+        .collect();
+
+    let counter = AtomicUsize::new(0);
+    nest(&pools, vec![], |scopes| {
+        for &s in scopes {
+            s.spawn(|_| {
+                // Our 'scope lets us borrow the counter in every pool.
+                counter.fetch_add(1, Ordering::Relaxed);
+            });
+        }
+    });
+    assert_eq!(counter.into_inner(), pools.len());
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn nested_fifo_scopes() {
+    // Create matching fifo scopes for every thread pool.
+    fn nest<'scope, OP>(pools: &[ThreadPool], scopes: Vec<&ScopeFifo<'scope>>, op: OP)
+    where
+        OP: FnOnce(&[&ScopeFifo<'scope>]) + Send,
+    {
+        if let Some((pool, tail)) = pools.split_first() {
+            pool.scope_fifo(move |s| {
+                // This move reduces the reference lifetimes by variance to match s,
+                // but the actual scopes are still tied to the invariant 'scope.
+                let mut scopes = scopes;
+                scopes.push(s);
+                nest(tail, scopes, op)
+            })
+        } else {
+            (op)(&scopes)
+        }
+    }
+
+    let pools: Vec<_> = (0..10)
+        .map(|_| ThreadPoolBuilder::new().num_threads(1).build().unwrap())
+        .collect();
+
+    let counter = AtomicUsize::new(0);
+    nest(&pools, vec![], |scopes| {
+        for &s in scopes {
+            s.spawn_fifo(|_| {
+                // Our 'scope lets us borrow the counter in every pool.
+                counter.fetch_add(1, Ordering::Relaxed);
+            });
+        }
+    });
+    assert_eq!(counter.into_inner(), pools.len());
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn in_place_scope_no_deadlock() {
+    let pool = ThreadPoolBuilder::new().num_threads(1).build().unwrap();
+    let (tx, rx) = channel();
+    let rx_ref = &rx;
+    pool.in_place_scope(move |s| {
+        // With regular scopes this closure would never run because this scope op
+        // itself would block the only worker thread.
+        s.spawn(move |_| {
+            tx.send(()).unwrap();
+        });
+        rx_ref.recv().unwrap();
+    });
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn in_place_scope_fifo_no_deadlock() {
+    let pool = ThreadPoolBuilder::new().num_threads(1).build().unwrap();
+    let (tx, rx) = channel();
+    let rx_ref = &rx;
+    pool.in_place_scope_fifo(move |s| {
+        // With regular scopes this closure would never run because this scope op
+        // itself would block the only worker thread.
+        s.spawn_fifo(move |_| {
+            tx.send(()).unwrap();
+        });
+        rx_ref.recv().unwrap();
+    });
+}
+
+#[test]
+fn yield_now_to_spawn() {
+    let (tx, rx) = channel();
+
+    // Queue a regular spawn.
+    crate::spawn(move || tx.send(22).unwrap());
+
+    // The single-threaded fallback mode (for wasm etc.) won't
+    // get a chance to run the spawn if we never yield to it.
+    crate::registry::in_worker(move |_, _| {
+        crate::yield_now();
+    });
+
+    // The spawn **must** have started by now, but we still might have to wait
+    // for it to finish if a different thread stole it first.
+    assert_eq!(22, rx.recv().unwrap());
+}
+
+#[test]
+fn yield_local_to_spawn() {
+    let (tx, rx) = channel();
+
+    // Queue a regular spawn.
+    crate::spawn(move || tx.send(22).unwrap());
+
+    // The single-threaded fallback mode (for wasm etc.) won't
+    // get a chance to run the spawn if we never yield to it.
+    crate::registry::in_worker(move |_, _| {
+        crate::yield_local();
+    });
+
+    // The spawn **must** have started by now, but we still might have to wait
+    // for it to finish if a different thread stole it first.
+    assert_eq!(22, rx.recv().unwrap());
+}
diff --git a/crates/rayon-core/src/unwind.rs b/crates/rayon-core/src/unwind.rs
new file mode 100644
index 0000000..9671fa5
--- /dev/null
+++ b/crates/rayon-core/src/unwind.rs
@@ -0,0 +1,31 @@
+//! Package up unwind recovery. Note that if you are in some sensitive
+//! place, you can use the `AbortIfPanic` helper to protect against
+//! accidental panics in the rayon code itself.
+
+use std::any::Any;
+use std::panic::{self, AssertUnwindSafe};
+use std::thread;
+
+/// Executes `f` and captures any panic, translating that panic into a
+/// `Err` result. The assumption is that any panic will be propagated
+/// later with `resume_unwinding`, and hence `f` can be treated as
+/// exception safe.
+pub(super) fn halt_unwinding<F, R>(func: F) -> thread::Result<R>
+where
+    F: FnOnce() -> R,
+{
+    panic::catch_unwind(AssertUnwindSafe(func))
+}
+
+pub(super) fn resume_unwinding(payload: Box<dyn Any + Send>) -> ! {
+    panic::resume_unwind(payload)
+}
+
+pub(super) struct AbortIfPanic;
+
+impl Drop for AbortIfPanic {
+    fn drop(&mut self) {
+        eprintln!("Rayon: detected unexpected panic; aborting");
+        ::std::process::abort();
+    }
+}
diff --git a/crates/rayon-core/tests/double_init_fail.rs b/crates/rayon-core/tests/double_init_fail.rs
new file mode 100644
index 0000000..1591530
--- /dev/null
+++ b/crates/rayon-core/tests/double_init_fail.rs
@@ -0,0 +1,15 @@
+use rayon_core::ThreadPoolBuilder;
+use std::error::Error;
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn double_init_fail() {
+    let result1 = ThreadPoolBuilder::new().build_global();
+    assert!(result1.is_ok());
+    let err = ThreadPoolBuilder::new().build_global().unwrap_err();
+    assert!(err.source().is_none());
+    assert_eq!(
+        err.to_string(),
+        "The global thread pool has already been initialized.",
+    );
+}
diff --git a/crates/rayon-core/tests/init_zero_threads.rs b/crates/rayon-core/tests/init_zero_threads.rs
new file mode 100644
index 0000000..3c1ad25
--- /dev/null
+++ b/crates/rayon-core/tests/init_zero_threads.rs
@@ -0,0 +1,10 @@
+use rayon_core::ThreadPoolBuilder;
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn init_zero_threads() {
+    ThreadPoolBuilder::new()
+        .num_threads(0)
+        .build_global()
+        .unwrap();
+}
diff --git a/crates/rayon-core/tests/scope_join.rs b/crates/rayon-core/tests/scope_join.rs
new file mode 100644
index 0000000..9d88133
--- /dev/null
+++ b/crates/rayon-core/tests/scope_join.rs
@@ -0,0 +1,45 @@
+/// Test that one can emulate join with `scope`:
+fn pseudo_join<F, G>(f: F, g: G)
+where
+    F: FnOnce() + Send,
+    G: FnOnce() + Send,
+{
+    rayon_core::scope(|s| {
+        s.spawn(|_| g());
+        f();
+    });
+}
+
+fn quick_sort<T: PartialOrd + Send>(v: &mut [T]) {
+    if v.len() <= 1 {
+        return;
+    }
+
+    let mid = partition(v);
+    let (lo, hi) = v.split_at_mut(mid);
+    pseudo_join(|| quick_sort(lo), || quick_sort(hi));
+}
+
+fn partition<T: PartialOrd + Send>(v: &mut [T]) -> usize {
+    let pivot = v.len() - 1;
+    let mut i = 0;
+    for j in 0..pivot {
+        if v[j] <= v[pivot] {
+            v.swap(i, j);
+            i += 1;
+        }
+    }
+    v.swap(i, pivot);
+    i
+}
+
+fn is_sorted<T: Send + Ord>(v: &[T]) -> bool {
+    (1..v.len()).all(|i| v[i - 1] <= v[i])
+}
+
+#[test]
+fn scope_join() {
+    let mut v: Vec<i32> = (0..256).rev().collect();
+    quick_sort(&mut v);
+    assert!(is_sorted(&v));
+}
diff --git a/crates/rayon-core/tests/scoped_threadpool.rs b/crates/rayon-core/tests/scoped_threadpool.rs
new file mode 100644
index 0000000..9321471
--- /dev/null
+++ b/crates/rayon-core/tests/scoped_threadpool.rs
@@ -0,0 +1,99 @@
+use crossbeam_utils::thread;
+use rayon_core::ThreadPoolBuilder;
+
+#[derive(PartialEq, Eq, Debug)]
+struct Local(i32);
+
+scoped_tls::scoped_thread_local!(static LOCAL: Local);
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn missing_scoped_tls() {
+    LOCAL.set(&Local(42), || {
+        let pool = ThreadPoolBuilder::new()
+            .build()
+            .expect("thread pool created");
+
+        // `LOCAL` is not set in the pool.
+        pool.install(|| {
+            assert!(!LOCAL.is_set());
+        });
+    });
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn spawn_scoped_tls_threadpool() {
+    LOCAL.set(&Local(42), || {
+        LOCAL.with(|x| {
+            thread::scope(|scope| {
+                let pool = ThreadPoolBuilder::new()
+                    .spawn_handler(move |thread| {
+                        scope
+                            .builder()
+                            .spawn(move |_| {
+                                // Borrow the same local value in the thread pool.
+                                LOCAL.set(x, || thread.run())
+                            })
+                            .map(|_| ())
+                    })
+                    .build()
+                    .expect("thread pool created");
+
+                // The pool matches our local value.
+                pool.install(|| {
+                    assert!(LOCAL.is_set());
+                    LOCAL.with(|y| {
+                        assert_eq!(x, y);
+                    });
+                });
+
+                // If we change our local value, the pool is not affected.
+                LOCAL.set(&Local(-1), || {
+                    pool.install(|| {
+                        assert!(LOCAL.is_set());
+                        LOCAL.with(|y| {
+                            assert_eq!(x, y);
+                        });
+                    });
+                });
+            })
+            .expect("scope threads ok");
+            // `thread::scope` will wait for the threads to exit before returning.
+        });
+    });
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn build_scoped_tls_threadpool() {
+    LOCAL.set(&Local(42), || {
+        LOCAL.with(|x| {
+            ThreadPoolBuilder::new()
+                .build_scoped(
+                    move |thread| LOCAL.set(x, || thread.run()),
+                    |pool| {
+                        // The pool matches our local value.
+                        pool.install(|| {
+                            assert!(LOCAL.is_set());
+                            LOCAL.with(|y| {
+                                assert_eq!(x, y);
+                            });
+                        });
+
+                        // If we change our local value, the pool is not affected.
+                        LOCAL.set(&Local(-1), || {
+                            pool.install(|| {
+                                assert!(LOCAL.is_set());
+                                LOCAL.with(|y| {
+                                    assert_eq!(x, y);
+                                });
+                            });
+                        });
+                    },
+                )
+                .expect("thread pool created");
+            // Internally, `std::thread::scope` will wait for the threads to exit before returning.
+        });
+    });
+}
diff --git a/crates/rayon-core/tests/simple_panic.rs b/crates/rayon-core/tests/simple_panic.rs
new file mode 100644
index 0000000..2564482
--- /dev/null
+++ b/crates/rayon-core/tests/simple_panic.rs
@@ -0,0 +1,7 @@
+use rayon_core::join;
+
+#[test]
+#[should_panic(expected = "should panic")]
+fn simple_panic() {
+    join(|| {}, || panic!("should panic"));
+}
diff --git a/crates/rayon-core/tests/stack_overflow_crash.rs b/crates/rayon-core/tests/stack_overflow_crash.rs
new file mode 100644
index 0000000..7dcde43
--- /dev/null
+++ b/crates/rayon-core/tests/stack_overflow_crash.rs
@@ -0,0 +1,97 @@
+use rayon_core::ThreadPoolBuilder;
+
+use std::env;
+use std::process::{Command, ExitStatus, Stdio};
+
+#[cfg(target_os = "linux")]
+use std::os::unix::process::ExitStatusExt;
+
+fn force_stack_overflow(depth: u32) {
+    let mut buffer = [0u8; 1024 * 1024];
+    std::hint::black_box(&mut buffer);
+    if depth > 0 {
+        force_stack_overflow(depth - 1);
+    }
+}
+
+#[cfg(unix)]
+fn disable_core() {
+    unsafe {
+        libc::setrlimit(
+            libc::RLIMIT_CORE,
+            &libc::rlimit {
+                rlim_cur: 0,
+                rlim_max: 0,
+            },
+        );
+    }
+}
+
+#[cfg(unix)]
+fn overflow_code() -> Option<i32> {
+    None
+}
+
+#[cfg(windows)]
+fn overflow_code() -> Option<i32> {
+    use std::os::windows::process::ExitStatusExt;
+
+    ExitStatus::from_raw(0xc00000fd /*STATUS_STACK_OVERFLOW*/).code()
+}
+
+#[test]
+#[cfg_attr(not(any(unix, windows)), ignore)]
+fn stack_overflow_crash() {
+    // First check that the recursive call actually causes a stack overflow,
+    // and does not get optimized away.
+    let status = run_ignored("run_with_small_stack");
+    assert!(!status.success());
+    #[cfg(any(unix, windows))]
+    assert_eq!(status.code(), overflow_code());
+    #[cfg(target_os = "linux")]
+    assert!(matches!(
+        status.signal(),
+        Some(libc::SIGABRT | libc::SIGSEGV)
+    ));
+
+    // Now run with a larger stack and verify correct operation.
+    let status = run_ignored("run_with_large_stack");
+    assert_eq!(status.code(), Some(0));
+    #[cfg(target_os = "linux")]
+    assert_eq!(status.signal(), None);
+}
+
+fn run_ignored(test: &str) -> ExitStatus {
+    Command::new(env::current_exe().unwrap())
+        .arg("--ignored")
+        .arg("--exact")
+        .arg(test)
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .status()
+        .unwrap()
+}
+
+#[test]
+#[ignore]
+fn run_with_small_stack() {
+    run_with_stack(8);
+}
+
+#[test]
+#[ignore]
+fn run_with_large_stack() {
+    run_with_stack(48);
+}
+
+fn run_with_stack(stack_size_in_mb: usize) {
+    let pool = ThreadPoolBuilder::new()
+        .stack_size(stack_size_in_mb * 1024 * 1024)
+        .build()
+        .unwrap();
+    pool.install(|| {
+        #[cfg(unix)]
+        disable_core();
+        force_stack_overflow(32);
+    });
+}
diff --git a/crates/rayon-core/tests/use_current_thread.rs b/crates/rayon-core/tests/use_current_thread.rs
new file mode 100644
index 0000000..ec801c9
--- /dev/null
+++ b/crates/rayon-core/tests/use_current_thread.rs
@@ -0,0 +1,57 @@
+use rayon_core::ThreadPoolBuilder;
+use std::sync::{Arc, Condvar, Mutex};
+use std::thread::{self, JoinHandle};
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn use_current_thread_basic() {
+    static JOIN_HANDLES: Mutex<Vec<JoinHandle<()>>> = Mutex::new(Vec::new());
+    let pool = ThreadPoolBuilder::new()
+        .num_threads(2)
+        .use_current_thread()
+        .spawn_handler(|builder| {
+            let handle = thread::Builder::new().spawn(|| builder.run())?;
+            JOIN_HANDLES.lock().unwrap().push(handle);
+            Ok(())
+        })
+        .build()
+        .unwrap();
+    assert_eq!(rayon_core::current_thread_index(), Some(0));
+    assert_eq!(
+        JOIN_HANDLES.lock().unwrap().len(),
+        1,
+        "Should only spawn one extra thread"
+    );
+
+    let another_pool = ThreadPoolBuilder::new()
+        .num_threads(2)
+        .use_current_thread()
+        .build();
+    assert!(
+        another_pool.is_err(),
+        "Should error if the thread is already part of a pool"
+    );
+
+    let pair = Arc::new((Mutex::new(false), Condvar::new()));
+    let pair2 = Arc::clone(&pair);
+    pool.spawn(move || {
+        assert_ne!(rayon_core::current_thread_index(), Some(0));
+        // This should execute even if the current thread is blocked, since we have two threads in
+        // the pool.
+        let &(ref started, ref condvar) = &*pair2;
+        *started.lock().unwrap() = true;
+        condvar.notify_one();
+    });
+
+    let _guard = pair
+        .1
+        .wait_while(pair.0.lock().unwrap(), |ran| !*ran)
+        .unwrap();
+    std::mem::drop(pool); // Drop the pool.
+
+    // Wait until all threads have actually exited. This is not really needed, other than to
+    // reduce noise of leak-checking tools.
+    for handle in std::mem::take(&mut *JOIN_HANDLES.lock().unwrap()) {
+        let _ = handle.join();
+    }
+}
diff --git a/crates/rayon/.cargo-checksum.json b/crates/rayon/.cargo-checksum.json
new file mode 100644
index 0000000..a6a3bf3
--- /dev/null
+++ b/crates/rayon/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"eeb8b2cf6665ad35f658a5788c9bd37f4886a01ad947ad665cce8199f0958781","FAQ.md":"e963b051f6295a2944ff5abec368c7da914b913e21049978c2ef0017294abf8f","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"0621878e61f0d0fda054bcbe02df75192c28bde1ecc8289cbd86aeba2dd72720","README.md":"d5a3ae90475558e39eb06be743ab77ebeb063a45e092df1bea9fcd9d0a66ba90","RELEASES.md":"105ce10e535624114a8fdd57654d4a8d19460546560a3705eb32768de5cb9c07","src/array.rs":"0e1524d222baa8b64f67689b0dea3115f3befb8cc3b5aee9ace169c57b2d29d2","src/collections/binary_heap.rs":"58e2590ff52fa2cfe7b5797fdc37902d0c111cca844aac21a4024add2f28a8db","src/collections/btree_map.rs":"d3094ed5c54620f81a86133f52e74164bae9f0137745eb66e6d31db2e942bcab","src/collections/btree_set.rs":"7de12e388d36cb2f8672bc3b68aed5b44d047c9f5fe262a7260584634299480f","src/collections/hash_map.rs":"cdaf1aa3bedf9bde591fcb323d64bee9366feb35fee6886bedb5fec8d0018564","src/collections/hash_set.rs":"685690108fc20eca2cf346e74e48d6c751f5ceb6028996366d49f1f1ad6051e0","src/collections/linked_list.rs":"bef7f32da49b55db76cfefa0afa4789a6979e08a69427e49bab2874967163fef","src/collections/mod.rs":"3978222720a2df20be7fd0856d8515b6f9fa40f6556662bd3c0726b1392970ca","src/collections/vec_deque.rs":"d14aa4edc858cd3469fff3597fc35ab83c27f3bdf66ede06d1dd25021f383109","src/compile_fail/cannot_collect_filtermap_data.rs":"f76e6727ae8bd0dc8fff5f4a79df3fc598daf5d7371bdf8b2e730fba4ba82719","src/compile_fail/cannot_zip_filtered_data.rs":"3588fcf72e804ea867ea525b6dfa7a3d45fe14e28088e849fa9ddb029acc8a7a","src/compile_fail/cell_par_iter.rs":"ebf8804993c103f9d8228aba0bb2a5f0aadb957de9f1eb59cf546dbace285201","src/compile_fail/mod.rs":"2c346e4b52941fe0ac2667eeb753c0c21a1f998a544bb9d9167f200caba0a7bb","src/compile_fail/must_use.rs":"42ae57ed7cb909fad8d079ce6e3742a92ca7f72a9cc209b149d1d88df568d757","src/compile_fail/no_send_par_iter.rs":"b241446439c659f35060df12ba91590ea4267f373ddc688e4ffc203321db24b3","src/compile_fail/rc_par_iter.rs":"938776b08612e35c85b99962024d54af5a8c87d45a050a76375d16ef6fe4299f","src/delegate.rs":"aad2a11998240fb7dd96bd054b588cac469df3b716b8dffb05239102b6507d05","src/iter/chain.rs":"f82a25577ca36bac93b5a13e75dcd70e8cee381b9baa5993dd645f0714fb9eb6","src/iter/chunks.rs":"9b901441bd8684782d4e50bf24c261bdf3392f576e7ab25b2b83be2fc9361545","src/iter/cloned.rs":"35e1c864f99f7bc93c258c4976d15ccfc1d04df969dc878fd03d35f6799377f7","src/iter/collect/consumer.rs":"5f9728fdf2db728a3ea37849c2fc43c417b221e580860be4dfc6cab526e57f8e","src/iter/collect/mod.rs":"ede28d59713c3291709a842cd54b17760008f6854a3982404eca973bdc3d2f23","src/iter/collect/test.rs":"9afcf4c6cf6bbfe22aed42e5bb5a0dcbd4d7c9b060d80d3b01fad665b46e4952","src/iter/copied.rs":"1a3457f3b0fb020593049b8b1f1be2f7a6684c2fcc66c02c911cb14e0a1943d7","src/iter/empty.rs":"3cb2d05721aab1a4d9e9c5813473e1646116c1ea570e26d9ac81e083688a0b7d","src/iter/enumerate.rs":"3204255723a93b3275cf0f208939de8960b13a9b13b8c2ba6b664e65da21cd87","src/iter/extend.rs":"211dcb0615e4a2eb00f85391c9c1c1a74754b998badc15b517c28a392595eab4","src/iter/filter.rs":"e48f317ee4d66dea6f19ac2607c6f764d20c023d847b66c6c01826e6a46f96ab","src/iter/filter_map.rs":"2530b726b27fe3a678a34722b1baf8e223a65a0770fa8ed5dca13786ea454580","src/iter/find.rs":"896ddb05b2fa7368462e0ff2a73982ced5f93266c0e0e8c27bb3fc4ec737af21","src/iter/find_first_last/mod.rs":"fa7d7692d81ecdbecb178606ad3b1b00c80e5e4159c57d34929b012b0bea0c82","src/iter/find_first_last/test.rs":"2052eb8b87c5a0a0d49a76c83d9d74f81be18aad52ceb1b06d7e209f4fefba94","src/iter/flat_map.rs":"4db54dcda5f1f916497d0162268e6cd554478bc7ea0190709cc7c73941a0e20f","src/iter/flat_map_iter.rs":"81886d1d71f4991963ec9b6d767d9ef391c9e84807d27f6135cd92a451dc1b32","src/iter/flatten.rs":"93407a8f44f4a265f47d7fe568508d6ef922597c4ca4558e8945cf1aacdd6b30","src/iter/flatten_iter.rs":"23cf3ddc25b6cad117932c4bac2e8b945c6b56626730fd3b1787f233495d15e6","src/iter/fold.rs":"874259b408d7f8cdc376d34276d37c1837950c035ff780de8281d1edf65ded9f","src/iter/fold_chunks.rs":"78c267cc341fa71206a587b548480038a7a9bbb29d341b43733515b34e4cec48","src/iter/fold_chunks_with.rs":"fc3a49dd6a2027ec8e0c78e459ed80da1185b365909694bf1395af12b22648a8","src/iter/for_each.rs":"7af0e21ed8479eec65831d1409f61a88d45a31764f2385ec759eda1a46d388b2","src/iter/from_par_iter.rs":"3f443878c95def492047b92ee2e3946179e21a8198330860927d5692611b4b79","src/iter/inspect.rs":"d502b6e435a44f34ba49dfe46aa809a1bad3dbaefa048540a98e3026437b1016","src/iter/interleave.rs":"3c6d82fe13b52e2ce5e1b3dba93c47f479ff44d232059cd88523b422c51dea96","src/iter/interleave_shortest.rs":"a2b1f31ea4cb29f4761d3724feddcf5a96e1f21fd623f95c85a8659294a6745a","src/iter/intersperse.rs":"6b5d3d826ed3499ba78f0ff07468d96a0e104c7ee142a2ced6be8143b43241a5","src/iter/len.rs":"1d890dffb912134402c4778b1635af713df23df8bd2a98890209926a936d8407","src/iter/map.rs":"f778f1bd0a71c962375d2ce886b40ac365afed4a032e2b9dd6c385712d3d75eb","src/iter/map_with.rs":"f83950016bb02addecec049fda73663861c80232477a7b89b7e8718291a4b481","src/iter/mod.rs":"db985d0c24bed56897bdc5771d4dc092a31eb42987380feba655b25ff415c01f","src/iter/multizip.rs":"10ec107f6673c9bc6d1d611e11b716c37e8601ab2f4257a460c4bc4962771347","src/iter/noop.rs":"5be6332ddfbb8fdbae1ffdb00983950a8b37a295bcb58e9a265b33806ee504e6","src/iter/once.rs":"fcebffc374dcdd206d13311dcc2e7d7a04da5687658b2f3ec3409f03ed12774b","src/iter/panic_fuse.rs":"2a4d43fa4e717629de7f69eb180f13db90ef95004975cfa20dcfaacc80435015","src/iter/par_bridge.rs":"ca6571ab851ca7794214a7b099c763dbf8aad676f42c0a885994f61f9dc27e6e","src/iter/plumbing/README.md":"da11d90143745b30efe99934bb5d8267d7b205c8096d0936ddb1bbba0b13ea17","src/iter/plumbing/mod.rs":"1156c55a15b651d161f463cb86b2f602f6246a3c7f8a82fb484db12aa6a60091","src/iter/positions.rs":"b7abfb59c12b6cceb5e539e85f9eca836054ae88225e16cfc0ba8e68177c7917","src/iter/product.rs":"eaddbf216b068d33cb92f594cf57522f6ea1e2d7699887a086484843bdec3585","src/iter/reduce.rs":"2f5d6e07d7c0de2360505fa5d9198c31fd43ba7e58a6ec40f79edec19319e502","src/iter/repeat.rs":"ed46b17b79d8569f9d67b50585b116ee0293e1d6c17c0dc683c66644f6a58fd5","src/iter/rev.rs":"c4c796d7cb6398e74bef043a080403acccdf70f6a4e74b242e530d1718969b8f","src/iter/skip.rs":"93d54e17316ae15ff3cc30ca7144cb448569b18ea967dd2cd8913ac6f1334390","src/iter/skip_any.rs":"e827e1658aea906ab1045533d97476a91886dc6c41ab1fe9b6147f90385e45b8","src/iter/skip_any_while.rs":"88e8f5aea16cde70ae41f5eb32749e955861a476766ff678b8bbfca96ed80803","src/iter/splitter.rs":"0024db04b4430c2a1e8c921cec86af641f612f877f3675b15df0da9122de5f00","src/iter/step_by.rs":"be7abe2c2fba252a1b69c8cf18adfe510036c30f8ee2994404c18ae15dde317e","src/iter/sum.rs":"073a886b8d6b0d7ca5621449a20e9980c90c6d39de56f074371fb075d9df2bed","src/iter/take.rs":"e47eeca1249553b0dfaf54cd8f99026be68db76b42f1f29e09c07a98c165c50a","src/iter/take_any.rs":"51f5b39c3fb608fcf7d7b35592a28d95250d9cbb28dbc13a0dc01d22aa0023f9","src/iter/take_any_while.rs":"8327c019b4047d567d8fdae975049c9bc1e4422dddffd3196b62c938d1f5e1fc","src/iter/test.rs":"385b65a973c2febbe97ab11cf7cc8ccf253a2c6dcd027213d56f1f63ddf59127","src/iter/try_fold.rs":"d4f40a00995273b8803031da4a4b139a5f462a174ef1d3c8ba54524b47ab8180","src/iter/try_reduce.rs":"12317a649f777e76e6ae610d205104d7946fbe45804fbf1caa0843118531baed","src/iter/try_reduce_with.rs":"9171563fc22110d7a359f19de7ca66a6823d8f712099d05d01560795781fdeec","src/iter/unzip.rs":"9a16ea1f3b3019a090b7189f6c42c75beb3537bc849bd4c51093120a907cea6b","src/iter/update.rs":"0362185a002cdda0e73b13237017ddc3d5e72390bba6cb2e2f021e947ed861dc","src/iter/while_some.rs":"a514891d7a07031354b48e377c239ff330d0955f184abc57a69d2a193e7fcb45","src/iter/zip.rs":"4d908f75a10b5e9b68d012bbba289f3e5e9d6a9570ce0f56fc1b4f9d96860499","src/iter/zip_eq.rs":"4c18d8f7a78e197a3268c9ef74d16690f8c960407c18bb63dc6905a2fe2bde62","src/lib.rs":"74e9dc639f5319859280c4d35575550420274769652f58fe78e47ab050f211a5","src/math.rs":"040e82a4ba7a6680eb65b65f4d1fc3dc477d902855d8651105b138ae2e71c8e8","src/option.rs":"00979a9bb8f42629f2b956a6cfbd286fc8a41ffbbec85f1b5d0f0da5615dac9c","src/par_either.rs":"afa4b04ba6ea1d37aed2d68eca44d7ba0d1d09ea985c9091540dd8d3c51974f1","src/prelude.rs":"b1af578abff57f9c8a285c39e3793125cf40d9901d0f2a4f0c5f1bb9252a08de","src/private.rs":"152f6d65ce4741616a1dec796b9442f78a018d38bb040f76c4cd85008333a3bb","src/range.rs":"93bd821b851d334a365211e14b60e0fc5052a7ee09e9a26ea7dd4f018c9bf7ae","src/range_inclusive.rs":"1f18ee155ab46e7398203163d49b4dfa87135e578de3d80e2641877c5b037126","src/result.rs":"0656f0000efcea10e571df90247925dfd00a0c2194043fcbc009711fb2f7af02","src/slice/chunks.rs":"2bf07a3522381e7747e40f787727747b62fbe1f1504eac6c383f0608a335ec91","src/slice/mergesort.rs":"effe59ecc40b330c364a3da868182b72b487025d9ba0256079f8a284b85a05ef","src/slice/mod.rs":"d293c9105edc3e51b11f873ac816f28232dd708120901ce3a518e03d5b748bcf","src/slice/quicksort.rs":"a7e5dd9f86e9292ccf6b2ca1668c93b8789eb85b7a9d3c9cb9fbe0ed49046e9b","src/slice/rchunks.rs":"23229976840da07e8fff6657ca626810ed380682719e4d1f0693ac08839e1b7c","src/slice/test.rs":"fca5e5e6bb5464c9332d14e7d963098ad9a072801ea508ae9eabf5d278b66bb2","src/split_producer.rs":"2b143e16bc6540792f861e215a86cfea7f4ee500d4faca2476d4165619eac90d","src/str.rs":"fe3fca9218fd17a265619551602001addf80f83187b086b3c65b4edd7857abd2","src/string.rs":"6691dd31264bd93a0528fc584585415c12f56cfb4baebbfd31ea2f1b21550f77","src/vec.rs":"c80653f3040c07e04fa293fa0359e1f8e7faad13d67899e78780e855b6f9f63a","tests/chars.rs":"5a2bef1cd8a7d1740a4e5403830da7bbdd584e97d602a07645c4986ee34c2ad3","tests/clones.rs":"1a8a4c053d2f5154c527cfb3396de2b3d1b3712e31a74f8b5e79862ea91359ea","tests/collect.rs":"3ae066cd89eacc9d171ad99ec73335e8040748370e3a3f46845d5af12ce30cc2","tests/cross-pool.rs":"d2ce3b9013f77c955aa02313b27436c5bf760ab0e6a1e7d768effae69b5bdbfe","tests/debug.rs":"187e3ef1ada63a91db117c02ca4b351d31e8eb6b891ca651bfa60a51afe4ea7c","tests/drain_vec.rs":"305ca40ba41ed3b459a334386cd742c66586d62aadfb624278aabdf10b872a12","tests/intersperse.rs":"bda4fb2179086e32c77c8293b9bb85d55509c282441837ba1849c2d3aa3186a7","tests/issue671-unzip.rs":"d5eb38d8a6d8f66fdf1c40293abbf58f3ac42b5acfc5dca62b02c7ace5bfc1a4","tests/issue671.rs":"52914cac517074deaedcb81bd76b867f0b99cc7b65c3e01cfe12dc9fe38c0266","tests/iter_panic.rs":"2ca857b37b740528b2e8395b479a409227383b46e0ed012286dcdd1330dacd70","tests/named-threads.rs":"9bd7ea27b4f6cf9e3b3486311747e15a3beb9b9d4e48f115d66ed8288ca19d38","tests/octillion.rs":"756d3789300d6eb4d5f7690937e06f87714b6b0a62ac812f72b622bb6974ccd2","tests/par_bridge_recursion.rs":"6e7030de6d97d1db1c335f676dd2a6348cde2873520df290c4a16bf949c06f00","tests/producer_split_at.rs":"fbb28da59e85e4c253cc314f35f113ced8db2981ceda9977145af540f9996837","tests/sort-panic-safe.rs":"2746cf3bca0c3ae4645ab124ae8027be9670aa749cfbb6f4205b095f6f1dbcad","tests/str.rs":"49059384999be57994841652718cc048389380741be5c493423f8bd2206e4453"},"package":"fa7237101a77a10773db45d62004a272517633fbcc3df19d96455ede1122e051"}
\ No newline at end of file
diff --git a/crates/rayon/Android.bp b/crates/rayon/Android.bp
new file mode 100644
index 0000000..7bcdb2b
--- /dev/null
+++ b/crates/rayon/Android.bp
@@ -0,0 +1,34 @@
+// This file is generated by cargo_embargo.
+// Do not modify this file because the changes will be overridden on upgrade.
+
+package {
+    default_applicable_licenses: ["external_rust_crates_rayon_license"],
+    default_team: "trendy_team_android_rust",
+}
+
+license {
+    name: "external_rust_crates_rayon_license",
+    visibility: [":__subpackages__"],
+    license_kinds: ["SPDX-license-identifier-Apache-2.0"],
+    license_text: ["LICENSE"],
+}
+
+rust_library {
+    name: "librayon",
+    host_supported: true,
+    crate_name: "rayon",
+    cargo_env_compat: true,
+    cargo_pkg_version: "1.8.1",
+    crate_root: "src/lib.rs",
+    edition: "2021",
+    rustlibs: [
+        "libeither",
+        "librayon_core",
+    ],
+    apex_available: [
+        "//apex_available:platform",
+        "//apex_available:anyapex",
+    ],
+    product_available: true,
+    vendor_available: true,
+}
diff --git a/crates/rayon/Cargo.lock b/crates/rayon/Cargo.lock
new file mode 100644
index 0000000..720a814
--- /dev/null
+++ b/crates/rayon/Cargo.lock
@@ -0,0 +1,298 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "bumpalo"
+version = "3.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c"
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "613f8cc01fe9cf1a3eb3d7f488fd2fa8388403e97039e2f73692932e291a770d"
+dependencies = [
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22ec99545bb0ed0ea7bb9b8e1e9122ea386ff8a48c0922e43f36d45ab09e0e80"
+
+[[package]]
+name = "either"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0"
+
+[[package]]
+name = "getrandom"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "js-sys"
+version = "0.3.70"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1868808506b929d7b0cfa8f75951347aa71bb21144b7791bae35d9bccfcfe37a"
+dependencies = [
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.158"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439"
+
+[[package]]
+name = "log"
+version = "0.4.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
+
+[[package]]
+name = "once_cell"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.86"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "rand_xorshift"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d25bf25ec5ae4a3f1b92f929810509a2f53d7dca2f50b794ff57e3face536c8f"
+dependencies = [
+ "rand_core",
+]
+
+[[package]]
+name = "rayon"
+version = "1.8.1"
+dependencies = [
+ "either",
+ "rand",
+ "rand_xorshift",
+ "rayon-core",
+ "wasm_sync",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2"
+dependencies = [
+ "crossbeam-deque",
+ "crossbeam-utils",
+ "wasm_sync",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.76"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "578e081a14e0cefc3279b0472138c513f37b41a08d5a3cca9b6e4e8ceb6cd525"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
+
+[[package]]
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.93"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a82edfc16a6c469f5f44dc7b571814045d60404b55a0ee849f9bcfa2e63dd9b5"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "wasm-bindgen-macro",
+]
+
+[[package]]
+name = "wasm-bindgen-backend"
+version = "0.2.93"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9de396da306523044d3302746f1208fa71d7532227f15e347e2d93e4145dd77b"
+dependencies = [
+ "bumpalo",
+ "log",
+ "once_cell",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.93"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "585c4c91a46b072c92e908d99cb1dcdf95c5218eeb6f3bf1efa991ee7a68cccf"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.93"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "afc340c74d9005395cf9dd098506f7f44e38f2b4a21c6aaacf9a105ea5e1e836"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-backend",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.93"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c62a0a307cb4a311d3a07867860911ca130c3494e8c2719593806c08bc5d0484"
+
+[[package]]
+name = "wasm_sync"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cff360cade7fec41ff0e9d2cda57fe58258c5f16def0e21302394659e6bbb0ea"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "web-sys"
+version = "0.3.70"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26fdeaafd9bd129f65e7c031593c24d62186301e0c72c8978fa1678be7d532c0"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.7.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
+dependencies = [
+ "byteorder",
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.7.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
diff --git a/crates/rayon/Cargo.toml b/crates/rayon/Cargo.toml
new file mode 100644
index 0000000..a1761f1
--- /dev/null
+++ b/crates/rayon/Cargo.toml
@@ -0,0 +1,61 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2021"
+rust-version = "1.63"
+name = "rayon"
+version = "1.8.1"
+authors = [
+    "Niko Matsakis <niko@alum.mit.edu>",
+    "Josh Stone <cuviper@gmail.com>",
+]
+exclude = [
+    "/ci/*",
+    "/scripts/*",
+    "/.github/*",
+]
+description = "Simple work-stealing parallelism for Rust"
+documentation = "https://docs.rs/rayon/"
+readme = "README.md"
+keywords = [
+    "parallel",
+    "thread",
+    "concurrency",
+    "join",
+    "performance",
+]
+categories = ["concurrency"]
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/rayon-rs/rayon"
+
+[dependencies.either]
+version = "1.0"
+default-features = false
+
+[dependencies.rayon-core]
+version = "1.12.1"
+
+[dependencies.wasm_sync]
+version = "0.1.0"
+optional = true
+
+[dev-dependencies.rand]
+version = "0.8"
+
+[dev-dependencies.rand_xorshift]
+version = "0.3"
+
+[features]
+web_spin_lock = [
+    "dep:wasm_sync",
+    "rayon-core/web_spin_lock",
+]
diff --git a/crates/rayon/FAQ.md b/crates/rayon/FAQ.md
new file mode 100644
index 0000000..745f033
--- /dev/null
+++ b/crates/rayon/FAQ.md
@@ -0,0 +1,227 @@
+# Rayon FAQ
+
+This file is for general questions that don't fit into the README or
+crate docs.
+
+## How many threads will Rayon spawn?
+
+By default, Rayon uses the same number of threads as the number of
+CPUs available. Note that on systems with hyperthreading enabled this
+equals the number of logical cores and not the physical ones.
+
+If you want to alter the number of threads spawned, you can set the
+environmental variable `RAYON_NUM_THREADS` to the desired number of
+threads or use the
+[`ThreadPoolBuilder::build_global` function](https://docs.rs/rayon/*/rayon/struct.ThreadPoolBuilder.html#method.build_global)
+method.
+
+## How does Rayon balance work between threads?
+
+Behind the scenes, Rayon uses a technique called **work stealing** to
+try and dynamically ascertain how much parallelism is available and
+exploit it. The idea is very simple: we always have a pool of worker
+threads available, waiting for some work to do. When you call `join`
+the first time, we shift over into that pool of threads. But if you
+call `join(a, b)` from a worker thread W, then W will place `b` into
+its work queue, advertising that this is work that other worker
+threads might help out with. W will then start executing `a`.
+
+While W is busy with `a`, other threads might come along and take `b`
+from its queue. That is called *stealing* `b`. Once `a` is done, W
+checks whether `b` was stolen by another thread and, if not, executes
+`b` itself. If W runs out of jobs in its own queue, it will look
+through the other threads' queues and try to steal work from them.
+
+This technique is not new. It was first introduced by the
+[Cilk project][cilk], done at MIT in the late nineties. The name Rayon
+is an homage to that work.
+
+[cilk]: http://supertech.csail.mit.edu/cilk/
+
+## What should I do if I use `Rc`, `Cell`, `RefCell` or other non-Send-and-Sync types?
+
+There are a number of non-threadsafe types in the Rust standard library,
+and if your code is using them, you will not be able to combine it
+with Rayon. Similarly, even if you don't have such types, but you try
+to have multiple closures mutating the same state, you will get
+compilation errors; for example, this function won't work, because
+both closures access `slice`:
+
+```rust
+/// Increment all values in slice.
+fn increment_all(slice: &mut [i32]) {
+    rayon::join(|| process(slice), || process(slice));
+}
+```
+
+The correct way to resolve such errors will depend on the case.  Some
+cases are easy: for example, uses of [`Rc`] can typically be replaced
+with [`Arc`], which is basically equivalent, but thread-safe.
+
+Code that uses `Cell` or `RefCell`, however, can be somewhat more complicated.
+If you can refactor your code to avoid those types, that is often the best way
+forward, but otherwise, you can try to replace those types with their threadsafe
+equivalents:
+
+- `Cell` -- replacement: `AtomicUsize`, `AtomicBool`, etc
+- `RefCell` -- replacement: `RwLock`, or perhaps `Mutex`
+
+However, you have to be wary! The parallel versions of these types
+have different atomicity guarantees. For example, with a `Cell`, you
+can increment a counter like so:
+
+```rust
+let value = counter.get();
+counter.set(value + 1);
+```
+
+But when you use the equivalent `AtomicUsize` methods, you are
+actually introducing a potential race condition (not a data race,
+technically, but it can be an awfully fine distinction):
+
+```rust
+let value = tscounter.load(Ordering::SeqCst);
+tscounter.store(value + 1, Ordering::SeqCst);
+```
+
+You can already see that the `AtomicUsize` API is a bit more complex,
+as it requires you to specify an
+[ordering](https://doc.rust-lang.org/std/sync/atomic/enum.Ordering.html). (I
+won't go into the details on ordering here, but suffice to say that if
+you don't know what an ordering is, and probably even if you do, you
+should use `Ordering::SeqCst`.) The danger in this parallel version of
+the counter is that other threads might be running at the same time
+and they could cause our counter to get out of sync. For example, if
+we have two threads, then they might both execute the "load" before
+either has a chance to execute the "store":
+
+```
+Thread 1                                          Thread 2
+let value = tscounter.load(Ordering::SeqCst);
+// value = X                                      let value = tscounter.load(Ordering::SeqCst);
+                                                  // value = X
+tscounter.store(value+1);                         tscounter.store(value+1);
+// tscounter = X+1                                // tscounter = X+1
+```
+
+Now even though we've had two increments, we'll only increase the
+counter by one!  Even though we've got no data race, this is still
+probably not the result we wanted. The problem here is that the `Cell`
+API doesn't make clear the scope of a "transaction" -- that is, the
+set of reads/writes that should occur atomically. In this case, we
+probably wanted the get/set to occur together.
+
+In fact, when using the `Atomic` types, you very rarely want a plain
+`load` or plain `store`. You probably want the more complex
+operations. A counter, for example, would use `fetch_add` to
+atomically load and increment the value in one step. Compare-and-swap
+is another popular building block.
+
+A similar problem can arise when converting `RefCell` to `RwLock`, but
+it is somewhat less likely, because the `RefCell` API does in fact
+have a notion of a transaction: the scope of the handle returned by
+`borrow` or `borrow_mut`. So if you convert each call to `borrow` to
+`read` (and `borrow_mut` to `write`), things will mostly work fine in
+a parallel setting, but there can still be changes in behavior.
+Consider using a `handle: RefCell<Vec<i32>>` like:
+
+```rust
+let len = handle.borrow().len();
+for i in 0 .. len {
+    let data = handle.borrow()[i];
+    println!("{}", data);
+}
+```
+
+In sequential code, we know that this loop is safe. But if we convert
+this to parallel code with an `RwLock`, we do not: this is because
+another thread could come along and do
+`handle.write().unwrap().pop()`, and thus change the length of the
+vector. In fact, even in *sequential* code, using very small borrow
+sections like this is an anti-pattern: you ought to be enclosing the
+entire transaction together, like so:
+
+```rust
+let vec = handle.borrow();
+let len = vec.len();
+for i in 0 .. len {
+    let data = vec[i];
+    println!("{}", data);
+}
+```
+
+Or, even better, using an iterator instead of indexing:
+
+```rust
+let vec = handle.borrow();
+for data in vec {
+    println!("{}", data);
+}
+```
+
+There are several reasons to prefer one borrow over many. The most
+obvious is that it is more efficient, since each borrow has to perform
+some safety checks. But it's also more reliable: suppose we modified
+the loop above to not just print things out, but also call into a
+helper function:
+
+```rust
+let vec = handle.borrow();
+for data in vec {
+    helper(...);
+}
+```
+
+And now suppose, independently, this helper fn evolved and had to pop
+something off of the vector:
+
+```rust
+fn helper(...) {
+    handle.borrow_mut().pop();
+}
+```
+
+Under the old model, where we did lots of small borrows, this would
+yield precisely the same error that we saw in parallel land using an
+`RwLock`: the length would be out of sync and our indexing would fail
+(note that in neither case would there be an actual *data race* and
+hence there would never be undefined behavior). But now that we use a
+single borrow, we'll see a borrow error instead, which is much easier
+to diagnose, since it occurs at the point of the `borrow_mut`, rather
+than downstream. Similarly, if we move to an `RwLock`, we'll find that
+the code either deadlocks (if the write is on the same thread as the
+read) or, if the write is on another thread, works just fine. Both of
+these are preferable to random failures in my experience.
+
+## But wait, isn't Rust supposed to free me from this kind of thinking?
+
+You might think that Rust is supposed to mean that you don't have to
+think about atomicity at all. In fact, if you avoid interior
+mutability (`Cell` and `RefCell` in a sequential setting, or
+`AtomicUsize`, `RwLock`, `Mutex`, et al. in parallel code), then this
+is true: the type system will basically guarantee that you don't have
+to think about atomicity at all. But often there are times when you
+WANT threads to interleave in the ways I showed above.
+
+Consider for example when you are conducting a search in parallel, say
+to find the shortest route. To avoid fruitless search, you might want
+to keep a cell with the shortest route you've found thus far.  This
+way, when you are searching down some path that's already longer than
+this shortest route, you can just stop and avoid wasted effort. In
+sequential land, you might model this "best result" as a shared value
+like `Rc<Cell<usize>>` (here the `usize` represents the length of best
+path found so far); in parallel land, you'd use a `Arc<AtomicUsize>`.
+Now we can make our search function look like:
+
+```rust
+fn search(path: &Path, cost_so_far: usize, best_cost: &Arc<AtomicUsize>) {
+    if cost_so_far >= best_cost.load(Ordering::SeqCst) {
+        return;
+    }
+    ...
+    best_cost.store(...);
+}
+```
+
+Now in this case, we really WANT to see results from other threads
+interjected into our execution!
diff --git a/crates/rayon/LICENSE b/crates/rayon/LICENSE
new file mode 120000
index 0000000..6b579aa
--- /dev/null
+++ b/crates/rayon/LICENSE
@@ -0,0 +1 @@
+LICENSE-APACHE
\ No newline at end of file
diff --git a/crates/rayon/LICENSE-APACHE b/crates/rayon/LICENSE-APACHE
new file mode 100644
index 0000000..16fe87b
--- /dev/null
+++ b/crates/rayon/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/crates/rayon/LICENSE-MIT b/crates/rayon/LICENSE-MIT
new file mode 100644
index 0000000..25597d5
--- /dev/null
+++ b/crates/rayon/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2010 The Rust Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/crates/rayon/METADATA b/crates/rayon/METADATA
new file mode 100644
index 0000000..4b10622
--- /dev/null
+++ b/crates/rayon/METADATA
@@ -0,0 +1,20 @@
+# This project was upgraded with external_updater.
+# Usage: tools/external_updater/updater.sh update external/rust/crates/rayon
+# For more info, check https://cs.android.com/android/platform/superproject/+/main:tools/external_updater/README.md
+
+name: "rayon"
+description: "Simple work-stealing parallelism for Rust"
+third_party {
+  license_type: NOTICE
+  last_upgrade_date {
+    year: 2024
+    month: 2
+    day: 6
+  }
+  homepage: "https://crates.io/crates/rayon"
+  identifier {
+    type: "Archive"
+    value: "https://static.crates.io/crates/rayon/rayon-1.8.1.crate"
+    version: "1.8.1"
+  }
+}
diff --git a/crates/rayon/MODULE_LICENSE_APACHE2 b/crates/rayon/MODULE_LICENSE_APACHE2
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/crates/rayon/MODULE_LICENSE_APACHE2
diff --git a/crates/rayon/README.md b/crates/rayon/README.md
new file mode 100644
index 0000000..082f6a4
--- /dev/null
+++ b/crates/rayon/README.md
@@ -0,0 +1,144 @@
+# Rayon
+
+[![Rayon crate](https://img.shields.io/crates/v/rayon.svg)](https://crates.io/crates/rayon)
+[![Rayon documentation](https://docs.rs/rayon/badge.svg)](https://docs.rs/rayon)
+![minimum rustc 1.63](https://img.shields.io/badge/rustc-1.63+-red.svg)
+[![build status](https://github.com/rayon-rs/rayon/workflows/master/badge.svg)](https://github.com/rayon-rs/rayon/actions)
+[![Join the chat at https://gitter.im/rayon-rs/Lobby](https://badges.gitter.im/rayon-rs/Lobby.svg)](https://gitter.im/rayon-rs/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+Rayon is a data-parallelism library for Rust. It is extremely
+lightweight and makes it easy to convert a sequential computation into
+a parallel one. It also guarantees data-race freedom. (You may also
+enjoy [this blog post][blog] about Rayon, which gives more background
+and details about how it works, or [this video][video], from the Rust
+Belt Rust conference.) Rayon is
+[available on crates.io](https://crates.io/crates/rayon), and
+[API documentation is available on docs.rs](https://docs.rs/rayon).
+
+[blog]: https://smallcultfollowing.com/babysteps/blog/2015/12/18/rayon-data-parallelism-in-rust/
+[video]: https://www.youtube.com/watch?v=gof_OEv71Aw
+
+## Parallel iterators and more
+
+Rayon makes it drop-dead simple to convert sequential iterators into
+parallel ones: usually, you just change your `foo.iter()` call into
+`foo.par_iter()`, and Rayon does the rest:
+
+```rust
+use rayon::prelude::*;
+fn sum_of_squares(input: &[i32]) -> i32 {
+    input.par_iter() // <-- just change that!
+         .map(|&i| i * i)
+         .sum()
+}
+```
+
+[Parallel iterators] take care of deciding how to divide your data
+into tasks; it will dynamically adapt for maximum performance. If you
+need more flexibility than that, Rayon also offers the [join] and
+[scope] functions, which let you create parallel tasks on your own.
+For even more control, you can create [custom threadpools] rather than
+using Rayon's default, global threadpool.
+
+[Parallel iterators]: https://docs.rs/rayon/*/rayon/iter/index.html
+[join]: https://docs.rs/rayon/*/rayon/fn.join.html
+[scope]: https://docs.rs/rayon/*/rayon/fn.scope.html
+[custom threadpools]: https://docs.rs/rayon/*/rayon/struct.ThreadPool.html
+
+## No data races
+
+You may have heard that parallel execution can produce all kinds of
+crazy bugs. Well, rest easy. Rayon's APIs all guarantee **data-race
+freedom**, which generally rules out most parallel bugs (though not
+all). In other words, **if your code compiles**, it typically does the
+same thing it did before.
+
+For the most, parallel iterators in particular are guaranteed to
+produce the same results as their sequential counterparts. One caveat:
+If your iterator has side effects (for example, sending methods to
+other threads through a [Rust channel] or writing to disk), those side
+effects may occur in a different order. Note also that, in some cases,
+parallel iterators offer alternative versions of the sequential
+iterator methods that can have higher performance.
+
+[Rust channel]: https://doc.rust-lang.org/std/sync/mpsc/fn.channel.html
+
+## Using Rayon
+
+[Rayon is available on crates.io](https://crates.io/crates/rayon). The
+recommended way to use it is to add a line into your Cargo.toml such
+as:
+
+```toml
+[dependencies]
+rayon = "1.8"
+```
+
+To use the parallel iterator APIs, a number of traits have to be in
+scope. The easiest way to bring those things into scope is to use the
+[Rayon prelude](https://docs.rs/rayon/*/rayon/prelude/index.html). In
+each module where you would like to use the parallel iterator APIs,
+just add:
+
+```rust
+use rayon::prelude::*;
+```
+
+Rayon currently requires `rustc 1.63.0` or greater.
+
+### Usage with WebAssembly
+
+Rayon can work on the Web via WebAssembly, but requires an adapter and
+some project configuration to account for differences between
+WebAssembly threads and threads on the other platforms.
+
+Check out the
+[wasm-bindgen-rayon](https://github.com/GoogleChromeLabs/wasm-bindgen-rayon)
+docs for more details.
+
+## Contribution
+
+Rayon is an open source project! If you'd like to contribute to Rayon,
+check out
+[the list of "help wanted" issues](https://github.com/rayon-rs/rayon/issues?q=is%3Aissue+is%3Aopen+label%3A%22help+wanted%22).
+These are all (or should be) issues that are suitable for getting
+started, and they generally include a detailed set of instructions for
+what to do. Please ask questions if anything is unclear! Also, check
+out the
+[Guide to Development](https://github.com/rayon-rs/rayon/wiki/Guide-to-Development)
+page on the wiki. Note that all code submitted in PRs to Rayon is
+assumed to
+[be licensed under Rayon's dual MIT/Apache 2.0 licensing](https://github.com/rayon-rs/rayon/blob/master/README.md#license).
+
+## Quick demo
+
+To see Rayon in action, check out the `rayon-demo` directory, which
+includes a number of demos of code using Rayon. For example, run this
+command to get a visualization of an N-body simulation. To see the
+effect of using Rayon, press `s` to run sequentially and `p` to run in
+parallel.
+
+```text
+> cd rayon-demo
+> cargo run --release -- nbody visualize
+```
+
+For more information on demos, try:
+
+```text
+> cd rayon-demo
+> cargo run --release -- --help
+```
+
+## Other questions?
+
+See [the Rayon FAQ][faq].
+
+[faq]: https://github.com/rayon-rs/rayon/blob/master/FAQ.md
+
+## License
+
+Rayon is distributed under the terms of both the MIT license and the
+Apache License (Version 2.0). See [LICENSE-APACHE](LICENSE-APACHE) and
+[LICENSE-MIT](LICENSE-MIT) for details. Opening a pull request is
+assumed to signal agreement with these licensing terms.
diff --git a/crates/rayon/RELEASES.md b/crates/rayon/RELEASES.md
new file mode 100644
index 0000000..9b71516
--- /dev/null
+++ b/crates/rayon/RELEASES.md
@@ -0,0 +1,883 @@
+# Release rayon 1.8.1 / rayon-core 1.12.1 (2024-01-17)
+
+- The new `"web_spin_lock"` crate feature makes mutexes spin on the main
+  browser thread in WebAssembly, rather than suffer an error about forbidden
+  `atomics.wait` if they were to block in that context. Thanks @RReverser!
+
+# Release rayon 1.8.0 / rayon-core 1.12.0 (2023-09-20)
+
+- The minimum supported `rustc` is now 1.63.
+- Added `ThreadPoolBuilder::use_current_thread` to use the builder thread as
+  part of the new thread pool. That thread does not run the pool's main loop,
+  but it may participate in work-stealing if it yields to rayon in some way.
+- Implemented `FromParallelIterator<T>` for `Box<[T]>`, `Rc<[T]>`, and
+  `Arc<[T]>`, as well as `FromParallelIterator<Box<str>>` and
+  `ParallelExtend<Box<str>>` for `String`.
+- `ThreadPoolBuilder::build_scoped` now uses `std::thread::scope`.
+- The default number of threads is now determined using
+  `std::thread::available_parallelism` instead of the `num_cpus` crate.
+- The internal logging facility has been removed, reducing bloat for all users.
+- Many smaller performance tweaks and documentation updates.
+
+# Release rayon 1.7.0 / rayon-core 1.11.0 (2023-03-03)
+
+- The minimum supported `rustc` is now 1.59.
+- Added a fallback when threading is unsupported.
+- The new `ParallelIterator::take_any` and `skip_any` methods work like
+  unordered `IndexedParallelIterator::take` and `skip`, counting items in
+  whatever order they are visited in parallel.
+- The new `ParallelIterator::take_any_while` and `skip_any_while` methods work
+  like unordered `Iterator::take_while` and `skip_while`, which previously had
+  no parallel equivalent. The "while" condition may be satisfied from anywhere
+  in the parallel iterator, affecting all future items regardless of position.
+- The new `yield_now` and `yield_local` functions will cooperatively yield
+  execution to Rayon, either trying to execute pending work from the entire
+  pool or from just the local deques of the current thread, respectively.
+
+# Release rayon-core 1.10.2 (2023-01-22)
+
+- Fixed miri-reported UB for SharedReadOnly tags protected by a call.
+
+# Release rayon 1.6.1 (2022-12-09)
+
+- Simplified `par_bridge` to only pull one item at a time from the iterator,
+  without batching. Threads that are waiting for iterator items will now block
+  appropriately rather than spinning CPU. (Thanks @njaard!)
+- Added protection against recursion in `par_bridge`, so iterators that also
+  invoke rayon will not cause mutex recursion deadlocks.
+
+# Release rayon-core 1.10.1 (2022-11-18)
+
+- Fixed a race condition with threads going to sleep while a broadcast starts.
+
+# Release rayon 1.6.0 / rayon-core 1.10.0 (2022-11-18)
+
+- The minimum supported `rustc` is now 1.56.
+- The new `IndexedParallelIterator::fold_chunks` and `fold_chunks_with` methods
+  work like `ParallelIterator::fold` and `fold_with` with fixed-size chunks of
+  items. This may be useful for predictable batching performance, without the
+  allocation overhead of `IndexedParallelIterator::chunks`.
+- New "broadcast" methods run a given function on all threads in the pool.
+  These run at a sort of reduced priority after each thread has exhausted their
+  local work queue, but before they attempt work-stealing from other threads.
+  - The global `broadcast` function and `ThreadPool::broadcast` method will
+    block until completion, returning a `Vec` of all return values.
+  - The global `spawn_broadcast` function and methods on `ThreadPool`, `Scope`,
+    and `ScopeFifo` will run detached, without blocking the current thread.
+- Panicking methods now use `#[track_caller]` to report the caller's location.
+- Fixed a truncated length in `vec::Drain` when given an empty range.
+
+## Contributors
+
+Thanks to all of the contributors for this release!
+
+- @cuviper
+- @idanmuze
+- @JoeyBF
+- @JustForFun88
+- @kianmeng
+- @kornelski
+- @ritchie46
+- @ryanrussell
+- @steffahn
+- @TheIronBorn
+- @willcrozi
+
+# Release rayon 1.5.3 (2022-05-13)
+
+- The new `ParallelSliceMut::par_sort_by_cached_key` is a stable sort that caches
+  the keys for each item -- a parallel version of `slice::sort_by_cached_key`.
+
+# Release rayon-core 1.9.3 (2022-05-13)
+
+- Fixed a use-after-free race in job notification.
+
+# Release rayon 1.5.2 / rayon-core 1.9.2 (2022-04-13)
+
+- The new `ParallelSlice::par_rchunks()` and `par_rchunks_exact()` iterate
+  slice chunks in reverse, aligned the against the end of the slice if the
+  length is not a perfect multiple of the chunk size. The new
+  `ParallelSliceMut::par_rchunks_mut()` and `par_rchunks_exact_mut()` are the
+  same for mutable slices.
+- The `ParallelIterator::try_*` methods now support `std::ops::ControlFlow` and
+  `std::task::Poll` items, mirroring the unstable `Try` implementations in the
+  standard library.
+- The `ParallelString` pattern-based methods now support `&[char]` patterns,
+  which match when any character in that slice is found in the string.
+- A soft limit is now enforced on the number of threads allowed in a single
+  thread pool, respecting internal bit limits that already existed. The current
+  maximum is publicly available from the new function `max_num_threads()`.
+- Fixed several Stacked Borrow and provenance issues found by `cargo miri`.
+
+## Contributors
+
+Thanks to all of the contributors for this release!
+
+- @atouchet
+- @bluss
+- @cuviper
+- @fzyzcjy
+- @nyanzebra
+- @paolobarbolini
+- @RReverser
+- @saethlin
+
+# Release rayon 1.5.1 / rayon-core 1.9.1 (2021-05-18)
+
+- The new `in_place_scope` and `in_place_scope_fifo` are variations of `scope`
+  and `scope_fifo`, running the initial non-`Send` callback directly on the
+  current thread, rather than moving execution to the thread pool.
+- With Rust 1.51 or later, arrays now implement `IntoParallelIterator`.
+- New implementations of `FromParallelIterator` make it possible to `collect`
+  complicated nestings of items.
+  - `FromParallelIterator<(A, B)> for (FromA, FromB)` works like `unzip`.
+  - `FromParallelIterator<Either<L, R>> for (A, B)` works like `partition_map`.
+- Type inference now works better with parallel `Range` and `RangeInclusive`.
+- The implementation of `FromParallelIterator` and `ParallelExtend` for
+  `Vec<T>` now uses `MaybeUninit<T>` internally to avoid creating any
+  references to uninitialized data.
+- `ParallelBridge` fixed a bug with threads missing available work.
+
+## Contributors
+
+Thanks to all of the contributors for this release!
+
+- @atouchet
+- @cuviper
+- @Hywan
+- @iRaiko
+- @Qwaz
+- @rocallahan
+
+# Release rayon 1.5.0 / rayon-core 1.9.0 (2020-10-21)
+
+- Update crossbeam dependencies.
+- The minimum supported `rustc` is now 1.36.
+
+## Contributors
+
+Thanks to all of the contributors for this release!
+
+- @cuviper
+- @mbrubeck
+- @mrksu
+
+# Release rayon 1.4.1 (2020-09-29)
+
+- The new `flat_map_iter` and `flatten_iter` methods can be used to flatten
+  sequential iterators, which may perform better in cases that don't need the
+  nested parallelism of `flat_map` and `flatten`.
+- The new `par_drain` method is a parallel version of the standard `drain` for
+  collections, removing items while keeping the original capacity. Collections
+  that implement this through `ParallelDrainRange` support draining items from
+  arbitrary index ranges, while `ParallelDrainFull` always drains everything.
+- The new `positions` method finds all items that match the given predicate and
+  returns their indices in a new iterator.
+
+# Release rayon-core 1.8.1 (2020-09-17)
+
+- Fixed an overflow panic on high-contention workloads, for a counter that was
+  meant to simply wrap. This panic only occurred with debug assertions enabled,
+  and was much more likely on 32-bit targets.
+
+# Release rayon 1.4.0 / rayon-core 1.8.0 (2020-08-24)
+
+- Implemented a new thread scheduler, [RFC 5], which uses targeted wakeups for
+  new work and for notifications of completed stolen work, reducing wasteful
+  CPU usage in idle threads.
+- Implemented `IntoParallelIterator for Range<char>` and `RangeInclusive<char>`
+  with the same iteration semantics as Rust 1.45.
+- Relaxed the lifetime requirements of the initial `scope` closure.
+
+[RFC 5]: https://github.com/rayon-rs/rfcs/pull/5
+
+## Contributors
+
+Thanks to all of the contributors for this release!
+
+- @CAD97
+- @cuviper
+- @kmaork
+- @nikomatsakis
+- @SuperFluffy
+
+
+# Release rayon 1.3.1 / rayon-core 1.7.1 (2020-06-15)
+
+- Fixed a use-after-free race in calls blocked between two rayon thread pools.
+- Collecting to an indexed `Vec` now drops any partial writes while unwinding,
+  rather than just leaking them. If dropping also panics, Rust will abort.
+  - Note: the old leaking behavior is considered _safe_, just not ideal.
+- The new `IndexedParallelIterator::step_by()` adapts an iterator to step
+  through items by the given count, like `Iterator::step_by()`.
+- The new `ParallelSlice::par_chunks_exact()` and mutable equivalent
+  `ParallelSliceMut::par_chunks_exact_mut()` ensure that the chunks always have
+  the exact length requested, leaving any remainder separate, like the slice
+  methods `chunks_exact()` and `chunks_exact_mut()`.
+
+## Contributors
+
+Thanks to all of the contributors for this release!
+
+- @adrian5
+- @bluss
+- @cuviper
+- @FlyingCanoe
+- @GuillaumeGomez
+- @matthiasbeyer
+- @picoHz
+- @zesterer
+
+
+# Release rayon 1.3.0 / rayon-core 1.7.0 (2019-12-21)
+
+- Tuples up to length 12 now implement `IntoParallelIterator`, creating a
+  `MultiZip` iterator that produces items as similarly-shaped tuples.
+- The `--cfg=rayon_unstable` supporting code for `rayon-futures` is removed.
+- The minimum supported `rustc` is now 1.31.
+
+## Contributors
+
+Thanks to all of the contributors for this release!
+
+- @cuviper
+- @c410-f3r
+- @silwol
+
+
+# Release rayon-futures 0.1.1 (2019-12-21)
+
+- `Send` bounds have been added for the `Item` and `Error` associated types on
+  all generic `F: Future` interfaces. While technically a breaking change, this
+  is a soundness fix, so we are not increasing the semantic version for this.
+- This crate is now deprecated, and the `--cfg=rayon_unstable` supporting code
+  will be removed in `rayon-core 1.7.0`. This only supported the now-obsolete
+  `Future` from `futures 0.1`, while support for `std::future::Future` is
+  expected to come directly in `rayon-core` -- although that is not ready yet.
+
+## Contributors
+
+Thanks to all of the contributors for this release!
+
+- @cuviper
+- @kornelski
+- @jClaireCodesStuff
+- @jwass
+- @seanchen1991
+
+
+# Release rayon 1.2.1 / rayon-core 1.6.1 (2019-11-20)
+
+- Update crossbeam dependencies.
+- Add top-level doc links for the iterator traits.
+- Document that the iterator traits are not object safe.
+
+## Contributors
+
+Thanks to all of the contributors for this release!
+
+- @cuviper
+- @dnaka91
+- @matklad
+- @nikomatsakis
+- @Qqwy
+- @vorner
+
+
+# Release rayon 1.2.0 / rayon-core 1.6.0 (2019-08-30)
+
+- The new `ParallelIterator::copied()` converts an iterator of references into
+  copied values, like `Iterator::copied()`.
+- `ParallelExtend` is now implemented for the unit `()`.
+- Internal updates were made to improve test determinism, reduce closure type
+  sizes, reduce task allocations, and update dependencies.
+- The minimum supported `rustc` is now 1.28.
+
+## Contributors
+
+Thanks to all of the contributors for this release!
+
+- @Aaron1011
+- @cuviper
+- @ralfbiedert
+
+
+# Release rayon 1.1.0 / rayon-core 1.5.0 (2019-06-12)
+
+- FIFO spawns are now supported using the new `spawn_fifo()` and `scope_fifo()`
+  global functions, and their corresponding `ThreadPool` methods.
+  - Normally when tasks are queued on a thread, the most recent is processed
+    first (LIFO) while other threads will steal the oldest (FIFO). With FIFO
+    spawns, those tasks are processed locally in FIFO order too.
+  - Regular spawns and other tasks like `join` are not affected.
+  - The `breadth_first` configuration flag, which globally approximated this
+    effect, is now deprecated.
+  - For more design details, please see [RFC 1].
+- `ThreadPoolBuilder` can now take a custom `spawn_handler` to control how
+  threads will be created in the pool.
+  - `ThreadPoolBuilder::build_scoped()` uses this to create a scoped thread
+    pool, where the threads are able to use non-static data.
+  - This may also be used to support threading in exotic environments, like
+    WebAssembly, which don't support the normal `std::thread`.
+- `ParallelIterator` has 3 new methods: `find_map_any()`, `find_map_first()`,
+  and `find_map_last()`, like `Iterator::find_map()` with ordering constraints.
+- The new `ParallelIterator::panic_fuse()` makes a parallel iterator halt as soon
+  as possible if any of its threads panic. Otherwise, the panic state is not
+  usually noticed until the iterator joins its parallel tasks back together.
+- `IntoParallelIterator` is now implemented for integral `RangeInclusive`.
+- Several internal `Folder`s now have optimized `consume_iter` implementations.
+- `rayon_core::current_thread_index()` is now re-exported in `rayon`.
+- The minimum `rustc` is now 1.26, following the update policy defined in [RFC 3].
+
+## Contributors
+
+Thanks to all of the contributors for this release!
+
+- @cuviper
+- @didroe
+- @GuillaumeGomez
+- @huonw
+- @janriemer
+- @kornelski
+- @nikomatsakis
+- @seanchen1991
+- @yegeun542
+
+[RFC 1]: https://github.com/rayon-rs/rfcs/blob/master/accepted/rfc0001-scope-scheduling.md
+[RFC 3]: https://github.com/rayon-rs/rfcs/blob/master/accepted/rfc0003-minimum-rustc.md
+
+
+# Release rayon 1.0.3 (2018-11-02)
+
+- `ParallelExtend` is now implemented for tuple pairs, enabling nested
+  `unzip()` and `partition_map()` operations.  For instance, `(A, (B, C))`
+  items can be unzipped into `(Vec<A>, (Vec<B>, Vec<C>))`.
+  - `ParallelExtend<(A, B)>` works like `unzip()`.
+  - `ParallelExtend<Either<A, B>>` works like `partition_map()`.
+- `ParallelIterator` now has a method `map_init()` which calls an `init`
+  function for a value to pair with items, like `map_with()` but dynamically
+  constructed.  That value type has no constraints, not even `Send` or `Sync`.
+  - The new `for_each_init()` is a variant of this for simple iteration.
+  - The new `try_for_each_init()` is a variant for fallible iteration.
+
+## Contributors
+
+Thanks to all of the contributors for this release!
+
+- @cuviper
+- @dan-zheng
+- @dholbert
+- @ignatenkobrain
+- @mdonoughe
+
+
+# Release rayon 1.0.2 / rayon-core 1.4.1 (2018-07-17)
+
+- The `ParallelBridge` trait with method `par_bridge()` makes it possible to
+  use any `Send`able `Iterator` in parallel!
+  - This trait has been added to `rayon::prelude`.
+  - It automatically implements internal synchronization and queueing to
+    spread the `Item`s across the thread pool.  Iteration order is not
+    preserved by this adaptor.
+  - "Native" Rayon iterators like `par_iter()` should still be preferred when
+    possible for better efficiency.
+- `ParallelString` now has additional methods for parity with `std` string
+  iterators: `par_char_indices()`, `par_bytes()`, `par_encode_utf16()`,
+  `par_matches()`, and `par_match_indices()`.
+- `ParallelIterator` now has fallible methods `try_fold()`, `try_reduce()`,
+  and `try_for_each`, plus `*_with()` variants of each, for automatically
+  short-circuiting iterators on `None` or `Err` values.  These are inspired by
+  `Iterator::try_fold()` and `try_for_each()` that were stabilized in Rust 1.27.
+- `Range<i128>` and `Range<u128>` are now supported with Rust 1.26 and later.
+- Small improvements have been made to the documentation.
+- `rayon-core` now only depends on `rand` for testing.
+- Rayon tests now work on stable Rust.
+
+## Contributors
+
+Thanks to all of the contributors for this release!
+
+- @AndyGauge
+- @cuviper
+- @ignatenkobrain
+- @LukasKalbertodt
+- @MajorBreakfast
+- @nikomatsakis
+- @paulkernfeld
+- @QuietMisdreavus
+
+
+# Release rayon 1.0.1 (2018-03-16)
+
+- Added more documentation for `rayon::iter::split()`.
+- Corrected links and typos in documentation.
+
+## Contributors
+
+Thanks to all of the contributors for this release!
+
+- @cuviper
+- @HadrienG2
+- @matthiasbeyer
+- @nikomatsakis
+
+
+# Release rayon 1.0.0 / rayon-core 1.4.0 (2018-02-15)
+
+- `ParallelIterator` added the `update` method which applies a function to
+  mutable references, inspired by `itertools`.
+- `IndexedParallelIterator` added the `chunks` method which yields vectors of
+  consecutive items from the base iterator, inspired by `itertools`.
+- `String` now implements `FromParallelIterator<Cow<str>>` and
+  `ParallelExtend<Cow<str>>`, inspired by `std`.
+- `()` now implements `FromParallelIterator<()>`, inspired by `std`.
+- The new `ThreadPoolBuilder` replaces and deprecates `Configuration`.
+  - Errors from initialization now have the concrete `ThreadPoolBuildError`
+    type, rather than `Box<Error>`, and this type implements `Send` and `Sync`.
+  - `ThreadPool::new` is deprecated in favor of `ThreadPoolBuilder::build`.
+  - `initialize` is deprecated in favor of `ThreadPoolBuilder::build_global`.
+- Examples have been added to most of the parallel iterator methods.
+- A lot of the documentation has been reorganized and extended.
+
+## Breaking changes
+
+- Rayon now requires rustc 1.13 or greater.
+- `IndexedParallelIterator::len` and `ParallelIterator::opt_len` now operate on
+  `&self` instead of `&mut self`.
+- `IndexedParallelIterator::collect_into` is now `collect_into_vec`.
+- `IndexedParallelIterator::unzip_into` is now `unzip_into_vecs`.
+- Rayon no longer exports the deprecated `Configuration` and `initialize` from
+  rayon-core.
+
+## Contributors
+
+Thanks to all of the contributors for this release!
+
+- @Bilkow
+- @cuviper
+- @Enet4
+- @ignatenkobrain
+- @iwillspeak
+- @jeehoonkang
+- @jwass
+- @Kerollmops
+- @KodrAus
+- @kornelski
+- @MaloJaffre
+- @nikomatsakis
+- @obv-mikhail
+- @oddg
+- @phimuemue
+- @stjepang
+- @tmccombs
+- bors[bot]
+
+
+# Release rayon 0.9.0 / rayon-core 1.3.0 / rayon-futures 0.1.0 (2017-11-09)
+
+- `Configuration` now has a `build` method.
+- `ParallelIterator` added `flatten` and `intersperse`, both inspired by
+  itertools.
+- `IndexedParallelIterator` added `interleave`, `interleave_shortest`, and
+  `zip_eq`, all inspired by itertools.
+- The new functions `iter::empty` and `once` create parallel iterators of
+  exactly zero or one item, like their `std` counterparts.
+- The new functions `iter::repeat` and `repeatn` create parallel iterators
+  repeating an item indefinitely or `n` times, respectively.
+- The new function `join_context` works like `join`, with an added `FnContext`
+  parameter that indicates whether the job was stolen.
+- `Either` (used by `ParallelIterator::partition_map`) is now re-exported from
+  the `either` crate, instead of defining our own type.
+  - `Either` also now implements `ParallelIterator`, `IndexedParallelIterator`,
+    and `ParallelExtend` when both of its `Left` and `Right` types do.
+- All public types now implement `Debug`.
+- Many of the parallel iterators now implement `Clone` where possible.
+- Much of the documentation has been extended. (but still could use more help!)
+- All rayon crates have improved metadata.
+- Rayon was evaluated in the Libz Blitz, leading to many of these improvements.
+- Rayon pull requests are now guarded by bors-ng.
+
+## Futures
+
+The `spawn_future()` method has been refactored into its own `rayon-futures`
+crate, now through a `ScopeFutureExt` trait for `ThreadPool` and `Scope`.  The
+supporting `rayon-core` APIs are still gated by `--cfg rayon_unstable`.
+
+## Breaking changes
+
+- Two breaking changes have been made to `rayon-core`, but since they're fixing
+  soundness bugs, we are considering these _minor_ changes for semver.
+  - `Scope::spawn` now requires `Send` for the closure.
+  - `ThreadPool::install` now requires `Send` for the return value.
+- The `iter::internal` module has been renamed to `iter::plumbing`, to hopefully
+  indicate that while these are low-level details, they're not really internal
+  or private to rayon.  The contents of that module are needed for third-parties
+  to implement new parallel iterators, and we'll treat them with normal semver
+  stability guarantees.
+- The function `rayon::iter::split` is no longer re-exported as `rayon::split`.
+
+## Contributors
+
+Thanks to all of the contributors for this release!
+
+- @AndyGauge
+- @ChristopherDavenport
+- @chrisvittal
+- @cuviper
+- @dns2utf8
+- @dtolnay
+- @frewsxcv
+- @gsquire
+- @Hittherhod
+- @jdr023
+- @laumann
+- @leodasvacas
+- @lvillani
+- @MajorBreakfast
+- @mamuleanu
+- @marmistrz
+- @mbrubeck
+- @mgattozzi
+- @nikomatsakis
+- @smt923
+- @stjepang
+- @tmccombs
+- @vishalsodani
+- bors[bot]
+
+
+# Release rayon 0.8.2 (2017-06-28)
+
+- `ParallelSliceMut` now has six parallel sorting methods with the same
+  variations as the standard library.
+  - `par_sort`, `par_sort_by`, and `par_sort_by_key` perform stable sorts in
+    parallel, using the default order, a custom comparator, or a key extraction
+    function, respectively.
+  - `par_sort_unstable`, `par_sort_unstable_by`, and `par_sort_unstable_by_key`
+    perform unstable sorts with the same comparison options.
+  - Thanks to @stjepang!
+
+
+# Release rayon 0.8.1 / rayon-core 1.2.0 (2017-06-14)
+
+- The following core APIs are being stabilized:
+  - `rayon::spawn()` -- spawns a task into the Rayon threadpool; as it
+    is contained in the global scope (rather than a user-created
+    scope), the task cannot capture anything from the current stack
+    frame.
+  - `ThreadPool::join()`, `ThreadPool::spawn()`, `ThreadPool::scope()`
+    -- convenience APIs for launching new work within a thread-pool.
+- The various iterator adapters are now tagged with `#[must_use]`
+- Parallel iterators now offer a `for_each_with` adapter, similar to
+  `map_with`.
+- We are adopting a new approach to handling the remaining unstable
+  APIs (which primarily pertain to futures integration). As awlays,
+  unstable APIs are intended for experimentation, but do not come with
+  any promise of compatibility (in other words, we might change them
+  in arbitrary ways in any release). Previously, we designated such
+  APIs using a Cargo feature "unstable". Now, we are using a regular
+  `#[cfg]` flag. This means that to see the unstable APIs, you must do
+  `RUSTFLAGS='--cfg rayon_unstable' cargo build`. This is
+  intentionally inconvenient; in particular, if you are a library,
+  then your clients must also modify their environment, signaling
+  their agreement to instability.
+
+
+# Release rayon 0.8.0 / rayon-core 1.1.0 (2017-06-13)
+
+## Rayon 0.8.0
+
+- Added the `map_with` and `fold_with` combinators, which help for
+  passing along state (like channels) that cannot be shared between
+  threads but which can be cloned on each thread split.
+- Added the `while_some` combinator, which helps for writing short-circuiting iterators.
+- Added support for "short-circuiting" collection: e.g., collecting
+  from an iterator producing `Option<T>` or `Result<T, E>` into a
+  `Option<Collection<T>>` or `Result<Collection<T>, E>`.
+- Support `FromParallelIterator` for `Cow`.
+- Removed the deprecated weight APIs.
+- Simplified the parallel iterator trait hierarchy by removing the
+  `BoundedParallelIterator` and `ExactParallelIterator` traits,
+  which were not serving much purpose.
+- Improved documentation.
+- Added some missing `Send` impls.
+- Fixed some small bugs.
+
+## Rayon-core 1.1.0
+
+- We now have more documentation.
+- Renamed the (unstable) methods `spawn_async` and
+  `spawn_future_async` -- which spawn tasks that cannot hold
+  references -- to simply `spawn` and `spawn_future`, respectively.
+- We are now using the coco library for our deque.
+- Individual threadpools can now be configured in "breadth-first"
+  mode, which causes them to execute spawned tasks in the reverse
+  order that they used to.  In some specific scenarios, this can be a
+  win (though it is not generally the right choice).
+- Added top-level functions:
+  - `current_thread_index`, for querying the index of the current worker thread within
+    its thread-pool (previously available as `thread_pool.current_thread_index()`);
+  - `current_thread_has_pending_tasks`, for querying whether the
+    current worker that has an empty task deque or not. This can be
+    useful when deciding whether to spawn a task.
+- The environment variables for controlling Rayon are now
+  `RAYON_NUM_THREADS` and `RAYON_LOG`. The older variables (e.g.,
+  `RAYON_RS_NUM_CPUS` are still supported but deprecated).
+
+## Rayon-demo
+
+- Added a new game-of-life benchmark.
+
+## Contributors
+
+Thanks to the following contributors:
+
+- @ChristopherDavenport
+- @SuperFluffy
+- @antoinewdg
+- @crazymykl
+- @cuviper
+- @glandium
+- @julian-seward1
+- @leodasvacas
+- @leshow
+- @lilianmoraru
+- @mschmo
+- @nikomatsakis
+- @stjepang
+
+
+# Release rayon 0.7.1 / rayon-core 1.0.2 (2017-05-30)
+
+This release is a targeted performance fix for #343, an issue where
+rayon threads could sometimes enter into a spin loop where they would
+be unable to make progress until they are pre-empted.
+
+
+# Release rayon 0.7 / rayon-core 1.0 (2017-04-06)
+
+This release marks the first step towards Rayon 1.0. **For best
+performance, it is important that all Rayon users update to at least
+Rayon 0.7.** This is because, as of Rayon 0.7, we have taken steps to
+ensure that, no matter how many versions of rayon are actively in use,
+there will only be a single global scheduler. This is achieved via the
+`rayon-core` crate, which is being released at version 1.0, and which
+encapsulates the core schedule APIs like `join()`. (Note: the
+`rayon-core` crate is, to some degree, an implementation detail, and
+not intended to be imported directly; it's entire API surface is
+mirrored through the rayon crate.)
+
+We have also done a lot of work reorganizing the API for Rayon 0.7 in
+preparation for 1.0. The names of iterator types have been changed and
+reorganized (but few users are expected to be naming those types
+explicitly anyhow). In addition, a number of parallel iterator methods
+have been adjusted to match those in the standard iterator traits more
+closely. See the "Breaking Changes" section below for
+details.
+
+Finally, Rayon 0.7 includes a number of new features and new parallel
+iterator methods. **As of this release, Rayon's parallel iterators
+have officially reached parity with sequential iterators** -- that is,
+every sequential iterator method that makes any sense in parallel is
+supported in some capacity.
+
+### New features and methods
+
+- The internal `Producer` trait now features `fold_with`, which enables
+  better performance for some parallel iterators.
+- Strings now support `par_split()` and `par_split_whitespace()`.
+- The `Configuration` API is expanded and simplified:
+    - `num_threads(0)` no longer triggers an error
+    - you can now supply a closure to name the Rayon threads that get created
+      by using `Configuration::thread_name`.
+    - you can now inject code when Rayon threads start up and finish
+    - you can now set a custom panic handler to handle panics in various odd situations
+- Threadpools are now able to more gracefully put threads to sleep when not needed.
+- Parallel iterators now support `find_first()`, `find_last()`, `position_first()`,
+  and `position_last()`.
+- Parallel iterators now support `rev()`, which primarily affects subsequent calls
+  to `enumerate()`.
+- The `scope()` API is now considered stable (and part of `rayon-core`).
+- There is now a useful `rayon::split` function for creating custom
+  Rayon parallel iterators.
+- Parallel iterators now allow you to customize the min/max number of
+  items to be processed in a given thread. This mechanism replaces the
+  older `weight` mechanism, which is deprecated.
+- `sum()` and friends now use the standard `Sum` traits
+
+### Breaking changes
+
+In the move towards 1.0, there have been a number of minor breaking changes:
+
+- Configuration setters like `Configuration::set_num_threads()` lost the `set_` prefix,
+  and hence become something like `Configuration::num_threads()`.
+- `Configuration` getters are removed
+- Iterator types have been shuffled around and exposed more consistently:
+    - combinator types live in `rayon::iter`, e.g. `rayon::iter::Filter`
+    - iterators over various types live in a module named after their type,
+      e.g. `rayon::slice::Windows`
+- When doing a `sum()` or `product()`, type annotations are needed for the result
+  since it is now possible to have the resulting sum be of a type other than the value
+  you are iterating over (this mirrors sequential iterators).
+
+### Experimental features
+
+Experimental features require the use of the `unstable` feature. Their
+APIs may change or disappear entirely in future releases (even minor
+releases) and hence they should be avoided for production code.
+
+- We now have (unstable) support for futures integration. You can use
+  `Scope::spawn_future` or `rayon::spawn_future_async()`.
+- There is now a `rayon::spawn_async()` function for using the Rayon
+  threadpool to run tasks that do not have references to the stack.
+
+### Contributors
+
+Thanks to the following people for their contributions to this release:
+
+- @Aaronepower
+- @ChristopherDavenport
+- @bluss
+- @cuviper
+- @froydnj
+- @gaurikholkar
+- @hniksic
+- @leodasvacas
+- @leshow
+- @martinhath
+- @mbrubeck
+- @nikomatsakis
+- @pegomes
+- @schuster
+- @torkleyy
+
+
+# Release 0.6 (2016-12-21)
+
+This release includes a lot of progress towards the goal of parity
+with the sequential iterator API, though there are still a few methods
+that are not yet complete. If you'd like to help with that effort,
+[check out the milestone](https://github.com/rayon-rs/rayon/issues?q=is%3Aopen+is%3Aissue+milestone%3A%22Parity+with+the+%60Iterator%60+trait%22)
+to see the remaining issues.
+
+**Announcement:** @cuviper has been added as a collaborator to the
+Rayon repository for all of his outstanding work on Rayon, which
+includes both internal refactoring and helping to shape the public
+API. Thanks @cuviper! Keep it up.
+
+- We now support `collect()` and not just `collect_with()`.
+  You can use `collect()` to build a number of collections,
+  including vectors, maps, and sets. Moreover, when building a vector
+  with `collect()`, you are no longer limited to exact parallel iterators.
+  Thanks @nikomatsakis, @cuviper!
+- We now support `skip()` and `take()` on parallel iterators.
+  Thanks @martinhath!
+- **Breaking change:** We now match the sequential APIs for `min()` and `max()`.
+  We also support `min_by_key()` and `max_by_key()`. Thanks @tapeinosyne!
+- **Breaking change:** The `mul()` method is now renamed to `product()`,
+  to match sequential iterators. Thanks @jonathandturner!
+- We now support parallel iterator over ranges on `u64` values. Thanks @cuviper!
+- We now offer a `par_chars()` method on strings for iterating over characters
+  in parallel. Thanks @cuviper!
+- We now have new demos: a traveling salesman problem solver as well as matrix
+  multiplication. Thanks @nikomatsakis, @edre!
+- We are now documenting our minimum rustc requirement (currently
+  v1.12.0).  We will attempt to maintain compatibility with rustc
+  stable v1.12.0 as long as it remains convenient, but if new features
+  are stabilized or added that would be helpful to Rayon, or there are
+  bug fixes that we need, we will bump to the most recent rustc. Thanks @cuviper!
+- The `reduce()` functionality now has better inlining.
+  Thanks @bluss!
+- The `join()` function now has some documentation. Thanks @gsquire!
+- The project source has now been fully run through rustfmt.
+  Thanks @ChristopherDavenport!
+- Exposed helper methods for accessing the current thread index.
+  Thanks @bholley!
+
+
+# Release 0.5 (2016-11-04)
+
+- **Breaking change:** The `reduce` method has been vastly
+  simplified, and `reduce_with_identity` has been deprecated.
+- **Breaking change:** The `fold` method has been changed. It used to
+  always reduce the values, but now instead it is a combinator that
+  returns a parallel iterator which can itself be reduced. See the
+  docs for more information.
+- The following parallel iterator combinators are now available (thanks @cuviper!):
+  - `find_any()`: similar to `find` on a sequential iterator,
+    but doesn't necessarily return the *first* matching item
+  - `position_any()`: similar to `position` on a sequential iterator,
+    but doesn't necessarily return the index of *first* matching item
+  - `any()`, `all()`: just like their sequential counterparts
+- The `count()` combinator is now available for parallel iterators.
+- We now build with older versions of rustc again (thanks @durango!),
+  as we removed a stray semicolon from `thread_local!`.
+- Various improvements to the (unstable) `scope()` API implementation.
+
+
+# Release 0.4.3 (2016-10-25)
+
+- Parallel iterators now offer an adaptive weight scheme,
+  which means that explicit weights should no longer
+  be necessary in most cases! Thanks @cuviper!
+  - We are considering removing weights or changing the weight mechanism
+    before 1.0. Examples of scenarios where you still need weights even
+    with this adaptive mechanism would be great. Join the discussion
+    at <https://github.com/rayon-rs/rayon/issues/111>.
+- New (unstable) scoped threads API, see `rayon::scope` for details.
+  - You will need to supply the [cargo feature] `unstable`.
+- The various demos and benchmarks have been consolidated into one
+  program, `rayon-demo`.
+- Optimizations in Rayon's inner workings. Thanks @emilio!
+- Update `num_cpus` to 1.0. Thanks @jamwt!
+- Various internal cleanup in the implementation and typo fixes.
+  Thanks @cuviper, @Eh2406, and @spacejam!
+
+[cargo feature]: https://doc.rust-lang.org/cargo/reference/features.html#the-features-section
+
+
+# Release 0.4.2 (2016-09-15)
+
+- Updated crates.io metadata.
+
+
+# Release 0.4.1 (2016-09-14)
+
+- New `chain` combinator for parallel iterators.
+- `Option`, `Result`, as well as many more collection types now have
+  parallel iterators.
+- New mergesort demo.
+- Misc fixes.
+
+Thanks to @cuviper, @edre, @jdanford, @frewsxcv for their contributions!
+
+
+# Release 0.4 (2016-05-16)
+
+- Make use of latest versions of catch-panic and various fixes to panic propagation.
+- Add new prime sieve demo.
+- Add `cloned()` and `inspect()` combinators.
+- Misc fixes for Rust RFC 1214.
+
+Thanks to @areilb1, @Amanieu, @SharplEr, and @cuviper for their contributions!
+
+
+# Release 0.3 (2016-02-23)
+
+- Expanded `par_iter` APIs now available:
+  - `into_par_iter` is now supported on vectors (taking ownership of the elements)
+- Panic handling is much improved:
+  - if you use the Nightly feature, experimental panic recovery is available
+  - otherwise, panics propagate out and poision the workpool
+- New `Configuration` object to control number of threads and other details
+- New demos and benchmarks
+  - try `cargo run --release -- visualize` in `demo/nbody` :)
+    - Note: a nightly compiler is required for this demo due to the
+      use of the `+=` syntax
+
+Thanks to @bjz, @cuviper, @Amanieu, and @willi-kappler for their contributions!
+
+
+# Release 0.2 and earlier
+
+No release notes were being kept at this time.
diff --git a/crates/rayon/TEST_MAPPING b/crates/rayon/TEST_MAPPING
new file mode 100644
index 0000000..55384f0
--- /dev/null
+++ b/crates/rayon/TEST_MAPPING
@@ -0,0 +1,20 @@
+// Generated by update_crate_tests.py for tests that depend on this crate.
+{
+  "imports": [
+    {
+      "path": "external/rust/crates/base64"
+    },
+    {
+      "path": "external/rust/crates/hashbrown"
+    },
+    {
+      "path": "external/rust/crates/tinytemplate"
+    },
+    {
+      "path": "external/rust/crates/tinyvec"
+    },
+    {
+      "path": "external/rust/crates/unicode-xid"
+    }
+  ]
+}
diff --git a/crates/rayon/cargo_embargo.json b/crates/rayon/cargo_embargo.json
new file mode 100644
index 0000000..cb908d7
--- /dev/null
+++ b/crates/rayon/cargo_embargo.json
@@ -0,0 +1,3 @@
+{
+  "run_cargo": false
+}
diff --git a/crates/rayon/src/array.rs b/crates/rayon/src/array.rs
new file mode 100644
index 0000000..32a5fdd
--- /dev/null
+++ b/crates/rayon/src/array.rs
@@ -0,0 +1,85 @@
+//! Parallel iterator types for [arrays] (`[T; N]`)
+//!
+//! You will rarely need to interact with this module directly unless you need
+//! to name one of the iterator types.
+//!
+//! [arrays]: https://doc.rust-lang.org/std/primitive.array.html
+
+use crate::iter::plumbing::*;
+use crate::iter::*;
+use crate::slice::{Iter, IterMut};
+use crate::vec::DrainProducer;
+use std::mem::ManuallyDrop;
+
+impl<'data, T: Sync + 'data, const N: usize> IntoParallelIterator for &'data [T; N] {
+    type Item = &'data T;
+    type Iter = Iter<'data, T>;
+
+    fn into_par_iter(self) -> Self::Iter {
+        <&[T]>::into_par_iter(self)
+    }
+}
+
+impl<'data, T: Send + 'data, const N: usize> IntoParallelIterator for &'data mut [T; N] {
+    type Item = &'data mut T;
+    type Iter = IterMut<'data, T>;
+
+    fn into_par_iter(self) -> Self::Iter {
+        <&mut [T]>::into_par_iter(self)
+    }
+}
+
+impl<T: Send, const N: usize> IntoParallelIterator for [T; N] {
+    type Item = T;
+    type Iter = IntoIter<T, N>;
+
+    fn into_par_iter(self) -> Self::Iter {
+        IntoIter { array: self }
+    }
+}
+
+/// Parallel iterator that moves out of an array.
+#[derive(Debug, Clone)]
+pub struct IntoIter<T: Send, const N: usize> {
+    array: [T; N],
+}
+
+impl<T: Send, const N: usize> ParallelIterator for IntoIter<T, N> {
+    type Item = T;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        Some(N)
+    }
+}
+
+impl<T: Send, const N: usize> IndexedParallelIterator for IntoIter<T, N> {
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn len(&self) -> usize {
+        N
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        unsafe {
+            // Drain every item, and then the local array can just fall out of scope.
+            let mut array = ManuallyDrop::new(self.array);
+            let producer = DrainProducer::new(array.as_mut_slice());
+            callback.callback(producer)
+        }
+    }
+}
diff --git a/crates/rayon/src/collections/binary_heap.rs b/crates/rayon/src/collections/binary_heap.rs
new file mode 100644
index 0000000..fa90312
--- /dev/null
+++ b/crates/rayon/src/collections/binary_heap.rs
@@ -0,0 +1,120 @@
+//! This module contains the parallel iterator types for heaps
+//! (`BinaryHeap<T>`). You will rarely need to interact with it directly
+//! unless you have need to name one of the iterator types.
+
+use std::collections::BinaryHeap;
+
+use crate::iter::plumbing::*;
+use crate::iter::*;
+
+use crate::vec;
+
+/// Parallel iterator over a binary heap
+#[derive(Debug, Clone)]
+pub struct IntoIter<T: Ord + Send> {
+    inner: vec::IntoIter<T>,
+}
+
+impl<T: Ord + Send> IntoParallelIterator for BinaryHeap<T> {
+    type Item = T;
+    type Iter = IntoIter<T>;
+
+    fn into_par_iter(self) -> Self::Iter {
+        IntoIter {
+            inner: Vec::from(self).into_par_iter(),
+        }
+    }
+}
+
+delegate_indexed_iterator! {
+    IntoIter<T> => T,
+    impl<T: Ord + Send>
+}
+
+/// Parallel iterator over an immutable reference to a binary heap
+#[derive(Debug)]
+pub struct Iter<'a, T: Ord + Sync> {
+    inner: vec::IntoIter<&'a T>,
+}
+
+impl<'a, T: Ord + Sync> Clone for Iter<'a, T> {
+    fn clone(&self) -> Self {
+        Iter {
+            inner: self.inner.clone(),
+        }
+    }
+}
+
+into_par_vec! {
+    &'a BinaryHeap<T> => Iter<'a, T>,
+    impl<'a, T: Ord + Sync>
+}
+
+delegate_indexed_iterator! {
+    Iter<'a, T> => &'a T,
+    impl<'a, T: Ord + Sync + 'a>
+}
+
+// `BinaryHeap` doesn't have a mutable `Iterator`
+
+/// Draining parallel iterator that moves out of a binary heap,
+/// but keeps the total capacity.
+#[derive(Debug)]
+pub struct Drain<'a, T: Ord + Send> {
+    heap: &'a mut BinaryHeap<T>,
+}
+
+impl<'a, T: Ord + Send> ParallelDrainFull for &'a mut BinaryHeap<T> {
+    type Iter = Drain<'a, T>;
+    type Item = T;
+
+    fn par_drain(self) -> Self::Iter {
+        Drain { heap: self }
+    }
+}
+
+impl<'a, T: Ord + Send> ParallelIterator for Drain<'a, T> {
+    type Item = T;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        Some(self.len())
+    }
+}
+
+impl<'a, T: Ord + Send> IndexedParallelIterator for Drain<'a, T> {
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn len(&self) -> usize {
+        self.heap.len()
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        super::DrainGuard::new(self.heap)
+            .par_drain(..)
+            .with_producer(callback)
+    }
+}
+
+impl<'a, T: Ord + Send> Drop for Drain<'a, T> {
+    fn drop(&mut self) {
+        if !self.heap.is_empty() {
+            // We must not have produced, so just call a normal drain to remove the items.
+            self.heap.drain();
+        }
+    }
+}
diff --git a/crates/rayon/src/collections/btree_map.rs b/crates/rayon/src/collections/btree_map.rs
new file mode 100644
index 0000000..12436dc
--- /dev/null
+++ b/crates/rayon/src/collections/btree_map.rs
@@ -0,0 +1,66 @@
+//! This module contains the parallel iterator types for B-Tree maps
+//! (`BTreeMap<K, V>`). You will rarely need to interact with it directly
+//! unless you have need to name one of the iterator types.
+
+use std::collections::BTreeMap;
+
+use crate::iter::plumbing::*;
+use crate::iter::*;
+
+use crate::vec;
+
+/// Parallel iterator over a B-Tree map
+#[derive(Debug)] // std doesn't Clone
+pub struct IntoIter<K: Ord + Send, V: Send> {
+    inner: vec::IntoIter<(K, V)>,
+}
+
+into_par_vec! {
+    BTreeMap<K, V> => IntoIter<K, V>,
+    impl<K: Ord + Send, V: Send>
+}
+
+delegate_iterator! {
+    IntoIter<K, V> => (K, V),
+    impl<K: Ord + Send, V: Send>
+}
+
+/// Parallel iterator over an immutable reference to a B-Tree map
+#[derive(Debug)]
+pub struct Iter<'a, K: Ord + Sync, V: Sync> {
+    inner: vec::IntoIter<(&'a K, &'a V)>,
+}
+
+impl<'a, K: Ord + Sync, V: Sync> Clone for Iter<'a, K, V> {
+    fn clone(&self) -> Self {
+        Iter {
+            inner: self.inner.clone(),
+        }
+    }
+}
+
+into_par_vec! {
+    &'a BTreeMap<K, V> => Iter<'a, K, V>,
+    impl<'a, K: Ord + Sync, V: Sync>
+}
+
+delegate_iterator! {
+    Iter<'a, K, V> => (&'a K, &'a V),
+    impl<'a, K: Ord + Sync + 'a, V: Sync + 'a>
+}
+
+/// Parallel iterator over a mutable reference to a B-Tree map
+#[derive(Debug)]
+pub struct IterMut<'a, K: Ord + Sync, V: Send> {
+    inner: vec::IntoIter<(&'a K, &'a mut V)>,
+}
+
+into_par_vec! {
+    &'a mut BTreeMap<K, V> => IterMut<'a, K, V>,
+    impl<'a, K: Ord + Sync, V: Send>
+}
+
+delegate_iterator! {
+    IterMut<'a, K, V> => (&'a K, &'a mut V),
+    impl<'a, K: Ord + Sync + 'a, V: Send + 'a>
+}
diff --git a/crates/rayon/src/collections/btree_set.rs b/crates/rayon/src/collections/btree_set.rs
new file mode 100644
index 0000000..061d37c
--- /dev/null
+++ b/crates/rayon/src/collections/btree_set.rs
@@ -0,0 +1,52 @@
+//! This module contains the parallel iterator types for B-Tree sets
+//! (`BTreeSet<T>`). You will rarely need to interact with it directly
+//! unless you have need to name one of the iterator types.
+
+use std::collections::BTreeSet;
+
+use crate::iter::plumbing::*;
+use crate::iter::*;
+
+use crate::vec;
+
+/// Parallel iterator over a B-Tree set
+#[derive(Debug)] // std doesn't Clone
+pub struct IntoIter<T: Ord + Send> {
+    inner: vec::IntoIter<T>,
+}
+
+into_par_vec! {
+    BTreeSet<T> => IntoIter<T>,
+    impl<T: Ord + Send>
+}
+
+delegate_iterator! {
+    IntoIter<T> => T,
+    impl<T: Ord + Send>
+}
+
+/// Parallel iterator over an immutable reference to a B-Tree set
+#[derive(Debug)]
+pub struct Iter<'a, T: Ord + Sync> {
+    inner: vec::IntoIter<&'a T>,
+}
+
+impl<'a, T: Ord + Sync + 'a> Clone for Iter<'a, T> {
+    fn clone(&self) -> Self {
+        Iter {
+            inner: self.inner.clone(),
+        }
+    }
+}
+
+into_par_vec! {
+    &'a BTreeSet<T> => Iter<'a, T>,
+    impl<'a, T: Ord + Sync>
+}
+
+delegate_iterator! {
+    Iter<'a, T> => &'a T,
+    impl<'a, T: Ord + Sync + 'a>
+}
+
+// `BTreeSet` doesn't have a mutable `Iterator`
diff --git a/crates/rayon/src/collections/hash_map.rs b/crates/rayon/src/collections/hash_map.rs
new file mode 100644
index 0000000..b657851
--- /dev/null
+++ b/crates/rayon/src/collections/hash_map.rs
@@ -0,0 +1,96 @@
+//! This module contains the parallel iterator types for hash maps
+//! (`HashMap<K, V>`). You will rarely need to interact with it directly
+//! unless you have need to name one of the iterator types.
+
+use std::collections::HashMap;
+use std::hash::{BuildHasher, Hash};
+use std::marker::PhantomData;
+
+use crate::iter::plumbing::*;
+use crate::iter::*;
+
+use crate::vec;
+
+/// Parallel iterator over a hash map
+#[derive(Debug)] // std doesn't Clone
+pub struct IntoIter<K: Hash + Eq + Send, V: Send> {
+    inner: vec::IntoIter<(K, V)>,
+}
+
+into_par_vec! {
+    HashMap<K, V, S> => IntoIter<K, V>,
+    impl<K: Hash + Eq + Send, V: Send, S: BuildHasher>
+}
+
+delegate_iterator! {
+    IntoIter<K, V> => (K, V),
+    impl<K: Hash + Eq + Send, V: Send>
+}
+
+/// Parallel iterator over an immutable reference to a hash map
+#[derive(Debug)]
+pub struct Iter<'a, K: Hash + Eq + Sync, V: Sync> {
+    inner: vec::IntoIter<(&'a K, &'a V)>,
+}
+
+impl<'a, K: Hash + Eq + Sync, V: Sync> Clone for Iter<'a, K, V> {
+    fn clone(&self) -> Self {
+        Iter {
+            inner: self.inner.clone(),
+        }
+    }
+}
+
+into_par_vec! {
+    &'a HashMap<K, V, S> => Iter<'a, K, V>,
+    impl<'a, K: Hash + Eq + Sync, V: Sync, S: BuildHasher>
+}
+
+delegate_iterator! {
+    Iter<'a, K, V> => (&'a K, &'a V),
+    impl<'a, K: Hash + Eq + Sync + 'a, V: Sync + 'a>
+}
+
+/// Parallel iterator over a mutable reference to a hash map
+#[derive(Debug)]
+pub struct IterMut<'a, K: Hash + Eq + Sync, V: Send> {
+    inner: vec::IntoIter<(&'a K, &'a mut V)>,
+}
+
+into_par_vec! {
+    &'a mut HashMap<K, V, S> => IterMut<'a, K, V>,
+    impl<'a, K: Hash + Eq + Sync, V: Send, S: BuildHasher>
+}
+
+delegate_iterator! {
+    IterMut<'a, K, V> => (&'a K, &'a mut V),
+    impl<'a, K: Hash + Eq + Sync + 'a, V: Send + 'a>
+}
+
+/// Draining parallel iterator that moves out of a hash map,
+/// but keeps the total capacity.
+#[derive(Debug)]
+pub struct Drain<'a, K: Hash + Eq + Send, V: Send> {
+    inner: vec::IntoIter<(K, V)>,
+    marker: PhantomData<&'a mut HashMap<K, V>>,
+}
+
+impl<'a, K: Hash + Eq + Send, V: Send, S: BuildHasher> ParallelDrainFull
+    for &'a mut HashMap<K, V, S>
+{
+    type Iter = Drain<'a, K, V>;
+    type Item = (K, V);
+
+    fn par_drain(self) -> Self::Iter {
+        let vec: Vec<_> = self.drain().collect();
+        Drain {
+            inner: vec.into_par_iter(),
+            marker: PhantomData,
+        }
+    }
+}
+
+delegate_iterator! {
+    Drain<'_, K, V> => (K, V),
+    impl<K: Hash + Eq + Send, V: Send>
+}
diff --git a/crates/rayon/src/collections/hash_set.rs b/crates/rayon/src/collections/hash_set.rs
new file mode 100644
index 0000000..b6ee1c1
--- /dev/null
+++ b/crates/rayon/src/collections/hash_set.rs
@@ -0,0 +1,80 @@
+//! This module contains the parallel iterator types for hash sets
+//! (`HashSet<T>`). You will rarely need to interact with it directly
+//! unless you have need to name one of the iterator types.
+
+use std::collections::HashSet;
+use std::hash::{BuildHasher, Hash};
+use std::marker::PhantomData;
+
+use crate::iter::plumbing::*;
+use crate::iter::*;
+
+use crate::vec;
+
+/// Parallel iterator over a hash set
+#[derive(Debug)] // std doesn't Clone
+pub struct IntoIter<T: Hash + Eq + Send> {
+    inner: vec::IntoIter<T>,
+}
+
+into_par_vec! {
+    HashSet<T, S> => IntoIter<T>,
+    impl<T: Hash + Eq + Send, S: BuildHasher>
+}
+
+delegate_iterator! {
+    IntoIter<T> => T,
+    impl<T: Hash + Eq + Send>
+}
+
+/// Parallel iterator over an immutable reference to a hash set
+#[derive(Debug)]
+pub struct Iter<'a, T: Hash + Eq + Sync> {
+    inner: vec::IntoIter<&'a T>,
+}
+
+impl<'a, T: Hash + Eq + Sync> Clone for Iter<'a, T> {
+    fn clone(&self) -> Self {
+        Iter {
+            inner: self.inner.clone(),
+        }
+    }
+}
+
+into_par_vec! {
+    &'a HashSet<T, S> => Iter<'a, T>,
+    impl<'a, T: Hash + Eq + Sync, S: BuildHasher>
+}
+
+delegate_iterator! {
+    Iter<'a, T> => &'a T,
+    impl<'a, T: Hash + Eq + Sync + 'a>
+}
+
+// `HashSet` doesn't have a mutable `Iterator`
+
+/// Draining parallel iterator that moves out of a hash set,
+/// but keeps the total capacity.
+#[derive(Debug)]
+pub struct Drain<'a, T: Hash + Eq + Send> {
+    inner: vec::IntoIter<T>,
+    marker: PhantomData<&'a mut HashSet<T>>,
+}
+
+impl<'a, T: Hash + Eq + Send, S: BuildHasher> ParallelDrainFull for &'a mut HashSet<T, S> {
+    type Iter = Drain<'a, T>;
+    type Item = T;
+
+    fn par_drain(self) -> Self::Iter {
+        let vec: Vec<_> = self.drain().collect();
+        Drain {
+            inner: vec.into_par_iter(),
+            marker: PhantomData,
+        }
+    }
+}
+
+delegate_iterator! {
+    Drain<'_, T> => T,
+    impl<T: Hash + Eq + Send>
+}
diff --git a/crates/rayon/src/collections/linked_list.rs b/crates/rayon/src/collections/linked_list.rs
new file mode 100644
index 0000000..bddd2b0
--- /dev/null
+++ b/crates/rayon/src/collections/linked_list.rs
@@ -0,0 +1,66 @@
+//! This module contains the parallel iterator types for linked lists
+//! (`LinkedList<T>`). You will rarely need to interact with it directly
+//! unless you have need to name one of the iterator types.
+
+use std::collections::LinkedList;
+
+use crate::iter::plumbing::*;
+use crate::iter::*;
+
+use crate::vec;
+
+/// Parallel iterator over a linked list
+#[derive(Debug, Clone)]
+pub struct IntoIter<T: Send> {
+    inner: vec::IntoIter<T>,
+}
+
+into_par_vec! {
+    LinkedList<T> => IntoIter<T>,
+    impl<T: Send>
+}
+
+delegate_iterator! {
+    IntoIter<T> => T,
+    impl<T: Send>
+}
+
+/// Parallel iterator over an immutable reference to a linked list
+#[derive(Debug)]
+pub struct Iter<'a, T: Sync> {
+    inner: vec::IntoIter<&'a T>,
+}
+
+impl<'a, T: Sync> Clone for Iter<'a, T> {
+    fn clone(&self) -> Self {
+        Iter {
+            inner: self.inner.clone(),
+        }
+    }
+}
+
+into_par_vec! {
+    &'a LinkedList<T> => Iter<'a, T>,
+    impl<'a, T: Sync>
+}
+
+delegate_iterator! {
+    Iter<'a, T> => &'a T,
+    impl<'a, T: Sync + 'a>
+}
+
+/// Parallel iterator over a mutable reference to a linked list
+#[derive(Debug)]
+pub struct IterMut<'a, T: Send> {
+    inner: vec::IntoIter<&'a mut T>,
+}
+
+into_par_vec! {
+    &'a mut LinkedList<T> => IterMut<'a, T>,
+    impl<'a, T: Send>
+}
+
+delegate_iterator! {
+    IterMut<'a, T> => &'a mut T,
+    impl<'a, T: Send + 'a>
+}
diff --git a/crates/rayon/src/collections/mod.rs b/crates/rayon/src/collections/mod.rs
new file mode 100644
index 0000000..3c99f32
--- /dev/null
+++ b/crates/rayon/src/collections/mod.rs
@@ -0,0 +1,84 @@
+//! Parallel iterator types for [standard collections][std::collections]
+//!
+//! You will rarely need to interact with this module directly unless you need
+//! to name one of the iterator types.
+//!
+//! [std::collections]: https://doc.rust-lang.org/stable/std/collections/
+
+/// Convert an iterable collection into a parallel iterator by first
+/// collecting into a temporary `Vec`, then iterating that.
+macro_rules! into_par_vec {
+    ($t:ty => $iter:ident<$($i:tt),*>, impl $($args:tt)*) => {
+        impl $($args)* IntoParallelIterator for $t {
+            type Item = <$t as IntoIterator>::Item;
+            type Iter = $iter<$($i),*>;
+
+            fn into_par_iter(self) -> Self::Iter {
+                use std::iter::FromIterator;
+                $iter { inner: Vec::from_iter(self).into_par_iter() }
+            }
+        }
+    };
+}
+
+pub mod binary_heap;
+pub mod btree_map;
+pub mod btree_set;
+pub mod hash_map;
+pub mod hash_set;
+pub mod linked_list;
+pub mod vec_deque;
+
+use self::drain_guard::DrainGuard;
+
+mod drain_guard {
+    use crate::iter::ParallelDrainRange;
+    use std::mem;
+    use std::ops::RangeBounds;
+
+    /// A proxy for draining a collection by converting to a `Vec` and back.
+    ///
+    /// This is used for draining `BinaryHeap` and `VecDeque`, which both have
+    /// zero-allocation conversions to/from `Vec`, though not zero-cost:
+    /// - `BinaryHeap` will heapify from `Vec`, but at least that will be empty.
+    /// - `VecDeque` has to shift items to offset 0 when converting to `Vec`.
+    #[allow(missing_debug_implementations)]
+    pub(super) struct DrainGuard<'a, T, C: From<Vec<T>>> {
+        collection: &'a mut C,
+        vec: Vec<T>,
+    }
+
+    impl<'a, T, C> DrainGuard<'a, T, C>
+    where
+        C: Default + From<Vec<T>>,
+        Vec<T>: From<C>,
+    {
+        pub(super) fn new(collection: &'a mut C) -> Self {
+            Self {
+                // Temporarily steal the inner `Vec` so we can drain in place.
+                vec: Vec::from(mem::take(collection)),
+                collection,
+            }
+        }
+    }
+
+    impl<'a, T, C: From<Vec<T>>> Drop for DrainGuard<'a, T, C> {
+        fn drop(&mut self) {
+            // Restore the collection from the `Vec` with its original capacity.
+            *self.collection = C::from(mem::take(&mut self.vec));
+        }
+    }
+
+    impl<'a, T, C> ParallelDrainRange<usize> for &'a mut DrainGuard<'_, T, C>
+    where
+        T: Send,
+        C: From<Vec<T>>,
+    {
+        type Iter = crate::vec::Drain<'a, T>;
+        type Item = T;
+
+        fn par_drain<R: RangeBounds<usize>>(self, range: R) -> Self::Iter {
+            self.vec.par_drain(range)
+        }
+    }
+}
diff --git a/crates/rayon/src/collections/vec_deque.rs b/crates/rayon/src/collections/vec_deque.rs
new file mode 100644
index 0000000..f87ce6b
--- /dev/null
+++ b/crates/rayon/src/collections/vec_deque.rs
@@ -0,0 +1,159 @@
+//! This module contains the parallel iterator types for double-ended queues
+//! (`VecDeque<T>`). You will rarely need to interact with it directly
+//! unless you have need to name one of the iterator types.
+
+use std::collections::VecDeque;
+use std::ops::{Range, RangeBounds};
+
+use crate::iter::plumbing::*;
+use crate::iter::*;
+use crate::math::simplify_range;
+
+use crate::slice;
+use crate::vec;
+
+/// Parallel iterator over a double-ended queue
+#[derive(Debug, Clone)]
+pub struct IntoIter<T: Send> {
+    inner: vec::IntoIter<T>,
+}
+
+impl<T: Send> IntoParallelIterator for VecDeque<T> {
+    type Item = T;
+    type Iter = IntoIter<T>;
+
+    fn into_par_iter(self) -> Self::Iter {
+        // NOTE: requires data movement if the deque doesn't start at offset 0.
+        let inner = Vec::from(self).into_par_iter();
+        IntoIter { inner }
+    }
+}
+
+delegate_indexed_iterator! {
+    IntoIter<T> => T,
+    impl<T: Send>
+}
+
+/// Parallel iterator over an immutable reference to a double-ended queue
+#[derive(Debug)]
+pub struct Iter<'a, T: Sync> {
+    inner: Chain<slice::Iter<'a, T>, slice::Iter<'a, T>>,
+}
+
+impl<'a, T: Sync> Clone for Iter<'a, T> {
+    fn clone(&self) -> Self {
+        Iter {
+            inner: self.inner.clone(),
+        }
+    }
+}
+
+impl<'a, T: Sync> IntoParallelIterator for &'a VecDeque<T> {
+    type Item = &'a T;
+    type Iter = Iter<'a, T>;
+
+    fn into_par_iter(self) -> Self::Iter {
+        let (a, b) = self.as_slices();
+        Iter {
+            inner: a.into_par_iter().chain(b),
+        }
+    }
+}
+
+delegate_indexed_iterator! {
+    Iter<'a, T> => &'a T,
+    impl<'a, T: Sync + 'a>
+}
+
+/// Parallel iterator over a mutable reference to a double-ended queue
+#[derive(Debug)]
+pub struct IterMut<'a, T: Send> {
+    inner: Chain<slice::IterMut<'a, T>, slice::IterMut<'a, T>>,
+}
+
+impl<'a, T: Send> IntoParallelIterator for &'a mut VecDeque<T> {
+    type Item = &'a mut T;
+    type Iter = IterMut<'a, T>;
+
+    fn into_par_iter(self) -> Self::Iter {
+        let (a, b) = self.as_mut_slices();
+        IterMut {
+            inner: a.into_par_iter().chain(b),
+        }
+    }
+}
+
+delegate_indexed_iterator! {
+    IterMut<'a, T> => &'a mut T,
+    impl<'a, T: Send + 'a>
+}
+
+/// Draining parallel iterator that moves a range out of a double-ended queue,
+/// but keeps the total capacity.
+#[derive(Debug)]
+pub struct Drain<'a, T: Send> {
+    deque: &'a mut VecDeque<T>,
+    range: Range<usize>,
+    orig_len: usize,
+}
+
+impl<'a, T: Send> ParallelDrainRange<usize> for &'a mut VecDeque<T> {
+    type Iter = Drain<'a, T>;
+    type Item = T;
+
+    fn par_drain<R: RangeBounds<usize>>(self, range: R) -> Self::Iter {
+        Drain {
+            orig_len: self.len(),
+            range: simplify_range(range, self.len()),
+            deque: self,
+        }
+    }
+}
+
+impl<'a, T: Send> ParallelIterator for Drain<'a, T> {
+    type Item = T;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        Some(self.len())
+    }
+}
+
+impl<'a, T: Send> IndexedParallelIterator for Drain<'a, T> {
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn len(&self) -> usize {
+        self.range.len()
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        // NOTE: requires data movement if the deque doesn't start at offset 0.
+        super::DrainGuard::new(self.deque)
+            .par_drain(self.range.clone())
+            .with_producer(callback)
+    }
+}
+
+impl<'a, T: Send> Drop for Drain<'a, T> {
+    fn drop(&mut self) {
+        if self.deque.len() != self.orig_len - self.range.len() {
+            // We must not have produced, so just call a normal drain to remove the items.
+            assert_eq!(self.deque.len(), self.orig_len);
+            self.deque.drain(self.range.clone());
+        }
+    }
+}
diff --git a/crates/rayon/src/compile_fail/cannot_collect_filtermap_data.rs b/crates/rayon/src/compile_fail/cannot_collect_filtermap_data.rs
new file mode 100644
index 0000000..bb62ce0
--- /dev/null
+++ b/crates/rayon/src/compile_fail/cannot_collect_filtermap_data.rs
@@ -0,0 +1,14 @@
+/*! ```compile_fail,E0599
+
+use rayon::prelude::*;
+
+// zip requires data of exact size, but filter yields only bounded
+// size, so check that we cannot apply it.
+
+let a: Vec<usize> = (0..1024).collect();
+let mut v = vec![];
+a.par_iter()
+    .filter_map(|&x| Some(x as f32))
+    .collect_into_vec(&mut v); //~ ERROR no method
+
+``` */
diff --git a/crates/rayon/src/compile_fail/cannot_zip_filtered_data.rs b/crates/rayon/src/compile_fail/cannot_zip_filtered_data.rs
new file mode 100644
index 0000000..54fd50d
--- /dev/null
+++ b/crates/rayon/src/compile_fail/cannot_zip_filtered_data.rs
@@ -0,0 +1,14 @@
+/*! ```compile_fail,E0277
+
+use rayon::prelude::*;
+
+// zip requires data of exact size, but filter yields only bounded
+// size, so check that we cannot apply it.
+
+let mut a: Vec<usize> = (0..1024).rev().collect();
+let b: Vec<usize> = (0..1024).collect();
+
+a.par_iter()
+    .zip(b.par_iter().filter(|&&x| x > 3)); //~ ERROR
+
+``` */
diff --git a/crates/rayon/src/compile_fail/cell_par_iter.rs b/crates/rayon/src/compile_fail/cell_par_iter.rs
new file mode 100644
index 0000000..98a1cf9
--- /dev/null
+++ b/crates/rayon/src/compile_fail/cell_par_iter.rs
@@ -0,0 +1,13 @@
+/*! ```compile_fail,E0277
+
+// Check that we can't use the par-iter API to access contents of a `Cell`.
+
+use rayon::prelude::*;
+use std::cell::Cell;
+
+let c = Cell::new(42_i32);
+(0_i32..1024).into_par_iter()
+    .map(|_| c.get()) //~ ERROR E0277
+    .min();
+
+``` */
diff --git a/crates/rayon/src/compile_fail/mod.rs b/crates/rayon/src/compile_fail/mod.rs
new file mode 100644
index 0000000..13209a4
--- /dev/null
+++ b/crates/rayon/src/compile_fail/mod.rs
@@ -0,0 +1,7 @@
+// These modules contain `compile_fail` doc tests.
+mod cannot_collect_filtermap_data;
+mod cannot_zip_filtered_data;
+mod cell_par_iter;
+mod must_use;
+mod no_send_par_iter;
+mod rc_par_iter;
diff --git a/crates/rayon/src/compile_fail/must_use.rs b/crates/rayon/src/compile_fail/must_use.rs
new file mode 100644
index 0000000..b4b3d77
--- /dev/null
+++ b/crates/rayon/src/compile_fail/must_use.rs
@@ -0,0 +1,69 @@
+// Check that we are flagged for ignoring `must_use` parallel adaptors.
+// (unfortunately there's no error code for `unused_must_use`)
+
+macro_rules! must_use {
+    ($( $name:ident #[$expr:meta] )*) => {$(
+        /// First sanity check that the expression is OK.
+        ///
+        /// ```
+        /// #![deny(unused_must_use)]
+        ///
+        /// use rayon::prelude::*;
+        ///
+        /// let v: Vec<_> = (0..100).map(Some).collect();
+        /// let _ =
+        #[$expr]
+        /// ```
+        ///
+        /// Now trigger the `must_use`.
+        ///
+        /// ```compile_fail
+        /// #![deny(unused_must_use)]
+        ///
+        /// use rayon::prelude::*;
+        ///
+        /// let v: Vec<_> = (0..100).map(Some).collect();
+        #[$expr]
+        /// ```
+        mod $name {}
+    )*}
+}
+
+must_use! {
+    step_by             /** v.par_iter().step_by(2); */
+    chain               /** v.par_iter().chain(&v); */
+    chunks              /** v.par_iter().chunks(2); */
+    fold_chunks         /** v.par_iter().fold_chunks(2, || 0, |x, _| x); */
+    fold_chunks_with    /** v.par_iter().fold_chunks_with(2, 0, |x, _| x); */
+    cloned              /** v.par_iter().cloned(); */
+    copied              /** v.par_iter().copied(); */
+    enumerate           /** v.par_iter().enumerate(); */
+    filter              /** v.par_iter().filter(|_| true); */
+    filter_map          /** v.par_iter().filter_map(|x| *x); */
+    flat_map            /** v.par_iter().flat_map(|x| *x); */
+    flat_map_iter       /** v.par_iter().flat_map_iter(|x| *x); */
+    flatten             /** v.par_iter().flatten(); */
+    flatten_iter        /** v.par_iter().flatten_iter(); */
+    fold                /** v.par_iter().fold(|| 0, |x, _| x); */
+    fold_with           /** v.par_iter().fold_with(0, |x, _| x); */
+    try_fold            /** v.par_iter().try_fold(|| 0, |x, _| Some(x)); */
+    try_fold_with       /** v.par_iter().try_fold_with(0, |x, _| Some(x)); */
+    inspect             /** v.par_iter().inspect(|_| {}); */
+    interleave          /** v.par_iter().interleave(&v); */
+    interleave_shortest /** v.par_iter().interleave_shortest(&v); */
+    intersperse         /** v.par_iter().intersperse(&None); */
+    map                 /** v.par_iter().map(|x| x); */
+    map_with            /** v.par_iter().map_with(0, |_, x| x); */
+    map_init            /** v.par_iter().map_init(|| 0, |_, x| x); */
+    panic_fuse          /** v.par_iter().panic_fuse(); */
+    positions           /** v.par_iter().positions(|_| true); */
+    rev                 /** v.par_iter().rev(); */
+    skip                /** v.par_iter().skip(1); */
+    take                /** v.par_iter().take(1); */
+    update              /** v.par_iter().update(|_| {}); */
+    while_some          /** v.par_iter().cloned().while_some(); */
+    with_max_len        /** v.par_iter().with_max_len(1); */
+    with_min_len        /** v.par_iter().with_min_len(1); */
+    zip                 /** v.par_iter().zip(&v); */
+    zip_eq              /** v.par_iter().zip_eq(&v); */
+}
diff --git a/crates/rayon/src/compile_fail/no_send_par_iter.rs b/crates/rayon/src/compile_fail/no_send_par_iter.rs
new file mode 100644
index 0000000..7573c03
--- /dev/null
+++ b/crates/rayon/src/compile_fail/no_send_par_iter.rs
@@ -0,0 +1,58 @@
+// Check that `!Send` types fail early.
+
+/** ```compile_fail,E0277
+
+use rayon::prelude::*;
+use std::ptr::null;
+
+#[derive(Copy, Clone)]
+struct NoSend(*const ());
+
+unsafe impl Sync for NoSend {}
+
+let x = Some(NoSend(null()));
+
+x.par_iter()
+    .map(|&x| x) //~ ERROR
+    .count(); //~ ERROR
+
+``` */
+mod map {}
+
+/** ```compile_fail,E0277
+
+use rayon::prelude::*;
+use std::ptr::null;
+
+#[derive(Copy, Clone)]
+struct NoSend(*const ());
+
+unsafe impl Sync for NoSend {}
+
+let x = Some(NoSend(null()));
+
+x.par_iter()
+    .filter_map(|&x| Some(x)) //~ ERROR
+    .count(); //~ ERROR
+
+``` */
+mod filter_map {}
+
+/** ```compile_fail,E0277
+
+use rayon::prelude::*;
+use std::ptr::null;
+
+#[derive(Copy, Clone)]
+struct NoSend(*const ());
+
+unsafe impl Sync for NoSend {}
+
+let x = Some(NoSend(null()));
+
+x.par_iter()
+    .cloned() //~ ERROR
+    .count(); //~ ERROR
+
+``` */
+mod cloned {}
diff --git a/crates/rayon/src/compile_fail/rc_par_iter.rs b/crates/rayon/src/compile_fail/rc_par_iter.rs
new file mode 100644
index 0000000..aca63e7
--- /dev/null
+++ b/crates/rayon/src/compile_fail/rc_par_iter.rs
@@ -0,0 +1,15 @@
+/*! ```compile_fail,E0599
+
+// Check that we can't use the par-iter API to access contents of an
+// `Rc`.
+
+use rayon::prelude::*;
+use std::rc::Rc;
+
+let x = vec![Rc::new(22), Rc::new(23)];
+let mut y = vec![];
+x.into_par_iter() //~ ERROR no method named `into_par_iter`
+    .map(|rc| *rc)
+    .collect_into_vec(&mut y);
+
+``` */
diff --git a/crates/rayon/src/delegate.rs b/crates/rayon/src/delegate.rs
new file mode 100644
index 0000000..2a6e331
--- /dev/null
+++ b/crates/rayon/src/delegate.rs
@@ -0,0 +1,109 @@
+//! Macros for delegating newtype iterators to inner types.
+
+// Note: these place `impl` bounds at the end, as token gobbling is the only way
+// I know how to consume an arbitrary list of constraints, with `$($args:tt)*`.
+
+/// Creates a parallel iterator implementation which simply wraps an inner type
+/// and delegates all methods inward.  The actual struct must already be
+/// declared with an `inner` field.
+///
+/// The implementation of `IntoParallelIterator` should be added separately.
+macro_rules! delegate_iterator {
+    ($iter:ty => $item:ty ,
+     impl $( $args:tt )*
+     ) => {
+        impl $( $args )* ParallelIterator for $iter {
+            type Item = $item;
+
+            fn drive_unindexed<C>(self, consumer: C) -> C::Result
+                where C: UnindexedConsumer<Self::Item>
+            {
+                self.inner.drive_unindexed(consumer)
+            }
+
+            fn opt_len(&self) -> Option<usize> {
+                self.inner.opt_len()
+            }
+        }
+    }
+}
+
+/// Creates an indexed parallel iterator implementation which simply wraps an
+/// inner type and delegates all methods inward.  The actual struct must already
+/// be declared with an `inner` field.
+macro_rules! delegate_indexed_iterator {
+    ($iter:ty => $item:ty ,
+     impl $( $args:tt )*
+     ) => {
+        delegate_iterator!{
+            $iter => $item ,
+            impl $( $args )*
+        }
+
+        impl $( $args )* IndexedParallelIterator for $iter {
+            fn drive<C>(self, consumer: C) -> C::Result
+                where C: Consumer<Self::Item>
+            {
+                self.inner.drive(consumer)
+            }
+
+            fn len(&self) -> usize {
+                self.inner.len()
+            }
+
+            fn with_producer<CB>(self, callback: CB) -> CB::Output
+                where CB: ProducerCallback<Self::Item>
+            {
+                self.inner.with_producer(callback)
+            }
+        }
+    }
+}
+
+#[test]
+fn unindexed_example() {
+    use crate::collections::btree_map::IntoIter;
+    use crate::iter::plumbing::*;
+    use crate::prelude::*;
+
+    use std::collections::BTreeMap;
+
+    struct MyIntoIter<T: Ord + Send, U: Send> {
+        inner: IntoIter<T, U>,
+    }
+
+    delegate_iterator! {
+        MyIntoIter<T, U> => (T, U),
+        impl<T: Ord + Send, U: Send>
+    }
+
+    let map = BTreeMap::from([(1, 'a'), (2, 'b'), (3, 'c')]);
+    let iter = MyIntoIter {
+        inner: map.into_par_iter(),
+    };
+    let vec: Vec<_> = iter.map(|(k, _)| k).collect();
+    assert_eq!(vec, &[1, 2, 3]);
+}
+
+#[test]
+fn indexed_example() {
+    use crate::iter::plumbing::*;
+    use crate::prelude::*;
+    use crate::vec::IntoIter;
+
+    struct MyIntoIter<T: Send> {
+        inner: IntoIter<T>,
+    }
+
+    delegate_indexed_iterator! {
+        MyIntoIter<T> => T,
+        impl<T: Send>
+    }
+
+    let iter = MyIntoIter {
+        inner: vec![1, 2, 3].into_par_iter(),
+    };
+    let mut vec = vec![];
+    iter.collect_into_vec(&mut vec);
+    assert_eq!(vec, &[1, 2, 3]);
+}
diff --git a/crates/rayon/src/iter/chain.rs b/crates/rayon/src/iter/chain.rs
new file mode 100644
index 0000000..48fce07
--- /dev/null
+++ b/crates/rayon/src/iter/chain.rs
@@ -0,0 +1,268 @@
+use super::plumbing::*;
+use super::*;
+use rayon_core::join;
+use std::cmp;
+use std::iter;
+
+/// `Chain` is an iterator that joins `b` after `a` in one continuous iterator.
+/// This struct is created by the [`chain()`] method on [`ParallelIterator`]
+///
+/// [`chain()`]: trait.ParallelIterator.html#method.chain
+/// [`ParallelIterator`]: trait.ParallelIterator.html
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Debug, Clone)]
+pub struct Chain<A, B>
+where
+    A: ParallelIterator,
+    B: ParallelIterator<Item = A::Item>,
+{
+    a: A,
+    b: B,
+}
+
+impl<A, B> Chain<A, B>
+where
+    A: ParallelIterator,
+    B: ParallelIterator<Item = A::Item>,
+{
+    /// Creates a new `Chain` iterator.
+    pub(super) fn new(a: A, b: B) -> Self {
+        Chain { a, b }
+    }
+}
+
+impl<A, B> ParallelIterator for Chain<A, B>
+where
+    A: ParallelIterator,
+    B: ParallelIterator<Item = A::Item>,
+{
+    type Item = A::Item;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        let Chain { a, b } = self;
+
+        // If we returned a value from our own `opt_len`, then the collect consumer in particular
+        // will balk at being treated like an actual `UnindexedConsumer`.  But when we do know the
+        // length, we can use `Consumer::split_at` instead, and this is still harmless for other
+        // truly-unindexed consumers too.
+        let (left, right, reducer) = if let Some(len) = a.opt_len() {
+            consumer.split_at(len)
+        } else {
+            let reducer = consumer.to_reducer();
+            (consumer.split_off_left(), consumer, reducer)
+        };
+
+        let (a, b) = join(|| a.drive_unindexed(left), || b.drive_unindexed(right));
+        reducer.reduce(a, b)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        self.a.opt_len()?.checked_add(self.b.opt_len()?)
+    }
+}
+
+impl<A, B> IndexedParallelIterator for Chain<A, B>
+where
+    A: IndexedParallelIterator,
+    B: IndexedParallelIterator<Item = A::Item>,
+{
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        let Chain { a, b } = self;
+        let (left, right, reducer) = consumer.split_at(a.len());
+        let (a, b) = join(|| a.drive(left), || b.drive(right));
+        reducer.reduce(a, b)
+    }
+
+    fn len(&self) -> usize {
+        self.a.len().checked_add(self.b.len()).expect("overflow")
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        let a_len = self.a.len();
+        return self.a.with_producer(CallbackA {
+            callback,
+            a_len,
+            b: self.b,
+        });
+
+        struct CallbackA<CB, B> {
+            callback: CB,
+            a_len: usize,
+            b: B,
+        }
+
+        impl<CB, B> ProducerCallback<B::Item> for CallbackA<CB, B>
+        where
+            B: IndexedParallelIterator,
+            CB: ProducerCallback<B::Item>,
+        {
+            type Output = CB::Output;
+
+            fn callback<A>(self, a_producer: A) -> Self::Output
+            where
+                A: Producer<Item = B::Item>,
+            {
+                self.b.with_producer(CallbackB {
+                    callback: self.callback,
+                    a_len: self.a_len,
+                    a_producer,
+                })
+            }
+        }
+
+        struct CallbackB<CB, A> {
+            callback: CB,
+            a_len: usize,
+            a_producer: A,
+        }
+
+        impl<CB, A> ProducerCallback<A::Item> for CallbackB<CB, A>
+        where
+            A: Producer,
+            CB: ProducerCallback<A::Item>,
+        {
+            type Output = CB::Output;
+
+            fn callback<B>(self, b_producer: B) -> Self::Output
+            where
+                B: Producer<Item = A::Item>,
+            {
+                let producer = ChainProducer::new(self.a_len, self.a_producer, b_producer);
+                self.callback.callback(producer)
+            }
+        }
+    }
+}
+
+/// ////////////////////////////////////////////////////////////////////////
+
+struct ChainProducer<A, B>
+where
+    A: Producer,
+    B: Producer<Item = A::Item>,
+{
+    a_len: usize,
+    a: A,
+    b: B,
+}
+
+impl<A, B> ChainProducer<A, B>
+where
+    A: Producer,
+    B: Producer<Item = A::Item>,
+{
+    fn new(a_len: usize, a: A, b: B) -> Self {
+        ChainProducer { a_len, a, b }
+    }
+}
+
+impl<A, B> Producer for ChainProducer<A, B>
+where
+    A: Producer,
+    B: Producer<Item = A::Item>,
+{
+    type Item = A::Item;
+    type IntoIter = ChainSeq<A::IntoIter, B::IntoIter>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        ChainSeq::new(self.a.into_iter(), self.b.into_iter())
+    }
+
+    fn min_len(&self) -> usize {
+        cmp::max(self.a.min_len(), self.b.min_len())
+    }
+
+    fn max_len(&self) -> usize {
+        cmp::min(self.a.max_len(), self.b.max_len())
+    }
+
+    fn split_at(self, index: usize) -> (Self, Self) {
+        if index <= self.a_len {
+            let a_rem = self.a_len - index;
+            let (a_left, a_right) = self.a.split_at(index);
+            let (b_left, b_right) = self.b.split_at(0);
+            (
+                ChainProducer::new(index, a_left, b_left),
+                ChainProducer::new(a_rem, a_right, b_right),
+            )
+        } else {
+            let (a_left, a_right) = self.a.split_at(self.a_len);
+            let (b_left, b_right) = self.b.split_at(index - self.a_len);
+            (
+                ChainProducer::new(self.a_len, a_left, b_left),
+                ChainProducer::new(0, a_right, b_right),
+            )
+        }
+    }
+
+    fn fold_with<F>(self, mut folder: F) -> F
+    where
+        F: Folder<A::Item>,
+    {
+        folder = self.a.fold_with(folder);
+        if folder.full() {
+            folder
+        } else {
+            self.b.fold_with(folder)
+        }
+    }
+}
+
+/// ////////////////////////////////////////////////////////////////////////
+/// Wrapper for Chain to implement ExactSizeIterator
+
+struct ChainSeq<A, B> {
+    chain: iter::Chain<A, B>,
+}
+
+impl<A, B> ChainSeq<A, B> {
+    fn new(a: A, b: B) -> ChainSeq<A, B>
+    where
+        A: ExactSizeIterator,
+        B: ExactSizeIterator<Item = A::Item>,
+    {
+        ChainSeq { chain: a.chain(b) }
+    }
+}
+
+impl<A, B> Iterator for ChainSeq<A, B>
+where
+    A: Iterator,
+    B: Iterator<Item = A::Item>,
+{
+    type Item = A::Item;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.chain.next()
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.chain.size_hint()
+    }
+}
+
+impl<A, B> ExactSizeIterator for ChainSeq<A, B>
+where
+    A: ExactSizeIterator,
+    B: ExactSizeIterator<Item = A::Item>,
+{
+}
+
+impl<A, B> DoubleEndedIterator for ChainSeq<A, B>
+where
+    A: DoubleEndedIterator,
+    B: DoubleEndedIterator<Item = A::Item>,
+{
+    fn next_back(&mut self) -> Option<Self::Item> {
+        self.chain.next_back()
+    }
+}
diff --git a/crates/rayon/src/iter/chunks.rs b/crates/rayon/src/iter/chunks.rs
new file mode 100644
index 0000000..ec48278
--- /dev/null
+++ b/crates/rayon/src/iter/chunks.rs
@@ -0,0 +1,226 @@
+use std::cmp::min;
+
+use super::plumbing::*;
+use super::*;
+use crate::math::div_round_up;
+
+/// `Chunks` is an iterator that groups elements of an underlying iterator.
+///
+/// This struct is created by the [`chunks()`] method on [`IndexedParallelIterator`]
+///
+/// [`chunks()`]: trait.IndexedParallelIterator.html#method.chunks
+/// [`IndexedParallelIterator`]: trait.IndexedParallelIterator.html
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Debug, Clone)]
+pub struct Chunks<I>
+where
+    I: IndexedParallelIterator,
+{
+    size: usize,
+    i: I,
+}
+
+impl<I> Chunks<I>
+where
+    I: IndexedParallelIterator,
+{
+    /// Creates a new `Chunks` iterator
+    pub(super) fn new(i: I, size: usize) -> Self {
+        Chunks { i, size }
+    }
+}
+
+impl<I> ParallelIterator for Chunks<I>
+where
+    I: IndexedParallelIterator,
+{
+    type Item = Vec<I::Item>;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Vec<I::Item>>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        Some(self.len())
+    }
+}
+
+impl<I> IndexedParallelIterator for Chunks<I>
+where
+    I: IndexedParallelIterator,
+{
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn len(&self) -> usize {
+        div_round_up(self.i.len(), self.size)
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        let len = self.i.len();
+        return self.i.with_producer(Callback {
+            size: self.size,
+            len,
+            callback,
+        });
+
+        struct Callback<CB> {
+            size: usize,
+            len: usize,
+            callback: CB,
+        }
+
+        impl<T, CB> ProducerCallback<T> for Callback<CB>
+        where
+            CB: ProducerCallback<Vec<T>>,
+        {
+            type Output = CB::Output;
+
+            fn callback<P>(self, base: P) -> CB::Output
+            where
+                P: Producer<Item = T>,
+            {
+                let producer = ChunkProducer::new(self.size, self.len, base, Vec::from_iter);
+                self.callback.callback(producer)
+            }
+        }
+    }
+}
+
+pub(super) struct ChunkProducer<P, F> {
+    chunk_size: usize,
+    len: usize,
+    base: P,
+    map: F,
+}
+
+impl<P, F> ChunkProducer<P, F> {
+    pub(super) fn new(chunk_size: usize, len: usize, base: P, map: F) -> Self {
+        Self {
+            chunk_size,
+            len,
+            base,
+            map,
+        }
+    }
+}
+
+impl<P, F, T> Producer for ChunkProducer<P, F>
+where
+    P: Producer,
+    F: Fn(P::IntoIter) -> T + Send + Clone,
+{
+    type Item = T;
+    type IntoIter = std::iter::Map<ChunkSeq<P>, F>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        let chunks = ChunkSeq {
+            chunk_size: self.chunk_size,
+            len: self.len,
+            inner: if self.len > 0 { Some(self.base) } else { None },
+        };
+        chunks.map(self.map)
+    }
+
+    fn split_at(self, index: usize) -> (Self, Self) {
+        let elem_index = min(index * self.chunk_size, self.len);
+        let (left, right) = self.base.split_at(elem_index);
+        (
+            ChunkProducer {
+                chunk_size: self.chunk_size,
+                len: elem_index,
+                base: left,
+                map: self.map.clone(),
+            },
+            ChunkProducer {
+                chunk_size: self.chunk_size,
+                len: self.len - elem_index,
+                base: right,
+                map: self.map,
+            },
+        )
+    }
+
+    fn min_len(&self) -> usize {
+        div_round_up(self.base.min_len(), self.chunk_size)
+    }
+
+    fn max_len(&self) -> usize {
+        self.base.max_len() / self.chunk_size
+    }
+}
+
+pub(super) struct ChunkSeq<P> {
+    chunk_size: usize,
+    len: usize,
+    inner: Option<P>,
+}
+
+impl<P> Iterator for ChunkSeq<P>
+where
+    P: Producer,
+{
+    type Item = P::IntoIter;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let producer = self.inner.take()?;
+        if self.len > self.chunk_size {
+            let (left, right) = producer.split_at(self.chunk_size);
+            self.inner = Some(right);
+            self.len -= self.chunk_size;
+            Some(left.into_iter())
+        } else {
+            debug_assert!(self.len > 0);
+            self.len = 0;
+            Some(producer.into_iter())
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let len = self.len();
+        (len, Some(len))
+    }
+}
+
+impl<P> ExactSizeIterator for ChunkSeq<P>
+where
+    P: Producer,
+{
+    #[inline]
+    fn len(&self) -> usize {
+        div_round_up(self.len, self.chunk_size)
+    }
+}
+
+impl<P> DoubleEndedIterator for ChunkSeq<P>
+where
+    P: Producer,
+{
+    fn next_back(&mut self) -> Option<Self::Item> {
+        let producer = self.inner.take()?;
+        if self.len > self.chunk_size {
+            let mut size = self.len % self.chunk_size;
+            if size == 0 {
+                size = self.chunk_size;
+            }
+            let (left, right) = producer.split_at(self.len - size);
+            self.inner = Some(left);
+            self.len -= size;
+            Some(right.into_iter())
+        } else {
+            debug_assert!(self.len > 0);
+            self.len = 0;
+            Some(producer.into_iter())
+        }
+    }
+}
diff --git a/crates/rayon/src/iter/cloned.rs b/crates/rayon/src/iter/cloned.rs
new file mode 100644
index 0000000..8d5f420
--- /dev/null
+++ b/crates/rayon/src/iter/cloned.rs
@@ -0,0 +1,223 @@
+use super::plumbing::*;
+use super::*;
+
+use std::iter;
+
+/// `Cloned` is an iterator that clones the elements of an underlying iterator.
+///
+/// This struct is created by the [`cloned()`] method on [`ParallelIterator`]
+///
+/// [`cloned()`]: trait.ParallelIterator.html#method.cloned
+/// [`ParallelIterator`]: trait.ParallelIterator.html
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Debug, Clone)]
+pub struct Cloned<I: ParallelIterator> {
+    base: I,
+}
+
+impl<I> Cloned<I>
+where
+    I: ParallelIterator,
+{
+    /// Creates a new `Cloned` iterator.
+    pub(super) fn new(base: I) -> Self {
+        Cloned { base }
+    }
+}
+
+impl<'a, T, I> ParallelIterator for Cloned<I>
+where
+    I: ParallelIterator<Item = &'a T>,
+    T: 'a + Clone + Send + Sync,
+{
+    type Item = T;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        let consumer1 = ClonedConsumer::new(consumer);
+        self.base.drive_unindexed(consumer1)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        self.base.opt_len()
+    }
+}
+
+impl<'a, T, I> IndexedParallelIterator for Cloned<I>
+where
+    I: IndexedParallelIterator<Item = &'a T>,
+    T: 'a + Clone + Send + Sync,
+{
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        let consumer1 = ClonedConsumer::new(consumer);
+        self.base.drive(consumer1)
+    }
+
+    fn len(&self) -> usize {
+        self.base.len()
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        return self.base.with_producer(Callback { callback });
+
+        struct Callback<CB> {
+            callback: CB,
+        }
+
+        impl<'a, T, CB> ProducerCallback<&'a T> for Callback<CB>
+        where
+            CB: ProducerCallback<T>,
+            T: 'a + Clone + Send,
+        {
+            type Output = CB::Output;
+
+            fn callback<P>(self, base: P) -> CB::Output
+            where
+                P: Producer<Item = &'a T>,
+            {
+                let producer = ClonedProducer { base };
+                self.callback.callback(producer)
+            }
+        }
+    }
+}
+
+/// ////////////////////////////////////////////////////////////////////////
+
+struct ClonedProducer<P> {
+    base: P,
+}
+
+impl<'a, T, P> Producer for ClonedProducer<P>
+where
+    P: Producer<Item = &'a T>,
+    T: 'a + Clone,
+{
+    type Item = T;
+    type IntoIter = iter::Cloned<P::IntoIter>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.base.into_iter().cloned()
+    }
+
+    fn min_len(&self) -> usize {
+        self.base.min_len()
+    }
+
+    fn max_len(&self) -> usize {
+        self.base.max_len()
+    }
+
+    fn split_at(self, index: usize) -> (Self, Self) {
+        let (left, right) = self.base.split_at(index);
+        (
+            ClonedProducer { base: left },
+            ClonedProducer { base: right },
+        )
+    }
+
+    fn fold_with<F>(self, folder: F) -> F
+    where
+        F: Folder<Self::Item>,
+    {
+        self.base.fold_with(ClonedFolder { base: folder }).base
+    }
+}
+
+/// ////////////////////////////////////////////////////////////////////////
+/// Consumer implementation
+
+struct ClonedConsumer<C> {
+    base: C,
+}
+
+impl<C> ClonedConsumer<C> {
+    fn new(base: C) -> Self {
+        ClonedConsumer { base }
+    }
+}
+
+impl<'a, T, C> Consumer<&'a T> for ClonedConsumer<C>
+where
+    C: Consumer<T>,
+    T: 'a + Clone,
+{
+    type Folder = ClonedFolder<C::Folder>;
+    type Reducer = C::Reducer;
+    type Result = C::Result;
+
+    fn split_at(self, index: usize) -> (Self, Self, Self::Reducer) {
+        let (left, right, reducer) = self.base.split_at(index);
+        (
+            ClonedConsumer::new(left),
+            ClonedConsumer::new(right),
+            reducer,
+        )
+    }
+
+    fn into_folder(self) -> Self::Folder {
+        ClonedFolder {
+            base: self.base.into_folder(),
+        }
+    }
+
+    fn full(&self) -> bool {
+        self.base.full()
+    }
+}
+
+impl<'a, T, C> UnindexedConsumer<&'a T> for ClonedConsumer<C>
+where
+    C: UnindexedConsumer<T>,
+    T: 'a + Clone,
+{
+    fn split_off_left(&self) -> Self {
+        ClonedConsumer::new(self.base.split_off_left())
+    }
+
+    fn to_reducer(&self) -> Self::Reducer {
+        self.base.to_reducer()
+    }
+}
+
+struct ClonedFolder<F> {
+    base: F,
+}
+
+impl<'a, T, F> Folder<&'a T> for ClonedFolder<F>
+where
+    F: Folder<T>,
+    T: 'a + Clone,
+{
+    type Result = F::Result;
+
+    fn consume(self, item: &'a T) -> Self {
+        ClonedFolder {
+            base: self.base.consume(item.clone()),
+        }
+    }
+
+    fn consume_iter<I>(mut self, iter: I) -> Self
+    where
+        I: IntoIterator<Item = &'a T>,
+    {
+        self.base = self.base.consume_iter(iter.into_iter().cloned());
+        self
+    }
+
+    fn complete(self) -> F::Result {
+        self.base.complete()
+    }
+
+    fn full(&self) -> bool {
+        self.base.full()
+    }
+}
diff --git a/crates/rayon/src/iter/collect/consumer.rs b/crates/rayon/src/iter/collect/consumer.rs
new file mode 100644
index 0000000..acd67df
--- /dev/null
+++ b/crates/rayon/src/iter/collect/consumer.rs
@@ -0,0 +1,186 @@
+use super::super::plumbing::*;
+use crate::SendPtr;
+use std::marker::PhantomData;
+use std::ptr;
+use std::slice;
+
+pub(super) struct CollectConsumer<'c, T: Send> {
+    /// See `CollectResult` for explanation of why this is not a slice
+    start: SendPtr<T>,
+    len: usize,
+    marker: PhantomData<&'c mut T>,
+}
+
+impl<T: Send> CollectConsumer<'_, T> {
+    /// Create a collector for `len` items in the unused capacity of the vector.
+    pub(super) fn appender(vec: &mut Vec<T>, len: usize) -> CollectConsumer<'_, T> {
+        let start = vec.len();
+        assert!(vec.capacity() - start >= len);
+
+        // SAFETY: We already made sure to have the additional space allocated.
+        // The pointer is derived from `Vec` directly, not through a `Deref`,
+        // so it has provenance over the whole allocation.
+        unsafe { CollectConsumer::new(vec.as_mut_ptr().add(start), len) }
+    }
+}
+
+impl<'c, T: Send + 'c> CollectConsumer<'c, T> {
+    /// The target memory is considered uninitialized, and will be
+    /// overwritten without reading or dropping existing values.
+    unsafe fn new(start: *mut T, len: usize) -> Self {
+        CollectConsumer {
+            start: SendPtr(start),
+            len,
+            marker: PhantomData,
+        }
+    }
+}
+
+/// CollectResult represents an initialized part of the target slice.
+///
+/// This is a proxy owner of the elements in the slice; when it drops,
+/// the elements will be dropped, unless its ownership is released before then.
+#[must_use]
+pub(super) struct CollectResult<'c, T> {
+    /// This pointer and length has the same representation as a slice,
+    /// but retains the provenance of the entire array so that we can merge
+    /// these regions together in `CollectReducer`.
+    start: SendPtr<T>,
+    total_len: usize,
+    /// The current initialized length after `start`
+    initialized_len: usize,
+    /// Lifetime invariance guarantees that the data flows from consumer to result,
+    /// especially for the `scope_fn` callback in `Collect::with_consumer`.
+    invariant_lifetime: PhantomData<&'c mut &'c mut [T]>,
+}
+
+unsafe impl<'c, T> Send for CollectResult<'c, T> where T: Send {}
+
+impl<'c, T> CollectResult<'c, T> {
+    /// The current length of the collect result
+    pub(super) fn len(&self) -> usize {
+        self.initialized_len
+    }
+
+    /// Release ownership of the slice of elements, and return the length
+    pub(super) fn release_ownership(mut self) -> usize {
+        let ret = self.initialized_len;
+        self.initialized_len = 0;
+        ret
+    }
+}
+
+impl<'c, T> Drop for CollectResult<'c, T> {
+    fn drop(&mut self) {
+        // Drop the first `self.initialized_len` elements, which have been recorded
+        // to be initialized by the folder.
+        unsafe {
+            ptr::drop_in_place(slice::from_raw_parts_mut(
+                self.start.0,
+                self.initialized_len,
+            ));
+        }
+    }
+}
+
+impl<'c, T: Send + 'c> Consumer<T> for CollectConsumer<'c, T> {
+    type Folder = CollectResult<'c, T>;
+    type Reducer = CollectReducer;
+    type Result = CollectResult<'c, T>;
+
+    fn split_at(self, index: usize) -> (Self, Self, CollectReducer) {
+        let CollectConsumer { start, len, .. } = self;
+
+        // Produce new consumers.
+        // SAFETY: This assert checks that `index` is a valid offset for `start`
+        unsafe {
+            assert!(index <= len);
+            (
+                CollectConsumer::new(start.0, index),
+                CollectConsumer::new(start.0.add(index), len - index),
+                CollectReducer,
+            )
+        }
+    }
+
+    fn into_folder(self) -> Self::Folder {
+        // Create a result/folder that consumes values and writes them
+        // into the region after start. The initial result has length 0.
+        CollectResult {
+            start: self.start,
+            total_len: self.len,
+            initialized_len: 0,
+            invariant_lifetime: PhantomData,
+        }
+    }
+
+    fn full(&self) -> bool {
+        false
+    }
+}
+
+impl<'c, T: Send + 'c> Folder<T> for CollectResult<'c, T> {
+    type Result = Self;
+
+    fn consume(mut self, item: T) -> Self {
+        assert!(
+            self.initialized_len < self.total_len,
+            "too many values pushed to consumer"
+        );
+
+        // SAFETY: The assert above is a bounds check for this write, and we
+        // avoid assignment here so we do not drop an uninitialized T.
+        unsafe {
+            // Write item and increase the initialized length
+            self.start.0.add(self.initialized_len).write(item);
+            self.initialized_len += 1;
+        }
+
+        self
+    }
+
+    fn complete(self) -> Self::Result {
+        // NB: We don't explicitly check that the local writes were complete,
+        // but Collect will assert the total result length in the end.
+        self
+    }
+
+    fn full(&self) -> bool {
+        false
+    }
+}
+
+/// Pretend to be unindexed for `special_collect_into_vec`,
+/// but we should never actually get used that way...
+impl<'c, T: Send + 'c> UnindexedConsumer<T> for CollectConsumer<'c, T> {
+    fn split_off_left(&self) -> Self {
+        unreachable!("CollectConsumer must be indexed!")
+    }
+    fn to_reducer(&self) -> Self::Reducer {
+        CollectReducer
+    }
+}
+
+/// CollectReducer combines adjacent chunks; the result must always
+/// be contiguous so that it is one combined slice.
+pub(super) struct CollectReducer;
+
+impl<'c, T> Reducer<CollectResult<'c, T>> for CollectReducer {
+    fn reduce(
+        self,
+        mut left: CollectResult<'c, T>,
+        right: CollectResult<'c, T>,
+    ) -> CollectResult<'c, T> {
+        // Merge if the CollectResults are adjacent and in left to right order
+        // else: drop the right piece now and total length will end up short in the end,
+        // when the correctness of the collected result is asserted.
+        unsafe {
+            let left_end = left.start.0.add(left.initialized_len);
+            if left_end == right.start.0 {
+                left.total_len += right.total_len;
+                left.initialized_len += right.release_ownership();
+            }
+            left
+        }
+    }
+}
diff --git a/crates/rayon/src/iter/collect/mod.rs b/crates/rayon/src/iter/collect/mod.rs
new file mode 100644
index 0000000..4044a68
--- /dev/null
+++ b/crates/rayon/src/iter/collect/mod.rs
@@ -0,0 +1,116 @@
+use super::{IndexedParallelIterator, ParallelIterator};
+
+mod consumer;
+use self::consumer::CollectConsumer;
+use self::consumer::CollectResult;
+use super::unzip::unzip_indexed;
+
+mod test;
+
+/// Collects the results of the exact iterator into the specified vector.
+///
+/// This is called by `IndexedParallelIterator::collect_into_vec`.
+pub(super) fn collect_into_vec<I, T>(pi: I, v: &mut Vec<T>)
+where
+    I: IndexedParallelIterator<Item = T>,
+    T: Send,
+{
+    v.truncate(0); // clear any old data
+    let len = pi.len();
+    collect_with_consumer(v, len, |consumer| pi.drive(consumer));
+}
+
+/// Collects the results of the iterator into the specified vector.
+///
+/// Technically, this only works for `IndexedParallelIterator`, but we're faking a
+/// bit of specialization here until Rust can do that natively.  Callers are
+/// using `opt_len` to find the length before calling this, and only exact
+/// iterators will return anything but `None` there.
+///
+/// Since the type system doesn't understand that contract, we have to allow
+/// *any* `ParallelIterator` here, and `CollectConsumer` has to also implement
+/// `UnindexedConsumer`.  That implementation panics `unreachable!` in case
+/// there's a bug where we actually do try to use this unindexed.
+pub(super) fn special_extend<I, T>(pi: I, len: usize, v: &mut Vec<T>)
+where
+    I: ParallelIterator<Item = T>,
+    T: Send,
+{
+    collect_with_consumer(v, len, |consumer| pi.drive_unindexed(consumer));
+}
+
+/// Unzips the results of the exact iterator into the specified vectors.
+///
+/// This is called by `IndexedParallelIterator::unzip_into_vecs`.
+pub(super) fn unzip_into_vecs<I, A, B>(pi: I, left: &mut Vec<A>, right: &mut Vec<B>)
+where
+    I: IndexedParallelIterator<Item = (A, B)>,
+    A: Send,
+    B: Send,
+{
+    // clear any old data
+    left.truncate(0);
+    right.truncate(0);
+
+    let len = pi.len();
+    collect_with_consumer(right, len, |right_consumer| {
+        let mut right_result = None;
+        collect_with_consumer(left, len, |left_consumer| {
+            let (left_r, right_r) = unzip_indexed(pi, left_consumer, right_consumer);
+            right_result = Some(right_r);
+            left_r
+        });
+        right_result.unwrap()
+    });
+}
+
+/// Create a consumer on the slice of memory we are collecting into.
+///
+/// The consumer needs to be used inside the scope function, and the
+/// complete collect result passed back.
+///
+/// This method will verify the collect result, and panic if the slice
+/// was not fully written into. Otherwise, in the successful case,
+/// the vector is complete with the collected result.
+fn collect_with_consumer<T, F>(vec: &mut Vec<T>, len: usize, scope_fn: F)
+where
+    T: Send,
+    F: FnOnce(CollectConsumer<'_, T>) -> CollectResult<'_, T>,
+{
+    // Reserve space for `len` more elements in the vector,
+    vec.reserve(len);
+
+    // Create the consumer and run the callback for collection.
+    let result = scope_fn(CollectConsumer::appender(vec, len));
+
+    // The `CollectResult` represents a contiguous part of the slice, that has
+    // been written to. On unwind here, the `CollectResult` will be dropped. If
+    // some producers on the way did not produce enough elements, partial
+    // `CollectResult`s may have been dropped without being reduced to the final
+    // result, and we will see that as the length coming up short.
+    //
+    // Here, we assert that added length is fully initialized. This is checked
+    // by the following assert, which verifies if a complete `CollectResult`
+    // was produced; if the length is correct, it is necessarily covering the
+    // target slice. Since we know that the consumer cannot have escaped from
+    // `drive` (by parametricity, essentially), we know that any stores that
+    // will happen, have happened. Unless some code is buggy, that means we
+    // should have seen `len` total writes.
+    let actual_writes = result.len();
+    assert!(
+        actual_writes == len,
+        "expected {} total writes, but got {}",
+        len,
+        actual_writes
+    );
+
+    // Release the result's mutable borrow and "proxy ownership"
+    // of the elements, before the vector takes it over.
+    result.release_ownership();
+
+    let new_len = vec.len() + len;
+
+    unsafe {
+        vec.set_len(new_len);
+    }
+}
diff --git a/crates/rayon/src/iter/collect/test.rs b/crates/rayon/src/iter/collect/test.rs
new file mode 100644
index 0000000..97bec3f
--- /dev/null
+++ b/crates/rayon/src/iter/collect/test.rs
@@ -0,0 +1,373 @@
+#![cfg(test)]
+#![allow(unused_assignments)]
+
+// These tests are primarily targeting "abusive" producers that will
+// try to drive the "collect consumer" incorrectly. These should
+// result in panics.
+
+use super::collect_with_consumer;
+use crate::iter::plumbing::*;
+use rayon_core::join;
+
+use std::fmt;
+use std::panic;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::thread::Result as ThreadResult;
+
+/// Promises to produce 2 items, but then produces 3.  Does not do any
+/// splits at all.
+#[test]
+#[should_panic(expected = "too many values")]
+fn produce_too_many_items() {
+    let mut v = vec![];
+    collect_with_consumer(&mut v, 2, |consumer| {
+        let mut folder = consumer.into_folder();
+        folder = folder.consume(22);
+        folder = folder.consume(23);
+        folder = folder.consume(24);
+        unreachable!("folder does not complete")
+    });
+}
+
+/// Produces fewer items than promised. Does not do any
+/// splits at all.
+#[test]
+#[should_panic(expected = "expected 5 total writes, but got 2")]
+fn produce_fewer_items() {
+    let mut v = vec![];
+    collect_with_consumer(&mut v, 5, |consumer| {
+        let mut folder = consumer.into_folder();
+        folder = folder.consume(22);
+        folder = folder.consume(23);
+        folder.complete()
+    });
+}
+
+// Complete is not called by the consumer. Hence,the collection vector is not fully initialized.
+#[test]
+#[should_panic(expected = "expected 4 total writes, but got 2")]
+fn left_produces_items_with_no_complete() {
+    let mut v = vec![];
+    collect_with_consumer(&mut v, 4, |consumer| {
+        let (left_consumer, right_consumer, _) = consumer.split_at(2);
+        let mut left_folder = left_consumer.into_folder();
+        let mut right_folder = right_consumer.into_folder();
+        left_folder = left_folder.consume(0).consume(1);
+        right_folder = right_folder.consume(2).consume(3);
+        right_folder.complete()
+    });
+}
+
+// Complete is not called by the right consumer. Hence,the
+// collection vector is not fully initialized.
+#[test]
+#[should_panic(expected = "expected 4 total writes, but got 2")]
+fn right_produces_items_with_no_complete() {
+    let mut v = vec![];
+    collect_with_consumer(&mut v, 4, |consumer| {
+        let (left_consumer, right_consumer, _) = consumer.split_at(2);
+        let mut left_folder = left_consumer.into_folder();
+        let mut right_folder = right_consumer.into_folder();
+        left_folder = left_folder.consume(0).consume(1);
+        right_folder = right_folder.consume(2).consume(3);
+        left_folder.complete()
+    });
+}
+
+// Complete is not called by the consumer. Hence,the collection vector is not fully initialized.
+#[test]
+#[cfg_attr(not(panic = "unwind"), ignore)]
+fn produces_items_with_no_complete() {
+    let counter = DropCounter::default();
+    let mut v = vec![];
+    let panic_result = panic::catch_unwind(panic::AssertUnwindSafe(|| {
+        collect_with_consumer(&mut v, 2, |consumer| {
+            let mut folder = consumer.into_folder();
+            folder = folder.consume(counter.element());
+            folder = folder.consume(counter.element());
+            panic!("folder does not complete");
+        });
+    }));
+    assert!(v.is_empty());
+    assert_is_panic_with_message(&panic_result, "folder does not complete");
+    counter.assert_drop_count();
+}
+
+// The left consumer produces too many items while the right
+// consumer produces correct number.
+#[test]
+#[should_panic(expected = "too many values")]
+fn left_produces_too_many_items() {
+    let mut v = vec![];
+    collect_with_consumer(&mut v, 4, |consumer| {
+        let (left_consumer, right_consumer, _) = consumer.split_at(2);
+        let mut left_folder = left_consumer.into_folder();
+        let mut right_folder = right_consumer.into_folder();
+        left_folder = left_folder.consume(0).consume(1).consume(2);
+        right_folder = right_folder.consume(2).consume(3);
+        let _ = right_folder.complete();
+        unreachable!("folder does not complete");
+    });
+}
+
+// The right consumer produces too many items while the left
+// consumer produces correct number.
+#[test]
+#[should_panic(expected = "too many values")]
+fn right_produces_too_many_items() {
+    let mut v = vec![];
+    collect_with_consumer(&mut v, 4, |consumer| {
+        let (left_consumer, right_consumer, _) = consumer.split_at(2);
+        let mut left_folder = left_consumer.into_folder();
+        let mut right_folder = right_consumer.into_folder();
+        left_folder = left_folder.consume(0).consume(1);
+        right_folder = right_folder.consume(2).consume(3).consume(4);
+        let _ = left_folder.complete();
+        unreachable!("folder does not complete");
+    });
+}
+
+// The left consumer produces fewer items while the right
+// consumer produces correct number.
+#[test]
+#[should_panic(expected = "expected 4 total writes, but got 1")]
+fn left_produces_fewer_items() {
+    let mut v = vec![];
+    collect_with_consumer(&mut v, 4, |consumer| {
+        let reducer = consumer.to_reducer();
+        let (left_consumer, right_consumer, _) = consumer.split_at(2);
+        let mut left_folder = left_consumer.into_folder();
+        let mut right_folder = right_consumer.into_folder();
+        left_folder = left_folder.consume(0);
+        right_folder = right_folder.consume(2).consume(3);
+        let left_result = left_folder.complete();
+        let right_result = right_folder.complete();
+        reducer.reduce(left_result, right_result)
+    });
+}
+
+// The left and right consumer produce the correct number but
+// only left result is returned
+#[test]
+#[should_panic(expected = "expected 4 total writes, but got 2")]
+fn only_left_result() {
+    let mut v = vec![];
+    collect_with_consumer(&mut v, 4, |consumer| {
+        let (left_consumer, right_consumer, _) = consumer.split_at(2);
+        let mut left_folder = left_consumer.into_folder();
+        let mut right_folder = right_consumer.into_folder();
+        left_folder = left_folder.consume(0).consume(1);
+        right_folder = right_folder.consume(2).consume(3);
+        let left_result = left_folder.complete();
+        let _ = right_folder.complete();
+        left_result
+    });
+}
+
+// The left and right consumer produce the correct number but
+// only right result is returned
+#[test]
+#[should_panic(expected = "expected 4 total writes, but got 2")]
+fn only_right_result() {
+    let mut v = vec![];
+    collect_with_consumer(&mut v, 4, |consumer| {
+        let (left_consumer, right_consumer, _) = consumer.split_at(2);
+        let mut left_folder = left_consumer.into_folder();
+        let mut right_folder = right_consumer.into_folder();
+        left_folder = left_folder.consume(0).consume(1);
+        right_folder = right_folder.consume(2).consume(3);
+        let _ = left_folder.complete();
+        right_folder.complete()
+    });
+}
+
+// The left and right consumer produce the correct number but reduce
+// in the wrong order.
+#[test]
+#[should_panic(expected = "expected 4 total writes, but got 2")]
+fn reducer_does_not_preserve_order() {
+    let mut v = vec![];
+    collect_with_consumer(&mut v, 4, |consumer| {
+        let reducer = consumer.to_reducer();
+        let (left_consumer, right_consumer, _) = consumer.split_at(2);
+        let mut left_folder = left_consumer.into_folder();
+        let mut right_folder = right_consumer.into_folder();
+        left_folder = left_folder.consume(0).consume(1);
+        right_folder = right_folder.consume(2).consume(3);
+        let left_result = left_folder.complete();
+        let right_result = right_folder.complete();
+        reducer.reduce(right_result, left_result)
+    });
+}
+
+// The right consumer produces fewer items while the left
+// consumer produces correct number.
+#[test]
+#[should_panic(expected = "expected 4 total writes, but got 3")]
+fn right_produces_fewer_items() {
+    let mut v = vec![];
+    collect_with_consumer(&mut v, 4, |consumer| {
+        let reducer = consumer.to_reducer();
+        let (left_consumer, right_consumer, _) = consumer.split_at(2);
+        let mut left_folder = left_consumer.into_folder();
+        let mut right_folder = right_consumer.into_folder();
+        left_folder = left_folder.consume(0).consume(1);
+        right_folder = right_folder.consume(2);
+        let left_result = left_folder.complete();
+        let right_result = right_folder.complete();
+        reducer.reduce(left_result, right_result)
+    });
+}
+
+// The left consumer panics and the right stops short, like `panic_fuse()`.
+// We should get the left panic without finishing `collect_with_consumer`.
+#[test]
+#[should_panic(expected = "left consumer panic")]
+fn left_panics() {
+    let mut v = vec![];
+    collect_with_consumer(&mut v, 4, |consumer| {
+        let reducer = consumer.to_reducer();
+        let (left_consumer, right_consumer, _) = consumer.split_at(2);
+        let (left_result, right_result) = join(
+            || {
+                let mut left_folder = left_consumer.into_folder();
+                left_folder = left_folder.consume(0);
+                panic!("left consumer panic");
+            },
+            || {
+                let mut right_folder = right_consumer.into_folder();
+                right_folder = right_folder.consume(2);
+                right_folder.complete() // early return
+            },
+        );
+        reducer.reduce(left_result, right_result)
+    });
+    unreachable!();
+}
+
+// The right consumer panics and the left stops short, like `panic_fuse()`.
+// We should get the right panic without finishing `collect_with_consumer`.
+#[test]
+#[should_panic(expected = "right consumer panic")]
+fn right_panics() {
+    let mut v = vec![];
+    collect_with_consumer(&mut v, 4, |consumer| {
+        let reducer = consumer.to_reducer();
+        let (left_consumer, right_consumer, _) = consumer.split_at(2);
+        let (left_result, right_result) = join(
+            || {
+                let mut left_folder = left_consumer.into_folder();
+                left_folder = left_folder.consume(0);
+                left_folder.complete() // early return
+            },
+            || {
+                let mut right_folder = right_consumer.into_folder();
+                right_folder = right_folder.consume(2);
+                panic!("right consumer panic");
+            },
+        );
+        reducer.reduce(left_result, right_result)
+    });
+    unreachable!();
+}
+
+// The left consumer produces fewer items while the right
+// consumer produces correct number; check that created elements are dropped
+#[test]
+#[cfg_attr(not(panic = "unwind"), ignore)]
+fn left_produces_fewer_items_drops() {
+    let counter = DropCounter::default();
+    let mut v = vec![];
+    let panic_result = panic::catch_unwind(panic::AssertUnwindSafe(|| {
+        collect_with_consumer(&mut v, 4, |consumer| {
+            let reducer = consumer.to_reducer();
+            let (left_consumer, right_consumer, _) = consumer.split_at(2);
+            let mut left_folder = left_consumer.into_folder();
+            let mut right_folder = right_consumer.into_folder();
+            left_folder = left_folder.consume(counter.element());
+            right_folder = right_folder
+                .consume(counter.element())
+                .consume(counter.element());
+            let left_result = left_folder.complete();
+            let right_result = right_folder.complete();
+            reducer.reduce(left_result, right_result)
+        });
+    }));
+    assert!(v.is_empty());
+    assert_is_panic_with_message(&panic_result, "expected 4 total writes, but got 1");
+    counter.assert_drop_count();
+}
+
+/// This counter can create elements, and then count and verify
+/// the number of which have actually been dropped again.
+#[derive(Default)]
+struct DropCounter {
+    created: AtomicUsize,
+    dropped: AtomicUsize,
+}
+
+struct Element<'a>(&'a AtomicUsize);
+
+impl DropCounter {
+    fn created(&self) -> usize {
+        self.created.load(Ordering::SeqCst)
+    }
+
+    fn dropped(&self) -> usize {
+        self.dropped.load(Ordering::SeqCst)
+    }
+
+    fn element(&self) -> Element<'_> {
+        self.created.fetch_add(1, Ordering::SeqCst);
+        Element(&self.dropped)
+    }
+
+    fn assert_drop_count(&self) {
+        assert_eq!(
+            self.created(),
+            self.dropped(),
+            "Expected {} dropped elements, but found {}",
+            self.created(),
+            self.dropped()
+        );
+    }
+}
+
+impl<'a> Drop for Element<'a> {
+    fn drop(&mut self) {
+        self.0.fetch_add(1, Ordering::SeqCst);
+    }
+}
+
+/// Assert that the result from catch_unwind is a panic that contains expected message
+fn assert_is_panic_with_message<T>(result: &ThreadResult<T>, expected: &str)
+where
+    T: fmt::Debug,
+{
+    match result {
+        Ok(value) => {
+            panic!(
+                "assertion failure: Expected panic, got successful {:?}",
+                value
+            );
+        }
+        Err(error) => {
+            let message_str = error.downcast_ref::<&'static str>().cloned();
+            let message_string = error.downcast_ref::<String>().map(String::as_str);
+            if let Some(message) = message_str.or(message_string) {
+                if !message.contains(expected) {
+                    panic!(
+                        "assertion failure: Expected {:?}, but found panic with {:?}",
+                        expected, message
+                    );
+                }
+            // assertion passes
+            } else {
+                panic!(
+                    "assertion failure: Expected {:?}, but found panic with unknown value",
+                    expected
+                );
+            }
+        }
+    }
+}
diff --git a/crates/rayon/src/iter/copied.rs b/crates/rayon/src/iter/copied.rs
new file mode 100644
index 0000000..12c9c5b
--- /dev/null
+++ b/crates/rayon/src/iter/copied.rs
@@ -0,0 +1,223 @@
+use super::plumbing::*;
+use super::*;
+
+use std::iter;
+
+/// `Copied` is an iterator that copies the elements of an underlying iterator.
+///
+/// This struct is created by the [`copied()`] method on [`ParallelIterator`]
+///
+/// [`copied()`]: trait.ParallelIterator.html#method.copied
+/// [`ParallelIterator`]: trait.ParallelIterator.html
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Debug, Clone)]
+pub struct Copied<I: ParallelIterator> {
+    base: I,
+}
+
+impl<I> Copied<I>
+where
+    I: ParallelIterator,
+{
+    /// Creates a new `Copied` iterator.
+    pub(super) fn new(base: I) -> Self {
+        Copied { base }
+    }
+}
+
+impl<'a, T, I> ParallelIterator for Copied<I>
+where
+    I: ParallelIterator<Item = &'a T>,
+    T: 'a + Copy + Send + Sync,
+{
+    type Item = T;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        let consumer1 = CopiedConsumer::new(consumer);
+        self.base.drive_unindexed(consumer1)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        self.base.opt_len()
+    }
+}
+
+impl<'a, T, I> IndexedParallelIterator for Copied<I>
+where
+    I: IndexedParallelIterator<Item = &'a T>,
+    T: 'a + Copy + Send + Sync,
+{
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        let consumer1 = CopiedConsumer::new(consumer);
+        self.base.drive(consumer1)
+    }
+
+    fn len(&self) -> usize {
+        self.base.len()
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        return self.base.with_producer(Callback { callback });
+
+        struct Callback<CB> {
+            callback: CB,
+        }
+
+        impl<'a, T, CB> ProducerCallback<&'a T> for Callback<CB>
+        where
+            CB: ProducerCallback<T>,
+            T: 'a + Copy + Send,
+        {
+            type Output = CB::Output;
+
+            fn callback<P>(self, base: P) -> CB::Output
+            where
+                P: Producer<Item = &'a T>,
+            {
+                let producer = CopiedProducer { base };
+                self.callback.callback(producer)
+            }
+        }
+    }
+}
+
+/// ////////////////////////////////////////////////////////////////////////
+
+struct CopiedProducer<P> {
+    base: P,
+}
+
+impl<'a, T, P> Producer for CopiedProducer<P>
+where
+    P: Producer<Item = &'a T>,
+    T: 'a + Copy,
+{
+    type Item = T;
+    type IntoIter = iter::Copied<P::IntoIter>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.base.into_iter().copied()
+    }
+
+    fn min_len(&self) -> usize {
+        self.base.min_len()
+    }
+
+    fn max_len(&self) -> usize {
+        self.base.max_len()
+    }
+
+    fn split_at(self, index: usize) -> (Self, Self) {
+        let (left, right) = self.base.split_at(index);
+        (
+            CopiedProducer { base: left },
+            CopiedProducer { base: right },
+        )
+    }
+
+    fn fold_with<F>(self, folder: F) -> F
+    where
+        F: Folder<Self::Item>,
+    {
+        self.base.fold_with(CopiedFolder { base: folder }).base
+    }
+}
+
+/// ////////////////////////////////////////////////////////////////////////
+/// Consumer implementation
+
+struct CopiedConsumer<C> {
+    base: C,
+}
+
+impl<C> CopiedConsumer<C> {
+    fn new(base: C) -> Self {
+        CopiedConsumer { base }
+    }
+}
+
+impl<'a, T, C> Consumer<&'a T> for CopiedConsumer<C>
+where
+    C: Consumer<T>,
+    T: 'a + Copy,
+{
+    type Folder = CopiedFolder<C::Folder>;
+    type Reducer = C::Reducer;
+    type Result = C::Result;
+
+    fn split_at(self, index: usize) -> (Self, Self, Self::Reducer) {
+        let (left, right, reducer) = self.base.split_at(index);
+        (
+            CopiedConsumer::new(left),
+            CopiedConsumer::new(right),
+            reducer,
+        )
+    }
+
+    fn into_folder(self) -> Self::Folder {
+        CopiedFolder {
+            base: self.base.into_folder(),
+        }
+    }
+
+    fn full(&self) -> bool {
+        self.base.full()
+    }
+}
+
+impl<'a, T, C> UnindexedConsumer<&'a T> for CopiedConsumer<C>
+where
+    C: UnindexedConsumer<T>,
+    T: 'a + Copy,
+{
+    fn split_off_left(&self) -> Self {
+        CopiedConsumer::new(self.base.split_off_left())
+    }
+
+    fn to_reducer(&self) -> Self::Reducer {
+        self.base.to_reducer()
+    }
+}
+
+struct CopiedFolder<F> {
+    base: F,
+}
+
+impl<'a, T, F> Folder<&'a T> for CopiedFolder<F>
+where
+    F: Folder<T>,
+    T: 'a + Copy,
+{
+    type Result = F::Result;
+
+    fn consume(self, &item: &'a T) -> Self {
+        CopiedFolder {
+            base: self.base.consume(item),
+        }
+    }
+
+    fn consume_iter<I>(mut self, iter: I) -> Self
+    where
+        I: IntoIterator<Item = &'a T>,
+    {
+        self.base = self.base.consume_iter(iter.into_iter().copied());
+        self
+    }
+
+    fn complete(self) -> F::Result {
+        self.base.complete()
+    }
+
+    fn full(&self) -> bool {
+        self.base.full()
+    }
+}
diff --git a/crates/rayon/src/iter/empty.rs b/crates/rayon/src/iter/empty.rs
new file mode 100644
index 0000000..85a2e5f
--- /dev/null
+++ b/crates/rayon/src/iter/empty.rs
@@ -0,0 +1,104 @@
+use crate::iter::plumbing::*;
+use crate::iter::*;
+
+use std::fmt;
+use std::marker::PhantomData;
+
+/// Creates a parallel iterator that produces nothing.
+///
+/// This admits no parallelism on its own, but it could be used for code that
+/// deals with generic parallel iterators.
+///
+/// # Examples
+///
+/// ```
+/// use rayon::prelude::*;
+/// use rayon::iter::empty;
+///
+/// let pi = (0..1234).into_par_iter()
+///     .chain(empty())
+///     .chain(1234..10_000);
+///
+/// assert_eq!(pi.count(), 10_000);
+/// ```
+pub fn empty<T: Send>() -> Empty<T> {
+    Empty {
+        marker: PhantomData,
+    }
+}
+
+/// Iterator adaptor for [the `empty()` function](fn.empty.html).
+pub struct Empty<T: Send> {
+    marker: PhantomData<T>,
+}
+
+impl<T: Send> Clone for Empty<T> {
+    fn clone(&self) -> Self {
+        empty()
+    }
+}
+
+impl<T: Send> fmt::Debug for Empty<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.pad("Empty")
+    }
+}
+
+impl<T: Send> ParallelIterator for Empty<T> {
+    type Item = T;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        self.drive(consumer)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        Some(0)
+    }
+}
+
+impl<T: Send> IndexedParallelIterator for Empty<T> {
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        consumer.into_folder().complete()
+    }
+
+    fn len(&self) -> usize {
+        0
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        callback.callback(EmptyProducer(PhantomData))
+    }
+}
+
+/// Private empty producer
+struct EmptyProducer<T: Send>(PhantomData<T>);
+
+impl<T: Send> Producer for EmptyProducer<T> {
+    type Item = T;
+    type IntoIter = std::iter::Empty<T>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        std::iter::empty()
+    }
+
+    fn split_at(self, index: usize) -> (Self, Self) {
+        debug_assert_eq!(index, 0);
+        (self, EmptyProducer(PhantomData))
+    }
+
+    fn fold_with<F>(self, folder: F) -> F
+    where
+        F: Folder<Self::Item>,
+    {
+        folder
+    }
+}
diff --git a/crates/rayon/src/iter/enumerate.rs b/crates/rayon/src/iter/enumerate.rs
new file mode 100644
index 0000000..980ee7c
--- /dev/null
+++ b/crates/rayon/src/iter/enumerate.rs
@@ -0,0 +1,133 @@
+use super::plumbing::*;
+use super::*;
+use std::iter;
+use std::ops::Range;
+use std::usize;
+
+/// `Enumerate` is an iterator that returns the current count along with the element.
+/// This struct is created by the [`enumerate()`] method on [`IndexedParallelIterator`]
+///
+/// [`enumerate()`]: trait.IndexedParallelIterator.html#method.enumerate
+/// [`IndexedParallelIterator`]: trait.IndexedParallelIterator.html
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Debug, Clone)]
+pub struct Enumerate<I: IndexedParallelIterator> {
+    base: I,
+}
+
+impl<I> Enumerate<I>
+where
+    I: IndexedParallelIterator,
+{
+    /// Creates a new `Enumerate` iterator.
+    pub(super) fn new(base: I) -> Self {
+        Enumerate { base }
+    }
+}
+
+impl<I> ParallelIterator for Enumerate<I>
+where
+    I: IndexedParallelIterator,
+{
+    type Item = (usize, I::Item);
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        Some(self.len())
+    }
+}
+
+impl<I> IndexedParallelIterator for Enumerate<I>
+where
+    I: IndexedParallelIterator,
+{
+    fn drive<C: Consumer<Self::Item>>(self, consumer: C) -> C::Result {
+        bridge(self, consumer)
+    }
+
+    fn len(&self) -> usize {
+        self.base.len()
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        return self.base.with_producer(Callback { callback });
+
+        struct Callback<CB> {
+            callback: CB,
+        }
+
+        impl<I, CB> ProducerCallback<I> for Callback<CB>
+        where
+            CB: ProducerCallback<(usize, I)>,
+        {
+            type Output = CB::Output;
+            fn callback<P>(self, base: P) -> CB::Output
+            where
+                P: Producer<Item = I>,
+            {
+                let producer = EnumerateProducer { base, offset: 0 };
+                self.callback.callback(producer)
+            }
+        }
+    }
+}
+
+/// ////////////////////////////////////////////////////////////////////////
+/// Producer implementation
+
+struct EnumerateProducer<P> {
+    base: P,
+    offset: usize,
+}
+
+impl<P> Producer for EnumerateProducer<P>
+where
+    P: Producer,
+{
+    type Item = (usize, P::Item);
+    type IntoIter = iter::Zip<Range<usize>, P::IntoIter>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        // Enumerate only works for IndexedParallelIterators. Since those
+        // have a max length of usize::MAX, their max index is
+        // usize::MAX - 1, so the range 0..usize::MAX includes all
+        // possible indices.
+        //
+        // However, we should to use a precise end to the range, otherwise
+        // reversing the iterator may have to walk back a long ways before
+        // `Zip::next_back` can produce anything.
+        let base = self.base.into_iter();
+        let end = self.offset + base.len();
+        (self.offset..end).zip(base)
+    }
+
+    fn min_len(&self) -> usize {
+        self.base.min_len()
+    }
+    fn max_len(&self) -> usize {
+        self.base.max_len()
+    }
+
+    fn split_at(self, index: usize) -> (Self, Self) {
+        let (left, right) = self.base.split_at(index);
+        (
+            EnumerateProducer {
+                base: left,
+                offset: self.offset,
+            },
+            EnumerateProducer {
+                base: right,
+                offset: self.offset + index,
+            },
+        )
+    }
+}
diff --git a/crates/rayon/src/iter/extend.rs b/crates/rayon/src/iter/extend.rs
new file mode 100644
index 0000000..a264528
--- /dev/null
+++ b/crates/rayon/src/iter/extend.rs
@@ -0,0 +1,614 @@
+use super::noop::NoopConsumer;
+use super::plumbing::{Consumer, Folder, Reducer, UnindexedConsumer};
+use super::{IntoParallelIterator, ParallelExtend, ParallelIterator};
+
+use std::borrow::Cow;
+use std::collections::LinkedList;
+use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
+use std::collections::{BinaryHeap, VecDeque};
+use std::hash::{BuildHasher, Hash};
+
+/// Performs a generic `par_extend` by collecting to a `LinkedList<Vec<_>>` in
+/// parallel, then extending the collection sequentially.
+macro_rules! extend {
+    ($self:ident, $par_iter:ident, $extend:ident) => {
+        $extend(
+            $self,
+            $par_iter.into_par_iter().drive_unindexed(ListVecConsumer),
+        );
+    };
+}
+
+/// Computes the total length of a `LinkedList<Vec<_>>`.
+fn len<T>(list: &LinkedList<Vec<T>>) -> usize {
+    list.iter().map(Vec::len).sum()
+}
+
+struct ListVecConsumer;
+
+struct ListVecFolder<T> {
+    vec: Vec<T>,
+}
+
+impl<T: Send> Consumer<T> for ListVecConsumer {
+    type Folder = ListVecFolder<T>;
+    type Reducer = ListReducer;
+    type Result = LinkedList<Vec<T>>;
+
+    fn split_at(self, _index: usize) -> (Self, Self, Self::Reducer) {
+        (Self, Self, ListReducer)
+    }
+
+    fn into_folder(self) -> Self::Folder {
+        ListVecFolder { vec: Vec::new() }
+    }
+
+    fn full(&self) -> bool {
+        false
+    }
+}
+
+impl<T: Send> UnindexedConsumer<T> for ListVecConsumer {
+    fn split_off_left(&self) -> Self {
+        Self
+    }
+
+    fn to_reducer(&self) -> Self::Reducer {
+        ListReducer
+    }
+}
+
+impl<T> Folder<T> for ListVecFolder<T> {
+    type Result = LinkedList<Vec<T>>;
+
+    fn consume(mut self, item: T) -> Self {
+        self.vec.push(item);
+        self
+    }
+
+    fn consume_iter<I>(mut self, iter: I) -> Self
+    where
+        I: IntoIterator<Item = T>,
+    {
+        self.vec.extend(iter);
+        self
+    }
+
+    fn complete(self) -> Self::Result {
+        let mut list = LinkedList::new();
+        if !self.vec.is_empty() {
+            list.push_back(self.vec);
+        }
+        list
+    }
+
+    fn full(&self) -> bool {
+        false
+    }
+}
+
+fn heap_extend<T, Item>(heap: &mut BinaryHeap<T>, list: LinkedList<Vec<Item>>)
+where
+    BinaryHeap<T>: Extend<Item>,
+{
+    heap.reserve(len(&list));
+    for vec in list {
+        heap.extend(vec);
+    }
+}
+
+/// Extends a binary heap with items from a parallel iterator.
+impl<T> ParallelExtend<T> for BinaryHeap<T>
+where
+    T: Ord + Send,
+{
+    fn par_extend<I>(&mut self, par_iter: I)
+    where
+        I: IntoParallelIterator<Item = T>,
+    {
+        extend!(self, par_iter, heap_extend);
+    }
+}
+
+/// Extends a binary heap with copied items from a parallel iterator.
+impl<'a, T> ParallelExtend<&'a T> for BinaryHeap<T>
+where
+    T: 'a + Copy + Ord + Send + Sync,
+{
+    fn par_extend<I>(&mut self, par_iter: I)
+    where
+        I: IntoParallelIterator<Item = &'a T>,
+    {
+        extend!(self, par_iter, heap_extend);
+    }
+}
+
+fn btree_map_extend<K, V, Item>(map: &mut BTreeMap<K, V>, list: LinkedList<Vec<Item>>)
+where
+    BTreeMap<K, V>: Extend<Item>,
+{
+    for vec in list {
+        map.extend(vec);
+    }
+}
+
+/// Extends a B-tree map with items from a parallel iterator.
+impl<K, V> ParallelExtend<(K, V)> for BTreeMap<K, V>
+where
+    K: Ord + Send,
+    V: Send,
+{
+    fn par_extend<I>(&mut self, par_iter: I)
+    where
+        I: IntoParallelIterator<Item = (K, V)>,
+    {
+        extend!(self, par_iter, btree_map_extend);
+    }
+}
+
+/// Extends a B-tree map with copied items from a parallel iterator.
+impl<'a, K: 'a, V: 'a> ParallelExtend<(&'a K, &'a V)> for BTreeMap<K, V>
+where
+    K: Copy + Ord + Send + Sync,
+    V: Copy + Send + Sync,
+{
+    fn par_extend<I>(&mut self, par_iter: I)
+    where
+        I: IntoParallelIterator<Item = (&'a K, &'a V)>,
+    {
+        extend!(self, par_iter, btree_map_extend);
+    }
+}
+
+fn btree_set_extend<T, Item>(set: &mut BTreeSet<T>, list: LinkedList<Vec<Item>>)
+where
+    BTreeSet<T>: Extend<Item>,
+{
+    for vec in list {
+        set.extend(vec);
+    }
+}
+
+/// Extends a B-tree set with items from a parallel iterator.
+impl<T> ParallelExtend<T> for BTreeSet<T>
+where
+    T: Ord + Send,
+{
+    fn par_extend<I>(&mut self, par_iter: I)
+    where
+        I: IntoParallelIterator<Item = T>,
+    {
+        extend!(self, par_iter, btree_set_extend);
+    }
+}
+
+/// Extends a B-tree set with copied items from a parallel iterator.
+impl<'a, T> ParallelExtend<&'a T> for BTreeSet<T>
+where
+    T: 'a + Copy + Ord + Send + Sync,
+{
+    fn par_extend<I>(&mut self, par_iter: I)
+    where
+        I: IntoParallelIterator<Item = &'a T>,
+    {
+        extend!(self, par_iter, btree_set_extend);
+    }
+}
+
+fn hash_map_extend<K, V, S, Item>(map: &mut HashMap<K, V, S>, list: LinkedList<Vec<Item>>)
+where
+    HashMap<K, V, S>: Extend<Item>,
+    K: Eq + Hash,
+    S: BuildHasher,
+{
+    map.reserve(len(&list));
+    for vec in list {
+        map.extend(vec);
+    }
+}
+
+/// Extends a hash map with items from a parallel iterator.
+impl<K, V, S> ParallelExtend<(K, V)> for HashMap<K, V, S>
+where
+    K: Eq + Hash + Send,
+    V: Send,
+    S: BuildHasher + Send,
+{
+    fn par_extend<I>(&mut self, par_iter: I)
+    where
+        I: IntoParallelIterator<Item = (K, V)>,
+    {
+        // See the map_collect benchmarks in rayon-demo for different strategies.
+        extend!(self, par_iter, hash_map_extend);
+    }
+}
+
+/// Extends a hash map with copied items from a parallel iterator.
+impl<'a, K: 'a, V: 'a, S> ParallelExtend<(&'a K, &'a V)> for HashMap<K, V, S>
+where
+    K: Copy + Eq + Hash + Send + Sync,
+    V: Copy + Send + Sync,
+    S: BuildHasher + Send,
+{
+    fn par_extend<I>(&mut self, par_iter: I)
+    where
+        I: IntoParallelIterator<Item = (&'a K, &'a V)>,
+    {
+        extend!(self, par_iter, hash_map_extend);
+    }
+}
+
+fn hash_set_extend<T, S, Item>(set: &mut HashSet<T, S>, list: LinkedList<Vec<Item>>)
+where
+    HashSet<T, S>: Extend<Item>,
+    T: Eq + Hash,
+    S: BuildHasher,
+{
+    set.reserve(len(&list));
+    for vec in list {
+        set.extend(vec);
+    }
+}
+
+/// Extends a hash set with items from a parallel iterator.
+impl<T, S> ParallelExtend<T> for HashSet<T, S>
+where
+    T: Eq + Hash + Send,
+    S: BuildHasher + Send,
+{
+    fn par_extend<I>(&mut self, par_iter: I)
+    where
+        I: IntoParallelIterator<Item = T>,
+    {
+        extend!(self, par_iter, hash_set_extend);
+    }
+}
+
+/// Extends a hash set with copied items from a parallel iterator.
+impl<'a, T, S> ParallelExtend<&'a T> for HashSet<T, S>
+where
+    T: 'a + Copy + Eq + Hash + Send + Sync,
+    S: BuildHasher + Send,
+{
+    fn par_extend<I>(&mut self, par_iter: I)
+    where
+        I: IntoParallelIterator<Item = &'a T>,
+    {
+        extend!(self, par_iter, hash_set_extend);
+    }
+}
+
+/// Extends a linked list with items from a parallel iterator.
+impl<T> ParallelExtend<T> for LinkedList<T>
+where
+    T: Send,
+{
+    fn par_extend<I>(&mut self, par_iter: I)
+    where
+        I: IntoParallelIterator<Item = T>,
+    {
+        let mut list = par_iter.into_par_iter().drive_unindexed(ListConsumer);
+        self.append(&mut list);
+    }
+}
+
+/// Extends a linked list with copied items from a parallel iterator.
+impl<'a, T> ParallelExtend<&'a T> for LinkedList<T>
+where
+    T: 'a + Copy + Send + Sync,
+{
+    fn par_extend<I>(&mut self, par_iter: I)
+    where
+        I: IntoParallelIterator<Item = &'a T>,
+    {
+        self.par_extend(par_iter.into_par_iter().copied())
+    }
+}
+
+struct ListConsumer;
+
+struct ListFolder<T> {
+    list: LinkedList<T>,
+}
+
+struct ListReducer;
+
+impl<T: Send> Consumer<T> for ListConsumer {
+    type Folder = ListFolder<T>;
+    type Reducer = ListReducer;
+    type Result = LinkedList<T>;
+
+    fn split_at(self, _index: usize) -> (Self, Self, Self::Reducer) {
+        (Self, Self, ListReducer)
+    }
+
+    fn into_folder(self) -> Self::Folder {
+        ListFolder {
+            list: LinkedList::new(),
+        }
+    }
+
+    fn full(&self) -> bool {
+        false
+    }
+}
+
+impl<T: Send> UnindexedConsumer<T> for ListConsumer {
+    fn split_off_left(&self) -> Self {
+        Self
+    }
+
+    fn to_reducer(&self) -> Self::Reducer {
+        ListReducer
+    }
+}
+
+impl<T> Folder<T> for ListFolder<T> {
+    type Result = LinkedList<T>;
+
+    fn consume(mut self, item: T) -> Self {
+        self.list.push_back(item);
+        self
+    }
+
+    fn consume_iter<I>(mut self, iter: I) -> Self
+    where
+        I: IntoIterator<Item = T>,
+    {
+        self.list.extend(iter);
+        self
+    }
+
+    fn complete(self) -> Self::Result {
+        self.list
+    }
+
+    fn full(&self) -> bool {
+        false
+    }
+}
+
+impl<T> Reducer<LinkedList<T>> for ListReducer {
+    fn reduce(self, mut left: LinkedList<T>, mut right: LinkedList<T>) -> LinkedList<T> {
+        left.append(&mut right);
+        left
+    }
+}
+
+fn flat_string_extend(string: &mut String, list: LinkedList<String>) {
+    string.reserve(list.iter().map(String::len).sum());
+    string.extend(list);
+}
+
+/// Extends a string with characters from a parallel iterator.
+impl ParallelExtend<char> for String {
+    fn par_extend<I>(&mut self, par_iter: I)
+    where
+        I: IntoParallelIterator<Item = char>,
+    {
+        // This is like `extend`, but `Vec<char>` is less efficient to deal
+        // with than `String`, so instead collect to `LinkedList<String>`.
+        let list = par_iter.into_par_iter().drive_unindexed(ListStringConsumer);
+        flat_string_extend(self, list);
+    }
+}
+
+/// Extends a string with copied characters from a parallel iterator.
+impl<'a> ParallelExtend<&'a char> for String {
+    fn par_extend<I>(&mut self, par_iter: I)
+    where
+        I: IntoParallelIterator<Item = &'a char>,
+    {
+        self.par_extend(par_iter.into_par_iter().copied())
+    }
+}
+
+struct ListStringConsumer;
+
+struct ListStringFolder {
+    string: String,
+}
+
+impl Consumer<char> for ListStringConsumer {
+    type Folder = ListStringFolder;
+    type Reducer = ListReducer;
+    type Result = LinkedList<String>;
+
+    fn split_at(self, _index: usize) -> (Self, Self, Self::Reducer) {
+        (Self, Self, ListReducer)
+    }
+
+    fn into_folder(self) -> Self::Folder {
+        ListStringFolder {
+            string: String::new(),
+        }
+    }
+
+    fn full(&self) -> bool {
+        false
+    }
+}
+
+impl UnindexedConsumer<char> for ListStringConsumer {
+    fn split_off_left(&self) -> Self {
+        Self
+    }
+
+    fn to_reducer(&self) -> Self::Reducer {
+        ListReducer
+    }
+}
+
+impl Folder<char> for ListStringFolder {
+    type Result = LinkedList<String>;
+
+    fn consume(mut self, item: char) -> Self {
+        self.string.push(item);
+        self
+    }
+
+    fn consume_iter<I>(mut self, iter: I) -> Self
+    where
+        I: IntoIterator<Item = char>,
+    {
+        self.string.extend(iter);
+        self
+    }
+
+    fn complete(self) -> Self::Result {
+        let mut list = LinkedList::new();
+        if !self.string.is_empty() {
+            list.push_back(self.string);
+        }
+        list
+    }
+
+    fn full(&self) -> bool {
+        false
+    }
+}
+
+fn string_extend<Item>(string: &mut String, list: LinkedList<Vec<Item>>)
+where
+    String: Extend<Item>,
+    Item: AsRef<str>,
+{
+    let len = list.iter().flatten().map(Item::as_ref).map(str::len).sum();
+    string.reserve(len);
+    for vec in list {
+        string.extend(vec);
+    }
+}
+
+/// Extends a string with string slices from a parallel iterator.
+impl<'a> ParallelExtend<&'a str> for String {
+    fn par_extend<I>(&mut self, par_iter: I)
+    where
+        I: IntoParallelIterator<Item = &'a str>,
+    {
+        extend!(self, par_iter, string_extend);
+    }
+}
+
+/// Extends a string with strings from a parallel iterator.
+impl ParallelExtend<String> for String {
+    fn par_extend<I>(&mut self, par_iter: I)
+    where
+        I: IntoParallelIterator<Item = String>,
+    {
+        extend!(self, par_iter, string_extend);
+    }
+}
+
+/// Extends a string with boxed strings from a parallel iterator.
+impl ParallelExtend<Box<str>> for String {
+    fn par_extend<I>(&mut self, par_iter: I)
+    where
+        I: IntoParallelIterator<Item = Box<str>>,
+    {
+        extend!(self, par_iter, string_extend);
+    }
+}
+
+/// Extends a string with string slices from a parallel iterator.
+impl<'a> ParallelExtend<Cow<'a, str>> for String {
+    fn par_extend<I>(&mut self, par_iter: I)
+    where
+        I: IntoParallelIterator<Item = Cow<'a, str>>,
+    {
+        extend!(self, par_iter, string_extend);
+    }
+}
+
+fn deque_extend<T, Item>(deque: &mut VecDeque<T>, list: LinkedList<Vec<Item>>)
+where
+    VecDeque<T>: Extend<Item>,
+{
+    deque.reserve(len(&list));
+    for vec in list {
+        deque.extend(vec);
+    }
+}
+
+/// Extends a deque with items from a parallel iterator.
+impl<T> ParallelExtend<T> for VecDeque<T>
+where
+    T: Send,
+{
+    fn par_extend<I>(&mut self, par_iter: I)
+    where
+        I: IntoParallelIterator<Item = T>,
+    {
+        extend!(self, par_iter, deque_extend);
+    }
+}
+
+/// Extends a deque with copied items from a parallel iterator.
+impl<'a, T> ParallelExtend<&'a T> for VecDeque<T>
+where
+    T: 'a + Copy + Send + Sync,
+{
+    fn par_extend<I>(&mut self, par_iter: I)
+    where
+        I: IntoParallelIterator<Item = &'a T>,
+    {
+        extend!(self, par_iter, deque_extend);
+    }
+}
+
+fn vec_append<T>(vec: &mut Vec<T>, list: LinkedList<Vec<T>>) {
+    vec.reserve(len(&list));
+    for mut other in list {
+        vec.append(&mut other);
+    }
+}
+
+/// Extends a vector with items from a parallel iterator.
+impl<T> ParallelExtend<T> for Vec<T>
+where
+    T: Send,
+{
+    fn par_extend<I>(&mut self, par_iter: I)
+    where
+        I: IntoParallelIterator<Item = T>,
+    {
+        // See the vec_collect benchmarks in rayon-demo for different strategies.
+        let par_iter = par_iter.into_par_iter();
+        match par_iter.opt_len() {
+            Some(len) => {
+                // When Rust gets specialization, we can get here for indexed iterators
+                // without relying on `opt_len`.  Until then, `special_extend()` fakes
+                // an unindexed mode on the promise that `opt_len()` is accurate.
+                super::collect::special_extend(par_iter, len, self);
+            }
+            None => {
+                // This works like `extend`, but `Vec::append` is more efficient.
+                let list = par_iter.drive_unindexed(ListVecConsumer);
+                vec_append(self, list);
+            }
+        }
+    }
+}
+
+/// Extends a vector with copied items from a parallel iterator.
+impl<'a, T> ParallelExtend<&'a T> for Vec<T>
+where
+    T: 'a + Copy + Send + Sync,
+{
+    fn par_extend<I>(&mut self, par_iter: I)
+    where
+        I: IntoParallelIterator<Item = &'a T>,
+    {
+        self.par_extend(par_iter.into_par_iter().copied())
+    }
+}
+
+/// Collapses all unit items from a parallel iterator into one.
+impl ParallelExtend<()> for () {
+    fn par_extend<I>(&mut self, par_iter: I)
+    where
+        I: IntoParallelIterator<Item = ()>,
+    {
+        par_iter.into_par_iter().drive_unindexed(NoopConsumer)
+    }
+}
diff --git a/crates/rayon/src/iter/filter.rs b/crates/rayon/src/iter/filter.rs
new file mode 100644
index 0000000..e1b74ba
--- /dev/null
+++ b/crates/rayon/src/iter/filter.rs
@@ -0,0 +1,141 @@
+use super::plumbing::*;
+use super::*;
+
+use std::fmt::{self, Debug};
+
+/// `Filter` takes a predicate `filter_op` and filters out elements that match.
+/// This struct is created by the [`filter()`] method on [`ParallelIterator`]
+///
+/// [`filter()`]: trait.ParallelIterator.html#method.filter
+/// [`ParallelIterator`]: trait.ParallelIterator.html
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Clone)]
+pub struct Filter<I: ParallelIterator, P> {
+    base: I,
+    filter_op: P,
+}
+
+impl<I: ParallelIterator + Debug, P> Debug for Filter<I, P> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Filter").field("base", &self.base).finish()
+    }
+}
+
+impl<I, P> Filter<I, P>
+where
+    I: ParallelIterator,
+{
+    /// Creates a new `Filter` iterator.
+    pub(super) fn new(base: I, filter_op: P) -> Self {
+        Filter { base, filter_op }
+    }
+}
+
+impl<I, P> ParallelIterator for Filter<I, P>
+where
+    I: ParallelIterator,
+    P: Fn(&I::Item) -> bool + Sync + Send,
+{
+    type Item = I::Item;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        let consumer1 = FilterConsumer::new(consumer, &self.filter_op);
+        self.base.drive_unindexed(consumer1)
+    }
+}
+
+/// ////////////////////////////////////////////////////////////////////////
+/// Consumer implementation
+
+struct FilterConsumer<'p, C, P> {
+    base: C,
+    filter_op: &'p P,
+}
+
+impl<'p, C, P> FilterConsumer<'p, C, P> {
+    fn new(base: C, filter_op: &'p P) -> Self {
+        FilterConsumer { base, filter_op }
+    }
+}
+
+impl<'p, T, C, P: 'p> Consumer<T> for FilterConsumer<'p, C, P>
+where
+    C: Consumer<T>,
+    P: Fn(&T) -> bool + Sync,
+{
+    type Folder = FilterFolder<'p, C::Folder, P>;
+    type Reducer = C::Reducer;
+    type Result = C::Result;
+
+    fn split_at(self, index: usize) -> (Self, Self, C::Reducer) {
+        let (left, right, reducer) = self.base.split_at(index);
+        (
+            FilterConsumer::new(left, self.filter_op),
+            FilterConsumer::new(right, self.filter_op),
+            reducer,
+        )
+    }
+
+    fn into_folder(self) -> Self::Folder {
+        FilterFolder {
+            base: self.base.into_folder(),
+            filter_op: self.filter_op,
+        }
+    }
+
+    fn full(&self) -> bool {
+        self.base.full()
+    }
+}
+
+impl<'p, T, C, P: 'p> UnindexedConsumer<T> for FilterConsumer<'p, C, P>
+where
+    C: UnindexedConsumer<T>,
+    P: Fn(&T) -> bool + Sync,
+{
+    fn split_off_left(&self) -> Self {
+        FilterConsumer::new(self.base.split_off_left(), self.filter_op)
+    }
+
+    fn to_reducer(&self) -> Self::Reducer {
+        self.base.to_reducer()
+    }
+}
+
+struct FilterFolder<'p, C, P> {
+    base: C,
+    filter_op: &'p P,
+}
+
+impl<'p, C, P, T> Folder<T> for FilterFolder<'p, C, P>
+where
+    C: Folder<T>,
+    P: Fn(&T) -> bool + 'p,
+{
+    type Result = C::Result;
+
+    fn consume(self, item: T) -> Self {
+        let filter_op = self.filter_op;
+        if filter_op(&item) {
+            let base = self.base.consume(item);
+            FilterFolder { base, filter_op }
+        } else {
+            self
+        }
+    }
+
+    // This cannot easily specialize `consume_iter` to be better than
+    // the default, because that requires checking `self.base.full()`
+    // during a call to `self.base.consume_iter()`. (#632)
+
+    fn complete(self) -> Self::Result {
+        self.base.complete()
+    }
+
+    fn full(&self) -> bool {
+        self.base.full()
+    }
+}
diff --git a/crates/rayon/src/iter/filter_map.rs b/crates/rayon/src/iter/filter_map.rs
new file mode 100644
index 0000000..db1c7e3
--- /dev/null
+++ b/crates/rayon/src/iter/filter_map.rs
@@ -0,0 +1,142 @@
+use super::plumbing::*;
+use super::*;
+
+use std::fmt::{self, Debug};
+
+/// `FilterMap` creates an iterator that uses `filter_op` to both filter and map elements.
+/// This struct is created by the [`filter_map()`] method on [`ParallelIterator`].
+///
+/// [`filter_map()`]: trait.ParallelIterator.html#method.filter_map
+/// [`ParallelIterator`]: trait.ParallelIterator.html
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Clone)]
+pub struct FilterMap<I: ParallelIterator, P> {
+    base: I,
+    filter_op: P,
+}
+
+impl<I: ParallelIterator + Debug, P> Debug for FilterMap<I, P> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("FilterMap")
+            .field("base", &self.base)
+            .finish()
+    }
+}
+
+impl<I: ParallelIterator, P> FilterMap<I, P> {
+    /// Creates a new `FilterMap` iterator.
+    pub(super) fn new(base: I, filter_op: P) -> Self {
+        FilterMap { base, filter_op }
+    }
+}
+
+impl<I, P, R> ParallelIterator for FilterMap<I, P>
+where
+    I: ParallelIterator,
+    P: Fn(I::Item) -> Option<R> + Sync + Send,
+    R: Send,
+{
+    type Item = R;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        let consumer = FilterMapConsumer::new(consumer, &self.filter_op);
+        self.base.drive_unindexed(consumer)
+    }
+}
+
+/// ////////////////////////////////////////////////////////////////////////
+/// Consumer implementation
+
+struct FilterMapConsumer<'p, C, P> {
+    base: C,
+    filter_op: &'p P,
+}
+
+impl<'p, C, P: 'p> FilterMapConsumer<'p, C, P> {
+    fn new(base: C, filter_op: &'p P) -> Self {
+        FilterMapConsumer { base, filter_op }
+    }
+}
+
+impl<'p, T, U, C, P> Consumer<T> for FilterMapConsumer<'p, C, P>
+where
+    C: Consumer<U>,
+    P: Fn(T) -> Option<U> + Sync + 'p,
+{
+    type Folder = FilterMapFolder<'p, C::Folder, P>;
+    type Reducer = C::Reducer;
+    type Result = C::Result;
+
+    fn split_at(self, index: usize) -> (Self, Self, Self::Reducer) {
+        let (left, right, reducer) = self.base.split_at(index);
+        (
+            FilterMapConsumer::new(left, self.filter_op),
+            FilterMapConsumer::new(right, self.filter_op),
+            reducer,
+        )
+    }
+
+    fn into_folder(self) -> Self::Folder {
+        let base = self.base.into_folder();
+        FilterMapFolder {
+            base,
+            filter_op: self.filter_op,
+        }
+    }
+
+    fn full(&self) -> bool {
+        self.base.full()
+    }
+}
+
+impl<'p, T, U, C, P> UnindexedConsumer<T> for FilterMapConsumer<'p, C, P>
+where
+    C: UnindexedConsumer<U>,
+    P: Fn(T) -> Option<U> + Sync + 'p,
+{
+    fn split_off_left(&self) -> Self {
+        FilterMapConsumer::new(self.base.split_off_left(), self.filter_op)
+    }
+
+    fn to_reducer(&self) -> Self::Reducer {
+        self.base.to_reducer()
+    }
+}
+
+struct FilterMapFolder<'p, C, P> {
+    base: C,
+    filter_op: &'p P,
+}
+
+impl<'p, T, U, C, P> Folder<T> for FilterMapFolder<'p, C, P>
+where
+    C: Folder<U>,
+    P: Fn(T) -> Option<U> + Sync + 'p,
+{
+    type Result = C::Result;
+
+    fn consume(self, item: T) -> Self {
+        let filter_op = self.filter_op;
+        if let Some(mapped_item) = filter_op(item) {
+            let base = self.base.consume(mapped_item);
+            FilterMapFolder { base, filter_op }
+        } else {
+            self
+        }
+    }
+
+    // This cannot easily specialize `consume_iter` to be better than
+    // the default, because that requires checking `self.base.full()`
+    // during a call to `self.base.consume_iter()`. (#632)
+
+    fn complete(self) -> C::Result {
+        self.base.complete()
+    }
+
+    fn full(&self) -> bool {
+        self.base.full()
+    }
+}
diff --git a/crates/rayon/src/iter/find.rs b/crates/rayon/src/iter/find.rs
new file mode 100644
index 0000000..b16ee84
--- /dev/null
+++ b/crates/rayon/src/iter/find.rs
@@ -0,0 +1,120 @@
+use super::plumbing::*;
+use super::*;
+use std::sync::atomic::{AtomicBool, Ordering};
+
+pub(super) fn find<I, P>(pi: I, find_op: P) -> Option<I::Item>
+where
+    I: ParallelIterator,
+    P: Fn(&I::Item) -> bool + Sync,
+{
+    let found = AtomicBool::new(false);
+    let consumer = FindConsumer::new(&find_op, &found);
+    pi.drive_unindexed(consumer)
+}
+
+struct FindConsumer<'p, P> {
+    find_op: &'p P,
+    found: &'p AtomicBool,
+}
+
+impl<'p, P> FindConsumer<'p, P> {
+    fn new(find_op: &'p P, found: &'p AtomicBool) -> Self {
+        FindConsumer { find_op, found }
+    }
+}
+
+impl<'p, T, P: 'p> Consumer<T> for FindConsumer<'p, P>
+where
+    T: Send,
+    P: Fn(&T) -> bool + Sync,
+{
+    type Folder = FindFolder<'p, T, P>;
+    type Reducer = FindReducer;
+    type Result = Option<T>;
+
+    fn split_at(self, _index: usize) -> (Self, Self, Self::Reducer) {
+        (self.split_off_left(), self, FindReducer)
+    }
+
+    fn into_folder(self) -> Self::Folder {
+        FindFolder {
+            find_op: self.find_op,
+            found: self.found,
+            item: None,
+        }
+    }
+
+    fn full(&self) -> bool {
+        self.found.load(Ordering::Relaxed)
+    }
+}
+
+impl<'p, T, P: 'p> UnindexedConsumer<T> for FindConsumer<'p, P>
+where
+    T: Send,
+    P: Fn(&T) -> bool + Sync,
+{
+    fn split_off_left(&self) -> Self {
+        FindConsumer::new(self.find_op, self.found)
+    }
+
+    fn to_reducer(&self) -> Self::Reducer {
+        FindReducer
+    }
+}
+
+struct FindFolder<'p, T, P> {
+    find_op: &'p P,
+    found: &'p AtomicBool,
+    item: Option<T>,
+}
+
+impl<'p, T, P> Folder<T> for FindFolder<'p, T, P>
+where
+    P: Fn(&T) -> bool + 'p,
+{
+    type Result = Option<T>;
+
+    fn consume(mut self, item: T) -> Self {
+        if (self.find_op)(&item) {
+            self.found.store(true, Ordering::Relaxed);
+            self.item = Some(item);
+        }
+        self
+    }
+
+    fn consume_iter<I>(mut self, iter: I) -> Self
+    where
+        I: IntoIterator<Item = T>,
+    {
+        fn not_full<T>(found: &AtomicBool) -> impl Fn(&T) -> bool + '_ {
+            move |_| !found.load(Ordering::Relaxed)
+        }
+
+        self.item = iter
+            .into_iter()
+            // stop iterating if another thread has found something
+            .take_while(not_full(self.found))
+            .find(self.find_op);
+        if self.item.is_some() {
+            self.found.store(true, Ordering::Relaxed)
+        }
+        self
+    }
+
+    fn complete(self) -> Self::Result {
+        self.item
+    }
+
+    fn full(&self) -> bool {
+        self.found.load(Ordering::Relaxed)
+    }
+}
+
+struct FindReducer;
+
+impl<T> Reducer<Option<T>> for FindReducer {
+    fn reduce(self, left: Option<T>, right: Option<T>) -> Option<T> {
+        left.or(right)
+    }
+}
diff --git a/crates/rayon/src/iter/find_first_last/mod.rs b/crates/rayon/src/iter/find_first_last/mod.rs
new file mode 100644
index 0000000..e5da8f0
--- /dev/null
+++ b/crates/rayon/src/iter/find_first_last/mod.rs
@@ -0,0 +1,238 @@
+use super::plumbing::*;
+use super::*;
+use std::cell::Cell;
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+#[cfg(test)]
+mod test;
+
+// The key optimization for find_first is that a consumer can stop its search if
+// some consumer to its left already found a match (and similarly for consumers
+// to the right for find_last). To make this work, all consumers need some
+// notion of their position in the data relative to other consumers, including
+// unindexed consumers that have no built-in notion of position.
+//
+// To solve this, we assign each consumer a lower and upper bound for an
+// imaginary "range" of data that it consumes. The initial consumer starts with
+// the range 0..usize::max_value(). The split divides this range in half so that
+// one resulting consumer has the range 0..(usize::max_value() / 2), and the
+// other has (usize::max_value() / 2)..usize::max_value(). Every subsequent
+// split divides the range in half again until it cannot be split anymore
+// (i.e. its length is 1), in which case the split returns two consumers with
+// the same range. In that case both consumers will continue to consume all
+// their data regardless of whether a better match is found, but the reducer
+// will still return the correct answer.
+
+#[derive(Copy, Clone)]
+enum MatchPosition {
+    Leftmost,
+    Rightmost,
+}
+
+/// Returns true if pos1 is a better match than pos2 according to MatchPosition
+#[inline]
+fn better_position(pos1: usize, pos2: usize, mp: MatchPosition) -> bool {
+    match mp {
+        MatchPosition::Leftmost => pos1 < pos2,
+        MatchPosition::Rightmost => pos1 > pos2,
+    }
+}
+
+pub(super) fn find_first<I, P>(pi: I, find_op: P) -> Option<I::Item>
+where
+    I: ParallelIterator,
+    P: Fn(&I::Item) -> bool + Sync,
+{
+    let best_found = AtomicUsize::new(usize::max_value());
+    let consumer = FindConsumer::new(&find_op, MatchPosition::Leftmost, &best_found);
+    pi.drive_unindexed(consumer)
+}
+
+pub(super) fn find_last<I, P>(pi: I, find_op: P) -> Option<I::Item>
+where
+    I: ParallelIterator,
+    P: Fn(&I::Item) -> bool + Sync,
+{
+    let best_found = AtomicUsize::new(0);
+    let consumer = FindConsumer::new(&find_op, MatchPosition::Rightmost, &best_found);
+    pi.drive_unindexed(consumer)
+}
+
+struct FindConsumer<'p, P> {
+    find_op: &'p P,
+    lower_bound: Cell<usize>,
+    upper_bound: usize,
+    match_position: MatchPosition,
+    best_found: &'p AtomicUsize,
+}
+
+impl<'p, P> FindConsumer<'p, P> {
+    fn new(find_op: &'p P, match_position: MatchPosition, best_found: &'p AtomicUsize) -> Self {
+        FindConsumer {
+            find_op,
+            lower_bound: Cell::new(0),
+            upper_bound: usize::max_value(),
+            match_position,
+            best_found,
+        }
+    }
+
+    fn current_index(&self) -> usize {
+        match self.match_position {
+            MatchPosition::Leftmost => self.lower_bound.get(),
+            MatchPosition::Rightmost => self.upper_bound,
+        }
+    }
+}
+
+impl<'p, T, P> Consumer<T> for FindConsumer<'p, P>
+where
+    T: Send,
+    P: Fn(&T) -> bool + Sync,
+{
+    type Folder = FindFolder<'p, T, P>;
+    type Reducer = FindReducer;
+    type Result = Option<T>;
+
+    fn split_at(self, _index: usize) -> (Self, Self, Self::Reducer) {
+        let dir = self.match_position;
+        (
+            self.split_off_left(),
+            self,
+            FindReducer {
+                match_position: dir,
+            },
+        )
+    }
+
+    fn into_folder(self) -> Self::Folder {
+        FindFolder {
+            find_op: self.find_op,
+            boundary: self.current_index(),
+            match_position: self.match_position,
+            best_found: self.best_found,
+            item: None,
+        }
+    }
+
+    fn full(&self) -> bool {
+        // can stop consuming if the best found index so far is *strictly*
+        // better than anything this consumer will find
+        better_position(
+            self.best_found.load(Ordering::Relaxed),
+            self.current_index(),
+            self.match_position,
+        )
+    }
+}
+
+impl<'p, T, P> UnindexedConsumer<T> for FindConsumer<'p, P>
+where
+    T: Send,
+    P: Fn(&T) -> bool + Sync,
+{
+    fn split_off_left(&self) -> Self {
+        // Upper bound for one consumer will be lower bound for the other. This
+        // overlap is okay, because only one of the bounds will be used for
+        // comparing against best_found; the other is kept only to be able to
+        // divide the range in half.
+        //
+        // When the resolution of usize has been exhausted (i.e. when
+        // upper_bound = lower_bound), both results of this split will have the
+        // same range. When that happens, we lose the ability to tell one
+        // consumer to stop working when the other finds a better match, but the
+        // reducer ensures that the best answer is still returned (see the test
+        // above).
+        let old_lower_bound = self.lower_bound.get();
+        let median = old_lower_bound + ((self.upper_bound - old_lower_bound) / 2);
+        self.lower_bound.set(median);
+
+        FindConsumer {
+            find_op: self.find_op,
+            lower_bound: Cell::new(old_lower_bound),
+            upper_bound: median,
+            match_position: self.match_position,
+            best_found: self.best_found,
+        }
+    }
+
+    fn to_reducer(&self) -> Self::Reducer {
+        FindReducer {
+            match_position: self.match_position,
+        }
+    }
+}
+
+struct FindFolder<'p, T, P> {
+    find_op: &'p P,
+    boundary: usize,
+    match_position: MatchPosition,
+    best_found: &'p AtomicUsize,
+    item: Option<T>,
+}
+
+impl<'p, P: 'p + Fn(&T) -> bool, T> Folder<T> for FindFolder<'p, T, P> {
+    type Result = Option<T>;
+
+    fn consume(mut self, item: T) -> Self {
+        let found_best_in_range = match self.match_position {
+            MatchPosition::Leftmost => self.item.is_some(),
+            MatchPosition::Rightmost => false,
+        };
+
+        if !found_best_in_range && (self.find_op)(&item) {
+            // Continuously try to set best_found until we succeed or we
+            // discover a better match was already found.
+            let mut current = self.best_found.load(Ordering::Relaxed);
+            loop {
+                if better_position(current, self.boundary, self.match_position) {
+                    break;
+                }
+                match self.best_found.compare_exchange_weak(
+                    current,
+                    self.boundary,
+                    Ordering::Relaxed,
+                    Ordering::Relaxed,
+                ) {
+                    Ok(_) => {
+                        self.item = Some(item);
+                        break;
+                    }
+                    Err(v) => current = v,
+                }
+            }
+        }
+        self
+    }
+
+    fn complete(self) -> Self::Result {
+        self.item
+    }
+
+    fn full(&self) -> bool {
+        let found_best_in_range = match self.match_position {
+            MatchPosition::Leftmost => self.item.is_some(),
+            MatchPosition::Rightmost => false,
+        };
+
+        found_best_in_range
+            || better_position(
+                self.best_found.load(Ordering::Relaxed),
+                self.boundary,
+                self.match_position,
+            )
+    }
+}
+
+struct FindReducer {
+    match_position: MatchPosition,
+}
+
+impl<T> Reducer<Option<T>> for FindReducer {
+    fn reduce(self, left: Option<T>, right: Option<T>) -> Option<T> {
+        match self.match_position {
+            MatchPosition::Leftmost => left.or(right),
+            MatchPosition::Rightmost => right.or(left),
+        }
+    }
+}
diff --git a/crates/rayon/src/iter/find_first_last/test.rs b/crates/rayon/src/iter/find_first_last/test.rs
new file mode 100644
index 0000000..05271bc
--- /dev/null
+++ b/crates/rayon/src/iter/find_first_last/test.rs
@@ -0,0 +1,106 @@
+use super::*;
+use std::sync::atomic::AtomicUsize;
+
+#[test]
+fn same_range_first_consumers_return_correct_answer() {
+    let find_op = |x: &i32| x % 2 == 0;
+    let first_found = AtomicUsize::new(usize::max_value());
+    let far_right_consumer = FindConsumer::new(&find_op, MatchPosition::Leftmost, &first_found);
+
+    // We save a consumer that will be far to the right of the main consumer (and therefore not
+    // sharing an index range with that consumer) for fullness testing
+    let consumer = far_right_consumer.split_off_left();
+
+    // split until we have an indivisible range
+    let bits_in_usize = usize::min_value().count_zeros();
+
+    for _ in 0..bits_in_usize {
+        consumer.split_off_left();
+    }
+
+    let reducer = consumer.to_reducer();
+    // the left and right folders should now have the same range, having
+    // exhausted the resolution of usize
+    let left_folder = consumer.split_off_left().into_folder();
+    let right_folder = consumer.into_folder();
+
+    let left_folder = left_folder.consume(0).consume(1);
+    assert_eq!(left_folder.boundary, right_folder.boundary);
+    // expect not full even though a better match has been found because the
+    // ranges are the same
+    assert!(!right_folder.full());
+    assert!(far_right_consumer.full());
+    let right_folder = right_folder.consume(2).consume(3);
+    assert_eq!(
+        reducer.reduce(left_folder.complete(), right_folder.complete()),
+        Some(0)
+    );
+}
+
+#[test]
+fn same_range_last_consumers_return_correct_answer() {
+    let find_op = |x: &i32| x % 2 == 0;
+    let last_found = AtomicUsize::new(0);
+    let consumer = FindConsumer::new(&find_op, MatchPosition::Rightmost, &last_found);
+
+    // We save a consumer that will be far to the left of the main consumer (and therefore not
+    // sharing an index range with that consumer) for fullness testing
+    let far_left_consumer = consumer.split_off_left();
+
+    // split until we have an indivisible range
+    let bits_in_usize = usize::min_value().count_zeros();
+    for _ in 0..bits_in_usize {
+        consumer.split_off_left();
+    }
+
+    let reducer = consumer.to_reducer();
+    // due to the exact calculation in split_off_left, the very last consumer has a
+    // range of width 2, so we use the second-to-last consumer instead to get
+    // the same boundary on both folders
+    let consumer = consumer.split_off_left();
+    let left_folder = consumer.split_off_left().into_folder();
+    let right_folder = consumer.into_folder();
+    let right_folder = right_folder.consume(2).consume(3);
+    assert_eq!(left_folder.boundary, right_folder.boundary);
+    // expect not full even though a better match has been found because the
+    // ranges are the same
+    assert!(!left_folder.full());
+    assert!(far_left_consumer.full());
+    let left_folder = left_folder.consume(0).consume(1);
+    assert_eq!(
+        reducer.reduce(left_folder.complete(), right_folder.complete()),
+        Some(2)
+    );
+}
+
+// These tests requires that a folder be assigned to an iterator with more than
+// one element. We can't necessarily determine when that will happen for a given
+// input to find_first/find_last, so we test the folder directly here instead.
+#[test]
+fn find_first_folder_does_not_clobber_first_found() {
+    let best_found = AtomicUsize::new(usize::max_value());
+    let f = FindFolder {
+        find_op: &(|&_: &i32| -> bool { true }),
+        boundary: 0,
+        match_position: MatchPosition::Leftmost,
+        best_found: &best_found,
+        item: None,
+    };
+    let f = f.consume(0_i32).consume(1_i32).consume(2_i32);
+    assert!(f.full());
+    assert_eq!(f.complete(), Some(0_i32));
+}
+
+#[test]
+fn find_last_folder_yields_last_match() {
+    let best_found = AtomicUsize::new(0);
+    let f = FindFolder {
+        find_op: &(|&_: &i32| -> bool { true }),
+        boundary: 0,
+        match_position: MatchPosition::Rightmost,
+        best_found: &best_found,
+        item: None,
+    };
+    let f = f.consume(0_i32).consume(1_i32).consume(2_i32);
+    assert_eq!(f.complete(), Some(2_i32));
+}
diff --git a/crates/rayon/src/iter/flat_map.rs b/crates/rayon/src/iter/flat_map.rs
new file mode 100644
index 0000000..f264e1e
--- /dev/null
+++ b/crates/rayon/src/iter/flat_map.rs
@@ -0,0 +1,154 @@
+use super::plumbing::*;
+use super::*;
+
+use std::fmt::{self, Debug};
+
+/// `FlatMap` maps each element to a parallel iterator, then flattens these iterators together.
+/// This struct is created by the [`flat_map()`] method on [`ParallelIterator`]
+///
+/// [`flat_map()`]: trait.ParallelIterator.html#method.flat_map
+/// [`ParallelIterator`]: trait.ParallelIterator.html
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Clone)]
+pub struct FlatMap<I: ParallelIterator, F> {
+    base: I,
+    map_op: F,
+}
+
+impl<I: ParallelIterator + Debug, F> Debug for FlatMap<I, F> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("FlatMap").field("base", &self.base).finish()
+    }
+}
+
+impl<I: ParallelIterator, F> FlatMap<I, F> {
+    /// Creates a new `FlatMap` iterator.
+    pub(super) fn new(base: I, map_op: F) -> Self {
+        FlatMap { base, map_op }
+    }
+}
+
+impl<I, F, PI> ParallelIterator for FlatMap<I, F>
+where
+    I: ParallelIterator,
+    F: Fn(I::Item) -> PI + Sync + Send,
+    PI: IntoParallelIterator,
+{
+    type Item = PI::Item;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        let consumer = FlatMapConsumer::new(consumer, &self.map_op);
+        self.base.drive_unindexed(consumer)
+    }
+}
+
+/// ////////////////////////////////////////////////////////////////////////
+/// Consumer implementation
+
+struct FlatMapConsumer<'f, C, F> {
+    base: C,
+    map_op: &'f F,
+}
+
+impl<'f, C, F> FlatMapConsumer<'f, C, F> {
+    fn new(base: C, map_op: &'f F) -> Self {
+        FlatMapConsumer { base, map_op }
+    }
+}
+
+impl<'f, T, U, C, F> Consumer<T> for FlatMapConsumer<'f, C, F>
+where
+    C: UnindexedConsumer<U::Item>,
+    F: Fn(T) -> U + Sync,
+    U: IntoParallelIterator,
+{
+    type Folder = FlatMapFolder<'f, C, F, C::Result>;
+    type Reducer = C::Reducer;
+    type Result = C::Result;
+
+    fn split_at(self, index: usize) -> (Self, Self, C::Reducer) {
+        let (left, right, reducer) = self.base.split_at(index);
+        (
+            FlatMapConsumer::new(left, self.map_op),
+            FlatMapConsumer::new(right, self.map_op),
+            reducer,
+        )
+    }
+
+    fn into_folder(self) -> Self::Folder {
+        FlatMapFolder {
+            base: self.base,
+            map_op: self.map_op,
+            previous: None,
+        }
+    }
+
+    fn full(&self) -> bool {
+        self.base.full()
+    }
+}
+
+impl<'f, T, U, C, F> UnindexedConsumer<T> for FlatMapConsumer<'f, C, F>
+where
+    C: UnindexedConsumer<U::Item>,
+    F: Fn(T) -> U + Sync,
+    U: IntoParallelIterator,
+{
+    fn split_off_left(&self) -> Self {
+        FlatMapConsumer::new(self.base.split_off_left(), self.map_op)
+    }
+
+    fn to_reducer(&self) -> Self::Reducer {
+        self.base.to_reducer()
+    }
+}
+
+struct FlatMapFolder<'f, C, F, R> {
+    base: C,
+    map_op: &'f F,
+    previous: Option<R>,
+}
+
+impl<'f, T, U, C, F> Folder<T> for FlatMapFolder<'f, C, F, C::Result>
+where
+    C: UnindexedConsumer<U::Item>,
+    F: Fn(T) -> U + Sync,
+    U: IntoParallelIterator,
+{
+    type Result = C::Result;
+
+    fn consume(self, item: T) -> Self {
+        let map_op = self.map_op;
+        let par_iter = map_op(item).into_par_iter();
+        let consumer = self.base.split_off_left();
+        let result = par_iter.drive_unindexed(consumer);
+
+        let previous = match self.previous {
+            None => Some(result),
+            Some(previous) => {
+                let reducer = self.base.to_reducer();
+                Some(reducer.reduce(previous, result))
+            }
+        };
+
+        FlatMapFolder {
+            base: self.base,
+            map_op,
+            previous,
+        }
+    }
+
+    fn complete(self) -> Self::Result {
+        match self.previous {
+            Some(previous) => previous,
+            None => self.base.into_folder().complete(),
+        }
+    }
+
+    fn full(&self) -> bool {
+        self.base.full()
+    }
+}
diff --git a/crates/rayon/src/iter/flat_map_iter.rs b/crates/rayon/src/iter/flat_map_iter.rs
new file mode 100644
index 0000000..c76cf68
--- /dev/null
+++ b/crates/rayon/src/iter/flat_map_iter.rs
@@ -0,0 +1,147 @@
+use super::plumbing::*;
+use super::*;
+
+use std::fmt::{self, Debug};
+
+/// `FlatMapIter` maps each element to a serial iterator, then flattens these iterators together.
+/// This struct is created by the [`flat_map_iter()`] method on [`ParallelIterator`]
+///
+/// [`flat_map_iter()`]: trait.ParallelIterator.html#method.flat_map_iter
+/// [`ParallelIterator`]: trait.ParallelIterator.html
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Clone)]
+pub struct FlatMapIter<I: ParallelIterator, F> {
+    base: I,
+    map_op: F,
+}
+
+impl<I: ParallelIterator + Debug, F> Debug for FlatMapIter<I, F> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("FlatMapIter")
+            .field("base", &self.base)
+            .finish()
+    }
+}
+
+impl<I: ParallelIterator, F> FlatMapIter<I, F> {
+    /// Creates a new `FlatMapIter` iterator.
+    pub(super) fn new(base: I, map_op: F) -> Self {
+        FlatMapIter { base, map_op }
+    }
+}
+
+impl<I, F, SI> ParallelIterator for FlatMapIter<I, F>
+where
+    I: ParallelIterator,
+    F: Fn(I::Item) -> SI + Sync + Send,
+    SI: IntoIterator,
+    SI::Item: Send,
+{
+    type Item = SI::Item;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        let consumer = FlatMapIterConsumer::new(consumer, &self.map_op);
+        self.base.drive_unindexed(consumer)
+    }
+}
+
+/// ////////////////////////////////////////////////////////////////////////
+/// Consumer implementation
+
+struct FlatMapIterConsumer<'f, C, F> {
+    base: C,
+    map_op: &'f F,
+}
+
+impl<'f, C, F> FlatMapIterConsumer<'f, C, F> {
+    fn new(base: C, map_op: &'f F) -> Self {
+        FlatMapIterConsumer { base, map_op }
+    }
+}
+
+impl<'f, T, U, C, F> Consumer<T> for FlatMapIterConsumer<'f, C, F>
+where
+    C: UnindexedConsumer<U::Item>,
+    F: Fn(T) -> U + Sync,
+    U: IntoIterator,
+{
+    type Folder = FlatMapIterFolder<'f, C::Folder, F>;
+    type Reducer = C::Reducer;
+    type Result = C::Result;
+
+    fn split_at(self, index: usize) -> (Self, Self, C::Reducer) {
+        let (left, right, reducer) = self.base.split_at(index);
+        (
+            FlatMapIterConsumer::new(left, self.map_op),
+            FlatMapIterConsumer::new(right, self.map_op),
+            reducer,
+        )
+    }
+
+    fn into_folder(self) -> Self::Folder {
+        FlatMapIterFolder {
+            base: self.base.into_folder(),
+            map_op: self.map_op,
+        }
+    }
+
+    fn full(&self) -> bool {
+        self.base.full()
+    }
+}
+
+impl<'f, T, U, C, F> UnindexedConsumer<T> for FlatMapIterConsumer<'f, C, F>
+where
+    C: UnindexedConsumer<U::Item>,
+    F: Fn(T) -> U + Sync,
+    U: IntoIterator,
+{
+    fn split_off_left(&self) -> Self {
+        FlatMapIterConsumer::new(self.base.split_off_left(), self.map_op)
+    }
+
+    fn to_reducer(&self) -> Self::Reducer {
+        self.base.to_reducer()
+    }
+}
+
+struct FlatMapIterFolder<'f, C, F> {
+    base: C,
+    map_op: &'f F,
+}
+
+impl<'f, T, U, C, F> Folder<T> for FlatMapIterFolder<'f, C, F>
+where
+    C: Folder<U::Item>,
+    F: Fn(T) -> U,
+    U: IntoIterator,
+{
+    type Result = C::Result;
+
+    fn consume(self, item: T) -> Self {
+        let map_op = self.map_op;
+        let base = self.base.consume_iter(map_op(item));
+        FlatMapIterFolder { base, map_op }
+    }
+
+    fn consume_iter<I>(self, iter: I) -> Self
+    where
+        I: IntoIterator<Item = T>,
+    {
+        let map_op = self.map_op;
+        let iter = iter.into_iter().flat_map(map_op);
+        let base = self.base.consume_iter(iter);
+        FlatMapIterFolder { base, map_op }
+    }
+
+    fn complete(self) -> Self::Result {
+        self.base.complete()
+    }
+
+    fn full(&self) -> bool {
+        self.base.full()
+    }
+}
diff --git a/crates/rayon/src/iter/flatten.rs b/crates/rayon/src/iter/flatten.rs
new file mode 100644
index 0000000..29d88f9
--- /dev/null
+++ b/crates/rayon/src/iter/flatten.rs
@@ -0,0 +1,140 @@
+use super::plumbing::*;
+use super::*;
+
+/// `Flatten` turns each element to a parallel iterator, then flattens these iterators
+/// together. This struct is created by the [`flatten()`] method on [`ParallelIterator`].
+///
+/// [`flatten()`]: trait.ParallelIterator.html#method.flatten
+/// [`ParallelIterator`]: trait.ParallelIterator.html
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Debug, Clone)]
+pub struct Flatten<I: ParallelIterator> {
+    base: I,
+}
+
+impl<I> Flatten<I>
+where
+    I: ParallelIterator,
+    I::Item: IntoParallelIterator,
+{
+    /// Creates a new `Flatten` iterator.
+    pub(super) fn new(base: I) -> Self {
+        Flatten { base }
+    }
+}
+
+impl<I> ParallelIterator for Flatten<I>
+where
+    I: ParallelIterator,
+    I::Item: IntoParallelIterator,
+{
+    type Item = <I::Item as IntoParallelIterator>::Item;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        let consumer = FlattenConsumer::new(consumer);
+        self.base.drive_unindexed(consumer)
+    }
+}
+
+/// ////////////////////////////////////////////////////////////////////////
+/// Consumer implementation
+
+struct FlattenConsumer<C> {
+    base: C,
+}
+
+impl<C> FlattenConsumer<C> {
+    fn new(base: C) -> Self {
+        FlattenConsumer { base }
+    }
+}
+
+impl<T, C> Consumer<T> for FlattenConsumer<C>
+where
+    C: UnindexedConsumer<T::Item>,
+    T: IntoParallelIterator,
+{
+    type Folder = FlattenFolder<C, C::Result>;
+    type Reducer = C::Reducer;
+    type Result = C::Result;
+
+    fn split_at(self, index: usize) -> (Self, Self, C::Reducer) {
+        let (left, right, reducer) = self.base.split_at(index);
+        (
+            FlattenConsumer::new(left),
+            FlattenConsumer::new(right),
+            reducer,
+        )
+    }
+
+    fn into_folder(self) -> Self::Folder {
+        FlattenFolder {
+            base: self.base,
+            previous: None,
+        }
+    }
+
+    fn full(&self) -> bool {
+        self.base.full()
+    }
+}
+
+impl<T, C> UnindexedConsumer<T> for FlattenConsumer<C>
+where
+    C: UnindexedConsumer<T::Item>,
+    T: IntoParallelIterator,
+{
+    fn split_off_left(&self) -> Self {
+        FlattenConsumer::new(self.base.split_off_left())
+    }
+
+    fn to_reducer(&self) -> Self::Reducer {
+        self.base.to_reducer()
+    }
+}
+
+struct FlattenFolder<C, R> {
+    base: C,
+    previous: Option<R>,
+}
+
+impl<T, C> Folder<T> for FlattenFolder<C, C::Result>
+where
+    C: UnindexedConsumer<T::Item>,
+    T: IntoParallelIterator,
+{
+    type Result = C::Result;
+
+    fn consume(self, item: T) -> Self {
+        let par_iter = item.into_par_iter();
+        let consumer = self.base.split_off_left();
+        let result = par_iter.drive_unindexed(consumer);
+
+        let previous = match self.previous {
+            None => Some(result),
+            Some(previous) => {
+                let reducer = self.base.to_reducer();
+                Some(reducer.reduce(previous, result))
+            }
+        };
+
+        FlattenFolder {
+            base: self.base,
+            previous,
+        }
+    }
+
+    fn complete(self) -> Self::Result {
+        match self.previous {
+            Some(previous) => previous,
+            None => self.base.into_folder().complete(),
+        }
+    }
+
+    fn full(&self) -> bool {
+        self.base.full()
+    }
+}
diff --git a/crates/rayon/src/iter/flatten_iter.rs b/crates/rayon/src/iter/flatten_iter.rs
new file mode 100644
index 0000000..3ce0a3c
--- /dev/null
+++ b/crates/rayon/src/iter/flatten_iter.rs
@@ -0,0 +1,132 @@
+use super::plumbing::*;
+use super::*;
+
+/// `FlattenIter` turns each element to a serial iterator, then flattens these iterators
+/// together. This struct is created by the [`flatten_iter()`] method on [`ParallelIterator`].
+///
+/// [`flatten_iter()`]: trait.ParallelIterator.html#method.flatten_iter
+/// [`ParallelIterator`]: trait.ParallelIterator.html
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Debug, Clone)]
+pub struct FlattenIter<I: ParallelIterator> {
+    base: I,
+}
+
+impl<I> FlattenIter<I>
+where
+    I: ParallelIterator,
+    I::Item: IntoIterator,
+    <I::Item as IntoIterator>::Item: Send,
+{
+    /// Creates a new `FlattenIter` iterator.
+    pub(super) fn new(base: I) -> Self {
+        FlattenIter { base }
+    }
+}
+
+impl<I> ParallelIterator for FlattenIter<I>
+where
+    I: ParallelIterator,
+    I::Item: IntoIterator,
+    <I::Item as IntoIterator>::Item: Send,
+{
+    type Item = <I::Item as IntoIterator>::Item;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        let consumer = FlattenIterConsumer::new(consumer);
+        self.base.drive_unindexed(consumer)
+    }
+}
+
+/// ////////////////////////////////////////////////////////////////////////
+/// Consumer implementation
+
+struct FlattenIterConsumer<C> {
+    base: C,
+}
+
+impl<C> FlattenIterConsumer<C> {
+    fn new(base: C) -> Self {
+        FlattenIterConsumer { base }
+    }
+}
+
+impl<T, C> Consumer<T> for FlattenIterConsumer<C>
+where
+    C: UnindexedConsumer<T::Item>,
+    T: IntoIterator,
+{
+    type Folder = FlattenIterFolder<C::Folder>;
+    type Reducer = C::Reducer;
+    type Result = C::Result;
+
+    fn split_at(self, index: usize) -> (Self, Self, C::Reducer) {
+        let (left, right, reducer) = self.base.split_at(index);
+        (
+            FlattenIterConsumer::new(left),
+            FlattenIterConsumer::new(right),
+            reducer,
+        )
+    }
+
+    fn into_folder(self) -> Self::Folder {
+        FlattenIterFolder {
+            base: self.base.into_folder(),
+        }
+    }
+
+    fn full(&self) -> bool {
+        self.base.full()
+    }
+}
+
+impl<T, C> UnindexedConsumer<T> for FlattenIterConsumer<C>
+where
+    C: UnindexedConsumer<T::Item>,
+    T: IntoIterator,
+{
+    fn split_off_left(&self) -> Self {
+        FlattenIterConsumer::new(self.base.split_off_left())
+    }
+
+    fn to_reducer(&self) -> Self::Reducer {
+        self.base.to_reducer()
+    }
+}
+
+struct FlattenIterFolder<C> {
+    base: C,
+}
+
+impl<T, C> Folder<T> for FlattenIterFolder<C>
+where
+    C: Folder<T::Item>,
+    T: IntoIterator,
+{
+    type Result = C::Result;
+
+    fn consume(self, item: T) -> Self {
+        let base = self.base.consume_iter(item);
+        FlattenIterFolder { base }
+    }
+
+    fn consume_iter<I>(self, iter: I) -> Self
+    where
+        I: IntoIterator<Item = T>,
+    {
+        let iter = iter.into_iter().flatten();
+        let base = self.base.consume_iter(iter);
+        FlattenIterFolder { base }
+    }
+
+    fn complete(self) -> Self::Result {
+        self.base.complete()
+    }
+
+    fn full(&self) -> bool {
+        self.base.full()
+    }
+}
diff --git a/crates/rayon/src/iter/fold.rs b/crates/rayon/src/iter/fold.rs
new file mode 100644
index 0000000..345afbd
--- /dev/null
+++ b/crates/rayon/src/iter/fold.rs
@@ -0,0 +1,302 @@
+use super::plumbing::*;
+use super::*;
+
+use std::fmt::{self, Debug};
+
+impl<U, I, ID, F> Fold<I, ID, F>
+where
+    I: ParallelIterator,
+    F: Fn(U, I::Item) -> U + Sync + Send,
+    ID: Fn() -> U + Sync + Send,
+    U: Send,
+{
+    pub(super) fn new(base: I, identity: ID, fold_op: F) -> Self {
+        Fold {
+            base,
+            identity,
+            fold_op,
+        }
+    }
+}
+
+/// `Fold` is an iterator that applies a function over an iterator producing a single value.
+/// This struct is created by the [`fold()`] method on [`ParallelIterator`]
+///
+/// [`fold()`]: trait.ParallelIterator.html#method.fold
+/// [`ParallelIterator`]: trait.ParallelIterator.html
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Clone)]
+pub struct Fold<I, ID, F> {
+    base: I,
+    identity: ID,
+    fold_op: F,
+}
+
+impl<I: ParallelIterator + Debug, ID, F> Debug for Fold<I, ID, F> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Fold").field("base", &self.base).finish()
+    }
+}
+
+impl<U, I, ID, F> ParallelIterator for Fold<I, ID, F>
+where
+    I: ParallelIterator,
+    F: Fn(U, I::Item) -> U + Sync + Send,
+    ID: Fn() -> U + Sync + Send,
+    U: Send,
+{
+    type Item = U;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        let consumer1 = FoldConsumer {
+            base: consumer,
+            fold_op: &self.fold_op,
+            identity: &self.identity,
+        };
+        self.base.drive_unindexed(consumer1)
+    }
+}
+
+struct FoldConsumer<'c, C, ID, F> {
+    base: C,
+    fold_op: &'c F,
+    identity: &'c ID,
+}
+
+impl<'r, U, T, C, ID, F> Consumer<T> for FoldConsumer<'r, C, ID, F>
+where
+    C: Consumer<U>,
+    F: Fn(U, T) -> U + Sync,
+    ID: Fn() -> U + Sync,
+    U: Send,
+{
+    type Folder = FoldFolder<'r, C::Folder, U, F>;
+    type Reducer = C::Reducer;
+    type Result = C::Result;
+
+    fn split_at(self, index: usize) -> (Self, Self, Self::Reducer) {
+        let (left, right, reducer) = self.base.split_at(index);
+        (
+            FoldConsumer { base: left, ..self },
+            FoldConsumer {
+                base: right,
+                ..self
+            },
+            reducer,
+        )
+    }
+
+    fn into_folder(self) -> Self::Folder {
+        FoldFolder {
+            base: self.base.into_folder(),
+            item: (self.identity)(),
+            fold_op: self.fold_op,
+        }
+    }
+
+    fn full(&self) -> bool {
+        self.base.full()
+    }
+}
+
+impl<'r, U, T, C, ID, F> UnindexedConsumer<T> for FoldConsumer<'r, C, ID, F>
+where
+    C: UnindexedConsumer<U>,
+    F: Fn(U, T) -> U + Sync,
+    ID: Fn() -> U + Sync,
+    U: Send,
+{
+    fn split_off_left(&self) -> Self {
+        FoldConsumer {
+            base: self.base.split_off_left(),
+            ..*self
+        }
+    }
+
+    fn to_reducer(&self) -> Self::Reducer {
+        self.base.to_reducer()
+    }
+}
+
+struct FoldFolder<'r, C, ID, F> {
+    base: C,
+    fold_op: &'r F,
+    item: ID,
+}
+
+impl<'r, C, ID, F, T> Folder<T> for FoldFolder<'r, C, ID, F>
+where
+    C: Folder<ID>,
+    F: Fn(ID, T) -> ID + Sync,
+{
+    type Result = C::Result;
+
+    fn consume(self, item: T) -> Self {
+        let item = (self.fold_op)(self.item, item);
+        FoldFolder {
+            base: self.base,
+            fold_op: self.fold_op,
+            item,
+        }
+    }
+
+    fn consume_iter<I>(self, iter: I) -> Self
+    where
+        I: IntoIterator<Item = T>,
+    {
+        fn not_full<C, ID, T>(base: &C) -> impl Fn(&T) -> bool + '_
+        where
+            C: Folder<ID>,
+        {
+            move |_| !base.full()
+        }
+
+        let base = self.base;
+        let item = iter
+            .into_iter()
+            // stop iterating if another thread has finished
+            .take_while(not_full(&base))
+            .fold(self.item, self.fold_op);
+
+        FoldFolder {
+            base,
+            item,
+            fold_op: self.fold_op,
+        }
+    }
+
+    fn complete(self) -> C::Result {
+        self.base.consume(self.item).complete()
+    }
+
+    fn full(&self) -> bool {
+        self.base.full()
+    }
+}
+
+// ///////////////////////////////////////////////////////////////////////////
+
+impl<U, I, F> FoldWith<I, U, F>
+where
+    I: ParallelIterator,
+    F: Fn(U, I::Item) -> U + Sync + Send,
+    U: Send + Clone,
+{
+    pub(super) fn new(base: I, item: U, fold_op: F) -> Self {
+        FoldWith {
+            base,
+            item,
+            fold_op,
+        }
+    }
+}
+
+/// `FoldWith` is an iterator that applies a function over an iterator producing a single value.
+/// This struct is created by the [`fold_with()`] method on [`ParallelIterator`]
+///
+/// [`fold_with()`]: trait.ParallelIterator.html#method.fold_with
+/// [`ParallelIterator`]: trait.ParallelIterator.html
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Clone)]
+pub struct FoldWith<I, U, F> {
+    base: I,
+    item: U,
+    fold_op: F,
+}
+
+impl<I: ParallelIterator + Debug, U: Debug, F> Debug for FoldWith<I, U, F> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("FoldWith")
+            .field("base", &self.base)
+            .field("item", &self.item)
+            .finish()
+    }
+}
+
+impl<U, I, F> ParallelIterator for FoldWith<I, U, F>
+where
+    I: ParallelIterator,
+    F: Fn(U, I::Item) -> U + Sync + Send,
+    U: Send + Clone,
+{
+    type Item = U;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        let consumer1 = FoldWithConsumer {
+            base: consumer,
+            item: self.item,
+            fold_op: &self.fold_op,
+        };
+        self.base.drive_unindexed(consumer1)
+    }
+}
+
+struct FoldWithConsumer<'c, C, U, F> {
+    base: C,
+    item: U,
+    fold_op: &'c F,
+}
+
+impl<'r, U, T, C, F> Consumer<T> for FoldWithConsumer<'r, C, U, F>
+where
+    C: Consumer<U>,
+    F: Fn(U, T) -> U + Sync,
+    U: Send + Clone,
+{
+    type Folder = FoldFolder<'r, C::Folder, U, F>;
+    type Reducer = C::Reducer;
+    type Result = C::Result;
+
+    fn split_at(self, index: usize) -> (Self, Self, Self::Reducer) {
+        let (left, right, reducer) = self.base.split_at(index);
+        (
+            FoldWithConsumer {
+                base: left,
+                item: self.item.clone(),
+                ..self
+            },
+            FoldWithConsumer {
+                base: right,
+                ..self
+            },
+            reducer,
+        )
+    }
+
+    fn into_folder(self) -> Self::Folder {
+        FoldFolder {
+            base: self.base.into_folder(),
+            item: self.item,
+            fold_op: self.fold_op,
+        }
+    }
+
+    fn full(&self) -> bool {
+        self.base.full()
+    }
+}
+
+impl<'r, U, T, C, F> UnindexedConsumer<T> for FoldWithConsumer<'r, C, U, F>
+where
+    C: UnindexedConsumer<U>,
+    F: Fn(U, T) -> U + Sync,
+    U: Send + Clone,
+{
+    fn split_off_left(&self) -> Self {
+        FoldWithConsumer {
+            base: self.base.split_off_left(),
+            item: self.item.clone(),
+            ..*self
+        }
+    }
+
+    fn to_reducer(&self) -> Self::Reducer {
+        self.base.to_reducer()
+    }
+}
diff --git a/crates/rayon/src/iter/fold_chunks.rs b/crates/rayon/src/iter/fold_chunks.rs
new file mode 100644
index 0000000..185fb1a
--- /dev/null
+++ b/crates/rayon/src/iter/fold_chunks.rs
@@ -0,0 +1,236 @@
+use std::fmt::{self, Debug};
+
+use super::chunks::ChunkProducer;
+use super::plumbing::*;
+use super::*;
+use crate::math::div_round_up;
+
+/// `FoldChunks` is an iterator that groups elements of an underlying iterator and applies a
+/// function over them, producing a single value for each group.
+///
+/// This struct is created by the [`fold_chunks()`] method on [`IndexedParallelIterator`]
+///
+/// [`fold_chunks()`]: trait.IndexedParallelIterator.html#method.fold_chunks
+/// [`IndexedParallelIterator`]: trait.IndexedParallelIterator.html
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Clone)]
+pub struct FoldChunks<I, ID, F>
+where
+    I: IndexedParallelIterator,
+{
+    base: I,
+    chunk_size: usize,
+    fold_op: F,
+    identity: ID,
+}
+
+impl<I: IndexedParallelIterator + Debug, ID, F> Debug for FoldChunks<I, ID, F> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Fold")
+            .field("base", &self.base)
+            .field("chunk_size", &self.chunk_size)
+            .finish()
+    }
+}
+
+impl<I, ID, U, F> FoldChunks<I, ID, F>
+where
+    I: IndexedParallelIterator,
+    ID: Fn() -> U + Send + Sync,
+    F: Fn(U, I::Item) -> U + Send + Sync,
+    U: Send,
+{
+    /// Creates a new `FoldChunks` iterator
+    pub(super) fn new(base: I, chunk_size: usize, identity: ID, fold_op: F) -> Self {
+        FoldChunks {
+            base,
+            chunk_size,
+            identity,
+            fold_op,
+        }
+    }
+}
+
+impl<I, ID, U, F> ParallelIterator for FoldChunks<I, ID, F>
+where
+    I: IndexedParallelIterator,
+    ID: Fn() -> U + Send + Sync,
+    F: Fn(U, I::Item) -> U + Send + Sync,
+    U: Send,
+{
+    type Item = U;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<U>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        Some(self.len())
+    }
+}
+
+impl<I, ID, U, F> IndexedParallelIterator for FoldChunks<I, ID, F>
+where
+    I: IndexedParallelIterator,
+    ID: Fn() -> U + Send + Sync,
+    F: Fn(U, I::Item) -> U + Send + Sync,
+    U: Send,
+{
+    fn len(&self) -> usize {
+        div_round_up(self.base.len(), self.chunk_size)
+    }
+
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        let len = self.base.len();
+        return self.base.with_producer(Callback {
+            chunk_size: self.chunk_size,
+            len,
+            identity: self.identity,
+            fold_op: self.fold_op,
+            callback,
+        });
+
+        struct Callback<CB, ID, F> {
+            chunk_size: usize,
+            len: usize,
+            identity: ID,
+            fold_op: F,
+            callback: CB,
+        }
+
+        impl<T, CB, ID, U, F> ProducerCallback<T> for Callback<CB, ID, F>
+        where
+            CB: ProducerCallback<U>,
+            ID: Fn() -> U + Send + Sync,
+            F: Fn(U, T) -> U + Send + Sync,
+        {
+            type Output = CB::Output;
+
+            fn callback<P>(self, base: P) -> CB::Output
+            where
+                P: Producer<Item = T>,
+            {
+                let identity = &self.identity;
+                let fold_op = &self.fold_op;
+                let fold_iter = move |iter: P::IntoIter| iter.fold(identity(), fold_op);
+                let producer = ChunkProducer::new(self.chunk_size, self.len, base, fold_iter);
+                self.callback.callback(producer)
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use std::ops::Add;
+
+    #[test]
+    fn check_fold_chunks() {
+        let words = "bishbashbosh!"
+            .chars()
+            .collect::<Vec<_>>()
+            .into_par_iter()
+            .fold_chunks(4, String::new, |mut s, c| {
+                s.push(c);
+                s
+            })
+            .collect::<Vec<_>>();
+
+        assert_eq!(words, vec!["bish", "bash", "bosh", "!"]);
+    }
+
+    // 'closure' values for tests below
+    fn id() -> i32 {
+        0
+    }
+    fn sum<T, U>(x: T, y: U) -> T
+    where
+        T: Add<U, Output = T>,
+    {
+        x + y
+    }
+
+    #[test]
+    #[should_panic(expected = "chunk_size must not be zero")]
+    fn check_fold_chunks_zero_size() {
+        let _: Vec<i32> = vec![1, 2, 3]
+            .into_par_iter()
+            .fold_chunks(0, id, sum)
+            .collect();
+    }
+
+    #[test]
+    fn check_fold_chunks_even_size() {
+        assert_eq!(
+            vec![1 + 2 + 3, 4 + 5 + 6, 7 + 8 + 9],
+            (1..10)
+                .into_par_iter()
+                .fold_chunks(3, id, sum)
+                .collect::<Vec<i32>>()
+        );
+    }
+
+    #[test]
+    fn check_fold_chunks_empty() {
+        let v: Vec<i32> = vec![];
+        let expected: Vec<i32> = vec![];
+        assert_eq!(
+            expected,
+            v.into_par_iter()
+                .fold_chunks(2, id, sum)
+                .collect::<Vec<i32>>()
+        );
+    }
+
+    #[test]
+    fn check_fold_chunks_len() {
+        assert_eq!(4, (0..8).into_par_iter().fold_chunks(2, id, sum).len());
+        assert_eq!(3, (0..9).into_par_iter().fold_chunks(3, id, sum).len());
+        assert_eq!(3, (0..8).into_par_iter().fold_chunks(3, id, sum).len());
+        assert_eq!(1, (&[1]).par_iter().fold_chunks(3, id, sum).len());
+        assert_eq!(0, (0..0).into_par_iter().fold_chunks(3, id, sum).len());
+    }
+
+    #[test]
+    fn check_fold_chunks_uneven() {
+        let cases: Vec<(Vec<u32>, usize, Vec<u32>)> = vec![
+            ((0..5).collect(), 3, vec![0 + 1 + 2, 3 + 4]),
+            (vec![1], 5, vec![1]),
+            ((0..4).collect(), 3, vec![0 + 1 + 2, 3]),
+        ];
+
+        for (i, (v, n, expected)) in cases.into_iter().enumerate() {
+            let mut res: Vec<u32> = vec![];
+            v.par_iter()
+                .fold_chunks(n, || 0, sum)
+                .collect_into_vec(&mut res);
+            assert_eq!(expected, res, "Case {} failed", i);
+
+            res.truncate(0);
+            v.into_par_iter()
+                .fold_chunks(n, || 0, sum)
+                .rev()
+                .collect_into_vec(&mut res);
+            assert_eq!(
+                expected.into_iter().rev().collect::<Vec<u32>>(),
+                res,
+                "Case {} reversed failed",
+                i
+            );
+        }
+    }
+}
diff --git a/crates/rayon/src/iter/fold_chunks_with.rs b/crates/rayon/src/iter/fold_chunks_with.rs
new file mode 100644
index 0000000..af120ae
--- /dev/null
+++ b/crates/rayon/src/iter/fold_chunks_with.rs
@@ -0,0 +1,231 @@
+use std::fmt::{self, Debug};
+
+use super::chunks::ChunkProducer;
+use super::plumbing::*;
+use super::*;
+use crate::math::div_round_up;
+
+/// `FoldChunksWith` is an iterator that groups elements of an underlying iterator and applies a
+/// function over them, producing a single value for each group.
+///
+/// This struct is created by the [`fold_chunks_with()`] method on [`IndexedParallelIterator`]
+///
+/// [`fold_chunks_with()`]: trait.IndexedParallelIterator.html#method.fold_chunks
+/// [`IndexedParallelIterator`]: trait.IndexedParallelIterator.html
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Clone)]
+pub struct FoldChunksWith<I, U, F>
+where
+    I: IndexedParallelIterator,
+{
+    base: I,
+    chunk_size: usize,
+    item: U,
+    fold_op: F,
+}
+
+impl<I: IndexedParallelIterator + Debug, U: Debug, F> Debug for FoldChunksWith<I, U, F> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Fold")
+            .field("base", &self.base)
+            .field("chunk_size", &self.chunk_size)
+            .field("item", &self.item)
+            .finish()
+    }
+}
+
+impl<I, U, F> FoldChunksWith<I, U, F>
+where
+    I: IndexedParallelIterator,
+    U: Send + Clone,
+    F: Fn(U, I::Item) -> U + Send + Sync,
+{
+    /// Creates a new `FoldChunksWith` iterator
+    pub(super) fn new(base: I, chunk_size: usize, item: U, fold_op: F) -> Self {
+        FoldChunksWith {
+            base,
+            chunk_size,
+            item,
+            fold_op,
+        }
+    }
+}
+
+impl<I, U, F> ParallelIterator for FoldChunksWith<I, U, F>
+where
+    I: IndexedParallelIterator,
+    U: Send + Clone,
+    F: Fn(U, I::Item) -> U + Send + Sync,
+{
+    type Item = U;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<U>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        Some(self.len())
+    }
+}
+
+impl<I, U, F> IndexedParallelIterator for FoldChunksWith<I, U, F>
+where
+    I: IndexedParallelIterator,
+    U: Send + Clone,
+    F: Fn(U, I::Item) -> U + Send + Sync,
+{
+    fn len(&self) -> usize {
+        div_round_up(self.base.len(), self.chunk_size)
+    }
+
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        let len = self.base.len();
+        return self.base.with_producer(Callback {
+            chunk_size: self.chunk_size,
+            len,
+            item: self.item,
+            fold_op: self.fold_op,
+            callback,
+        });
+
+        struct Callback<CB, T, F> {
+            chunk_size: usize,
+            len: usize,
+            item: T,
+            fold_op: F,
+            callback: CB,
+        }
+
+        impl<T, U, F, CB> ProducerCallback<T> for Callback<CB, U, F>
+        where
+            CB: ProducerCallback<U>,
+            U: Send + Clone,
+            F: Fn(U, T) -> U + Send + Sync,
+        {
+            type Output = CB::Output;
+
+            fn callback<P>(self, base: P) -> CB::Output
+            where
+                P: Producer<Item = T>,
+            {
+                let item = self.item;
+                let fold_op = &self.fold_op;
+                let fold_iter = move |iter: P::IntoIter| iter.fold(item.clone(), fold_op);
+                let producer = ChunkProducer::new(self.chunk_size, self.len, base, fold_iter);
+                self.callback.callback(producer)
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use std::ops::Add;
+
+    #[test]
+    fn check_fold_chunks_with() {
+        let words = "bishbashbosh!"
+            .chars()
+            .collect::<Vec<_>>()
+            .into_par_iter()
+            .fold_chunks_with(4, String::new(), |mut s, c| {
+                s.push(c);
+                s
+            })
+            .collect::<Vec<_>>();
+
+        assert_eq!(words, vec!["bish", "bash", "bosh", "!"]);
+    }
+
+    // 'closure' value for tests below
+    fn sum<T, U>(x: T, y: U) -> T
+    where
+        T: Add<U, Output = T>,
+    {
+        x + y
+    }
+
+    #[test]
+    #[should_panic(expected = "chunk_size must not be zero")]
+    fn check_fold_chunks_zero_size() {
+        let _: Vec<i32> = vec![1, 2, 3]
+            .into_par_iter()
+            .fold_chunks_with(0, 0, sum)
+            .collect();
+    }
+
+    #[test]
+    fn check_fold_chunks_even_size() {
+        assert_eq!(
+            vec![1 + 2 + 3, 4 + 5 + 6, 7 + 8 + 9],
+            (1..10)
+                .into_par_iter()
+                .fold_chunks_with(3, 0, sum)
+                .collect::<Vec<i32>>()
+        );
+    }
+
+    #[test]
+    fn check_fold_chunks_with_empty() {
+        let v: Vec<i32> = vec![];
+        let expected: Vec<i32> = vec![];
+        assert_eq!(
+            expected,
+            v.into_par_iter()
+                .fold_chunks_with(2, 0, sum)
+                .collect::<Vec<i32>>()
+        );
+    }
+
+    #[test]
+    fn check_fold_chunks_len() {
+        assert_eq!(4, (0..8).into_par_iter().fold_chunks_with(2, 0, sum).len());
+        assert_eq!(3, (0..9).into_par_iter().fold_chunks_with(3, 0, sum).len());
+        assert_eq!(3, (0..8).into_par_iter().fold_chunks_with(3, 0, sum).len());
+        assert_eq!(1, (&[1]).par_iter().fold_chunks_with(3, 0, sum).len());
+        assert_eq!(0, (0..0).into_par_iter().fold_chunks_with(3, 0, sum).len());
+    }
+
+    #[test]
+    fn check_fold_chunks_uneven() {
+        let cases: Vec<(Vec<u32>, usize, Vec<u32>)> = vec![
+            ((0..5).collect(), 3, vec![0 + 1 + 2, 3 + 4]),
+            (vec![1], 5, vec![1]),
+            ((0..4).collect(), 3, vec![0 + 1 + 2, 3]),
+        ];
+
+        for (i, (v, n, expected)) in cases.into_iter().enumerate() {
+            let mut res: Vec<u32> = vec![];
+            v.par_iter()
+                .fold_chunks_with(n, 0, sum)
+                .collect_into_vec(&mut res);
+            assert_eq!(expected, res, "Case {} failed", i);
+
+            res.truncate(0);
+            v.into_par_iter()
+                .fold_chunks_with(n, 0, sum)
+                .rev()
+                .collect_into_vec(&mut res);
+            assert_eq!(
+                expected.into_iter().rev().collect::<Vec<u32>>(),
+                res,
+                "Case {} reversed failed",
+                i
+            );
+        }
+    }
+}
diff --git a/crates/rayon/src/iter/for_each.rs b/crates/rayon/src/iter/for_each.rs
new file mode 100644
index 0000000..3b77beb
--- /dev/null
+++ b/crates/rayon/src/iter/for_each.rs
@@ -0,0 +1,77 @@
+use super::noop::*;
+use super::plumbing::*;
+use super::ParallelIterator;
+
+pub(super) fn for_each<I, F, T>(pi: I, op: &F)
+where
+    I: ParallelIterator<Item = T>,
+    F: Fn(T) + Sync,
+    T: Send,
+{
+    let consumer = ForEachConsumer { op };
+    pi.drive_unindexed(consumer)
+}
+
+struct ForEachConsumer<'f, F> {
+    op: &'f F,
+}
+
+impl<'f, F, T> Consumer<T> for ForEachConsumer<'f, F>
+where
+    F: Fn(T) + Sync,
+{
+    type Folder = ForEachConsumer<'f, F>;
+    type Reducer = NoopReducer;
+    type Result = ();
+
+    fn split_at(self, _index: usize) -> (Self, Self, NoopReducer) {
+        (self.split_off_left(), self, NoopReducer)
+    }
+
+    fn into_folder(self) -> Self {
+        self
+    }
+
+    fn full(&self) -> bool {
+        false
+    }
+}
+
+impl<'f, F, T> Folder<T> for ForEachConsumer<'f, F>
+where
+    F: Fn(T) + Sync,
+{
+    type Result = ();
+
+    fn consume(self, item: T) -> Self {
+        (self.op)(item);
+        self
+    }
+
+    fn consume_iter<I>(self, iter: I) -> Self
+    where
+        I: IntoIterator<Item = T>,
+    {
+        iter.into_iter().for_each(self.op);
+        self
+    }
+
+    fn complete(self) {}
+
+    fn full(&self) -> bool {
+        false
+    }
+}
+
+impl<'f, F, T> UnindexedConsumer<T> for ForEachConsumer<'f, F>
+where
+    F: Fn(T) + Sync,
+{
+    fn split_off_left(&self) -> Self {
+        ForEachConsumer { op: self.op }
+    }
+
+    fn to_reducer(&self) -> NoopReducer {
+        NoopReducer
+    }
+}
diff --git a/crates/rayon/src/iter/from_par_iter.rs b/crates/rayon/src/iter/from_par_iter.rs
new file mode 100644
index 0000000..49afd6c
--- /dev/null
+++ b/crates/rayon/src/iter/from_par_iter.rs
@@ -0,0 +1,279 @@
+use super::noop::NoopConsumer;
+use super::{FromParallelIterator, IntoParallelIterator, ParallelExtend, ParallelIterator};
+
+use std::borrow::Cow;
+use std::collections::LinkedList;
+use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
+use std::collections::{BinaryHeap, VecDeque};
+use std::hash::{BuildHasher, Hash};
+use std::rc::Rc;
+use std::sync::Arc;
+
+/// Creates an empty default collection and extends it.
+fn collect_extended<C, I>(par_iter: I) -> C
+where
+    I: IntoParallelIterator,
+    C: ParallelExtend<I::Item> + Default,
+{
+    let mut collection = C::default();
+    collection.par_extend(par_iter);
+    collection
+}
+
+/// Collects items from a parallel iterator into a vector.
+impl<T> FromParallelIterator<T> for Vec<T>
+where
+    T: Send,
+{
+    fn from_par_iter<I>(par_iter: I) -> Self
+    where
+        I: IntoParallelIterator<Item = T>,
+    {
+        collect_extended(par_iter)
+    }
+}
+
+/// Collects items from a parallel iterator into a boxed slice.
+impl<T> FromParallelIterator<T> for Box<[T]>
+where
+    T: Send,
+{
+    fn from_par_iter<I>(par_iter: I) -> Self
+    where
+        I: IntoParallelIterator<Item = T>,
+    {
+        Vec::from_par_iter(par_iter).into()
+    }
+}
+
+/// Collects items from a parallel iterator into a reference-counted slice.
+impl<T> FromParallelIterator<T> for Rc<[T]>
+where
+    T: Send,
+{
+    fn from_par_iter<I>(par_iter: I) -> Self
+    where
+        I: IntoParallelIterator<Item = T>,
+    {
+        Vec::from_par_iter(par_iter).into()
+    }
+}
+
+/// Collects items from a parallel iterator into an atomically-reference-counted slice.
+impl<T> FromParallelIterator<T> for Arc<[T]>
+where
+    T: Send,
+{
+    fn from_par_iter<I>(par_iter: I) -> Self
+    where
+        I: IntoParallelIterator<Item = T>,
+    {
+        Vec::from_par_iter(par_iter).into()
+    }
+}
+
+/// Collects items from a parallel iterator into a vecdeque.
+impl<T> FromParallelIterator<T> for VecDeque<T>
+where
+    T: Send,
+{
+    fn from_par_iter<I>(par_iter: I) -> Self
+    where
+        I: IntoParallelIterator<Item = T>,
+    {
+        Vec::from_par_iter(par_iter).into()
+    }
+}
+
+/// Collects items from a parallel iterator into a binaryheap.
+/// The heap-ordering is calculated serially after all items are collected.
+impl<T> FromParallelIterator<T> for BinaryHeap<T>
+where
+    T: Ord + Send,
+{
+    fn from_par_iter<I>(par_iter: I) -> Self
+    where
+        I: IntoParallelIterator<Item = T>,
+    {
+        Vec::from_par_iter(par_iter).into()
+    }
+}
+
+/// Collects items from a parallel iterator into a freshly allocated
+/// linked list.
+impl<T> FromParallelIterator<T> for LinkedList<T>
+where
+    T: Send,
+{
+    fn from_par_iter<I>(par_iter: I) -> Self
+    where
+        I: IntoParallelIterator<Item = T>,
+    {
+        collect_extended(par_iter)
+    }
+}
+
+/// Collects (key, value) pairs from a parallel iterator into a
+/// hashmap. If multiple pairs correspond to the same key, then the
+/// ones produced earlier in the parallel iterator will be
+/// overwritten, just as with a sequential iterator.
+impl<K, V, S> FromParallelIterator<(K, V)> for HashMap<K, V, S>
+where
+    K: Eq + Hash + Send,
+    V: Send,
+    S: BuildHasher + Default + Send,
+{
+    fn from_par_iter<I>(par_iter: I) -> Self
+    where
+        I: IntoParallelIterator<Item = (K, V)>,
+    {
+        collect_extended(par_iter)
+    }
+}
+
+/// Collects (key, value) pairs from a parallel iterator into a
+/// btreemap. If multiple pairs correspond to the same key, then the
+/// ones produced earlier in the parallel iterator will be
+/// overwritten, just as with a sequential iterator.
+impl<K, V> FromParallelIterator<(K, V)> for BTreeMap<K, V>
+where
+    K: Ord + Send,
+    V: Send,
+{
+    fn from_par_iter<I>(par_iter: I) -> Self
+    where
+        I: IntoParallelIterator<Item = (K, V)>,
+    {
+        collect_extended(par_iter)
+    }
+}
+
+/// Collects values from a parallel iterator into a hashset.
+impl<V, S> FromParallelIterator<V> for HashSet<V, S>
+where
+    V: Eq + Hash + Send,
+    S: BuildHasher + Default + Send,
+{
+    fn from_par_iter<I>(par_iter: I) -> Self
+    where
+        I: IntoParallelIterator<Item = V>,
+    {
+        collect_extended(par_iter)
+    }
+}
+
+/// Collects values from a parallel iterator into a btreeset.
+impl<V> FromParallelIterator<V> for BTreeSet<V>
+where
+    V: Send + Ord,
+{
+    fn from_par_iter<I>(par_iter: I) -> Self
+    where
+        I: IntoParallelIterator<Item = V>,
+    {
+        collect_extended(par_iter)
+    }
+}
+
+/// Collects characters from a parallel iterator into a string.
+impl FromParallelIterator<char> for String {
+    fn from_par_iter<I>(par_iter: I) -> Self
+    where
+        I: IntoParallelIterator<Item = char>,
+    {
+        collect_extended(par_iter)
+    }
+}
+
+/// Collects characters from a parallel iterator into a string.
+impl<'a> FromParallelIterator<&'a char> for String {
+    fn from_par_iter<I>(par_iter: I) -> Self
+    where
+        I: IntoParallelIterator<Item = &'a char>,
+    {
+        collect_extended(par_iter)
+    }
+}
+
+/// Collects string slices from a parallel iterator into a string.
+impl<'a> FromParallelIterator<&'a str> for String {
+    fn from_par_iter<I>(par_iter: I) -> Self
+    where
+        I: IntoParallelIterator<Item = &'a str>,
+    {
+        collect_extended(par_iter)
+    }
+}
+
+/// Collects strings from a parallel iterator into one large string.
+impl FromParallelIterator<String> for String {
+    fn from_par_iter<I>(par_iter: I) -> Self
+    where
+        I: IntoParallelIterator<Item = String>,
+    {
+        collect_extended(par_iter)
+    }
+}
+
+/// Collects boxed strings from a parallel iterator into one large string.
+impl FromParallelIterator<Box<str>> for String {
+    fn from_par_iter<I>(par_iter: I) -> Self
+    where
+        I: IntoParallelIterator<Item = Box<str>>,
+    {
+        collect_extended(par_iter)
+    }
+}
+
+/// Collects string slices from a parallel iterator into a string.
+impl<'a> FromParallelIterator<Cow<'a, str>> for String {
+    fn from_par_iter<I>(par_iter: I) -> Self
+    where
+        I: IntoParallelIterator<Item = Cow<'a, str>>,
+    {
+        collect_extended(par_iter)
+    }
+}
+
+/// Collects an arbitrary `Cow` collection.
+///
+/// Note, the standard library only has `FromIterator` for `Cow<'a, str>` and
+/// `Cow<'a, [T]>`, because no one thought to add a blanket implementation
+/// before it was stabilized.
+impl<'a, C: ?Sized, T> FromParallelIterator<T> for Cow<'a, C>
+where
+    C: ToOwned,
+    C::Owned: FromParallelIterator<T>,
+    T: Send,
+{
+    fn from_par_iter<I>(par_iter: I) -> Self
+    where
+        I: IntoParallelIterator<Item = T>,
+    {
+        Cow::Owned(C::Owned::from_par_iter(par_iter))
+    }
+}
+
+/// Collapses all unit items from a parallel iterator into one.
+///
+/// This is more useful when combined with higher-level abstractions, like
+/// collecting to a `Result<(), E>` where you only care about errors:
+///
+/// ```
+/// use std::io::*;
+/// use rayon::prelude::*;
+///
+/// let data = vec![1, 2, 3, 4, 5];
+/// let res: Result<()> = data.par_iter()
+///     .map(|x| writeln!(stdout(), "{}", x))
+///     .collect();
+/// assert!(res.is_ok());
+/// ```
+impl FromParallelIterator<()> for () {
+    fn from_par_iter<I>(par_iter: I) -> Self
+    where
+        I: IntoParallelIterator<Item = ()>,
+    {
+        par_iter.into_par_iter().drive_unindexed(NoopConsumer)
+    }
+}
diff --git a/crates/rayon/src/iter/inspect.rs b/crates/rayon/src/iter/inspect.rs
new file mode 100644
index 0000000..c50ca02
--- /dev/null
+++ b/crates/rayon/src/iter/inspect.rs
@@ -0,0 +1,257 @@
+use super::plumbing::*;
+use super::*;
+
+use std::fmt::{self, Debug};
+use std::iter;
+
+/// `Inspect` is an iterator that calls a function with a reference to each
+/// element before yielding it.
+///
+/// This struct is created by the [`inspect()`] method on [`ParallelIterator`]
+///
+/// [`inspect()`]: trait.ParallelIterator.html#method.inspect
+/// [`ParallelIterator`]: trait.ParallelIterator.html
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Clone)]
+pub struct Inspect<I: ParallelIterator, F> {
+    base: I,
+    inspect_op: F,
+}
+
+impl<I: ParallelIterator + Debug, F> Debug for Inspect<I, F> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Inspect").field("base", &self.base).finish()
+    }
+}
+
+impl<I, F> Inspect<I, F>
+where
+    I: ParallelIterator,
+{
+    /// Creates a new `Inspect` iterator.
+    pub(super) fn new(base: I, inspect_op: F) -> Self {
+        Inspect { base, inspect_op }
+    }
+}
+
+impl<I, F> ParallelIterator for Inspect<I, F>
+where
+    I: ParallelIterator,
+    F: Fn(&I::Item) + Sync + Send,
+{
+    type Item = I::Item;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        let consumer1 = InspectConsumer::new(consumer, &self.inspect_op);
+        self.base.drive_unindexed(consumer1)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        self.base.opt_len()
+    }
+}
+
+impl<I, F> IndexedParallelIterator for Inspect<I, F>
+where
+    I: IndexedParallelIterator,
+    F: Fn(&I::Item) + Sync + Send,
+{
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        let consumer1 = InspectConsumer::new(consumer, &self.inspect_op);
+        self.base.drive(consumer1)
+    }
+
+    fn len(&self) -> usize {
+        self.base.len()
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        return self.base.with_producer(Callback {
+            callback,
+            inspect_op: self.inspect_op,
+        });
+
+        struct Callback<CB, F> {
+            callback: CB,
+            inspect_op: F,
+        }
+
+        impl<T, F, CB> ProducerCallback<T> for Callback<CB, F>
+        where
+            CB: ProducerCallback<T>,
+            F: Fn(&T) + Sync,
+        {
+            type Output = CB::Output;
+
+            fn callback<P>(self, base: P) -> CB::Output
+            where
+                P: Producer<Item = T>,
+            {
+                let producer = InspectProducer {
+                    base,
+                    inspect_op: &self.inspect_op,
+                };
+                self.callback.callback(producer)
+            }
+        }
+    }
+}
+
+/// ////////////////////////////////////////////////////////////////////////
+
+struct InspectProducer<'f, P, F> {
+    base: P,
+    inspect_op: &'f F,
+}
+
+impl<'f, P, F> Producer for InspectProducer<'f, P, F>
+where
+    P: Producer,
+    F: Fn(&P::Item) + Sync,
+{
+    type Item = P::Item;
+    type IntoIter = iter::Inspect<P::IntoIter, &'f F>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.base.into_iter().inspect(self.inspect_op)
+    }
+
+    fn min_len(&self) -> usize {
+        self.base.min_len()
+    }
+
+    fn max_len(&self) -> usize {
+        self.base.max_len()
+    }
+
+    fn split_at(self, index: usize) -> (Self, Self) {
+        let (left, right) = self.base.split_at(index);
+        (
+            InspectProducer {
+                base: left,
+                inspect_op: self.inspect_op,
+            },
+            InspectProducer {
+                base: right,
+                inspect_op: self.inspect_op,
+            },
+        )
+    }
+
+    fn fold_with<G>(self, folder: G) -> G
+    where
+        G: Folder<Self::Item>,
+    {
+        let folder1 = InspectFolder {
+            base: folder,
+            inspect_op: self.inspect_op,
+        };
+        self.base.fold_with(folder1).base
+    }
+}
+
+/// ////////////////////////////////////////////////////////////////////////
+/// Consumer implementation
+
+struct InspectConsumer<'f, C, F> {
+    base: C,
+    inspect_op: &'f F,
+}
+
+impl<'f, C, F> InspectConsumer<'f, C, F> {
+    fn new(base: C, inspect_op: &'f F) -> Self {
+        InspectConsumer { base, inspect_op }
+    }
+}
+
+impl<'f, T, C, F> Consumer<T> for InspectConsumer<'f, C, F>
+where
+    C: Consumer<T>,
+    F: Fn(&T) + Sync,
+{
+    type Folder = InspectFolder<'f, C::Folder, F>;
+    type Reducer = C::Reducer;
+    type Result = C::Result;
+
+    fn split_at(self, index: usize) -> (Self, Self, Self::Reducer) {
+        let (left, right, reducer) = self.base.split_at(index);
+        (
+            InspectConsumer::new(left, self.inspect_op),
+            InspectConsumer::new(right, self.inspect_op),
+            reducer,
+        )
+    }
+
+    fn into_folder(self) -> Self::Folder {
+        InspectFolder {
+            base: self.base.into_folder(),
+            inspect_op: self.inspect_op,
+        }
+    }
+
+    fn full(&self) -> bool {
+        self.base.full()
+    }
+}
+
+impl<'f, T, C, F> UnindexedConsumer<T> for InspectConsumer<'f, C, F>
+where
+    C: UnindexedConsumer<T>,
+    F: Fn(&T) + Sync,
+{
+    fn split_off_left(&self) -> Self {
+        InspectConsumer::new(self.base.split_off_left(), self.inspect_op)
+    }
+
+    fn to_reducer(&self) -> Self::Reducer {
+        self.base.to_reducer()
+    }
+}
+
+struct InspectFolder<'f, C, F> {
+    base: C,
+    inspect_op: &'f F,
+}
+
+impl<'f, T, C, F> Folder<T> for InspectFolder<'f, C, F>
+where
+    C: Folder<T>,
+    F: Fn(&T),
+{
+    type Result = C::Result;
+
+    fn consume(self, item: T) -> Self {
+        (self.inspect_op)(&item);
+        InspectFolder {
+            base: self.base.consume(item),
+            inspect_op: self.inspect_op,
+        }
+    }
+
+    fn consume_iter<I>(mut self, iter: I) -> Self
+    where
+        I: IntoIterator<Item = T>,
+    {
+        self.base = self
+            .base
+            .consume_iter(iter.into_iter().inspect(self.inspect_op));
+        self
+    }
+
+    fn complete(self) -> C::Result {
+        self.base.complete()
+    }
+
+    fn full(&self) -> bool {
+        self.base.full()
+    }
+}
diff --git a/crates/rayon/src/iter/interleave.rs b/crates/rayon/src/iter/interleave.rs
new file mode 100644
index 0000000..3cacc49
--- /dev/null
+++ b/crates/rayon/src/iter/interleave.rs
@@ -0,0 +1,336 @@
+use super::plumbing::*;
+use super::*;
+use std::cmp;
+use std::iter::Fuse;
+
+/// `Interleave` is an iterator that interleaves elements of iterators
+/// `i` and `j` in one continuous iterator. This struct is created by
+/// the [`interleave()`] method on [`IndexedParallelIterator`]
+///
+/// [`interleave()`]: trait.IndexedParallelIterator.html#method.interleave
+/// [`IndexedParallelIterator`]: trait.IndexedParallelIterator.html
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Debug, Clone)]
+pub struct Interleave<I, J>
+where
+    I: IndexedParallelIterator,
+    J: IndexedParallelIterator<Item = I::Item>,
+{
+    i: I,
+    j: J,
+}
+
+impl<I, J> Interleave<I, J>
+where
+    I: IndexedParallelIterator,
+    J: IndexedParallelIterator<Item = I::Item>,
+{
+    /// Creates a new `Interleave` iterator
+    pub(super) fn new(i: I, j: J) -> Self {
+        Interleave { i, j }
+    }
+}
+
+impl<I, J> ParallelIterator for Interleave<I, J>
+where
+    I: IndexedParallelIterator,
+    J: IndexedParallelIterator<Item = I::Item>,
+{
+    type Item = I::Item;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<I::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        Some(self.len())
+    }
+}
+
+impl<I, J> IndexedParallelIterator for Interleave<I, J>
+where
+    I: IndexedParallelIterator,
+    J: IndexedParallelIterator<Item = I::Item>,
+{
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn len(&self) -> usize {
+        self.i.len().checked_add(self.j.len()).expect("overflow")
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        let (i_len, j_len) = (self.i.len(), self.j.len());
+        return self.i.with_producer(CallbackI {
+            callback,
+            i_len,
+            j_len,
+            i_next: false,
+            j: self.j,
+        });
+
+        struct CallbackI<CB, J> {
+            callback: CB,
+            i_len: usize,
+            j_len: usize,
+            i_next: bool,
+            j: J,
+        }
+
+        impl<CB, J> ProducerCallback<J::Item> for CallbackI<CB, J>
+        where
+            J: IndexedParallelIterator,
+            CB: ProducerCallback<J::Item>,
+        {
+            type Output = CB::Output;
+
+            fn callback<I>(self, i_producer: I) -> Self::Output
+            where
+                I: Producer<Item = J::Item>,
+            {
+                self.j.with_producer(CallbackJ {
+                    i_producer,
+                    i_len: self.i_len,
+                    j_len: self.j_len,
+                    i_next: self.i_next,
+                    callback: self.callback,
+                })
+            }
+        }
+
+        struct CallbackJ<CB, I> {
+            callback: CB,
+            i_len: usize,
+            j_len: usize,
+            i_next: bool,
+            i_producer: I,
+        }
+
+        impl<CB, I> ProducerCallback<I::Item> for CallbackJ<CB, I>
+        where
+            I: Producer,
+            CB: ProducerCallback<I::Item>,
+        {
+            type Output = CB::Output;
+
+            fn callback<J>(self, j_producer: J) -> Self::Output
+            where
+                J: Producer<Item = I::Item>,
+            {
+                let producer = InterleaveProducer::new(
+                    self.i_producer,
+                    j_producer,
+                    self.i_len,
+                    self.j_len,
+                    self.i_next,
+                );
+                self.callback.callback(producer)
+            }
+        }
+    }
+}
+
+struct InterleaveProducer<I, J>
+where
+    I: Producer,
+    J: Producer<Item = I::Item>,
+{
+    i: I,
+    j: J,
+    i_len: usize,
+    j_len: usize,
+    i_next: bool,
+}
+
+impl<I, J> InterleaveProducer<I, J>
+where
+    I: Producer,
+    J: Producer<Item = I::Item>,
+{
+    fn new(i: I, j: J, i_len: usize, j_len: usize, i_next: bool) -> InterleaveProducer<I, J> {
+        InterleaveProducer {
+            i,
+            j,
+            i_len,
+            j_len,
+            i_next,
+        }
+    }
+}
+
+impl<I, J> Producer for InterleaveProducer<I, J>
+where
+    I: Producer,
+    J: Producer<Item = I::Item>,
+{
+    type Item = I::Item;
+    type IntoIter = InterleaveSeq<I::IntoIter, J::IntoIter>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        InterleaveSeq {
+            i: self.i.into_iter().fuse(),
+            j: self.j.into_iter().fuse(),
+            i_next: self.i_next,
+        }
+    }
+
+    fn min_len(&self) -> usize {
+        cmp::max(self.i.min_len(), self.j.min_len())
+    }
+
+    fn max_len(&self) -> usize {
+        cmp::min(self.i.max_len(), self.j.max_len())
+    }
+
+    /// We know 0 < index <= self.i_len + self.j_len
+    ///
+    /// Find a, b satisfying:
+    ///
+    ///  (1) 0 < a <= self.i_len
+    ///  (2) 0 < b <= self.j_len
+    ///  (3) a + b == index
+    ///
+    /// For even splits, set a = b = index/2.
+    /// For odd splits, set a = (index/2)+1, b = index/2, if `i`
+    /// should yield the next element, otherwise, if `j` should yield
+    /// the next element, set a = index/2 and b = (index/2)+1
+    fn split_at(self, index: usize) -> (Self, Self) {
+        #[inline]
+        fn odd_offset(flag: bool) -> usize {
+            (!flag) as usize
+        }
+
+        let even = index % 2 == 0;
+        let idx = index >> 1;
+
+        // desired split
+        let (i_idx, j_idx) = (
+            idx + odd_offset(even || self.i_next),
+            idx + odd_offset(even || !self.i_next),
+        );
+
+        let (i_split, j_split) = if self.i_len >= i_idx && self.j_len >= j_idx {
+            (i_idx, j_idx)
+        } else if self.i_len >= i_idx {
+            // j too short
+            (index - self.j_len, self.j_len)
+        } else {
+            // i too short
+            (self.i_len, index - self.i_len)
+        };
+
+        let trailing_i_next = even == self.i_next;
+        let (i_left, i_right) = self.i.split_at(i_split);
+        let (j_left, j_right) = self.j.split_at(j_split);
+
+        (
+            InterleaveProducer::new(i_left, j_left, i_split, j_split, self.i_next),
+            InterleaveProducer::new(
+                i_right,
+                j_right,
+                self.i_len - i_split,
+                self.j_len - j_split,
+                trailing_i_next,
+            ),
+        )
+    }
+}
+
+/// Wrapper for Interleave to implement DoubleEndedIterator and
+/// ExactSizeIterator.
+///
+/// This iterator is fused.
+struct InterleaveSeq<I, J> {
+    i: Fuse<I>,
+    j: Fuse<J>,
+
+    /// Flag to control which iterator should provide the next element. When
+    /// `false` then `i` produces the next element, otherwise `j` produces the
+    /// next element.
+    i_next: bool,
+}
+
+/// Iterator implementation for InterleaveSeq. This implementation is
+/// taken more or less verbatim from itertools. It is replicated here
+/// (instead of calling itertools directly), because we also need to
+/// implement `DoubledEndedIterator` and `ExactSizeIterator`.
+impl<I, J> Iterator for InterleaveSeq<I, J>
+where
+    I: Iterator,
+    J: Iterator<Item = I::Item>,
+{
+    type Item = I::Item;
+
+    #[inline]
+    fn next(&mut self) -> Option<Self::Item> {
+        self.i_next = !self.i_next;
+        if self.i_next {
+            match self.i.next() {
+                None => self.j.next(),
+                r => r,
+            }
+        } else {
+            match self.j.next() {
+                None => self.i.next(),
+                r => r,
+            }
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let (ih, jh) = (self.i.size_hint(), self.j.size_hint());
+        let min = ih.0.saturating_add(jh.0);
+        let max = match (ih.1, jh.1) {
+            (Some(x), Some(y)) => x.checked_add(y),
+            _ => None,
+        };
+        (min, max)
+    }
+}
+
+// The implementation for DoubleEndedIterator requires
+// ExactSizeIterator to provide `next_back()`. The last element will
+// come from the iterator that runs out last (ie has the most elements
+// in it). If the iterators have the same number of elements, then the
+// last iterator will provide the last element.
+impl<I, J> DoubleEndedIterator for InterleaveSeq<I, J>
+where
+    I: DoubleEndedIterator + ExactSizeIterator,
+    J: DoubleEndedIterator<Item = I::Item> + ExactSizeIterator<Item = I::Item>,
+{
+    #[inline]
+    fn next_back(&mut self) -> Option<I::Item> {
+        match self.i.len().cmp(&self.j.len()) {
+            Ordering::Less => self.j.next_back(),
+            Ordering::Equal => {
+                if self.i_next {
+                    self.i.next_back()
+                } else {
+                    self.j.next_back()
+                }
+            }
+            Ordering::Greater => self.i.next_back(),
+        }
+    }
+}
+
+impl<I, J> ExactSizeIterator for InterleaveSeq<I, J>
+where
+    I: ExactSizeIterator,
+    J: ExactSizeIterator<Item = I::Item>,
+{
+    #[inline]
+    fn len(&self) -> usize {
+        self.i.len() + self.j.len()
+    }
+}
diff --git a/crates/rayon/src/iter/interleave_shortest.rs b/crates/rayon/src/iter/interleave_shortest.rs
new file mode 100644
index 0000000..7d81369
--- /dev/null
+++ b/crates/rayon/src/iter/interleave_shortest.rs
@@ -0,0 +1,85 @@
+use super::plumbing::*;
+use super::*;
+
+/// `InterleaveShortest` is an iterator that works similarly to
+/// `Interleave`, but this version stops returning elements once one
+/// of the iterators run out.
+///
+/// This struct is created by the [`interleave_shortest()`] method on
+/// [`IndexedParallelIterator`].
+///
+/// [`interleave_shortest()`]: trait.IndexedParallelIterator.html#method.interleave_shortest
+/// [`IndexedParallelIterator`]: trait.IndexedParallelIterator.html
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Debug, Clone)]
+pub struct InterleaveShortest<I, J>
+where
+    I: IndexedParallelIterator,
+    J: IndexedParallelIterator<Item = I::Item>,
+{
+    interleave: Interleave<Take<I>, Take<J>>,
+}
+
+impl<I, J> InterleaveShortest<I, J>
+where
+    I: IndexedParallelIterator,
+    J: IndexedParallelIterator<Item = I::Item>,
+{
+    /// Creates a new `InterleaveShortest` iterator
+    pub(super) fn new(i: I, j: J) -> Self {
+        InterleaveShortest {
+            interleave: if i.len() <= j.len() {
+                // take equal lengths from both iterators
+                let n = i.len();
+                i.take(n).interleave(j.take(n))
+            } else {
+                // take one extra item from the first iterator
+                let n = j.len();
+                i.take(n + 1).interleave(j.take(n))
+            },
+        }
+    }
+}
+
+impl<I, J> ParallelIterator for InterleaveShortest<I, J>
+where
+    I: IndexedParallelIterator,
+    J: IndexedParallelIterator<Item = I::Item>,
+{
+    type Item = I::Item;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<I::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        Some(self.len())
+    }
+}
+
+impl<I, J> IndexedParallelIterator for InterleaveShortest<I, J>
+where
+    I: IndexedParallelIterator,
+    J: IndexedParallelIterator<Item = I::Item>,
+{
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn len(&self) -> usize {
+        self.interleave.len()
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        self.interleave.with_producer(callback)
+    }
+}
diff --git a/crates/rayon/src/iter/intersperse.rs b/crates/rayon/src/iter/intersperse.rs
new file mode 100644
index 0000000..798bdc1
--- /dev/null
+++ b/crates/rayon/src/iter/intersperse.rs
@@ -0,0 +1,410 @@
+use super::plumbing::*;
+use super::*;
+use std::cell::Cell;
+use std::iter::{self, Fuse};
+
+/// `Intersperse` is an iterator that inserts a particular item between each
+/// item of the adapted iterator.  This struct is created by the
+/// [`intersperse()`] method on [`ParallelIterator`]
+///
+/// [`intersperse()`]: trait.ParallelIterator.html#method.intersperse
+/// [`ParallelIterator`]: trait.ParallelIterator.html
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Clone, Debug)]
+pub struct Intersperse<I>
+where
+    I: ParallelIterator,
+    I::Item: Clone,
+{
+    base: I,
+    item: I::Item,
+}
+
+impl<I> Intersperse<I>
+where
+    I: ParallelIterator,
+    I::Item: Clone,
+{
+    /// Creates a new `Intersperse` iterator
+    pub(super) fn new(base: I, item: I::Item) -> Self {
+        Intersperse { base, item }
+    }
+}
+
+impl<I> ParallelIterator for Intersperse<I>
+where
+    I: ParallelIterator,
+    I::Item: Clone + Send,
+{
+    type Item = I::Item;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<I::Item>,
+    {
+        let consumer1 = IntersperseConsumer::new(consumer, self.item);
+        self.base.drive_unindexed(consumer1)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        match self.base.opt_len()? {
+            0 => Some(0),
+            len => len.checked_add(len - 1),
+        }
+    }
+}
+
+impl<I> IndexedParallelIterator for Intersperse<I>
+where
+    I: IndexedParallelIterator,
+    I::Item: Clone + Send,
+{
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        let consumer1 = IntersperseConsumer::new(consumer, self.item);
+        self.base.drive(consumer1)
+    }
+
+    fn len(&self) -> usize {
+        let len = self.base.len();
+        if len > 0 {
+            len.checked_add(len - 1).expect("overflow")
+        } else {
+            0
+        }
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        let len = self.len();
+        return self.base.with_producer(Callback {
+            callback,
+            item: self.item,
+            len,
+        });
+
+        struct Callback<CB, T> {
+            callback: CB,
+            item: T,
+            len: usize,
+        }
+
+        impl<T, CB> ProducerCallback<T> for Callback<CB, T>
+        where
+            CB: ProducerCallback<T>,
+            T: Clone + Send,
+        {
+            type Output = CB::Output;
+
+            fn callback<P>(self, base: P) -> CB::Output
+            where
+                P: Producer<Item = T>,
+            {
+                let producer = IntersperseProducer::new(base, self.item, self.len);
+                self.callback.callback(producer)
+            }
+        }
+    }
+}
+
+struct IntersperseProducer<P>
+where
+    P: Producer,
+{
+    base: P,
+    item: P::Item,
+    len: usize,
+    clone_first: bool,
+}
+
+impl<P> IntersperseProducer<P>
+where
+    P: Producer,
+{
+    fn new(base: P, item: P::Item, len: usize) -> Self {
+        IntersperseProducer {
+            base,
+            item,
+            len,
+            clone_first: false,
+        }
+    }
+}
+
+impl<P> Producer for IntersperseProducer<P>
+where
+    P: Producer,
+    P::Item: Clone + Send,
+{
+    type Item = P::Item;
+    type IntoIter = IntersperseIter<P::IntoIter>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        IntersperseIter {
+            base: self.base.into_iter().fuse(),
+            item: self.item,
+            clone_first: self.len > 0 && self.clone_first,
+
+            // If there's more than one item, then even lengths end the opposite
+            // of how they started with respect to interspersed clones.
+            clone_last: self.len > 1 && ((self.len & 1 == 0) ^ self.clone_first),
+        }
+    }
+
+    fn min_len(&self) -> usize {
+        self.base.min_len()
+    }
+    fn max_len(&self) -> usize {
+        self.base.max_len()
+    }
+
+    fn split_at(self, index: usize) -> (Self, Self) {
+        debug_assert!(index <= self.len);
+
+        // The left needs half of the items from the base producer, and the
+        // other half will be our interspersed item.  If we're not leading with
+        // a cloned item, then we need to round up the base number of items,
+        // otherwise round down.
+        let base_index = (index + !self.clone_first as usize) / 2;
+        let (left_base, right_base) = self.base.split_at(base_index);
+
+        let left = IntersperseProducer {
+            base: left_base,
+            item: self.item.clone(),
+            len: index,
+            clone_first: self.clone_first,
+        };
+
+        let right = IntersperseProducer {
+            base: right_base,
+            item: self.item,
+            len: self.len - index,
+
+            // If the index is odd, the right side toggles `clone_first`.
+            clone_first: (index & 1 == 1) ^ self.clone_first,
+        };
+
+        (left, right)
+    }
+
+    fn fold_with<F>(self, folder: F) -> F
+    where
+        F: Folder<Self::Item>,
+    {
+        let folder1 = IntersperseFolder {
+            base: folder,
+            item: self.item,
+            clone_first: self.clone_first,
+        };
+        self.base.fold_with(folder1).base
+    }
+}
+
+struct IntersperseIter<I>
+where
+    I: Iterator,
+{
+    base: Fuse<I>,
+    item: I::Item,
+    clone_first: bool,
+    clone_last: bool,
+}
+
+impl<I> Iterator for IntersperseIter<I>
+where
+    I: DoubleEndedIterator + ExactSizeIterator,
+    I::Item: Clone,
+{
+    type Item = I::Item;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.clone_first {
+            self.clone_first = false;
+            Some(self.item.clone())
+        } else if let next @ Some(_) = self.base.next() {
+            // If there are any items left, we'll need another clone in front.
+            self.clone_first = self.base.len() != 0;
+            next
+        } else if self.clone_last {
+            self.clone_last = false;
+            Some(self.item.clone())
+        } else {
+            None
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let len = self.len();
+        (len, Some(len))
+    }
+}
+
+impl<I> DoubleEndedIterator for IntersperseIter<I>
+where
+    I: DoubleEndedIterator + ExactSizeIterator,
+    I::Item: Clone,
+{
+    fn next_back(&mut self) -> Option<Self::Item> {
+        if self.clone_last {
+            self.clone_last = false;
+            Some(self.item.clone())
+        } else if let next_back @ Some(_) = self.base.next_back() {
+            // If there are any items left, we'll need another clone in back.
+            self.clone_last = self.base.len() != 0;
+            next_back
+        } else if self.clone_first {
+            self.clone_first = false;
+            Some(self.item.clone())
+        } else {
+            None
+        }
+    }
+}
+
+impl<I> ExactSizeIterator for IntersperseIter<I>
+where
+    I: DoubleEndedIterator + ExactSizeIterator,
+    I::Item: Clone,
+{
+    fn len(&self) -> usize {
+        let len = self.base.len();
+        len + len.saturating_sub(1) + self.clone_first as usize + self.clone_last as usize
+    }
+}
+
+struct IntersperseConsumer<C, T> {
+    base: C,
+    item: T,
+    clone_first: Cell<bool>,
+}
+
+impl<C, T> IntersperseConsumer<C, T>
+where
+    C: Consumer<T>,
+{
+    fn new(base: C, item: T) -> Self {
+        IntersperseConsumer {
+            base,
+            item,
+            clone_first: false.into(),
+        }
+    }
+}
+
+impl<C, T> Consumer<T> for IntersperseConsumer<C, T>
+where
+    C: Consumer<T>,
+    T: Clone + Send,
+{
+    type Folder = IntersperseFolder<C::Folder, T>;
+    type Reducer = C::Reducer;
+    type Result = C::Result;
+
+    fn split_at(mut self, index: usize) -> (Self, Self, Self::Reducer) {
+        // We'll feed twice as many items to the base consumer, except if we're
+        // not currently leading with a cloned item, then it's one less.
+        let base_index = index + index.saturating_sub(!self.clone_first.get() as usize);
+        let (left, right, reducer) = self.base.split_at(base_index);
+
+        let right = IntersperseConsumer {
+            base: right,
+            item: self.item.clone(),
+            clone_first: true.into(),
+        };
+        self.base = left;
+        (self, right, reducer)
+    }
+
+    fn into_folder(self) -> Self::Folder {
+        IntersperseFolder {
+            base: self.base.into_folder(),
+            item: self.item,
+            clone_first: self.clone_first.get(),
+        }
+    }
+
+    fn full(&self) -> bool {
+        self.base.full()
+    }
+}
+
+impl<C, T> UnindexedConsumer<T> for IntersperseConsumer<C, T>
+where
+    C: UnindexedConsumer<T>,
+    T: Clone + Send,
+{
+    fn split_off_left(&self) -> Self {
+        let left = IntersperseConsumer {
+            base: self.base.split_off_left(),
+            item: self.item.clone(),
+            clone_first: self.clone_first.clone(),
+        };
+        self.clone_first.set(true);
+        left
+    }
+
+    fn to_reducer(&self) -> Self::Reducer {
+        self.base.to_reducer()
+    }
+}
+
+struct IntersperseFolder<C, T> {
+    base: C,
+    item: T,
+    clone_first: bool,
+}
+
+impl<C, T> Folder<T> for IntersperseFolder<C, T>
+where
+    C: Folder<T>,
+    T: Clone,
+{
+    type Result = C::Result;
+
+    fn consume(mut self, item: T) -> Self {
+        if self.clone_first {
+            self.base = self.base.consume(self.item.clone());
+            if self.base.full() {
+                return self;
+            }
+        } else {
+            self.clone_first = true;
+        }
+        self.base = self.base.consume(item);
+        self
+    }
+
+    fn consume_iter<I>(self, iter: I) -> Self
+    where
+        I: IntoIterator<Item = T>,
+    {
+        let mut clone_first = self.clone_first;
+        let between_item = self.item;
+        let base = self.base.consume_iter(iter.into_iter().flat_map(|item| {
+            let first = if clone_first {
+                Some(between_item.clone())
+            } else {
+                clone_first = true;
+                None
+            };
+            first.into_iter().chain(iter::once(item))
+        }));
+        IntersperseFolder {
+            base,
+            item: between_item,
+            clone_first,
+        }
+    }
+
+    fn complete(self) -> C::Result {
+        self.base.complete()
+    }
+
+    fn full(&self) -> bool {
+        self.base.full()
+    }
+}
diff --git a/crates/rayon/src/iter/len.rs b/crates/rayon/src/iter/len.rs
new file mode 100644
index 0000000..8ec7f33
--- /dev/null
+++ b/crates/rayon/src/iter/len.rs
@@ -0,0 +1,271 @@
+use super::plumbing::*;
+use super::*;
+use std::cmp;
+
+/// `MinLen` is an iterator that imposes a minimum length on iterator splits.
+/// This struct is created by the [`with_min_len()`] method on [`IndexedParallelIterator`]
+///
+/// [`with_min_len()`]: trait.IndexedParallelIterator.html#method.with_min_len
+/// [`IndexedParallelIterator`]: trait.IndexedParallelIterator.html
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Debug, Clone)]
+pub struct MinLen<I: IndexedParallelIterator> {
+    base: I,
+    min: usize,
+}
+
+impl<I> MinLen<I>
+where
+    I: IndexedParallelIterator,
+{
+    /// Creates a new `MinLen` iterator.
+    pub(super) fn new(base: I, min: usize) -> Self {
+        MinLen { base, min }
+    }
+}
+
+impl<I> ParallelIterator for MinLen<I>
+where
+    I: IndexedParallelIterator,
+{
+    type Item = I::Item;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        Some(self.len())
+    }
+}
+
+impl<I> IndexedParallelIterator for MinLen<I>
+where
+    I: IndexedParallelIterator,
+{
+    fn drive<C: Consumer<Self::Item>>(self, consumer: C) -> C::Result {
+        bridge(self, consumer)
+    }
+
+    fn len(&self) -> usize {
+        self.base.len()
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        return self.base.with_producer(Callback {
+            callback,
+            min: self.min,
+        });
+
+        struct Callback<CB> {
+            callback: CB,
+            min: usize,
+        }
+
+        impl<T, CB> ProducerCallback<T> for Callback<CB>
+        where
+            CB: ProducerCallback<T>,
+        {
+            type Output = CB::Output;
+            fn callback<P>(self, base: P) -> CB::Output
+            where
+                P: Producer<Item = T>,
+            {
+                let producer = MinLenProducer {
+                    base,
+                    min: self.min,
+                };
+                self.callback.callback(producer)
+            }
+        }
+    }
+}
+
+/// ////////////////////////////////////////////////////////////////////////
+/// `MinLenProducer` implementation
+
+struct MinLenProducer<P> {
+    base: P,
+    min: usize,
+}
+
+impl<P> Producer for MinLenProducer<P>
+where
+    P: Producer,
+{
+    type Item = P::Item;
+    type IntoIter = P::IntoIter;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.base.into_iter()
+    }
+
+    fn min_len(&self) -> usize {
+        cmp::max(self.min, self.base.min_len())
+    }
+
+    fn max_len(&self) -> usize {
+        self.base.max_len()
+    }
+
+    fn split_at(self, index: usize) -> (Self, Self) {
+        let (left, right) = self.base.split_at(index);
+        (
+            MinLenProducer {
+                base: left,
+                min: self.min,
+            },
+            MinLenProducer {
+                base: right,
+                min: self.min,
+            },
+        )
+    }
+
+    fn fold_with<F>(self, folder: F) -> F
+    where
+        F: Folder<Self::Item>,
+    {
+        self.base.fold_with(folder)
+    }
+}
+
+/// `MaxLen` is an iterator that imposes a maximum length on iterator splits.
+/// This struct is created by the [`with_max_len()`] method on [`IndexedParallelIterator`]
+///
+/// [`with_max_len()`]: trait.IndexedParallelIterator.html#method.with_max_len
+/// [`IndexedParallelIterator`]: trait.IndexedParallelIterator.html
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Debug, Clone)]
+pub struct MaxLen<I: IndexedParallelIterator> {
+    base: I,
+    max: usize,
+}
+
+impl<I> MaxLen<I>
+where
+    I: IndexedParallelIterator,
+{
+    /// Creates a new `MaxLen` iterator.
+    pub(super) fn new(base: I, max: usize) -> Self {
+        MaxLen { base, max }
+    }
+}
+
+impl<I> ParallelIterator for MaxLen<I>
+where
+    I: IndexedParallelIterator,
+{
+    type Item = I::Item;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        Some(self.len())
+    }
+}
+
+impl<I> IndexedParallelIterator for MaxLen<I>
+where
+    I: IndexedParallelIterator,
+{
+    fn drive<C: Consumer<Self::Item>>(self, consumer: C) -> C::Result {
+        bridge(self, consumer)
+    }
+
+    fn len(&self) -> usize {
+        self.base.len()
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        return self.base.with_producer(Callback {
+            callback,
+            max: self.max,
+        });
+
+        struct Callback<CB> {
+            callback: CB,
+            max: usize,
+        }
+
+        impl<T, CB> ProducerCallback<T> for Callback<CB>
+        where
+            CB: ProducerCallback<T>,
+        {
+            type Output = CB::Output;
+            fn callback<P>(self, base: P) -> CB::Output
+            where
+                P: Producer<Item = T>,
+            {
+                let producer = MaxLenProducer {
+                    base,
+                    max: self.max,
+                };
+                self.callback.callback(producer)
+            }
+        }
+    }
+}
+
+/// ////////////////////////////////////////////////////////////////////////
+/// `MaxLenProducer` implementation
+
+struct MaxLenProducer<P> {
+    base: P,
+    max: usize,
+}
+
+impl<P> Producer for MaxLenProducer<P>
+where
+    P: Producer,
+{
+    type Item = P::Item;
+    type IntoIter = P::IntoIter;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.base.into_iter()
+    }
+
+    fn min_len(&self) -> usize {
+        self.base.min_len()
+    }
+
+    fn max_len(&self) -> usize {
+        cmp::min(self.max, self.base.max_len())
+    }
+
+    fn split_at(self, index: usize) -> (Self, Self) {
+        let (left, right) = self.base.split_at(index);
+        (
+            MaxLenProducer {
+                base: left,
+                max: self.max,
+            },
+            MaxLenProducer {
+                base: right,
+                max: self.max,
+            },
+        )
+    }
+
+    fn fold_with<F>(self, folder: F) -> F
+    where
+        F: Folder<Self::Item>,
+    {
+        self.base.fold_with(folder)
+    }
+}
diff --git a/crates/rayon/src/iter/map.rs b/crates/rayon/src/iter/map.rs
new file mode 100644
index 0000000..da14d40
--- /dev/null
+++ b/crates/rayon/src/iter/map.rs
@@ -0,0 +1,259 @@
+use super::plumbing::*;
+use super::*;
+
+use std::fmt::{self, Debug};
+use std::iter;
+
+/// `Map` is an iterator that transforms the elements of an underlying iterator.
+///
+/// This struct is created by the [`map()`] method on [`ParallelIterator`]
+///
+/// [`map()`]: trait.ParallelIterator.html#method.map
+/// [`ParallelIterator`]: trait.ParallelIterator.html
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Clone)]
+pub struct Map<I: ParallelIterator, F> {
+    base: I,
+    map_op: F,
+}
+
+impl<I: ParallelIterator + Debug, F> Debug for Map<I, F> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Map").field("base", &self.base).finish()
+    }
+}
+
+impl<I, F> Map<I, F>
+where
+    I: ParallelIterator,
+{
+    /// Creates a new `Map` iterator.
+    pub(super) fn new(base: I, map_op: F) -> Self {
+        Map { base, map_op }
+    }
+}
+
+impl<I, F, R> ParallelIterator for Map<I, F>
+where
+    I: ParallelIterator,
+    F: Fn(I::Item) -> R + Sync + Send,
+    R: Send,
+{
+    type Item = F::Output;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        let consumer1 = MapConsumer::new(consumer, &self.map_op);
+        self.base.drive_unindexed(consumer1)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        self.base.opt_len()
+    }
+}
+
+impl<I, F, R> IndexedParallelIterator for Map<I, F>
+where
+    I: IndexedParallelIterator,
+    F: Fn(I::Item) -> R + Sync + Send,
+    R: Send,
+{
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        let consumer1 = MapConsumer::new(consumer, &self.map_op);
+        self.base.drive(consumer1)
+    }
+
+    fn len(&self) -> usize {
+        self.base.len()
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        return self.base.with_producer(Callback {
+            callback,
+            map_op: self.map_op,
+        });
+
+        struct Callback<CB, F> {
+            callback: CB,
+            map_op: F,
+        }
+
+        impl<T, F, R, CB> ProducerCallback<T> for Callback<CB, F>
+        where
+            CB: ProducerCallback<R>,
+            F: Fn(T) -> R + Sync,
+            R: Send,
+        {
+            type Output = CB::Output;
+
+            fn callback<P>(self, base: P) -> CB::Output
+            where
+                P: Producer<Item = T>,
+            {
+                let producer = MapProducer {
+                    base,
+                    map_op: &self.map_op,
+                };
+                self.callback.callback(producer)
+            }
+        }
+    }
+}
+
+/// ////////////////////////////////////////////////////////////////////////
+
+struct MapProducer<'f, P, F> {
+    base: P,
+    map_op: &'f F,
+}
+
+impl<'f, P, F, R> Producer for MapProducer<'f, P, F>
+where
+    P: Producer,
+    F: Fn(P::Item) -> R + Sync,
+    R: Send,
+{
+    type Item = F::Output;
+    type IntoIter = iter::Map<P::IntoIter, &'f F>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.base.into_iter().map(self.map_op)
+    }
+
+    fn min_len(&self) -> usize {
+        self.base.min_len()
+    }
+    fn max_len(&self) -> usize {
+        self.base.max_len()
+    }
+
+    fn split_at(self, index: usize) -> (Self, Self) {
+        let (left, right) = self.base.split_at(index);
+        (
+            MapProducer {
+                base: left,
+                map_op: self.map_op,
+            },
+            MapProducer {
+                base: right,
+                map_op: self.map_op,
+            },
+        )
+    }
+
+    fn fold_with<G>(self, folder: G) -> G
+    where
+        G: Folder<Self::Item>,
+    {
+        let folder1 = MapFolder {
+            base: folder,
+            map_op: self.map_op,
+        };
+        self.base.fold_with(folder1).base
+    }
+}
+
+/// ////////////////////////////////////////////////////////////////////////
+/// Consumer implementation
+
+struct MapConsumer<'f, C, F> {
+    base: C,
+    map_op: &'f F,
+}
+
+impl<'f, C, F> MapConsumer<'f, C, F> {
+    fn new(base: C, map_op: &'f F) -> Self {
+        MapConsumer { base, map_op }
+    }
+}
+
+impl<'f, T, R, C, F> Consumer<T> for MapConsumer<'f, C, F>
+where
+    C: Consumer<F::Output>,
+    F: Fn(T) -> R + Sync,
+    R: Send,
+{
+    type Folder = MapFolder<'f, C::Folder, F>;
+    type Reducer = C::Reducer;
+    type Result = C::Result;
+
+    fn split_at(self, index: usize) -> (Self, Self, Self::Reducer) {
+        let (left, right, reducer) = self.base.split_at(index);
+        (
+            MapConsumer::new(left, self.map_op),
+            MapConsumer::new(right, self.map_op),
+            reducer,
+        )
+    }
+
+    fn into_folder(self) -> Self::Folder {
+        MapFolder {
+            base: self.base.into_folder(),
+            map_op: self.map_op,
+        }
+    }
+
+    fn full(&self) -> bool {
+        self.base.full()
+    }
+}
+
+impl<'f, T, R, C, F> UnindexedConsumer<T> for MapConsumer<'f, C, F>
+where
+    C: UnindexedConsumer<F::Output>,
+    F: Fn(T) -> R + Sync,
+    R: Send,
+{
+    fn split_off_left(&self) -> Self {
+        MapConsumer::new(self.base.split_off_left(), self.map_op)
+    }
+
+    fn to_reducer(&self) -> Self::Reducer {
+        self.base.to_reducer()
+    }
+}
+
+struct MapFolder<'f, C, F> {
+    base: C,
+    map_op: &'f F,
+}
+
+impl<'f, T, R, C, F> Folder<T> for MapFolder<'f, C, F>
+where
+    C: Folder<F::Output>,
+    F: Fn(T) -> R,
+{
+    type Result = C::Result;
+
+    fn consume(self, item: T) -> Self {
+        let mapped_item = (self.map_op)(item);
+        MapFolder {
+            base: self.base.consume(mapped_item),
+            map_op: self.map_op,
+        }
+    }
+
+    fn consume_iter<I>(mut self, iter: I) -> Self
+    where
+        I: IntoIterator<Item = T>,
+    {
+        self.base = self.base.consume_iter(iter.into_iter().map(self.map_op));
+        self
+    }
+
+    fn complete(self) -> C::Result {
+        self.base.complete()
+    }
+
+    fn full(&self) -> bool {
+        self.base.full()
+    }
+}
diff --git a/crates/rayon/src/iter/map_with.rs b/crates/rayon/src/iter/map_with.rs
new file mode 100644
index 0000000..10b1b4c
--- /dev/null
+++ b/crates/rayon/src/iter/map_with.rs
@@ -0,0 +1,573 @@
+use super::plumbing::*;
+use super::*;
+
+use std::fmt::{self, Debug};
+
+/// `MapWith` is an iterator that transforms the elements of an underlying iterator.
+///
+/// This struct is created by the [`map_with()`] method on [`ParallelIterator`]
+///
+/// [`map_with()`]: trait.ParallelIterator.html#method.map_with
+/// [`ParallelIterator`]: trait.ParallelIterator.html
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Clone)]
+pub struct MapWith<I: ParallelIterator, T, F> {
+    base: I,
+    item: T,
+    map_op: F,
+}
+
+impl<I: ParallelIterator + Debug, T: Debug, F> Debug for MapWith<I, T, F> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("MapWith")
+            .field("base", &self.base)
+            .field("item", &self.item)
+            .finish()
+    }
+}
+
+impl<I, T, F> MapWith<I, T, F>
+where
+    I: ParallelIterator,
+{
+    /// Creates a new `MapWith` iterator.
+    pub(super) fn new(base: I, item: T, map_op: F) -> Self {
+        MapWith { base, item, map_op }
+    }
+}
+
+impl<I, T, F, R> ParallelIterator for MapWith<I, T, F>
+where
+    I: ParallelIterator,
+    T: Send + Clone,
+    F: Fn(&mut T, I::Item) -> R + Sync + Send,
+    R: Send,
+{
+    type Item = R;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        let consumer1 = MapWithConsumer::new(consumer, self.item, &self.map_op);
+        self.base.drive_unindexed(consumer1)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        self.base.opt_len()
+    }
+}
+
+impl<I, T, F, R> IndexedParallelIterator for MapWith<I, T, F>
+where
+    I: IndexedParallelIterator,
+    T: Send + Clone,
+    F: Fn(&mut T, I::Item) -> R + Sync + Send,
+    R: Send,
+{
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        let consumer1 = MapWithConsumer::new(consumer, self.item, &self.map_op);
+        self.base.drive(consumer1)
+    }
+
+    fn len(&self) -> usize {
+        self.base.len()
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        return self.base.with_producer(Callback {
+            callback,
+            item: self.item,
+            map_op: self.map_op,
+        });
+
+        struct Callback<CB, U, F> {
+            callback: CB,
+            item: U,
+            map_op: F,
+        }
+
+        impl<T, U, F, R, CB> ProducerCallback<T> for Callback<CB, U, F>
+        where
+            CB: ProducerCallback<R>,
+            U: Send + Clone,
+            F: Fn(&mut U, T) -> R + Sync,
+            R: Send,
+        {
+            type Output = CB::Output;
+
+            fn callback<P>(self, base: P) -> CB::Output
+            where
+                P: Producer<Item = T>,
+            {
+                let producer = MapWithProducer {
+                    base,
+                    item: self.item,
+                    map_op: &self.map_op,
+                };
+                self.callback.callback(producer)
+            }
+        }
+    }
+}
+
+/// ////////////////////////////////////////////////////////////////////////
+
+struct MapWithProducer<'f, P, U, F> {
+    base: P,
+    item: U,
+    map_op: &'f F,
+}
+
+impl<'f, P, U, F, R> Producer for MapWithProducer<'f, P, U, F>
+where
+    P: Producer,
+    U: Send + Clone,
+    F: Fn(&mut U, P::Item) -> R + Sync,
+    R: Send,
+{
+    type Item = R;
+    type IntoIter = MapWithIter<'f, P::IntoIter, U, F>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        MapWithIter {
+            base: self.base.into_iter(),
+            item: self.item,
+            map_op: self.map_op,
+        }
+    }
+
+    fn min_len(&self) -> usize {
+        self.base.min_len()
+    }
+    fn max_len(&self) -> usize {
+        self.base.max_len()
+    }
+
+    fn split_at(self, index: usize) -> (Self, Self) {
+        let (left, right) = self.base.split_at(index);
+        (
+            MapWithProducer {
+                base: left,
+                item: self.item.clone(),
+                map_op: self.map_op,
+            },
+            MapWithProducer {
+                base: right,
+                item: self.item,
+                map_op: self.map_op,
+            },
+        )
+    }
+
+    fn fold_with<G>(self, folder: G) -> G
+    where
+        G: Folder<Self::Item>,
+    {
+        let folder1 = MapWithFolder {
+            base: folder,
+            item: self.item,
+            map_op: self.map_op,
+        };
+        self.base.fold_with(folder1).base
+    }
+}
+
+struct MapWithIter<'f, I, U, F> {
+    base: I,
+    item: U,
+    map_op: &'f F,
+}
+
+impl<'f, I, U, F, R> Iterator for MapWithIter<'f, I, U, F>
+where
+    I: Iterator,
+    F: Fn(&mut U, I::Item) -> R + Sync,
+    R: Send,
+{
+    type Item = R;
+
+    fn next(&mut self) -> Option<R> {
+        let item = self.base.next()?;
+        Some((self.map_op)(&mut self.item, item))
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.base.size_hint()
+    }
+}
+
+impl<'f, I, U, F, R> DoubleEndedIterator for MapWithIter<'f, I, U, F>
+where
+    I: DoubleEndedIterator,
+    F: Fn(&mut U, I::Item) -> R + Sync,
+    R: Send,
+{
+    fn next_back(&mut self) -> Option<R> {
+        let item = self.base.next_back()?;
+        Some((self.map_op)(&mut self.item, item))
+    }
+}
+
+impl<'f, I, U, F, R> ExactSizeIterator for MapWithIter<'f, I, U, F>
+where
+    I: ExactSizeIterator,
+    F: Fn(&mut U, I::Item) -> R + Sync,
+    R: Send,
+{
+}
+
+/// ////////////////////////////////////////////////////////////////////////
+/// Consumer implementation
+
+struct MapWithConsumer<'f, C, U, F> {
+    base: C,
+    item: U,
+    map_op: &'f F,
+}
+
+impl<'f, C, U, F> MapWithConsumer<'f, C, U, F> {
+    fn new(base: C, item: U, map_op: &'f F) -> Self {
+        MapWithConsumer { base, item, map_op }
+    }
+}
+
+impl<'f, T, U, R, C, F> Consumer<T> for MapWithConsumer<'f, C, U, F>
+where
+    C: Consumer<R>,
+    U: Send + Clone,
+    F: Fn(&mut U, T) -> R + Sync,
+    R: Send,
+{
+    type Folder = MapWithFolder<'f, C::Folder, U, F>;
+    type Reducer = C::Reducer;
+    type Result = C::Result;
+
+    fn split_at(self, index: usize) -> (Self, Self, Self::Reducer) {
+        let (left, right, reducer) = self.base.split_at(index);
+        (
+            MapWithConsumer::new(left, self.item.clone(), self.map_op),
+            MapWithConsumer::new(right, self.item, self.map_op),
+            reducer,
+        )
+    }
+
+    fn into_folder(self) -> Self::Folder {
+        MapWithFolder {
+            base: self.base.into_folder(),
+            item: self.item,
+            map_op: self.map_op,
+        }
+    }
+
+    fn full(&self) -> bool {
+        self.base.full()
+    }
+}
+
+impl<'f, T, U, R, C, F> UnindexedConsumer<T> for MapWithConsumer<'f, C, U, F>
+where
+    C: UnindexedConsumer<R>,
+    U: Send + Clone,
+    F: Fn(&mut U, T) -> R + Sync,
+    R: Send,
+{
+    fn split_off_left(&self) -> Self {
+        MapWithConsumer::new(self.base.split_off_left(), self.item.clone(), self.map_op)
+    }
+
+    fn to_reducer(&self) -> Self::Reducer {
+        self.base.to_reducer()
+    }
+}
+
+struct MapWithFolder<'f, C, U, F> {
+    base: C,
+    item: U,
+    map_op: &'f F,
+}
+
+impl<'f, T, U, R, C, F> Folder<T> for MapWithFolder<'f, C, U, F>
+where
+    C: Folder<R>,
+    F: Fn(&mut U, T) -> R,
+{
+    type Result = C::Result;
+
+    fn consume(mut self, item: T) -> Self {
+        let mapped_item = (self.map_op)(&mut self.item, item);
+        self.base = self.base.consume(mapped_item);
+        self
+    }
+
+    fn consume_iter<I>(mut self, iter: I) -> Self
+    where
+        I: IntoIterator<Item = T>,
+    {
+        fn with<'f, T, U, R>(
+            item: &'f mut U,
+            map_op: impl Fn(&mut U, T) -> R + 'f,
+        ) -> impl FnMut(T) -> R + 'f {
+            move |x| map_op(item, x)
+        }
+
+        {
+            let mapped_iter = iter.into_iter().map(with(&mut self.item, self.map_op));
+            self.base = self.base.consume_iter(mapped_iter);
+        }
+        self
+    }
+
+    fn complete(self) -> C::Result {
+        self.base.complete()
+    }
+
+    fn full(&self) -> bool {
+        self.base.full()
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+
+/// `MapInit` is an iterator that transforms the elements of an underlying iterator.
+///
+/// This struct is created by the [`map_init()`] method on [`ParallelIterator`]
+///
+/// [`map_init()`]: trait.ParallelIterator.html#method.map_init
+/// [`ParallelIterator`]: trait.ParallelIterator.html
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Clone)]
+pub struct MapInit<I: ParallelIterator, INIT, F> {
+    base: I,
+    init: INIT,
+    map_op: F,
+}
+
+impl<I: ParallelIterator + Debug, INIT, F> Debug for MapInit<I, INIT, F> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("MapInit").field("base", &self.base).finish()
+    }
+}
+
+impl<I, INIT, F> MapInit<I, INIT, F>
+where
+    I: ParallelIterator,
+{
+    /// Creates a new `MapInit` iterator.
+    pub(super) fn new(base: I, init: INIT, map_op: F) -> Self {
+        MapInit { base, init, map_op }
+    }
+}
+
+impl<I, INIT, T, F, R> ParallelIterator for MapInit<I, INIT, F>
+where
+    I: ParallelIterator,
+    INIT: Fn() -> T + Sync + Send,
+    F: Fn(&mut T, I::Item) -> R + Sync + Send,
+    R: Send,
+{
+    type Item = R;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        let consumer1 = MapInitConsumer::new(consumer, &self.init, &self.map_op);
+        self.base.drive_unindexed(consumer1)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        self.base.opt_len()
+    }
+}
+
+impl<I, INIT, T, F, R> IndexedParallelIterator for MapInit<I, INIT, F>
+where
+    I: IndexedParallelIterator,
+    INIT: Fn() -> T + Sync + Send,
+    F: Fn(&mut T, I::Item) -> R + Sync + Send,
+    R: Send,
+{
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        let consumer1 = MapInitConsumer::new(consumer, &self.init, &self.map_op);
+        self.base.drive(consumer1)
+    }
+
+    fn len(&self) -> usize {
+        self.base.len()
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        return self.base.with_producer(Callback {
+            callback,
+            init: self.init,
+            map_op: self.map_op,
+        });
+
+        struct Callback<CB, INIT, F> {
+            callback: CB,
+            init: INIT,
+            map_op: F,
+        }
+
+        impl<T, INIT, U, F, R, CB> ProducerCallback<T> for Callback<CB, INIT, F>
+        where
+            CB: ProducerCallback<R>,
+            INIT: Fn() -> U + Sync,
+            F: Fn(&mut U, T) -> R + Sync,
+            R: Send,
+        {
+            type Output = CB::Output;
+
+            fn callback<P>(self, base: P) -> CB::Output
+            where
+                P: Producer<Item = T>,
+            {
+                let producer = MapInitProducer {
+                    base,
+                    init: &self.init,
+                    map_op: &self.map_op,
+                };
+                self.callback.callback(producer)
+            }
+        }
+    }
+}
+
+/// ////////////////////////////////////////////////////////////////////////
+
+struct MapInitProducer<'f, P, INIT, F> {
+    base: P,
+    init: &'f INIT,
+    map_op: &'f F,
+}
+
+impl<'f, P, INIT, U, F, R> Producer for MapInitProducer<'f, P, INIT, F>
+where
+    P: Producer,
+    INIT: Fn() -> U + Sync,
+    F: Fn(&mut U, P::Item) -> R + Sync,
+    R: Send,
+{
+    type Item = R;
+    type IntoIter = MapWithIter<'f, P::IntoIter, U, F>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        MapWithIter {
+            base: self.base.into_iter(),
+            item: (self.init)(),
+            map_op: self.map_op,
+        }
+    }
+
+    fn min_len(&self) -> usize {
+        self.base.min_len()
+    }
+    fn max_len(&self) -> usize {
+        self.base.max_len()
+    }
+
+    fn split_at(self, index: usize) -> (Self, Self) {
+        let (left, right) = self.base.split_at(index);
+        (
+            MapInitProducer {
+                base: left,
+                init: self.init,
+                map_op: self.map_op,
+            },
+            MapInitProducer {
+                base: right,
+                init: self.init,
+                map_op: self.map_op,
+            },
+        )
+    }
+
+    fn fold_with<G>(self, folder: G) -> G
+    where
+        G: Folder<Self::Item>,
+    {
+        let folder1 = MapWithFolder {
+            base: folder,
+            item: (self.init)(),
+            map_op: self.map_op,
+        };
+        self.base.fold_with(folder1).base
+    }
+}
+
+/// ////////////////////////////////////////////////////////////////////////
+/// Consumer implementation
+
+struct MapInitConsumer<'f, C, INIT, F> {
+    base: C,
+    init: &'f INIT,
+    map_op: &'f F,
+}
+
+impl<'f, C, INIT, F> MapInitConsumer<'f, C, INIT, F> {
+    fn new(base: C, init: &'f INIT, map_op: &'f F) -> Self {
+        MapInitConsumer { base, init, map_op }
+    }
+}
+
+impl<'f, T, INIT, U, R, C, F> Consumer<T> for MapInitConsumer<'f, C, INIT, F>
+where
+    C: Consumer<R>,
+    INIT: Fn() -> U + Sync,
+    F: Fn(&mut U, T) -> R + Sync,
+    R: Send,
+{
+    type Folder = MapWithFolder<'f, C::Folder, U, F>;
+    type Reducer = C::Reducer;
+    type Result = C::Result;
+
+    fn split_at(self, index: usize) -> (Self, Self, Self::Reducer) {
+        let (left, right, reducer) = self.base.split_at(index);
+        (
+            MapInitConsumer::new(left, self.init, self.map_op),
+            MapInitConsumer::new(right, self.init, self.map_op),
+            reducer,
+        )
+    }
+
+    fn into_folder(self) -> Self::Folder {
+        MapWithFolder {
+            base: self.base.into_folder(),
+            item: (self.init)(),
+            map_op: self.map_op,
+        }
+    }
+
+    fn full(&self) -> bool {
+        self.base.full()
+    }
+}
+
+impl<'f, T, INIT, U, R, C, F> UnindexedConsumer<T> for MapInitConsumer<'f, C, INIT, F>
+where
+    C: UnindexedConsumer<R>,
+    INIT: Fn() -> U + Sync,
+    F: Fn(&mut U, T) -> R + Sync,
+    R: Send,
+{
+    fn split_off_left(&self) -> Self {
+        MapInitConsumer::new(self.base.split_off_left(), self.init, self.map_op)
+    }
+
+    fn to_reducer(&self) -> Self::Reducer {
+        self.base.to_reducer()
+    }
+}
diff --git a/crates/rayon/src/iter/mod.rs b/crates/rayon/src/iter/mod.rs
new file mode 100644
index 0000000..7b5a29a
--- /dev/null
+++ b/crates/rayon/src/iter/mod.rs
@@ -0,0 +1,3531 @@
+//! Traits for writing parallel programs using an iterator-style interface
+//!
+//! You will rarely need to interact with this module directly unless you have
+//! need to name one of the iterator types.
+//!
+//! Parallel iterators make it easy to write iterator-like chains that
+//! execute in parallel: typically all you have to do is convert the
+//! first `.iter()` (or `iter_mut()`, `into_iter()`, etc) method into
+//! `par_iter()` (or `par_iter_mut()`, `into_par_iter()`, etc). For
+//! example, to compute the sum of the squares of a sequence of
+//! integers, one might write:
+//!
+//! ```rust
+//! use rayon::prelude::*;
+//! fn sum_of_squares(input: &[i32]) -> i32 {
+//!     input.par_iter()
+//!          .map(|i| i * i)
+//!          .sum()
+//! }
+//! ```
+//!
+//! Or, to increment all the integers in a slice, you could write:
+//!
+//! ```rust
+//! use rayon::prelude::*;
+//! fn increment_all(input: &mut [i32]) {
+//!     input.par_iter_mut()
+//!          .for_each(|p| *p += 1);
+//! }
+//! ```
+//!
+//! To use parallel iterators, first import the traits by adding
+//! something like `use rayon::prelude::*` to your module. You can
+//! then call `par_iter`, `par_iter_mut`, or `into_par_iter` to get a
+//! parallel iterator. Like a [regular iterator][], parallel
+//! iterators work by first constructing a computation and then
+//! executing it.
+//!
+//! In addition to `par_iter()` and friends, some types offer other
+//! ways to create (or consume) parallel iterators:
+//!
+//! - Slices (`&[T]`, `&mut [T]`) offer methods like `par_split` and
+//!   `par_windows`, as well as various parallel sorting
+//!   operations. See [the `ParallelSlice` trait] for the full list.
+//! - Strings (`&str`) offer methods like `par_split` and `par_lines`.
+//!   See [the `ParallelString` trait] for the full list.
+//! - Various collections offer [`par_extend`], which grows a
+//!   collection given a parallel iterator. (If you don't have a
+//!   collection to extend, you can use [`collect()`] to create a new
+//!   one from scratch.)
+//!
+//! [the `ParallelSlice` trait]: ../slice/trait.ParallelSlice.html
+//! [the `ParallelString` trait]: ../str/trait.ParallelString.html
+//! [`par_extend`]: trait.ParallelExtend.html
+//! [`collect()`]: trait.ParallelIterator.html#method.collect
+//!
+//! To see the full range of methods available on parallel iterators,
+//! check out the [`ParallelIterator`] and [`IndexedParallelIterator`]
+//! traits.
+//!
+//! If you'd like to build a custom parallel iterator, or to write your own
+//! combinator, then check out the [split] function and the [plumbing] module.
+//!
+//! [regular iterator]: https://doc.rust-lang.org/std/iter/trait.Iterator.html
+//! [`ParallelIterator`]: trait.ParallelIterator.html
+//! [`IndexedParallelIterator`]: trait.IndexedParallelIterator.html
+//! [split]: fn.split.html
+//! [plumbing]: plumbing/index.html
+//!
+//! Note: Several of the `ParallelIterator` methods rely on a `Try` trait which
+//! has been deliberately obscured from the public API.  This trait is intended
+//! to mirror the unstable `std::ops::Try` with implementations for `Option` and
+//! `Result`, where `Some`/`Ok` values will let those iterators continue, but
+//! `None`/`Err` values will exit early.
+//!
+//! A note about object safety: It is currently _not_ possible to wrap
+//! a `ParallelIterator` (or any trait that depends on it) using a
+//! `Box<dyn ParallelIterator>` or other kind of dynamic allocation,
+//! because `ParallelIterator` is **not object-safe**.
+//! (This keeps the implementation simpler and allows extra optimizations.)
+
+use self::plumbing::*;
+use self::private::Try;
+pub use either::Either;
+use std::cmp::{self, Ordering};
+use std::iter::{Product, Sum};
+use std::ops::{Fn, RangeBounds};
+
+pub mod plumbing;
+
+#[cfg(test)]
+mod test;
+
+// There is a method to the madness here:
+//
+// - These modules are private but expose certain types to the end-user
+//   (e.g., `enumerate::Enumerate`) -- specifically, the types that appear in the
+//   public API surface of the `ParallelIterator` traits.
+// - In **this** module, those public types are always used unprefixed, which forces
+//   us to add a `pub use` and helps identify if we missed anything.
+// - In contrast, items that appear **only** in the body of a method,
+//   e.g. `find::find()`, are always used **prefixed**, so that they
+//   can be readily distinguished.
+
+mod chain;
+mod chunks;
+mod cloned;
+mod collect;
+mod copied;
+mod empty;
+mod enumerate;
+mod extend;
+mod filter;
+mod filter_map;
+mod find;
+mod find_first_last;
+mod flat_map;
+mod flat_map_iter;
+mod flatten;
+mod flatten_iter;
+mod fold;
+mod fold_chunks;
+mod fold_chunks_with;
+mod for_each;
+mod from_par_iter;
+mod inspect;
+mod interleave;
+mod interleave_shortest;
+mod intersperse;
+mod len;
+mod map;
+mod map_with;
+mod multizip;
+mod noop;
+mod once;
+mod panic_fuse;
+mod par_bridge;
+mod positions;
+mod product;
+mod reduce;
+mod repeat;
+mod rev;
+mod skip;
+mod skip_any;
+mod skip_any_while;
+mod splitter;
+mod step_by;
+mod sum;
+mod take;
+mod take_any;
+mod take_any_while;
+mod try_fold;
+mod try_reduce;
+mod try_reduce_with;
+mod unzip;
+mod update;
+mod while_some;
+mod zip;
+mod zip_eq;
+
+pub use self::{
+    chain::Chain,
+    chunks::Chunks,
+    cloned::Cloned,
+    copied::Copied,
+    empty::{empty, Empty},
+    enumerate::Enumerate,
+    filter::Filter,
+    filter_map::FilterMap,
+    flat_map::FlatMap,
+    flat_map_iter::FlatMapIter,
+    flatten::Flatten,
+    flatten_iter::FlattenIter,
+    fold::{Fold, FoldWith},
+    fold_chunks::FoldChunks,
+    fold_chunks_with::FoldChunksWith,
+    inspect::Inspect,
+    interleave::Interleave,
+    interleave_shortest::InterleaveShortest,
+    intersperse::Intersperse,
+    len::{MaxLen, MinLen},
+    map::Map,
+    map_with::{MapInit, MapWith},
+    multizip::MultiZip,
+    once::{once, Once},
+    panic_fuse::PanicFuse,
+    par_bridge::{IterBridge, ParallelBridge},
+    positions::Positions,
+    repeat::{repeat, repeatn, Repeat, RepeatN},
+    rev::Rev,
+    skip::Skip,
+    skip_any::SkipAny,
+    skip_any_while::SkipAnyWhile,
+    splitter::{split, Split},
+    step_by::StepBy,
+    take::Take,
+    take_any::TakeAny,
+    take_any_while::TakeAnyWhile,
+    try_fold::{TryFold, TryFoldWith},
+    update::Update,
+    while_some::WhileSome,
+    zip::Zip,
+    zip_eq::ZipEq,
+};
+
+/// `IntoParallelIterator` implements the conversion to a [`ParallelIterator`].
+///
+/// By implementing `IntoParallelIterator` for a type, you define how it will
+/// transformed into an iterator. This is a parallel version of the standard
+/// library's [`std::iter::IntoIterator`] trait.
+///
+/// [`ParallelIterator`]: trait.ParallelIterator.html
+/// [`std::iter::IntoIterator`]: https://doc.rust-lang.org/std/iter/trait.IntoIterator.html
+pub trait IntoParallelIterator {
+    /// The parallel iterator type that will be created.
+    type Iter: ParallelIterator<Item = Self::Item>;
+
+    /// The type of item that the parallel iterator will produce.
+    type Item: Send;
+
+    /// Converts `self` into a parallel iterator.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// println!("counting in parallel:");
+    /// (0..100).into_par_iter()
+    ///     .for_each(|i| println!("{}", i));
+    /// ```
+    ///
+    /// This conversion is often implicit for arguments to methods like [`zip`].
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let v: Vec<_> = (0..5).into_par_iter().zip(5..10).collect();
+    /// assert_eq!(v, [(0, 5), (1, 6), (2, 7), (3, 8), (4, 9)]);
+    /// ```
+    ///
+    /// [`zip`]: trait.IndexedParallelIterator.html#method.zip
+    fn into_par_iter(self) -> Self::Iter;
+}
+
+/// `IntoParallelRefIterator` implements the conversion to a
+/// [`ParallelIterator`], providing shared references to the data.
+///
+/// This is a parallel version of the `iter()` method
+/// defined by various collections.
+///
+/// This trait is automatically implemented
+/// `for I where &I: IntoParallelIterator`. In most cases, users
+/// will want to implement [`IntoParallelIterator`] rather than implement
+/// this trait directly.
+///
+/// [`ParallelIterator`]: trait.ParallelIterator.html
+/// [`IntoParallelIterator`]: trait.IntoParallelIterator.html
+pub trait IntoParallelRefIterator<'data> {
+    /// The type of the parallel iterator that will be returned.
+    type Iter: ParallelIterator<Item = Self::Item>;
+
+    /// The type of item that the parallel iterator will produce.
+    /// This will typically be an `&'data T` reference type.
+    type Item: Send + 'data;
+
+    /// Converts `self` into a parallel iterator.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let v: Vec<_> = (0..100).collect();
+    /// assert_eq!(v.par_iter().sum::<i32>(), 100 * 99 / 2);
+    ///
+    /// // `v.par_iter()` is shorthand for `(&v).into_par_iter()`,
+    /// // producing the exact same references.
+    /// assert!(v.par_iter().zip(&v)
+    ///          .all(|(a, b)| std::ptr::eq(a, b)));
+    /// ```
+    fn par_iter(&'data self) -> Self::Iter;
+}
+
+impl<'data, I: 'data + ?Sized> IntoParallelRefIterator<'data> for I
+where
+    &'data I: IntoParallelIterator,
+{
+    type Iter = <&'data I as IntoParallelIterator>::Iter;
+    type Item = <&'data I as IntoParallelIterator>::Item;
+
+    fn par_iter(&'data self) -> Self::Iter {
+        self.into_par_iter()
+    }
+}
+
+/// `IntoParallelRefMutIterator` implements the conversion to a
+/// [`ParallelIterator`], providing mutable references to the data.
+///
+/// This is a parallel version of the `iter_mut()` method
+/// defined by various collections.
+///
+/// This trait is automatically implemented
+/// `for I where &mut I: IntoParallelIterator`. In most cases, users
+/// will want to implement [`IntoParallelIterator`] rather than implement
+/// this trait directly.
+///
+/// [`ParallelIterator`]: trait.ParallelIterator.html
+/// [`IntoParallelIterator`]: trait.IntoParallelIterator.html
+pub trait IntoParallelRefMutIterator<'data> {
+    /// The type of iterator that will be created.
+    type Iter: ParallelIterator<Item = Self::Item>;
+
+    /// The type of item that will be produced; this is typically an
+    /// `&'data mut T` reference.
+    type Item: Send + 'data;
+
+    /// Creates the parallel iterator from `self`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let mut v = vec![0usize; 5];
+    /// v.par_iter_mut().enumerate().for_each(|(i, x)| *x = i);
+    /// assert_eq!(v, [0, 1, 2, 3, 4]);
+    /// ```
+    fn par_iter_mut(&'data mut self) -> Self::Iter;
+}
+
+impl<'data, I: 'data + ?Sized> IntoParallelRefMutIterator<'data> for I
+where
+    &'data mut I: IntoParallelIterator,
+{
+    type Iter = <&'data mut I as IntoParallelIterator>::Iter;
+    type Item = <&'data mut I as IntoParallelIterator>::Item;
+
+    fn par_iter_mut(&'data mut self) -> Self::Iter {
+        self.into_par_iter()
+    }
+}
+
+/// Parallel version of the standard iterator trait.
+///
+/// The combinators on this trait are available on **all** parallel
+/// iterators.  Additional methods can be found on the
+/// [`IndexedParallelIterator`] trait: those methods are only
+/// available for parallel iterators where the number of items is
+/// known in advance (so, e.g., after invoking `filter`, those methods
+/// become unavailable).
+///
+/// For examples of using parallel iterators, see [the docs on the
+/// `iter` module][iter].
+///
+/// [iter]: index.html
+/// [`IndexedParallelIterator`]: trait.IndexedParallelIterator.html
+pub trait ParallelIterator: Sized + Send {
+    /// The type of item that this parallel iterator produces.
+    /// For example, if you use the [`for_each`] method, this is the type of
+    /// item that your closure will be invoked with.
+    ///
+    /// [`for_each`]: #method.for_each
+    type Item: Send;
+
+    /// Executes `OP` on each item produced by the iterator, in parallel.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// (0..100).into_par_iter().for_each(|x| println!("{:?}", x));
+    /// ```
+    fn for_each<OP>(self, op: OP)
+    where
+        OP: Fn(Self::Item) + Sync + Send,
+    {
+        for_each::for_each(self, &op)
+    }
+
+    /// Executes `OP` on the given `init` value with each item produced by
+    /// the iterator, in parallel.
+    ///
+    /// The `init` value will be cloned only as needed to be paired with
+    /// the group of items in each rayon job.  It does not require the type
+    /// to be `Sync`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::sync::mpsc::channel;
+    /// use rayon::prelude::*;
+    ///
+    /// let (sender, receiver) = channel();
+    ///
+    /// (0..5).into_par_iter().for_each_with(sender, |s, x| s.send(x).unwrap());
+    ///
+    /// let mut res: Vec<_> = receiver.iter().collect();
+    ///
+    /// res.sort();
+    ///
+    /// assert_eq!(&res[..], &[0, 1, 2, 3, 4])
+    /// ```
+    fn for_each_with<OP, T>(self, init: T, op: OP)
+    where
+        OP: Fn(&mut T, Self::Item) + Sync + Send,
+        T: Send + Clone,
+    {
+        self.map_with(init, op).collect()
+    }
+
+    /// Executes `OP` on a value returned by `init` with each item produced by
+    /// the iterator, in parallel.
+    ///
+    /// The `init` function will be called only as needed for a value to be
+    /// paired with the group of items in each rayon job.  There is no
+    /// constraint on that returned type at all!
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rand::Rng;
+    /// use rayon::prelude::*;
+    ///
+    /// let mut v = vec![0u8; 1_000_000];
+    ///
+    /// v.par_chunks_mut(1000)
+    ///     .for_each_init(
+    ///         || rand::thread_rng(),
+    ///         |rng, chunk| rng.fill(chunk),
+    ///     );
+    ///
+    /// // There's a remote chance that this will fail...
+    /// for i in 0u8..=255 {
+    ///     assert!(v.contains(&i));
+    /// }
+    /// ```
+    fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP)
+    where
+        OP: Fn(&mut T, Self::Item) + Sync + Send,
+        INIT: Fn() -> T + Sync + Send,
+    {
+        self.map_init(init, op).collect()
+    }
+
+    /// Executes a fallible `OP` on each item produced by the iterator, in parallel.
+    ///
+    /// If the `OP` returns `Result::Err` or `Option::None`, we will attempt to
+    /// stop processing the rest of the items in the iterator as soon as
+    /// possible, and we will return that terminating value.  Otherwise, we will
+    /// return an empty `Result::Ok(())` or `Option::Some(())`.  If there are
+    /// multiple errors in parallel, it is not specified which will be returned.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    /// use std::io::{self, Write};
+    ///
+    /// // This will stop iteration early if there's any write error, like
+    /// // having piped output get closed on the other end.
+    /// (0..100).into_par_iter()
+    ///     .try_for_each(|x| writeln!(io::stdout(), "{:?}", x))
+    ///     .expect("expected no write errors");
+    /// ```
+    fn try_for_each<OP, R>(self, op: OP) -> R
+    where
+        OP: Fn(Self::Item) -> R + Sync + Send,
+        R: Try<Output = ()> + Send,
+    {
+        fn ok<R: Try<Output = ()>>(_: (), _: ()) -> R {
+            R::from_output(())
+        }
+
+        self.map(op).try_reduce(<()>::default, ok)
+    }
+
+    /// Executes a fallible `OP` on the given `init` value with each item
+    /// produced by the iterator, in parallel.
+    ///
+    /// This combines the `init` semantics of [`for_each_with()`] and the
+    /// failure semantics of [`try_for_each()`].
+    ///
+    /// [`for_each_with()`]: #method.for_each_with
+    /// [`try_for_each()`]: #method.try_for_each
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::sync::mpsc::channel;
+    /// use rayon::prelude::*;
+    ///
+    /// let (sender, receiver) = channel();
+    ///
+    /// (0..5).into_par_iter()
+    ///     .try_for_each_with(sender, |s, x| s.send(x))
+    ///     .expect("expected no send errors");
+    ///
+    /// let mut res: Vec<_> = receiver.iter().collect();
+    ///
+    /// res.sort();
+    ///
+    /// assert_eq!(&res[..], &[0, 1, 2, 3, 4])
+    /// ```
+    fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R
+    where
+        OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
+        T: Send + Clone,
+        R: Try<Output = ()> + Send,
+    {
+        fn ok<R: Try<Output = ()>>(_: (), _: ()) -> R {
+            R::from_output(())
+        }
+
+        self.map_with(init, op).try_reduce(<()>::default, ok)
+    }
+
+    /// Executes a fallible `OP` on a value returned by `init` with each item
+    /// produced by the iterator, in parallel.
+    ///
+    /// This combines the `init` semantics of [`for_each_init()`] and the
+    /// failure semantics of [`try_for_each()`].
+    ///
+    /// [`for_each_init()`]: #method.for_each_init
+    /// [`try_for_each()`]: #method.try_for_each
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rand::Rng;
+    /// use rayon::prelude::*;
+    ///
+    /// let mut v = vec![0u8; 1_000_000];
+    ///
+    /// v.par_chunks_mut(1000)
+    ///     .try_for_each_init(
+    ///         || rand::thread_rng(),
+    ///         |rng, chunk| rng.try_fill(chunk),
+    ///     )
+    ///     .expect("expected no rand errors");
+    ///
+    /// // There's a remote chance that this will fail...
+    /// for i in 0u8..=255 {
+    ///     assert!(v.contains(&i));
+    /// }
+    /// ```
+    fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R
+    where
+        OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
+        INIT: Fn() -> T + Sync + Send,
+        R: Try<Output = ()> + Send,
+    {
+        fn ok<R: Try<Output = ()>>(_: (), _: ()) -> R {
+            R::from_output(())
+        }
+
+        self.map_init(init, op).try_reduce(<()>::default, ok)
+    }
+
+    /// Counts the number of items in this parallel iterator.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let count = (0..100).into_par_iter().count();
+    ///
+    /// assert_eq!(count, 100);
+    /// ```
+    fn count(self) -> usize {
+        fn one<T>(_: T) -> usize {
+            1
+        }
+
+        self.map(one).sum()
+    }
+
+    /// Applies `map_op` to each item of this iterator, producing a new
+    /// iterator with the results.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let mut par_iter = (0..5).into_par_iter().map(|x| x * 2);
+    ///
+    /// let doubles: Vec<_> = par_iter.collect();
+    ///
+    /// assert_eq!(&doubles[..], &[0, 2, 4, 6, 8]);
+    /// ```
+    fn map<F, R>(self, map_op: F) -> Map<Self, F>
+    where
+        F: Fn(Self::Item) -> R + Sync + Send,
+        R: Send,
+    {
+        Map::new(self, map_op)
+    }
+
+    /// Applies `map_op` to the given `init` value with each item of this
+    /// iterator, producing a new iterator with the results.
+    ///
+    /// The `init` value will be cloned only as needed to be paired with
+    /// the group of items in each rayon job.  It does not require the type
+    /// to be `Sync`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::sync::mpsc::channel;
+    /// use rayon::prelude::*;
+    ///
+    /// let (sender, receiver) = channel();
+    ///
+    /// let a: Vec<_> = (0..5)
+    ///                 .into_par_iter()            // iterating over i32
+    ///                 .map_with(sender, |s, x| {
+    ///                     s.send(x).unwrap();     // sending i32 values through the channel
+    ///                     x                       // returning i32
+    ///                 })
+    ///                 .collect();                 // collecting the returned values into a vector
+    ///
+    /// let mut b: Vec<_> = receiver.iter()         // iterating over the values in the channel
+    ///                             .collect();     // and collecting them
+    /// b.sort();
+    ///
+    /// assert_eq!(a, b);
+    /// ```
+    fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F>
+    where
+        F: Fn(&mut T, Self::Item) -> R + Sync + Send,
+        T: Send + Clone,
+        R: Send,
+    {
+        MapWith::new(self, init, map_op)
+    }
+
+    /// Applies `map_op` to a value returned by `init` with each item of this
+    /// iterator, producing a new iterator with the results.
+    ///
+    /// The `init` function will be called only as needed for a value to be
+    /// paired with the group of items in each rayon job.  There is no
+    /// constraint on that returned type at all!
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rand::Rng;
+    /// use rayon::prelude::*;
+    ///
+    /// let a: Vec<_> = (1i32..1_000_000)
+    ///     .into_par_iter()
+    ///     .map_init(
+    ///         || rand::thread_rng(),  // get the thread-local RNG
+    ///         |rng, x| if rng.gen() { // randomly negate items
+    ///             -x
+    ///         } else {
+    ///             x
+    ///         },
+    ///     ).collect();
+    ///
+    /// // There's a remote chance that this will fail...
+    /// assert!(a.iter().any(|&x| x < 0));
+    /// assert!(a.iter().any(|&x| x > 0));
+    /// ```
+    fn map_init<F, INIT, T, R>(self, init: INIT, map_op: F) -> MapInit<Self, INIT, F>
+    where
+        F: Fn(&mut T, Self::Item) -> R + Sync + Send,
+        INIT: Fn() -> T + Sync + Send,
+        R: Send,
+    {
+        MapInit::new(self, init, map_op)
+    }
+
+    /// Creates an iterator which clones all of its elements.  This may be
+    /// useful when you have an iterator over `&T`, but you need `T`, and
+    /// that type implements `Clone`. See also [`copied()`].
+    ///
+    /// [`copied()`]: #method.copied
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let a = [1, 2, 3];
+    ///
+    /// let v_cloned: Vec<_> = a.par_iter().cloned().collect();
+    ///
+    /// // cloned is the same as .map(|&x| x), for integers
+    /// let v_map: Vec<_> = a.par_iter().map(|&x| x).collect();
+    ///
+    /// assert_eq!(v_cloned, vec![1, 2, 3]);
+    /// assert_eq!(v_map, vec![1, 2, 3]);
+    /// ```
+    fn cloned<'a, T>(self) -> Cloned<Self>
+    where
+        T: 'a + Clone + Send,
+        Self: ParallelIterator<Item = &'a T>,
+    {
+        Cloned::new(self)
+    }
+
+    /// Creates an iterator which copies all of its elements.  This may be
+    /// useful when you have an iterator over `&T`, but you need `T`, and
+    /// that type implements `Copy`. See also [`cloned()`].
+    ///
+    /// [`cloned()`]: #method.cloned
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let a = [1, 2, 3];
+    ///
+    /// let v_copied: Vec<_> = a.par_iter().copied().collect();
+    ///
+    /// // copied is the same as .map(|&x| x), for integers
+    /// let v_map: Vec<_> = a.par_iter().map(|&x| x).collect();
+    ///
+    /// assert_eq!(v_copied, vec![1, 2, 3]);
+    /// assert_eq!(v_map, vec![1, 2, 3]);
+    /// ```
+    fn copied<'a, T>(self) -> Copied<Self>
+    where
+        T: 'a + Copy + Send,
+        Self: ParallelIterator<Item = &'a T>,
+    {
+        Copied::new(self)
+    }
+
+    /// Applies `inspect_op` to a reference to each item of this iterator,
+    /// producing a new iterator passing through the original items.  This is
+    /// often useful for debugging to see what's happening in iterator stages.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let a = [1, 4, 2, 3];
+    ///
+    /// // this iterator sequence is complex.
+    /// let sum = a.par_iter()
+    ///             .cloned()
+    ///             .filter(|&x| x % 2 == 0)
+    ///             .reduce(|| 0, |sum, i| sum + i);
+    ///
+    /// println!("{}", sum);
+    ///
+    /// // let's add some inspect() calls to investigate what's happening
+    /// let sum = a.par_iter()
+    ///             .cloned()
+    ///             .inspect(|x| println!("about to filter: {}", x))
+    ///             .filter(|&x| x % 2 == 0)
+    ///             .inspect(|x| println!("made it through filter: {}", x))
+    ///             .reduce(|| 0, |sum, i| sum + i);
+    ///
+    /// println!("{}", sum);
+    /// ```
+    fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP>
+    where
+        OP: Fn(&Self::Item) + Sync + Send,
+    {
+        Inspect::new(self, inspect_op)
+    }
+
+    /// Mutates each item of this iterator before yielding it.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let par_iter = (0..5).into_par_iter().update(|x| {*x *= 2;});
+    ///
+    /// let doubles: Vec<_> = par_iter.collect();
+    ///
+    /// assert_eq!(&doubles[..], &[0, 2, 4, 6, 8]);
+    /// ```
+    fn update<F>(self, update_op: F) -> Update<Self, F>
+    where
+        F: Fn(&mut Self::Item) + Sync + Send,
+    {
+        Update::new(self, update_op)
+    }
+
+    /// Applies `filter_op` to each item of this iterator, producing a new
+    /// iterator with only the items that gave `true` results.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let mut par_iter = (0..10).into_par_iter().filter(|x| x % 2 == 0);
+    ///
+    /// let even_numbers: Vec<_> = par_iter.collect();
+    ///
+    /// assert_eq!(&even_numbers[..], &[0, 2, 4, 6, 8]);
+    /// ```
+    fn filter<P>(self, filter_op: P) -> Filter<Self, P>
+    where
+        P: Fn(&Self::Item) -> bool + Sync + Send,
+    {
+        Filter::new(self, filter_op)
+    }
+
+    /// Applies `filter_op` to each item of this iterator to get an `Option`,
+    /// producing a new iterator with only the items from `Some` results.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let mut par_iter = (0..10).into_par_iter()
+    ///                         .filter_map(|x| {
+    ///                             if x % 2 == 0 { Some(x * 3) }
+    ///                             else { None }
+    ///                         });
+    ///
+    /// let even_numbers: Vec<_> = par_iter.collect();
+    ///
+    /// assert_eq!(&even_numbers[..], &[0, 6, 12, 18, 24]);
+    /// ```
+    fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P>
+    where
+        P: Fn(Self::Item) -> Option<R> + Sync + Send,
+        R: Send,
+    {
+        FilterMap::new(self, filter_op)
+    }
+
+    /// Applies `map_op` to each item of this iterator to get nested parallel iterators,
+    /// producing a new parallel iterator that flattens these back into one.
+    ///
+    /// See also [`flat_map_iter`](#method.flat_map_iter).
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let a = [[1, 2], [3, 4], [5, 6], [7, 8]];
+    ///
+    /// let par_iter = a.par_iter().cloned().flat_map(|a| a.to_vec());
+    ///
+    /// let vec: Vec<_> = par_iter.collect();
+    ///
+    /// assert_eq!(&vec[..], &[1, 2, 3, 4, 5, 6, 7, 8]);
+    /// ```
+    fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F>
+    where
+        F: Fn(Self::Item) -> PI + Sync + Send,
+        PI: IntoParallelIterator,
+    {
+        FlatMap::new(self, map_op)
+    }
+
+    /// Applies `map_op` to each item of this iterator to get nested serial iterators,
+    /// producing a new parallel iterator that flattens these back into one.
+    ///
+    /// # `flat_map_iter` versus `flat_map`
+    ///
+    /// These two methods are similar but behave slightly differently. With [`flat_map`],
+    /// each of the nested iterators must be a parallel iterator, and they will be further
+    /// split up with nested parallelism. With `flat_map_iter`, each nested iterator is a
+    /// sequential `Iterator`, and we only parallelize _between_ them, while the items
+    /// produced by each nested iterator are processed sequentially.
+    ///
+    /// When choosing between these methods, consider whether nested parallelism suits the
+    /// potential iterators at hand. If there's little computation involved, or its length
+    /// is much less than the outer parallel iterator, then it may perform better to avoid
+    /// the overhead of parallelism, just flattening sequentially with `flat_map_iter`.
+    /// If there is a lot of computation, potentially outweighing the outer parallel
+    /// iterator, then the nested parallelism of `flat_map` may be worthwhile.
+    ///
+    /// [`flat_map`]: #method.flat_map
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    /// use std::cell::RefCell;
+    ///
+    /// let a = [[1, 2], [3, 4], [5, 6], [7, 8]];
+    ///
+    /// let par_iter = a.par_iter().flat_map_iter(|a| {
+    ///     // The serial iterator doesn't have to be thread-safe, just its items.
+    ///     let cell_iter = RefCell::new(a.iter().cloned());
+    ///     std::iter::from_fn(move || cell_iter.borrow_mut().next())
+    /// });
+    ///
+    /// let vec: Vec<_> = par_iter.collect();
+    ///
+    /// assert_eq!(&vec[..], &[1, 2, 3, 4, 5, 6, 7, 8]);
+    /// ```
+    fn flat_map_iter<F, SI>(self, map_op: F) -> FlatMapIter<Self, F>
+    where
+        F: Fn(Self::Item) -> SI + Sync + Send,
+        SI: IntoIterator,
+        SI::Item: Send,
+    {
+        FlatMapIter::new(self, map_op)
+    }
+
+    /// An adaptor that flattens parallel-iterable `Item`s into one large iterator.
+    ///
+    /// See also [`flatten_iter`](#method.flatten_iter).
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let x: Vec<Vec<_>> = vec![vec![1, 2], vec![3, 4]];
+    /// let y: Vec<_> = x.into_par_iter().flatten().collect();
+    ///
+    /// assert_eq!(y, vec![1, 2, 3, 4]);
+    /// ```
+    fn flatten(self) -> Flatten<Self>
+    where
+        Self::Item: IntoParallelIterator,
+    {
+        Flatten::new(self)
+    }
+
+    /// An adaptor that flattens serial-iterable `Item`s into one large iterator.
+    ///
+    /// See also [`flatten`](#method.flatten) and the analogous comparison of
+    /// [`flat_map_iter` versus `flat_map`](#flat_map_iter-versus-flat_map).
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let x: Vec<Vec<_>> = vec![vec![1, 2], vec![3, 4]];
+    /// let iters: Vec<_> = x.into_iter().map(Vec::into_iter).collect();
+    /// let y: Vec<_> = iters.into_par_iter().flatten_iter().collect();
+    ///
+    /// assert_eq!(y, vec![1, 2, 3, 4]);
+    /// ```
+    fn flatten_iter(self) -> FlattenIter<Self>
+    where
+        Self::Item: IntoIterator,
+        <Self::Item as IntoIterator>::Item: Send,
+    {
+        FlattenIter::new(self)
+    }
+
+    /// Reduces the items in the iterator into one item using `op`.
+    /// The argument `identity` should be a closure that can produce
+    /// "identity" value which may be inserted into the sequence as
+    /// needed to create opportunities for parallel execution. So, for
+    /// example, if you are doing a summation, then `identity()` ought
+    /// to produce something that represents the zero for your type
+    /// (but consider just calling `sum()` in that case).
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// // Iterate over a sequence of pairs `(x0, y0), ..., (xN, yN)`
+    /// // and use reduce to compute one pair `(x0 + ... + xN, y0 + ... + yN)`
+    /// // where the first/second elements are summed separately.
+    /// use rayon::prelude::*;
+    /// let sums = [(0, 1), (5, 6), (16, 2), (8, 9)]
+    ///            .par_iter()        // iterating over &(i32, i32)
+    ///            .cloned()          // iterating over (i32, i32)
+    ///            .reduce(|| (0, 0), // the "identity" is 0 in both columns
+    ///                    |a, b| (a.0 + b.0, a.1 + b.1));
+    /// assert_eq!(sums, (0 + 5 + 16 + 8, 1 + 6 + 2 + 9));
+    /// ```
+    ///
+    /// **Note:** unlike a sequential `fold` operation, the order in
+    /// which `op` will be applied to reduce the result is not fully
+    /// specified. So `op` should be [associative] or else the results
+    /// will be non-deterministic. And of course `identity()` should
+    /// produce a true identity.
+    ///
+    /// [associative]: https://en.wikipedia.org/wiki/Associative_property
+    fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item
+    where
+        OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
+        ID: Fn() -> Self::Item + Sync + Send,
+    {
+        reduce::reduce(self, identity, op)
+    }
+
+    /// Reduces the items in the iterator into one item using `op`.
+    /// If the iterator is empty, `None` is returned; otherwise,
+    /// `Some` is returned.
+    ///
+    /// This version of `reduce` is simple but somewhat less
+    /// efficient. If possible, it is better to call `reduce()`, which
+    /// requires an identity element.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    /// let sums = [(0, 1), (5, 6), (16, 2), (8, 9)]
+    ///            .par_iter()        // iterating over &(i32, i32)
+    ///            .cloned()          // iterating over (i32, i32)
+    ///            .reduce_with(|a, b| (a.0 + b.0, a.1 + b.1))
+    ///            .unwrap();
+    /// assert_eq!(sums, (0 + 5 + 16 + 8, 1 + 6 + 2 + 9));
+    /// ```
+    ///
+    /// **Note:** unlike a sequential `fold` operation, the order in
+    /// which `op` will be applied to reduce the result is not fully
+    /// specified. So `op` should be [associative] or else the results
+    /// will be non-deterministic.
+    ///
+    /// [associative]: https://en.wikipedia.org/wiki/Associative_property
+    fn reduce_with<OP>(self, op: OP) -> Option<Self::Item>
+    where
+        OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
+    {
+        fn opt_fold<T>(op: impl Fn(T, T) -> T) -> impl Fn(Option<T>, T) -> Option<T> {
+            move |opt_a, b| match opt_a {
+                Some(a) => Some(op(a, b)),
+                None => Some(b),
+            }
+        }
+
+        fn opt_reduce<T>(op: impl Fn(T, T) -> T) -> impl Fn(Option<T>, Option<T>) -> Option<T> {
+            move |opt_a, opt_b| match (opt_a, opt_b) {
+                (Some(a), Some(b)) => Some(op(a, b)),
+                (Some(v), None) | (None, Some(v)) => Some(v),
+                (None, None) => None,
+            }
+        }
+
+        self.fold(<_>::default, opt_fold(&op))
+            .reduce(<_>::default, opt_reduce(&op))
+    }
+
+    /// Reduces the items in the iterator into one item using a fallible `op`.
+    /// The `identity` argument is used the same way as in [`reduce()`].
+    ///
+    /// [`reduce()`]: #method.reduce
+    ///
+    /// If a `Result::Err` or `Option::None` item is found, or if `op` reduces
+    /// to one, we will attempt to stop processing the rest of the items in the
+    /// iterator as soon as possible, and we will return that terminating value.
+    /// Otherwise, we will return the final reduced `Result::Ok(T)` or
+    /// `Option::Some(T)`.  If there are multiple errors in parallel, it is not
+    /// specified which will be returned.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// // Compute the sum of squares, being careful about overflow.
+    /// fn sum_squares<I: IntoParallelIterator<Item = i32>>(iter: I) -> Option<i32> {
+    ///     iter.into_par_iter()
+    ///         .map(|i| i.checked_mul(i))            // square each item,
+    ///         .try_reduce(|| 0, i32::checked_add)   // and add them up!
+    /// }
+    /// assert_eq!(sum_squares(0..5), Some(0 + 1 + 4 + 9 + 16));
+    ///
+    /// // The sum might overflow
+    /// assert_eq!(sum_squares(0..10_000), None);
+    ///
+    /// // Or the squares might overflow before it even reaches `try_reduce`
+    /// assert_eq!(sum_squares(1_000_000..1_000_001), None);
+    /// ```
+    fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item
+    where
+        OP: Fn(T, T) -> Self::Item + Sync + Send,
+        ID: Fn() -> T + Sync + Send,
+        Self::Item: Try<Output = T>,
+    {
+        try_reduce::try_reduce(self, identity, op)
+    }
+
+    /// Reduces the items in the iterator into one item using a fallible `op`.
+    ///
+    /// Like [`reduce_with()`], if the iterator is empty, `None` is returned;
+    /// otherwise, `Some` is returned.  Beyond that, it behaves like
+    /// [`try_reduce()`] for handling `Err`/`None`.
+    ///
+    /// [`reduce_with()`]: #method.reduce_with
+    /// [`try_reduce()`]: #method.try_reduce
+    ///
+    /// For instance, with `Option` items, the return value may be:
+    /// - `None`, the iterator was empty
+    /// - `Some(None)`, we stopped after encountering `None`.
+    /// - `Some(Some(x))`, the entire iterator reduced to `x`.
+    ///
+    /// With `Result` items, the nesting is more obvious:
+    /// - `None`, the iterator was empty
+    /// - `Some(Err(e))`, we stopped after encountering an error `e`.
+    /// - `Some(Ok(x))`, the entire iterator reduced to `x`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let files = ["/dev/null", "/does/not/exist"];
+    ///
+    /// // Find the biggest file
+    /// files.into_par_iter()
+    ///     .map(|path| std::fs::metadata(path).map(|m| (path, m.len())))
+    ///     .try_reduce_with(|a, b| {
+    ///         Ok(if a.1 >= b.1 { a } else { b })
+    ///     })
+    ///     .expect("Some value, since the iterator is not empty")
+    ///     .expect_err("not found");
+    /// ```
+    fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item>
+    where
+        OP: Fn(T, T) -> Self::Item + Sync + Send,
+        Self::Item: Try<Output = T>,
+    {
+        try_reduce_with::try_reduce_with(self, op)
+    }
+
+    /// Parallel fold is similar to sequential fold except that the
+    /// sequence of items may be subdivided before it is
+    /// folded. Consider a list of numbers like `22 3 77 89 46`. If
+    /// you used sequential fold to add them (`fold(0, |a,b| a+b)`,
+    /// you would wind up first adding 0 + 22, then 22 + 3, then 25 +
+    /// 77, and so forth. The **parallel fold** works similarly except
+    /// that it first breaks up your list into sublists, and hence
+    /// instead of yielding up a single sum at the end, it yields up
+    /// multiple sums. The number of results is nondeterministic, as
+    /// is the point where the breaks occur.
+    ///
+    /// So if we did the same parallel fold (`fold(0, |a,b| a+b)`) on
+    /// our example list, we might wind up with a sequence of two numbers,
+    /// like so:
+    ///
+    /// ```notrust
+    /// 22 3 77 89 46
+    ///       |     |
+    ///     102   135
+    /// ```
+    ///
+    /// Or perhaps these three numbers:
+    ///
+    /// ```notrust
+    /// 22 3 77 89 46
+    ///       |  |  |
+    ///     102 89 46
+    /// ```
+    ///
+    /// In general, Rayon will attempt to find good breaking points
+    /// that keep all of your cores busy.
+    ///
+    /// ### Fold versus reduce
+    ///
+    /// The `fold()` and `reduce()` methods each take an identity element
+    /// and a combining function, but they operate rather differently.
+    ///
+    /// `reduce()` requires that the identity function has the same
+    /// type as the things you are iterating over, and it fully
+    /// reduces the list of items into a single item. So, for example,
+    /// imagine we are iterating over a list of bytes `bytes: [128_u8,
+    /// 64_u8, 64_u8]`. If we used `bytes.reduce(|| 0_u8, |a: u8, b:
+    /// u8| a + b)`, we would get an overflow. This is because `0`,
+    /// `a`, and `b` here are all bytes, just like the numbers in the
+    /// list (I wrote the types explicitly above, but those are the
+    /// only types you can use). To avoid the overflow, we would need
+    /// to do something like `bytes.map(|b| b as u32).reduce(|| 0, |a,
+    /// b| a + b)`, in which case our result would be `256`.
+    ///
+    /// In contrast, with `fold()`, the identity function does not
+    /// have to have the same type as the things you are iterating
+    /// over, and you potentially get back many results. So, if we
+    /// continue with the `bytes` example from the previous paragraph,
+    /// we could do `bytes.fold(|| 0_u32, |a, b| a + (b as u32))` to
+    /// convert our bytes into `u32`. And of course we might not get
+    /// back a single sum.
+    ///
+    /// There is a more subtle distinction as well, though it's
+    /// actually implied by the above points. When you use `reduce()`,
+    /// your reduction function is sometimes called with values that
+    /// were never part of your original parallel iterator (for
+    /// example, both the left and right might be a partial sum). With
+    /// `fold()`, in contrast, the left value in the fold function is
+    /// always the accumulator, and the right value is always from
+    /// your original sequence.
+    ///
+    /// ### Fold vs Map/Reduce
+    ///
+    /// Fold makes sense if you have some operation where it is
+    /// cheaper to create groups of elements at a time. For example,
+    /// imagine collecting characters into a string. If you were going
+    /// to use map/reduce, you might try this:
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let s =
+    ///     ['a', 'b', 'c', 'd', 'e']
+    ///     .par_iter()
+    ///     .map(|c: &char| format!("{}", c))
+    ///     .reduce(|| String::new(),
+    ///             |mut a: String, b: String| { a.push_str(&b); a });
+    ///
+    /// assert_eq!(s, "abcde");
+    /// ```
+    ///
+    /// Because reduce produces the same type of element as its input,
+    /// you have to first map each character into a string, and then
+    /// you can reduce them. This means we create one string per
+    /// element in our iterator -- not so great. Using `fold`, we can
+    /// do this instead:
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let s =
+    ///     ['a', 'b', 'c', 'd', 'e']
+    ///     .par_iter()
+    ///     .fold(|| String::new(),
+    ///             |mut s: String, c: &char| { s.push(*c); s })
+    ///     .reduce(|| String::new(),
+    ///             |mut a: String, b: String| { a.push_str(&b); a });
+    ///
+    /// assert_eq!(s, "abcde");
+    /// ```
+    ///
+    /// Now `fold` will process groups of our characters at a time,
+    /// and we only make one string per group. We should wind up with
+    /// some small-ish number of strings roughly proportional to the
+    /// number of CPUs you have (it will ultimately depend on how busy
+    /// your processors are). Note that we still need to do a reduce
+    /// afterwards to combine those groups of strings into a single
+    /// string.
+    ///
+    /// You could use a similar trick to save partial results (e.g., a
+    /// cache) or something similar.
+    ///
+    /// ### Combining fold with other operations
+    ///
+    /// You can combine `fold` with `reduce` if you want to produce a
+    /// single value. This is then roughly equivalent to a map/reduce
+    /// combination in effect:
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let bytes = 0..22_u8;
+    /// let sum = bytes.into_par_iter()
+    ///                .fold(|| 0_u32, |a: u32, b: u8| a + (b as u32))
+    ///                .sum::<u32>();
+    ///
+    /// assert_eq!(sum, (0..22).sum()); // compare to sequential
+    /// ```
+    fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F>
+    where
+        F: Fn(T, Self::Item) -> T + Sync + Send,
+        ID: Fn() -> T + Sync + Send,
+        T: Send,
+    {
+        Fold::new(self, identity, fold_op)
+    }
+
+    /// Applies `fold_op` to the given `init` value with each item of this
+    /// iterator, finally producing the value for further use.
+    ///
+    /// This works essentially like `fold(|| init.clone(), fold_op)`, except
+    /// it doesn't require the `init` type to be `Sync`, nor any other form
+    /// of added synchronization.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let bytes = 0..22_u8;
+    /// let sum = bytes.into_par_iter()
+    ///                .fold_with(0_u32, |a: u32, b: u8| a + (b as u32))
+    ///                .sum::<u32>();
+    ///
+    /// assert_eq!(sum, (0..22).sum()); // compare to sequential
+    /// ```
+    fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F>
+    where
+        F: Fn(T, Self::Item) -> T + Sync + Send,
+        T: Send + Clone,
+    {
+        FoldWith::new(self, init, fold_op)
+    }
+
+    /// Performs a fallible parallel fold.
+    ///
+    /// This is a variation of [`fold()`] for operations which can fail with
+    /// `Option::None` or `Result::Err`.  The first such failure stops
+    /// processing the local set of items, without affecting other folds in the
+    /// iterator's subdivisions.
+    ///
+    /// Often, `try_fold()` will be followed by [`try_reduce()`]
+    /// for a final reduction and global short-circuiting effect.
+    ///
+    /// [`fold()`]: #method.fold
+    /// [`try_reduce()`]: #method.try_reduce
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let bytes = 0..22_u8;
+    /// let sum = bytes.into_par_iter()
+    ///                .try_fold(|| 0_u32, |a: u32, b: u8| a.checked_add(b as u32))
+    ///                .try_reduce(|| 0, u32::checked_add);
+    ///
+    /// assert_eq!(sum, Some((0..22).sum())); // compare to sequential
+    /// ```
+    fn try_fold<T, R, ID, F>(self, identity: ID, fold_op: F) -> TryFold<Self, R, ID, F>
+    where
+        F: Fn(T, Self::Item) -> R + Sync + Send,
+        ID: Fn() -> T + Sync + Send,
+        R: Try<Output = T> + Send,
+    {
+        TryFold::new(self, identity, fold_op)
+    }
+
+    /// Performs a fallible parallel fold with a cloneable `init` value.
+    ///
+    /// This combines the `init` semantics of [`fold_with()`] and the failure
+    /// semantics of [`try_fold()`].
+    ///
+    /// [`fold_with()`]: #method.fold_with
+    /// [`try_fold()`]: #method.try_fold
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let bytes = 0..22_u8;
+    /// let sum = bytes.into_par_iter()
+    ///                .try_fold_with(0_u32, |a: u32, b: u8| a.checked_add(b as u32))
+    ///                .try_reduce(|| 0, u32::checked_add);
+    ///
+    /// assert_eq!(sum, Some((0..22).sum())); // compare to sequential
+    /// ```
+    fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F>
+    where
+        F: Fn(T, Self::Item) -> R + Sync + Send,
+        R: Try<Output = T> + Send,
+        T: Clone + Send,
+    {
+        TryFoldWith::new(self, init, fold_op)
+    }
+
+    /// Sums up the items in the iterator.
+    ///
+    /// Note that the order in items will be reduced is not specified,
+    /// so if the `+` operator is not truly [associative] \(as is the
+    /// case for floating point numbers), then the results are not
+    /// fully deterministic.
+    ///
+    /// [associative]: https://en.wikipedia.org/wiki/Associative_property
+    ///
+    /// Basically equivalent to `self.reduce(|| 0, |a, b| a + b)`,
+    /// except that the type of `0` and the `+` operation may vary
+    /// depending on the type of value being produced.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let a = [1, 5, 7];
+    ///
+    /// let sum: i32 = a.par_iter().sum();
+    ///
+    /// assert_eq!(sum, 13);
+    /// ```
+    fn sum<S>(self) -> S
+    where
+        S: Send + Sum<Self::Item> + Sum<S>,
+    {
+        sum::sum(self)
+    }
+
+    /// Multiplies all the items in the iterator.
+    ///
+    /// Note that the order in items will be reduced is not specified,
+    /// so if the `*` operator is not truly [associative] \(as is the
+    /// case for floating point numbers), then the results are not
+    /// fully deterministic.
+    ///
+    /// [associative]: https://en.wikipedia.org/wiki/Associative_property
+    ///
+    /// Basically equivalent to `self.reduce(|| 1, |a, b| a * b)`,
+    /// except that the type of `1` and the `*` operation may vary
+    /// depending on the type of value being produced.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// fn factorial(n: u32) -> u32 {
+    ///    (1..n+1).into_par_iter().product()
+    /// }
+    ///
+    /// assert_eq!(factorial(0), 1);
+    /// assert_eq!(factorial(1), 1);
+    /// assert_eq!(factorial(5), 120);
+    /// ```
+    fn product<P>(self) -> P
+    where
+        P: Send + Product<Self::Item> + Product<P>,
+    {
+        product::product(self)
+    }
+
+    /// Computes the minimum of all the items in the iterator. If the
+    /// iterator is empty, `None` is returned; otherwise, `Some(min)`
+    /// is returned.
+    ///
+    /// Note that the order in which the items will be reduced is not
+    /// specified, so if the `Ord` impl is not truly associative, then
+    /// the results are not deterministic.
+    ///
+    /// Basically equivalent to `self.reduce_with(|a, b| cmp::min(a, b))`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let a = [45, 74, 32];
+    ///
+    /// assert_eq!(a.par_iter().min(), Some(&32));
+    ///
+    /// let b: [i32; 0] = [];
+    ///
+    /// assert_eq!(b.par_iter().min(), None);
+    /// ```
+    fn min(self) -> Option<Self::Item>
+    where
+        Self::Item: Ord,
+    {
+        self.reduce_with(cmp::min)
+    }
+
+    /// Computes the minimum of all the items in the iterator with respect to
+    /// the given comparison function. If the iterator is empty, `None` is
+    /// returned; otherwise, `Some(min)` is returned.
+    ///
+    /// Note that the order in which the items will be reduced is not
+    /// specified, so if the comparison function is not associative, then
+    /// the results are not deterministic.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let a = [-3_i32, 77, 53, 240, -1];
+    ///
+    /// assert_eq!(a.par_iter().min_by(|x, y| x.cmp(y)), Some(&-3));
+    /// ```
+    fn min_by<F>(self, f: F) -> Option<Self::Item>
+    where
+        F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
+    {
+        fn min<T>(f: impl Fn(&T, &T) -> Ordering) -> impl Fn(T, T) -> T {
+            move |a, b| match f(&a, &b) {
+                Ordering::Greater => b,
+                _ => a,
+            }
+        }
+
+        self.reduce_with(min(f))
+    }
+
+    /// Computes the item that yields the minimum value for the given
+    /// function. If the iterator is empty, `None` is returned;
+    /// otherwise, `Some(item)` is returned.
+    ///
+    /// Note that the order in which the items will be reduced is not
+    /// specified, so if the `Ord` impl is not truly associative, then
+    /// the results are not deterministic.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let a = [-3_i32, 34, 2, 5, -10, -3, -23];
+    ///
+    /// assert_eq!(a.par_iter().min_by_key(|x| x.abs()), Some(&2));
+    /// ```
+    fn min_by_key<K, F>(self, f: F) -> Option<Self::Item>
+    where
+        K: Ord + Send,
+        F: Sync + Send + Fn(&Self::Item) -> K,
+    {
+        fn key<T, K>(f: impl Fn(&T) -> K) -> impl Fn(T) -> (K, T) {
+            move |x| (f(&x), x)
+        }
+
+        fn min_key<T, K: Ord>(a: (K, T), b: (K, T)) -> (K, T) {
+            match (a.0).cmp(&b.0) {
+                Ordering::Greater => b,
+                _ => a,
+            }
+        }
+
+        let (_, x) = self.map(key(f)).reduce_with(min_key)?;
+        Some(x)
+    }
+
+    /// Computes the maximum of all the items in the iterator. If the
+    /// iterator is empty, `None` is returned; otherwise, `Some(max)`
+    /// is returned.
+    ///
+    /// Note that the order in which the items will be reduced is not
+    /// specified, so if the `Ord` impl is not truly associative, then
+    /// the results are not deterministic.
+    ///
+    /// Basically equivalent to `self.reduce_with(|a, b| cmp::max(a, b))`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let a = [45, 74, 32];
+    ///
+    /// assert_eq!(a.par_iter().max(), Some(&74));
+    ///
+    /// let b: [i32; 0] = [];
+    ///
+    /// assert_eq!(b.par_iter().max(), None);
+    /// ```
+    fn max(self) -> Option<Self::Item>
+    where
+        Self::Item: Ord,
+    {
+        self.reduce_with(cmp::max)
+    }
+
+    /// Computes the maximum of all the items in the iterator with respect to
+    /// the given comparison function. If the iterator is empty, `None` is
+    /// returned; otherwise, `Some(max)` is returned.
+    ///
+    /// Note that the order in which the items will be reduced is not
+    /// specified, so if the comparison function is not associative, then
+    /// the results are not deterministic.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let a = [-3_i32, 77, 53, 240, -1];
+    ///
+    /// assert_eq!(a.par_iter().max_by(|x, y| x.abs().cmp(&y.abs())), Some(&240));
+    /// ```
+    fn max_by<F>(self, f: F) -> Option<Self::Item>
+    where
+        F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
+    {
+        fn max<T>(f: impl Fn(&T, &T) -> Ordering) -> impl Fn(T, T) -> T {
+            move |a, b| match f(&a, &b) {
+                Ordering::Greater => a,
+                _ => b,
+            }
+        }
+
+        self.reduce_with(max(f))
+    }
+
+    /// Computes the item that yields the maximum value for the given
+    /// function. If the iterator is empty, `None` is returned;
+    /// otherwise, `Some(item)` is returned.
+    ///
+    /// Note that the order in which the items will be reduced is not
+    /// specified, so if the `Ord` impl is not truly associative, then
+    /// the results are not deterministic.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let a = [-3_i32, 34, 2, 5, -10, -3, -23];
+    ///
+    /// assert_eq!(a.par_iter().max_by_key(|x| x.abs()), Some(&34));
+    /// ```
+    fn max_by_key<K, F>(self, f: F) -> Option<Self::Item>
+    where
+        K: Ord + Send,
+        F: Sync + Send + Fn(&Self::Item) -> K,
+    {
+        fn key<T, K>(f: impl Fn(&T) -> K) -> impl Fn(T) -> (K, T) {
+            move |x| (f(&x), x)
+        }
+
+        fn max_key<T, K: Ord>(a: (K, T), b: (K, T)) -> (K, T) {
+            match (a.0).cmp(&b.0) {
+                Ordering::Greater => a,
+                _ => b,
+            }
+        }
+
+        let (_, x) = self.map(key(f)).reduce_with(max_key)?;
+        Some(x)
+    }
+
+    /// Takes two iterators and creates a new iterator over both.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let a = [0, 1, 2];
+    /// let b = [9, 8, 7];
+    ///
+    /// let par_iter = a.par_iter().chain(b.par_iter());
+    ///
+    /// let chained: Vec<_> = par_iter.cloned().collect();
+    ///
+    /// assert_eq!(&chained[..], &[0, 1, 2, 9, 8, 7]);
+    /// ```
+    fn chain<C>(self, chain: C) -> Chain<Self, C::Iter>
+    where
+        C: IntoParallelIterator<Item = Self::Item>,
+    {
+        Chain::new(self, chain.into_par_iter())
+    }
+
+    /// Searches for **some** item in the parallel iterator that
+    /// matches the given predicate and returns it. This operation
+    /// is similar to [`find` on sequential iterators][find] but
+    /// the item returned may not be the **first** one in the parallel
+    /// sequence which matches, since we search the entire sequence in parallel.
+    ///
+    /// Once a match is found, we will attempt to stop processing
+    /// the rest of the items in the iterator as soon as possible
+    /// (just as `find` stops iterating once a match is found).
+    ///
+    /// [find]: https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.find
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let a = [1, 2, 3, 3];
+    ///
+    /// assert_eq!(a.par_iter().find_any(|&&x| x == 3), Some(&3));
+    ///
+    /// assert_eq!(a.par_iter().find_any(|&&x| x == 100), None);
+    /// ```
+    fn find_any<P>(self, predicate: P) -> Option<Self::Item>
+    where
+        P: Fn(&Self::Item) -> bool + Sync + Send,
+    {
+        find::find(self, predicate)
+    }
+
+    /// Searches for the sequentially **first** item in the parallel iterator
+    /// that matches the given predicate and returns it.
+    ///
+    /// Once a match is found, all attempts to the right of the match
+    /// will be stopped, while attempts to the left must continue in case
+    /// an earlier match is found.
+    ///
+    /// Note that not all parallel iterators have a useful order, much like
+    /// sequential `HashMap` iteration, so "first" may be nebulous.  If you
+    /// just want the first match that discovered anywhere in the iterator,
+    /// `find_any` is a better choice.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let a = [1, 2, 3, 3];
+    ///
+    /// assert_eq!(a.par_iter().find_first(|&&x| x == 3), Some(&3));
+    ///
+    /// assert_eq!(a.par_iter().find_first(|&&x| x == 100), None);
+    /// ```
+    fn find_first<P>(self, predicate: P) -> Option<Self::Item>
+    where
+        P: Fn(&Self::Item) -> bool + Sync + Send,
+    {
+        find_first_last::find_first(self, predicate)
+    }
+
+    /// Searches for the sequentially **last** item in the parallel iterator
+    /// that matches the given predicate and returns it.
+    ///
+    /// Once a match is found, all attempts to the left of the match
+    /// will be stopped, while attempts to the right must continue in case
+    /// a later match is found.
+    ///
+    /// Note that not all parallel iterators have a useful order, much like
+    /// sequential `HashMap` iteration, so "last" may be nebulous.  When the
+    /// order doesn't actually matter to you, `find_any` is a better choice.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let a = [1, 2, 3, 3];
+    ///
+    /// assert_eq!(a.par_iter().find_last(|&&x| x == 3), Some(&3));
+    ///
+    /// assert_eq!(a.par_iter().find_last(|&&x| x == 100), None);
+    /// ```
+    fn find_last<P>(self, predicate: P) -> Option<Self::Item>
+    where
+        P: Fn(&Self::Item) -> bool + Sync + Send,
+    {
+        find_first_last::find_last(self, predicate)
+    }
+
+    /// Applies the given predicate to the items in the parallel iterator
+    /// and returns **any** non-None result of the map operation.
+    ///
+    /// Once a non-None value is produced from the map operation, we will
+    /// attempt to stop processing the rest of the items in the iterator
+    /// as soon as possible.
+    ///
+    /// Note that this method only returns **some** item in the parallel
+    /// iterator that is not None from the map predicate. The item returned
+    /// may not be the **first** non-None value produced in the parallel
+    /// sequence, since the entire sequence is mapped over in parallel.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let c = ["lol", "NaN", "5", "5"];
+    ///
+    /// let found_number = c.par_iter().find_map_any(|s| s.parse().ok());
+    ///
+    /// assert_eq!(found_number, Some(5));
+    /// ```
+    fn find_map_any<P, R>(self, predicate: P) -> Option<R>
+    where
+        P: Fn(Self::Item) -> Option<R> + Sync + Send,
+        R: Send,
+    {
+        fn yes<T>(_: &T) -> bool {
+            true
+        }
+        self.filter_map(predicate).find_any(yes)
+    }
+
+    /// Applies the given predicate to the items in the parallel iterator and
+    /// returns the sequentially **first** non-None result of the map operation.
+    ///
+    /// Once a non-None value is produced from the map operation, all attempts
+    /// to the right of the match will be stopped, while attempts to the left
+    /// must continue in case an earlier match is found.
+    ///
+    /// Note that not all parallel iterators have a useful order, much like
+    /// sequential `HashMap` iteration, so "first" may be nebulous. If you
+    /// just want the first non-None value discovered anywhere in the iterator,
+    /// `find_map_any` is a better choice.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let c = ["lol", "NaN", "2", "5"];
+    ///
+    /// let first_number = c.par_iter().find_map_first(|s| s.parse().ok());
+    ///
+    /// assert_eq!(first_number, Some(2));
+    /// ```
+    fn find_map_first<P, R>(self, predicate: P) -> Option<R>
+    where
+        P: Fn(Self::Item) -> Option<R> + Sync + Send,
+        R: Send,
+    {
+        fn yes<T>(_: &T) -> bool {
+            true
+        }
+        self.filter_map(predicate).find_first(yes)
+    }
+
+    /// Applies the given predicate to the items in the parallel iterator and
+    /// returns the sequentially **last** non-None result of the map operation.
+    ///
+    /// Once a non-None value is produced from the map operation, all attempts
+    /// to the left of the match will be stopped, while attempts to the right
+    /// must continue in case a later match is found.
+    ///
+    /// Note that not all parallel iterators have a useful order, much like
+    /// sequential `HashMap` iteration, so "first" may be nebulous. If you
+    /// just want the first non-None value discovered anywhere in the iterator,
+    /// `find_map_any` is a better choice.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let c = ["lol", "NaN", "2", "5"];
+    ///
+    /// let last_number = c.par_iter().find_map_last(|s| s.parse().ok());
+    ///
+    /// assert_eq!(last_number, Some(5));
+    /// ```
+    fn find_map_last<P, R>(self, predicate: P) -> Option<R>
+    where
+        P: Fn(Self::Item) -> Option<R> + Sync + Send,
+        R: Send,
+    {
+        fn yes<T>(_: &T) -> bool {
+            true
+        }
+        self.filter_map(predicate).find_last(yes)
+    }
+
+    #[doc(hidden)]
+    #[deprecated(note = "parallel `find` does not search in order -- use `find_any`, \\
+                         `find_first`, or `find_last`")]
+    fn find<P>(self, predicate: P) -> Option<Self::Item>
+    where
+        P: Fn(&Self::Item) -> bool + Sync + Send,
+    {
+        self.find_any(predicate)
+    }
+
+    /// Searches for **some** item in the parallel iterator that
+    /// matches the given predicate, and if so returns true.  Once
+    /// a match is found, we'll attempt to stop process the rest
+    /// of the items.  Proving that there's no match, returning false,
+    /// does require visiting every item.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let a = [0, 12, 3, 4, 0, 23, 0];
+    ///
+    /// let is_valid = a.par_iter().any(|&x| x > 10);
+    ///
+    /// assert!(is_valid);
+    /// ```
+    fn any<P>(self, predicate: P) -> bool
+    where
+        P: Fn(Self::Item) -> bool + Sync + Send,
+    {
+        self.map(predicate).find_any(bool::clone).is_some()
+    }
+
+    /// Tests that every item in the parallel iterator matches the given
+    /// predicate, and if so returns true.  If a counter-example is found,
+    /// we'll attempt to stop processing more items, then return false.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let a = [0, 12, 3, 4, 0, 23, 0];
+    ///
+    /// let is_valid = a.par_iter().all(|&x| x > 10);
+    ///
+    /// assert!(!is_valid);
+    /// ```
+    fn all<P>(self, predicate: P) -> bool
+    where
+        P: Fn(Self::Item) -> bool + Sync + Send,
+    {
+        #[inline]
+        fn is_false(x: &bool) -> bool {
+            !x
+        }
+
+        self.map(predicate).find_any(is_false).is_none()
+    }
+
+    /// Creates an iterator over the `Some` items of this iterator, halting
+    /// as soon as any `None` is found.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    /// use std::sync::atomic::{AtomicUsize, Ordering};
+    ///
+    /// let counter = AtomicUsize::new(0);
+    /// let value = (0_i32..2048)
+    ///     .into_par_iter()
+    ///     .map(|x| {
+    ///              counter.fetch_add(1, Ordering::SeqCst);
+    ///              if x < 1024 { Some(x) } else { None }
+    ///          })
+    ///     .while_some()
+    ///     .max();
+    ///
+    /// assert!(value < Some(1024));
+    /// assert!(counter.load(Ordering::SeqCst) < 2048); // should not have visited every single one
+    /// ```
+    fn while_some<T>(self) -> WhileSome<Self>
+    where
+        Self: ParallelIterator<Item = Option<T>>,
+        T: Send,
+    {
+        WhileSome::new(self)
+    }
+
+    /// Wraps an iterator with a fuse in case of panics, to halt all threads
+    /// as soon as possible.
+    ///
+    /// Panics within parallel iterators are always propagated to the caller,
+    /// but they don't always halt the rest of the iterator right away, due to
+    /// the internal semantics of [`join`]. This adaptor makes a greater effort
+    /// to stop processing other items sooner, with the cost of additional
+    /// synchronization overhead, which may also inhibit some optimizations.
+    ///
+    /// [`join`]: ../fn.join.html#panics
+    ///
+    /// # Examples
+    ///
+    /// If this code didn't use `panic_fuse()`, it would continue processing
+    /// many more items in other threads (with long sleep delays) before the
+    /// panic is finally propagated.
+    ///
+    /// ```should_panic
+    /// use rayon::prelude::*;
+    /// use std::{thread, time};
+    ///
+    /// (0..1_000_000)
+    ///     .into_par_iter()
+    ///     .panic_fuse()
+    ///     .for_each(|i| {
+    ///         // simulate some work
+    ///         thread::sleep(time::Duration::from_secs(1));
+    ///         assert!(i > 0); // oops!
+    ///     });
+    /// ```
+    fn panic_fuse(self) -> PanicFuse<Self> {
+        PanicFuse::new(self)
+    }
+
+    /// Creates a fresh collection containing all the elements produced
+    /// by this parallel iterator.
+    ///
+    /// You may prefer [`collect_into_vec()`] implemented on
+    /// [`IndexedParallelIterator`], if your underlying iterator also implements
+    /// it. [`collect_into_vec()`] allocates efficiently with precise knowledge
+    /// of how many elements the iterator contains, and even allows you to reuse
+    /// an existing vector's backing store rather than allocating a fresh vector.
+    ///
+    /// [`IndexedParallelIterator`]: trait.IndexedParallelIterator.html
+    /// [`collect_into_vec()`]:
+    ///     trait.IndexedParallelIterator.html#method.collect_into_vec
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let sync_vec: Vec<_> = (0..100).into_iter().collect();
+    ///
+    /// let async_vec: Vec<_> = (0..100).into_par_iter().collect();
+    ///
+    /// assert_eq!(sync_vec, async_vec);
+    /// ```
+    ///
+    /// You can collect a pair of collections like [`unzip`](#method.unzip)
+    /// for paired items:
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let a = [(0, 1), (1, 2), (2, 3), (3, 4)];
+    /// let (first, second): (Vec<_>, Vec<_>) = a.into_par_iter().collect();
+    ///
+    /// assert_eq!(first, [0, 1, 2, 3]);
+    /// assert_eq!(second, [1, 2, 3, 4]);
+    /// ```
+    ///
+    /// Or like [`partition_map`](#method.partition_map) for `Either` items:
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    /// use rayon::iter::Either;
+    ///
+    /// let (left, right): (Vec<_>, Vec<_>) = (0..8).into_par_iter().map(|x| {
+    ///     if x % 2 == 0 {
+    ///         Either::Left(x * 4)
+    ///     } else {
+    ///         Either::Right(x * 3)
+    ///     }
+    /// }).collect();
+    ///
+    /// assert_eq!(left, [0, 8, 16, 24]);
+    /// assert_eq!(right, [3, 9, 15, 21]);
+    /// ```
+    ///
+    /// You can even collect an arbitrarily-nested combination of pairs and `Either`:
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    /// use rayon::iter::Either;
+    ///
+    /// let (first, (left, right)): (Vec<_>, (Vec<_>, Vec<_>))
+    ///     = (0..8).into_par_iter().map(|x| {
+    ///         if x % 2 == 0 {
+    ///             (x, Either::Left(x * 4))
+    ///         } else {
+    ///             (-x, Either::Right(x * 3))
+    ///         }
+    ///     }).collect();
+    ///
+    /// assert_eq!(first, [0, -1, 2, -3, 4, -5, 6, -7]);
+    /// assert_eq!(left, [0, 8, 16, 24]);
+    /// assert_eq!(right, [3, 9, 15, 21]);
+    /// ```
+    ///
+    /// All of that can _also_ be combined with short-circuiting collection of
+    /// `Result` or `Option` types:
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    /// use rayon::iter::Either;
+    ///
+    /// let result: Result<(Vec<_>, (Vec<_>, Vec<_>)), _>
+    ///     = (0..8).into_par_iter().map(|x| {
+    ///         if x > 5 {
+    ///             Err(x)
+    ///         } else if x % 2 == 0 {
+    ///             Ok((x, Either::Left(x * 4)))
+    ///         } else {
+    ///             Ok((-x, Either::Right(x * 3)))
+    ///         }
+    ///     }).collect();
+    ///
+    /// let error = result.unwrap_err();
+    /// assert!(error == 6 || error == 7);
+    /// ```
+    fn collect<C>(self) -> C
+    where
+        C: FromParallelIterator<Self::Item>,
+    {
+        C::from_par_iter(self)
+    }
+
+    /// Unzips the items of a parallel iterator into a pair of arbitrary
+    /// `ParallelExtend` containers.
+    ///
+    /// You may prefer to use `unzip_into_vecs()`, which allocates more
+    /// efficiently with precise knowledge of how many elements the
+    /// iterator contains, and even allows you to reuse existing
+    /// vectors' backing stores rather than allocating fresh vectors.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let a = [(0, 1), (1, 2), (2, 3), (3, 4)];
+    ///
+    /// let (left, right): (Vec<_>, Vec<_>) = a.par_iter().cloned().unzip();
+    ///
+    /// assert_eq!(left, [0, 1, 2, 3]);
+    /// assert_eq!(right, [1, 2, 3, 4]);
+    /// ```
+    ///
+    /// Nested pairs can be unzipped too.
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let (values, (squares, cubes)): (Vec<_>, (Vec<_>, Vec<_>)) = (0..4).into_par_iter()
+    ///     .map(|i| (i, (i * i, i * i * i)))
+    ///     .unzip();
+    ///
+    /// assert_eq!(values, [0, 1, 2, 3]);
+    /// assert_eq!(squares, [0, 1, 4, 9]);
+    /// assert_eq!(cubes, [0, 1, 8, 27]);
+    /// ```
+    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
+    where
+        Self: ParallelIterator<Item = (A, B)>,
+        FromA: Default + Send + ParallelExtend<A>,
+        FromB: Default + Send + ParallelExtend<B>,
+        A: Send,
+        B: Send,
+    {
+        unzip::unzip(self)
+    }
+
+    /// Partitions the items of a parallel iterator into a pair of arbitrary
+    /// `ParallelExtend` containers.  Items for which the `predicate` returns
+    /// true go into the first container, and the rest go into the second.
+    ///
+    /// Note: unlike the standard `Iterator::partition`, this allows distinct
+    /// collection types for the left and right items.  This is more flexible,
+    /// but may require new type annotations when converting sequential code
+    /// that used type inference assuming the two were the same.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let (left, right): (Vec<_>, Vec<_>) = (0..8).into_par_iter().partition(|x| x % 2 == 0);
+    ///
+    /// assert_eq!(left, [0, 2, 4, 6]);
+    /// assert_eq!(right, [1, 3, 5, 7]);
+    /// ```
+    fn partition<A, B, P>(self, predicate: P) -> (A, B)
+    where
+        A: Default + Send + ParallelExtend<Self::Item>,
+        B: Default + Send + ParallelExtend<Self::Item>,
+        P: Fn(&Self::Item) -> bool + Sync + Send,
+    {
+        unzip::partition(self, predicate)
+    }
+
+    /// Partitions and maps the items of a parallel iterator into a pair of
+    /// arbitrary `ParallelExtend` containers.  `Either::Left` items go into
+    /// the first container, and `Either::Right` items go into the second.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    /// use rayon::iter::Either;
+    ///
+    /// let (left, right): (Vec<_>, Vec<_>) = (0..8).into_par_iter()
+    ///     .partition_map(|x| {
+    ///         if x % 2 == 0 {
+    ///             Either::Left(x * 4)
+    ///         } else {
+    ///             Either::Right(x * 3)
+    ///         }
+    ///     });
+    ///
+    /// assert_eq!(left, [0, 8, 16, 24]);
+    /// assert_eq!(right, [3, 9, 15, 21]);
+    /// ```
+    ///
+    /// Nested `Either` enums can be split as well.
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    /// use rayon::iter::Either::*;
+    ///
+    /// let ((fizzbuzz, fizz), (buzz, other)): ((Vec<_>, Vec<_>), (Vec<_>, Vec<_>)) = (1..20)
+    ///     .into_par_iter()
+    ///     .partition_map(|x| match (x % 3, x % 5) {
+    ///         (0, 0) => Left(Left(x)),
+    ///         (0, _) => Left(Right(x)),
+    ///         (_, 0) => Right(Left(x)),
+    ///         (_, _) => Right(Right(x)),
+    ///     });
+    ///
+    /// assert_eq!(fizzbuzz, [15]);
+    /// assert_eq!(fizz, [3, 6, 9, 12, 18]);
+    /// assert_eq!(buzz, [5, 10]);
+    /// assert_eq!(other, [1, 2, 4, 7, 8, 11, 13, 14, 16, 17, 19]);
+    /// ```
+    fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B)
+    where
+        A: Default + Send + ParallelExtend<L>,
+        B: Default + Send + ParallelExtend<R>,
+        P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
+        L: Send,
+        R: Send,
+    {
+        unzip::partition_map(self, predicate)
+    }
+
+    /// Intersperses clones of an element between items of this iterator.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let x = vec![1, 2, 3];
+    /// let r: Vec<_> = x.into_par_iter().intersperse(-1).collect();
+    ///
+    /// assert_eq!(r, vec![1, -1, 2, -1, 3]);
+    /// ```
+    fn intersperse(self, element: Self::Item) -> Intersperse<Self>
+    where
+        Self::Item: Clone,
+    {
+        Intersperse::new(self, element)
+    }
+
+    /// Creates an iterator that yields `n` elements from *anywhere* in the original iterator.
+    ///
+    /// This is similar to [`IndexedParallelIterator::take`] without being
+    /// constrained to the "first" `n` of the original iterator order. The
+    /// taken items will still maintain their relative order where that is
+    /// visible in `collect`, `reduce`, and similar outputs.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let result: Vec<_> = (0..100)
+    ///     .into_par_iter()
+    ///     .filter(|&x| x % 2 == 0)
+    ///     .take_any(5)
+    ///     .collect();
+    ///
+    /// assert_eq!(result.len(), 5);
+    /// assert!(result.windows(2).all(|w| w[0] < w[1]));
+    /// ```
+    fn take_any(self, n: usize) -> TakeAny<Self> {
+        TakeAny::new(self, n)
+    }
+
+    /// Creates an iterator that skips `n` elements from *anywhere* in the original iterator.
+    ///
+    /// This is similar to [`IndexedParallelIterator::skip`] without being
+    /// constrained to the "first" `n` of the original iterator order. The
+    /// remaining items will still maintain their relative order where that is
+    /// visible in `collect`, `reduce`, and similar outputs.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let result: Vec<_> = (0..100)
+    ///     .into_par_iter()
+    ///     .filter(|&x| x % 2 == 0)
+    ///     .skip_any(5)
+    ///     .collect();
+    ///
+    /// assert_eq!(result.len(), 45);
+    /// assert!(result.windows(2).all(|w| w[0] < w[1]));
+    /// ```
+    fn skip_any(self, n: usize) -> SkipAny<Self> {
+        SkipAny::new(self, n)
+    }
+
+    /// Creates an iterator that takes elements from *anywhere* in the original iterator
+    /// until the given `predicate` returns `false`.
+    ///
+    /// The `predicate` may be anything -- e.g. it could be checking a fact about the item, a
+    /// global condition unrelated to the item itself, or some combination thereof.
+    ///
+    /// If parallel calls to the `predicate` race and give different results, then the
+    /// `true` results will still take those particular items, while respecting the `false`
+    /// result from elsewhere to skip any further items.
+    ///
+    /// This is similar to [`Iterator::take_while`] without being constrained to the original
+    /// iterator order. The taken items will still maintain their relative order where that is
+    /// visible in `collect`, `reduce`, and similar outputs.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let result: Vec<_> = (0..100)
+    ///     .into_par_iter()
+    ///     .take_any_while(|x| *x < 50)
+    ///     .collect();
+    ///
+    /// assert!(result.len() <= 50);
+    /// assert!(result.windows(2).all(|w| w[0] < w[1]));
+    /// ```
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    /// use std::sync::atomic::AtomicUsize;
+    /// use std::sync::atomic::Ordering::Relaxed;
+    ///
+    /// // Collect any group of items that sum <= 1000
+    /// let quota = AtomicUsize::new(1000);
+    /// let result: Vec<_> = (0_usize..100)
+    ///     .into_par_iter()
+    ///     .take_any_while(|&x| {
+    ///         quota.fetch_update(Relaxed, Relaxed, |q| q.checked_sub(x))
+    ///             .is_ok()
+    ///     })
+    ///     .collect();
+    ///
+    /// let sum = result.iter().sum::<usize>();
+    /// assert!(matches!(sum, 902..=1000));
+    /// ```
+    fn take_any_while<P>(self, predicate: P) -> TakeAnyWhile<Self, P>
+    where
+        P: Fn(&Self::Item) -> bool + Sync + Send,
+    {
+        TakeAnyWhile::new(self, predicate)
+    }
+
+    /// Creates an iterator that skips elements from *anywhere* in the original iterator
+    /// until the given `predicate` returns `false`.
+    ///
+    /// The `predicate` may be anything -- e.g. it could be checking a fact about the item, a
+    /// global condition unrelated to the item itself, or some combination thereof.
+    ///
+    /// If parallel calls to the `predicate` race and give different results, then the
+    /// `true` results will still skip those particular items, while respecting the `false`
+    /// result from elsewhere to skip any further items.
+    ///
+    /// This is similar to [`Iterator::skip_while`] without being constrained to the original
+    /// iterator order. The remaining items will still maintain their relative order where that is
+    /// visible in `collect`, `reduce`, and similar outputs.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let result: Vec<_> = (0..100)
+    ///     .into_par_iter()
+    ///     .skip_any_while(|x| *x < 50)
+    ///     .collect();
+    ///
+    /// assert!(result.len() >= 50);
+    /// assert!(result.windows(2).all(|w| w[0] < w[1]));
+    /// ```
+    fn skip_any_while<P>(self, predicate: P) -> SkipAnyWhile<Self, P>
+    where
+        P: Fn(&Self::Item) -> bool + Sync + Send,
+    {
+        SkipAnyWhile::new(self, predicate)
+    }
+
+    /// Internal method used to define the behavior of this parallel
+    /// iterator. You should not need to call this directly.
+    ///
+    /// This method causes the iterator `self` to start producing
+    /// items and to feed them to the consumer `consumer` one by one.
+    /// It may split the consumer before doing so to create the
+    /// opportunity to produce in parallel.
+    ///
+    /// See the [README] for more details on the internals of parallel
+    /// iterators.
+    ///
+    /// [README]: https://github.com/rayon-rs/rayon/blob/master/src/iter/plumbing/README.md
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>;
+
+    /// Internal method used to define the behavior of this parallel
+    /// iterator. You should not need to call this directly.
+    ///
+    /// Returns the number of items produced by this iterator, if known
+    /// statically. This can be used by consumers to trigger special fast
+    /// paths. Therefore, if `Some(_)` is returned, this iterator must only
+    /// use the (indexed) `Consumer` methods when driving a consumer, such
+    /// as `split_at()`. Calling `UnindexedConsumer::split_off_left()` or
+    /// other `UnindexedConsumer` methods -- or returning an inaccurate
+    /// value -- may result in panics.
+    ///
+    /// This method is currently used to optimize `collect` for want
+    /// of true Rust specialization; it may be removed when
+    /// specialization is stable.
+    fn opt_len(&self) -> Option<usize> {
+        None
+    }
+}
+
+impl<T: ParallelIterator> IntoParallelIterator for T {
+    type Iter = T;
+    type Item = T::Item;
+
+    fn into_par_iter(self) -> T {
+        self
+    }
+}
+
+/// An iterator that supports "random access" to its data, meaning
+/// that you can split it at arbitrary indices and draw data from
+/// those points.
+///
+/// **Note:** Not implemented for `u64`, `i64`, `u128`, or `i128` ranges
+// Waiting for `ExactSizeIterator::is_empty` to be stabilized. See rust-lang/rust#35428
+#[allow(clippy::len_without_is_empty)]
+pub trait IndexedParallelIterator: ParallelIterator {
+    /// Collects the results of the iterator into the specified
+    /// vector. The vector is always cleared before execution
+    /// begins. If possible, reusing the vector across calls can lead
+    /// to better performance since it reuses the same backing buffer.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// // any prior data will be cleared
+    /// let mut vec = vec![-1, -2, -3];
+    ///
+    /// (0..5).into_par_iter()
+    ///     .collect_into_vec(&mut vec);
+    ///
+    /// assert_eq!(vec, [0, 1, 2, 3, 4]);
+    /// ```
+    fn collect_into_vec(self, target: &mut Vec<Self::Item>) {
+        collect::collect_into_vec(self, target);
+    }
+
+    /// Unzips the results of the iterator into the specified
+    /// vectors. The vectors are always cleared before execution
+    /// begins. If possible, reusing the vectors across calls can lead
+    /// to better performance since they reuse the same backing buffer.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// // any prior data will be cleared
+    /// let mut left = vec![42; 10];
+    /// let mut right = vec![-1; 10];
+    ///
+    /// (10..15).into_par_iter()
+    ///     .enumerate()
+    ///     .unzip_into_vecs(&mut left, &mut right);
+    ///
+    /// assert_eq!(left, [0, 1, 2, 3, 4]);
+    /// assert_eq!(right, [10, 11, 12, 13, 14]);
+    /// ```
+    fn unzip_into_vecs<A, B>(self, left: &mut Vec<A>, right: &mut Vec<B>)
+    where
+        Self: IndexedParallelIterator<Item = (A, B)>,
+        A: Send,
+        B: Send,
+    {
+        collect::unzip_into_vecs(self, left, right);
+    }
+
+    /// Iterates over tuples `(A, B)`, where the items `A` are from
+    /// this iterator and `B` are from the iterator given as argument.
+    /// Like the `zip` method on ordinary iterators, if the two
+    /// iterators are of unequal length, you only get the items they
+    /// have in common.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let result: Vec<_> = (1..4)
+    ///     .into_par_iter()
+    ///     .zip(vec!['a', 'b', 'c'])
+    ///     .collect();
+    ///
+    /// assert_eq!(result, [(1, 'a'), (2, 'b'), (3, 'c')]);
+    /// ```
+    fn zip<Z>(self, zip_op: Z) -> Zip<Self, Z::Iter>
+    where
+        Z: IntoParallelIterator,
+        Z::Iter: IndexedParallelIterator,
+    {
+        Zip::new(self, zip_op.into_par_iter())
+    }
+
+    /// The same as `Zip`, but requires that both iterators have the same length.
+    ///
+    /// # Panics
+    /// Will panic if `self` and `zip_op` are not the same length.
+    ///
+    /// ```should_panic
+    /// use rayon::prelude::*;
+    ///
+    /// let one = [1u8];
+    /// let two = [2u8, 2];
+    /// let one_iter = one.par_iter();
+    /// let two_iter = two.par_iter();
+    ///
+    /// // this will panic
+    /// let zipped: Vec<(&u8, &u8)> = one_iter.zip_eq(two_iter).collect();
+    ///
+    /// // we should never get here
+    /// assert_eq!(1, zipped.len());
+    /// ```
+    #[track_caller]
+    fn zip_eq<Z>(self, zip_op: Z) -> ZipEq<Self, Z::Iter>
+    where
+        Z: IntoParallelIterator,
+        Z::Iter: IndexedParallelIterator,
+    {
+        let zip_op_iter = zip_op.into_par_iter();
+        assert_eq!(
+            self.len(),
+            zip_op_iter.len(),
+            "iterators must have the same length"
+        );
+        ZipEq::new(self, zip_op_iter)
+    }
+
+    /// Interleaves elements of this iterator and the other given
+    /// iterator. Alternately yields elements from this iterator and
+    /// the given iterator, until both are exhausted. If one iterator
+    /// is exhausted before the other, the last elements are provided
+    /// from the other.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    /// let (x, y) = (vec![1, 2], vec![3, 4, 5, 6]);
+    /// let r: Vec<i32> = x.into_par_iter().interleave(y).collect();
+    /// assert_eq!(r, vec![1, 3, 2, 4, 5, 6]);
+    /// ```
+    fn interleave<I>(self, other: I) -> Interleave<Self, I::Iter>
+    where
+        I: IntoParallelIterator<Item = Self::Item>,
+        I::Iter: IndexedParallelIterator<Item = Self::Item>,
+    {
+        Interleave::new(self, other.into_par_iter())
+    }
+
+    /// Interleaves elements of this iterator and the other given
+    /// iterator, until one is exhausted.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    /// let (x, y) = (vec![1, 2, 3, 4], vec![5, 6]);
+    /// let r: Vec<i32> = x.into_par_iter().interleave_shortest(y).collect();
+    /// assert_eq!(r, vec![1, 5, 2, 6, 3]);
+    /// ```
+    fn interleave_shortest<I>(self, other: I) -> InterleaveShortest<Self, I::Iter>
+    where
+        I: IntoParallelIterator<Item = Self::Item>,
+        I::Iter: IndexedParallelIterator<Item = Self::Item>,
+    {
+        InterleaveShortest::new(self, other.into_par_iter())
+    }
+
+    /// Splits an iterator up into fixed-size chunks.
+    ///
+    /// Returns an iterator that returns `Vec`s of the given number of elements.
+    /// If the number of elements in the iterator is not divisible by `chunk_size`,
+    /// the last chunk may be shorter than `chunk_size`.
+    ///
+    /// See also [`par_chunks()`] and [`par_chunks_mut()`] for similar behavior on
+    /// slices, without having to allocate intermediate `Vec`s for the chunks.
+    ///
+    /// [`par_chunks()`]: ../slice/trait.ParallelSlice.html#method.par_chunks
+    /// [`par_chunks_mut()`]: ../slice/trait.ParallelSliceMut.html#method.par_chunks_mut
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    /// let a = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    /// let r: Vec<Vec<i32>> = a.into_par_iter().chunks(3).collect();
+    /// assert_eq!(r, vec![vec![1,2,3], vec![4,5,6], vec![7,8,9], vec![10]]);
+    /// ```
+    #[track_caller]
+    fn chunks(self, chunk_size: usize) -> Chunks<Self> {
+        assert!(chunk_size != 0, "chunk_size must not be zero");
+        Chunks::new(self, chunk_size)
+    }
+
+    /// Splits an iterator into fixed-size chunks, performing a sequential [`fold()`] on
+    /// each chunk.
+    ///
+    /// Returns an iterator that produces a folded result for each chunk of items
+    /// produced by this iterator.
+    ///
+    /// This works essentially like:
+    ///
+    /// ```text
+    /// iter.chunks(chunk_size)
+    ///     .map(|chunk|
+    ///         chunk.into_iter()
+    ///             .fold(identity, fold_op)
+    ///     )
+    /// ```
+    ///
+    /// except there is no per-chunk allocation overhead.
+    ///
+    /// [`fold()`]: std::iter::Iterator#method.fold
+    ///
+    /// **Panics** if `chunk_size` is 0.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    /// let nums = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    /// let chunk_sums = nums.into_par_iter().fold_chunks(2, || 0, |a, n| a + n).collect::<Vec<_>>();
+    /// assert_eq!(chunk_sums, vec![3, 7, 11, 15, 19]);
+    /// ```
+    #[track_caller]
+    fn fold_chunks<T, ID, F>(
+        self,
+        chunk_size: usize,
+        identity: ID,
+        fold_op: F,
+    ) -> FoldChunks<Self, ID, F>
+    where
+        ID: Fn() -> T + Send + Sync,
+        F: Fn(T, Self::Item) -> T + Send + Sync,
+        T: Send,
+    {
+        assert!(chunk_size != 0, "chunk_size must not be zero");
+        FoldChunks::new(self, chunk_size, identity, fold_op)
+    }
+
+    /// Splits an iterator into fixed-size chunks, performing a sequential [`fold()`] on
+    /// each chunk.
+    ///
+    /// Returns an iterator that produces a folded result for each chunk of items
+    /// produced by this iterator.
+    ///
+    /// This works essentially like `fold_chunks(chunk_size, || init.clone(), fold_op)`,
+    /// except it doesn't require the `init` type to be `Sync`, nor any other form of
+    /// added synchronization.
+    ///
+    /// [`fold()`]: std::iter::Iterator#method.fold
+    ///
+    /// **Panics** if `chunk_size` is 0.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    /// let nums = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    /// let chunk_sums = nums.into_par_iter().fold_chunks_with(2, 0, |a, n| a + n).collect::<Vec<_>>();
+    /// assert_eq!(chunk_sums, vec![3, 7, 11, 15, 19]);
+    /// ```
+    #[track_caller]
+    fn fold_chunks_with<T, F>(
+        self,
+        chunk_size: usize,
+        init: T,
+        fold_op: F,
+    ) -> FoldChunksWith<Self, T, F>
+    where
+        T: Send + Clone,
+        F: Fn(T, Self::Item) -> T + Send + Sync,
+    {
+        assert!(chunk_size != 0, "chunk_size must not be zero");
+        FoldChunksWith::new(self, chunk_size, init, fold_op)
+    }
+
+    /// Lexicographically compares the elements of this `ParallelIterator` with those of
+    /// another.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    /// use std::cmp::Ordering::*;
+    ///
+    /// let x = vec![1, 2, 3];
+    /// assert_eq!(x.par_iter().cmp(&vec![1, 3, 0]), Less);
+    /// assert_eq!(x.par_iter().cmp(&vec![1, 2, 3]), Equal);
+    /// assert_eq!(x.par_iter().cmp(&vec![1, 2]), Greater);
+    /// ```
+    fn cmp<I>(self, other: I) -> Ordering
+    where
+        I: IntoParallelIterator<Item = Self::Item>,
+        I::Iter: IndexedParallelIterator,
+        Self::Item: Ord,
+    {
+        #[inline]
+        fn ordering<T: Ord>((x, y): (T, T)) -> Ordering {
+            Ord::cmp(&x, &y)
+        }
+
+        #[inline]
+        fn inequal(&ord: &Ordering) -> bool {
+            ord != Ordering::Equal
+        }
+
+        let other = other.into_par_iter();
+        let ord_len = self.len().cmp(&other.len());
+        self.zip(other)
+            .map(ordering)
+            .find_first(inequal)
+            .unwrap_or(ord_len)
+    }
+
+    /// Lexicographically compares the elements of this `ParallelIterator` with those of
+    /// another.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    /// use std::cmp::Ordering::*;
+    /// use std::f64::NAN;
+    ///
+    /// let x = vec![1.0, 2.0, 3.0];
+    /// assert_eq!(x.par_iter().partial_cmp(&vec![1.0, 3.0, 0.0]), Some(Less));
+    /// assert_eq!(x.par_iter().partial_cmp(&vec![1.0, 2.0, 3.0]), Some(Equal));
+    /// assert_eq!(x.par_iter().partial_cmp(&vec![1.0, 2.0]), Some(Greater));
+    /// assert_eq!(x.par_iter().partial_cmp(&vec![1.0, NAN]), None);
+    /// ```
+    fn partial_cmp<I>(self, other: I) -> Option<Ordering>
+    where
+        I: IntoParallelIterator,
+        I::Iter: IndexedParallelIterator,
+        Self::Item: PartialOrd<I::Item>,
+    {
+        #[inline]
+        fn ordering<T: PartialOrd<U>, U>((x, y): (T, U)) -> Option<Ordering> {
+            PartialOrd::partial_cmp(&x, &y)
+        }
+
+        #[inline]
+        fn inequal(&ord: &Option<Ordering>) -> bool {
+            ord != Some(Ordering::Equal)
+        }
+
+        let other = other.into_par_iter();
+        let ord_len = self.len().cmp(&other.len());
+        self.zip(other)
+            .map(ordering)
+            .find_first(inequal)
+            .unwrap_or(Some(ord_len))
+    }
+
+    /// Determines if the elements of this `ParallelIterator`
+    /// are equal to those of another
+    fn eq<I>(self, other: I) -> bool
+    where
+        I: IntoParallelIterator,
+        I::Iter: IndexedParallelIterator,
+        Self::Item: PartialEq<I::Item>,
+    {
+        #[inline]
+        fn eq<T: PartialEq<U>, U>((x, y): (T, U)) -> bool {
+            PartialEq::eq(&x, &y)
+        }
+
+        let other = other.into_par_iter();
+        self.len() == other.len() && self.zip(other).all(eq)
+    }
+
+    /// Determines if the elements of this `ParallelIterator`
+    /// are unequal to those of another
+    fn ne<I>(self, other: I) -> bool
+    where
+        I: IntoParallelIterator,
+        I::Iter: IndexedParallelIterator,
+        Self::Item: PartialEq<I::Item>,
+    {
+        !self.eq(other)
+    }
+
+    /// Determines if the elements of this `ParallelIterator`
+    /// are lexicographically less than those of another.
+    fn lt<I>(self, other: I) -> bool
+    where
+        I: IntoParallelIterator,
+        I::Iter: IndexedParallelIterator,
+        Self::Item: PartialOrd<I::Item>,
+    {
+        self.partial_cmp(other) == Some(Ordering::Less)
+    }
+
+    /// Determines if the elements of this `ParallelIterator`
+    /// are less or equal to those of another.
+    fn le<I>(self, other: I) -> bool
+    where
+        I: IntoParallelIterator,
+        I::Iter: IndexedParallelIterator,
+        Self::Item: PartialOrd<I::Item>,
+    {
+        let ord = self.partial_cmp(other);
+        ord == Some(Ordering::Equal) || ord == Some(Ordering::Less)
+    }
+
+    /// Determines if the elements of this `ParallelIterator`
+    /// are lexicographically greater than those of another.
+    fn gt<I>(self, other: I) -> bool
+    where
+        I: IntoParallelIterator,
+        I::Iter: IndexedParallelIterator,
+        Self::Item: PartialOrd<I::Item>,
+    {
+        self.partial_cmp(other) == Some(Ordering::Greater)
+    }
+
+    /// Determines if the elements of this `ParallelIterator`
+    /// are less or equal to those of another.
+    fn ge<I>(self, other: I) -> bool
+    where
+        I: IntoParallelIterator,
+        I::Iter: IndexedParallelIterator,
+        Self::Item: PartialOrd<I::Item>,
+    {
+        let ord = self.partial_cmp(other);
+        ord == Some(Ordering::Equal) || ord == Some(Ordering::Greater)
+    }
+
+    /// Yields an index along with each item.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let chars = vec!['a', 'b', 'c'];
+    /// let result: Vec<_> = chars
+    ///     .into_par_iter()
+    ///     .enumerate()
+    ///     .collect();
+    ///
+    /// assert_eq!(result, [(0, 'a'), (1, 'b'), (2, 'c')]);
+    /// ```
+    fn enumerate(self) -> Enumerate<Self> {
+        Enumerate::new(self)
+    }
+
+    /// Creates an iterator that steps by the given amount
+    ///
+    /// # Examples
+    ///
+    /// ```
+    ///use rayon::prelude::*;
+    ///
+    /// let range = (3..10);
+    /// let result: Vec<i32> = range
+    ///    .into_par_iter()
+    ///    .step_by(3)
+    ///    .collect();
+    ///
+    /// assert_eq!(result, [3, 6, 9])
+    /// ```
+    fn step_by(self, step: usize) -> StepBy<Self> {
+        StepBy::new(self, step)
+    }
+
+    /// Creates an iterator that skips the first `n` elements.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let result: Vec<_> = (0..100)
+    ///     .into_par_iter()
+    ///     .skip(95)
+    ///     .collect();
+    ///
+    /// assert_eq!(result, [95, 96, 97, 98, 99]);
+    /// ```
+    fn skip(self, n: usize) -> Skip<Self> {
+        Skip::new(self, n)
+    }
+
+    /// Creates an iterator that yields the first `n` elements.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let result: Vec<_> = (0..100)
+    ///     .into_par_iter()
+    ///     .take(5)
+    ///     .collect();
+    ///
+    /// assert_eq!(result, [0, 1, 2, 3, 4]);
+    /// ```
+    fn take(self, n: usize) -> Take<Self> {
+        Take::new(self, n)
+    }
+
+    /// Searches for **some** item in the parallel iterator that
+    /// matches the given predicate, and returns its index.  Like
+    /// `ParallelIterator::find_any`, the parallel search will not
+    /// necessarily find the **first** match, and once a match is
+    /// found we'll attempt to stop processing any more.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let a = [1, 2, 3, 3];
+    ///
+    /// let i = a.par_iter().position_any(|&x| x == 3).expect("found");
+    /// assert!(i == 2 || i == 3);
+    ///
+    /// assert_eq!(a.par_iter().position_any(|&x| x == 100), None);
+    /// ```
+    fn position_any<P>(self, predicate: P) -> Option<usize>
+    where
+        P: Fn(Self::Item) -> bool + Sync + Send,
+    {
+        #[inline]
+        fn check(&(_, p): &(usize, bool)) -> bool {
+            p
+        }
+
+        let (i, _) = self.map(predicate).enumerate().find_any(check)?;
+        Some(i)
+    }
+
+    /// Searches for the sequentially **first** item in the parallel iterator
+    /// that matches the given predicate, and returns its index.
+    ///
+    /// Like `ParallelIterator::find_first`, once a match is found,
+    /// all attempts to the right of the match will be stopped, while
+    /// attempts to the left must continue in case an earlier match
+    /// is found.
+    ///
+    /// Note that not all parallel iterators have a useful order, much like
+    /// sequential `HashMap` iteration, so "first" may be nebulous.  If you
+    /// just want the first match that discovered anywhere in the iterator,
+    /// `position_any` is a better choice.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let a = [1, 2, 3, 3];
+    ///
+    /// assert_eq!(a.par_iter().position_first(|&x| x == 3), Some(2));
+    ///
+    /// assert_eq!(a.par_iter().position_first(|&x| x == 100), None);
+    /// ```
+    fn position_first<P>(self, predicate: P) -> Option<usize>
+    where
+        P: Fn(Self::Item) -> bool + Sync + Send,
+    {
+        #[inline]
+        fn check(&(_, p): &(usize, bool)) -> bool {
+            p
+        }
+
+        let (i, _) = self.map(predicate).enumerate().find_first(check)?;
+        Some(i)
+    }
+
+    /// Searches for the sequentially **last** item in the parallel iterator
+    /// that matches the given predicate, and returns its index.
+    ///
+    /// Like `ParallelIterator::find_last`, once a match is found,
+    /// all attempts to the left of the match will be stopped, while
+    /// attempts to the right must continue in case a later match
+    /// is found.
+    ///
+    /// Note that not all parallel iterators have a useful order, much like
+    /// sequential `HashMap` iteration, so "last" may be nebulous.  When the
+    /// order doesn't actually matter to you, `position_any` is a better
+    /// choice.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let a = [1, 2, 3, 3];
+    ///
+    /// assert_eq!(a.par_iter().position_last(|&x| x == 3), Some(3));
+    ///
+    /// assert_eq!(a.par_iter().position_last(|&x| x == 100), None);
+    /// ```
+    fn position_last<P>(self, predicate: P) -> Option<usize>
+    where
+        P: Fn(Self::Item) -> bool + Sync + Send,
+    {
+        #[inline]
+        fn check(&(_, p): &(usize, bool)) -> bool {
+            p
+        }
+
+        let (i, _) = self.map(predicate).enumerate().find_last(check)?;
+        Some(i)
+    }
+
+    #[doc(hidden)]
+    #[deprecated(
+        note = "parallel `position` does not search in order -- use `position_any`, \\
+                `position_first`, or `position_last`"
+    )]
+    fn position<P>(self, predicate: P) -> Option<usize>
+    where
+        P: Fn(Self::Item) -> bool + Sync + Send,
+    {
+        self.position_any(predicate)
+    }
+
+    /// Searches for items in the parallel iterator that match the given
+    /// predicate, and returns their indices.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let primes = vec![2, 3, 5, 7, 11, 13, 17, 19, 23, 29];
+    ///
+    /// // Find the positions of primes congruent to 1 modulo 6
+    /// let p1mod6: Vec<_> = primes.par_iter().positions(|&p| p % 6 == 1).collect();
+    /// assert_eq!(p1mod6, [3, 5, 7]); // primes 7, 13, and 19
+    ///
+    /// // Find the positions of primes congruent to 5 modulo 6
+    /// let p5mod6: Vec<_> = primes.par_iter().positions(|&p| p % 6 == 5).collect();
+    /// assert_eq!(p5mod6, [2, 4, 6, 8, 9]); // primes 5, 11, 17, 23, and 29
+    /// ```
+    fn positions<P>(self, predicate: P) -> Positions<Self, P>
+    where
+        P: Fn(Self::Item) -> bool + Sync + Send,
+    {
+        Positions::new(self, predicate)
+    }
+
+    /// Produces a new iterator with the elements of this iterator in
+    /// reverse order.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let result: Vec<_> = (0..5)
+    ///     .into_par_iter()
+    ///     .rev()
+    ///     .collect();
+    ///
+    /// assert_eq!(result, [4, 3, 2, 1, 0]);
+    /// ```
+    fn rev(self) -> Rev<Self> {
+        Rev::new(self)
+    }
+
+    /// Sets the minimum length of iterators desired to process in each
+    /// rayon job.  Rayon will not split any smaller than this length, but
+    /// of course an iterator could already be smaller to begin with.
+    ///
+    /// Producers like `zip` and `interleave` will use greater of the two
+    /// minimums.
+    /// Chained iterators and iterators inside `flat_map` may each use
+    /// their own minimum length.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let min = (0..1_000_000)
+    ///     .into_par_iter()
+    ///     .with_min_len(1234)
+    ///     .fold(|| 0, |acc, _| acc + 1) // count how many are in this segment
+    ///     .min().unwrap();
+    ///
+    /// assert!(min >= 1234);
+    /// ```
+    fn with_min_len(self, min: usize) -> MinLen<Self> {
+        MinLen::new(self, min)
+    }
+
+    /// Sets the maximum length of iterators desired to process in each
+    /// rayon job.  Rayon will try to split at least below this length,
+    /// unless that would put it below the length from `with_min_len()`.
+    /// For example, given min=10 and max=15, a length of 16 will not be
+    /// split any further.
+    ///
+    /// Producers like `zip` and `interleave` will use lesser of the two
+    /// maximums.
+    /// Chained iterators and iterators inside `flat_map` may each use
+    /// their own maximum length.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let max = (0..1_000_000)
+    ///     .into_par_iter()
+    ///     .with_max_len(1234)
+    ///     .fold(|| 0, |acc, _| acc + 1) // count how many are in this segment
+    ///     .max().unwrap();
+    ///
+    /// assert!(max <= 1234);
+    /// ```
+    fn with_max_len(self, max: usize) -> MaxLen<Self> {
+        MaxLen::new(self, max)
+    }
+
+    /// Produces an exact count of how many items this iterator will
+    /// produce, presuming no panic occurs.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let par_iter = (0..100).into_par_iter().zip(vec![0; 10]);
+    /// assert_eq!(par_iter.len(), 10);
+    ///
+    /// let vec: Vec<_> = par_iter.collect();
+    /// assert_eq!(vec.len(), 10);
+    /// ```
+    fn len(&self) -> usize;
+
+    /// Internal method used to define the behavior of this parallel
+    /// iterator. You should not need to call this directly.
+    ///
+    /// This method causes the iterator `self` to start producing
+    /// items and to feed them to the consumer `consumer` one by one.
+    /// It may split the consumer before doing so to create the
+    /// opportunity to produce in parallel. If a split does happen, it
+    /// will inform the consumer of the index where the split should
+    /// occur (unlike `ParallelIterator::drive_unindexed()`).
+    ///
+    /// See the [README] for more details on the internals of parallel
+    /// iterators.
+    ///
+    /// [README]: https://github.com/rayon-rs/rayon/blob/master/src/iter/plumbing/README.md
+    fn drive<C: Consumer<Self::Item>>(self, consumer: C) -> C::Result;
+
+    /// Internal method used to define the behavior of this parallel
+    /// iterator. You should not need to call this directly.
+    ///
+    /// This method converts the iterator into a producer P and then
+    /// invokes `callback.callback()` with P. Note that the type of
+    /// this producer is not defined as part of the API, since
+    /// `callback` must be defined generically for all producers. This
+    /// allows the producer type to contain references; it also means
+    /// that parallel iterators can adjust that type without causing a
+    /// breaking change.
+    ///
+    /// See the [README] for more details on the internals of parallel
+    /// iterators.
+    ///
+    /// [README]: https://github.com/rayon-rs/rayon/blob/master/src/iter/plumbing/README.md
+    fn with_producer<CB: ProducerCallback<Self::Item>>(self, callback: CB) -> CB::Output;
+}
+
+/// `FromParallelIterator` implements the creation of a collection
+/// from a [`ParallelIterator`]. By implementing
+/// `FromParallelIterator` for a given type, you define how it will be
+/// created from an iterator.
+///
+/// `FromParallelIterator` is used through [`ParallelIterator`]'s [`collect()`] method.
+///
+/// [`ParallelIterator`]: trait.ParallelIterator.html
+/// [`collect()`]: trait.ParallelIterator.html#method.collect
+///
+/// # Examples
+///
+/// Implementing `FromParallelIterator` for your type:
+///
+/// ```
+/// use rayon::prelude::*;
+/// use std::mem;
+///
+/// struct BlackHole {
+///     mass: usize,
+/// }
+///
+/// impl<T: Send> FromParallelIterator<T> for BlackHole {
+///     fn from_par_iter<I>(par_iter: I) -> Self
+///         where I: IntoParallelIterator<Item = T>
+///     {
+///         let par_iter = par_iter.into_par_iter();
+///         BlackHole {
+///             mass: par_iter.count() * mem::size_of::<T>(),
+///         }
+///     }
+/// }
+///
+/// let bh: BlackHole = (0i32..1000).into_par_iter().collect();
+/// assert_eq!(bh.mass, 4000);
+/// ```
+pub trait FromParallelIterator<T>
+where
+    T: Send,
+{
+    /// Creates an instance of the collection from the parallel iterator `par_iter`.
+    ///
+    /// If your collection is not naturally parallel, the easiest (and
+    /// fastest) way to do this is often to collect `par_iter` into a
+    /// [`LinkedList`] or other intermediate data structure and then
+    /// sequentially extend your collection. However, a more 'native'
+    /// technique is to use the [`par_iter.fold`] or
+    /// [`par_iter.fold_with`] methods to create the collection.
+    /// Alternatively, if your collection is 'natively' parallel, you
+    /// can use `par_iter.for_each` to process each element in turn.
+    ///
+    /// [`LinkedList`]: https://doc.rust-lang.org/std/collections/struct.LinkedList.html
+    /// [`par_iter.fold`]: trait.ParallelIterator.html#method.fold
+    /// [`par_iter.fold_with`]: trait.ParallelIterator.html#method.fold_with
+    /// [`par_iter.for_each`]: trait.ParallelIterator.html#method.for_each
+    fn from_par_iter<I>(par_iter: I) -> Self
+    where
+        I: IntoParallelIterator<Item = T>;
+}
+
+/// `ParallelExtend` extends an existing collection with items from a [`ParallelIterator`].
+///
+/// [`ParallelIterator`]: trait.ParallelIterator.html
+///
+/// # Examples
+///
+/// Implementing `ParallelExtend` for your type:
+///
+/// ```
+/// use rayon::prelude::*;
+/// use std::mem;
+///
+/// struct BlackHole {
+///     mass: usize,
+/// }
+///
+/// impl<T: Send> ParallelExtend<T> for BlackHole {
+///     fn par_extend<I>(&mut self, par_iter: I)
+///         where I: IntoParallelIterator<Item = T>
+///     {
+///         let par_iter = par_iter.into_par_iter();
+///         self.mass += par_iter.count() * mem::size_of::<T>();
+///     }
+/// }
+///
+/// let mut bh = BlackHole { mass: 0 };
+/// bh.par_extend(0i32..1000);
+/// assert_eq!(bh.mass, 4000);
+/// bh.par_extend(0i64..10);
+/// assert_eq!(bh.mass, 4080);
+/// ```
+pub trait ParallelExtend<T>
+where
+    T: Send,
+{
+    /// Extends an instance of the collection with the elements drawn
+    /// from the parallel iterator `par_iter`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let mut vec = vec![];
+    /// vec.par_extend(0..5);
+    /// vec.par_extend((0..5).into_par_iter().map(|i| i * i));
+    /// assert_eq!(vec, [0, 1, 2, 3, 4, 0, 1, 4, 9, 16]);
+    /// ```
+    fn par_extend<I>(&mut self, par_iter: I)
+    where
+        I: IntoParallelIterator<Item = T>;
+}
+
+/// `ParallelDrainFull` creates a parallel iterator that moves all items
+/// from a collection while retaining the original capacity.
+///
+/// Types which are indexable typically implement [`ParallelDrainRange`]
+/// instead, where you can drain fully with `par_drain(..)`.
+///
+/// [`ParallelDrainRange`]: trait.ParallelDrainRange.html
+pub trait ParallelDrainFull {
+    /// The draining parallel iterator type that will be created.
+    type Iter: ParallelIterator<Item = Self::Item>;
+
+    /// The type of item that the parallel iterator will produce.
+    /// This is usually the same as `IntoParallelIterator::Item`.
+    type Item: Send;
+
+    /// Returns a draining parallel iterator over an entire collection.
+    ///
+    /// When the iterator is dropped, all items are removed, even if the
+    /// iterator was not fully consumed. If the iterator is leaked, for example
+    /// using `std::mem::forget`, it is unspecified how many items are removed.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    /// use std::collections::{BinaryHeap, HashSet};
+    ///
+    /// let squares: HashSet<i32> = (0..10).map(|x| x * x).collect();
+    ///
+    /// let mut heap: BinaryHeap<_> = squares.iter().copied().collect();
+    /// assert_eq!(
+    ///     // heaps are drained in arbitrary order
+    ///     heap.par_drain()
+    ///         .inspect(|x| assert!(squares.contains(x)))
+    ///         .count(),
+    ///     squares.len(),
+    /// );
+    /// assert!(heap.is_empty());
+    /// assert!(heap.capacity() >= squares.len());
+    /// ```
+    fn par_drain(self) -> Self::Iter;
+}
+
+/// `ParallelDrainRange` creates a parallel iterator that moves a range of items
+/// from a collection while retaining the original capacity.
+///
+/// Types which are not indexable may implement [`ParallelDrainFull`] instead.
+///
+/// [`ParallelDrainFull`]: trait.ParallelDrainFull.html
+pub trait ParallelDrainRange<Idx = usize> {
+    /// The draining parallel iterator type that will be created.
+    type Iter: ParallelIterator<Item = Self::Item>;
+
+    /// The type of item that the parallel iterator will produce.
+    /// This is usually the same as `IntoParallelIterator::Item`.
+    type Item: Send;
+
+    /// Returns a draining parallel iterator over a range of the collection.
+    ///
+    /// When the iterator is dropped, all items in the range are removed, even
+    /// if the iterator was not fully consumed. If the iterator is leaked, for
+    /// example using `std::mem::forget`, it is unspecified how many items are
+    /// removed.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let squares: Vec<i32> = (0..10).map(|x| x * x).collect();
+    ///
+    /// println!("RangeFull");
+    /// let mut vec = squares.clone();
+    /// assert!(vec.par_drain(..)
+    ///            .eq(squares.par_iter().copied()));
+    /// assert!(vec.is_empty());
+    /// assert!(vec.capacity() >= squares.len());
+    ///
+    /// println!("RangeFrom");
+    /// let mut vec = squares.clone();
+    /// assert!(vec.par_drain(5..)
+    ///            .eq(squares[5..].par_iter().copied()));
+    /// assert_eq!(&vec[..], &squares[..5]);
+    /// assert!(vec.capacity() >= squares.len());
+    ///
+    /// println!("RangeTo");
+    /// let mut vec = squares.clone();
+    /// assert!(vec.par_drain(..5)
+    ///            .eq(squares[..5].par_iter().copied()));
+    /// assert_eq!(&vec[..], &squares[5..]);
+    /// assert!(vec.capacity() >= squares.len());
+    ///
+    /// println!("RangeToInclusive");
+    /// let mut vec = squares.clone();
+    /// assert!(vec.par_drain(..=5)
+    ///            .eq(squares[..=5].par_iter().copied()));
+    /// assert_eq!(&vec[..], &squares[6..]);
+    /// assert!(vec.capacity() >= squares.len());
+    ///
+    /// println!("Range");
+    /// let mut vec = squares.clone();
+    /// assert!(vec.par_drain(3..7)
+    ///            .eq(squares[3..7].par_iter().copied()));
+    /// assert_eq!(&vec[..3], &squares[..3]);
+    /// assert_eq!(&vec[3..], &squares[7..]);
+    /// assert!(vec.capacity() >= squares.len());
+    ///
+    /// println!("RangeInclusive");
+    /// let mut vec = squares.clone();
+    /// assert!(vec.par_drain(3..=7)
+    ///            .eq(squares[3..=7].par_iter().copied()));
+    /// assert_eq!(&vec[..3], &squares[..3]);
+    /// assert_eq!(&vec[3..], &squares[8..]);
+    /// assert!(vec.capacity() >= squares.len());
+    /// ```
+    fn par_drain<R: RangeBounds<Idx>>(self, range: R) -> Self::Iter;
+}
+
+/// We hide the `Try` trait in a private module, as it's only meant to be a
+/// stable clone of the standard library's `Try` trait, as yet unstable.
+mod private {
+    use std::convert::Infallible;
+    use std::ops::ControlFlow::{self, Break, Continue};
+    use std::task::Poll;
+
+    /// Clone of `std::ops::Try`.
+    ///
+    /// Implementing this trait is not permitted outside of `rayon`.
+    pub trait Try {
+        private_decl! {}
+
+        type Output;
+        type Residual;
+
+        fn from_output(output: Self::Output) -> Self;
+
+        fn from_residual(residual: Self::Residual) -> Self;
+
+        fn branch(self) -> ControlFlow<Self::Residual, Self::Output>;
+    }
+
+    impl<B, C> Try for ControlFlow<B, C> {
+        private_impl! {}
+
+        type Output = C;
+        type Residual = ControlFlow<B, Infallible>;
+
+        fn from_output(output: Self::Output) -> Self {
+            Continue(output)
+        }
+
+        fn from_residual(residual: Self::Residual) -> Self {
+            match residual {
+                Break(b) => Break(b),
+                Continue(_) => unreachable!(),
+            }
+        }
+
+        fn branch(self) -> ControlFlow<Self::Residual, Self::Output> {
+            match self {
+                Continue(c) => Continue(c),
+                Break(b) => Break(Break(b)),
+            }
+        }
+    }
+
+    impl<T> Try for Option<T> {
+        private_impl! {}
+
+        type Output = T;
+        type Residual = Option<Infallible>;
+
+        fn from_output(output: Self::Output) -> Self {
+            Some(output)
+        }
+
+        fn from_residual(residual: Self::Residual) -> Self {
+            match residual {
+                None => None,
+                Some(_) => unreachable!(),
+            }
+        }
+
+        fn branch(self) -> ControlFlow<Self::Residual, Self::Output> {
+            match self {
+                Some(c) => Continue(c),
+                None => Break(None),
+            }
+        }
+    }
+
+    impl<T, E> Try for Result<T, E> {
+        private_impl! {}
+
+        type Output = T;
+        type Residual = Result<Infallible, E>;
+
+        fn from_output(output: Self::Output) -> Self {
+            Ok(output)
+        }
+
+        fn from_residual(residual: Self::Residual) -> Self {
+            match residual {
+                Err(e) => Err(e),
+                Ok(_) => unreachable!(),
+            }
+        }
+
+        fn branch(self) -> ControlFlow<Self::Residual, Self::Output> {
+            match self {
+                Ok(c) => Continue(c),
+                Err(e) => Break(Err(e)),
+            }
+        }
+    }
+
+    impl<T, E> Try for Poll<Result<T, E>> {
+        private_impl! {}
+
+        type Output = Poll<T>;
+        type Residual = Result<Infallible, E>;
+
+        fn from_output(output: Self::Output) -> Self {
+            output.map(Ok)
+        }
+
+        fn from_residual(residual: Self::Residual) -> Self {
+            match residual {
+                Err(e) => Poll::Ready(Err(e)),
+                Ok(_) => unreachable!(),
+            }
+        }
+
+        fn branch(self) -> ControlFlow<Self::Residual, Self::Output> {
+            match self {
+                Poll::Pending => Continue(Poll::Pending),
+                Poll::Ready(Ok(c)) => Continue(Poll::Ready(c)),
+                Poll::Ready(Err(e)) => Break(Err(e)),
+            }
+        }
+    }
+
+    impl<T, E> Try for Poll<Option<Result<T, E>>> {
+        private_impl! {}
+
+        type Output = Poll<Option<T>>;
+        type Residual = Result<Infallible, E>;
+
+        fn from_output(output: Self::Output) -> Self {
+            match output {
+                Poll::Ready(o) => Poll::Ready(o.map(Ok)),
+                Poll::Pending => Poll::Pending,
+            }
+        }
+
+        fn from_residual(residual: Self::Residual) -> Self {
+            match residual {
+                Err(e) => Poll::Ready(Some(Err(e))),
+                Ok(_) => unreachable!(),
+            }
+        }
+
+        fn branch(self) -> ControlFlow<Self::Residual, Self::Output> {
+            match self {
+                Poll::Pending => Continue(Poll::Pending),
+                Poll::Ready(None) => Continue(Poll::Ready(None)),
+                Poll::Ready(Some(Ok(c))) => Continue(Poll::Ready(Some(c))),
+                Poll::Ready(Some(Err(e))) => Break(Err(e)),
+            }
+        }
+    }
+}
diff --git a/crates/rayon/src/iter/multizip.rs b/crates/rayon/src/iter/multizip.rs
new file mode 100644
index 0000000..8e36d08
--- /dev/null
+++ b/crates/rayon/src/iter/multizip.rs
@@ -0,0 +1,338 @@
+use super::plumbing::*;
+use super::*;
+
+/// `MultiZip` is an iterator that zips up a tuple of parallel iterators to
+/// produce tuples of their items.
+///
+/// It is created by calling `into_par_iter()` on a tuple of types that
+/// implement `IntoParallelIterator`, or `par_iter()`/`par_iter_mut()` with
+/// types that are iterable by reference.
+///
+/// The implementation currently support tuples up to length 12.
+///
+/// # Examples
+///
+/// ```
+/// use rayon::prelude::*;
+///
+/// // This will iterate `r` by mutable reference, like `par_iter_mut()`, while
+/// // ranges are all iterated by value like `into_par_iter()`.
+/// // Note that the zipped iterator is only as long as the shortest input.
+/// let mut r = vec![0; 3];
+/// (&mut r, 1..10, 10..100, 100..1000).into_par_iter()
+///     .for_each(|(r, x, y, z)| *r = x * y + z);
+///
+/// assert_eq!(&r, &[1 * 10 + 100, 2 * 11 + 101, 3 * 12 + 102]);
+/// ```
+///
+/// For a group that should all be iterated by reference, you can use a tuple reference.
+///
+/// ```
+/// use rayon::prelude::*;
+///
+/// let xs: Vec<_> = (1..10).collect();
+/// let ys: Vec<_> = (10..100).collect();
+/// let zs: Vec<_> = (100..1000).collect();
+///
+/// // Reference each input separately with `IntoParallelIterator`:
+/// let r1: Vec<_> = (&xs, &ys, &zs).into_par_iter()
+///     .map(|(x, y, z)| x * y + z)
+///     .collect();
+///
+/// // Reference them all together with `IntoParallelRefIterator`:
+/// let r2: Vec<_> = (xs, ys, zs).par_iter()
+///     .map(|(x, y, z)| x * y + z)
+///     .collect();
+///
+/// assert_eq!(r1, r2);
+/// ```
+///
+/// Mutable references to a tuple will work similarly.
+///
+/// ```
+/// use rayon::prelude::*;
+///
+/// let mut xs: Vec<_> = (1..4).collect();
+/// let mut ys: Vec<_> = (-4..-1).collect();
+/// let mut zs = vec![0; 3];
+///
+/// // Mutably reference each input separately with `IntoParallelIterator`:
+/// (&mut xs, &mut ys, &mut zs).into_par_iter().for_each(|(x, y, z)| {
+///     *z += *x + *y;
+///     std::mem::swap(x, y);
+/// });
+///
+/// assert_eq!(xs, (vec![-4, -3, -2]));
+/// assert_eq!(ys, (vec![1, 2, 3]));
+/// assert_eq!(zs, (vec![-3, -1, 1]));
+///
+/// // Mutably reference them all together with `IntoParallelRefMutIterator`:
+/// let mut tuple = (xs, ys, zs);
+/// tuple.par_iter_mut().for_each(|(x, y, z)| {
+///     *z += *x + *y;
+///     std::mem::swap(x, y);
+/// });
+///
+/// assert_eq!(tuple, (vec![1, 2, 3], vec![-4, -3, -2], vec![-6, -2, 2]));
+/// ```
+#[derive(Debug, Clone)]
+pub struct MultiZip<T> {
+    tuple: T,
+}
+
+// These macros greedily consume 4 or 2 items first to achieve log2 nesting depth.
+// For example, 5 => 4,1 => (2,2),1.
+//
+// The tuples go up to 12, so we might want to greedily consume 8 too, but
+// the depth works out the same if we let that expand on the right:
+//      9 => 4,5 => (2,2),(4,1) => (2,2),((2,2),1)
+//     12 => 4,8 => (2,2),(4,4) => (2,2),((2,2),(2,2))
+//
+// But if we ever increase to 13, we would want to split 8,5 rather than 4,9.
+
+macro_rules! reduce {
+    ($a:expr, $b:expr, $c:expr, $d:expr, $( $x:expr ),+ => $fn:path) => {
+        reduce!(reduce!($a, $b, $c, $d => $fn),
+                reduce!($( $x ),+ => $fn)
+                => $fn)
+    };
+    ($a:expr, $b:expr, $( $x:expr ),+ => $fn:path) => {
+        reduce!(reduce!($a, $b => $fn),
+                reduce!($( $x ),+ => $fn)
+                => $fn)
+    };
+    ($a:expr, $b:expr => $fn:path) => { $fn($a, $b) };
+    ($a:expr => $fn:path) => { $a };
+}
+
+macro_rules! nest {
+    ($A:tt, $B:tt, $C:tt, $D:tt, $( $X:tt ),+) => {
+        (nest!($A, $B, $C, $D), nest!($( $X ),+))
+    };
+    ($A:tt, $B:tt, $( $X:tt ),+) => {
+        (($A, $B), nest!($( $X ),+))
+    };
+    ($A:tt, $B:tt) => { ($A, $B) };
+    ($A:tt) => { $A };
+}
+
+macro_rules! flatten {
+    ($( $T:ident ),+) => {{
+        #[allow(non_snake_case)]
+        fn flatten<$( $T ),+>(nest!($( $T ),+) : nest!($( $T ),+)) -> ($( $T, )+) {
+            ($( $T, )+)
+        }
+        flatten
+    }};
+}
+
+macro_rules! multizip_impls {
+    ($(
+        $Tuple:ident {
+            $(($idx:tt) -> $T:ident)+
+        }
+    )+) => {
+        $(
+            impl<$( $T, )+> IntoParallelIterator for ($( $T, )+)
+            where
+                $(
+                    $T: IntoParallelIterator,
+                    $T::Iter: IndexedParallelIterator,
+                )+
+            {
+                type Item = ($( $T::Item, )+);
+                type Iter = MultiZip<($( $T::Iter, )+)>;
+
+                fn into_par_iter(self) -> Self::Iter {
+                    MultiZip {
+                        tuple: ( $( self.$idx.into_par_iter(), )+ ),
+                    }
+                }
+            }
+
+            impl<'a, $( $T, )+> IntoParallelIterator for &'a ($( $T, )+)
+            where
+                $(
+                    $T: IntoParallelRefIterator<'a>,
+                    $T::Iter: IndexedParallelIterator,
+                )+
+            {
+                type Item = ($( $T::Item, )+);
+                type Iter = MultiZip<($( $T::Iter, )+)>;
+
+                fn into_par_iter(self) -> Self::Iter {
+                    MultiZip {
+                        tuple: ( $( self.$idx.par_iter(), )+ ),
+                    }
+                }
+            }
+
+            impl<'a, $( $T, )+> IntoParallelIterator for &'a mut ($( $T, )+)
+            where
+                $(
+                    $T: IntoParallelRefMutIterator<'a>,
+                    $T::Iter: IndexedParallelIterator,
+                )+
+            {
+                type Item = ($( $T::Item, )+);
+                type Iter = MultiZip<($( $T::Iter, )+)>;
+
+                fn into_par_iter(self) -> Self::Iter {
+                    MultiZip {
+                        tuple: ( $( self.$idx.par_iter_mut(), )+ ),
+                    }
+                }
+            }
+
+            impl<$( $T, )+> ParallelIterator for MultiZip<($( $T, )+)>
+            where
+                $( $T: IndexedParallelIterator, )+
+            {
+                type Item = ($( $T::Item, )+);
+
+                fn drive_unindexed<CONSUMER>(self, consumer: CONSUMER) -> CONSUMER::Result
+                where
+                    CONSUMER: UnindexedConsumer<Self::Item>,
+                {
+                    self.drive(consumer)
+                }
+
+                fn opt_len(&self) -> Option<usize> {
+                    Some(self.len())
+                }
+            }
+
+            impl<$( $T, )+> IndexedParallelIterator for MultiZip<($( $T, )+)>
+            where
+                $( $T: IndexedParallelIterator, )+
+            {
+                fn drive<CONSUMER>(self, consumer: CONSUMER) -> CONSUMER::Result
+                where
+                    CONSUMER: Consumer<Self::Item>,
+                {
+                    reduce!($( self.tuple.$idx ),+ => IndexedParallelIterator::zip)
+                        .map(flatten!($( $T ),+))
+                        .drive(consumer)
+                }
+
+                fn len(&self) -> usize {
+                    reduce!($( self.tuple.$idx.len() ),+ => Ord::min)
+                }
+
+                fn with_producer<CB>(self, callback: CB) -> CB::Output
+                where
+                    CB: ProducerCallback<Self::Item>,
+                {
+                    reduce!($( self.tuple.$idx ),+ => IndexedParallelIterator::zip)
+                        .map(flatten!($( $T ),+))
+                        .with_producer(callback)
+                }
+            }
+        )+
+    }
+}
+
+multizip_impls! {
+    Tuple1 {
+        (0) -> A
+    }
+    Tuple2 {
+        (0) -> A
+        (1) -> B
+    }
+    Tuple3 {
+        (0) -> A
+        (1) -> B
+        (2) -> C
+    }
+    Tuple4 {
+        (0) -> A
+        (1) -> B
+        (2) -> C
+        (3) -> D
+    }
+    Tuple5 {
+        (0) -> A
+        (1) -> B
+        (2) -> C
+        (3) -> D
+        (4) -> E
+    }
+    Tuple6 {
+        (0) -> A
+        (1) -> B
+        (2) -> C
+        (3) -> D
+        (4) -> E
+        (5) -> F
+    }
+    Tuple7 {
+        (0) -> A
+        (1) -> B
+        (2) -> C
+        (3) -> D
+        (4) -> E
+        (5) -> F
+        (6) -> G
+    }
+    Tuple8 {
+        (0) -> A
+        (1) -> B
+        (2) -> C
+        (3) -> D
+        (4) -> E
+        (5) -> F
+        (6) -> G
+        (7) -> H
+    }
+    Tuple9 {
+        (0) -> A
+        (1) -> B
+        (2) -> C
+        (3) -> D
+        (4) -> E
+        (5) -> F
+        (6) -> G
+        (7) -> H
+        (8) -> I
+    }
+    Tuple10 {
+        (0) -> A
+        (1) -> B
+        (2) -> C
+        (3) -> D
+        (4) -> E
+        (5) -> F
+        (6) -> G
+        (7) -> H
+        (8) -> I
+        (9) -> J
+    }
+    Tuple11 {
+        (0) -> A
+        (1) -> B
+        (2) -> C
+        (3) -> D
+        (4) -> E
+        (5) -> F
+        (6) -> G
+        (7) -> H
+        (8) -> I
+        (9) -> J
+        (10) -> K
+    }
+    Tuple12 {
+        (0) -> A
+        (1) -> B
+        (2) -> C
+        (3) -> D
+        (4) -> E
+        (5) -> F
+        (6) -> G
+        (7) -> H
+        (8) -> I
+        (9) -> J
+        (10) -> K
+        (11) -> L
+    }
+}
diff --git a/crates/rayon/src/iter/noop.rs b/crates/rayon/src/iter/noop.rs
new file mode 100644
index 0000000..1e55ecb
--- /dev/null
+++ b/crates/rayon/src/iter/noop.rs
@@ -0,0 +1,59 @@
+use super::plumbing::*;
+
+pub(super) struct NoopConsumer;
+
+impl<T> Consumer<T> for NoopConsumer {
+    type Folder = NoopConsumer;
+    type Reducer = NoopReducer;
+    type Result = ();
+
+    fn split_at(self, _index: usize) -> (Self, Self, NoopReducer) {
+        (NoopConsumer, NoopConsumer, NoopReducer)
+    }
+
+    fn into_folder(self) -> Self {
+        self
+    }
+
+    fn full(&self) -> bool {
+        false
+    }
+}
+
+impl<T> Folder<T> for NoopConsumer {
+    type Result = ();
+
+    fn consume(self, _item: T) -> Self {
+        self
+    }
+
+    fn consume_iter<I>(self, iter: I) -> Self
+    where
+        I: IntoIterator<Item = T>,
+    {
+        iter.into_iter().for_each(drop);
+        self
+    }
+
+    fn complete(self) {}
+
+    fn full(&self) -> bool {
+        false
+    }
+}
+
+impl<T> UnindexedConsumer<T> for NoopConsumer {
+    fn split_off_left(&self) -> Self {
+        NoopConsumer
+    }
+
+    fn to_reducer(&self) -> NoopReducer {
+        NoopReducer
+    }
+}
+
+pub(super) struct NoopReducer;
+
+impl Reducer<()> for NoopReducer {
+    fn reduce(self, _left: (), _right: ()) {}
+}
diff --git a/crates/rayon/src/iter/once.rs b/crates/rayon/src/iter/once.rs
new file mode 100644
index 0000000..5140b6b
--- /dev/null
+++ b/crates/rayon/src/iter/once.rs
@@ -0,0 +1,68 @@
+use crate::iter::plumbing::*;
+use crate::iter::*;
+
+/// Creates a parallel iterator that produces an element exactly once.
+///
+/// This admits no parallelism on its own, but it could be chained to existing
+/// parallel iterators to extend their contents, or otherwise used for any code
+/// that deals with generic parallel iterators.
+///
+/// # Examples
+///
+/// ```
+/// use rayon::prelude::*;
+/// use rayon::iter::once;
+///
+/// let pi = (0..1234).into_par_iter()
+///     .chain(once(-1))
+///     .chain(1234..10_000);
+///
+/// assert_eq!(pi.clone().count(), 10_001);
+/// assert_eq!(pi.clone().filter(|&x| x < 0).count(), 1);
+/// assert_eq!(pi.position_any(|x| x < 0), Some(1234));
+/// ```
+pub fn once<T: Send>(item: T) -> Once<T> {
+    Once { item }
+}
+
+/// Iterator adaptor for [the `once()` function](fn.once.html).
+#[derive(Clone, Debug)]
+pub struct Once<T: Send> {
+    item: T,
+}
+
+impl<T: Send> ParallelIterator for Once<T> {
+    type Item = T;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        self.drive(consumer)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        Some(1)
+    }
+}
+
+impl<T: Send> IndexedParallelIterator for Once<T> {
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        consumer.into_folder().consume(self.item).complete()
+    }
+
+    fn len(&self) -> usize {
+        1
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        // Let `OptionProducer` handle it.
+        Some(self.item).into_par_iter().with_producer(callback)
+    }
+}
diff --git a/crates/rayon/src/iter/panic_fuse.rs b/crates/rayon/src/iter/panic_fuse.rs
new file mode 100644
index 0000000..7487230
--- /dev/null
+++ b/crates/rayon/src/iter/panic_fuse.rs
@@ -0,0 +1,342 @@
+use super::plumbing::*;
+use super::*;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::thread;
+
+/// `PanicFuse` is an adaptor that wraps an iterator with a fuse in case
+/// of panics, to halt all threads as soon as possible.
+///
+/// This struct is created by the [`panic_fuse()`] method on [`ParallelIterator`]
+///
+/// [`panic_fuse()`]: trait.ParallelIterator.html#method.panic_fuse
+/// [`ParallelIterator`]: trait.ParallelIterator.html
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Debug, Clone)]
+pub struct PanicFuse<I: ParallelIterator> {
+    base: I,
+}
+
+/// Helper that sets a bool to `true` if dropped while unwinding.
+#[derive(Clone)]
+struct Fuse<'a>(&'a AtomicBool);
+
+impl<'a> Drop for Fuse<'a> {
+    #[inline]
+    fn drop(&mut self) {
+        if thread::panicking() {
+            self.0.store(true, Ordering::Relaxed);
+        }
+    }
+}
+
+impl<'a> Fuse<'a> {
+    #[inline]
+    fn panicked(&self) -> bool {
+        self.0.load(Ordering::Relaxed)
+    }
+}
+
+impl<I> PanicFuse<I>
+where
+    I: ParallelIterator,
+{
+    /// Creates a new `PanicFuse` iterator.
+    pub(super) fn new(base: I) -> PanicFuse<I> {
+        PanicFuse { base }
+    }
+}
+
+impl<I> ParallelIterator for PanicFuse<I>
+where
+    I: ParallelIterator,
+{
+    type Item = I::Item;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        let panicked = AtomicBool::new(false);
+        let consumer1 = PanicFuseConsumer {
+            base: consumer,
+            fuse: Fuse(&panicked),
+        };
+        self.base.drive_unindexed(consumer1)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        self.base.opt_len()
+    }
+}
+
+impl<I> IndexedParallelIterator for PanicFuse<I>
+where
+    I: IndexedParallelIterator,
+{
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        let panicked = AtomicBool::new(false);
+        let consumer1 = PanicFuseConsumer {
+            base: consumer,
+            fuse: Fuse(&panicked),
+        };
+        self.base.drive(consumer1)
+    }
+
+    fn len(&self) -> usize {
+        self.base.len()
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        return self.base.with_producer(Callback { callback });
+
+        struct Callback<CB> {
+            callback: CB,
+        }
+
+        impl<T, CB> ProducerCallback<T> for Callback<CB>
+        where
+            CB: ProducerCallback<T>,
+        {
+            type Output = CB::Output;
+
+            fn callback<P>(self, base: P) -> CB::Output
+            where
+                P: Producer<Item = T>,
+            {
+                let panicked = AtomicBool::new(false);
+                let producer = PanicFuseProducer {
+                    base,
+                    fuse: Fuse(&panicked),
+                };
+                self.callback.callback(producer)
+            }
+        }
+    }
+}
+
+/// ////////////////////////////////////////////////////////////////////////
+/// Producer implementation
+
+struct PanicFuseProducer<'a, P> {
+    base: P,
+    fuse: Fuse<'a>,
+}
+
+impl<'a, P> Producer for PanicFuseProducer<'a, P>
+where
+    P: Producer,
+{
+    type Item = P::Item;
+    type IntoIter = PanicFuseIter<'a, P::IntoIter>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        PanicFuseIter {
+            base: self.base.into_iter(),
+            fuse: self.fuse,
+        }
+    }
+
+    fn min_len(&self) -> usize {
+        self.base.min_len()
+    }
+    fn max_len(&self) -> usize {
+        self.base.max_len()
+    }
+
+    fn split_at(self, index: usize) -> (Self, Self) {
+        let (left, right) = self.base.split_at(index);
+        (
+            PanicFuseProducer {
+                base: left,
+                fuse: self.fuse.clone(),
+            },
+            PanicFuseProducer {
+                base: right,
+                fuse: self.fuse,
+            },
+        )
+    }
+
+    fn fold_with<G>(self, folder: G) -> G
+    where
+        G: Folder<Self::Item>,
+    {
+        let folder1 = PanicFuseFolder {
+            base: folder,
+            fuse: self.fuse,
+        };
+        self.base.fold_with(folder1).base
+    }
+}
+
+struct PanicFuseIter<'a, I> {
+    base: I,
+    fuse: Fuse<'a>,
+}
+
+impl<'a, I> Iterator for PanicFuseIter<'a, I>
+where
+    I: Iterator,
+{
+    type Item = I::Item;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.fuse.panicked() {
+            None
+        } else {
+            self.base.next()
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.base.size_hint()
+    }
+}
+
+impl<'a, I> DoubleEndedIterator for PanicFuseIter<'a, I>
+where
+    I: DoubleEndedIterator,
+{
+    fn next_back(&mut self) -> Option<Self::Item> {
+        if self.fuse.panicked() {
+            None
+        } else {
+            self.base.next_back()
+        }
+    }
+}
+
+impl<'a, I> ExactSizeIterator for PanicFuseIter<'a, I>
+where
+    I: ExactSizeIterator,
+{
+    fn len(&self) -> usize {
+        self.base.len()
+    }
+}
+
+/// ////////////////////////////////////////////////////////////////////////
+/// Consumer implementation
+
+struct PanicFuseConsumer<'a, C> {
+    base: C,
+    fuse: Fuse<'a>,
+}
+
+impl<'a, T, C> Consumer<T> for PanicFuseConsumer<'a, C>
+where
+    C: Consumer<T>,
+{
+    type Folder = PanicFuseFolder<'a, C::Folder>;
+    type Reducer = PanicFuseReducer<'a, C::Reducer>;
+    type Result = C::Result;
+
+    fn split_at(self, index: usize) -> (Self, Self, Self::Reducer) {
+        let (left, right, reducer) = self.base.split_at(index);
+        (
+            PanicFuseConsumer {
+                base: left,
+                fuse: self.fuse.clone(),
+            },
+            PanicFuseConsumer {
+                base: right,
+                fuse: self.fuse.clone(),
+            },
+            PanicFuseReducer {
+                base: reducer,
+                _fuse: self.fuse,
+            },
+        )
+    }
+
+    fn into_folder(self) -> Self::Folder {
+        PanicFuseFolder {
+            base: self.base.into_folder(),
+            fuse: self.fuse,
+        }
+    }
+
+    fn full(&self) -> bool {
+        self.fuse.panicked() || self.base.full()
+    }
+}
+
+impl<'a, T, C> UnindexedConsumer<T> for PanicFuseConsumer<'a, C>
+where
+    C: UnindexedConsumer<T>,
+{
+    fn split_off_left(&self) -> Self {
+        PanicFuseConsumer {
+            base: self.base.split_off_left(),
+            fuse: self.fuse.clone(),
+        }
+    }
+
+    fn to_reducer(&self) -> Self::Reducer {
+        PanicFuseReducer {
+            base: self.base.to_reducer(),
+            _fuse: self.fuse.clone(),
+        }
+    }
+}
+
+struct PanicFuseFolder<'a, C> {
+    base: C,
+    fuse: Fuse<'a>,
+}
+
+impl<'a, T, C> Folder<T> for PanicFuseFolder<'a, C>
+where
+    C: Folder<T>,
+{
+    type Result = C::Result;
+
+    fn consume(mut self, item: T) -> Self {
+        self.base = self.base.consume(item);
+        self
+    }
+
+    fn consume_iter<I>(mut self, iter: I) -> Self
+    where
+        I: IntoIterator<Item = T>,
+    {
+        fn cool<'a, T>(fuse: &'a Fuse<'_>) -> impl Fn(&T) -> bool + 'a {
+            move |_| !fuse.panicked()
+        }
+
+        self.base = {
+            let fuse = &self.fuse;
+            let iter = iter.into_iter().take_while(cool(fuse));
+            self.base.consume_iter(iter)
+        };
+        self
+    }
+
+    fn complete(self) -> C::Result {
+        self.base.complete()
+    }
+
+    fn full(&self) -> bool {
+        self.fuse.panicked() || self.base.full()
+    }
+}
+
+struct PanicFuseReducer<'a, C> {
+    base: C,
+    _fuse: Fuse<'a>,
+}
+
+impl<'a, T, C> Reducer<T> for PanicFuseReducer<'a, C>
+where
+    C: Reducer<T>,
+{
+    fn reduce(self, left: T, right: T) -> T {
+        self.base.reduce(left, right)
+    }
+}
diff --git a/crates/rayon/src/iter/par_bridge.rs b/crates/rayon/src/iter/par_bridge.rs
new file mode 100644
index 0000000..17bc15b
--- /dev/null
+++ b/crates/rayon/src/iter/par_bridge.rs
@@ -0,0 +1,172 @@
+#[cfg(not(feature = "web_spin_lock"))]
+use std::sync::Mutex;
+
+#[cfg(feature = "web_spin_lock")]
+use wasm_sync::Mutex;
+
+use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
+
+use crate::iter::plumbing::{bridge_unindexed, Folder, UnindexedConsumer, UnindexedProducer};
+use crate::iter::ParallelIterator;
+use crate::{current_num_threads, current_thread_index};
+
+/// Conversion trait to convert an `Iterator` to a `ParallelIterator`.
+///
+/// This creates a "bridge" from a sequential iterator to a parallel one, by distributing its items
+/// across the Rayon thread pool. This has the advantage of being able to parallelize just about
+/// anything, but the resulting `ParallelIterator` can be less efficient than if you started with
+/// `par_iter` instead. However, it can still be useful for iterators that are difficult to
+/// parallelize by other means, like channels or file or network I/O.
+///
+/// Iterator items are pulled by `next()` one at a time, synchronized from each thread that is
+/// ready for work, so this may become a bottleneck if the serial iterator can't keep up with the
+/// parallel demand. The items are not buffered by `IterBridge`, so it's fine to use this with
+/// large or even unbounded iterators.
+///
+/// The resulting iterator is not guaranteed to keep the order of the original iterator.
+///
+/// # Examples
+///
+/// To use this trait, take an existing `Iterator` and call `par_bridge` on it. After that, you can
+/// use any of the `ParallelIterator` methods:
+///
+/// ```
+/// use rayon::iter::ParallelBridge;
+/// use rayon::prelude::ParallelIterator;
+/// use std::sync::mpsc::channel;
+///
+/// let rx = {
+///     let (tx, rx) = channel();
+///
+///     tx.send("one!");
+///     tx.send("two!");
+///     tx.send("three!");
+///
+///     rx
+/// };
+///
+/// let mut output: Vec<&'static str> = rx.into_iter().par_bridge().collect();
+/// output.sort_unstable();
+///
+/// assert_eq!(&*output, &["one!", "three!", "two!"]);
+/// ```
+pub trait ParallelBridge: Sized {
+    /// Creates a bridge from this type to a `ParallelIterator`.
+    fn par_bridge(self) -> IterBridge<Self>;
+}
+
+impl<T: Iterator + Send> ParallelBridge for T
+where
+    T::Item: Send,
+{
+    fn par_bridge(self) -> IterBridge<Self> {
+        IterBridge { iter: self }
+    }
+}
+
+/// `IterBridge` is a parallel iterator that wraps a sequential iterator.
+///
+/// This type is created when using the `par_bridge` method on `ParallelBridge`. See the
+/// [`ParallelBridge`] documentation for details.
+///
+/// [`ParallelBridge`]: trait.ParallelBridge.html
+#[derive(Debug, Clone)]
+pub struct IterBridge<Iter> {
+    iter: Iter,
+}
+
+impl<Iter: Iterator + Send> ParallelIterator for IterBridge<Iter>
+where
+    Iter::Item: Send,
+{
+    type Item = Iter::Item;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        let num_threads = current_num_threads();
+        let threads_started: Vec<_> = (0..num_threads).map(|_| AtomicBool::new(false)).collect();
+
+        bridge_unindexed(
+            &IterParallelProducer {
+                split_count: AtomicUsize::new(num_threads),
+                iter: Mutex::new(self.iter.fuse()),
+                threads_started: &threads_started,
+            },
+            consumer,
+        )
+    }
+}
+
+struct IterParallelProducer<'a, Iter> {
+    split_count: AtomicUsize,
+    iter: Mutex<std::iter::Fuse<Iter>>,
+    threads_started: &'a [AtomicBool],
+}
+
+impl<Iter: Iterator + Send> UnindexedProducer for &IterParallelProducer<'_, Iter> {
+    type Item = Iter::Item;
+
+    fn split(self) -> (Self, Option<Self>) {
+        let mut count = self.split_count.load(Ordering::SeqCst);
+
+        loop {
+            // Check if the iterator is exhausted
+            if let Some(new_count) = count.checked_sub(1) {
+                match self.split_count.compare_exchange_weak(
+                    count,
+                    new_count,
+                    Ordering::SeqCst,
+                    Ordering::SeqCst,
+                ) {
+                    Ok(_) => return (self, Some(self)),
+                    Err(last_count) => count = last_count,
+                }
+            } else {
+                return (self, None);
+            }
+        }
+    }
+
+    fn fold_with<F>(self, mut folder: F) -> F
+    where
+        F: Folder<Self::Item>,
+    {
+        // Guard against work-stealing-induced recursion, in case `Iter::next()`
+        // calls rayon internally, so we don't deadlock our mutex. We might also
+        // be recursing via `folder` methods, which doesn't present a mutex hazard,
+        // but it's lower overhead for us to just check this once, rather than
+        // updating additional shared state on every mutex lock/unlock.
+        // (If this isn't a rayon thread, then there's no work-stealing anyway...)
+        if let Some(i) = current_thread_index() {
+            // Note: If the number of threads in the pool ever grows dynamically, then
+            // we'll end up sharing flags and may falsely detect recursion -- that's
+            // still fine for overall correctness, just not optimal for parallelism.
+            let thread_started = &self.threads_started[i % self.threads_started.len()];
+            if thread_started.swap(true, Ordering::Relaxed) {
+                // We can't make progress with a nested mutex, so just return and let
+                // the outermost loop continue with the rest of the iterator items.
+                return folder;
+            }
+        }
+
+        loop {
+            if let Ok(mut iter) = self.iter.lock() {
+                if let Some(it) = iter.next() {
+                    drop(iter);
+                    folder = folder.consume(it);
+                    if folder.full() {
+                        return folder;
+                    }
+                } else {
+                    return folder;
+                }
+            } else {
+                // any panics from other threads will have been caught by the pool,
+                // and will be re-thrown when joined - just exit
+                return folder;
+            }
+        }
+    }
+}
diff --git a/crates/rayon/src/iter/plumbing/README.md b/crates/rayon/src/iter/plumbing/README.md
new file mode 100644
index 0000000..42d22ef
--- /dev/null
+++ b/crates/rayon/src/iter/plumbing/README.md
@@ -0,0 +1,315 @@
+# Parallel Iterators
+
+These are some notes on the design of the parallel iterator traits.
+This file does not describe how to **use** parallel iterators.
+
+## The challenge
+
+Parallel iterators are more complicated than sequential iterators.
+The reason is that they have to be able to split themselves up and
+operate in parallel across the two halves.
+
+The current design for parallel iterators has two distinct modes in
+which they can be used; as we will see, not all iterators support both
+modes (which is why there are two):
+
+- **Pull mode** (the `Producer` and `UnindexedProducer` traits): in this mode,
+  the iterator is asked to produce the next item using a call to `next`. This
+  is basically like a normal iterator, but with a twist: you can split the
+  iterator in half to produce disjoint items in separate threads.
+  - in the `Producer` trait, splitting is done with `split_at`, which accepts
+    an index where the split should be performed. Only indexed iterators can
+    work in this mode, as they know exactly how much data they will produce,
+    and how to locate the requested index.
+  - in the `UnindexedProducer` trait, splitting is done with `split`, which
+    simply requests that the producer divide itself *approximately* in half.
+    This is useful when the exact length and/or layout is unknown, as with
+    `String` characters, or when the length might exceed `usize`, as with
+    `Range<u64>` on 32-bit platforms.
+    - In theory, any `Producer` could act unindexed, but we don't currently
+      use that possibility.  When you know the exact length, a `split` can
+      simply be implemented as `split_at(length/2)`.
+- **Push mode** (the `Consumer` and `UnindexedConsumer` traits): in
+  this mode, the iterator instead is *given* each item in turn, which
+  is then processed. This is the opposite of a normal iterator. It's
+  more like a `for_each` call: each time a new item is produced, the
+  `consume` method is called with that item. (The traits themselves are
+  a bit more complex, as they support state that can be threaded
+  through and ultimately reduced.) Like producers, there are two
+  variants of consumers which differ in how the split is performed:
+  - in the `Consumer` trait, splitting is done with `split_at`, which
+    accepts an index where the split should be performed. All
+    iterators can work in this mode. The resulting halves thus have an
+    idea about how much data they expect to consume.
+  - in the `UnindexedConsumer` trait, splitting is done with
+    `split_off_left`.  There is no index: the resulting halves must be
+    prepared to process any amount of data, and they don't know where that
+    data falls in the overall stream.
+    - Not all consumers can operate in this mode. It works for
+      `for_each` and `reduce`, for example, but it does not work for
+      `collect_into_vec`, since in that case the position of each item is
+      important for knowing where it ends up in the target collection.
+
+## How iterator execution proceeds
+
+We'll walk through this example iterator chain to start. This chain
+demonstrates more-or-less the full complexity of what can happen.
+
+```rust
+vec1.par_iter()
+    .zip(vec2.par_iter())
+    .flat_map(some_function)
+    .for_each(some_other_function)
+```
+
+To handle an iterator chain, we start by creating consumers. This
+works from the end. So in this case, the call to `for_each` is the
+final step, so it will create a `ForEachConsumer` that, given an item,
+just calls `some_other_function` with that item. (`ForEachConsumer` is
+a very simple consumer because it doesn't need to thread any state
+between items at all.)
+
+Now, the `for_each` call will pass this consumer to the base iterator,
+which is the `flat_map`. It will do this by calling the `drive_unindexed`
+method on the `ParallelIterator` trait. `drive_unindexed` basically
+says "produce items for this iterator and feed them to this consumer";
+it only works for unindexed consumers.
+
+(As an aside, it is interesting that only some consumers can work in
+unindexed mode, but all producers can *drive* an unindexed consumer.
+In contrast, only some producers can drive an *indexed* consumer, but
+all consumers can be supplied indexes. Isn't variance neat.)
+
+As it happens, `FlatMap` only works with unindexed consumers anyway.
+This is because flat-map basically has no idea how many items it will
+produce. If you ask flat-map to produce the 22nd item, it can't do it,
+at least not without some intermediate state. It doesn't know whether
+processing the first item will create 1 item, 3 items, or 100;
+therefore, to produce an arbitrary item, it would basically just have
+to start at the beginning and execute sequentially, which is not what
+we want. But for unindexed consumers, this doesn't matter, since they
+don't need to know how much data they will get.
+
+Therefore, `FlatMap` can wrap the `ForEachConsumer` with a
+`FlatMapConsumer` that feeds to it. This `FlatMapConsumer` will be
+given one item. It will then invoke `some_function` to get a parallel
+iterator out. It will then ask this new parallel iterator to drive the
+`ForEachConsumer`. The `drive_unindexed` method on `flat_map` can then
+pass the `FlatMapConsumer` up the chain to the previous item, which is
+`zip`. At this point, something interesting happens.
+
+## Switching from push to pull mode
+
+If you think about `zip`, it can't really be implemented as a
+consumer, at least not without an intermediate thread and some
+channels or something (or maybe coroutines). The problem is that it
+has to walk two iterators *in lockstep*. Basically, it can't call two
+`drive` methods simultaneously, it can only call one at a time. So at
+this point, the `zip` iterator needs to switch from *push mode* into
+*pull mode*.
+
+You'll note that `Zip` is only usable if its inputs implement
+`IndexedParallelIterator`, meaning that they can produce data starting
+at random points in the stream. This need to switch to push mode is
+exactly why. If we want to split a zip iterator at position 22, we
+need to be able to start zipping items from index 22 right away,
+without having to start from index 0.
+
+Anyway, so at this point, the `drive_unindexed` method for `Zip` stops
+creating consumers. Instead, it creates a *producer*, a `ZipProducer`,
+to be exact, and calls the `bridge` function in the `internals`
+module. Creating a `ZipProducer` will in turn create producers for
+the two iterators being zipped. This is possible because they both
+implement `IndexedParallelIterator`.
+
+The `bridge` function will then connect the consumer, which is
+handling the `flat_map` and `for_each`, with the producer, which is
+handling the `zip` and its predecessors. It will split down until the
+chunks seem reasonably small, then pull items from the producer and
+feed them to the consumer.
+
+## The base case
+
+The other time that `bridge` gets used is when we bottom out in an
+indexed producer, such as a slice or range.  There is also a
+`bridge_unindexed` equivalent for - you guessed it - unindexed producers,
+such as string characters.
+
+<a name="producer-callback">
+
+## What on earth is `ProducerCallback`?
+
+We saw that when you call a parallel action method like
+`par_iter.reduce()`, that will create a "reducing" consumer and then
+invoke `par_iter.drive_unindexed()` (or `par_iter.drive()`) as
+appropriate. This may create yet more consumers as we proceed up the
+parallel iterator chain. But at some point we're going to get to the
+start of the chain, or to a parallel iterator (like `zip()`) that has
+to coordinate multiple inputs. At that point, we need to start
+converting parallel iterators into producers.
+
+The way we do this is by invoking the method `with_producer()`, defined on
+`IndexedParallelIterator`. This is a callback scheme. In an ideal world,
+it would work like this:
+
+```rust
+base_iter.with_producer(|base_producer| {
+    // here, `base_producer` is the producer for `base_iter`
+});
+```
+
+In that case, we could implement a combinator like `map()` by getting
+the producer for the base iterator, wrapping it to make our own
+`MapProducer`, and then passing that to the callback. Something like
+this:
+
+```rust
+struct MapProducer<'f, P, F: 'f> {
+    base: P,
+    map_op: &'f F,
+}
+
+impl<I, F> IndexedParallelIterator for Map<I, F>
+    where I: IndexedParallelIterator,
+          F: MapOp<I::Item>,
+{
+    fn with_producer<CB>(self, callback: CB) -> CB::Output {
+        let map_op = &self.map_op;
+        self.base_iter.with_producer(|base_producer| {
+            // Here `producer` is the producer for `self.base_iter`.
+            // Wrap that to make a `MapProducer`
+            let map_producer = MapProducer {
+                base: base_producer,
+                map_op: map_op
+            };
+
+            // invoke the callback with the wrapped version
+            callback(map_producer)
+        });
+    }
+});
+```
+
+This example demonstrates some of the power of the callback scheme.
+It winds up being a very flexible setup. For one thing, it means we
+can take ownership of `par_iter`; we can then in turn give ownership
+away of its bits and pieces into the producer (this is very useful if
+the iterator owns an `&mut` slice, for example), or create shared
+references and put *those* in the producer. In the case of map, for
+example, the parallel iterator owns the `map_op`, and we borrow
+references to it which we then put into the `MapProducer` (this means
+the `MapProducer` can easily split itself and share those references).
+The `with_producer` method can also create resources that are needed
+during the parallel execution, since the producer does not have to be
+returned.
+
+Unfortunately there is a catch. We can't actually use closures the way
+I showed you. To see why, think about the type that `map_producer`
+would have to have. If we were going to write the `with_producer`
+method using a closure, it would have to look something like this:
+
+```rust
+pub trait IndexedParallelIterator: ParallelIterator {
+    type Producer;
+    fn with_producer<CB, R>(self, callback: CB) -> R
+        where CB: FnOnce(Self::Producer) -> R;
+    ...
+}
+```
+
+Note that we had to add this associated type `Producer` so that
+we could specify the argument of the callback to be `Self::Producer`.
+Now, imagine trying to write that `MapProducer` impl using this style:
+
+```rust
+impl<I, F> IndexedParallelIterator for Map<I, F>
+    where I: IndexedParallelIterator,
+          F: MapOp<I::Item>,
+{
+    type MapProducer = MapProducer<'f, P::Producer, F>;
+    //                             ^^ wait, what is this `'f`?
+
+    fn with_producer<CB, R>(self, callback: CB) -> R
+        where CB: FnOnce(Self::Producer) -> R
+    {
+        let map_op = &self.map_op;
+        //  ^^^^^^ `'f` is (conceptually) the lifetime of this reference,
+        //         so it will be different for each call to `with_producer`!
+    }
+}
+```
+
+This may look familiar to you: it's the same problem that we have
+trying to define an `Iterable` trait. Basically, the producer type
+needs to include a lifetime (here, `'f`) that refers to the body of
+`with_producer` and hence is not in scope at the impl level.
+
+If we had [associated type constructors][1598], we could solve this
+problem that way. But there is another solution. We can use a
+dedicated callback trait like `ProducerCallback`, instead of `FnOnce`:
+
+[1598]: https://github.com/rust-lang/rfcs/pull/1598
+
+```rust
+pub trait ProducerCallback<T> {
+    type Output;
+    fn callback<P>(self, producer: P) -> Self::Output
+        where P: Producer<Item=T>;
+}
+```
+
+Using this trait, the signature of `with_producer()` looks like this:
+
+```rust
+fn with_producer<CB: ProducerCallback<Self::Item>>(self, callback: CB) -> CB::Output;
+```
+
+Notice that this signature **never has to name the producer type** --
+there is no associated type `Producer` anymore. This is because the
+`callback()` method is generically over **all** producers `P`.
+
+The problem is that now the `||` sugar doesn't work anymore. So we
+have to manually create the callback struct, which is a mite tedious.
+So our `MapProducer` code looks like this:
+
+```rust
+impl<I, F> IndexedParallelIterator for Map<I, F>
+    where I: IndexedParallelIterator,
+          F: MapOp<I::Item>,
+{
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+        where CB: ProducerCallback<Self::Item>
+    {
+        return self.base.with_producer(Callback { callback: callback, map_op: self.map_op });
+        //                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        //                             Manual version of the closure sugar: create an instance
+        //                             of a struct that implements `ProducerCallback`.
+
+        // The struct declaration. Each field is something that need to capture from the
+        // creating scope.
+        struct Callback<CB, F> {
+            callback: CB,
+            map_op: F,
+        }
+
+        // Implement the `ProducerCallback` trait. This is pure boilerplate.
+        impl<T, F, CB> ProducerCallback<T> for Callback<CB, F>
+            where F: MapOp<T>,
+                  CB: ProducerCallback<F::Output>
+        {
+            type Output = CB::Output;
+
+            fn callback<P>(self, base: P) -> CB::Output
+                where P: Producer<Item=T>
+            {
+                // The body of the closure is here:
+                let producer = MapProducer { base: base,
+                                             map_op: &self.map_op };
+                self.callback.callback(producer)
+            }
+        }
+    }
+}
+```
+
+OK, a bit tedious, but it works!
diff --git a/crates/rayon/src/iter/plumbing/mod.rs b/crates/rayon/src/iter/plumbing/mod.rs
new file mode 100644
index 0000000..71d4fb4
--- /dev/null
+++ b/crates/rayon/src/iter/plumbing/mod.rs
@@ -0,0 +1,484 @@
+//! Traits and functions used to implement parallel iteration.  These are
+//! low-level details -- users of parallel iterators should not need to
+//! interact with them directly.  See [the `plumbing` README][r] for a general overview.
+//!
+//! [r]: https://github.com/rayon-rs/rayon/blob/master/src/iter/plumbing/README.md
+
+use crate::join_context;
+
+use super::IndexedParallelIterator;
+
+use std::cmp;
+use std::usize;
+
+/// The `ProducerCallback` trait is a kind of generic closure,
+/// [analogous to `FnOnce`][FnOnce]. See [the corresponding section in
+/// the plumbing README][r] for more details.
+///
+/// [r]: https://github.com/rayon-rs/rayon/blob/master/src/iter/plumbing/README.md#producer-callback
+/// [FnOnce]: https://doc.rust-lang.org/std/ops/trait.FnOnce.html
+pub trait ProducerCallback<T> {
+    /// The type of value returned by this callback. Analogous to
+    /// [`Output` from the `FnOnce` trait][Output].
+    ///
+    /// [Output]: https://doc.rust-lang.org/std/ops/trait.FnOnce.html#associatedtype.Output
+    type Output;
+
+    /// Invokes the callback with the given producer as argument. The
+    /// key point of this trait is that this method is generic over
+    /// `P`, and hence implementors must be defined for any producer.
+    fn callback<P>(self, producer: P) -> Self::Output
+    where
+        P: Producer<Item = T>;
+}
+
+/// A `Producer` is effectively a "splittable `IntoIterator`". That
+/// is, a producer is a value which can be converted into an iterator
+/// at any time: at that point, it simply produces items on demand,
+/// like any iterator. But what makes a `Producer` special is that,
+/// *before* we convert to an iterator, we can also **split** it at a
+/// particular point using the `split_at` method. This will yield up
+/// two producers, one producing the items before that point, and one
+/// producing the items after that point (these two producers can then
+/// independently be split further, or be converted into iterators).
+/// In Rayon, this splitting is used to divide between threads.
+/// See [the `plumbing` README][r] for further details.
+///
+/// Note that each producer will always produce a fixed number of
+/// items N. However, this number N is not queryable through the API;
+/// the consumer is expected to track it.
+///
+/// NB. You might expect `Producer` to extend the `IntoIterator`
+/// trait.  However, [rust-lang/rust#20671][20671] prevents us from
+/// declaring the DoubleEndedIterator and ExactSizeIterator
+/// constraints on a required IntoIterator trait, so we inline
+/// IntoIterator here until that issue is fixed.
+///
+/// [r]: https://github.com/rayon-rs/rayon/blob/master/src/iter/plumbing/README.md
+/// [20671]: https://github.com/rust-lang/rust/issues/20671
+pub trait Producer: Send + Sized {
+    /// The type of item that will be produced by this producer once
+    /// it is converted into an iterator.
+    type Item;
+
+    /// The type of iterator we will become.
+    type IntoIter: Iterator<Item = Self::Item> + DoubleEndedIterator + ExactSizeIterator;
+
+    /// Convert `self` into an iterator; at this point, no more parallel splits
+    /// are possible.
+    fn into_iter(self) -> Self::IntoIter;
+
+    /// The minimum number of items that we will process
+    /// sequentially. Defaults to 1, which means that we will split
+    /// all the way down to a single item. This can be raised higher
+    /// using the [`with_min_len`] method, which will force us to
+    /// create sequential tasks at a larger granularity. Note that
+    /// Rayon automatically normally attempts to adjust the size of
+    /// parallel splits to reduce overhead, so this should not be
+    /// needed.
+    ///
+    /// [`with_min_len`]: ../trait.IndexedParallelIterator.html#method.with_min_len
+    fn min_len(&self) -> usize {
+        1
+    }
+
+    /// The maximum number of items that we will process
+    /// sequentially. Defaults to MAX, which means that we can choose
+    /// not to split at all. This can be lowered using the
+    /// [`with_max_len`] method, which will force us to create more
+    /// parallel tasks. Note that Rayon automatically normally
+    /// attempts to adjust the size of parallel splits to reduce
+    /// overhead, so this should not be needed.
+    ///
+    /// [`with_max_len`]: ../trait.IndexedParallelIterator.html#method.with_max_len
+    fn max_len(&self) -> usize {
+        usize::MAX
+    }
+
+    /// Split into two producers; one produces items `0..index`, the
+    /// other `index..N`. Index must be less than or equal to `N`.
+    fn split_at(self, index: usize) -> (Self, Self);
+
+    /// Iterate the producer, feeding each element to `folder`, and
+    /// stop when the folder is full (or all elements have been consumed).
+    ///
+    /// The provided implementation is sufficient for most iterables.
+    fn fold_with<F>(self, folder: F) -> F
+    where
+        F: Folder<Self::Item>,
+    {
+        folder.consume_iter(self.into_iter())
+    }
+}
+
+/// A consumer is effectively a [generalized "fold" operation][fold],
+/// and in fact each consumer will eventually be converted into a
+/// [`Folder`]. What makes a consumer special is that, like a
+/// [`Producer`], it can be **split** into multiple consumers using
+/// the `split_at` method. When a consumer is split, it produces two
+/// consumers, as well as a **reducer**. The two consumers can be fed
+/// items independently, and when they are done the reducer is used to
+/// combine their two results into one. See [the `plumbing`
+/// README][r] for further details.
+///
+/// [r]: https://github.com/rayon-rs/rayon/blob/master/src/iter/plumbing/README.md
+/// [fold]: https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.fold
+/// [`Folder`]: trait.Folder.html
+/// [`Producer`]: trait.Producer.html
+pub trait Consumer<Item>: Send + Sized {
+    /// The type of folder that this consumer can be converted into.
+    type Folder: Folder<Item, Result = Self::Result>;
+
+    /// The type of reducer that is produced if this consumer is split.
+    type Reducer: Reducer<Self::Result>;
+
+    /// The type of result that this consumer will ultimately produce.
+    type Result: Send;
+
+    /// Divide the consumer into two consumers, one processing items
+    /// `0..index` and one processing items from `index..`. Also
+    /// produces a reducer that can be used to reduce the results at
+    /// the end.
+    fn split_at(self, index: usize) -> (Self, Self, Self::Reducer);
+
+    /// Convert the consumer into a folder that can consume items
+    /// sequentially, eventually producing a final result.
+    fn into_folder(self) -> Self::Folder;
+
+    /// Hint whether this `Consumer` would like to stop processing
+    /// further items, e.g. if a search has been completed.
+    fn full(&self) -> bool;
+}
+
+/// The `Folder` trait encapsulates [the standard fold
+/// operation][fold].  It can be fed many items using the `consume`
+/// method. At the end, once all items have been consumed, it can then
+/// be converted (using `complete`) into a final value.
+///
+/// [fold]: https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.fold
+pub trait Folder<Item>: Sized {
+    /// The type of result that will ultimately be produced by the folder.
+    type Result;
+
+    /// Consume next item and return new sequential state.
+    fn consume(self, item: Item) -> Self;
+
+    /// Consume items from the iterator until full, and return new sequential state.
+    ///
+    /// This method is **optional**. The default simply iterates over
+    /// `iter`, invoking `consume` and checking after each iteration
+    /// whether `full` returns false.
+    ///
+    /// The main reason to override it is if you can provide a more
+    /// specialized, efficient implementation.
+    fn consume_iter<I>(mut self, iter: I) -> Self
+    where
+        I: IntoIterator<Item = Item>,
+    {
+        for item in iter {
+            self = self.consume(item);
+            if self.full() {
+                break;
+            }
+        }
+        self
+    }
+
+    /// Finish consuming items, produce final result.
+    fn complete(self) -> Self::Result;
+
+    /// Hint whether this `Folder` would like to stop processing
+    /// further items, e.g. if a search has been completed.
+    fn full(&self) -> bool;
+}
+
+/// The reducer is the final step of a `Consumer` -- after a consumer
+/// has been split into two parts, and each of those parts has been
+/// fully processed, we are left with two results. The reducer is then
+/// used to combine those two results into one. See [the `plumbing`
+/// README][r] for further details.
+///
+/// [r]: https://github.com/rayon-rs/rayon/blob/master/src/iter/plumbing/README.md
+pub trait Reducer<Result> {
+    /// Reduce two final results into one; this is executed after a
+    /// split.
+    fn reduce(self, left: Result, right: Result) -> Result;
+}
+
+/// A stateless consumer can be freely copied. These consumers can be
+/// used like regular consumers, but they also support a
+/// `split_off_left` method that does not take an index to split, but
+/// simply splits at some arbitrary point (`for_each`, for example,
+/// produces an unindexed consumer).
+pub trait UnindexedConsumer<I>: Consumer<I> {
+    /// Splits off a "left" consumer and returns it. The `self`
+    /// consumer should then be used to consume the "right" portion of
+    /// the data. (The ordering matters for methods like find_first --
+    /// values produced by the returned value are given precedence
+    /// over values produced by `self`.) Once the left and right
+    /// halves have been fully consumed, you should reduce the results
+    /// with the result of `to_reducer`.
+    fn split_off_left(&self) -> Self;
+
+    /// Creates a reducer that can be used to combine the results from
+    /// a split consumer.
+    fn to_reducer(&self) -> Self::Reducer;
+}
+
+/// A variant on `Producer` which does not know its exact length or
+/// cannot represent it in a `usize`. These producers act like
+/// ordinary producers except that they cannot be told to split at a
+/// particular point. Instead, you just ask them to split 'somewhere'.
+///
+/// (In principle, `Producer` could extend this trait; however, it
+/// does not because to do so would require producers to carry their
+/// own length with them.)
+pub trait UnindexedProducer: Send + Sized {
+    /// The type of item returned by this producer.
+    type Item;
+
+    /// Split midway into a new producer if possible, otherwise return `None`.
+    fn split(self) -> (Self, Option<Self>);
+
+    /// Iterate the producer, feeding each element to `folder`, and
+    /// stop when the folder is full (or all elements have been consumed).
+    fn fold_with<F>(self, folder: F) -> F
+    where
+        F: Folder<Self::Item>;
+}
+
+/// A splitter controls the policy for splitting into smaller work items.
+///
+/// Thief-splitting is an adaptive policy that starts by splitting into
+/// enough jobs for every worker thread, and then resets itself whenever a
+/// job is actually stolen into a different thread.
+#[derive(Clone, Copy)]
+struct Splitter {
+    /// The `splits` tell us approximately how many remaining times we'd
+    /// like to split this job.  We always just divide it by two though, so
+    /// the effective number of pieces will be `next_power_of_two()`.
+    splits: usize,
+}
+
+impl Splitter {
+    #[inline]
+    fn new() -> Splitter {
+        Splitter {
+            splits: crate::current_num_threads(),
+        }
+    }
+
+    #[inline]
+    fn try_split(&mut self, stolen: bool) -> bool {
+        let Splitter { splits } = *self;
+
+        if stolen {
+            // This job was stolen!  Reset the number of desired splits to the
+            // thread count, if that's more than we had remaining anyway.
+            self.splits = cmp::max(crate::current_num_threads(), self.splits / 2);
+            true
+        } else if splits > 0 {
+            // We have splits remaining, make it so.
+            self.splits /= 2;
+            true
+        } else {
+            // Not stolen, and no more splits -- we're done!
+            false
+        }
+    }
+}
+
+/// The length splitter is built on thief-splitting, but additionally takes
+/// into account the remaining length of the iterator.
+#[derive(Clone, Copy)]
+struct LengthSplitter {
+    inner: Splitter,
+
+    /// The smallest we're willing to divide into.  Usually this is just 1,
+    /// but you can choose a larger working size with `with_min_len()`.
+    min: usize,
+}
+
+impl LengthSplitter {
+    /// Creates a new splitter based on lengths.
+    ///
+    /// The `min` is a hard lower bound.  We'll never split below that, but
+    /// of course an iterator might start out smaller already.
+    ///
+    /// The `max` is an upper bound on the working size, used to determine
+    /// the minimum number of times we need to split to get under that limit.
+    /// The adaptive algorithm may very well split even further, but never
+    /// smaller than the `min`.
+    #[inline]
+    fn new(min: usize, max: usize, len: usize) -> LengthSplitter {
+        let mut splitter = LengthSplitter {
+            inner: Splitter::new(),
+            min: cmp::max(min, 1),
+        };
+
+        // Divide the given length by the max working length to get the minimum
+        // number of splits we need to get under that max.  This rounds down,
+        // but the splitter actually gives `next_power_of_two()` pieces anyway.
+        // e.g. len 12345 / max 100 = 123 min_splits -> 128 pieces.
+        let min_splits = len / cmp::max(max, 1);
+
+        // Only update the value if it's not splitting enough already.
+        if min_splits > splitter.inner.splits {
+            splitter.inner.splits = min_splits;
+        }
+
+        splitter
+    }
+
+    #[inline]
+    fn try_split(&mut self, len: usize, stolen: bool) -> bool {
+        // If splitting wouldn't make us too small, try the inner splitter.
+        len / 2 >= self.min && self.inner.try_split(stolen)
+    }
+}
+
+/// This helper function is used to "connect" a parallel iterator to a
+/// consumer. It will convert the `par_iter` into a producer P and
+/// then pull items from P and feed them to `consumer`, splitting and
+/// creating parallel threads as needed.
+///
+/// This is useful when you are implementing your own parallel
+/// iterators: it is often used as the definition of the
+/// [`drive_unindexed`] or [`drive`] methods.
+///
+/// [`drive_unindexed`]: ../trait.ParallelIterator.html#tymethod.drive_unindexed
+/// [`drive`]: ../trait.IndexedParallelIterator.html#tymethod.drive
+pub fn bridge<I, C>(par_iter: I, consumer: C) -> C::Result
+where
+    I: IndexedParallelIterator,
+    C: Consumer<I::Item>,
+{
+    let len = par_iter.len();
+    return par_iter.with_producer(Callback { len, consumer });
+
+    struct Callback<C> {
+        len: usize,
+        consumer: C,
+    }
+
+    impl<C, I> ProducerCallback<I> for Callback<C>
+    where
+        C: Consumer<I>,
+    {
+        type Output = C::Result;
+        fn callback<P>(self, producer: P) -> C::Result
+        where
+            P: Producer<Item = I>,
+        {
+            bridge_producer_consumer(self.len, producer, self.consumer)
+        }
+    }
+}
+
+/// This helper function is used to "connect" a producer and a
+/// consumer. You may prefer to call [`bridge`], which wraps this
+/// function. This function will draw items from `producer` and feed
+/// them to `consumer`, splitting and creating parallel tasks when
+/// needed.
+///
+/// This is useful when you are implementing your own parallel
+/// iterators: it is often used as the definition of the
+/// [`drive_unindexed`] or [`drive`] methods.
+///
+/// [`bridge`]: fn.bridge.html
+/// [`drive_unindexed`]: ../trait.ParallelIterator.html#tymethod.drive_unindexed
+/// [`drive`]: ../trait.IndexedParallelIterator.html#tymethod.drive
+pub fn bridge_producer_consumer<P, C>(len: usize, producer: P, consumer: C) -> C::Result
+where
+    P: Producer,
+    C: Consumer<P::Item>,
+{
+    let splitter = LengthSplitter::new(producer.min_len(), producer.max_len(), len);
+    return helper(len, false, splitter, producer, consumer);
+
+    fn helper<P, C>(
+        len: usize,
+        migrated: bool,
+        mut splitter: LengthSplitter,
+        producer: P,
+        consumer: C,
+    ) -> C::Result
+    where
+        P: Producer,
+        C: Consumer<P::Item>,
+    {
+        if consumer.full() {
+            consumer.into_folder().complete()
+        } else if splitter.try_split(len, migrated) {
+            let mid = len / 2;
+            let (left_producer, right_producer) = producer.split_at(mid);
+            let (left_consumer, right_consumer, reducer) = consumer.split_at(mid);
+            let (left_result, right_result) = join_context(
+                |context| {
+                    helper(
+                        mid,
+                        context.migrated(),
+                        splitter,
+                        left_producer,
+                        left_consumer,
+                    )
+                },
+                |context| {
+                    helper(
+                        len - mid,
+                        context.migrated(),
+                        splitter,
+                        right_producer,
+                        right_consumer,
+                    )
+                },
+            );
+            reducer.reduce(left_result, right_result)
+        } else {
+            producer.fold_with(consumer.into_folder()).complete()
+        }
+    }
+}
+
+/// A variant of [`bridge_producer_consumer`] where the producer is an unindexed producer.
+///
+/// [`bridge_producer_consumer`]: fn.bridge_producer_consumer.html
+pub fn bridge_unindexed<P, C>(producer: P, consumer: C) -> C::Result
+where
+    P: UnindexedProducer,
+    C: UnindexedConsumer<P::Item>,
+{
+    let splitter = Splitter::new();
+    bridge_unindexed_producer_consumer(false, splitter, producer, consumer)
+}
+
+fn bridge_unindexed_producer_consumer<P, C>(
+    migrated: bool,
+    mut splitter: Splitter,
+    producer: P,
+    consumer: C,
+) -> C::Result
+where
+    P: UnindexedProducer,
+    C: UnindexedConsumer<P::Item>,
+{
+    if consumer.full() {
+        consumer.into_folder().complete()
+    } else if splitter.try_split(migrated) {
+        match producer.split() {
+            (left_producer, Some(right_producer)) => {
+                let (reducer, left_consumer, right_consumer) =
+                    (consumer.to_reducer(), consumer.split_off_left(), consumer);
+                let bridge = bridge_unindexed_producer_consumer;
+                let (left_result, right_result) = join_context(
+                    |context| bridge(context.migrated(), splitter, left_producer, left_consumer),
+                    |context| bridge(context.migrated(), splitter, right_producer, right_consumer),
+                );
+                reducer.reduce(left_result, right_result)
+            }
+            (producer, None) => producer.fold_with(consumer.into_folder()).complete(),
+        }
+    } else {
+        producer.fold_with(consumer.into_folder()).complete()
+    }
+}
diff --git a/crates/rayon/src/iter/positions.rs b/crates/rayon/src/iter/positions.rs
new file mode 100644
index 0000000..f584bb2
--- /dev/null
+++ b/crates/rayon/src/iter/positions.rs
@@ -0,0 +1,137 @@
+use super::plumbing::*;
+use super::*;
+
+use std::fmt::{self, Debug};
+
+/// `Positions` takes a predicate `predicate` and filters out elements that match,
+/// yielding their indices.
+///
+/// This struct is created by the [`positions()`] method on [`IndexedParallelIterator`]
+///
+/// [`positions()`]: trait.IndexedParallelIterator.html#method.positions
+/// [`IndexedParallelIterator`]: trait.IndexedParallelIterator.html
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Clone)]
+pub struct Positions<I: IndexedParallelIterator, P> {
+    base: I,
+    predicate: P,
+}
+
+impl<I: IndexedParallelIterator + Debug, P> Debug for Positions<I, P> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Positions")
+            .field("base", &self.base)
+            .finish()
+    }
+}
+
+impl<I, P> Positions<I, P>
+where
+    I: IndexedParallelIterator,
+{
+    /// Create a new `Positions` iterator.
+    pub(super) fn new(base: I, predicate: P) -> Self {
+        Positions { base, predicate }
+    }
+}
+
+impl<I, P> ParallelIterator for Positions<I, P>
+where
+    I: IndexedParallelIterator,
+    P: Fn(I::Item) -> bool + Sync + Send,
+{
+    type Item = usize;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        let consumer1 = PositionsConsumer::new(consumer, &self.predicate, 0);
+        self.base.drive(consumer1)
+    }
+}
+
+/// ////////////////////////////////////////////////////////////////////////
+/// Consumer implementation
+
+struct PositionsConsumer<'p, C, P> {
+    base: C,
+    predicate: &'p P,
+    offset: usize,
+}
+
+impl<'p, C, P> PositionsConsumer<'p, C, P> {
+    fn new(base: C, predicate: &'p P, offset: usize) -> Self {
+        PositionsConsumer {
+            base,
+            predicate,
+            offset,
+        }
+    }
+}
+
+impl<'p, T, C, P> Consumer<T> for PositionsConsumer<'p, C, P>
+where
+    C: Consumer<usize>,
+    P: Fn(T) -> bool + Sync,
+{
+    type Folder = PositionsFolder<'p, C::Folder, P>;
+    type Reducer = C::Reducer;
+    type Result = C::Result;
+
+    fn split_at(self, index: usize) -> (Self, Self, C::Reducer) {
+        let (left, right, reducer) = self.base.split_at(index);
+        (
+            PositionsConsumer::new(left, self.predicate, self.offset),
+            PositionsConsumer::new(right, self.predicate, self.offset + index),
+            reducer,
+        )
+    }
+
+    fn into_folder(self) -> Self::Folder {
+        PositionsFolder {
+            base: self.base.into_folder(),
+            predicate: self.predicate,
+            offset: self.offset,
+        }
+    }
+
+    fn full(&self) -> bool {
+        self.base.full()
+    }
+}
+
+struct PositionsFolder<'p, F, P> {
+    base: F,
+    predicate: &'p P,
+    offset: usize,
+}
+
+impl<F, P, T> Folder<T> for PositionsFolder<'_, F, P>
+where
+    F: Folder<usize>,
+    P: Fn(T) -> bool,
+{
+    type Result = F::Result;
+
+    fn consume(mut self, item: T) -> Self {
+        let index = self.offset;
+        self.offset += 1;
+        if (self.predicate)(item) {
+            self.base = self.base.consume(index);
+        }
+        self
+    }
+
+    // This cannot easily specialize `consume_iter` to be better than
+    // the default, because that requires checking `self.base.full()`
+    // during a call to `self.base.consume_iter()`. (#632)
+
+    fn complete(self) -> Self::Result {
+        self.base.complete()
+    }
+
+    fn full(&self) -> bool {
+        self.base.full()
+    }
+}
diff --git a/crates/rayon/src/iter/product.rs b/crates/rayon/src/iter/product.rs
new file mode 100644
index 0000000..e081be0
--- /dev/null
+++ b/crates/rayon/src/iter/product.rs
@@ -0,0 +1,114 @@
+use super::plumbing::*;
+use super::ParallelIterator;
+
+use std::iter::{self, Product};
+use std::marker::PhantomData;
+
+pub(super) fn product<PI, P>(pi: PI) -> P
+where
+    PI: ParallelIterator,
+    P: Send + Product<PI::Item> + Product,
+{
+    pi.drive_unindexed(ProductConsumer::new())
+}
+
+fn mul<T: Product>(left: T, right: T) -> T {
+    [left, right].into_iter().product()
+}
+
+struct ProductConsumer<P: Send> {
+    _marker: PhantomData<*const P>,
+}
+
+unsafe impl<P: Send> Send for ProductConsumer<P> {}
+
+impl<P: Send> ProductConsumer<P> {
+    fn new() -> ProductConsumer<P> {
+        ProductConsumer {
+            _marker: PhantomData,
+        }
+    }
+}
+
+impl<P, T> Consumer<T> for ProductConsumer<P>
+where
+    P: Send + Product<T> + Product,
+{
+    type Folder = ProductFolder<P>;
+    type Reducer = Self;
+    type Result = P;
+
+    fn split_at(self, _index: usize) -> (Self, Self, Self) {
+        (
+            ProductConsumer::new(),
+            ProductConsumer::new(),
+            ProductConsumer::new(),
+        )
+    }
+
+    fn into_folder(self) -> Self::Folder {
+        ProductFolder {
+            product: iter::empty::<T>().product(),
+        }
+    }
+
+    fn full(&self) -> bool {
+        false
+    }
+}
+
+impl<P, T> UnindexedConsumer<T> for ProductConsumer<P>
+where
+    P: Send + Product<T> + Product,
+{
+    fn split_off_left(&self) -> Self {
+        ProductConsumer::new()
+    }
+
+    fn to_reducer(&self) -> Self::Reducer {
+        ProductConsumer::new()
+    }
+}
+
+impl<P> Reducer<P> for ProductConsumer<P>
+where
+    P: Send + Product,
+{
+    fn reduce(self, left: P, right: P) -> P {
+        mul(left, right)
+    }
+}
+
+struct ProductFolder<P> {
+    product: P,
+}
+
+impl<P, T> Folder<T> for ProductFolder<P>
+where
+    P: Product<T> + Product,
+{
+    type Result = P;
+
+    fn consume(self, item: T) -> Self {
+        ProductFolder {
+            product: mul(self.product, iter::once(item).product()),
+        }
+    }
+
+    fn consume_iter<I>(self, iter: I) -> Self
+    where
+        I: IntoIterator<Item = T>,
+    {
+        ProductFolder {
+            product: mul(self.product, iter.into_iter().product()),
+        }
+    }
+
+    fn complete(self) -> P {
+        self.product
+    }
+
+    fn full(&self) -> bool {
+        false
+    }
+}
diff --git a/crates/rayon/src/iter/reduce.rs b/crates/rayon/src/iter/reduce.rs
new file mode 100644
index 0000000..321b5dd
--- /dev/null
+++ b/crates/rayon/src/iter/reduce.rs
@@ -0,0 +1,116 @@
+use super::plumbing::*;
+use super::ParallelIterator;
+
+pub(super) fn reduce<PI, R, ID, T>(pi: PI, identity: ID, reduce_op: R) -> T
+where
+    PI: ParallelIterator<Item = T>,
+    R: Fn(T, T) -> T + Sync,
+    ID: Fn() -> T + Sync,
+    T: Send,
+{
+    let consumer = ReduceConsumer {
+        identity: &identity,
+        reduce_op: &reduce_op,
+    };
+    pi.drive_unindexed(consumer)
+}
+
+struct ReduceConsumer<'r, R, ID> {
+    identity: &'r ID,
+    reduce_op: &'r R,
+}
+
+impl<'r, R, ID> Copy for ReduceConsumer<'r, R, ID> {}
+
+impl<'r, R, ID> Clone for ReduceConsumer<'r, R, ID> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<'r, R, ID, T> Consumer<T> for ReduceConsumer<'r, R, ID>
+where
+    R: Fn(T, T) -> T + Sync,
+    ID: Fn() -> T + Sync,
+    T: Send,
+{
+    type Folder = ReduceFolder<'r, R, T>;
+    type Reducer = Self;
+    type Result = T;
+
+    fn split_at(self, _index: usize) -> (Self, Self, Self) {
+        (self, self, self)
+    }
+
+    fn into_folder(self) -> Self::Folder {
+        ReduceFolder {
+            reduce_op: self.reduce_op,
+            item: (self.identity)(),
+        }
+    }
+
+    fn full(&self) -> bool {
+        false
+    }
+}
+
+impl<'r, R, ID, T> UnindexedConsumer<T> for ReduceConsumer<'r, R, ID>
+where
+    R: Fn(T, T) -> T + Sync,
+    ID: Fn() -> T + Sync,
+    T: Send,
+{
+    fn split_off_left(&self) -> Self {
+        *self
+    }
+
+    fn to_reducer(&self) -> Self::Reducer {
+        *self
+    }
+}
+
+impl<'r, R, ID, T> Reducer<T> for ReduceConsumer<'r, R, ID>
+where
+    R: Fn(T, T) -> T + Sync,
+{
+    fn reduce(self, left: T, right: T) -> T {
+        (self.reduce_op)(left, right)
+    }
+}
+
+struct ReduceFolder<'r, R, T> {
+    reduce_op: &'r R,
+    item: T,
+}
+
+impl<'r, R, T> Folder<T> for ReduceFolder<'r, R, T>
+where
+    R: Fn(T, T) -> T,
+{
+    type Result = T;
+
+    fn consume(self, item: T) -> Self {
+        ReduceFolder {
+            reduce_op: self.reduce_op,
+            item: (self.reduce_op)(self.item, item),
+        }
+    }
+
+    fn consume_iter<I>(self, iter: I) -> Self
+    where
+        I: IntoIterator<Item = T>,
+    {
+        ReduceFolder {
+            reduce_op: self.reduce_op,
+            item: iter.into_iter().fold(self.item, self.reduce_op),
+        }
+    }
+
+    fn complete(self) -> T {
+        self.item
+    }
+
+    fn full(&self) -> bool {
+        false
+    }
+}
diff --git a/crates/rayon/src/iter/repeat.rs b/crates/rayon/src/iter/repeat.rs
new file mode 100644
index 0000000..f84a6fe
--- /dev/null
+++ b/crates/rayon/src/iter/repeat.rs
@@ -0,0 +1,241 @@
+use super::plumbing::*;
+use super::*;
+use std::iter;
+use std::usize;
+
+/// Iterator adaptor for [the `repeat()` function](fn.repeat.html).
+#[derive(Debug, Clone)]
+pub struct Repeat<T: Clone + Send> {
+    element: T,
+}
+
+/// Creates a parallel iterator that endlessly repeats `elt` (by
+/// cloning it). Note that this iterator has "infinite" length, so
+/// typically you would want to use `zip` or `take` or some other
+/// means to shorten it, or consider using
+/// [the `repeatn()` function](fn.repeatn.html) instead.
+///
+/// # Examples
+///
+/// ```
+/// use rayon::prelude::*;
+/// use rayon::iter::repeat;
+/// let x: Vec<(i32, i32)> = repeat(22).zip(0..3).collect();
+/// assert_eq!(x, vec![(22, 0), (22, 1), (22, 2)]);
+/// ```
+pub fn repeat<T: Clone + Send>(elt: T) -> Repeat<T> {
+    Repeat { element: elt }
+}
+
+impl<T> Repeat<T>
+where
+    T: Clone + Send,
+{
+    /// Takes only `n` repeats of the element, similar to the general
+    /// [`take()`](trait.IndexedParallelIterator.html#method.take).
+    ///
+    /// The resulting `RepeatN` is an `IndexedParallelIterator`, allowing
+    /// more functionality than `Repeat` alone.
+    pub fn take(self, n: usize) -> RepeatN<T> {
+        repeatn(self.element, n)
+    }
+
+    /// Iterates tuples, repeating the element with items from another
+    /// iterator, similar to the general
+    /// [`zip()`](trait.IndexedParallelIterator.html#method.zip).
+    pub fn zip<Z>(self, zip_op: Z) -> Zip<RepeatN<T>, Z::Iter>
+    where
+        Z: IntoParallelIterator,
+        Z::Iter: IndexedParallelIterator,
+    {
+        let z = zip_op.into_par_iter();
+        let n = z.len();
+        self.take(n).zip(z)
+    }
+}
+
+impl<T> ParallelIterator for Repeat<T>
+where
+    T: Clone + Send,
+{
+    type Item = T;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        let producer = RepeatProducer {
+            element: self.element,
+        };
+        bridge_unindexed(producer, consumer)
+    }
+}
+
+/// Unindexed producer for `Repeat`.
+struct RepeatProducer<T: Clone + Send> {
+    element: T,
+}
+
+impl<T: Clone + Send> UnindexedProducer for RepeatProducer<T> {
+    type Item = T;
+
+    fn split(self) -> (Self, Option<Self>) {
+        (
+            RepeatProducer {
+                element: self.element.clone(),
+            },
+            Some(RepeatProducer {
+                element: self.element,
+            }),
+        )
+    }
+
+    fn fold_with<F>(self, folder: F) -> F
+    where
+        F: Folder<T>,
+    {
+        folder.consume_iter(iter::repeat(self.element))
+    }
+}
+
+/// Iterator adaptor for [the `repeatn()` function](fn.repeatn.html).
+#[derive(Debug, Clone)]
+pub struct RepeatN<T: Clone + Send> {
+    element: T,
+    count: usize,
+}
+
+/// Creates a parallel iterator that produces `n` repeats of `elt`
+/// (by cloning it).
+///
+/// # Examples
+///
+/// ```
+/// use rayon::prelude::*;
+/// use rayon::iter::repeatn;
+/// let x: Vec<(i32, i32)> = repeatn(22, 3).zip(0..3).collect();
+/// assert_eq!(x, vec![(22, 0), (22, 1), (22, 2)]);
+/// ```
+pub fn repeatn<T: Clone + Send>(elt: T, n: usize) -> RepeatN<T> {
+    RepeatN {
+        element: elt,
+        count: n,
+    }
+}
+
+impl<T> ParallelIterator for RepeatN<T>
+where
+    T: Clone + Send,
+{
+    type Item = T;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        Some(self.count)
+    }
+}
+
+impl<T> IndexedParallelIterator for RepeatN<T>
+where
+    T: Clone + Send,
+{
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        callback.callback(RepeatNProducer {
+            element: self.element,
+            count: self.count,
+        })
+    }
+
+    fn len(&self) -> usize {
+        self.count
+    }
+}
+
+/// Producer for `RepeatN`.
+struct RepeatNProducer<T: Clone + Send> {
+    element: T,
+    count: usize,
+}
+
+impl<T: Clone + Send> Producer for RepeatNProducer<T> {
+    type Item = T;
+    type IntoIter = Iter<T>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        Iter {
+            element: self.element,
+            count: self.count,
+        }
+    }
+
+    fn split_at(self, index: usize) -> (Self, Self) {
+        (
+            RepeatNProducer {
+                element: self.element.clone(),
+                count: index,
+            },
+            RepeatNProducer {
+                element: self.element,
+                count: self.count - index,
+            },
+        )
+    }
+}
+
+/// Iterator for `RepeatN`.
+///
+/// This is conceptually like `std::iter::Take<std::iter::Repeat<T>>`, but
+/// we need `DoubleEndedIterator` and unconditional `ExactSizeIterator`.
+struct Iter<T: Clone> {
+    element: T,
+    count: usize,
+}
+
+impl<T: Clone> Iterator for Iter<T> {
+    type Item = T;
+
+    #[inline]
+    fn next(&mut self) -> Option<T> {
+        if self.count > 0 {
+            self.count -= 1;
+            Some(self.element.clone())
+        } else {
+            None
+        }
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (self.count, Some(self.count))
+    }
+}
+
+impl<T: Clone> DoubleEndedIterator for Iter<T> {
+    #[inline]
+    fn next_back(&mut self) -> Option<T> {
+        self.next()
+    }
+}
+
+impl<T: Clone> ExactSizeIterator for Iter<T> {
+    #[inline]
+    fn len(&self) -> usize {
+        self.count
+    }
+}
diff --git a/crates/rayon/src/iter/rev.rs b/crates/rayon/src/iter/rev.rs
new file mode 100644
index 0000000..a4c3b7c
--- /dev/null
+++ b/crates/rayon/src/iter/rev.rs
@@ -0,0 +1,123 @@
+use super::plumbing::*;
+use super::*;
+use std::iter;
+
+/// `Rev` is an iterator that produces elements in reverse order. This struct
+/// is created by the [`rev()`] method on [`IndexedParallelIterator`]
+///
+/// [`rev()`]: trait.IndexedParallelIterator.html#method.rev
+/// [`IndexedParallelIterator`]: trait.IndexedParallelIterator.html
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Debug, Clone)]
+pub struct Rev<I: IndexedParallelIterator> {
+    base: I,
+}
+
+impl<I> Rev<I>
+where
+    I: IndexedParallelIterator,
+{
+    /// Creates a new `Rev` iterator.
+    pub(super) fn new(base: I) -> Self {
+        Rev { base }
+    }
+}
+
+impl<I> ParallelIterator for Rev<I>
+where
+    I: IndexedParallelIterator,
+{
+    type Item = I::Item;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        Some(self.len())
+    }
+}
+
+impl<I> IndexedParallelIterator for Rev<I>
+where
+    I: IndexedParallelIterator,
+{
+    fn drive<C: Consumer<Self::Item>>(self, consumer: C) -> C::Result {
+        bridge(self, consumer)
+    }
+
+    fn len(&self) -> usize {
+        self.base.len()
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        let len = self.base.len();
+        return self.base.with_producer(Callback { callback, len });
+
+        struct Callback<CB> {
+            callback: CB,
+            len: usize,
+        }
+
+        impl<T, CB> ProducerCallback<T> for Callback<CB>
+        where
+            CB: ProducerCallback<T>,
+        {
+            type Output = CB::Output;
+            fn callback<P>(self, base: P) -> CB::Output
+            where
+                P: Producer<Item = T>,
+            {
+                let producer = RevProducer {
+                    base,
+                    len: self.len,
+                };
+                self.callback.callback(producer)
+            }
+        }
+    }
+}
+
+struct RevProducer<P> {
+    base: P,
+    len: usize,
+}
+
+impl<P> Producer for RevProducer<P>
+where
+    P: Producer,
+{
+    type Item = P::Item;
+    type IntoIter = iter::Rev<P::IntoIter>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.base.into_iter().rev()
+    }
+
+    fn min_len(&self) -> usize {
+        self.base.min_len()
+    }
+    fn max_len(&self) -> usize {
+        self.base.max_len()
+    }
+
+    fn split_at(self, index: usize) -> (Self, Self) {
+        let (left, right) = self.base.split_at(self.len - index);
+        (
+            RevProducer {
+                base: right,
+                len: index,
+            },
+            RevProducer {
+                base: left,
+                len: self.len - index,
+            },
+        )
+    }
+}
diff --git a/crates/rayon/src/iter/skip.rs b/crates/rayon/src/iter/skip.rs
new file mode 100644
index 0000000..2d0f947
--- /dev/null
+++ b/crates/rayon/src/iter/skip.rs
@@ -0,0 +1,95 @@
+use super::noop::NoopConsumer;
+use super::plumbing::*;
+use super::*;
+use std::cmp::min;
+
+/// `Skip` is an iterator that skips over the first `n` elements.
+/// This struct is created by the [`skip()`] method on [`IndexedParallelIterator`]
+///
+/// [`skip()`]: trait.IndexedParallelIterator.html#method.skip
+/// [`IndexedParallelIterator`]: trait.IndexedParallelIterator.html
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Debug, Clone)]
+pub struct Skip<I> {
+    base: I,
+    n: usize,
+}
+
+impl<I> Skip<I>
+where
+    I: IndexedParallelIterator,
+{
+    /// Creates a new `Skip` iterator.
+    pub(super) fn new(base: I, n: usize) -> Self {
+        let n = min(base.len(), n);
+        Skip { base, n }
+    }
+}
+
+impl<I> ParallelIterator for Skip<I>
+where
+    I: IndexedParallelIterator,
+{
+    type Item = I::Item;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        Some(self.len())
+    }
+}
+
+impl<I> IndexedParallelIterator for Skip<I>
+where
+    I: IndexedParallelIterator,
+{
+    fn len(&self) -> usize {
+        self.base.len() - self.n
+    }
+
+    fn drive<C: Consumer<Self::Item>>(self, consumer: C) -> C::Result {
+        bridge(self, consumer)
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        return self.base.with_producer(Callback {
+            callback,
+            n: self.n,
+        });
+
+        struct Callback<CB> {
+            callback: CB,
+            n: usize,
+        }
+
+        impl<T, CB> ProducerCallback<T> for Callback<CB>
+        where
+            CB: ProducerCallback<T>,
+        {
+            type Output = CB::Output;
+            fn callback<P>(self, base: P) -> CB::Output
+            where
+                P: Producer<Item = T>,
+            {
+                crate::in_place_scope(|scope| {
+                    let Self { callback, n } = self;
+                    let (before_skip, after_skip) = base.split_at(n);
+
+                    // Run the skipped part separately for side effects.
+                    // We'll still get any panics propagated back by the scope.
+                    scope.spawn(move |_| bridge_producer_consumer(n, before_skip, NoopConsumer));
+
+                    callback.callback(after_skip)
+                })
+            }
+        }
+    }
+}
diff --git a/crates/rayon/src/iter/skip_any.rs b/crates/rayon/src/iter/skip_any.rs
new file mode 100644
index 0000000..0660a56
--- /dev/null
+++ b/crates/rayon/src/iter/skip_any.rs
@@ -0,0 +1,144 @@
+use super::plumbing::*;
+use super::*;
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+/// `SkipAny` is an iterator that skips over `n` elements from anywhere in `I`.
+/// This struct is created by the [`skip_any()`] method on [`ParallelIterator`]
+///
+/// [`skip_any()`]: trait.ParallelIterator.html#method.skip_any
+/// [`ParallelIterator`]: trait.ParallelIterator.html
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Clone, Debug)]
+pub struct SkipAny<I: ParallelIterator> {
+    base: I,
+    count: usize,
+}
+
+impl<I> SkipAny<I>
+where
+    I: ParallelIterator,
+{
+    /// Creates a new `SkipAny` iterator.
+    pub(super) fn new(base: I, count: usize) -> Self {
+        SkipAny { base, count }
+    }
+}
+
+impl<I> ParallelIterator for SkipAny<I>
+where
+    I: ParallelIterator,
+{
+    type Item = I::Item;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        let consumer1 = SkipAnyConsumer {
+            base: consumer,
+            count: &AtomicUsize::new(self.count),
+        };
+        self.base.drive_unindexed(consumer1)
+    }
+}
+
+/// ////////////////////////////////////////////////////////////////////////
+/// Consumer implementation
+
+struct SkipAnyConsumer<'f, C> {
+    base: C,
+    count: &'f AtomicUsize,
+}
+
+impl<'f, T, C> Consumer<T> for SkipAnyConsumer<'f, C>
+where
+    C: Consumer<T>,
+    T: Send,
+{
+    type Folder = SkipAnyFolder<'f, C::Folder>;
+    type Reducer = C::Reducer;
+    type Result = C::Result;
+
+    fn split_at(self, index: usize) -> (Self, Self, Self::Reducer) {
+        let (left, right, reducer) = self.base.split_at(index);
+        (
+            SkipAnyConsumer { base: left, ..self },
+            SkipAnyConsumer {
+                base: right,
+                ..self
+            },
+            reducer,
+        )
+    }
+
+    fn into_folder(self) -> Self::Folder {
+        SkipAnyFolder {
+            base: self.base.into_folder(),
+            count: self.count,
+        }
+    }
+
+    fn full(&self) -> bool {
+        self.base.full()
+    }
+}
+
+impl<'f, T, C> UnindexedConsumer<T> for SkipAnyConsumer<'f, C>
+where
+    C: UnindexedConsumer<T>,
+    T: Send,
+{
+    fn split_off_left(&self) -> Self {
+        SkipAnyConsumer {
+            base: self.base.split_off_left(),
+            ..*self
+        }
+    }
+
+    fn to_reducer(&self) -> Self::Reducer {
+        self.base.to_reducer()
+    }
+}
+
+struct SkipAnyFolder<'f, C> {
+    base: C,
+    count: &'f AtomicUsize,
+}
+
+fn checked_decrement(u: &AtomicUsize) -> bool {
+    u.fetch_update(Ordering::Relaxed, Ordering::Relaxed, |u| u.checked_sub(1))
+        .is_ok()
+}
+
+impl<'f, T, C> Folder<T> for SkipAnyFolder<'f, C>
+where
+    C: Folder<T>,
+{
+    type Result = C::Result;
+
+    fn consume(mut self, item: T) -> Self {
+        if !checked_decrement(self.count) {
+            self.base = self.base.consume(item);
+        }
+        self
+    }
+
+    fn consume_iter<I>(mut self, iter: I) -> Self
+    where
+        I: IntoIterator<Item = T>,
+    {
+        self.base = self.base.consume_iter(
+            iter.into_iter()
+                .skip_while(move |_| checked_decrement(self.count)),
+        );
+        self
+    }
+
+    fn complete(self) -> C::Result {
+        self.base.complete()
+    }
+
+    fn full(&self) -> bool {
+        self.base.full()
+    }
+}
diff --git a/crates/rayon/src/iter/skip_any_while.rs b/crates/rayon/src/iter/skip_any_while.rs
new file mode 100644
index 0000000..28b9e59
--- /dev/null
+++ b/crates/rayon/src/iter/skip_any_while.rs
@@ -0,0 +1,166 @@
+use super::plumbing::*;
+use super::*;
+use std::fmt;
+use std::sync::atomic::{AtomicBool, Ordering};
+
+/// `SkipAnyWhile` is an iterator that skips over elements from anywhere in `I`
+/// until the callback returns `false`.
+/// This struct is created by the [`skip_any_while()`] method on [`ParallelIterator`]
+///
+/// [`skip_any_while()`]: trait.ParallelIterator.html#method.skip_any_while
+/// [`ParallelIterator`]: trait.ParallelIterator.html
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Clone)]
+pub struct SkipAnyWhile<I: ParallelIterator, P> {
+    base: I,
+    predicate: P,
+}
+
+impl<I: ParallelIterator + fmt::Debug, P> fmt::Debug for SkipAnyWhile<I, P> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("SkipAnyWhile")
+            .field("base", &self.base)
+            .finish()
+    }
+}
+
+impl<I, P> SkipAnyWhile<I, P>
+where
+    I: ParallelIterator,
+{
+    /// Creates a new `SkipAnyWhile` iterator.
+    pub(super) fn new(base: I, predicate: P) -> Self {
+        SkipAnyWhile { base, predicate }
+    }
+}
+
+impl<I, P> ParallelIterator for SkipAnyWhile<I, P>
+where
+    I: ParallelIterator,
+    P: Fn(&I::Item) -> bool + Sync + Send,
+{
+    type Item = I::Item;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        let consumer1 = SkipAnyWhileConsumer {
+            base: consumer,
+            predicate: &self.predicate,
+            skipping: &AtomicBool::new(true),
+        };
+        self.base.drive_unindexed(consumer1)
+    }
+}
+
+/// ////////////////////////////////////////////////////////////////////////
+/// Consumer implementation
+
+struct SkipAnyWhileConsumer<'p, C, P> {
+    base: C,
+    predicate: &'p P,
+    skipping: &'p AtomicBool,
+}
+
+impl<'p, T, C, P> Consumer<T> for SkipAnyWhileConsumer<'p, C, P>
+where
+    C: Consumer<T>,
+    P: Fn(&T) -> bool + Sync,
+{
+    type Folder = SkipAnyWhileFolder<'p, C::Folder, P>;
+    type Reducer = C::Reducer;
+    type Result = C::Result;
+
+    fn split_at(self, index: usize) -> (Self, Self, Self::Reducer) {
+        let (left, right, reducer) = self.base.split_at(index);
+        (
+            SkipAnyWhileConsumer { base: left, ..self },
+            SkipAnyWhileConsumer {
+                base: right,
+                ..self
+            },
+            reducer,
+        )
+    }
+
+    fn into_folder(self) -> Self::Folder {
+        SkipAnyWhileFolder {
+            base: self.base.into_folder(),
+            predicate: self.predicate,
+            skipping: self.skipping,
+        }
+    }
+
+    fn full(&self) -> bool {
+        self.base.full()
+    }
+}
+
+impl<'p, T, C, P> UnindexedConsumer<T> for SkipAnyWhileConsumer<'p, C, P>
+where
+    C: UnindexedConsumer<T>,
+    P: Fn(&T) -> bool + Sync,
+{
+    fn split_off_left(&self) -> Self {
+        SkipAnyWhileConsumer {
+            base: self.base.split_off_left(),
+            ..*self
+        }
+    }
+
+    fn to_reducer(&self) -> Self::Reducer {
+        self.base.to_reducer()
+    }
+}
+
+struct SkipAnyWhileFolder<'p, C, P> {
+    base: C,
+    predicate: &'p P,
+    skipping: &'p AtomicBool,
+}
+
+fn skip<T>(item: &T, skipping: &AtomicBool, predicate: &impl Fn(&T) -> bool) -> bool {
+    if !skipping.load(Ordering::Relaxed) {
+        return false;
+    }
+    if predicate(item) {
+        return true;
+    }
+    skipping.store(false, Ordering::Relaxed);
+    false
+}
+
+impl<'p, T, C, P> Folder<T> for SkipAnyWhileFolder<'p, C, P>
+where
+    C: Folder<T>,
+    P: Fn(&T) -> bool + 'p,
+{
+    type Result = C::Result;
+
+    fn consume(mut self, item: T) -> Self {
+        if !skip(&item, self.skipping, self.predicate) {
+            self.base = self.base.consume(item);
+        }
+        self
+    }
+
+    fn consume_iter<I>(mut self, iter: I) -> Self
+    where
+        I: IntoIterator<Item = T>,
+    {
+        self.base = self.base.consume_iter(
+            iter.into_iter()
+                .skip_while(move |x| skip(x, self.skipping, self.predicate)),
+        );
+        self
+    }
+
+    fn complete(self) -> C::Result {
+        self.base.complete()
+    }
+
+    fn full(&self) -> bool {
+        self.base.full()
+    }
+}
diff --git a/crates/rayon/src/iter/splitter.rs b/crates/rayon/src/iter/splitter.rs
new file mode 100644
index 0000000..40935ac
--- /dev/null
+++ b/crates/rayon/src/iter/splitter.rs
@@ -0,0 +1,174 @@
+use super::plumbing::*;
+use super::*;
+
+use std::fmt::{self, Debug};
+
+/// The `split` function takes arbitrary data and a closure that knows how to
+/// split it, and turns this into a `ParallelIterator`.
+///
+/// # Examples
+///
+/// As a simple example, Rayon can recursively split ranges of indices
+///
+/// ```
+/// use rayon::iter;
+/// use rayon::prelude::*;
+/// use std::ops::Range;
+///
+///
+/// // We define a range of indices as follows
+/// type Range1D = Range<usize>;
+///
+/// // Splitting it in two can be done like this
+/// fn split_range1(r: Range1D) -> (Range1D, Option<Range1D>) {
+///     // We are mathematically unable to split the range if there is only
+///     // one point inside of it, but we could stop splitting before that.
+///     if r.end - r.start <= 1 { return (r, None); }
+///
+///     // Here, our range is considered large enough to be splittable
+///     let midpoint = r.start + (r.end - r.start) / 2;
+///     (r.start..midpoint, Some(midpoint..r.end))
+/// }
+///
+/// // By using iter::split, Rayon will split the range until it has enough work
+/// // to feed the CPU cores, then give us the resulting sub-ranges
+/// iter::split(0..4096, split_range1).for_each(|sub_range| {
+///     // As our initial range had a power-of-two size, the final sub-ranges
+///     // should have power-of-two sizes too
+///     assert!((sub_range.end - sub_range.start).is_power_of_two());
+/// });
+/// ```
+///
+/// This recursive splitting can be extended to two or three dimensions,
+/// to reproduce a classic "block-wise" parallelization scheme of graphics and
+/// numerical simulations:
+///
+/// ```
+/// # use rayon::iter;
+/// # use rayon::prelude::*;
+/// # use std::ops::Range;
+/// # type Range1D = Range<usize>;
+/// # fn split_range1(r: Range1D) -> (Range1D, Option<Range1D>) {
+/// #     if r.end - r.start <= 1 { return (r, None); }
+/// #     let midpoint = r.start + (r.end - r.start) / 2;
+/// #     (r.start..midpoint, Some(midpoint..r.end))
+/// # }
+/// #
+/// // A two-dimensional range of indices can be built out of two 1D ones
+/// struct Range2D {
+///     // Range of horizontal indices
+///     pub rx: Range1D,
+///
+///     // Range of vertical indices
+///     pub ry: Range1D,
+/// }
+///
+/// // We want to recursively split them by the largest dimension until we have
+/// // enough sub-ranges to feed our mighty multi-core CPU. This function
+/// // carries out one such split.
+/// fn split_range2(r2: Range2D) -> (Range2D, Option<Range2D>) {
+///     // Decide on which axis (horizontal/vertical) the range should be split
+///     let width = r2.rx.end - r2.rx.start;
+///     let height = r2.ry.end - r2.ry.start;
+///     if width >= height {
+///         // This is a wide range, split it on the horizontal axis
+///         let (split_rx, ry) = (split_range1(r2.rx), r2.ry);
+///         let out1 = Range2D {
+///             rx: split_rx.0,
+///             ry: ry.clone(),
+///         };
+///         let out2 = split_rx.1.map(|rx| Range2D { rx, ry });
+///         (out1, out2)
+///     } else {
+///         // This is a tall range, split it on the vertical axis
+///         let (rx, split_ry) = (r2.rx, split_range1(r2.ry));
+///         let out1 = Range2D {
+///             rx: rx.clone(),
+///             ry: split_ry.0,
+///         };
+///         let out2 = split_ry.1.map(|ry| Range2D { rx, ry, });
+///         (out1, out2)
+///     }
+/// }
+///
+/// // Again, rayon can handle the recursive splitting for us
+/// let range = Range2D { rx: 0..800, ry: 0..600 };
+/// iter::split(range, split_range2).for_each(|sub_range| {
+///     // If the sub-ranges were indeed split by the largest dimension, then
+///     // if no dimension was twice larger than the other initially, this
+///     // property will remain true in the final sub-ranges.
+///     let width = sub_range.rx.end - sub_range.rx.start;
+///     let height = sub_range.ry.end - sub_range.ry.start;
+///     assert!((width / 2 <= height) && (height / 2 <= width));
+/// });
+/// ```
+///
+pub fn split<D, S>(data: D, splitter: S) -> Split<D, S>
+where
+    D: Send,
+    S: Fn(D) -> (D, Option<D>) + Sync,
+{
+    Split { data, splitter }
+}
+
+/// `Split` is a parallel iterator using arbitrary data and a splitting function.
+/// This struct is created by the [`split()`] function.
+///
+/// [`split()`]: fn.split.html
+#[derive(Clone)]
+pub struct Split<D, S> {
+    data: D,
+    splitter: S,
+}
+
+impl<D: Debug, S> Debug for Split<D, S> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Split").field("data", &self.data).finish()
+    }
+}
+
+impl<D, S> ParallelIterator for Split<D, S>
+where
+    D: Send,
+    S: Fn(D) -> (D, Option<D>) + Sync + Send,
+{
+    type Item = D;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        let producer = SplitProducer {
+            data: self.data,
+            splitter: &self.splitter,
+        };
+        bridge_unindexed(producer, consumer)
+    }
+}
+
+struct SplitProducer<'a, D, S> {
+    data: D,
+    splitter: &'a S,
+}
+
+impl<'a, D, S> UnindexedProducer for SplitProducer<'a, D, S>
+where
+    D: Send,
+    S: Fn(D) -> (D, Option<D>) + Sync,
+{
+    type Item = D;
+
+    fn split(mut self) -> (Self, Option<Self>) {
+        let splitter = self.splitter;
+        let (left, right) = splitter(self.data);
+        self.data = left;
+        (self, right.map(|data| SplitProducer { data, splitter }))
+    }
+
+    fn fold_with<F>(self, folder: F) -> F
+    where
+        F: Folder<Self::Item>,
+    {
+        folder.consume(self.data)
+    }
+}
diff --git a/crates/rayon/src/iter/step_by.rs b/crates/rayon/src/iter/step_by.rs
new file mode 100644
index 0000000..94b8334
--- /dev/null
+++ b/crates/rayon/src/iter/step_by.rs
@@ -0,0 +1,143 @@
+use std::cmp::min;
+
+use super::plumbing::*;
+use super::*;
+use crate::math::div_round_up;
+use std::iter;
+use std::usize;
+
+/// `StepBy` is an iterator that skips `n` elements between each yield, where `n` is the given step.
+/// This struct is created by the [`step_by()`] method on [`IndexedParallelIterator`]
+///
+/// [`step_by()`]: trait.IndexedParallelIterator.html#method.step_by
+/// [`IndexedParallelIterator`]: trait.IndexedParallelIterator.html
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Debug, Clone)]
+pub struct StepBy<I: IndexedParallelIterator> {
+    base: I,
+    step: usize,
+}
+
+impl<I> StepBy<I>
+where
+    I: IndexedParallelIterator,
+{
+    /// Creates a new `StepBy` iterator.
+    pub(super) fn new(base: I, step: usize) -> Self {
+        StepBy { base, step }
+    }
+}
+
+impl<I> ParallelIterator for StepBy<I>
+where
+    I: IndexedParallelIterator,
+{
+    type Item = I::Item;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        Some(self.len())
+    }
+}
+
+impl<I> IndexedParallelIterator for StepBy<I>
+where
+    I: IndexedParallelIterator,
+{
+    fn drive<C: Consumer<Self::Item>>(self, consumer: C) -> C::Result {
+        bridge(self, consumer)
+    }
+
+    fn len(&self) -> usize {
+        div_round_up(self.base.len(), self.step)
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        let len = self.base.len();
+        return self.base.with_producer(Callback {
+            callback,
+            step: self.step,
+            len,
+        });
+
+        struct Callback<CB> {
+            callback: CB,
+            step: usize,
+            len: usize,
+        }
+
+        impl<T, CB> ProducerCallback<T> for Callback<CB>
+        where
+            CB: ProducerCallback<T>,
+        {
+            type Output = CB::Output;
+            fn callback<P>(self, base: P) -> CB::Output
+            where
+                P: Producer<Item = T>,
+            {
+                let producer = StepByProducer {
+                    base,
+                    step: self.step,
+                    len: self.len,
+                };
+                self.callback.callback(producer)
+            }
+        }
+    }
+}
+
+/// ////////////////////////////////////////////////////////////////////////
+/// Producer implementation
+
+struct StepByProducer<P> {
+    base: P,
+    step: usize,
+    len: usize,
+}
+
+impl<P> Producer for StepByProducer<P>
+where
+    P: Producer,
+{
+    type Item = P::Item;
+    type IntoIter = iter::StepBy<P::IntoIter>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.base.into_iter().step_by(self.step)
+    }
+
+    fn split_at(self, index: usize) -> (Self, Self) {
+        let elem_index = min(index * self.step, self.len);
+
+        let (left, right) = self.base.split_at(elem_index);
+        (
+            StepByProducer {
+                base: left,
+                step: self.step,
+                len: elem_index,
+            },
+            StepByProducer {
+                base: right,
+                step: self.step,
+                len: self.len - elem_index,
+            },
+        )
+    }
+
+    fn min_len(&self) -> usize {
+        div_round_up(self.base.min_len(), self.step)
+    }
+
+    fn max_len(&self) -> usize {
+        self.base.max_len() / self.step
+    }
+}
diff --git a/crates/rayon/src/iter/sum.rs b/crates/rayon/src/iter/sum.rs
new file mode 100644
index 0000000..ddae810
--- /dev/null
+++ b/crates/rayon/src/iter/sum.rs
@@ -0,0 +1,110 @@
+use super::plumbing::*;
+use super::ParallelIterator;
+
+use std::iter::{self, Sum};
+use std::marker::PhantomData;
+
+pub(super) fn sum<PI, S>(pi: PI) -> S
+where
+    PI: ParallelIterator,
+    S: Send + Sum<PI::Item> + Sum,
+{
+    pi.drive_unindexed(SumConsumer::new())
+}
+
+fn add<T: Sum>(left: T, right: T) -> T {
+    [left, right].into_iter().sum()
+}
+
+struct SumConsumer<S: Send> {
+    _marker: PhantomData<*const S>,
+}
+
+unsafe impl<S: Send> Send for SumConsumer<S> {}
+
+impl<S: Send> SumConsumer<S> {
+    fn new() -> SumConsumer<S> {
+        SumConsumer {
+            _marker: PhantomData,
+        }
+    }
+}
+
+impl<S, T> Consumer<T> for SumConsumer<S>
+where
+    S: Send + Sum<T> + Sum,
+{
+    type Folder = SumFolder<S>;
+    type Reducer = Self;
+    type Result = S;
+
+    fn split_at(self, _index: usize) -> (Self, Self, Self) {
+        (SumConsumer::new(), SumConsumer::new(), SumConsumer::new())
+    }
+
+    fn into_folder(self) -> Self::Folder {
+        SumFolder {
+            sum: iter::empty::<T>().sum(),
+        }
+    }
+
+    fn full(&self) -> bool {
+        false
+    }
+}
+
+impl<S, T> UnindexedConsumer<T> for SumConsumer<S>
+where
+    S: Send + Sum<T> + Sum,
+{
+    fn split_off_left(&self) -> Self {
+        SumConsumer::new()
+    }
+
+    fn to_reducer(&self) -> Self::Reducer {
+        SumConsumer::new()
+    }
+}
+
+impl<S> Reducer<S> for SumConsumer<S>
+where
+    S: Send + Sum,
+{
+    fn reduce(self, left: S, right: S) -> S {
+        add(left, right)
+    }
+}
+
+struct SumFolder<S> {
+    sum: S,
+}
+
+impl<S, T> Folder<T> for SumFolder<S>
+where
+    S: Sum<T> + Sum,
+{
+    type Result = S;
+
+    fn consume(self, item: T) -> Self {
+        SumFolder {
+            sum: add(self.sum, iter::once(item).sum()),
+        }
+    }
+
+    fn consume_iter<I>(self, iter: I) -> Self
+    where
+        I: IntoIterator<Item = T>,
+    {
+        SumFolder {
+            sum: add(self.sum, iter.into_iter().sum()),
+        }
+    }
+
+    fn complete(self) -> S {
+        self.sum
+    }
+
+    fn full(&self) -> bool {
+        false
+    }
+}
diff --git a/crates/rayon/src/iter/take.rs b/crates/rayon/src/iter/take.rs
new file mode 100644
index 0000000..52d15d8
--- /dev/null
+++ b/crates/rayon/src/iter/take.rs
@@ -0,0 +1,86 @@
+use super::plumbing::*;
+use super::*;
+use std::cmp::min;
+
+/// `Take` is an iterator that iterates over the first `n` elements.
+/// This struct is created by the [`take()`] method on [`IndexedParallelIterator`]
+///
+/// [`take()`]: trait.IndexedParallelIterator.html#method.take
+/// [`IndexedParallelIterator`]: trait.IndexedParallelIterator.html
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Debug, Clone)]
+pub struct Take<I> {
+    base: I,
+    n: usize,
+}
+
+impl<I> Take<I>
+where
+    I: IndexedParallelIterator,
+{
+    /// Creates a new `Take` iterator.
+    pub(super) fn new(base: I, n: usize) -> Self {
+        let n = min(base.len(), n);
+        Take { base, n }
+    }
+}
+
+impl<I> ParallelIterator for Take<I>
+where
+    I: IndexedParallelIterator,
+{
+    type Item = I::Item;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        Some(self.len())
+    }
+}
+
+impl<I> IndexedParallelIterator for Take<I>
+where
+    I: IndexedParallelIterator,
+{
+    fn len(&self) -> usize {
+        self.n
+    }
+
+    fn drive<C: Consumer<Self::Item>>(self, consumer: C) -> C::Result {
+        bridge(self, consumer)
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        return self.base.with_producer(Callback {
+            callback,
+            n: self.n,
+        });
+
+        struct Callback<CB> {
+            callback: CB,
+            n: usize,
+        }
+
+        impl<T, CB> ProducerCallback<T> for Callback<CB>
+        where
+            CB: ProducerCallback<T>,
+        {
+            type Output = CB::Output;
+            fn callback<P>(self, base: P) -> CB::Output
+            where
+                P: Producer<Item = T>,
+            {
+                let (producer, _) = base.split_at(self.n);
+                self.callback.callback(producer)
+            }
+        }
+    }
+}
diff --git a/crates/rayon/src/iter/take_any.rs b/crates/rayon/src/iter/take_any.rs
new file mode 100644
index 0000000..e3992b3
--- /dev/null
+++ b/crates/rayon/src/iter/take_any.rs
@@ -0,0 +1,144 @@
+use super::plumbing::*;
+use super::*;
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+/// `TakeAny` is an iterator that iterates over `n` elements from anywhere in `I`.
+/// This struct is created by the [`take_any()`] method on [`ParallelIterator`]
+///
+/// [`take_any()`]: trait.ParallelIterator.html#method.take_any
+/// [`ParallelIterator`]: trait.ParallelIterator.html
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Clone, Debug)]
+pub struct TakeAny<I: ParallelIterator> {
+    base: I,
+    count: usize,
+}
+
+impl<I> TakeAny<I>
+where
+    I: ParallelIterator,
+{
+    /// Creates a new `TakeAny` iterator.
+    pub(super) fn new(base: I, count: usize) -> Self {
+        TakeAny { base, count }
+    }
+}
+
+impl<I> ParallelIterator for TakeAny<I>
+where
+    I: ParallelIterator,
+{
+    type Item = I::Item;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        let consumer1 = TakeAnyConsumer {
+            base: consumer,
+            count: &AtomicUsize::new(self.count),
+        };
+        self.base.drive_unindexed(consumer1)
+    }
+}
+
+/// ////////////////////////////////////////////////////////////////////////
+/// Consumer implementation
+
+struct TakeAnyConsumer<'f, C> {
+    base: C,
+    count: &'f AtomicUsize,
+}
+
+impl<'f, T, C> Consumer<T> for TakeAnyConsumer<'f, C>
+where
+    C: Consumer<T>,
+    T: Send,
+{
+    type Folder = TakeAnyFolder<'f, C::Folder>;
+    type Reducer = C::Reducer;
+    type Result = C::Result;
+
+    fn split_at(self, index: usize) -> (Self, Self, Self::Reducer) {
+        let (left, right, reducer) = self.base.split_at(index);
+        (
+            TakeAnyConsumer { base: left, ..self },
+            TakeAnyConsumer {
+                base: right,
+                ..self
+            },
+            reducer,
+        )
+    }
+
+    fn into_folder(self) -> Self::Folder {
+        TakeAnyFolder {
+            base: self.base.into_folder(),
+            count: self.count,
+        }
+    }
+
+    fn full(&self) -> bool {
+        self.count.load(Ordering::Relaxed) == 0 || self.base.full()
+    }
+}
+
+impl<'f, T, C> UnindexedConsumer<T> for TakeAnyConsumer<'f, C>
+where
+    C: UnindexedConsumer<T>,
+    T: Send,
+{
+    fn split_off_left(&self) -> Self {
+        TakeAnyConsumer {
+            base: self.base.split_off_left(),
+            ..*self
+        }
+    }
+
+    fn to_reducer(&self) -> Self::Reducer {
+        self.base.to_reducer()
+    }
+}
+
+struct TakeAnyFolder<'f, C> {
+    base: C,
+    count: &'f AtomicUsize,
+}
+
+fn checked_decrement(u: &AtomicUsize) -> bool {
+    u.fetch_update(Ordering::Relaxed, Ordering::Relaxed, |u| u.checked_sub(1))
+        .is_ok()
+}
+
+impl<'f, T, C> Folder<T> for TakeAnyFolder<'f, C>
+where
+    C: Folder<T>,
+{
+    type Result = C::Result;
+
+    fn consume(mut self, item: T) -> Self {
+        if checked_decrement(self.count) {
+            self.base = self.base.consume(item);
+        }
+        self
+    }
+
+    fn consume_iter<I>(mut self, iter: I) -> Self
+    where
+        I: IntoIterator<Item = T>,
+    {
+        self.base = self.base.consume_iter(
+            iter.into_iter()
+                .take_while(move |_| checked_decrement(self.count)),
+        );
+        self
+    }
+
+    fn complete(self) -> C::Result {
+        self.base.complete()
+    }
+
+    fn full(&self) -> bool {
+        self.count.load(Ordering::Relaxed) == 0 || self.base.full()
+    }
+}
diff --git a/crates/rayon/src/iter/take_any_while.rs b/crates/rayon/src/iter/take_any_while.rs
new file mode 100644
index 0000000..e6a91af
--- /dev/null
+++ b/crates/rayon/src/iter/take_any_while.rs
@@ -0,0 +1,166 @@
+use super::plumbing::*;
+use super::*;
+use std::fmt;
+use std::sync::atomic::{AtomicBool, Ordering};
+
+/// `TakeAnyWhile` is an iterator that iterates over elements from anywhere in `I`
+/// until the callback returns `false`.
+/// This struct is created by the [`take_any_while()`] method on [`ParallelIterator`]
+///
+/// [`take_any_while()`]: trait.ParallelIterator.html#method.take_any_while
+/// [`ParallelIterator`]: trait.ParallelIterator.html
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Clone)]
+pub struct TakeAnyWhile<I: ParallelIterator, P> {
+    base: I,
+    predicate: P,
+}
+
+impl<I: ParallelIterator + fmt::Debug, P> fmt::Debug for TakeAnyWhile<I, P> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("TakeAnyWhile")
+            .field("base", &self.base)
+            .finish()
+    }
+}
+
+impl<I, P> TakeAnyWhile<I, P>
+where
+    I: ParallelIterator,
+{
+    /// Creates a new `TakeAnyWhile` iterator.
+    pub(super) fn new(base: I, predicate: P) -> Self {
+        TakeAnyWhile { base, predicate }
+    }
+}
+
+impl<I, P> ParallelIterator for TakeAnyWhile<I, P>
+where
+    I: ParallelIterator,
+    P: Fn(&I::Item) -> bool + Sync + Send,
+{
+    type Item = I::Item;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        let consumer1 = TakeAnyWhileConsumer {
+            base: consumer,
+            predicate: &self.predicate,
+            taking: &AtomicBool::new(true),
+        };
+        self.base.drive_unindexed(consumer1)
+    }
+}
+
+/// ////////////////////////////////////////////////////////////////////////
+/// Consumer implementation
+
+struct TakeAnyWhileConsumer<'p, C, P> {
+    base: C,
+    predicate: &'p P,
+    taking: &'p AtomicBool,
+}
+
+impl<'p, T, C, P> Consumer<T> for TakeAnyWhileConsumer<'p, C, P>
+where
+    C: Consumer<T>,
+    P: Fn(&T) -> bool + Sync,
+{
+    type Folder = TakeAnyWhileFolder<'p, C::Folder, P>;
+    type Reducer = C::Reducer;
+    type Result = C::Result;
+
+    fn split_at(self, index: usize) -> (Self, Self, Self::Reducer) {
+        let (left, right, reducer) = self.base.split_at(index);
+        (
+            TakeAnyWhileConsumer { base: left, ..self },
+            TakeAnyWhileConsumer {
+                base: right,
+                ..self
+            },
+            reducer,
+        )
+    }
+
+    fn into_folder(self) -> Self::Folder {
+        TakeAnyWhileFolder {
+            base: self.base.into_folder(),
+            predicate: self.predicate,
+            taking: self.taking,
+        }
+    }
+
+    fn full(&self) -> bool {
+        !self.taking.load(Ordering::Relaxed) || self.base.full()
+    }
+}
+
+impl<'p, T, C, P> UnindexedConsumer<T> for TakeAnyWhileConsumer<'p, C, P>
+where
+    C: UnindexedConsumer<T>,
+    P: Fn(&T) -> bool + Sync,
+{
+    fn split_off_left(&self) -> Self {
+        TakeAnyWhileConsumer {
+            base: self.base.split_off_left(),
+            ..*self
+        }
+    }
+
+    fn to_reducer(&self) -> Self::Reducer {
+        self.base.to_reducer()
+    }
+}
+
+struct TakeAnyWhileFolder<'p, C, P> {
+    base: C,
+    predicate: &'p P,
+    taking: &'p AtomicBool,
+}
+
+fn take<T>(item: &T, taking: &AtomicBool, predicate: &impl Fn(&T) -> bool) -> bool {
+    if !taking.load(Ordering::Relaxed) {
+        return false;
+    }
+    if predicate(item) {
+        return true;
+    }
+    taking.store(false, Ordering::Relaxed);
+    false
+}
+
+impl<'p, T, C, P> Folder<T> for TakeAnyWhileFolder<'p, C, P>
+where
+    C: Folder<T>,
+    P: Fn(&T) -> bool + 'p,
+{
+    type Result = C::Result;
+
+    fn consume(mut self, item: T) -> Self {
+        if take(&item, self.taking, self.predicate) {
+            self.base = self.base.consume(item);
+        }
+        self
+    }
+
+    fn consume_iter<I>(mut self, iter: I) -> Self
+    where
+        I: IntoIterator<Item = T>,
+    {
+        self.base = self.base.consume_iter(
+            iter.into_iter()
+                .take_while(move |x| take(x, self.taking, self.predicate)),
+        );
+        self
+    }
+
+    fn complete(self) -> C::Result {
+        self.base.complete()
+    }
+
+    fn full(&self) -> bool {
+        !self.taking.load(Ordering::Relaxed) || self.base.full()
+    }
+}
diff --git a/crates/rayon/src/iter/test.rs b/crates/rayon/src/iter/test.rs
new file mode 100644
index 0000000..45fb971
--- /dev/null
+++ b/crates/rayon/src/iter/test.rs
@@ -0,0 +1,2188 @@
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+use super::*;
+use crate::prelude::*;
+use rayon_core::*;
+
+use rand::distributions::Standard;
+use rand::{Rng, SeedableRng};
+use rand_xorshift::XorShiftRng;
+use std::collections::LinkedList;
+use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
+use std::collections::{BinaryHeap, VecDeque};
+use std::f64;
+use std::fmt::Debug;
+use std::sync::mpsc;
+use std::usize;
+
+fn is_indexed<T: IndexedParallelIterator>(_: T) {}
+
+fn seeded_rng() -> XorShiftRng {
+    let mut seed = <XorShiftRng as SeedableRng>::Seed::default();
+    (0..).zip(seed.as_mut()).for_each(|(i, x)| *x = i);
+    XorShiftRng::from_seed(seed)
+}
+
+#[test]
+fn execute() {
+    let a: Vec<i32> = (0..1024).collect();
+    let mut b = vec![];
+    a.par_iter().map(|&i| i + 1).collect_into_vec(&mut b);
+    let c: Vec<i32> = (0..1024).map(|i| i + 1).collect();
+    assert_eq!(b, c);
+}
+
+#[test]
+fn execute_cloned() {
+    let a: Vec<i32> = (0..1024).collect();
+    let mut b: Vec<i32> = vec![];
+    a.par_iter().cloned().collect_into_vec(&mut b);
+    let c: Vec<i32> = (0..1024).collect();
+    assert_eq!(b, c);
+}
+
+#[test]
+fn execute_range() {
+    let a = 0i32..1024;
+    let mut b = vec![];
+    a.into_par_iter().map(|i| i + 1).collect_into_vec(&mut b);
+    let c: Vec<i32> = (0..1024).map(|i| i + 1).collect();
+    assert_eq!(b, c);
+}
+
+#[test]
+fn execute_unindexed_range() {
+    let a = 0i64..1024;
+    let b: LinkedList<i64> = a.into_par_iter().map(|i| i + 1).collect();
+    let c: LinkedList<i64> = (0..1024).map(|i| i + 1).collect();
+    assert_eq!(b, c);
+}
+
+#[test]
+fn execute_pseudo_indexed_range() {
+    use std::i128::MAX;
+    let range = MAX - 1024..MAX;
+
+    // Given `Some` length, collecting `Vec` will try to act indexed.
+    let a = range.clone().into_par_iter();
+    assert_eq!(a.opt_len(), Some(1024));
+
+    let b: Vec<i128> = a.map(|i| i + 1).collect();
+    let c: Vec<i128> = range.map(|i| i + 1).collect();
+    assert_eq!(b, c);
+}
+
+#[test]
+fn check_map_indexed() {
+    let a = [1, 2, 3];
+    is_indexed(a.par_iter().map(|x| x));
+}
+
+#[test]
+fn map_sum() {
+    let a: Vec<i32> = (0..1024).collect();
+    let r1: i32 = a.par_iter().map(|&i| i + 1).sum();
+    let r2 = a.iter().map(|&i| i + 1).sum();
+    assert_eq!(r1, r2);
+}
+
+#[test]
+fn map_reduce() {
+    let a: Vec<i32> = (0..1024).collect();
+    let r1 = a.par_iter().map(|&i| i + 1).reduce(|| 0, |i, j| i + j);
+    let r2 = a.iter().map(|&i| i + 1).sum();
+    assert_eq!(r1, r2);
+}
+
+#[test]
+fn map_reduce_with() {
+    let a: Vec<i32> = (0..1024).collect();
+    let r1 = a.par_iter().map(|&i| i + 1).reduce_with(|i, j| i + j);
+    let r2 = a.iter().map(|&i| i + 1).sum();
+    assert_eq!(r1, Some(r2));
+}
+
+#[test]
+fn fold_map_reduce() {
+    // Kind of a weird test, but it demonstrates various
+    // transformations that are taking place. Relies on
+    // `with_max_len(1).fold()` being equivalent to `map()`.
+    //
+    // Take each number from 0 to 32 and fold them by appending to a
+    // vector.  Because of `with_max_len(1)`, this will produce 32 vectors,
+    // each with one item.  We then collect all of these into an
+    // individual vector by mapping each into their own vector (so we
+    // have Vec<Vec<i32>>) and then reducing those into a single
+    // vector.
+    let r1 = (0_i32..32)
+        .into_par_iter()
+        .with_max_len(1)
+        .fold(Vec::new, |mut v, e| {
+            v.push(e);
+            v
+        })
+        .map(|v| vec![v])
+        .reduce_with(|mut v_a, v_b| {
+            v_a.extend(v_b);
+            v_a
+        });
+    assert_eq!(
+        r1,
+        Some(vec![
+            vec![0],
+            vec![1],
+            vec![2],
+            vec![3],
+            vec![4],
+            vec![5],
+            vec![6],
+            vec![7],
+            vec![8],
+            vec![9],
+            vec![10],
+            vec![11],
+            vec![12],
+            vec![13],
+            vec![14],
+            vec![15],
+            vec![16],
+            vec![17],
+            vec![18],
+            vec![19],
+            vec![20],
+            vec![21],
+            vec![22],
+            vec![23],
+            vec![24],
+            vec![25],
+            vec![26],
+            vec![27],
+            vec![28],
+            vec![29],
+            vec![30],
+            vec![31]
+        ])
+    );
+}
+
+#[test]
+fn fold_is_full() {
+    let counter = AtomicUsize::new(0);
+    let a = (0_i32..2048)
+        .into_par_iter()
+        .inspect(|_| {
+            counter.fetch_add(1, Ordering::SeqCst);
+        })
+        .fold(|| 0, |a, b| a + b)
+        .find_any(|_| true);
+    assert!(a.is_some());
+    assert!(counter.load(Ordering::SeqCst) < 2048); // should not have visited every single one
+}
+
+#[test]
+fn check_step_by() {
+    let a: Vec<i32> = (0..1024).step_by(2).collect();
+    let b: Vec<i32> = (0..1024).into_par_iter().step_by(2).collect();
+
+    assert_eq!(a, b);
+}
+
+#[test]
+fn check_step_by_unaligned() {
+    let a: Vec<i32> = (0..1029).step_by(10).collect();
+    let b: Vec<i32> = (0..1029).into_par_iter().step_by(10).collect();
+
+    assert_eq!(a, b)
+}
+
+#[test]
+fn check_step_by_rev() {
+    let a: Vec<i32> = (0..1024).step_by(2).rev().collect();
+    let b: Vec<i32> = (0..1024).into_par_iter().step_by(2).rev().collect();
+
+    assert_eq!(a, b);
+}
+
+#[test]
+fn check_enumerate() {
+    let a: Vec<usize> = (0..1024).rev().collect();
+
+    let mut b = vec![];
+    a.par_iter()
+        .enumerate()
+        .map(|(i, &x)| i + x)
+        .collect_into_vec(&mut b);
+    assert!(b.iter().all(|&x| x == a.len() - 1));
+}
+
+#[test]
+fn check_enumerate_rev() {
+    let a: Vec<usize> = (0..1024).rev().collect();
+
+    let mut b = vec![];
+    a.par_iter()
+        .enumerate()
+        .rev()
+        .map(|(i, &x)| i + x)
+        .collect_into_vec(&mut b);
+    assert!(b.iter().all(|&x| x == a.len() - 1));
+}
+
+#[test]
+fn check_indices_after_enumerate_split() {
+    let a: Vec<i32> = (0..1024).collect();
+    a.par_iter().enumerate().with_producer(WithProducer);
+
+    struct WithProducer;
+    impl<'a> ProducerCallback<(usize, &'a i32)> for WithProducer {
+        type Output = ();
+        fn callback<P>(self, producer: P)
+        where
+            P: Producer<Item = (usize, &'a i32)>,
+        {
+            let (a, b) = producer.split_at(512);
+            for ((index, value), trusted_index) in a.into_iter().zip(0..) {
+                assert_eq!(index, trusted_index);
+                assert_eq!(index, *value as usize);
+            }
+            for ((index, value), trusted_index) in b.into_iter().zip(512..) {
+                assert_eq!(index, trusted_index);
+                assert_eq!(index, *value as usize);
+            }
+        }
+    }
+}
+
+#[test]
+fn check_increment() {
+    let mut a: Vec<usize> = (0..1024).rev().collect();
+
+    a.par_iter_mut().enumerate().for_each(|(i, v)| *v += i);
+
+    assert!(a.iter().all(|&x| x == a.len() - 1));
+}
+
+#[test]
+fn check_skip() {
+    let a: Vec<usize> = (0..1024).collect();
+
+    let mut v1 = Vec::new();
+    a.par_iter().skip(16).collect_into_vec(&mut v1);
+    let v2 = a.iter().skip(16).collect::<Vec<_>>();
+    assert_eq!(v1, v2);
+
+    let mut v1 = Vec::new();
+    a.par_iter().skip(2048).collect_into_vec(&mut v1);
+    let v2 = a.iter().skip(2048).collect::<Vec<_>>();
+    assert_eq!(v1, v2);
+
+    let mut v1 = Vec::new();
+    a.par_iter().skip(0).collect_into_vec(&mut v1);
+    let v2 = a.iter().skip(0).collect::<Vec<_>>();
+    assert_eq!(v1, v2);
+
+    // Check that the skipped elements side effects are executed
+    use std::sync::atomic::{AtomicUsize, Ordering};
+    let num = AtomicUsize::new(0);
+    a.par_iter()
+        .map(|&n| num.fetch_add(n, Ordering::Relaxed))
+        .skip(512)
+        .count();
+    assert_eq!(num.load(Ordering::Relaxed), a.iter().sum::<usize>());
+}
+
+#[test]
+fn check_take() {
+    let a: Vec<usize> = (0..1024).collect();
+
+    let mut v1 = Vec::new();
+    a.par_iter().take(16).collect_into_vec(&mut v1);
+    let v2 = a.iter().take(16).collect::<Vec<_>>();
+    assert_eq!(v1, v2);
+
+    let mut v1 = Vec::new();
+    a.par_iter().take(2048).collect_into_vec(&mut v1);
+    let v2 = a.iter().take(2048).collect::<Vec<_>>();
+    assert_eq!(v1, v2);
+
+    let mut v1 = Vec::new();
+    a.par_iter().take(0).collect_into_vec(&mut v1);
+    let v2 = a.iter().take(0).collect::<Vec<_>>();
+    assert_eq!(v1, v2);
+}
+
+#[test]
+fn check_inspect() {
+    use std::sync::atomic::{AtomicUsize, Ordering};
+
+    let a = AtomicUsize::new(0);
+    let b: usize = (0_usize..1024)
+        .into_par_iter()
+        .inspect(|&i| {
+            a.fetch_add(i, Ordering::Relaxed);
+        })
+        .sum();
+
+    assert_eq!(a.load(Ordering::Relaxed), b);
+}
+
+#[test]
+fn check_move() {
+    let a = vec![vec![1, 2, 3]];
+    let ptr = a[0].as_ptr();
+
+    let mut b = vec![];
+    a.into_par_iter().collect_into_vec(&mut b);
+
+    // a simple move means the inner vec will be completely unchanged
+    assert_eq!(ptr, b[0].as_ptr());
+}
+
+#[test]
+fn check_drops() {
+    use std::sync::atomic::{AtomicUsize, Ordering};
+
+    let c = AtomicUsize::new(0);
+    let a = vec![DropCounter(&c); 10];
+
+    let mut b = vec![];
+    a.clone().into_par_iter().collect_into_vec(&mut b);
+    assert_eq!(c.load(Ordering::Relaxed), 0);
+
+    b.into_par_iter();
+    assert_eq!(c.load(Ordering::Relaxed), 10);
+
+    a.into_par_iter().with_producer(Partial);
+    assert_eq!(c.load(Ordering::Relaxed), 20);
+
+    #[derive(Clone)]
+    struct DropCounter<'a>(&'a AtomicUsize);
+    impl<'a> Drop for DropCounter<'a> {
+        fn drop(&mut self) {
+            self.0.fetch_add(1, Ordering::Relaxed);
+        }
+    }
+
+    struct Partial;
+    impl<'a> ProducerCallback<DropCounter<'a>> for Partial {
+        type Output = ();
+        fn callback<P>(self, producer: P)
+        where
+            P: Producer<Item = DropCounter<'a>>,
+        {
+            let (a, _) = producer.split_at(5);
+            a.into_iter().next();
+        }
+    }
+}
+
+#[test]
+fn check_slice_indexed() {
+    let a = vec![1, 2, 3];
+    is_indexed(a.par_iter());
+}
+
+#[test]
+fn check_slice_mut_indexed() {
+    let mut a = vec![1, 2, 3];
+    is_indexed(a.par_iter_mut());
+}
+
+#[test]
+fn check_vec_indexed() {
+    let a = vec![1, 2, 3];
+    is_indexed(a.into_par_iter());
+}
+
+#[test]
+fn check_range_indexed() {
+    is_indexed((1..5).into_par_iter());
+}
+
+#[test]
+fn check_cmp_direct() {
+    let a = (0..1024).into_par_iter();
+    let b = (0..1024).into_par_iter();
+
+    let result = a.cmp(b);
+
+    assert!(result == ::std::cmp::Ordering::Equal);
+}
+
+#[test]
+fn check_cmp_to_seq() {
+    assert_eq!(
+        (0..1024).into_par_iter().cmp(0..1024),
+        (0..1024).cmp(0..1024)
+    );
+}
+
+#[test]
+fn check_cmp_rng_to_seq() {
+    let mut rng = seeded_rng();
+    let rng = &mut rng;
+    let a: Vec<i32> = rng.sample_iter(&Standard).take(1024).collect();
+    let b: Vec<i32> = rng.sample_iter(&Standard).take(1024).collect();
+    for i in 0..a.len() {
+        let par_result = a[i..].par_iter().cmp(b[i..].par_iter());
+        let seq_result = a[i..].iter().cmp(b[i..].iter());
+
+        assert_eq!(par_result, seq_result);
+    }
+}
+
+#[test]
+fn check_cmp_lt_direct() {
+    let a = (0..1024).into_par_iter();
+    let b = (1..1024).into_par_iter();
+
+    let result = a.cmp(b);
+
+    assert!(result == ::std::cmp::Ordering::Less);
+}
+
+#[test]
+fn check_cmp_lt_to_seq() {
+    assert_eq!(
+        (0..1024).into_par_iter().cmp(1..1024),
+        (0..1024).cmp(1..1024)
+    )
+}
+
+#[test]
+fn check_cmp_gt_direct() {
+    let a = (1..1024).into_par_iter();
+    let b = (0..1024).into_par_iter();
+
+    let result = a.cmp(b);
+
+    assert!(result == ::std::cmp::Ordering::Greater);
+}
+
+#[test]
+fn check_cmp_gt_to_seq() {
+    assert_eq!(
+        (1..1024).into_par_iter().cmp(0..1024),
+        (1..1024).cmp(0..1024)
+    )
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn check_cmp_short_circuit() {
+    // We only use a single thread in order to make the short-circuit behavior deterministic.
+    let pool = ThreadPoolBuilder::new().num_threads(1).build().unwrap();
+
+    let a = vec![0; 1024];
+    let mut b = a.clone();
+    b[42] = 1;
+
+    pool.install(|| {
+        let expected = ::std::cmp::Ordering::Less;
+        assert_eq!(a.par_iter().cmp(&b), expected);
+
+        for len in 1..10 {
+            let counter = AtomicUsize::new(0);
+            let result = a
+                .par_iter()
+                .with_max_len(len)
+                .inspect(|_| {
+                    counter.fetch_add(1, Ordering::SeqCst);
+                })
+                .cmp(&b);
+            assert_eq!(result, expected);
+            // should not have visited every single one
+            assert!(counter.into_inner() < a.len());
+        }
+    });
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn check_partial_cmp_short_circuit() {
+    // We only use a single thread to make the short-circuit behavior deterministic.
+    let pool = ThreadPoolBuilder::new().num_threads(1).build().unwrap();
+
+    let a = vec![0; 1024];
+    let mut b = a.clone();
+    b[42] = 1;
+
+    pool.install(|| {
+        let expected = Some(::std::cmp::Ordering::Less);
+        assert_eq!(a.par_iter().partial_cmp(&b), expected);
+
+        for len in 1..10 {
+            let counter = AtomicUsize::new(0);
+            let result = a
+                .par_iter()
+                .with_max_len(len)
+                .inspect(|_| {
+                    counter.fetch_add(1, Ordering::SeqCst);
+                })
+                .partial_cmp(&b);
+            assert_eq!(result, expected);
+            // should not have visited every single one
+            assert!(counter.into_inner() < a.len());
+        }
+    });
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn check_partial_cmp_nan_short_circuit() {
+    // We only use a single thread to make the short-circuit behavior deterministic.
+    let pool = ThreadPoolBuilder::new().num_threads(1).build().unwrap();
+
+    let a = vec![0.0; 1024];
+    let mut b = a.clone();
+    b[42] = f64::NAN;
+
+    pool.install(|| {
+        let expected = None;
+        assert_eq!(a.par_iter().partial_cmp(&b), expected);
+
+        for len in 1..10 {
+            let counter = AtomicUsize::new(0);
+            let result = a
+                .par_iter()
+                .with_max_len(len)
+                .inspect(|_| {
+                    counter.fetch_add(1, Ordering::SeqCst);
+                })
+                .partial_cmp(&b);
+            assert_eq!(result, expected);
+            // should not have visited every single one
+            assert!(counter.into_inner() < a.len());
+        }
+    });
+}
+
+#[test]
+fn check_partial_cmp_direct() {
+    let a = (0..1024).into_par_iter();
+    let b = (0..1024).into_par_iter();
+
+    let result = a.partial_cmp(b);
+
+    assert!(result == Some(::std::cmp::Ordering::Equal));
+}
+
+#[test]
+fn check_partial_cmp_to_seq() {
+    let par_result = (0..1024).into_par_iter().partial_cmp(0..1024);
+    let seq_result = (0..1024).partial_cmp(0..1024);
+    assert_eq!(par_result, seq_result);
+}
+
+#[test]
+fn check_partial_cmp_rng_to_seq() {
+    let mut rng = seeded_rng();
+    let rng = &mut rng;
+    let a: Vec<i32> = rng.sample_iter(&Standard).take(1024).collect();
+    let b: Vec<i32> = rng.sample_iter(&Standard).take(1024).collect();
+    for i in 0..a.len() {
+        let par_result = a[i..].par_iter().partial_cmp(b[i..].par_iter());
+        let seq_result = a[i..].iter().partial_cmp(b[i..].iter());
+
+        assert_eq!(par_result, seq_result);
+    }
+}
+
+#[test]
+fn check_partial_cmp_lt_direct() {
+    let a = (0..1024).into_par_iter();
+    let b = (1..1024).into_par_iter();
+
+    let result = a.partial_cmp(b);
+
+    assert!(result == Some(::std::cmp::Ordering::Less));
+}
+
+#[test]
+fn check_partial_cmp_lt_to_seq() {
+    let par_result = (0..1024).into_par_iter().partial_cmp(1..1024);
+    let seq_result = (0..1024).partial_cmp(1..1024);
+    assert_eq!(par_result, seq_result);
+}
+
+#[test]
+fn check_partial_cmp_gt_direct() {
+    let a = (1..1024).into_par_iter();
+    let b = (0..1024).into_par_iter();
+
+    let result = a.partial_cmp(b);
+
+    assert!(result == Some(::std::cmp::Ordering::Greater));
+}
+
+#[test]
+fn check_partial_cmp_gt_to_seq() {
+    let par_result = (1..1024).into_par_iter().partial_cmp(0..1024);
+    let seq_result = (1..1024).partial_cmp(0..1024);
+    assert_eq!(par_result, seq_result);
+}
+
+#[test]
+fn check_partial_cmp_none_direct() {
+    let a = vec![f64::NAN, 0.0];
+    let b = vec![0.0, 1.0];
+
+    let result = a.par_iter().partial_cmp(b.par_iter());
+
+    assert!(result == None);
+}
+
+#[test]
+fn check_partial_cmp_none_to_seq() {
+    let a = vec![f64::NAN, 0.0];
+    let b = vec![0.0, 1.0];
+
+    let par_result = a.par_iter().partial_cmp(b.par_iter());
+    let seq_result = a.iter().partial_cmp(b.iter());
+
+    assert_eq!(par_result, seq_result);
+}
+
+#[test]
+fn check_partial_cmp_late_nan_direct() {
+    let a = vec![0.0, f64::NAN];
+    let b = vec![1.0, 1.0];
+
+    let result = a.par_iter().partial_cmp(b.par_iter());
+
+    assert!(result == Some(::std::cmp::Ordering::Less));
+}
+
+#[test]
+fn check_partial_cmp_late_nan_to_seq() {
+    let a = vec![0.0, f64::NAN];
+    let b = vec![1.0, 1.0];
+
+    let par_result = a.par_iter().partial_cmp(b.par_iter());
+    let seq_result = a.iter().partial_cmp(b.iter());
+
+    assert_eq!(par_result, seq_result);
+}
+
+#[test]
+fn check_cmp_lengths() {
+    // comparisons should consider length if they are otherwise equal
+    let a = vec![0; 1024];
+    let b = vec![0; 1025];
+
+    assert_eq!(a.par_iter().cmp(&b), a.iter().cmp(&b));
+    assert_eq!(a.par_iter().partial_cmp(&b), a.iter().partial_cmp(&b));
+}
+
+#[test]
+fn check_eq_direct() {
+    let a = (0..1024).into_par_iter();
+    let b = (0..1024).into_par_iter();
+
+    let result = a.eq(b);
+
+    assert!(result);
+}
+
+#[test]
+fn check_eq_to_seq() {
+    let par_result = (0..1024).into_par_iter().eq((0..1024).into_par_iter());
+    let seq_result = (0..1024).eq(0..1024);
+
+    assert_eq!(par_result, seq_result);
+}
+
+#[test]
+fn check_ne_direct() {
+    let a = (0..1024).into_par_iter();
+    let b = (1..1024).into_par_iter();
+
+    let result = a.ne(b);
+
+    assert!(result);
+}
+
+#[test]
+fn check_ne_to_seq() {
+    let par_result = (0..1024).into_par_iter().ne((1..1025).into_par_iter());
+    let seq_result = (0..1024).ne(1..1025);
+
+    assert_eq!(par_result, seq_result);
+}
+
+#[test]
+fn check_ne_lengths() {
+    // equality should consider length too
+    let a = vec![0; 1024];
+    let b = vec![0; 1025];
+
+    assert_eq!(a.par_iter().eq(&b), a.iter().eq(&b));
+    assert_eq!(a.par_iter().ne(&b), a.iter().ne(&b));
+}
+
+#[test]
+fn check_lt_direct() {
+    assert!((0..1024).into_par_iter().lt(1..1024));
+    assert!(!(1..1024).into_par_iter().lt(0..1024));
+}
+
+#[test]
+fn check_lt_to_seq() {
+    let par_result = (0..1024).into_par_iter().lt((1..1024).into_par_iter());
+    let seq_result = (0..1024).lt(1..1024);
+
+    assert_eq!(par_result, seq_result);
+}
+
+#[test]
+fn check_le_equal_direct() {
+    assert!((0..1024).into_par_iter().le((0..1024).into_par_iter()));
+}
+
+#[test]
+fn check_le_equal_to_seq() {
+    let par_result = (0..1024).into_par_iter().le((0..1024).into_par_iter());
+    let seq_result = (0..1024).le(0..1024);
+
+    assert_eq!(par_result, seq_result);
+}
+
+#[test]
+fn check_le_less_direct() {
+    assert!((0..1024).into_par_iter().le((1..1024).into_par_iter()));
+}
+
+#[test]
+fn check_le_less_to_seq() {
+    let par_result = (0..1024).into_par_iter().le((1..1024).into_par_iter());
+    let seq_result = (0..1024).le(1..1024);
+
+    assert_eq!(par_result, seq_result);
+}
+
+#[test]
+fn check_gt_direct() {
+    assert!((1..1024).into_par_iter().gt((0..1024).into_par_iter()));
+}
+
+#[test]
+fn check_gt_to_seq() {
+    let par_result = (1..1024).into_par_iter().gt((0..1024).into_par_iter());
+    let seq_result = (1..1024).gt(0..1024);
+
+    assert_eq!(par_result, seq_result);
+}
+
+#[test]
+fn check_ge_equal_direct() {
+    assert!((0..1024).into_par_iter().ge((0..1024).into_par_iter()));
+}
+
+#[test]
+fn check_ge_equal_to_seq() {
+    let par_result = (0..1024).into_par_iter().ge((0..1024).into_par_iter());
+    let seq_result = (0..1024).ge(0..1024);
+
+    assert_eq!(par_result, seq_result);
+}
+
+#[test]
+fn check_ge_greater_direct() {
+    assert!((1..1024).into_par_iter().ge((0..1024).into_par_iter()));
+}
+
+#[test]
+fn check_ge_greater_to_seq() {
+    let par_result = (1..1024).into_par_iter().ge((0..1024).into_par_iter());
+    let seq_result = (1..1024).ge(0..1024);
+
+    assert_eq!(par_result, seq_result);
+}
+
+#[test]
+fn check_zip() {
+    let mut a: Vec<usize> = (0..1024).rev().collect();
+    let b: Vec<usize> = (0..1024).collect();
+
+    a.par_iter_mut().zip(&b[..]).for_each(|(a, &b)| *a += b);
+
+    assert!(a.iter().all(|&x| x == a.len() - 1));
+}
+
+#[test]
+fn check_zip_into_par_iter() {
+    let mut a: Vec<usize> = (0..1024).rev().collect();
+    let b: Vec<usize> = (0..1024).collect();
+
+    a.par_iter_mut()
+        .zip(&b) // here we rely on &b iterating over &usize
+        .for_each(|(a, &b)| *a += b);
+
+    assert!(a.iter().all(|&x| x == a.len() - 1));
+}
+
+#[test]
+fn check_zip_into_mut_par_iter() {
+    let a: Vec<usize> = (0..1024).rev().collect();
+    let mut b: Vec<usize> = (0..1024).collect();
+
+    a.par_iter().zip(&mut b).for_each(|(&a, b)| *b += a);
+
+    assert!(b.iter().all(|&x| x == b.len() - 1));
+}
+
+#[test]
+fn check_zip_range() {
+    let mut a: Vec<usize> = (0..1024).rev().collect();
+
+    a.par_iter_mut()
+        .zip(0usize..1024)
+        .for_each(|(a, b)| *a += b);
+
+    assert!(a.iter().all(|&x| x == a.len() - 1));
+}
+
+#[test]
+fn check_zip_eq() {
+    let mut a: Vec<usize> = (0..1024).rev().collect();
+    let b: Vec<usize> = (0..1024).collect();
+
+    a.par_iter_mut().zip_eq(&b[..]).for_each(|(a, &b)| *a += b);
+
+    assert!(a.iter().all(|&x| x == a.len() - 1));
+}
+
+#[test]
+fn check_zip_eq_into_par_iter() {
+    let mut a: Vec<usize> = (0..1024).rev().collect();
+    let b: Vec<usize> = (0..1024).collect();
+
+    a.par_iter_mut()
+        .zip_eq(&b) // here we rely on &b iterating over &usize
+        .for_each(|(a, &b)| *a += b);
+
+    assert!(a.iter().all(|&x| x == a.len() - 1));
+}
+
+#[test]
+fn check_zip_eq_into_mut_par_iter() {
+    let a: Vec<usize> = (0..1024).rev().collect();
+    let mut b: Vec<usize> = (0..1024).collect();
+
+    a.par_iter().zip_eq(&mut b).for_each(|(&a, b)| *b += a);
+
+    assert!(b.iter().all(|&x| x == b.len() - 1));
+}
+
+#[test]
+fn check_zip_eq_range() {
+    let mut a: Vec<usize> = (0..1024).rev().collect();
+
+    a.par_iter_mut()
+        .zip_eq(0usize..1024)
+        .for_each(|(a, b)| *a += b);
+
+    assert!(a.iter().all(|&x| x == a.len() - 1));
+}
+
+#[test]
+fn check_sum_filtered_ints() {
+    let a: Vec<i32> = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    let par_sum_evens: i32 = a.par_iter().filter(|&x| (x & 1) == 0).sum();
+    let seq_sum_evens = a.iter().filter(|&x| (x & 1) == 0).sum();
+    assert_eq!(par_sum_evens, seq_sum_evens);
+}
+
+#[test]
+fn check_sum_filtermap_ints() {
+    let a: Vec<i32> = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    let par_sum_evens: u32 = a
+        .par_iter()
+        .filter_map(|&x| if (x & 1) == 0 { Some(x as u32) } else { None })
+        .sum();
+    let seq_sum_evens = a
+        .iter()
+        .filter_map(|&x| if (x & 1) == 0 { Some(x as u32) } else { None })
+        .sum();
+    assert_eq!(par_sum_evens, seq_sum_evens);
+}
+
+#[test]
+fn check_flat_map_nested_ranges() {
+    // FIXME -- why are precise type hints required on the integers here?
+
+    let v: i32 = (0_i32..10)
+        .into_par_iter()
+        .flat_map(|i| (0_i32..10).into_par_iter().map(move |j| (i, j)))
+        .map(|(i, j)| i * j)
+        .sum();
+
+    let w = (0_i32..10)
+        .flat_map(|i| (0_i32..10).map(move |j| (i, j)))
+        .map(|(i, j)| i * j)
+        .sum();
+
+    assert_eq!(v, w);
+}
+
+#[test]
+fn check_empty_flat_map_sum() {
+    let a: Vec<i32> = (0..1024).collect();
+    let empty = &a[..0];
+
+    // empty on the inside
+    let b: i32 = a.par_iter().flat_map(|_| empty).sum();
+    assert_eq!(b, 0);
+
+    // empty on the outside
+    let c: i32 = empty.par_iter().flat_map(|_| a.par_iter()).sum();
+    assert_eq!(c, 0);
+}
+
+#[test]
+fn check_flatten_vec() {
+    let a: Vec<i32> = (0..1024).collect();
+    let b: Vec<Vec<i32>> = vec![a.clone(), a.clone(), a.clone(), a.clone()];
+    let c: Vec<i32> = b.par_iter().flatten().cloned().collect();
+    let mut d = a.clone();
+    d.extend(&a);
+    d.extend(&a);
+    d.extend(&a);
+
+    assert_eq!(d, c);
+}
+
+#[test]
+fn check_flatten_vec_empty() {
+    let a: Vec<Vec<i32>> = vec![vec![]];
+    let b: Vec<i32> = a.par_iter().flatten().cloned().collect();
+
+    assert_eq!(vec![] as Vec<i32>, b);
+}
+
+#[test]
+fn check_slice_split() {
+    let v: Vec<_> = (0..1000).collect();
+    for m in 1..100 {
+        let a: Vec<_> = v.split(|x| x % m == 0).collect();
+        let b: Vec<_> = v.par_split(|x| x % m == 0).collect();
+        assert_eq!(a, b);
+    }
+
+    // same as std::slice::split() examples
+    let slice = [10, 40, 33, 20];
+    let v: Vec<_> = slice.par_split(|num| num % 3 == 0).collect();
+    assert_eq!(v, &[&slice[..2], &slice[3..]]);
+
+    let slice = [10, 40, 33];
+    let v: Vec<_> = slice.par_split(|num| num % 3 == 0).collect();
+    assert_eq!(v, &[&slice[..2], &slice[..0]]);
+
+    let slice = [10, 6, 33, 20];
+    let v: Vec<_> = slice.par_split(|num| num % 3 == 0).collect();
+    assert_eq!(v, &[&slice[..1], &slice[..0], &slice[3..]]);
+}
+
+#[test]
+fn check_slice_split_mut() {
+    let mut v1: Vec<_> = (0..1000).collect();
+    let mut v2 = v1.clone();
+    for m in 1..100 {
+        let a: Vec<_> = v1.split_mut(|x| x % m == 0).collect();
+        let b: Vec<_> = v2.par_split_mut(|x| x % m == 0).collect();
+        assert_eq!(a, b);
+    }
+
+    // same as std::slice::split_mut() example
+    let mut v = [10, 40, 30, 20, 60, 50];
+    v.par_split_mut(|num| num % 3 == 0).for_each(|group| {
+        group[0] = 1;
+    });
+    assert_eq!(v, [1, 40, 30, 1, 60, 1]);
+}
+
+#[test]
+fn check_chunks() {
+    let a: Vec<i32> = vec![1, 5, 10, 4, 100, 3, 1000, 2, 10000, 1];
+    let par_sum_product_pairs: i32 = a.par_chunks(2).map(|c| c.iter().product::<i32>()).sum();
+    let seq_sum_product_pairs = a.chunks(2).map(|c| c.iter().product::<i32>()).sum();
+    assert_eq!(par_sum_product_pairs, 12345);
+    assert_eq!(par_sum_product_pairs, seq_sum_product_pairs);
+
+    let par_sum_product_triples: i32 = a.par_chunks(3).map(|c| c.iter().product::<i32>()).sum();
+    let seq_sum_product_triples = a.chunks(3).map(|c| c.iter().product::<i32>()).sum();
+    assert_eq!(par_sum_product_triples, 5_0 + 12_00 + 20_000_000 + 1);
+    assert_eq!(par_sum_product_triples, seq_sum_product_triples);
+}
+
+#[test]
+fn check_chunks_mut() {
+    let mut a: Vec<i32> = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    let mut b: Vec<i32> = a.clone();
+    a.par_chunks_mut(2).for_each(|c| c[0] = c.iter().sum());
+    b.chunks_mut(2).for_each(|c| c[0] = c.iter().sum());
+    assert_eq!(a, &[3, 2, 7, 4, 11, 6, 15, 8, 19, 10]);
+    assert_eq!(a, b);
+
+    let mut a: Vec<i32> = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    let mut b: Vec<i32> = a.clone();
+    a.par_chunks_mut(3).for_each(|c| c[0] = c.iter().sum());
+    b.chunks_mut(3).for_each(|c| c[0] = c.iter().sum());
+    assert_eq!(a, &[6, 2, 3, 15, 5, 6, 24, 8, 9, 10]);
+    assert_eq!(a, b);
+}
+
+#[test]
+fn check_windows() {
+    let a: Vec<i32> = (0..1024).collect();
+    let par: Vec<_> = a.par_windows(2).collect();
+    let seq: Vec<_> = a.windows(2).collect();
+    assert_eq!(par, seq);
+
+    let par: Vec<_> = a.par_windows(100).collect();
+    let seq: Vec<_> = a.windows(100).collect();
+    assert_eq!(par, seq);
+
+    let par: Vec<_> = a.par_windows(1_000_000).collect();
+    let seq: Vec<_> = a.windows(1_000_000).collect();
+    assert_eq!(par, seq);
+
+    let par: Vec<_> = a
+        .par_windows(2)
+        .chain(a.par_windows(1_000_000))
+        .zip(a.par_windows(2))
+        .collect();
+    let seq: Vec<_> = a
+        .windows(2)
+        .chain(a.windows(1_000_000))
+        .zip(a.windows(2))
+        .collect();
+    assert_eq!(par, seq);
+}
+
+#[test]
+fn check_options() {
+    let mut a = vec![None, Some(1), None, None, Some(2), Some(4)];
+
+    assert_eq!(7, a.par_iter().flat_map(|opt| opt).sum::<i32>());
+    assert_eq!(7, a.par_iter().flat_map(|opt| opt).sum::<i32>());
+
+    a.par_iter_mut()
+        .flat_map(|opt| opt)
+        .for_each(|x| *x = *x * *x);
+
+    assert_eq!(21, a.into_par_iter().flat_map(|opt| opt).sum::<i32>());
+}
+
+#[test]
+fn check_results() {
+    let mut a = vec![Err(()), Ok(1i32), Err(()), Err(()), Ok(2), Ok(4)];
+
+    assert_eq!(7, a.par_iter().flat_map(|res| res).sum::<i32>());
+
+    assert_eq!(Err::<i32, ()>(()), a.par_iter().cloned().sum());
+    assert_eq!(Ok(7), a.par_iter().cloned().filter(Result::is_ok).sum());
+
+    assert_eq!(Err::<i32, ()>(()), a.par_iter().cloned().product());
+    assert_eq!(Ok(8), a.par_iter().cloned().filter(Result::is_ok).product());
+
+    a.par_iter_mut()
+        .flat_map(|res| res)
+        .for_each(|x| *x = *x * *x);
+
+    assert_eq!(21, a.into_par_iter().flat_map(|res| res).sum::<i32>());
+}
+
+#[test]
+fn check_binary_heap() {
+    use std::collections::BinaryHeap;
+
+    let a: BinaryHeap<i32> = (0..10).collect();
+
+    assert_eq!(45, a.par_iter().sum::<i32>());
+    assert_eq!(45, a.into_par_iter().sum::<i32>());
+}
+
+#[test]
+fn check_btree_map() {
+    use std::collections::BTreeMap;
+
+    let mut a: BTreeMap<i32, i32> = (0..10).map(|i| (i, -i)).collect();
+
+    assert_eq!(45, a.par_iter().map(|(&k, _)| k).sum::<i32>());
+    assert_eq!(-45, a.par_iter().map(|(_, &v)| v).sum::<i32>());
+
+    a.par_iter_mut().for_each(|(k, v)| *v += *k);
+
+    assert_eq!(0, a.into_par_iter().map(|(_, v)| v).sum::<i32>());
+}
+
+#[test]
+fn check_btree_set() {
+    use std::collections::BTreeSet;
+
+    let a: BTreeSet<i32> = (0..10).collect();
+
+    assert_eq!(45, a.par_iter().sum::<i32>());
+    assert_eq!(45, a.into_par_iter().sum::<i32>());
+}
+
+#[test]
+fn check_hash_map() {
+    use std::collections::HashMap;
+
+    let mut a: HashMap<i32, i32> = (0..10).map(|i| (i, -i)).collect();
+
+    assert_eq!(45, a.par_iter().map(|(&k, _)| k).sum::<i32>());
+    assert_eq!(-45, a.par_iter().map(|(_, &v)| v).sum::<i32>());
+
+    a.par_iter_mut().for_each(|(k, v)| *v += *k);
+
+    assert_eq!(0, a.into_par_iter().map(|(_, v)| v).sum::<i32>());
+}
+
+#[test]
+fn check_hash_set() {
+    use std::collections::HashSet;
+
+    let a: HashSet<i32> = (0..10).collect();
+
+    assert_eq!(45, a.par_iter().sum::<i32>());
+    assert_eq!(45, a.into_par_iter().sum::<i32>());
+}
+
+#[test]
+fn check_linked_list() {
+    use std::collections::LinkedList;
+
+    let mut a: LinkedList<i32> = (0..10).collect();
+
+    assert_eq!(45, a.par_iter().sum::<i32>());
+
+    a.par_iter_mut().for_each(|x| *x = -*x);
+
+    assert_eq!(-45, a.into_par_iter().sum::<i32>());
+}
+
+#[test]
+fn check_vec_deque() {
+    use std::collections::VecDeque;
+
+    let mut a: VecDeque<i32> = (0..10).collect();
+
+    // try to get it to wrap around
+    a.drain(..5);
+    a.extend(0..5);
+
+    assert_eq!(45, a.par_iter().sum::<i32>());
+
+    a.par_iter_mut().for_each(|x| *x = -*x);
+
+    assert_eq!(-45, a.into_par_iter().sum::<i32>());
+}
+
+#[test]
+fn check_chain() {
+    let mut res = vec![];
+
+    // stays indexed in the face of madness
+    Some(0)
+        .into_par_iter()
+        .chain(Ok::<_, ()>(1))
+        .chain(1..4)
+        .chain(Err("huh?"))
+        .chain(None)
+        .chain(vec![5, 8, 13])
+        .map(|x| (x as u8 + b'a') as char)
+        .chain(vec!['x', 'y', 'z'])
+        .zip((0i32..1000).into_par_iter().map(|x| -x))
+        .enumerate()
+        .map(|(a, (b, c))| (a, b, c))
+        .chain(None)
+        .collect_into_vec(&mut res);
+
+    assert_eq!(
+        res,
+        vec![
+            (0, 'a', 0),
+            (1, 'b', -1),
+            (2, 'b', -2),
+            (3, 'c', -3),
+            (4, 'd', -4),
+            (5, 'f', -5),
+            (6, 'i', -6),
+            (7, 'n', -7),
+            (8, 'x', -8),
+            (9, 'y', -9),
+            (10, 'z', -10)
+        ]
+    );
+
+    // unindexed is ok too
+    let res: Vec<i32> = Some(1i32)
+        .into_par_iter()
+        .chain(
+            (2i32..4)
+                .into_par_iter()
+                .chain(vec![5, 6, 7, 8, 9])
+                .chain(Some((10, 100)).into_par_iter().flat_map(|(a, b)| a..b))
+                .filter(|x| x & 1 == 1),
+        )
+        .collect();
+    let other: Vec<i32> = (0..100).filter(|x| x & 1 == 1).collect();
+    assert_eq!(res, other);
+
+    // chain collect is ok with the "fake" specialization
+    let res: Vec<i32> = Some(1i32).into_par_iter().chain(None).collect();
+    assert_eq!(res, &[1]);
+}
+
+#[test]
+fn check_count() {
+    let c0 = (0_u32..24 * 1024).filter(|i| i % 2 == 0).count();
+    let c1 = (0_u32..24 * 1024)
+        .into_par_iter()
+        .filter(|i| i % 2 == 0)
+        .count();
+    assert_eq!(c0, c1);
+}
+
+#[test]
+fn find_any() {
+    let a: Vec<i32> = (0..1024).collect();
+
+    assert!(a.par_iter().find_any(|&&x| x % 42 == 41).is_some());
+    assert_eq!(
+        a.par_iter().find_any(|&&x| x % 19 == 1 && x % 53 == 0),
+        Some(&742_i32)
+    );
+    assert_eq!(a.par_iter().find_any(|&&x| x < 0), None);
+
+    assert!(a.par_iter().position_any(|&x| x % 42 == 41).is_some());
+    assert_eq!(
+        a.par_iter().position_any(|&x| x % 19 == 1 && x % 53 == 0),
+        Some(742_usize)
+    );
+    assert_eq!(a.par_iter().position_any(|&x| x < 0), None);
+
+    assert!(a.par_iter().any(|&x| x > 1000));
+    assert!(!a.par_iter().any(|&x| x < 0));
+
+    assert!(!a.par_iter().all(|&x| x > 1000));
+    assert!(a.par_iter().all(|&x| x >= 0));
+}
+
+#[test]
+fn find_first_or_last() {
+    let a: Vec<i32> = (0..1024).collect();
+
+    assert_eq!(a.par_iter().find_first(|&&x| x % 42 == 41), Some(&41_i32));
+    assert_eq!(
+        a.par_iter().find_first(|&&x| x % 19 == 1 && x % 53 == 0),
+        Some(&742_i32)
+    );
+    assert_eq!(a.par_iter().find_first(|&&x| x < 0), None);
+
+    assert_eq!(
+        a.par_iter().position_first(|&x| x % 42 == 41),
+        Some(41_usize)
+    );
+    assert_eq!(
+        a.par_iter().position_first(|&x| x % 19 == 1 && x % 53 == 0),
+        Some(742_usize)
+    );
+    assert_eq!(a.par_iter().position_first(|&x| x < 0), None);
+
+    assert_eq!(a.par_iter().find_last(|&&x| x % 42 == 41), Some(&1007_i32));
+    assert_eq!(
+        a.par_iter().find_last(|&&x| x % 19 == 1 && x % 53 == 0),
+        Some(&742_i32)
+    );
+    assert_eq!(a.par_iter().find_last(|&&x| x < 0), None);
+
+    assert_eq!(
+        a.par_iter().position_last(|&x| x % 42 == 41),
+        Some(1007_usize)
+    );
+    assert_eq!(
+        a.par_iter().position_last(|&x| x % 19 == 1 && x % 53 == 0),
+        Some(742_usize)
+    );
+    assert_eq!(a.par_iter().position_last(|&x| x < 0), None);
+}
+
+#[test]
+fn find_map_first_or_last_or_any() {
+    let mut a: Vec<i32> = vec![];
+
+    assert!(a.par_iter().find_map_any(half_if_positive).is_none());
+    assert!(a.par_iter().find_map_first(half_if_positive).is_none());
+    assert!(a.par_iter().find_map_last(half_if_positive).is_none());
+
+    a = (-1024..-3).collect();
+
+    assert!(a.par_iter().find_map_any(half_if_positive).is_none());
+    assert!(a.par_iter().find_map_first(half_if_positive).is_none());
+    assert!(a.par_iter().find_map_last(half_if_positive).is_none());
+
+    assert!(a.par_iter().find_map_any(half_if_negative).is_some());
+    assert_eq!(
+        a.par_iter().find_map_first(half_if_negative),
+        Some(-512_i32)
+    );
+    assert_eq!(a.par_iter().find_map_last(half_if_negative), Some(-2_i32));
+
+    a.append(&mut (2..1025).collect());
+
+    assert!(a.par_iter().find_map_any(half_if_positive).is_some());
+    assert_eq!(a.par_iter().find_map_first(half_if_positive), Some(1_i32));
+    assert_eq!(a.par_iter().find_map_last(half_if_positive), Some(512_i32));
+
+    fn half_if_positive(x: &i32) -> Option<i32> {
+        if *x > 0 {
+            Some(x / 2)
+        } else {
+            None
+        }
+    }
+
+    fn half_if_negative(x: &i32) -> Option<i32> {
+        if *x < 0 {
+            Some(x / 2)
+        } else {
+            None
+        }
+    }
+}
+
+#[test]
+fn check_find_not_present() {
+    let counter = AtomicUsize::new(0);
+    let value: Option<i32> = (0_i32..2048).into_par_iter().find_any(|&p| {
+        counter.fetch_add(1, Ordering::SeqCst);
+        p >= 2048
+    });
+    assert!(value.is_none());
+    assert!(counter.load(Ordering::SeqCst) == 2048); // should have visited every single one
+}
+
+#[test]
+fn check_find_is_present() {
+    let counter = AtomicUsize::new(0);
+    let value: Option<i32> = (0_i32..2048).into_par_iter().find_any(|&p| {
+        counter.fetch_add(1, Ordering::SeqCst);
+        (1024..1096).contains(&p)
+    });
+    let q = value.unwrap();
+    assert!((1024..1096).contains(&q));
+    assert!(counter.load(Ordering::SeqCst) < 2048); // should not have visited every single one
+}
+
+#[test]
+fn check_while_some() {
+    let value = (0_i32..2048).into_par_iter().map(Some).while_some().max();
+    assert_eq!(value, Some(2047));
+
+    let counter = AtomicUsize::new(0);
+    let value = (0_i32..2048)
+        .into_par_iter()
+        .map(|x| {
+            counter.fetch_add(1, Ordering::SeqCst);
+            if x < 1024 {
+                Some(x)
+            } else {
+                None
+            }
+        })
+        .while_some()
+        .max();
+    assert!(value < Some(1024));
+    assert!(counter.load(Ordering::SeqCst) < 2048); // should not have visited every single one
+}
+
+#[test]
+fn par_iter_collect_option() {
+    let a: Option<Vec<_>> = (0_i32..2048).map(Some).collect();
+    let b: Option<Vec<_>> = (0_i32..2048).into_par_iter().map(Some).collect();
+    assert_eq!(a, b);
+
+    let c: Option<Vec<_>> = (0_i32..2048)
+        .into_par_iter()
+        .map(|x| if x == 1234 { None } else { Some(x) })
+        .collect();
+    assert_eq!(c, None);
+}
+
+#[test]
+fn par_iter_collect_result() {
+    let a: Result<Vec<_>, ()> = (0_i32..2048).map(Ok).collect();
+    let b: Result<Vec<_>, ()> = (0_i32..2048).into_par_iter().map(Ok).collect();
+    assert_eq!(a, b);
+
+    let c: Result<Vec<_>, _> = (0_i32..2048)
+        .into_par_iter()
+        .map(|x| if x == 1234 { Err(x) } else { Ok(x) })
+        .collect();
+    assert_eq!(c, Err(1234));
+
+    let d: Result<Vec<_>, _> = (0_i32..2048)
+        .into_par_iter()
+        .map(|x| if x % 100 == 99 { Err(x) } else { Ok(x) })
+        .collect();
+    assert_eq!(d.map_err(|x| x % 100), Err(99));
+}
+
+#[test]
+fn par_iter_collect() {
+    let a: Vec<i32> = (0..1024).collect();
+    let b: Vec<i32> = a.par_iter().map(|&i| i + 1).collect();
+    let c: Vec<i32> = (0..1024).map(|i| i + 1).collect();
+    assert_eq!(b, c);
+}
+
+#[test]
+fn par_iter_collect_vecdeque() {
+    let a: Vec<i32> = (0..1024).collect();
+    let b: VecDeque<i32> = a.par_iter().cloned().collect();
+    let c: VecDeque<i32> = a.iter().cloned().collect();
+    assert_eq!(b, c);
+}
+
+#[test]
+fn par_iter_collect_binaryheap() {
+    let a: Vec<i32> = (0..1024).collect();
+    let mut b: BinaryHeap<i32> = a.par_iter().cloned().collect();
+    assert_eq!(b.peek(), Some(&1023));
+    assert_eq!(b.len(), 1024);
+    for n in (0..1024).rev() {
+        assert_eq!(b.pop(), Some(n));
+        assert_eq!(b.len() as i32, n);
+    }
+}
+
+#[test]
+fn par_iter_collect_hashmap() {
+    let a: Vec<i32> = (0..1024).collect();
+    let b: HashMap<i32, String> = a.par_iter().map(|&i| (i, format!("{}", i))).collect();
+    assert_eq!(&b[&3], "3");
+    assert_eq!(b.len(), 1024);
+}
+
+#[test]
+fn par_iter_collect_hashset() {
+    let a: Vec<i32> = (0..1024).collect();
+    let b: HashSet<i32> = a.par_iter().cloned().collect();
+    assert_eq!(b.len(), 1024);
+}
+
+#[test]
+fn par_iter_collect_btreemap() {
+    let a: Vec<i32> = (0..1024).collect();
+    let b: BTreeMap<i32, String> = a.par_iter().map(|&i| (i, format!("{}", i))).collect();
+    assert_eq!(&b[&3], "3");
+    assert_eq!(b.len(), 1024);
+}
+
+#[test]
+fn par_iter_collect_btreeset() {
+    let a: Vec<i32> = (0..1024).collect();
+    let b: BTreeSet<i32> = a.par_iter().cloned().collect();
+    assert_eq!(b.len(), 1024);
+}
+
+#[test]
+fn par_iter_collect_linked_list() {
+    let a: Vec<i32> = (0..1024).collect();
+    let b: LinkedList<_> = a.par_iter().map(|&i| (i, format!("{}", i))).collect();
+    let c: LinkedList<_> = a.iter().map(|&i| (i, format!("{}", i))).collect();
+    assert_eq!(b, c);
+}
+
+#[test]
+fn par_iter_collect_linked_list_flat_map_filter() {
+    let b: LinkedList<i32> = (0_i32..1024)
+        .into_par_iter()
+        .flat_map(|i| (0..i))
+        .filter(|&i| i % 2 == 0)
+        .collect();
+    let c: LinkedList<i32> = (0_i32..1024)
+        .flat_map(|i| (0..i))
+        .filter(|&i| i % 2 == 0)
+        .collect();
+    assert_eq!(b, c);
+}
+
+#[test]
+fn par_iter_collect_cows() {
+    use std::borrow::Cow;
+
+    let s = "Fearless Concurrency with Rust";
+
+    // Collects `i32` into a `Vec`
+    let a: Cow<'_, [i32]> = (0..1024).collect();
+    let b: Cow<'_, [i32]> = a.par_iter().cloned().collect();
+    assert_eq!(a, b);
+
+    // Collects `char` into a `String`
+    let a: Cow<'_, str> = s.chars().collect();
+    let b: Cow<'_, str> = s.par_chars().collect();
+    assert_eq!(a, b);
+
+    // Collects `str` into a `String`
+    let a: Cow<'_, str> = s.split_whitespace().collect();
+    let b: Cow<'_, str> = s.par_split_whitespace().collect();
+    assert_eq!(a, b);
+
+    // Collects `String` into a `String`
+    let a: Cow<'_, str> = s.split_whitespace().map(str::to_owned).collect();
+    let b: Cow<'_, str> = s.par_split_whitespace().map(str::to_owned).collect();
+    assert_eq!(a, b);
+}
+
+#[test]
+fn par_iter_unindexed_flat_map() {
+    let b: Vec<i64> = (0_i64..1024).into_par_iter().flat_map(Some).collect();
+    let c: Vec<i64> = (0_i64..1024).flat_map(Some).collect();
+    assert_eq!(b, c);
+}
+
+#[test]
+fn min_max() {
+    let rng = seeded_rng();
+    let a: Vec<i32> = rng.sample_iter(&Standard).take(1024).collect();
+    for i in 0..=a.len() {
+        let slice = &a[..i];
+        assert_eq!(slice.par_iter().min(), slice.iter().min());
+        assert_eq!(slice.par_iter().max(), slice.iter().max());
+    }
+}
+
+#[test]
+fn min_max_by() {
+    let rng = seeded_rng();
+    // Make sure there are duplicate keys, for testing sort stability
+    let r: Vec<i32> = rng.sample_iter(&Standard).take(512).collect();
+    let a: Vec<(i32, u16)> = r.iter().chain(&r).cloned().zip(0..).collect();
+    for i in 0..=a.len() {
+        let slice = &a[..i];
+        assert_eq!(
+            slice.par_iter().min_by(|x, y| x.0.cmp(&y.0)),
+            slice.iter().min_by(|x, y| x.0.cmp(&y.0))
+        );
+        assert_eq!(
+            slice.par_iter().max_by(|x, y| x.0.cmp(&y.0)),
+            slice.iter().max_by(|x, y| x.0.cmp(&y.0))
+        );
+    }
+}
+
+#[test]
+fn min_max_by_key() {
+    let rng = seeded_rng();
+    // Make sure there are duplicate keys, for testing sort stability
+    let r: Vec<i32> = rng.sample_iter(&Standard).take(512).collect();
+    let a: Vec<(i32, u16)> = r.iter().chain(&r).cloned().zip(0..).collect();
+    for i in 0..=a.len() {
+        let slice = &a[..i];
+        assert_eq!(
+            slice.par_iter().min_by_key(|x| x.0),
+            slice.iter().min_by_key(|x| x.0)
+        );
+        assert_eq!(
+            slice.par_iter().max_by_key(|x| x.0),
+            slice.iter().max_by_key(|x| x.0)
+        );
+    }
+}
+
+#[test]
+fn check_rev() {
+    let a: Vec<usize> = (0..1024).rev().collect();
+    let b: Vec<usize> = (0..1024).collect();
+
+    assert!(a.par_iter().rev().zip(b).all(|(&a, b)| a == b));
+}
+
+#[test]
+fn scope_mix() {
+    let counter_p = &AtomicUsize::new(0);
+    scope(|s| {
+        s.spawn(move |s| {
+            divide_and_conquer(s, counter_p, 1024);
+        });
+        s.spawn(move |_| {
+            let a: Vec<i32> = (0..1024).collect();
+            let r1 = a.par_iter().map(|&i| i + 1).reduce_with(|i, j| i + j);
+            let r2 = a.iter().map(|&i| i + 1).sum();
+            assert_eq!(r1.unwrap(), r2);
+        });
+    });
+}
+
+fn divide_and_conquer<'scope>(scope: &Scope<'scope>, counter: &'scope AtomicUsize, size: usize) {
+    if size > 1 {
+        scope.spawn(move |scope| divide_and_conquer(scope, counter, size / 2));
+        scope.spawn(move |scope| divide_and_conquer(scope, counter, size / 2));
+    } else {
+        // count the leaves
+        counter.fetch_add(1, Ordering::SeqCst);
+    }
+}
+
+#[test]
+fn check_split() {
+    use std::ops::Range;
+
+    let a = (0..1024).into_par_iter();
+
+    let b = split(0..1024, |Range { start, end }| {
+        let mid = (end - start) / 2;
+        if mid > start {
+            (start..mid, Some(mid..end))
+        } else {
+            (start..end, None)
+        }
+    })
+    .flat_map(|range| range);
+
+    assert_eq!(a.collect::<Vec<_>>(), b.collect::<Vec<_>>());
+}
+
+#[test]
+fn check_lengths() {
+    fn check(min: usize, max: usize) {
+        let range = 0..1024 * 1024;
+
+        // Check against normalized values.
+        let min_check = cmp::min(cmp::max(min, 1), range.len());
+        let max_check = cmp::max(max, min_check.saturating_add(min_check - 1));
+
+        assert!(
+            range
+                .into_par_iter()
+                .with_min_len(min)
+                .with_max_len(max)
+                .fold(|| 0, |count, _| count + 1)
+                .all(|c| c >= min_check && c <= max_check),
+            "check_lengths failed {:?} -> {:?} ",
+            (min, max),
+            (min_check, max_check)
+        );
+    }
+
+    let lengths = [0, 1, 10, 100, 1_000, 10_000, 100_000, 1_000_000, usize::MAX];
+    for &min in &lengths {
+        for &max in &lengths {
+            check(min, max);
+        }
+    }
+}
+
+#[test]
+fn check_map_with() {
+    let (sender, receiver) = mpsc::channel();
+    let a: HashSet<_> = (0..1024).collect();
+
+    a.par_iter()
+        .cloned()
+        .map_with(sender, |s, i| s.send(i).unwrap())
+        .count();
+
+    let b: HashSet<_> = receiver.iter().collect();
+    assert_eq!(a, b);
+}
+
+#[test]
+fn check_fold_with() {
+    let (sender, receiver) = mpsc::channel();
+    let a: HashSet<_> = (0..1024).collect();
+
+    a.par_iter()
+        .cloned()
+        .fold_with(sender, |s, i| {
+            s.send(i).unwrap();
+            s
+        })
+        .count();
+
+    let b: HashSet<_> = receiver.iter().collect();
+    assert_eq!(a, b);
+}
+
+#[test]
+fn check_for_each_with() {
+    let (sender, receiver) = mpsc::channel();
+    let a: HashSet<_> = (0..1024).collect();
+
+    a.par_iter()
+        .cloned()
+        .for_each_with(sender, |s, i| s.send(i).unwrap());
+
+    let b: HashSet<_> = receiver.iter().collect();
+    assert_eq!(a, b);
+}
+
+#[test]
+fn check_extend_items() {
+    fn check<C>()
+    where
+        C: Default
+            + Eq
+            + Debug
+            + Extend<i32>
+            + for<'a> Extend<&'a i32>
+            + ParallelExtend<i32>
+            + for<'a> ParallelExtend<&'a i32>,
+    {
+        let mut serial = C::default();
+        let mut parallel = C::default();
+
+        // extend with references
+        let v: Vec<_> = (0..128).collect();
+        serial.extend(&v);
+        parallel.par_extend(&v);
+        assert_eq!(serial, parallel);
+
+        // extend with values
+        serial.extend(-128..0);
+        parallel.par_extend(-128..0);
+        assert_eq!(serial, parallel);
+    }
+
+    check::<BTreeSet<_>>();
+    check::<HashSet<_>>();
+    check::<LinkedList<_>>();
+    check::<Vec<_>>();
+    check::<VecDeque<_>>();
+}
+
+#[test]
+fn check_extend_heap() {
+    let mut serial: BinaryHeap<_> = Default::default();
+    let mut parallel: BinaryHeap<_> = Default::default();
+
+    // extend with references
+    let v: Vec<_> = (0..128).collect();
+    serial.extend(&v);
+    parallel.par_extend(&v);
+    assert_eq!(
+        serial.clone().into_sorted_vec(),
+        parallel.clone().into_sorted_vec()
+    );
+
+    // extend with values
+    serial.extend(-128..0);
+    parallel.par_extend(-128..0);
+    assert_eq!(serial.into_sorted_vec(), parallel.into_sorted_vec());
+}
+
+#[test]
+fn check_extend_pairs() {
+    fn check<C>()
+    where
+        C: Default
+            + Eq
+            + Debug
+            + Extend<(usize, i32)>
+            + for<'a> Extend<(&'a usize, &'a i32)>
+            + ParallelExtend<(usize, i32)>
+            + for<'a> ParallelExtend<(&'a usize, &'a i32)>,
+    {
+        let mut serial = C::default();
+        let mut parallel = C::default();
+
+        // extend with references
+        let m: HashMap<_, _> = (0..128).enumerate().collect();
+        serial.extend(&m);
+        parallel.par_extend(&m);
+        assert_eq!(serial, parallel);
+
+        // extend with values
+        let v: Vec<(_, _)> = (-128..0).enumerate().collect();
+        serial.extend(v.clone());
+        parallel.par_extend(v);
+        assert_eq!(serial, parallel);
+    }
+
+    check::<BTreeMap<usize, i32>>();
+    check::<HashMap<usize, i32>>();
+}
+
+#[test]
+fn check_unzip_into_vecs() {
+    let mut a = vec![];
+    let mut b = vec![];
+    (0..1024)
+        .into_par_iter()
+        .map(|i| i * i)
+        .enumerate()
+        .unzip_into_vecs(&mut a, &mut b);
+
+    let (c, d): (Vec<_>, Vec<_>) = (0..1024).map(|i| i * i).enumerate().unzip();
+    assert_eq!(a, c);
+    assert_eq!(b, d);
+}
+
+#[test]
+fn check_unzip() {
+    // indexed, unindexed
+    let (a, b): (Vec<_>, HashSet<_>) = (0..1024).into_par_iter().map(|i| i * i).enumerate().unzip();
+    let (c, d): (Vec<_>, HashSet<_>) = (0..1024).map(|i| i * i).enumerate().unzip();
+    assert_eq!(a, c);
+    assert_eq!(b, d);
+
+    // unindexed, indexed
+    let (a, b): (HashSet<_>, Vec<_>) = (0..1024).into_par_iter().map(|i| i * i).enumerate().unzip();
+    let (c, d): (HashSet<_>, Vec<_>) = (0..1024).map(|i| i * i).enumerate().unzip();
+    assert_eq!(a, c);
+    assert_eq!(b, d);
+
+    // indexed, indexed
+    let (a, b): (Vec<_>, Vec<_>) = (0..1024).into_par_iter().map(|i| i * i).enumerate().unzip();
+    let (c, d): (Vec<_>, Vec<_>) = (0..1024).map(|i| i * i).enumerate().unzip();
+    assert_eq!(a, c);
+    assert_eq!(b, d);
+
+    // unindexed producer
+    let (a, b): (Vec<_>, Vec<_>) = (0..1024)
+        .into_par_iter()
+        .filter_map(|i| Some((i, i * i)))
+        .unzip();
+    let (c, d): (Vec<_>, Vec<_>) = (0..1024).map(|i| (i, i * i)).unzip();
+    assert_eq!(a, c);
+    assert_eq!(b, d);
+}
+
+#[test]
+fn check_partition() {
+    let (a, b): (Vec<_>, Vec<_>) = (0..1024).into_par_iter().partition(|&i| i % 3 == 0);
+    let (c, d): (Vec<_>, Vec<_>) = (0..1024).partition(|&i| i % 3 == 0);
+    assert_eq!(a, c);
+    assert_eq!(b, d);
+}
+
+#[test]
+fn check_partition_map() {
+    let input = "a b c 1 2 3 x y z";
+    let (a, b): (Vec<_>, String) =
+        input
+            .par_split_whitespace()
+            .partition_map(|s| match s.parse::<i32>() {
+                Ok(n) => Either::Left(n),
+                Err(_) => Either::Right(s),
+            });
+    assert_eq!(a, vec![1, 2, 3]);
+    assert_eq!(b, "abcxyz");
+}
+
+#[test]
+fn check_either() {
+    type I = crate::vec::IntoIter<i32>;
+    type E = Either<I, I>;
+
+    let v: Vec<i32> = (0..1024).collect();
+
+    // try iterating the left side
+    let left: E = Either::Left(v.clone().into_par_iter());
+    assert!(left.eq(v.clone()));
+
+    // try iterating the right side
+    let right: E = Either::Right(v.clone().into_par_iter());
+    assert!(right.eq(v.clone()));
+
+    // try an indexed iterator
+    let left: E = Either::Left(v.clone().into_par_iter());
+    assert!(left.enumerate().eq(v.into_par_iter().enumerate()));
+}
+
+#[test]
+fn check_either_extend() {
+    type E = Either<Vec<i32>, HashSet<i32>>;
+
+    let v: Vec<i32> = (0..1024).collect();
+
+    // try extending the left side
+    let mut left: E = Either::Left(vec![]);
+    left.par_extend(v.clone());
+    assert_eq!(left.as_ref(), Either::Left(&v));
+
+    // try extending the right side
+    let mut right: E = Either::Right(HashSet::default());
+    right.par_extend(v.clone());
+    assert_eq!(right, Either::Right(v.iter().cloned().collect()));
+}
+
+#[test]
+fn check_interleave_eq() {
+    let xs: Vec<usize> = (0..10).collect();
+    let ys: Vec<usize> = (10..20).collect();
+
+    let mut actual = vec![];
+    xs.par_iter()
+        .interleave(&ys)
+        .map(|&i| i)
+        .collect_into_vec(&mut actual);
+
+    let expected: Vec<usize> = (0..10)
+        .zip(10..20)
+        .flat_map(|(i, j)| vec![i, j].into_iter())
+        .collect();
+    assert_eq!(expected, actual);
+}
+
+#[test]
+fn check_interleave_uneven() {
+    let cases: Vec<(Vec<usize>, Vec<usize>, Vec<usize>)> = vec![
+        (
+            (0..9).collect(),
+            vec![10],
+            vec![0, 10, 1, 2, 3, 4, 5, 6, 7, 8],
+        ),
+        (
+            vec![10],
+            (0..9).collect(),
+            vec![10, 0, 1, 2, 3, 4, 5, 6, 7, 8],
+        ),
+        (
+            (0..5).collect(),
+            (5..10).collect(),
+            (0..5)
+                .zip(5..10)
+                .flat_map(|(i, j)| vec![i, j].into_iter())
+                .collect(),
+        ),
+        (vec![], (0..9).collect(), (0..9).collect()),
+        ((0..9).collect(), vec![], (0..9).collect()),
+        (
+            (0..50).collect(),
+            (50..100).collect(),
+            (0..50)
+                .zip(50..100)
+                .flat_map(|(i, j)| vec![i, j].into_iter())
+                .collect(),
+        ),
+    ];
+
+    for (i, (xs, ys, expected)) in cases.into_iter().enumerate() {
+        let mut res = vec![];
+        xs.par_iter()
+            .interleave(&ys)
+            .map(|&i| i)
+            .collect_into_vec(&mut res);
+        assert_eq!(expected, res, "Case {} failed", i);
+
+        res.truncate(0);
+        xs.par_iter()
+            .interleave(&ys)
+            .rev()
+            .map(|&i| i)
+            .collect_into_vec(&mut res);
+        assert_eq!(
+            expected.into_iter().rev().collect::<Vec<usize>>(),
+            res,
+            "Case {} reversed failed",
+            i
+        );
+    }
+}
+
+#[test]
+fn check_interleave_shortest() {
+    let cases: Vec<(Vec<usize>, Vec<usize>, Vec<usize>)> = vec![
+        ((0..9).collect(), vec![10], vec![0, 10, 1]),
+        (vec![10], (0..9).collect(), vec![10, 0]),
+        (
+            (0..5).collect(),
+            (5..10).collect(),
+            (0..5)
+                .zip(5..10)
+                .flat_map(|(i, j)| vec![i, j].into_iter())
+                .collect(),
+        ),
+        (vec![], (0..9).collect(), vec![]),
+        ((0..9).collect(), vec![], vec![0]),
+        (
+            (0..50).collect(),
+            (50..100).collect(),
+            (0..50)
+                .zip(50..100)
+                .flat_map(|(i, j)| vec![i, j].into_iter())
+                .collect(),
+        ),
+    ];
+
+    for (i, (xs, ys, expected)) in cases.into_iter().enumerate() {
+        let mut res = vec![];
+        xs.par_iter()
+            .interleave_shortest(&ys)
+            .map(|&i| i)
+            .collect_into_vec(&mut res);
+        assert_eq!(expected, res, "Case {} failed", i);
+
+        res.truncate(0);
+        xs.par_iter()
+            .interleave_shortest(&ys)
+            .rev()
+            .map(|&i| i)
+            .collect_into_vec(&mut res);
+        assert_eq!(
+            expected.into_iter().rev().collect::<Vec<usize>>(),
+            res,
+            "Case {} reversed failed",
+            i
+        );
+    }
+}
+
+#[test]
+#[should_panic(expected = "chunk_size must not be zero")]
+fn check_chunks_zero_size() {
+    let _: Vec<Vec<i32>> = vec![1, 2, 3].into_par_iter().chunks(0).collect();
+}
+
+#[test]
+fn check_chunks_even_size() {
+    assert_eq!(
+        vec![vec![1, 2, 3], vec![4, 5, 6], vec![7, 8, 9]],
+        (1..10).into_par_iter().chunks(3).collect::<Vec<Vec<i32>>>()
+    );
+}
+
+#[test]
+fn check_chunks_empty() {
+    let v: Vec<i32> = vec![];
+    let expected: Vec<Vec<i32>> = vec![];
+    assert_eq!(
+        expected,
+        v.into_par_iter().chunks(2).collect::<Vec<Vec<i32>>>()
+    );
+}
+
+#[test]
+fn check_chunks_len() {
+    assert_eq!(4, (0..8).into_par_iter().chunks(2).len());
+    assert_eq!(3, (0..9).into_par_iter().chunks(3).len());
+    assert_eq!(3, (0..8).into_par_iter().chunks(3).len());
+    assert_eq!(1, [1].par_iter().chunks(3).len());
+    assert_eq!(0, (0..0).into_par_iter().chunks(3).len());
+}
+
+#[test]
+fn check_chunks_uneven() {
+    let cases: Vec<(Vec<u32>, usize, Vec<Vec<u32>>)> = vec![
+        ((0..5).collect(), 3, vec![vec![0, 1, 2], vec![3, 4]]),
+        (vec![1], 5, vec![vec![1]]),
+        ((0..4).collect(), 3, vec![vec![0, 1, 2], vec![3]]),
+    ];
+
+    for (i, (v, n, expected)) in cases.into_iter().enumerate() {
+        let mut res: Vec<Vec<u32>> = vec![];
+        v.par_iter()
+            .chunks(n)
+            .map(|v| v.into_iter().cloned().collect())
+            .collect_into_vec(&mut res);
+        assert_eq!(expected, res, "Case {} failed", i);
+
+        res.truncate(0);
+        v.into_par_iter().chunks(n).rev().collect_into_vec(&mut res);
+        assert_eq!(
+            expected.into_iter().rev().collect::<Vec<Vec<u32>>>(),
+            res,
+            "Case {} reversed failed",
+            i
+        );
+    }
+}
+
+#[test]
+#[ignore] // it's quick enough on optimized 32-bit platforms, but otherwise... ... ...
+#[should_panic(expected = "overflow")]
+#[cfg(debug_assertions)]
+fn check_repeat_unbounded() {
+    // use just one thread, so we don't get infinite adaptive splitting
+    // (forever stealing and re-splitting jobs that will panic on overflow)
+    let pool = ThreadPoolBuilder::new().num_threads(1).build().unwrap();
+    pool.install(|| {
+        println!("counted {} repeats", repeat(()).count());
+    });
+}
+
+#[test]
+fn check_repeat_find_any() {
+    let even = repeat(4).find_any(|&x| x % 2 == 0);
+    assert_eq!(even, Some(4));
+}
+
+#[test]
+fn check_repeat_take() {
+    let v: Vec<_> = repeat(4).take(4).collect();
+    assert_eq!(v, [4, 4, 4, 4]);
+}
+
+#[test]
+fn check_repeat_zip() {
+    let v = vec![4, 4, 4, 4];
+    let mut fours: Vec<_> = repeat(4).zip(v).collect();
+    assert_eq!(fours.len(), 4);
+    while let Some(item) = fours.pop() {
+        assert_eq!(item, (4, 4));
+    }
+}
+
+#[test]
+fn check_repeatn_zip_left() {
+    let v = vec![4, 4, 4, 4];
+    let mut fours: Vec<_> = repeatn(4, usize::MAX).zip(v).collect();
+    assert_eq!(fours.len(), 4);
+    while let Some(item) = fours.pop() {
+        assert_eq!(item, (4, 4));
+    }
+}
+
+#[test]
+fn check_repeatn_zip_right() {
+    let v = vec![4, 4, 4, 4];
+    let mut fours: Vec<_> = v.into_par_iter().zip(repeatn(4, usize::MAX)).collect();
+    assert_eq!(fours.len(), 4);
+    while let Some(item) = fours.pop() {
+        assert_eq!(item, (4, 4));
+    }
+}
+
+#[test]
+fn check_empty() {
+    // drive_unindexed
+    let mut v: Vec<i32> = empty().filter(|_| unreachable!()).collect();
+    assert!(v.is_empty());
+
+    // drive (indexed)
+    empty().collect_into_vec(&mut v);
+    assert!(v.is_empty());
+
+    // with_producer
+    let v: Vec<(i32, i32)> = empty().zip(1..10).collect();
+    assert!(v.is_empty());
+}
+
+#[test]
+fn check_once() {
+    // drive_unindexed
+    let mut v: Vec<i32> = once(42).filter(|_| true).collect();
+    assert_eq!(v, &[42]);
+
+    // drive (indexed)
+    once(42).collect_into_vec(&mut v);
+    assert_eq!(v, &[42]);
+
+    // with_producer
+    let v: Vec<(i32, i32)> = once(42).zip(1..10).collect();
+    assert_eq!(v, &[(42, 1)]);
+}
+
+#[test]
+fn check_update() {
+    let mut v: Vec<Vec<_>> = vec![vec![1], vec![3, 2, 1]];
+    v.par_iter_mut().update(|v| v.push(0)).for_each(|_| ());
+
+    assert_eq!(v, vec![vec![1, 0], vec![3, 2, 1, 0]]);
+}
diff --git a/crates/rayon/src/iter/try_fold.rs b/crates/rayon/src/iter/try_fold.rs
new file mode 100644
index 0000000..6d1048d
--- /dev/null
+++ b/crates/rayon/src/iter/try_fold.rs
@@ -0,0 +1,298 @@
+use super::plumbing::*;
+use super::ParallelIterator;
+use super::Try;
+
+use std::fmt::{self, Debug};
+use std::marker::PhantomData;
+use std::ops::ControlFlow::{self, Break, Continue};
+
+impl<U, I, ID, F> TryFold<I, U, ID, F>
+where
+    I: ParallelIterator,
+    F: Fn(U::Output, I::Item) -> U + Sync + Send,
+    ID: Fn() -> U::Output + Sync + Send,
+    U: Try + Send,
+{
+    pub(super) fn new(base: I, identity: ID, fold_op: F) -> Self {
+        TryFold {
+            base,
+            identity,
+            fold_op,
+            marker: PhantomData,
+        }
+    }
+}
+
+/// `TryFold` is an iterator that applies a function over an iterator producing a single value.
+/// This struct is created by the [`try_fold()`] method on [`ParallelIterator`]
+///
+/// [`try_fold()`]: trait.ParallelIterator.html#method.try_fold
+/// [`ParallelIterator`]: trait.ParallelIterator.html
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Clone)]
+pub struct TryFold<I, U, ID, F> {
+    base: I,
+    identity: ID,
+    fold_op: F,
+    marker: PhantomData<U>,
+}
+
+impl<U, I: ParallelIterator + Debug, ID, F> Debug for TryFold<I, U, ID, F> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("TryFold").field("base", &self.base).finish()
+    }
+}
+
+impl<U, I, ID, F> ParallelIterator for TryFold<I, U, ID, F>
+where
+    I: ParallelIterator,
+    F: Fn(U::Output, I::Item) -> U + Sync + Send,
+    ID: Fn() -> U::Output + Sync + Send,
+    U: Try + Send,
+{
+    type Item = U;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        let consumer1 = TryFoldConsumer {
+            base: consumer,
+            identity: &self.identity,
+            fold_op: &self.fold_op,
+            marker: PhantomData,
+        };
+        self.base.drive_unindexed(consumer1)
+    }
+}
+
+struct TryFoldConsumer<'c, U, C, ID, F> {
+    base: C,
+    identity: &'c ID,
+    fold_op: &'c F,
+    marker: PhantomData<U>,
+}
+
+impl<'r, U, T, C, ID, F> Consumer<T> for TryFoldConsumer<'r, U, C, ID, F>
+where
+    C: Consumer<U>,
+    F: Fn(U::Output, T) -> U + Sync,
+    ID: Fn() -> U::Output + Sync,
+    U: Try + Send,
+{
+    type Folder = TryFoldFolder<'r, C::Folder, U, F>;
+    type Reducer = C::Reducer;
+    type Result = C::Result;
+
+    fn split_at(self, index: usize) -> (Self, Self, Self::Reducer) {
+        let (left, right, reducer) = self.base.split_at(index);
+        (
+            TryFoldConsumer { base: left, ..self },
+            TryFoldConsumer {
+                base: right,
+                ..self
+            },
+            reducer,
+        )
+    }
+
+    fn into_folder(self) -> Self::Folder {
+        TryFoldFolder {
+            base: self.base.into_folder(),
+            control: Continue((self.identity)()),
+            fold_op: self.fold_op,
+        }
+    }
+
+    fn full(&self) -> bool {
+        self.base.full()
+    }
+}
+
+impl<'r, U, T, C, ID, F> UnindexedConsumer<T> for TryFoldConsumer<'r, U, C, ID, F>
+where
+    C: UnindexedConsumer<U>,
+    F: Fn(U::Output, T) -> U + Sync,
+    ID: Fn() -> U::Output + Sync,
+    U: Try + Send,
+{
+    fn split_off_left(&self) -> Self {
+        TryFoldConsumer {
+            base: self.base.split_off_left(),
+            ..*self
+        }
+    }
+
+    fn to_reducer(&self) -> Self::Reducer {
+        self.base.to_reducer()
+    }
+}
+
+struct TryFoldFolder<'r, C, U: Try, F> {
+    base: C,
+    fold_op: &'r F,
+    control: ControlFlow<U::Residual, U::Output>,
+}
+
+impl<'r, C, U, F, T> Folder<T> for TryFoldFolder<'r, C, U, F>
+where
+    C: Folder<U>,
+    F: Fn(U::Output, T) -> U + Sync,
+    U: Try,
+{
+    type Result = C::Result;
+
+    fn consume(mut self, item: T) -> Self {
+        let fold_op = self.fold_op;
+        if let Continue(acc) = self.control {
+            self.control = fold_op(acc, item).branch();
+        }
+        self
+    }
+
+    fn complete(self) -> C::Result {
+        let item = match self.control {
+            Continue(c) => U::from_output(c),
+            Break(r) => U::from_residual(r),
+        };
+        self.base.consume(item).complete()
+    }
+
+    fn full(&self) -> bool {
+        match self.control {
+            Break(_) => true,
+            _ => self.base.full(),
+        }
+    }
+}
+
+// ///////////////////////////////////////////////////////////////////////////
+
+impl<U, I, F> TryFoldWith<I, U, F>
+where
+    I: ParallelIterator,
+    F: Fn(U::Output, I::Item) -> U + Sync,
+    U: Try + Send,
+    U::Output: Clone + Send,
+{
+    pub(super) fn new(base: I, item: U::Output, fold_op: F) -> Self {
+        TryFoldWith {
+            base,
+            item,
+            fold_op,
+        }
+    }
+}
+
+/// `TryFoldWith` is an iterator that applies a function over an iterator producing a single value.
+/// This struct is created by the [`try_fold_with()`] method on [`ParallelIterator`]
+///
+/// [`try_fold_with()`]: trait.ParallelIterator.html#method.try_fold_with
+/// [`ParallelIterator`]: trait.ParallelIterator.html
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Clone)]
+pub struct TryFoldWith<I, U: Try, F> {
+    base: I,
+    item: U::Output,
+    fold_op: F,
+}
+
+impl<I: ParallelIterator + Debug, U: Try, F> Debug for TryFoldWith<I, U, F>
+where
+    U::Output: Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("TryFoldWith")
+            .field("base", &self.base)
+            .field("item", &self.item)
+            .finish()
+    }
+}
+
+impl<U, I, F> ParallelIterator for TryFoldWith<I, U, F>
+where
+    I: ParallelIterator,
+    F: Fn(U::Output, I::Item) -> U + Sync + Send,
+    U: Try + Send,
+    U::Output: Clone + Send,
+{
+    type Item = U;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        let consumer1 = TryFoldWithConsumer {
+            base: consumer,
+            item: self.item,
+            fold_op: &self.fold_op,
+        };
+        self.base.drive_unindexed(consumer1)
+    }
+}
+
+struct TryFoldWithConsumer<'c, C, U: Try, F> {
+    base: C,
+    item: U::Output,
+    fold_op: &'c F,
+}
+
+impl<'r, U, T, C, F> Consumer<T> for TryFoldWithConsumer<'r, C, U, F>
+where
+    C: Consumer<U>,
+    F: Fn(U::Output, T) -> U + Sync,
+    U: Try + Send,
+    U::Output: Clone + Send,
+{
+    type Folder = TryFoldFolder<'r, C::Folder, U, F>;
+    type Reducer = C::Reducer;
+    type Result = C::Result;
+
+    fn split_at(self, index: usize) -> (Self, Self, Self::Reducer) {
+        let (left, right, reducer) = self.base.split_at(index);
+        (
+            TryFoldWithConsumer {
+                base: left,
+                item: self.item.clone(),
+                ..self
+            },
+            TryFoldWithConsumer {
+                base: right,
+                ..self
+            },
+            reducer,
+        )
+    }
+
+    fn into_folder(self) -> Self::Folder {
+        TryFoldFolder {
+            base: self.base.into_folder(),
+            control: Continue(self.item),
+            fold_op: self.fold_op,
+        }
+    }
+
+    fn full(&self) -> bool {
+        self.base.full()
+    }
+}
+
+impl<'r, U, T, C, F> UnindexedConsumer<T> for TryFoldWithConsumer<'r, C, U, F>
+where
+    C: UnindexedConsumer<U>,
+    F: Fn(U::Output, T) -> U + Sync,
+    U: Try + Send,
+    U::Output: Clone + Send,
+{
+    fn split_off_left(&self) -> Self {
+        TryFoldWithConsumer {
+            base: self.base.split_off_left(),
+            item: self.item.clone(),
+            ..*self
+        }
+    }
+
+    fn to_reducer(&self) -> Self::Reducer {
+        self.base.to_reducer()
+    }
+}
diff --git a/crates/rayon/src/iter/try_reduce.rs b/crates/rayon/src/iter/try_reduce.rs
new file mode 100644
index 0000000..35a724c
--- /dev/null
+++ b/crates/rayon/src/iter/try_reduce.rs
@@ -0,0 +1,131 @@
+use super::plumbing::*;
+use super::ParallelIterator;
+use super::Try;
+
+use std::ops::ControlFlow::{self, Break, Continue};
+use std::sync::atomic::{AtomicBool, Ordering};
+
+pub(super) fn try_reduce<PI, R, ID, T>(pi: PI, identity: ID, reduce_op: R) -> T
+where
+    PI: ParallelIterator<Item = T>,
+    R: Fn(T::Output, T::Output) -> T + Sync,
+    ID: Fn() -> T::Output + Sync,
+    T: Try + Send,
+{
+    let full = AtomicBool::new(false);
+    let consumer = TryReduceConsumer {
+        identity: &identity,
+        reduce_op: &reduce_op,
+        full: &full,
+    };
+    pi.drive_unindexed(consumer)
+}
+
+struct TryReduceConsumer<'r, R, ID> {
+    identity: &'r ID,
+    reduce_op: &'r R,
+    full: &'r AtomicBool,
+}
+
+impl<'r, R, ID> Copy for TryReduceConsumer<'r, R, ID> {}
+
+impl<'r, R, ID> Clone for TryReduceConsumer<'r, R, ID> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<'r, R, ID, T> Consumer<T> for TryReduceConsumer<'r, R, ID>
+where
+    R: Fn(T::Output, T::Output) -> T + Sync,
+    ID: Fn() -> T::Output + Sync,
+    T: Try + Send,
+{
+    type Folder = TryReduceFolder<'r, R, T>;
+    type Reducer = Self;
+    type Result = T;
+
+    fn split_at(self, _index: usize) -> (Self, Self, Self) {
+        (self, self, self)
+    }
+
+    fn into_folder(self) -> Self::Folder {
+        TryReduceFolder {
+            reduce_op: self.reduce_op,
+            control: Continue((self.identity)()),
+            full: self.full,
+        }
+    }
+
+    fn full(&self) -> bool {
+        self.full.load(Ordering::Relaxed)
+    }
+}
+
+impl<'r, R, ID, T> UnindexedConsumer<T> for TryReduceConsumer<'r, R, ID>
+where
+    R: Fn(T::Output, T::Output) -> T + Sync,
+    ID: Fn() -> T::Output + Sync,
+    T: Try + Send,
+{
+    fn split_off_left(&self) -> Self {
+        *self
+    }
+
+    fn to_reducer(&self) -> Self::Reducer {
+        *self
+    }
+}
+
+impl<'r, R, ID, T> Reducer<T> for TryReduceConsumer<'r, R, ID>
+where
+    R: Fn(T::Output, T::Output) -> T + Sync,
+    T: Try,
+{
+    fn reduce(self, left: T, right: T) -> T {
+        match (left.branch(), right.branch()) {
+            (Continue(left), Continue(right)) => (self.reduce_op)(left, right),
+            (Break(r), _) | (_, Break(r)) => T::from_residual(r),
+        }
+    }
+}
+
+struct TryReduceFolder<'r, R, T: Try> {
+    reduce_op: &'r R,
+    control: ControlFlow<T::Residual, T::Output>,
+    full: &'r AtomicBool,
+}
+
+impl<'r, R, T> Folder<T> for TryReduceFolder<'r, R, T>
+where
+    R: Fn(T::Output, T::Output) -> T,
+    T: Try,
+{
+    type Result = T;
+
+    fn consume(mut self, item: T) -> Self {
+        let reduce_op = self.reduce_op;
+        self.control = match (self.control, item.branch()) {
+            (Continue(left), Continue(right)) => reduce_op(left, right).branch(),
+            (control @ Break(_), _) | (_, control @ Break(_)) => control,
+        };
+        if let Break(_) = self.control {
+            self.full.store(true, Ordering::Relaxed);
+        }
+        self
+    }
+
+    fn complete(self) -> T {
+        match self.control {
+            Continue(c) => T::from_output(c),
+            Break(r) => T::from_residual(r),
+        }
+    }
+
+    fn full(&self) -> bool {
+        match self.control {
+            Break(_) => true,
+            _ => self.full.load(Ordering::Relaxed),
+        }
+    }
+}
diff --git a/crates/rayon/src/iter/try_reduce_with.rs b/crates/rayon/src/iter/try_reduce_with.rs
new file mode 100644
index 0000000..cd7c83e
--- /dev/null
+++ b/crates/rayon/src/iter/try_reduce_with.rs
@@ -0,0 +1,132 @@
+use super::plumbing::*;
+use super::ParallelIterator;
+use super::Try;
+
+use std::ops::ControlFlow::{self, Break, Continue};
+use std::sync::atomic::{AtomicBool, Ordering};
+
+pub(super) fn try_reduce_with<PI, R, T>(pi: PI, reduce_op: R) -> Option<T>
+where
+    PI: ParallelIterator<Item = T>,
+    R: Fn(T::Output, T::Output) -> T + Sync,
+    T: Try + Send,
+{
+    let full = AtomicBool::new(false);
+    let consumer = TryReduceWithConsumer {
+        reduce_op: &reduce_op,
+        full: &full,
+    };
+    pi.drive_unindexed(consumer)
+}
+
+struct TryReduceWithConsumer<'r, R> {
+    reduce_op: &'r R,
+    full: &'r AtomicBool,
+}
+
+impl<'r, R> Copy for TryReduceWithConsumer<'r, R> {}
+
+impl<'r, R> Clone for TryReduceWithConsumer<'r, R> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<'r, R, T> Consumer<T> for TryReduceWithConsumer<'r, R>
+where
+    R: Fn(T::Output, T::Output) -> T + Sync,
+    T: Try + Send,
+{
+    type Folder = TryReduceWithFolder<'r, R, T>;
+    type Reducer = Self;
+    type Result = Option<T>;
+
+    fn split_at(self, _index: usize) -> (Self, Self, Self) {
+        (self, self, self)
+    }
+
+    fn into_folder(self) -> Self::Folder {
+        TryReduceWithFolder {
+            reduce_op: self.reduce_op,
+            opt_control: None,
+            full: self.full,
+        }
+    }
+
+    fn full(&self) -> bool {
+        self.full.load(Ordering::Relaxed)
+    }
+}
+
+impl<'r, R, T> UnindexedConsumer<T> for TryReduceWithConsumer<'r, R>
+where
+    R: Fn(T::Output, T::Output) -> T + Sync,
+    T: Try + Send,
+{
+    fn split_off_left(&self) -> Self {
+        *self
+    }
+
+    fn to_reducer(&self) -> Self::Reducer {
+        *self
+    }
+}
+
+impl<'r, R, T> Reducer<Option<T>> for TryReduceWithConsumer<'r, R>
+where
+    R: Fn(T::Output, T::Output) -> T + Sync,
+    T: Try,
+{
+    fn reduce(self, left: Option<T>, right: Option<T>) -> Option<T> {
+        let reduce_op = self.reduce_op;
+        match (left, right) {
+            (Some(left), Some(right)) => match (left.branch(), right.branch()) {
+                (Continue(left), Continue(right)) => Some(reduce_op(left, right)),
+                (Break(r), _) | (_, Break(r)) => Some(T::from_residual(r)),
+            },
+            (None, x) | (x, None) => x,
+        }
+    }
+}
+
+struct TryReduceWithFolder<'r, R, T: Try> {
+    reduce_op: &'r R,
+    opt_control: Option<ControlFlow<T::Residual, T::Output>>,
+    full: &'r AtomicBool,
+}
+
+impl<'r, R, T> Folder<T> for TryReduceWithFolder<'r, R, T>
+where
+    R: Fn(T::Output, T::Output) -> T,
+    T: Try,
+{
+    type Result = Option<T>;
+
+    fn consume(mut self, item: T) -> Self {
+        let reduce_op = self.reduce_op;
+        let control = match (self.opt_control, item.branch()) {
+            (Some(Continue(left)), Continue(right)) => reduce_op(left, right).branch(),
+            (Some(control @ Break(_)), _) | (_, control) => control,
+        };
+        if let Break(_) = control {
+            self.full.store(true, Ordering::Relaxed)
+        }
+        self.opt_control = Some(control);
+        self
+    }
+
+    fn complete(self) -> Option<T> {
+        match self.opt_control {
+            Some(Continue(c)) => Some(T::from_output(c)),
+            Some(Break(r)) => Some(T::from_residual(r)),
+            None => None,
+        }
+    }
+
+    fn full(&self) -> bool {
+        match self.opt_control {
+            Some(Break(_)) => true,
+            _ => self.full.load(Ordering::Relaxed),
+        }
+    }
+}
diff --git a/crates/rayon/src/iter/unzip.rs b/crates/rayon/src/iter/unzip.rs
new file mode 100644
index 0000000..0b7074e
--- /dev/null
+++ b/crates/rayon/src/iter/unzip.rs
@@ -0,0 +1,525 @@
+use super::plumbing::*;
+use super::*;
+
+/// This trait abstracts the different ways we can "unzip" one parallel
+/// iterator into two distinct consumers, which we can handle almost
+/// identically apart from how to process the individual items.
+trait UnzipOp<T>: Sync + Send {
+    /// The type of item expected by the left consumer.
+    type Left: Send;
+
+    /// The type of item expected by the right consumer.
+    type Right: Send;
+
+    /// Consumes one item and feeds it to one or both of the underlying folders.
+    fn consume<FA, FB>(&self, item: T, left: FA, right: FB) -> (FA, FB)
+    where
+        FA: Folder<Self::Left>,
+        FB: Folder<Self::Right>;
+
+    /// Reports whether this op may support indexed consumers.
+    /// - e.g. true for `unzip` where the item count passed through directly.
+    /// - e.g. false for `partition` where the sorting is not yet known.
+    fn indexable() -> bool {
+        false
+    }
+}
+
+/// Runs an unzip-like operation into default `ParallelExtend` collections.
+fn execute<I, OP, FromA, FromB>(pi: I, op: OP) -> (FromA, FromB)
+where
+    I: ParallelIterator,
+    OP: UnzipOp<I::Item>,
+    FromA: Default + Send + ParallelExtend<OP::Left>,
+    FromB: Default + Send + ParallelExtend<OP::Right>,
+{
+    let mut a = FromA::default();
+    let mut b = FromB::default();
+    execute_into(&mut a, &mut b, pi, op);
+    (a, b)
+}
+
+/// Runs an unzip-like operation into `ParallelExtend` collections.
+fn execute_into<I, OP, FromA, FromB>(a: &mut FromA, b: &mut FromB, pi: I, op: OP)
+where
+    I: ParallelIterator,
+    OP: UnzipOp<I::Item>,
+    FromA: Send + ParallelExtend<OP::Left>,
+    FromB: Send + ParallelExtend<OP::Right>,
+{
+    // We have no idea what the consumers will look like for these
+    // collections' `par_extend`, but we can intercept them in our own
+    // `drive_unindexed`.  Start with the left side, type `A`:
+    let iter = UnzipA { base: pi, op, b };
+    a.par_extend(iter);
+}
+
+/// Unzips the items of a parallel iterator into a pair of arbitrary
+/// `ParallelExtend` containers.
+///
+/// This is called by `ParallelIterator::unzip`.
+pub(super) fn unzip<I, A, B, FromA, FromB>(pi: I) -> (FromA, FromB)
+where
+    I: ParallelIterator<Item = (A, B)>,
+    FromA: Default + Send + ParallelExtend<A>,
+    FromB: Default + Send + ParallelExtend<B>,
+    A: Send,
+    B: Send,
+{
+    execute(pi, Unzip)
+}
+
+/// Unzips an `IndexedParallelIterator` into two arbitrary `Consumer`s.
+///
+/// This is called by `super::collect::unzip_into_vecs`.
+pub(super) fn unzip_indexed<I, A, B, CA, CB>(pi: I, left: CA, right: CB) -> (CA::Result, CB::Result)
+where
+    I: IndexedParallelIterator<Item = (A, B)>,
+    CA: Consumer<A>,
+    CB: Consumer<B>,
+    A: Send,
+    B: Send,
+{
+    let consumer = UnzipConsumer {
+        op: &Unzip,
+        left,
+        right,
+    };
+    pi.drive(consumer)
+}
+
+/// An `UnzipOp` that splits a tuple directly into the two consumers.
+struct Unzip;
+
+impl<A: Send, B: Send> UnzipOp<(A, B)> for Unzip {
+    type Left = A;
+    type Right = B;
+
+    fn consume<FA, FB>(&self, item: (A, B), left: FA, right: FB) -> (FA, FB)
+    where
+        FA: Folder<A>,
+        FB: Folder<B>,
+    {
+        (left.consume(item.0), right.consume(item.1))
+    }
+
+    fn indexable() -> bool {
+        true
+    }
+}
+
+/// Partitions the items of a parallel iterator into a pair of arbitrary
+/// `ParallelExtend` containers.
+///
+/// This is called by `ParallelIterator::partition`.
+pub(super) fn partition<I, A, B, P>(pi: I, predicate: P) -> (A, B)
+where
+    I: ParallelIterator,
+    A: Default + Send + ParallelExtend<I::Item>,
+    B: Default + Send + ParallelExtend<I::Item>,
+    P: Fn(&I::Item) -> bool + Sync + Send,
+{
+    execute(pi, Partition { predicate })
+}
+
+/// An `UnzipOp` that routes items depending on a predicate function.
+struct Partition<P> {
+    predicate: P,
+}
+
+impl<P, T> UnzipOp<T> for Partition<P>
+where
+    P: Fn(&T) -> bool + Sync + Send,
+    T: Send,
+{
+    type Left = T;
+    type Right = T;
+
+    fn consume<FA, FB>(&self, item: T, left: FA, right: FB) -> (FA, FB)
+    where
+        FA: Folder<T>,
+        FB: Folder<T>,
+    {
+        if (self.predicate)(&item) {
+            (left.consume(item), right)
+        } else {
+            (left, right.consume(item))
+        }
+    }
+}
+
+/// Partitions and maps the items of a parallel iterator into a pair of
+/// arbitrary `ParallelExtend` containers.
+///
+/// This called by `ParallelIterator::partition_map`.
+pub(super) fn partition_map<I, A, B, P, L, R>(pi: I, predicate: P) -> (A, B)
+where
+    I: ParallelIterator,
+    A: Default + Send + ParallelExtend<L>,
+    B: Default + Send + ParallelExtend<R>,
+    P: Fn(I::Item) -> Either<L, R> + Sync + Send,
+    L: Send,
+    R: Send,
+{
+    execute(pi, PartitionMap { predicate })
+}
+
+/// An `UnzipOp` that routes items depending on how they are mapped `Either`.
+struct PartitionMap<P> {
+    predicate: P,
+}
+
+impl<P, L, R, T> UnzipOp<T> for PartitionMap<P>
+where
+    P: Fn(T) -> Either<L, R> + Sync + Send,
+    L: Send,
+    R: Send,
+{
+    type Left = L;
+    type Right = R;
+
+    fn consume<FA, FB>(&self, item: T, left: FA, right: FB) -> (FA, FB)
+    where
+        FA: Folder<L>,
+        FB: Folder<R>,
+    {
+        match (self.predicate)(item) {
+            Either::Left(item) => (left.consume(item), right),
+            Either::Right(item) => (left, right.consume(item)),
+        }
+    }
+}
+
+/// A fake iterator to intercept the `Consumer` for type `A`.
+struct UnzipA<'b, I, OP, FromB> {
+    base: I,
+    op: OP,
+    b: &'b mut FromB,
+}
+
+impl<'b, I, OP, FromB> ParallelIterator for UnzipA<'b, I, OP, FromB>
+where
+    I: ParallelIterator,
+    OP: UnzipOp<I::Item>,
+    FromB: Send + ParallelExtend<OP::Right>,
+{
+    type Item = OP::Left;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        let mut result = None;
+        {
+            // Now it's time to find the consumer for type `B`
+            let iter = UnzipB {
+                base: self.base,
+                op: self.op,
+                left_consumer: consumer,
+                left_result: &mut result,
+            };
+            self.b.par_extend(iter);
+        }
+        // NB: If for some reason `b.par_extend` doesn't actually drive the
+        // iterator, then we won't have a result for the left side to return
+        // at all.  We can't fake an arbitrary consumer's result, so panic.
+        result.expect("unzip consumers didn't execute!")
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        if OP::indexable() {
+            self.base.opt_len()
+        } else {
+            None
+        }
+    }
+}
+
+/// A fake iterator to intercept the `Consumer` for type `B`.
+struct UnzipB<'r, I, OP, CA>
+where
+    I: ParallelIterator,
+    OP: UnzipOp<I::Item>,
+    CA: UnindexedConsumer<OP::Left>,
+    CA::Result: 'r,
+{
+    base: I,
+    op: OP,
+    left_consumer: CA,
+    left_result: &'r mut Option<CA::Result>,
+}
+
+impl<'r, I, OP, CA> ParallelIterator for UnzipB<'r, I, OP, CA>
+where
+    I: ParallelIterator,
+    OP: UnzipOp<I::Item>,
+    CA: UnindexedConsumer<OP::Left>,
+{
+    type Item = OP::Right;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        // Now that we have two consumers, we can unzip the real iterator.
+        let consumer = UnzipConsumer {
+            op: &self.op,
+            left: self.left_consumer,
+            right: consumer,
+        };
+
+        let result = self.base.drive_unindexed(consumer);
+        *self.left_result = Some(result.0);
+        result.1
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        if OP::indexable() {
+            self.base.opt_len()
+        } else {
+            None
+        }
+    }
+}
+
+/// `Consumer` that unzips into two other `Consumer`s
+struct UnzipConsumer<'a, OP, CA, CB> {
+    op: &'a OP,
+    left: CA,
+    right: CB,
+}
+
+impl<'a, T, OP, CA, CB> Consumer<T> for UnzipConsumer<'a, OP, CA, CB>
+where
+    OP: UnzipOp<T>,
+    CA: Consumer<OP::Left>,
+    CB: Consumer<OP::Right>,
+{
+    type Folder = UnzipFolder<'a, OP, CA::Folder, CB::Folder>;
+    type Reducer = UnzipReducer<CA::Reducer, CB::Reducer>;
+    type Result = (CA::Result, CB::Result);
+
+    fn split_at(self, index: usize) -> (Self, Self, Self::Reducer) {
+        let (left1, left2, left_reducer) = self.left.split_at(index);
+        let (right1, right2, right_reducer) = self.right.split_at(index);
+
+        (
+            UnzipConsumer {
+                op: self.op,
+                left: left1,
+                right: right1,
+            },
+            UnzipConsumer {
+                op: self.op,
+                left: left2,
+                right: right2,
+            },
+            UnzipReducer {
+                left: left_reducer,
+                right: right_reducer,
+            },
+        )
+    }
+
+    fn into_folder(self) -> Self::Folder {
+        UnzipFolder {
+            op: self.op,
+            left: self.left.into_folder(),
+            right: self.right.into_folder(),
+        }
+    }
+
+    fn full(&self) -> bool {
+        // don't stop until everyone is full
+        self.left.full() && self.right.full()
+    }
+}
+
+impl<'a, T, OP, CA, CB> UnindexedConsumer<T> for UnzipConsumer<'a, OP, CA, CB>
+where
+    OP: UnzipOp<T>,
+    CA: UnindexedConsumer<OP::Left>,
+    CB: UnindexedConsumer<OP::Right>,
+{
+    fn split_off_left(&self) -> Self {
+        UnzipConsumer {
+            op: self.op,
+            left: self.left.split_off_left(),
+            right: self.right.split_off_left(),
+        }
+    }
+
+    fn to_reducer(&self) -> Self::Reducer {
+        UnzipReducer {
+            left: self.left.to_reducer(),
+            right: self.right.to_reducer(),
+        }
+    }
+}
+
+/// `Folder` that unzips into two other `Folder`s
+struct UnzipFolder<'a, OP, FA, FB> {
+    op: &'a OP,
+    left: FA,
+    right: FB,
+}
+
+impl<'a, T, OP, FA, FB> Folder<T> for UnzipFolder<'a, OP, FA, FB>
+where
+    OP: UnzipOp<T>,
+    FA: Folder<OP::Left>,
+    FB: Folder<OP::Right>,
+{
+    type Result = (FA::Result, FB::Result);
+
+    fn consume(self, item: T) -> Self {
+        let (left, right) = self.op.consume(item, self.left, self.right);
+        UnzipFolder {
+            op: self.op,
+            left,
+            right,
+        }
+    }
+
+    fn complete(self) -> Self::Result {
+        (self.left.complete(), self.right.complete())
+    }
+
+    fn full(&self) -> bool {
+        // don't stop until everyone is full
+        self.left.full() && self.right.full()
+    }
+}
+
+/// `Reducer` that unzips into two other `Reducer`s
+struct UnzipReducer<RA, RB> {
+    left: RA,
+    right: RB,
+}
+
+impl<A, B, RA, RB> Reducer<(A, B)> for UnzipReducer<RA, RB>
+where
+    RA: Reducer<A>,
+    RB: Reducer<B>,
+{
+    fn reduce(self, left: (A, B), right: (A, B)) -> (A, B) {
+        (
+            self.left.reduce(left.0, right.0),
+            self.right.reduce(left.1, right.1),
+        )
+    }
+}
+
+impl<A, B, FromA, FromB> ParallelExtend<(A, B)> for (FromA, FromB)
+where
+    A: Send,
+    B: Send,
+    FromA: Send + ParallelExtend<A>,
+    FromB: Send + ParallelExtend<B>,
+{
+    fn par_extend<I>(&mut self, pi: I)
+    where
+        I: IntoParallelIterator<Item = (A, B)>,
+    {
+        execute_into(&mut self.0, &mut self.1, pi.into_par_iter(), Unzip);
+    }
+}
+
+impl<L, R, A, B> ParallelExtend<Either<L, R>> for (A, B)
+where
+    L: Send,
+    R: Send,
+    A: Send + ParallelExtend<L>,
+    B: Send + ParallelExtend<R>,
+{
+    fn par_extend<I>(&mut self, pi: I)
+    where
+        I: IntoParallelIterator<Item = Either<L, R>>,
+    {
+        execute_into(&mut self.0, &mut self.1, pi.into_par_iter(), UnEither);
+    }
+}
+
+/// An `UnzipOp` that routes items depending on their `Either` variant.
+struct UnEither;
+
+impl<L, R> UnzipOp<Either<L, R>> for UnEither
+where
+    L: Send,
+    R: Send,
+{
+    type Left = L;
+    type Right = R;
+
+    fn consume<FL, FR>(&self, item: Either<L, R>, left: FL, right: FR) -> (FL, FR)
+    where
+        FL: Folder<L>,
+        FR: Folder<R>,
+    {
+        match item {
+            Either::Left(item) => (left.consume(item), right),
+            Either::Right(item) => (left, right.consume(item)),
+        }
+    }
+}
+
+impl<A, B, FromA, FromB> FromParallelIterator<(A, B)> for (FromA, FromB)
+where
+    A: Send,
+    B: Send,
+    FromA: Send + FromParallelIterator<A>,
+    FromB: Send + FromParallelIterator<B>,
+{
+    fn from_par_iter<I>(pi: I) -> Self
+    where
+        I: IntoParallelIterator<Item = (A, B)>,
+    {
+        let (a, b): (Collector<FromA>, Collector<FromB>) = pi.into_par_iter().unzip();
+        (a.result.unwrap(), b.result.unwrap())
+    }
+}
+
+impl<L, R, A, B> FromParallelIterator<Either<L, R>> for (A, B)
+where
+    L: Send,
+    R: Send,
+    A: Send + FromParallelIterator<L>,
+    B: Send + FromParallelIterator<R>,
+{
+    fn from_par_iter<I>(pi: I) -> Self
+    where
+        I: IntoParallelIterator<Item = Either<L, R>>,
+    {
+        fn identity<T>(x: T) -> T {
+            x
+        }
+
+        let (a, b): (Collector<A>, Collector<B>) = pi.into_par_iter().partition_map(identity);
+        (a.result.unwrap(), b.result.unwrap())
+    }
+}
+
+/// Shim to implement a one-time `ParallelExtend` using `FromParallelIterator`.
+struct Collector<FromT> {
+    result: Option<FromT>,
+}
+
+impl<FromT> Default for Collector<FromT> {
+    fn default() -> Self {
+        Collector { result: None }
+    }
+}
+
+impl<T, FromT> ParallelExtend<T> for Collector<FromT>
+where
+    T: Send,
+    FromT: Send + FromParallelIterator<T>,
+{
+    fn par_extend<I>(&mut self, pi: I)
+    where
+        I: IntoParallelIterator<Item = T>,
+    {
+        debug_assert!(self.result.is_none());
+        self.result = Some(pi.into_par_iter().collect());
+    }
+}
diff --git a/crates/rayon/src/iter/update.rs b/crates/rayon/src/iter/update.rs
new file mode 100644
index 0000000..c693ac8
--- /dev/null
+++ b/crates/rayon/src/iter/update.rs
@@ -0,0 +1,327 @@
+use super::plumbing::*;
+use super::*;
+
+use std::fmt::{self, Debug};
+
+/// `Update` is an iterator that mutates the elements of an
+/// underlying iterator before they are yielded.
+///
+/// This struct is created by the [`update()`] method on [`ParallelIterator`]
+///
+/// [`update()`]: trait.ParallelIterator.html#method.update
+/// [`ParallelIterator`]: trait.ParallelIterator.html
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Clone)]
+pub struct Update<I: ParallelIterator, F> {
+    base: I,
+    update_op: F,
+}
+
+impl<I: ParallelIterator + Debug, F> Debug for Update<I, F> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Update").field("base", &self.base).finish()
+    }
+}
+
+impl<I, F> Update<I, F>
+where
+    I: ParallelIterator,
+{
+    /// Creates a new `Update` iterator.
+    pub(super) fn new(base: I, update_op: F) -> Self {
+        Update { base, update_op }
+    }
+}
+
+impl<I, F> ParallelIterator for Update<I, F>
+where
+    I: ParallelIterator,
+    F: Fn(&mut I::Item) + Send + Sync,
+{
+    type Item = I::Item;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        let consumer1 = UpdateConsumer::new(consumer, &self.update_op);
+        self.base.drive_unindexed(consumer1)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        self.base.opt_len()
+    }
+}
+
+impl<I, F> IndexedParallelIterator for Update<I, F>
+where
+    I: IndexedParallelIterator,
+    F: Fn(&mut I::Item) + Send + Sync,
+{
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        let consumer1 = UpdateConsumer::new(consumer, &self.update_op);
+        self.base.drive(consumer1)
+    }
+
+    fn len(&self) -> usize {
+        self.base.len()
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        return self.base.with_producer(Callback {
+            callback,
+            update_op: self.update_op,
+        });
+
+        struct Callback<CB, F> {
+            callback: CB,
+            update_op: F,
+        }
+
+        impl<T, F, CB> ProducerCallback<T> for Callback<CB, F>
+        where
+            CB: ProducerCallback<T>,
+            F: Fn(&mut T) + Send + Sync,
+        {
+            type Output = CB::Output;
+
+            fn callback<P>(self, base: P) -> CB::Output
+            where
+                P: Producer<Item = T>,
+            {
+                let producer = UpdateProducer {
+                    base,
+                    update_op: &self.update_op,
+                };
+                self.callback.callback(producer)
+            }
+        }
+    }
+}
+
+/// ////////////////////////////////////////////////////////////////////////
+
+struct UpdateProducer<'f, P, F> {
+    base: P,
+    update_op: &'f F,
+}
+
+impl<'f, P, F> Producer for UpdateProducer<'f, P, F>
+where
+    P: Producer,
+    F: Fn(&mut P::Item) + Send + Sync,
+{
+    type Item = P::Item;
+    type IntoIter = UpdateSeq<P::IntoIter, &'f F>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        UpdateSeq {
+            base: self.base.into_iter(),
+            update_op: self.update_op,
+        }
+    }
+
+    fn min_len(&self) -> usize {
+        self.base.min_len()
+    }
+    fn max_len(&self) -> usize {
+        self.base.max_len()
+    }
+
+    fn split_at(self, index: usize) -> (Self, Self) {
+        let (left, right) = self.base.split_at(index);
+        (
+            UpdateProducer {
+                base: left,
+                update_op: self.update_op,
+            },
+            UpdateProducer {
+                base: right,
+                update_op: self.update_op,
+            },
+        )
+    }
+
+    fn fold_with<G>(self, folder: G) -> G
+    where
+        G: Folder<Self::Item>,
+    {
+        let folder1 = UpdateFolder {
+            base: folder,
+            update_op: self.update_op,
+        };
+        self.base.fold_with(folder1).base
+    }
+}
+
+/// ////////////////////////////////////////////////////////////////////////
+/// Consumer implementation
+
+struct UpdateConsumer<'f, C, F> {
+    base: C,
+    update_op: &'f F,
+}
+
+impl<'f, C, F> UpdateConsumer<'f, C, F> {
+    fn new(base: C, update_op: &'f F) -> Self {
+        UpdateConsumer { base, update_op }
+    }
+}
+
+impl<'f, T, C, F> Consumer<T> for UpdateConsumer<'f, C, F>
+where
+    C: Consumer<T>,
+    F: Fn(&mut T) + Send + Sync,
+{
+    type Folder = UpdateFolder<'f, C::Folder, F>;
+    type Reducer = C::Reducer;
+    type Result = C::Result;
+
+    fn split_at(self, index: usize) -> (Self, Self, Self::Reducer) {
+        let (left, right, reducer) = self.base.split_at(index);
+        (
+            UpdateConsumer::new(left, self.update_op),
+            UpdateConsumer::new(right, self.update_op),
+            reducer,
+        )
+    }
+
+    fn into_folder(self) -> Self::Folder {
+        UpdateFolder {
+            base: self.base.into_folder(),
+            update_op: self.update_op,
+        }
+    }
+
+    fn full(&self) -> bool {
+        self.base.full()
+    }
+}
+
+impl<'f, T, C, F> UnindexedConsumer<T> for UpdateConsumer<'f, C, F>
+where
+    C: UnindexedConsumer<T>,
+    F: Fn(&mut T) + Send + Sync,
+{
+    fn split_off_left(&self) -> Self {
+        UpdateConsumer::new(self.base.split_off_left(), self.update_op)
+    }
+
+    fn to_reducer(&self) -> Self::Reducer {
+        self.base.to_reducer()
+    }
+}
+
+struct UpdateFolder<'f, C, F> {
+    base: C,
+    update_op: &'f F,
+}
+
+fn apply<T>(update_op: impl Fn(&mut T)) -> impl Fn(T) -> T {
+    move |mut item| {
+        update_op(&mut item);
+        item
+    }
+}
+
+impl<'f, T, C, F> Folder<T> for UpdateFolder<'f, C, F>
+where
+    C: Folder<T>,
+    F: Fn(&mut T),
+{
+    type Result = C::Result;
+
+    fn consume(self, mut item: T) -> Self {
+        (self.update_op)(&mut item);
+
+        UpdateFolder {
+            base: self.base.consume(item),
+            update_op: self.update_op,
+        }
+    }
+
+    fn consume_iter<I>(mut self, iter: I) -> Self
+    where
+        I: IntoIterator<Item = T>,
+    {
+        let update_op = self.update_op;
+        self.base = self
+            .base
+            .consume_iter(iter.into_iter().map(apply(update_op)));
+        self
+    }
+
+    fn complete(self) -> C::Result {
+        self.base.complete()
+    }
+
+    fn full(&self) -> bool {
+        self.base.full()
+    }
+}
+
+/// Standard Update adaptor, based on `itertools::adaptors::Update`
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Debug, Clone)]
+struct UpdateSeq<I, F> {
+    base: I,
+    update_op: F,
+}
+
+impl<I, F> Iterator for UpdateSeq<I, F>
+where
+    I: Iterator,
+    F: Fn(&mut I::Item),
+{
+    type Item = I::Item;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let mut v = self.base.next()?;
+        (self.update_op)(&mut v);
+        Some(v)
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.base.size_hint()
+    }
+
+    fn fold<Acc, G>(self, init: Acc, g: G) -> Acc
+    where
+        G: FnMut(Acc, Self::Item) -> Acc,
+    {
+        self.base.map(apply(self.update_op)).fold(init, g)
+    }
+
+    // if possible, re-use inner iterator specializations in collect
+    fn collect<C>(self) -> C
+    where
+        C: ::std::iter::FromIterator<Self::Item>,
+    {
+        self.base.map(apply(self.update_op)).collect()
+    }
+}
+
+impl<I, F> ExactSizeIterator for UpdateSeq<I, F>
+where
+    I: ExactSizeIterator,
+    F: Fn(&mut I::Item),
+{
+}
+
+impl<I, F> DoubleEndedIterator for UpdateSeq<I, F>
+where
+    I: DoubleEndedIterator,
+    F: Fn(&mut I::Item),
+{
+    fn next_back(&mut self) -> Option<Self::Item> {
+        let mut v = self.base.next_back()?;
+        (self.update_op)(&mut v);
+        Some(v)
+    }
+}
diff --git a/crates/rayon/src/iter/while_some.rs b/crates/rayon/src/iter/while_some.rs
new file mode 100644
index 0000000..215047b
--- /dev/null
+++ b/crates/rayon/src/iter/while_some.rs
@@ -0,0 +1,154 @@
+use super::plumbing::*;
+use super::*;
+use std::sync::atomic::{AtomicBool, Ordering};
+
+/// `WhileSome` is an iterator that yields the `Some` elements of an iterator,
+/// halting as soon as any `None` is produced.
+///
+/// This struct is created by the [`while_some()`] method on [`ParallelIterator`]
+///
+/// [`while_some()`]: trait.ParallelIterator.html#method.while_some
+/// [`ParallelIterator`]: trait.ParallelIterator.html
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Debug, Clone)]
+pub struct WhileSome<I: ParallelIterator> {
+    base: I,
+}
+
+impl<I> WhileSome<I>
+where
+    I: ParallelIterator,
+{
+    /// Creates a new `WhileSome` iterator.
+    pub(super) fn new(base: I) -> Self {
+        WhileSome { base }
+    }
+}
+
+impl<I, T> ParallelIterator for WhileSome<I>
+where
+    I: ParallelIterator<Item = Option<T>>,
+    T: Send,
+{
+    type Item = T;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        let full = AtomicBool::new(false);
+        let consumer1 = WhileSomeConsumer {
+            base: consumer,
+            full: &full,
+        };
+        self.base.drive_unindexed(consumer1)
+    }
+}
+
+/// ////////////////////////////////////////////////////////////////////////
+/// Consumer implementation
+
+struct WhileSomeConsumer<'f, C> {
+    base: C,
+    full: &'f AtomicBool,
+}
+
+impl<'f, T, C> Consumer<Option<T>> for WhileSomeConsumer<'f, C>
+where
+    C: Consumer<T>,
+    T: Send,
+{
+    type Folder = WhileSomeFolder<'f, C::Folder>;
+    type Reducer = C::Reducer;
+    type Result = C::Result;
+
+    fn split_at(self, index: usize) -> (Self, Self, Self::Reducer) {
+        let (left, right, reducer) = self.base.split_at(index);
+        (
+            WhileSomeConsumer { base: left, ..self },
+            WhileSomeConsumer {
+                base: right,
+                ..self
+            },
+            reducer,
+        )
+    }
+
+    fn into_folder(self) -> Self::Folder {
+        WhileSomeFolder {
+            base: self.base.into_folder(),
+            full: self.full,
+        }
+    }
+
+    fn full(&self) -> bool {
+        self.full.load(Ordering::Relaxed) || self.base.full()
+    }
+}
+
+impl<'f, T, C> UnindexedConsumer<Option<T>> for WhileSomeConsumer<'f, C>
+where
+    C: UnindexedConsumer<T>,
+    T: Send,
+{
+    fn split_off_left(&self) -> Self {
+        WhileSomeConsumer {
+            base: self.base.split_off_left(),
+            ..*self
+        }
+    }
+
+    fn to_reducer(&self) -> Self::Reducer {
+        self.base.to_reducer()
+    }
+}
+
+struct WhileSomeFolder<'f, C> {
+    base: C,
+    full: &'f AtomicBool,
+}
+
+impl<'f, T, C> Folder<Option<T>> for WhileSomeFolder<'f, C>
+where
+    C: Folder<T>,
+{
+    type Result = C::Result;
+
+    fn consume(mut self, item: Option<T>) -> Self {
+        match item {
+            Some(item) => self.base = self.base.consume(item),
+            None => self.full.store(true, Ordering::Relaxed),
+        }
+        self
+    }
+
+    fn consume_iter<I>(mut self, iter: I) -> Self
+    where
+        I: IntoIterator<Item = Option<T>>,
+    {
+        fn some<T>(full: &AtomicBool) -> impl Fn(&Option<T>) -> bool + '_ {
+            move |x| match *x {
+                Some(_) => !full.load(Ordering::Relaxed),
+                None => {
+                    full.store(true, Ordering::Relaxed);
+                    false
+                }
+            }
+        }
+
+        self.base = self.base.consume_iter(
+            iter.into_iter()
+                .take_while(some(self.full))
+                .map(Option::unwrap),
+        );
+        self
+    }
+
+    fn complete(self) -> C::Result {
+        self.base.complete()
+    }
+
+    fn full(&self) -> bool {
+        self.full.load(Ordering::Relaxed) || self.base.full()
+    }
+}
diff --git a/crates/rayon/src/iter/zip.rs b/crates/rayon/src/iter/zip.rs
new file mode 100644
index 0000000..33823db
--- /dev/null
+++ b/crates/rayon/src/iter/zip.rs
@@ -0,0 +1,159 @@
+use super::plumbing::*;
+use super::*;
+use std::cmp;
+use std::iter;
+
+/// `Zip` is an iterator that zips up `a` and `b` into a single iterator
+/// of pairs. This struct is created by the [`zip()`] method on
+/// [`IndexedParallelIterator`]
+///
+/// [`zip()`]: trait.IndexedParallelIterator.html#method.zip
+/// [`IndexedParallelIterator`]: trait.IndexedParallelIterator.html
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Debug, Clone)]
+pub struct Zip<A: IndexedParallelIterator, B: IndexedParallelIterator> {
+    a: A,
+    b: B,
+}
+
+impl<A, B> Zip<A, B>
+where
+    A: IndexedParallelIterator,
+    B: IndexedParallelIterator,
+{
+    /// Creates a new `Zip` iterator.
+    pub(super) fn new(a: A, b: B) -> Self {
+        Zip { a, b }
+    }
+}
+
+impl<A, B> ParallelIterator for Zip<A, B>
+where
+    A: IndexedParallelIterator,
+    B: IndexedParallelIterator,
+{
+    type Item = (A::Item, B::Item);
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        Some(self.len())
+    }
+}
+
+impl<A, B> IndexedParallelIterator for Zip<A, B>
+where
+    A: IndexedParallelIterator,
+    B: IndexedParallelIterator,
+{
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn len(&self) -> usize {
+        cmp::min(self.a.len(), self.b.len())
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        return self.a.with_producer(CallbackA {
+            callback,
+            b: self.b,
+        });
+
+        struct CallbackA<CB, B> {
+            callback: CB,
+            b: B,
+        }
+
+        impl<CB, ITEM, B> ProducerCallback<ITEM> for CallbackA<CB, B>
+        where
+            B: IndexedParallelIterator,
+            CB: ProducerCallback<(ITEM, B::Item)>,
+        {
+            type Output = CB::Output;
+
+            fn callback<A>(self, a_producer: A) -> Self::Output
+            where
+                A: Producer<Item = ITEM>,
+            {
+                self.b.with_producer(CallbackB {
+                    a_producer,
+                    callback: self.callback,
+                })
+            }
+        }
+
+        struct CallbackB<CB, A> {
+            a_producer: A,
+            callback: CB,
+        }
+
+        impl<CB, A, ITEM> ProducerCallback<ITEM> for CallbackB<CB, A>
+        where
+            A: Producer,
+            CB: ProducerCallback<(A::Item, ITEM)>,
+        {
+            type Output = CB::Output;
+
+            fn callback<B>(self, b_producer: B) -> Self::Output
+            where
+                B: Producer<Item = ITEM>,
+            {
+                self.callback.callback(ZipProducer {
+                    a: self.a_producer,
+                    b: b_producer,
+                })
+            }
+        }
+    }
+}
+
+/// ////////////////////////////////////////////////////////////////////////
+
+struct ZipProducer<A: Producer, B: Producer> {
+    a: A,
+    b: B,
+}
+
+impl<A: Producer, B: Producer> Producer for ZipProducer<A, B> {
+    type Item = (A::Item, B::Item);
+    type IntoIter = iter::Zip<A::IntoIter, B::IntoIter>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.a.into_iter().zip(self.b.into_iter())
+    }
+
+    fn min_len(&self) -> usize {
+        cmp::max(self.a.min_len(), self.b.min_len())
+    }
+
+    fn max_len(&self) -> usize {
+        cmp::min(self.a.max_len(), self.b.max_len())
+    }
+
+    fn split_at(self, index: usize) -> (Self, Self) {
+        let (a_left, a_right) = self.a.split_at(index);
+        let (b_left, b_right) = self.b.split_at(index);
+        (
+            ZipProducer {
+                a: a_left,
+                b: b_left,
+            },
+            ZipProducer {
+                a: a_right,
+                b: b_right,
+            },
+        )
+    }
+}
diff --git a/crates/rayon/src/iter/zip_eq.rs b/crates/rayon/src/iter/zip_eq.rs
new file mode 100644
index 0000000..4e64397
--- /dev/null
+++ b/crates/rayon/src/iter/zip_eq.rs
@@ -0,0 +1,72 @@
+use super::plumbing::*;
+use super::*;
+
+/// An [`IndexedParallelIterator`] that iterates over two parallel iterators of equal
+/// length simultaneously.
+///
+/// This struct is created by the [`zip_eq`] method on [`IndexedParallelIterator`],
+/// see its documentation for more information.
+///
+/// [`zip_eq`]: trait.IndexedParallelIterator.html#method.zip_eq
+/// [`IndexedParallelIterator`]: trait.IndexedParallelIterator.html
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+#[derive(Debug, Clone)]
+pub struct ZipEq<A: IndexedParallelIterator, B: IndexedParallelIterator> {
+    zip: Zip<A, B>,
+}
+
+impl<A, B> ZipEq<A, B>
+where
+    A: IndexedParallelIterator,
+    B: IndexedParallelIterator,
+{
+    /// Creates a new `ZipEq` iterator.
+    pub(super) fn new(a: A, b: B) -> Self {
+        ZipEq {
+            zip: super::Zip::new(a, b),
+        }
+    }
+}
+
+impl<A, B> ParallelIterator for ZipEq<A, B>
+where
+    A: IndexedParallelIterator,
+    B: IndexedParallelIterator,
+{
+    type Item = (A::Item, B::Item);
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        bridge(self.zip, consumer)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        Some(self.zip.len())
+    }
+}
+
+impl<A, B> IndexedParallelIterator for ZipEq<A, B>
+where
+    A: IndexedParallelIterator,
+    B: IndexedParallelIterator,
+{
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        bridge(self.zip, consumer)
+    }
+
+    fn len(&self) -> usize {
+        self.zip.len()
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        self.zip.with_producer(callback)
+    }
+}
diff --git a/crates/rayon/src/lib.rs b/crates/rayon/src/lib.rs
new file mode 100644
index 0000000..dc7fcc0
--- /dev/null
+++ b/crates/rayon/src/lib.rs
@@ -0,0 +1,160 @@
+#![deny(missing_debug_implementations)]
+#![deny(missing_docs)]
+#![deny(unreachable_pub)]
+#![warn(rust_2018_idioms)]
+
+//! Data-parallelism library that makes it easy to convert sequential
+//! computations into parallel
+//!
+//! Rayon is lightweight and convenient for introducing parallelism into existing
+//! code. It guarantees data-race free executions and takes advantage of
+//! parallelism when sensible, based on work-load at runtime.
+//!
+//! # How to use Rayon
+//!
+//! There are two ways to use Rayon:
+//!
+//! - **High-level parallel constructs** are the simplest way to use Rayon and also
+//!   typically the most efficient.
+//!   - [Parallel iterators][iter module] make it easy to convert a sequential iterator to
+//!     execute in parallel.
+//!     - The [`ParallelIterator`] trait defines general methods for all parallel iterators.
+//!     - The [`IndexedParallelIterator`] trait adds methods for iterators that support random
+//!       access.
+//!   - The [`par_sort`] method sorts `&mut [T]` slices (or vectors) in parallel.
+//!   - [`par_extend`] can be used to efficiently grow collections with items produced
+//!     by a parallel iterator.
+//! - **Custom tasks** let you divide your work into parallel tasks yourself.
+//!   - [`join`] is used to subdivide a task into two pieces.
+//!   - [`scope`] creates a scope within which you can create any number of parallel tasks.
+//!   - [`ThreadPoolBuilder`] can be used to create your own thread pools or customize
+//!     the global one.
+//!
+//! [iter module]: iter/index.html
+//! [`join`]: fn.join.html
+//! [`scope`]: fn.scope.html
+//! [`par_sort`]: slice/trait.ParallelSliceMut.html#method.par_sort
+//! [`par_extend`]: iter/trait.ParallelExtend.html#tymethod.par_extend
+//! [`ThreadPoolBuilder`]: struct.ThreadPoolBuilder.html
+//!
+//! # Basic usage and the Rayon prelude
+//!
+//! First, you will need to add `rayon` to your `Cargo.toml`.
+//!
+//! Next, to use parallel iterators or the other high-level methods,
+//! you need to import several traits. Those traits are bundled into
+//! the module [`rayon::prelude`]. It is recommended that you import
+//! all of these traits at once by adding `use rayon::prelude::*` at
+//! the top of each module that uses Rayon methods.
+//!
+//! These traits give you access to the `par_iter` method which provides
+//! parallel implementations of many iterative functions such as [`map`],
+//! [`for_each`], [`filter`], [`fold`], and [more].
+//!
+//! [`rayon::prelude`]: prelude/index.html
+//! [`map`]: iter/trait.ParallelIterator.html#method.map
+//! [`for_each`]: iter/trait.ParallelIterator.html#method.for_each
+//! [`filter`]: iter/trait.ParallelIterator.html#method.filter
+//! [`fold`]: iter/trait.ParallelIterator.html#method.fold
+//! [more]: iter/trait.ParallelIterator.html#provided-methods
+//! [`ParallelIterator`]: iter/trait.ParallelIterator.html
+//! [`IndexedParallelIterator`]: iter/trait.IndexedParallelIterator.html
+//!
+//! # Crate Layout
+//!
+//! Rayon extends many of the types found in the standard library with
+//! parallel iterator implementations. The modules in the `rayon`
+//! crate mirror [`std`] itself: so, e.g., the `option` module in
+//! Rayon contains parallel iterators for the `Option` type, which is
+//! found in [the `option` module of `std`]. Similarly, the
+//! `collections` module in Rayon offers parallel iterator types for
+//! [the `collections` from `std`]. You will rarely need to access
+//! these submodules unless you need to name iterator types
+//! explicitly.
+//!
+//! [the `option` module of `std`]: https://doc.rust-lang.org/std/option/index.html
+//! [the `collections` from `std`]: https://doc.rust-lang.org/std/collections/index.html
+//! [`std`]: https://doc.rust-lang.org/std/
+//!
+//! # Targets without threading
+//!
+//! Rayon has limited support for targets without `std` threading implementations.
+//! See the [`rayon_core`] documentation for more information about its global fallback.
+//!
+//! # Other questions?
+//!
+//! See [the Rayon FAQ][faq].
+//!
+//! [faq]: https://github.com/rayon-rs/rayon/blob/master/FAQ.md
+
+#[macro_use]
+mod delegate;
+
+#[macro_use]
+mod private;
+
+mod split_producer;
+
+pub mod array;
+pub mod collections;
+pub mod iter;
+pub mod option;
+pub mod prelude;
+pub mod range;
+pub mod range_inclusive;
+pub mod result;
+pub mod slice;
+pub mod str;
+pub mod string;
+pub mod vec;
+
+mod math;
+mod par_either;
+
+mod compile_fail;
+
+pub use rayon_core::FnContext;
+pub use rayon_core::ThreadBuilder;
+pub use rayon_core::ThreadPool;
+pub use rayon_core::ThreadPoolBuildError;
+pub use rayon_core::ThreadPoolBuilder;
+pub use rayon_core::{broadcast, spawn_broadcast, BroadcastContext};
+pub use rayon_core::{current_num_threads, current_thread_index, max_num_threads};
+pub use rayon_core::{in_place_scope, scope, Scope};
+pub use rayon_core::{in_place_scope_fifo, scope_fifo, ScopeFifo};
+pub use rayon_core::{join, join_context};
+pub use rayon_core::{spawn, spawn_fifo};
+pub use rayon_core::{yield_local, yield_now, Yield};
+
+/// We need to transmit raw pointers across threads. It is possible to do this
+/// without any unsafe code by converting pointers to usize or to AtomicPtr<T>
+/// then back to a raw pointer for use. We prefer this approach because code
+/// that uses this type is more explicit.
+///
+/// Unsafe code is still required to dereference the pointer, so this type is
+/// not unsound on its own, although it does partly lift the unconditional
+/// !Send and !Sync on raw pointers. As always, dereference with care.
+struct SendPtr<T>(*mut T);
+
+// SAFETY: !Send for raw pointers is not for safety, just as a lint
+unsafe impl<T: Send> Send for SendPtr<T> {}
+
+// SAFETY: !Sync for raw pointers is not for safety, just as a lint
+unsafe impl<T: Send> Sync for SendPtr<T> {}
+
+impl<T> SendPtr<T> {
+    // Helper to avoid disjoint captures of `send_ptr.0`
+    fn get(self) -> *mut T {
+        self.0
+    }
+}
+
+// Implement Clone without the T: Clone bound from the derive
+impl<T> Clone for SendPtr<T> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+// Implement Copy without the T: Copy bound from the derive
+impl<T> Copy for SendPtr<T> {}
diff --git a/crates/rayon/src/math.rs b/crates/rayon/src/math.rs
new file mode 100644
index 0000000..3a630be
--- /dev/null
+++ b/crates/rayon/src/math.rs
@@ -0,0 +1,54 @@
+use std::ops::{Bound, Range, RangeBounds};
+
+/// Divide `n` by `divisor`, and round up to the nearest integer
+/// if not evenly divisible.
+#[inline]
+pub(super) fn div_round_up(n: usize, divisor: usize) -> usize {
+    debug_assert!(divisor != 0, "Division by zero!");
+    if n == 0 {
+        0
+    } else {
+        (n - 1) / divisor + 1
+    }
+}
+
+/// Normalize arbitrary `RangeBounds` to a `Range`
+pub(super) fn simplify_range(range: impl RangeBounds<usize>, len: usize) -> Range<usize> {
+    let start = match range.start_bound() {
+        Bound::Unbounded => 0,
+        Bound::Included(&i) if i <= len => i,
+        Bound::Excluded(&i) if i < len => i + 1,
+        bound => panic!("range start {:?} should be <= length {}", bound, len),
+    };
+    let end = match range.end_bound() {
+        Bound::Unbounded => len,
+        Bound::Excluded(&i) if i <= len => i,
+        Bound::Included(&i) if i < len => i + 1,
+        bound => panic!("range end {:?} should be <= length {}", bound, len),
+    };
+    if start > end {
+        panic!(
+            "range start {:?} should be <= range end {:?}",
+            range.start_bound(),
+            range.end_bound()
+        );
+    }
+    start..end
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn check_div_round_up() {
+        assert_eq!(0, div_round_up(0, 5));
+        assert_eq!(1, div_round_up(5, 5));
+        assert_eq!(1, div_round_up(1, 5));
+        assert_eq!(2, div_round_up(3, 2));
+        assert_eq!(
+            usize::max_value() / 2 + 1,
+            div_round_up(usize::max_value(), 2)
+        );
+    }
+}
diff --git a/crates/rayon/src/option.rs b/crates/rayon/src/option.rs
new file mode 100644
index 0000000..0f56896
--- /dev/null
+++ b/crates/rayon/src/option.rs
@@ -0,0 +1,203 @@
+//! Parallel iterator types for [options][std::option]
+//!
+//! You will rarely need to interact with this module directly unless you need
+//! to name one of the iterator types.
+//!
+//! [std::option]: https://doc.rust-lang.org/stable/std/option/
+
+use crate::iter::plumbing::*;
+use crate::iter::*;
+use std::sync::atomic::{AtomicBool, Ordering};
+
+/// A parallel iterator over the value in [`Some`] variant of an [`Option`].
+///
+/// The iterator yields one value if the [`Option`] is a [`Some`], otherwise none.
+///
+/// This `struct` is created by the [`into_par_iter`] function.
+///
+/// [`Option`]: https://doc.rust-lang.org/std/option/enum.Option.html
+/// [`Some`]: https://doc.rust-lang.org/std/option/enum.Option.html#variant.Some
+/// [`into_par_iter`]: ../iter/trait.IntoParallelIterator.html#tymethod.into_par_iter
+#[derive(Debug, Clone)]
+pub struct IntoIter<T: Send> {
+    opt: Option<T>,
+}
+
+impl<T: Send> IntoParallelIterator for Option<T> {
+    type Item = T;
+    type Iter = IntoIter<T>;
+
+    fn into_par_iter(self) -> Self::Iter {
+        IntoIter { opt: self }
+    }
+}
+
+impl<T: Send> ParallelIterator for IntoIter<T> {
+    type Item = T;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        self.drive(consumer)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        Some(self.len())
+    }
+}
+
+impl<T: Send> IndexedParallelIterator for IntoIter<T> {
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        let mut folder = consumer.into_folder();
+        if let Some(item) = self.opt {
+            folder = folder.consume(item);
+        }
+        folder.complete()
+    }
+
+    fn len(&self) -> usize {
+        match self.opt {
+            Some(_) => 1,
+            None => 0,
+        }
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        callback.callback(OptionProducer { opt: self.opt })
+    }
+}
+
+/// A parallel iterator over a reference to the [`Some`] variant of an [`Option`].
+///
+/// The iterator yields one value if the [`Option`] is a [`Some`], otherwise none.
+///
+/// This `struct` is created by the [`par_iter`] function.
+///
+/// [`Option`]: https://doc.rust-lang.org/std/option/enum.Option.html
+/// [`Some`]: https://doc.rust-lang.org/std/option/enum.Option.html#variant.Some
+/// [`par_iter`]: ../iter/trait.IntoParallelRefIterator.html#tymethod.par_iter
+#[derive(Debug)]
+pub struct Iter<'a, T: Sync> {
+    inner: IntoIter<&'a T>,
+}
+
+impl<'a, T: Sync> Clone for Iter<'a, T> {
+    fn clone(&self) -> Self {
+        Iter {
+            inner: self.inner.clone(),
+        }
+    }
+}
+
+impl<'a, T: Sync> IntoParallelIterator for &'a Option<T> {
+    type Item = &'a T;
+    type Iter = Iter<'a, T>;
+
+    fn into_par_iter(self) -> Self::Iter {
+        Iter {
+            inner: self.as_ref().into_par_iter(),
+        }
+    }
+}
+
+delegate_indexed_iterator! {
+    Iter<'a, T> => &'a T,
+    impl<'a, T: Sync + 'a>
+}
+
+/// A parallel iterator over a mutable reference to the [`Some`] variant of an [`Option`].
+///
+/// The iterator yields one value if the [`Option`] is a [`Some`], otherwise none.
+///
+/// This `struct` is created by the [`par_iter_mut`] function.
+///
+/// [`Option`]: https://doc.rust-lang.org/std/option/enum.Option.html
+/// [`Some`]: https://doc.rust-lang.org/std/option/enum.Option.html#variant.Some
+/// [`par_iter_mut`]: ../iter/trait.IntoParallelRefMutIterator.html#tymethod.par_iter_mut
+#[derive(Debug)]
+pub struct IterMut<'a, T: Send> {
+    inner: IntoIter<&'a mut T>,
+}
+
+impl<'a, T: Send> IntoParallelIterator for &'a mut Option<T> {
+    type Item = &'a mut T;
+    type Iter = IterMut<'a, T>;
+
+    fn into_par_iter(self) -> Self::Iter {
+        IterMut {
+            inner: self.as_mut().into_par_iter(),
+        }
+    }
+}
+
+delegate_indexed_iterator! {
+    IterMut<'a, T> => &'a mut T,
+    impl<'a, T: Send + 'a>
+}
+
+/// Private producer for an option
+struct OptionProducer<T: Send> {
+    opt: Option<T>,
+}
+
+impl<T: Send> Producer for OptionProducer<T> {
+    type Item = T;
+    type IntoIter = std::option::IntoIter<T>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.opt.into_iter()
+    }
+
+    fn split_at(self, index: usize) -> (Self, Self) {
+        debug_assert!(index <= 1);
+        let none = OptionProducer { opt: None };
+        if index == 0 {
+            (none, self)
+        } else {
+            (self, none)
+        }
+    }
+}
+
+/// Collect an arbitrary `Option`-wrapped collection.
+///
+/// If any item is `None`, then all previous items collected are discarded,
+/// and it returns only `None`.
+impl<C, T> FromParallelIterator<Option<T>> for Option<C>
+where
+    C: FromParallelIterator<T>,
+    T: Send,
+{
+    fn from_par_iter<I>(par_iter: I) -> Self
+    where
+        I: IntoParallelIterator<Item = Option<T>>,
+    {
+        fn check<T>(found_none: &AtomicBool) -> impl Fn(&Option<T>) + '_ {
+            move |item| {
+                if item.is_none() {
+                    found_none.store(true, Ordering::Relaxed);
+                }
+            }
+        }
+
+        let found_none = AtomicBool::new(false);
+        let collection = par_iter
+            .into_par_iter()
+            .inspect(check(&found_none))
+            .while_some()
+            .collect();
+
+        if found_none.load(Ordering::Relaxed) {
+            None
+        } else {
+            Some(collection)
+        }
+    }
+}
diff --git a/crates/rayon/src/par_either.rs b/crates/rayon/src/par_either.rs
new file mode 100644
index 0000000..a19ce53
--- /dev/null
+++ b/crates/rayon/src/par_either.rs
@@ -0,0 +1,74 @@
+use crate::iter::plumbing::*;
+use crate::iter::Either::{Left, Right};
+use crate::iter::*;
+
+/// `Either<L, R>` is a parallel iterator if both `L` and `R` are parallel iterators.
+impl<L, R> ParallelIterator for Either<L, R>
+where
+    L: ParallelIterator,
+    R: ParallelIterator<Item = L::Item>,
+{
+    type Item = L::Item;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        match self {
+            Left(iter) => iter.drive_unindexed(consumer),
+            Right(iter) => iter.drive_unindexed(consumer),
+        }
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        self.as_ref().either(L::opt_len, R::opt_len)
+    }
+}
+
+impl<L, R> IndexedParallelIterator for Either<L, R>
+where
+    L: IndexedParallelIterator,
+    R: IndexedParallelIterator<Item = L::Item>,
+{
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        match self {
+            Left(iter) => iter.drive(consumer),
+            Right(iter) => iter.drive(consumer),
+        }
+    }
+
+    fn len(&self) -> usize {
+        self.as_ref().either(L::len, R::len)
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        match self {
+            Left(iter) => iter.with_producer(callback),
+            Right(iter) => iter.with_producer(callback),
+        }
+    }
+}
+
+/// `Either<L, R>` can be extended if both `L` and `R` are parallel extendable.
+impl<L, R, T> ParallelExtend<T> for Either<L, R>
+where
+    L: ParallelExtend<T>,
+    R: ParallelExtend<T>,
+    T: Send,
+{
+    fn par_extend<I>(&mut self, par_iter: I)
+    where
+        I: IntoParallelIterator<Item = T>,
+    {
+        match self.as_mut() {
+            Left(collection) => collection.par_extend(par_iter),
+            Right(collection) => collection.par_extend(par_iter),
+        }
+    }
+}
diff --git a/crates/rayon/src/prelude.rs b/crates/rayon/src/prelude.rs
new file mode 100644
index 0000000..6eaca06
--- /dev/null
+++ b/crates/rayon/src/prelude.rs
@@ -0,0 +1,17 @@
+//! The rayon prelude imports the various `ParallelIterator` traits.
+//! The intention is that one can include `use rayon::prelude::*` and
+//! have easy access to the various traits and methods you will need.
+
+pub use crate::iter::FromParallelIterator;
+pub use crate::iter::IndexedParallelIterator;
+pub use crate::iter::IntoParallelIterator;
+pub use crate::iter::IntoParallelRefIterator;
+pub use crate::iter::IntoParallelRefMutIterator;
+pub use crate::iter::ParallelBridge;
+pub use crate::iter::ParallelDrainFull;
+pub use crate::iter::ParallelDrainRange;
+pub use crate::iter::ParallelExtend;
+pub use crate::iter::ParallelIterator;
+pub use crate::slice::ParallelSlice;
+pub use crate::slice::ParallelSliceMut;
+pub use crate::str::ParallelString;
diff --git a/crates/rayon/src/private.rs b/crates/rayon/src/private.rs
new file mode 100644
index 0000000..c85e77b
--- /dev/null
+++ b/crates/rayon/src/private.rs
@@ -0,0 +1,26 @@
+//! The public parts of this private module are used to create traits
+//! that cannot be implemented outside of our own crate.  This way we
+//! can feel free to extend those traits without worrying about it
+//! being a breaking change for other implementations.
+
+/// If this type is pub but not publicly reachable, third parties
+/// can't name it and can't implement traits using it.
+#[allow(missing_debug_implementations)]
+pub struct PrivateMarker;
+
+macro_rules! private_decl {
+    () => {
+        /// This trait is private; this method exists to make it
+        /// impossible to implement outside the crate.
+        #[doc(hidden)]
+        fn __rayon_private__(&self) -> crate::private::PrivateMarker;
+    };
+}
+
+macro_rules! private_impl {
+    () => {
+        fn __rayon_private__(&self) -> crate::private::PrivateMarker {
+            crate::private::PrivateMarker
+        }
+    };
+}
diff --git a/crates/rayon/src/range.rs b/crates/rayon/src/range.rs
new file mode 100644
index 0000000..57b613e
--- /dev/null
+++ b/crates/rayon/src/range.rs
@@ -0,0 +1,462 @@
+//! Parallel iterator types for [ranges][std::range],
+//! the type for values created by `a..b` expressions
+//!
+//! You will rarely need to interact with this module directly unless you have
+//! need to name one of the iterator types.
+//!
+//! ```
+//! use rayon::prelude::*;
+//!
+//! let r = (0..100u64).into_par_iter()
+//!                    .sum();
+//!
+//! // compare result with sequential calculation
+//! assert_eq!((0..100).sum::<u64>(), r);
+//! ```
+//!
+//! [std::range]: https://doc.rust-lang.org/core/ops/struct.Range.html
+
+use crate::iter::plumbing::*;
+use crate::iter::*;
+use std::char;
+use std::convert::TryFrom;
+use std::ops::Range;
+use std::usize;
+
+/// Parallel iterator over a range, implemented for all integer types and `char`.
+///
+/// **Note:** The `zip` operation requires `IndexedParallelIterator`
+/// which is not implemented for `u64`, `i64`, `u128`, or `i128`.
+///
+/// ```
+/// use rayon::prelude::*;
+///
+/// let p = (0..25usize).into_par_iter()
+///                   .zip(0..25usize)
+///                   .filter(|&(x, y)| x % 5 == 0 || y % 5 == 0)
+///                   .map(|(x, y)| x * y)
+///                   .sum::<usize>();
+///
+/// let s = (0..25usize).zip(0..25)
+///                   .filter(|&(x, y)| x % 5 == 0 || y % 5 == 0)
+///                   .map(|(x, y)| x * y)
+///                   .sum();
+///
+/// assert_eq!(p, s);
+/// ```
+#[derive(Debug, Clone)]
+pub struct Iter<T> {
+    range: Range<T>,
+}
+
+/// Implemented for ranges of all primitive integer types and `char`.
+impl<T> IntoParallelIterator for Range<T>
+where
+    Iter<T>: ParallelIterator,
+{
+    type Item = <Iter<T> as ParallelIterator>::Item;
+    type Iter = Iter<T>;
+
+    fn into_par_iter(self) -> Self::Iter {
+        Iter { range: self }
+    }
+}
+
+struct IterProducer<T> {
+    range: Range<T>,
+}
+
+impl<T> IntoIterator for IterProducer<T>
+where
+    Range<T>: Iterator,
+{
+    type Item = <Range<T> as Iterator>::Item;
+    type IntoIter = Range<T>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.range
+    }
+}
+
+/// These traits help drive integer type inference. Without them, an unknown `{integer}` type only
+/// has constraints on `Iter<{integer}>`, which will probably give up and use `i32`. By adding
+/// these traits on the item type, the compiler can see a more direct constraint to infer like
+/// `{integer}: RangeInteger`, which works better. See `test_issue_833` for an example.
+///
+/// They have to be `pub` since they're seen in the public `impl ParallelIterator` constraints, but
+/// we put them in a private modules so they're not actually reachable in our public API.
+mod private {
+    use super::*;
+
+    /// Implementation details of `ParallelIterator for Iter<Self>`
+    pub trait RangeInteger: Sized + Send {
+        private_decl! {}
+
+        fn drive_unindexed<C>(iter: Iter<Self>, consumer: C) -> C::Result
+        where
+            C: UnindexedConsumer<Self>;
+
+        fn opt_len(iter: &Iter<Self>) -> Option<usize>;
+    }
+
+    /// Implementation details of `IndexedParallelIterator for Iter<Self>`
+    pub trait IndexedRangeInteger: RangeInteger {
+        private_decl! {}
+
+        fn drive<C>(iter: Iter<Self>, consumer: C) -> C::Result
+        where
+            C: Consumer<Self>;
+
+        fn len(iter: &Iter<Self>) -> usize;
+
+        fn with_producer<CB>(iter: Iter<Self>, callback: CB) -> CB::Output
+        where
+            CB: ProducerCallback<Self>;
+    }
+}
+use private::{IndexedRangeInteger, RangeInteger};
+
+impl<T: RangeInteger> ParallelIterator for Iter<T> {
+    type Item = T;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<T>,
+    {
+        T::drive_unindexed(self, consumer)
+    }
+
+    #[inline]
+    fn opt_len(&self) -> Option<usize> {
+        T::opt_len(self)
+    }
+}
+
+impl<T: IndexedRangeInteger> IndexedParallelIterator for Iter<T> {
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<T>,
+    {
+        T::drive(self, consumer)
+    }
+
+    #[inline]
+    fn len(&self) -> usize {
+        T::len(self)
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<T>,
+    {
+        T::with_producer(self, callback)
+    }
+}
+
+macro_rules! indexed_range_impl {
+    ( $t:ty ) => {
+        impl RangeInteger for $t {
+            private_impl! {}
+
+            fn drive_unindexed<C>(iter: Iter<$t>, consumer: C) -> C::Result
+            where
+                C: UnindexedConsumer<$t>,
+            {
+                bridge(iter, consumer)
+            }
+
+            fn opt_len(iter: &Iter<$t>) -> Option<usize> {
+                Some(iter.range.len())
+            }
+        }
+
+        impl IndexedRangeInteger for $t {
+            private_impl! {}
+
+            fn drive<C>(iter: Iter<$t>, consumer: C) -> C::Result
+            where
+                C: Consumer<$t>,
+            {
+                bridge(iter, consumer)
+            }
+
+            fn len(iter: &Iter<$t>) -> usize {
+                iter.range.len()
+            }
+
+            fn with_producer<CB>(iter: Iter<$t>, callback: CB) -> CB::Output
+            where
+                CB: ProducerCallback<$t>,
+            {
+                callback.callback(IterProducer { range: iter.range })
+            }
+        }
+
+        impl Producer for IterProducer<$t> {
+            type Item = <Range<$t> as Iterator>::Item;
+            type IntoIter = Range<$t>;
+            fn into_iter(self) -> Self::IntoIter {
+                self.range
+            }
+
+            fn split_at(self, index: usize) -> (Self, Self) {
+                assert!(index <= self.range.len());
+                // For signed $t, the length and requested index could be greater than $t::MAX, and
+                // then `index as $t` could wrap to negative, so wrapping_add is necessary.
+                let mid = self.range.start.wrapping_add(index as $t);
+                let left = self.range.start..mid;
+                let right = mid..self.range.end;
+                (IterProducer { range: left }, IterProducer { range: right })
+            }
+        }
+    };
+}
+
+trait UnindexedRangeLen<L> {
+    fn len(&self) -> L;
+}
+
+macro_rules! unindexed_range_impl {
+    ( $t:ty, $len_t:ty ) => {
+        impl UnindexedRangeLen<$len_t> for Range<$t> {
+            fn len(&self) -> $len_t {
+                let &Range { start, end } = self;
+                if end > start {
+                    end.wrapping_sub(start) as $len_t
+                } else {
+                    0
+                }
+            }
+        }
+
+        impl RangeInteger for $t {
+            private_impl! {}
+
+            fn drive_unindexed<C>(iter: Iter<$t>, consumer: C) -> C::Result
+            where
+                C: UnindexedConsumer<$t>,
+            {
+                #[inline]
+                fn offset(start: $t) -> impl Fn(usize) -> $t {
+                    move |i| start.wrapping_add(i as $t)
+                }
+
+                if let Some(len) = iter.opt_len() {
+                    // Drive this in indexed mode for better `collect`.
+                    (0..len)
+                        .into_par_iter()
+                        .map(offset(iter.range.start))
+                        .drive(consumer)
+                } else {
+                    bridge_unindexed(IterProducer { range: iter.range }, consumer)
+                }
+            }
+
+            fn opt_len(iter: &Iter<$t>) -> Option<usize> {
+                usize::try_from(iter.range.len()).ok()
+            }
+        }
+
+        impl UnindexedProducer for IterProducer<$t> {
+            type Item = $t;
+
+            fn split(mut self) -> (Self, Option<Self>) {
+                let index = self.range.len() / 2;
+                if index > 0 {
+                    let mid = self.range.start.wrapping_add(index as $t);
+                    let right = mid..self.range.end;
+                    self.range.end = mid;
+                    (self, Some(IterProducer { range: right }))
+                } else {
+                    (self, None)
+                }
+            }
+
+            fn fold_with<F>(self, folder: F) -> F
+            where
+                F: Folder<Self::Item>,
+            {
+                folder.consume_iter(self)
+            }
+        }
+    };
+}
+
+// all Range<T> with ExactSizeIterator
+indexed_range_impl! {u8}
+indexed_range_impl! {u16}
+indexed_range_impl! {u32}
+indexed_range_impl! {usize}
+indexed_range_impl! {i8}
+indexed_range_impl! {i16}
+indexed_range_impl! {i32}
+indexed_range_impl! {isize}
+
+// other Range<T> with just Iterator
+unindexed_range_impl! {u64, u64}
+unindexed_range_impl! {i64, u64}
+unindexed_range_impl! {u128, u128}
+unindexed_range_impl! {i128, u128}
+
+// char is special because of the surrogate range hole
+macro_rules! convert_char {
+    ( $self:ident . $method:ident ( $( $arg:expr ),* ) ) => {{
+        let start = $self.range.start as u32;
+        let end = $self.range.end as u32;
+        if start < 0xD800 && 0xE000 < end {
+            // chain the before and after surrogate range fragments
+            (start..0xD800)
+                .into_par_iter()
+                .chain(0xE000..end)
+                .map(|codepoint| unsafe { char::from_u32_unchecked(codepoint) })
+                .$method($( $arg ),*)
+        } else {
+            // no surrogate range to worry about
+            (start..end)
+                .into_par_iter()
+                .map(|codepoint| unsafe { char::from_u32_unchecked(codepoint) })
+                .$method($( $arg ),*)
+        }
+    }};
+}
+
+impl ParallelIterator for Iter<char> {
+    type Item = char;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        convert_char!(self.drive(consumer))
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        Some(self.len())
+    }
+}
+
+impl IndexedParallelIterator for Iter<char> {
+    // Split at the surrogate range first if we're allowed to
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        convert_char!(self.drive(consumer))
+    }
+
+    fn len(&self) -> usize {
+        // Taken from <char as Step>::steps_between
+        let start = self.range.start as u32;
+        let end = self.range.end as u32;
+        if start < end {
+            let mut count = end - start;
+            if start < 0xD800 && 0xE000 <= end {
+                count -= 0x800
+            }
+            count as usize
+        } else {
+            0
+        }
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        convert_char!(self.with_producer(callback))
+    }
+}
+
+#[test]
+fn check_range_split_at_overflow() {
+    // Note, this split index overflows i8!
+    let producer = IterProducer { range: -100i8..100 };
+    let (left, right) = producer.split_at(150);
+    let r1: i32 = left.range.map(i32::from).sum();
+    let r2: i32 = right.range.map(i32::from).sum();
+    assert_eq!(r1 + r2, -100);
+}
+
+#[test]
+fn test_i128_len_doesnt_overflow() {
+    use std::{i128, u128};
+
+    // Using parse because some versions of rust don't allow long literals
+    let octillion: i128 = "1000000000000000000000000000".parse().unwrap();
+    let producer = IterProducer {
+        range: 0..octillion,
+    };
+
+    assert_eq!(octillion as u128, producer.range.len());
+    assert_eq!(octillion as u128, (0..octillion).len());
+    assert_eq!(2 * octillion as u128, (-octillion..octillion).len());
+
+    assert_eq!(u128::MAX, (i128::MIN..i128::MAX).len());
+}
+
+#[test]
+fn test_u64_opt_len() {
+    use std::{u64, usize};
+    assert_eq!(Some(100), (0..100u64).into_par_iter().opt_len());
+    assert_eq!(
+        Some(usize::MAX),
+        (0..usize::MAX as u64).into_par_iter().opt_len()
+    );
+    if (usize::MAX as u64) < u64::MAX {
+        assert_eq!(
+            None,
+            (0..(usize::MAX as u64).wrapping_add(1))
+                .into_par_iter()
+                .opt_len()
+        );
+        assert_eq!(None, (0..u64::MAX).into_par_iter().opt_len());
+    }
+}
+
+#[test]
+fn test_u128_opt_len() {
+    use std::{u128, usize};
+    assert_eq!(Some(100), (0..100u128).into_par_iter().opt_len());
+    assert_eq!(
+        Some(usize::MAX),
+        (0..usize::MAX as u128).into_par_iter().opt_len()
+    );
+    assert_eq!(None, (0..1 + usize::MAX as u128).into_par_iter().opt_len());
+    assert_eq!(None, (0..u128::MAX).into_par_iter().opt_len());
+}
+
+// `usize as i64` can overflow, so make sure to wrap it appropriately
+// when using the `opt_len` "indexed" mode.
+#[test]
+#[cfg(target_pointer_width = "64")]
+fn test_usize_i64_overflow() {
+    use crate::ThreadPoolBuilder;
+    use std::i64;
+
+    let iter = (-2..i64::MAX).into_par_iter();
+    assert_eq!(iter.opt_len(), Some(i64::MAX as usize + 2));
+
+    // always run with multiple threads to split into, or this will take forever...
+    let pool = ThreadPoolBuilder::new().num_threads(8).build().unwrap();
+    pool.install(|| assert_eq!(iter.find_last(|_| true), Some(i64::MAX - 1)));
+}
+
+#[test]
+fn test_issue_833() {
+    fn is_even(n: i64) -> bool {
+        n % 2 == 0
+    }
+
+    // The integer type should be inferred from `is_even`
+    let v: Vec<_> = (1..100).into_par_iter().filter(|&x| is_even(x)).collect();
+    assert!(v.into_iter().eq((2..100).step_by(2)));
+
+    // Try examples with indexed iterators too
+    let pos = (0..100).into_par_iter().position_any(|x| x == 50i16);
+    assert_eq!(pos, Some(50usize));
+
+    assert!((0..100)
+        .into_par_iter()
+        .zip(0..100)
+        .all(|(a, b)| i16::eq(&a, &b)));
+}
diff --git a/crates/rayon/src/range_inclusive.rs b/crates/rayon/src/range_inclusive.rs
new file mode 100644
index 0000000..b7bb0ca
--- /dev/null
+++ b/crates/rayon/src/range_inclusive.rs
@@ -0,0 +1,386 @@
+//! Parallel iterator types for [inclusive ranges][std::range],
+//! the type for values created by `a..=b` expressions
+//!
+//! You will rarely need to interact with this module directly unless you have
+//! need to name one of the iterator types.
+//!
+//! ```
+//! use rayon::prelude::*;
+//!
+//! let r = (0..=100u64).into_par_iter()
+//!                     .sum();
+//!
+//! // compare result with sequential calculation
+//! assert_eq!((0..=100).sum::<u64>(), r);
+//! ```
+//!
+//! [std::range]: https://doc.rust-lang.org/core/ops/struct.RangeInclusive.html
+
+use crate::iter::plumbing::*;
+use crate::iter::*;
+use std::char;
+use std::ops::RangeInclusive;
+
+/// Parallel iterator over an inclusive range, implemented for all integer types and `char`.
+///
+/// **Note:** The `zip` operation requires `IndexedParallelIterator`
+/// which is only implemented for `u8`, `i8`, `u16`, `i16`, and `char`.
+///
+/// ```
+/// use rayon::prelude::*;
+///
+/// let p = (0..=25u16).into_par_iter()
+///                   .zip(0..=25u16)
+///                   .filter(|&(x, y)| x % 5 == 0 || y % 5 == 0)
+///                   .map(|(x, y)| x * y)
+///                   .sum::<u16>();
+///
+/// let s = (0..=25u16).zip(0..=25u16)
+///                   .filter(|&(x, y)| x % 5 == 0 || y % 5 == 0)
+///                   .map(|(x, y)| x * y)
+///                   .sum();
+///
+/// assert_eq!(p, s);
+/// ```
+#[derive(Debug, Clone)]
+pub struct Iter<T> {
+    range: RangeInclusive<T>,
+}
+
+impl<T> Iter<T>
+where
+    RangeInclusive<T>: Eq,
+    T: Ord + Copy,
+{
+    /// Returns `Some((start, end))` for `start..=end`, or `None` if it is exhausted.
+    ///
+    /// Note that `RangeInclusive` does not specify the bounds of an exhausted iterator,
+    /// so this is a way for us to figure out what we've got.  Thankfully, all of the
+    /// integer types we care about can be trivially cloned.
+    fn bounds(&self) -> Option<(T, T)> {
+        let start = *self.range.start();
+        let end = *self.range.end();
+        if start <= end && self.range == (start..=end) {
+            // If the range is still nonempty, this is obviously true
+            // If the range is exhausted, either start > end or
+            // the range does not equal start..=end.
+            Some((start, end))
+        } else {
+            None
+        }
+    }
+}
+
+/// Implemented for ranges of all primitive integer types and `char`.
+impl<T> IntoParallelIterator for RangeInclusive<T>
+where
+    Iter<T>: ParallelIterator,
+{
+    type Item = <Iter<T> as ParallelIterator>::Item;
+    type Iter = Iter<T>;
+
+    fn into_par_iter(self) -> Self::Iter {
+        Iter { range: self }
+    }
+}
+
+/// These traits help drive integer type inference. Without them, an unknown `{integer}` type only
+/// has constraints on `Iter<{integer}>`, which will probably give up and use `i32`. By adding
+/// these traits on the item type, the compiler can see a more direct constraint to infer like
+/// `{integer}: RangeInteger`, which works better. See `test_issue_833` for an example.
+///
+/// They have to be `pub` since they're seen in the public `impl ParallelIterator` constraints, but
+/// we put them in a private modules so they're not actually reachable in our public API.
+mod private {
+    use super::*;
+
+    /// Implementation details of `ParallelIterator for Iter<Self>`
+    pub trait RangeInteger: Sized + Send {
+        private_decl! {}
+
+        fn drive_unindexed<C>(iter: Iter<Self>, consumer: C) -> C::Result
+        where
+            C: UnindexedConsumer<Self>;
+
+        fn opt_len(iter: &Iter<Self>) -> Option<usize>;
+    }
+
+    /// Implementation details of `IndexedParallelIterator for Iter<Self>`
+    pub trait IndexedRangeInteger: RangeInteger {
+        private_decl! {}
+
+        fn drive<C>(iter: Iter<Self>, consumer: C) -> C::Result
+        where
+            C: Consumer<Self>;
+
+        fn len(iter: &Iter<Self>) -> usize;
+
+        fn with_producer<CB>(iter: Iter<Self>, callback: CB) -> CB::Output
+        where
+            CB: ProducerCallback<Self>;
+    }
+}
+use private::{IndexedRangeInteger, RangeInteger};
+
+impl<T: RangeInteger> ParallelIterator for Iter<T> {
+    type Item = T;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<T>,
+    {
+        T::drive_unindexed(self, consumer)
+    }
+
+    #[inline]
+    fn opt_len(&self) -> Option<usize> {
+        T::opt_len(self)
+    }
+}
+
+impl<T: IndexedRangeInteger> IndexedParallelIterator for Iter<T> {
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<T>,
+    {
+        T::drive(self, consumer)
+    }
+
+    #[inline]
+    fn len(&self) -> usize {
+        T::len(self)
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<T>,
+    {
+        T::with_producer(self, callback)
+    }
+}
+
+macro_rules! convert {
+    ( $iter:ident . $method:ident ( $( $arg:expr ),* ) ) => {
+        if let Some((start, end)) = $iter.bounds() {
+            if let Some(end) = end.checked_add(1) {
+                (start..end).into_par_iter().$method($( $arg ),*)
+            } else {
+                (start..end).into_par_iter().chain(once(end)).$method($( $arg ),*)
+            }
+        } else {
+            empty::<Self>().$method($( $arg ),*)
+        }
+    };
+}
+
+macro_rules! parallel_range_impl {
+    ( $t:ty ) => {
+        impl RangeInteger for $t {
+            private_impl! {}
+
+            fn drive_unindexed<C>(iter: Iter<$t>, consumer: C) -> C::Result
+            where
+                C: UnindexedConsumer<$t>,
+            {
+                convert!(iter.drive_unindexed(consumer))
+            }
+
+            fn opt_len(iter: &Iter<$t>) -> Option<usize> {
+                convert!(iter.opt_len())
+            }
+        }
+    };
+}
+
+macro_rules! indexed_range_impl {
+    ( $t:ty ) => {
+        parallel_range_impl! { $t }
+
+        impl IndexedRangeInteger for $t {
+            private_impl! {}
+
+            fn drive<C>(iter: Iter<$t>, consumer: C) -> C::Result
+            where
+                C: Consumer<$t>,
+            {
+                convert!(iter.drive(consumer))
+            }
+
+            fn len(iter: &Iter<$t>) -> usize {
+                iter.range.len()
+            }
+
+            fn with_producer<CB>(iter: Iter<$t>, callback: CB) -> CB::Output
+            where
+                CB: ProducerCallback<$t>,
+            {
+                convert!(iter.with_producer(callback))
+            }
+        }
+    };
+}
+
+// all RangeInclusive<T> with ExactSizeIterator
+indexed_range_impl! {u8}
+indexed_range_impl! {u16}
+indexed_range_impl! {i8}
+indexed_range_impl! {i16}
+
+// other RangeInclusive<T> with just Iterator
+parallel_range_impl! {usize}
+parallel_range_impl! {isize}
+parallel_range_impl! {u32}
+parallel_range_impl! {i32}
+parallel_range_impl! {u64}
+parallel_range_impl! {i64}
+parallel_range_impl! {u128}
+parallel_range_impl! {i128}
+
+// char is special
+macro_rules! convert_char {
+    ( $self:ident . $method:ident ( $( $arg:expr ),* ) ) => {
+        if let Some((start, end)) = $self.bounds() {
+            let start = start as u32;
+            let end = end as u32;
+            if start < 0xD800 && 0xE000 <= end {
+                // chain the before and after surrogate range fragments
+                (start..0xD800)
+                    .into_par_iter()
+                    .chain(0xE000..end + 1) // cannot use RangeInclusive, so add one to end
+                    .map(|codepoint| unsafe { char::from_u32_unchecked(codepoint) })
+                    .$method($( $arg ),*)
+            } else {
+                // no surrogate range to worry about
+                (start..end + 1) // cannot use RangeInclusive, so add one to end
+                    .into_par_iter()
+                    .map(|codepoint| unsafe { char::from_u32_unchecked(codepoint) })
+                    .$method($( $arg ),*)
+            }
+        } else {
+            empty::<char>().$method($( $arg ),*)
+        }
+    };
+}
+
+impl ParallelIterator for Iter<char> {
+    type Item = char;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        convert_char!(self.drive(consumer))
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        Some(self.len())
+    }
+}
+
+// Range<u32> is broken on 16 bit platforms, may as well benefit from it
+impl IndexedParallelIterator for Iter<char> {
+    // Split at the surrogate range first if we're allowed to
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        convert_char!(self.drive(consumer))
+    }
+
+    fn len(&self) -> usize {
+        if let Some((start, end)) = self.bounds() {
+            // Taken from <char as Step>::steps_between
+            let start = start as u32;
+            let end = end as u32;
+            let mut count = end - start;
+            if start < 0xD800 && 0xE000 <= end {
+                count -= 0x800
+            }
+            (count + 1) as usize // add one for inclusive
+        } else {
+            0
+        }
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        convert_char!(self.with_producer(callback))
+    }
+}
+
+#[test]
+#[cfg(target_pointer_width = "64")]
+fn test_u32_opt_len() {
+    use std::u32;
+    assert_eq!(Some(101), (0..=100u32).into_par_iter().opt_len());
+    assert_eq!(
+        Some(u32::MAX as usize),
+        (0..=u32::MAX - 1).into_par_iter().opt_len()
+    );
+    assert_eq!(
+        Some(u32::MAX as usize + 1),
+        (0..=u32::MAX).into_par_iter().opt_len()
+    );
+}
+
+#[test]
+fn test_u64_opt_len() {
+    use std::{u64, usize};
+    assert_eq!(Some(101), (0..=100u64).into_par_iter().opt_len());
+    assert_eq!(
+        Some(usize::MAX),
+        (0..=usize::MAX as u64 - 1).into_par_iter().opt_len()
+    );
+    assert_eq!(None, (0..=usize::MAX as u64).into_par_iter().opt_len());
+    assert_eq!(None, (0..=u64::MAX).into_par_iter().opt_len());
+}
+
+#[test]
+fn test_u128_opt_len() {
+    use std::{u128, usize};
+    assert_eq!(Some(101), (0..=100u128).into_par_iter().opt_len());
+    assert_eq!(
+        Some(usize::MAX),
+        (0..=usize::MAX as u128 - 1).into_par_iter().opt_len()
+    );
+    assert_eq!(None, (0..=usize::MAX as u128).into_par_iter().opt_len());
+    assert_eq!(None, (0..=u128::MAX).into_par_iter().opt_len());
+}
+
+// `usize as i64` can overflow, so make sure to wrap it appropriately
+// when using the `opt_len` "indexed" mode.
+#[test]
+#[cfg(target_pointer_width = "64")]
+fn test_usize_i64_overflow() {
+    use crate::ThreadPoolBuilder;
+    use std::i64;
+
+    let iter = (-2..=i64::MAX).into_par_iter();
+    assert_eq!(iter.opt_len(), Some(i64::MAX as usize + 3));
+
+    // always run with multiple threads to split into, or this will take forever...
+    let pool = ThreadPoolBuilder::new().num_threads(8).build().unwrap();
+    pool.install(|| assert_eq!(iter.find_last(|_| true), Some(i64::MAX)));
+}
+
+#[test]
+fn test_issue_833() {
+    fn is_even(n: i64) -> bool {
+        n % 2 == 0
+    }
+
+    // The integer type should be inferred from `is_even`
+    let v: Vec<_> = (1..=100).into_par_iter().filter(|&x| is_even(x)).collect();
+    assert!(v.into_iter().eq((2..=100).step_by(2)));
+
+    // Try examples with indexed iterators too
+    let pos = (0..=100).into_par_iter().position_any(|x| x == 50i16);
+    assert_eq!(pos, Some(50usize));
+
+    assert!((0..=100)
+        .into_par_iter()
+        .zip(0..=100)
+        .all(|(a, b)| i16::eq(&a, &b)));
+}
diff --git a/crates/rayon/src/result.rs b/crates/rayon/src/result.rs
new file mode 100644
index 0000000..43685ca
--- /dev/null
+++ b/crates/rayon/src/result.rs
@@ -0,0 +1,132 @@
+//! Parallel iterator types for [results][std::result]
+//!
+//! You will rarely need to interact with this module directly unless you need
+//! to name one of the iterator types.
+//!
+//! [std::result]: https://doc.rust-lang.org/stable/std/result/
+
+use crate::iter::plumbing::*;
+use crate::iter::*;
+use std::sync::Mutex;
+
+use crate::option;
+
+/// Parallel iterator over a result
+#[derive(Debug, Clone)]
+pub struct IntoIter<T: Send> {
+    inner: option::IntoIter<T>,
+}
+
+impl<T: Send, E> IntoParallelIterator for Result<T, E> {
+    type Item = T;
+    type Iter = IntoIter<T>;
+
+    fn into_par_iter(self) -> Self::Iter {
+        IntoIter {
+            inner: self.ok().into_par_iter(),
+        }
+    }
+}
+
+delegate_indexed_iterator! {
+    IntoIter<T> => T,
+    impl<T: Send>
+}
+
+/// Parallel iterator over an immutable reference to a result
+#[derive(Debug)]
+pub struct Iter<'a, T: Sync> {
+    inner: option::IntoIter<&'a T>,
+}
+
+impl<'a, T: Sync> Clone for Iter<'a, T> {
+    fn clone(&self) -> Self {
+        Iter {
+            inner: self.inner.clone(),
+        }
+    }
+}
+
+impl<'a, T: Sync, E> IntoParallelIterator for &'a Result<T, E> {
+    type Item = &'a T;
+    type Iter = Iter<'a, T>;
+
+    fn into_par_iter(self) -> Self::Iter {
+        Iter {
+            inner: self.as_ref().ok().into_par_iter(),
+        }
+    }
+}
+
+delegate_indexed_iterator! {
+    Iter<'a, T> => &'a T,
+    impl<'a, T: Sync + 'a>
+}
+
+/// Parallel iterator over a mutable reference to a result
+#[derive(Debug)]
+pub struct IterMut<'a, T: Send> {
+    inner: option::IntoIter<&'a mut T>,
+}
+
+impl<'a, T: Send, E> IntoParallelIterator for &'a mut Result<T, E> {
+    type Item = &'a mut T;
+    type Iter = IterMut<'a, T>;
+
+    fn into_par_iter(self) -> Self::Iter {
+        IterMut {
+            inner: self.as_mut().ok().into_par_iter(),
+        }
+    }
+}
+
+delegate_indexed_iterator! {
+    IterMut<'a, T> => &'a mut T,
+    impl<'a, T: Send + 'a>
+}
+
+/// Collect an arbitrary `Result`-wrapped collection.
+///
+/// If any item is `Err`, then all previous `Ok` items collected are
+/// discarded, and it returns that error.  If there are multiple errors, the
+/// one returned is not deterministic.
+impl<C, T, E> FromParallelIterator<Result<T, E>> for Result<C, E>
+where
+    C: FromParallelIterator<T>,
+    T: Send,
+    E: Send,
+{
+    fn from_par_iter<I>(par_iter: I) -> Self
+    where
+        I: IntoParallelIterator<Item = Result<T, E>>,
+    {
+        fn ok<T, E>(saved: &Mutex<Option<E>>) -> impl Fn(Result<T, E>) -> Option<T> + '_ {
+            move |item| match item {
+                Ok(item) => Some(item),
+                Err(error) => {
+                    // We don't need a blocking `lock()`, as anybody
+                    // else holding the lock will also be writing
+                    // `Some(error)`, and then ours is irrelevant.
+                    if let Ok(mut guard) = saved.try_lock() {
+                        if guard.is_none() {
+                            *guard = Some(error);
+                        }
+                    }
+                    None
+                }
+            }
+        }
+
+        let saved_error = Mutex::new(None);
+        let collection = par_iter
+            .into_par_iter()
+            .map(ok(&saved_error))
+            .while_some()
+            .collect();
+
+        match saved_error.into_inner().unwrap() {
+            Some(error) => Err(error),
+            None => Ok(collection),
+        }
+    }
+}
diff --git a/crates/rayon/src/slice/chunks.rs b/crates/rayon/src/slice/chunks.rs
new file mode 100644
index 0000000..a3cc709
--- /dev/null
+++ b/crates/rayon/src/slice/chunks.rs
@@ -0,0 +1,389 @@
+use crate::iter::plumbing::*;
+use crate::iter::*;
+use crate::math::div_round_up;
+use std::cmp;
+
+/// Parallel iterator over immutable non-overlapping chunks of a slice
+#[derive(Debug)]
+pub struct Chunks<'data, T: Sync> {
+    chunk_size: usize,
+    slice: &'data [T],
+}
+
+impl<'data, T: Sync> Chunks<'data, T> {
+    pub(super) fn new(chunk_size: usize, slice: &'data [T]) -> Self {
+        Self { chunk_size, slice }
+    }
+}
+
+impl<'data, T: Sync> Clone for Chunks<'data, T> {
+    fn clone(&self) -> Self {
+        Chunks { ..*self }
+    }
+}
+
+impl<'data, T: Sync + 'data> ParallelIterator for Chunks<'data, T> {
+    type Item = &'data [T];
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        Some(self.len())
+    }
+}
+
+impl<'data, T: Sync + 'data> IndexedParallelIterator for Chunks<'data, T> {
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn len(&self) -> usize {
+        div_round_up(self.slice.len(), self.chunk_size)
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        callback.callback(ChunksProducer {
+            chunk_size: self.chunk_size,
+            slice: self.slice,
+        })
+    }
+}
+
+struct ChunksProducer<'data, T: Sync> {
+    chunk_size: usize,
+    slice: &'data [T],
+}
+
+impl<'data, T: 'data + Sync> Producer for ChunksProducer<'data, T> {
+    type Item = &'data [T];
+    type IntoIter = ::std::slice::Chunks<'data, T>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.slice.chunks(self.chunk_size)
+    }
+
+    fn split_at(self, index: usize) -> (Self, Self) {
+        let elem_index = cmp::min(index * self.chunk_size, self.slice.len());
+        let (left, right) = self.slice.split_at(elem_index);
+        (
+            ChunksProducer {
+                chunk_size: self.chunk_size,
+                slice: left,
+            },
+            ChunksProducer {
+                chunk_size: self.chunk_size,
+                slice: right,
+            },
+        )
+    }
+}
+
+/// Parallel iterator over immutable non-overlapping chunks of a slice
+#[derive(Debug)]
+pub struct ChunksExact<'data, T: Sync> {
+    chunk_size: usize,
+    slice: &'data [T],
+    rem: &'data [T],
+}
+
+impl<'data, T: Sync> ChunksExact<'data, T> {
+    pub(super) fn new(chunk_size: usize, slice: &'data [T]) -> Self {
+        let rem_len = slice.len() % chunk_size;
+        let len = slice.len() - rem_len;
+        let (slice, rem) = slice.split_at(len);
+        Self {
+            chunk_size,
+            slice,
+            rem,
+        }
+    }
+
+    /// Return the remainder of the original slice that is not going to be
+    /// returned by the iterator. The returned slice has at most `chunk_size-1`
+    /// elements.
+    pub fn remainder(&self) -> &'data [T] {
+        self.rem
+    }
+}
+
+impl<'data, T: Sync> Clone for ChunksExact<'data, T> {
+    fn clone(&self) -> Self {
+        ChunksExact { ..*self }
+    }
+}
+
+impl<'data, T: Sync + 'data> ParallelIterator for ChunksExact<'data, T> {
+    type Item = &'data [T];
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        Some(self.len())
+    }
+}
+
+impl<'data, T: Sync + 'data> IndexedParallelIterator for ChunksExact<'data, T> {
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn len(&self) -> usize {
+        self.slice.len() / self.chunk_size
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        callback.callback(ChunksExactProducer {
+            chunk_size: self.chunk_size,
+            slice: self.slice,
+        })
+    }
+}
+
+struct ChunksExactProducer<'data, T: Sync> {
+    chunk_size: usize,
+    slice: &'data [T],
+}
+
+impl<'data, T: 'data + Sync> Producer for ChunksExactProducer<'data, T> {
+    type Item = &'data [T];
+    type IntoIter = ::std::slice::ChunksExact<'data, T>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.slice.chunks_exact(self.chunk_size)
+    }
+
+    fn split_at(self, index: usize) -> (Self, Self) {
+        let elem_index = index * self.chunk_size;
+        let (left, right) = self.slice.split_at(elem_index);
+        (
+            ChunksExactProducer {
+                chunk_size: self.chunk_size,
+                slice: left,
+            },
+            ChunksExactProducer {
+                chunk_size: self.chunk_size,
+                slice: right,
+            },
+        )
+    }
+}
+
+/// Parallel iterator over mutable non-overlapping chunks of a slice
+#[derive(Debug)]
+pub struct ChunksMut<'data, T: Send> {
+    chunk_size: usize,
+    slice: &'data mut [T],
+}
+
+impl<'data, T: Send> ChunksMut<'data, T> {
+    pub(super) fn new(chunk_size: usize, slice: &'data mut [T]) -> Self {
+        Self { chunk_size, slice }
+    }
+}
+
+impl<'data, T: Send + 'data> ParallelIterator for ChunksMut<'data, T> {
+    type Item = &'data mut [T];
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        Some(self.len())
+    }
+}
+
+impl<'data, T: Send + 'data> IndexedParallelIterator for ChunksMut<'data, T> {
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn len(&self) -> usize {
+        div_round_up(self.slice.len(), self.chunk_size)
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        callback.callback(ChunksMutProducer {
+            chunk_size: self.chunk_size,
+            slice: self.slice,
+        })
+    }
+}
+
+struct ChunksMutProducer<'data, T: Send> {
+    chunk_size: usize,
+    slice: &'data mut [T],
+}
+
+impl<'data, T: 'data + Send> Producer for ChunksMutProducer<'data, T> {
+    type Item = &'data mut [T];
+    type IntoIter = ::std::slice::ChunksMut<'data, T>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.slice.chunks_mut(self.chunk_size)
+    }
+
+    fn split_at(self, index: usize) -> (Self, Self) {
+        let elem_index = cmp::min(index * self.chunk_size, self.slice.len());
+        let (left, right) = self.slice.split_at_mut(elem_index);
+        (
+            ChunksMutProducer {
+                chunk_size: self.chunk_size,
+                slice: left,
+            },
+            ChunksMutProducer {
+                chunk_size: self.chunk_size,
+                slice: right,
+            },
+        )
+    }
+}
+
+/// Parallel iterator over mutable non-overlapping chunks of a slice
+#[derive(Debug)]
+pub struct ChunksExactMut<'data, T: Send> {
+    chunk_size: usize,
+    slice: &'data mut [T],
+    rem: &'data mut [T],
+}
+
+impl<'data, T: Send> ChunksExactMut<'data, T> {
+    pub(super) fn new(chunk_size: usize, slice: &'data mut [T]) -> Self {
+        let rem_len = slice.len() % chunk_size;
+        let len = slice.len() - rem_len;
+        let (slice, rem) = slice.split_at_mut(len);
+        Self {
+            chunk_size,
+            slice,
+            rem,
+        }
+    }
+
+    /// Return the remainder of the original slice that is not going to be
+    /// returned by the iterator. The returned slice has at most `chunk_size-1`
+    /// elements.
+    ///
+    /// Note that this has to consume `self` to return the original lifetime of
+    /// the data, which prevents this from actually being used as a parallel
+    /// iterator since that also consumes. This method is provided for parity
+    /// with `std::iter::ChunksExactMut`, but consider calling `remainder()` or
+    /// `take_remainder()` as alternatives.
+    pub fn into_remainder(self) -> &'data mut [T] {
+        self.rem
+    }
+
+    /// Return the remainder of the original slice that is not going to be
+    /// returned by the iterator. The returned slice has at most `chunk_size-1`
+    /// elements.
+    ///
+    /// Consider `take_remainder()` if you need access to the data with its
+    /// original lifetime, rather than borrowing through `&mut self` here.
+    pub fn remainder(&mut self) -> &mut [T] {
+        self.rem
+    }
+
+    /// Return the remainder of the original slice that is not going to be
+    /// returned by the iterator. The returned slice has at most `chunk_size-1`
+    /// elements. Subsequent calls will return an empty slice.
+    pub fn take_remainder(&mut self) -> &'data mut [T] {
+        std::mem::take(&mut self.rem)
+    }
+}
+
+impl<'data, T: Send + 'data> ParallelIterator for ChunksExactMut<'data, T> {
+    type Item = &'data mut [T];
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        Some(self.len())
+    }
+}
+
+impl<'data, T: Send + 'data> IndexedParallelIterator for ChunksExactMut<'data, T> {
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn len(&self) -> usize {
+        self.slice.len() / self.chunk_size
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        callback.callback(ChunksExactMutProducer {
+            chunk_size: self.chunk_size,
+            slice: self.slice,
+        })
+    }
+}
+
+struct ChunksExactMutProducer<'data, T: Send> {
+    chunk_size: usize,
+    slice: &'data mut [T],
+}
+
+impl<'data, T: 'data + Send> Producer for ChunksExactMutProducer<'data, T> {
+    type Item = &'data mut [T];
+    type IntoIter = ::std::slice::ChunksExactMut<'data, T>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.slice.chunks_exact_mut(self.chunk_size)
+    }
+
+    fn split_at(self, index: usize) -> (Self, Self) {
+        let elem_index = index * self.chunk_size;
+        let (left, right) = self.slice.split_at_mut(elem_index);
+        (
+            ChunksExactMutProducer {
+                chunk_size: self.chunk_size,
+                slice: left,
+            },
+            ChunksExactMutProducer {
+                chunk_size: self.chunk_size,
+                slice: right,
+            },
+        )
+    }
+}
diff --git a/crates/rayon/src/slice/mergesort.rs b/crates/rayon/src/slice/mergesort.rs
new file mode 100644
index 0000000..fec309d
--- /dev/null
+++ b/crates/rayon/src/slice/mergesort.rs
@@ -0,0 +1,755 @@
+//! Parallel merge sort.
+//!
+//! This implementation is copied verbatim from `std::slice::sort` and then parallelized.
+//! The only difference from the original is that the sequential `mergesort` returns
+//! `MergesortResult` and leaves descending arrays intact.
+
+use crate::iter::*;
+use crate::slice::ParallelSliceMut;
+use crate::SendPtr;
+use std::mem;
+use std::mem::size_of;
+use std::ptr;
+use std::slice;
+
+unsafe fn get_and_increment<T>(ptr: &mut *mut T) -> *mut T {
+    let old = *ptr;
+    *ptr = ptr.offset(1);
+    old
+}
+
+unsafe fn decrement_and_get<T>(ptr: &mut *mut T) -> *mut T {
+    *ptr = ptr.offset(-1);
+    *ptr
+}
+
+/// When dropped, copies from `src` into `dest` a sequence of length `len`.
+struct CopyOnDrop<T> {
+    src: *const T,
+    dest: *mut T,
+    len: usize,
+}
+
+impl<T> Drop for CopyOnDrop<T> {
+    fn drop(&mut self) {
+        unsafe {
+            ptr::copy_nonoverlapping(self.src, self.dest, self.len);
+        }
+    }
+}
+
+/// Inserts `v[0]` into pre-sorted sequence `v[1..]` so that whole `v[..]` becomes sorted.
+///
+/// This is the integral subroutine of insertion sort.
+fn insert_head<T, F>(v: &mut [T], is_less: &F)
+where
+    F: Fn(&T, &T) -> bool,
+{
+    if v.len() >= 2 && is_less(&v[1], &v[0]) {
+        unsafe {
+            // There are three ways to implement insertion here:
+            //
+            // 1. Swap adjacent elements until the first one gets to its final destination.
+            //    However, this way we copy data around more than is necessary. If elements are big
+            //    structures (costly to copy), this method will be slow.
+            //
+            // 2. Iterate until the right place for the first element is found. Then shift the
+            //    elements succeeding it to make room for it and finally place it into the
+            //    remaining hole. This is a good method.
+            //
+            // 3. Copy the first element into a temporary variable. Iterate until the right place
+            //    for it is found. As we go along, copy every traversed element into the slot
+            //    preceding it. Finally, copy data from the temporary variable into the remaining
+            //    hole. This method is very good. Benchmarks demonstrated slightly better
+            //    performance than with the 2nd method.
+            //
+            // All methods were benchmarked, and the 3rd showed best results. So we chose that one.
+            let tmp = mem::ManuallyDrop::new(ptr::read(&v[0]));
+
+            // Intermediate state of the insertion process is always tracked by `hole`, which
+            // serves two purposes:
+            // 1. Protects integrity of `v` from panics in `is_less`.
+            // 2. Fills the remaining hole in `v` in the end.
+            //
+            // Panic safety:
+            //
+            // If `is_less` panics at any point during the process, `hole` will get dropped and
+            // fill the hole in `v` with `tmp`, thus ensuring that `v` still holds every object it
+            // initially held exactly once.
+            let mut hole = InsertionHole {
+                src: &*tmp,
+                dest: &mut v[1],
+            };
+            ptr::copy_nonoverlapping(&v[1], &mut v[0], 1);
+
+            for i in 2..v.len() {
+                if !is_less(&v[i], &*tmp) {
+                    break;
+                }
+                ptr::copy_nonoverlapping(&v[i], &mut v[i - 1], 1);
+                hole.dest = &mut v[i];
+            }
+            // `hole` gets dropped and thus copies `tmp` into the remaining hole in `v`.
+        }
+    }
+
+    // When dropped, copies from `src` into `dest`.
+    struct InsertionHole<T> {
+        src: *const T,
+        dest: *mut T,
+    }
+
+    impl<T> Drop for InsertionHole<T> {
+        fn drop(&mut self) {
+            unsafe {
+                ptr::copy_nonoverlapping(self.src, self.dest, 1);
+            }
+        }
+    }
+}
+
+/// Merges non-decreasing runs `v[..mid]` and `v[mid..]` using `buf` as temporary storage, and
+/// stores the result into `v[..]`.
+///
+/// # Safety
+///
+/// The two slices must be non-empty and `mid` must be in bounds. Buffer `buf` must be long enough
+/// to hold a copy of the shorter slice. Also, `T` must not be a zero-sized type.
+unsafe fn merge<T, F>(v: &mut [T], mid: usize, buf: *mut T, is_less: &F)
+where
+    F: Fn(&T, &T) -> bool,
+{
+    let len = v.len();
+    let v = v.as_mut_ptr();
+    let v_mid = v.add(mid);
+    let v_end = v.add(len);
+
+    // The merge process first copies the shorter run into `buf`. Then it traces the newly copied
+    // run and the longer run forwards (or backwards), comparing their next unconsumed elements and
+    // copying the lesser (or greater) one into `v`.
+    //
+    // As soon as the shorter run is fully consumed, the process is done. If the longer run gets
+    // consumed first, then we must copy whatever is left of the shorter run into the remaining
+    // hole in `v`.
+    //
+    // Intermediate state of the process is always tracked by `hole`, which serves two purposes:
+    // 1. Protects integrity of `v` from panics in `is_less`.
+    // 2. Fills the remaining hole in `v` if the longer run gets consumed first.
+    //
+    // Panic safety:
+    //
+    // If `is_less` panics at any point during the process, `hole` will get dropped and fill the
+    // hole in `v` with the unconsumed range in `buf`, thus ensuring that `v` still holds every
+    // object it initially held exactly once.
+    let mut hole;
+
+    if mid <= len - mid {
+        // The left run is shorter.
+        ptr::copy_nonoverlapping(v, buf, mid);
+        hole = MergeHole {
+            start: buf,
+            end: buf.add(mid),
+            dest: v,
+        };
+
+        // Initially, these pointers point to the beginnings of their arrays.
+        let left = &mut hole.start;
+        let mut right = v_mid;
+        let out = &mut hole.dest;
+
+        while *left < hole.end && right < v_end {
+            // Consume the lesser side.
+            // If equal, prefer the left run to maintain stability.
+            let to_copy = if is_less(&*right, &**left) {
+                get_and_increment(&mut right)
+            } else {
+                get_and_increment(left)
+            };
+            ptr::copy_nonoverlapping(to_copy, get_and_increment(out), 1);
+        }
+    } else {
+        // The right run is shorter.
+        ptr::copy_nonoverlapping(v_mid, buf, len - mid);
+        hole = MergeHole {
+            start: buf,
+            end: buf.add(len - mid),
+            dest: v_mid,
+        };
+
+        // Initially, these pointers point past the ends of their arrays.
+        let left = &mut hole.dest;
+        let right = &mut hole.end;
+        let mut out = v_end;
+
+        while v < *left && buf < *right {
+            // Consume the greater side.
+            // If equal, prefer the right run to maintain stability.
+            let to_copy = if is_less(&*right.offset(-1), &*left.offset(-1)) {
+                decrement_and_get(left)
+            } else {
+                decrement_and_get(right)
+            };
+            ptr::copy_nonoverlapping(to_copy, decrement_and_get(&mut out), 1);
+        }
+    }
+    // Finally, `hole` gets dropped. If the shorter run was not fully consumed, whatever remains of
+    // it will now be copied into the hole in `v`.
+
+    // When dropped, copies the range `start..end` into `dest..`.
+    struct MergeHole<T> {
+        start: *mut T,
+        end: *mut T,
+        dest: *mut T,
+    }
+
+    impl<T> Drop for MergeHole<T> {
+        fn drop(&mut self) {
+            // `T` is not a zero-sized type, so it's okay to divide by its size.
+            unsafe {
+                let len = self.end.offset_from(self.start) as usize;
+                ptr::copy_nonoverlapping(self.start, self.dest, len);
+            }
+        }
+    }
+}
+
+/// The result of merge sort.
+#[must_use]
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum MergesortResult {
+    /// The slice has already been sorted.
+    NonDescending,
+    /// The slice has been descending and therefore it was left intact.
+    Descending,
+    /// The slice was sorted.
+    Sorted,
+}
+
+/// A sorted run that starts at index `start` and is of length `len`.
+#[derive(Clone, Copy)]
+struct Run {
+    start: usize,
+    len: usize,
+}
+
+/// Examines the stack of runs and identifies the next pair of runs to merge. More specifically,
+/// if `Some(r)` is returned, that means `runs[r]` and `runs[r + 1]` must be merged next. If the
+/// algorithm should continue building a new run instead, `None` is returned.
+///
+/// TimSort is infamous for its buggy implementations, as described here:
+/// http://envisage-project.eu/timsort-specification-and-verification/
+///
+/// The gist of the story is: we must enforce the invariants on the top four runs on the stack.
+/// Enforcing them on just top three is not sufficient to ensure that the invariants will still
+/// hold for *all* runs in the stack.
+///
+/// This function correctly checks invariants for the top four runs. Additionally, if the top
+/// run starts at index 0, it will always demand a merge operation until the stack is fully
+/// collapsed, in order to complete the sort.
+#[inline]
+fn collapse(runs: &[Run]) -> Option<usize> {
+    let n = runs.len();
+
+    if n >= 2
+        && (runs[n - 1].start == 0
+            || runs[n - 2].len <= runs[n - 1].len
+            || (n >= 3 && runs[n - 3].len <= runs[n - 2].len + runs[n - 1].len)
+            || (n >= 4 && runs[n - 4].len <= runs[n - 3].len + runs[n - 2].len))
+    {
+        if n >= 3 && runs[n - 3].len < runs[n - 1].len {
+            Some(n - 3)
+        } else {
+            Some(n - 2)
+        }
+    } else {
+        None
+    }
+}
+
+/// Sorts a slice using merge sort, unless it is already in descending order.
+///
+/// This function doesn't modify the slice if it is already non-descending or descending.
+/// Otherwise, it sorts the slice into non-descending order.
+///
+/// This merge sort borrows some (but not all) ideas from TimSort, which is described in detail
+/// [here](https://github.com/python/cpython/blob/main/Objects/listsort.txt).
+///
+/// The algorithm identifies strictly descending and non-descending subsequences, which are called
+/// natural runs. There is a stack of pending runs yet to be merged. Each newly found run is pushed
+/// onto the stack, and then some pairs of adjacent runs are merged until these two invariants are
+/// satisfied:
+///
+/// 1. for every `i` in `1..runs.len()`: `runs[i - 1].len > runs[i].len`
+/// 2. for every `i` in `2..runs.len()`: `runs[i - 2].len > runs[i - 1].len + runs[i].len`
+///
+/// The invariants ensure that the total running time is *O*(*n* \* log(*n*)) worst-case.
+///
+/// # Safety
+///
+/// The argument `buf` is used as a temporary buffer and must be at least as long as `v`.
+unsafe fn mergesort<T, F>(v: &mut [T], buf: *mut T, is_less: &F) -> MergesortResult
+where
+    T: Send,
+    F: Fn(&T, &T) -> bool + Sync,
+{
+    // Very short runs are extended using insertion sort to span at least this many elements.
+    const MIN_RUN: usize = 10;
+
+    let len = v.len();
+
+    // In order to identify natural runs in `v`, we traverse it backwards. That might seem like a
+    // strange decision, but consider the fact that merges more often go in the opposite direction
+    // (forwards). According to benchmarks, merging forwards is slightly faster than merging
+    // backwards. To conclude, identifying runs by traversing backwards improves performance.
+    let mut runs = vec![];
+    let mut end = len;
+    while end > 0 {
+        // Find the next natural run, and reverse it if it's strictly descending.
+        let mut start = end - 1;
+
+        if start > 0 {
+            start -= 1;
+
+            if is_less(v.get_unchecked(start + 1), v.get_unchecked(start)) {
+                while start > 0 && is_less(v.get_unchecked(start), v.get_unchecked(start - 1)) {
+                    start -= 1;
+                }
+
+                // If this descending run covers the whole slice, return immediately.
+                if start == 0 && end == len {
+                    return MergesortResult::Descending;
+                } else {
+                    v[start..end].reverse();
+                }
+            } else {
+                while start > 0 && !is_less(v.get_unchecked(start), v.get_unchecked(start - 1)) {
+                    start -= 1;
+                }
+
+                // If this non-descending run covers the whole slice, return immediately.
+                if end - start == len {
+                    return MergesortResult::NonDescending;
+                }
+            }
+        }
+
+        // Insert some more elements into the run if it's too short. Insertion sort is faster than
+        // merge sort on short sequences, so this significantly improves performance.
+        while start > 0 && end - start < MIN_RUN {
+            start -= 1;
+            insert_head(&mut v[start..end], &is_less);
+        }
+
+        // Push this run onto the stack.
+        runs.push(Run {
+            start,
+            len: end - start,
+        });
+        end = start;
+
+        // Merge some pairs of adjacent runs to satisfy the invariants.
+        while let Some(r) = collapse(&runs) {
+            let left = runs[r + 1];
+            let right = runs[r];
+            merge(
+                &mut v[left.start..right.start + right.len],
+                left.len,
+                buf,
+                &is_less,
+            );
+
+            runs[r] = Run {
+                start: left.start,
+                len: left.len + right.len,
+            };
+            runs.remove(r + 1);
+        }
+    }
+
+    // Finally, exactly one run must remain in the stack.
+    debug_assert!(runs.len() == 1 && runs[0].start == 0 && runs[0].len == len);
+
+    // The original order of the slice was neither non-descending nor descending.
+    MergesortResult::Sorted
+}
+
+////////////////////////////////////////////////////////////////////////////
+// Everything above this line is copied from `std::slice::sort` (with very minor tweaks).
+// Everything below this line is parallelization.
+////////////////////////////////////////////////////////////////////////////
+
+/// Splits two sorted slices so that they can be merged in parallel.
+///
+/// Returns two indices `(a, b)` so that slices `left[..a]` and `right[..b]` come before
+/// `left[a..]` and `right[b..]`.
+fn split_for_merge<T, F>(left: &[T], right: &[T], is_less: &F) -> (usize, usize)
+where
+    F: Fn(&T, &T) -> bool,
+{
+    let left_len = left.len();
+    let right_len = right.len();
+
+    if left_len >= right_len {
+        let left_mid = left_len / 2;
+
+        // Find the first element in `right` that is greater than or equal to `left[left_mid]`.
+        let mut a = 0;
+        let mut b = right_len;
+        while a < b {
+            let m = a + (b - a) / 2;
+            if is_less(&right[m], &left[left_mid]) {
+                a = m + 1;
+            } else {
+                b = m;
+            }
+        }
+
+        (left_mid, a)
+    } else {
+        let right_mid = right_len / 2;
+
+        // Find the first element in `left` that is greater than `right[right_mid]`.
+        let mut a = 0;
+        let mut b = left_len;
+        while a < b {
+            let m = a + (b - a) / 2;
+            if is_less(&right[right_mid], &left[m]) {
+                b = m;
+            } else {
+                a = m + 1;
+            }
+        }
+
+        (a, right_mid)
+    }
+}
+
+/// Merges slices `left` and `right` in parallel and stores the result into `dest`.
+///
+/// # Safety
+///
+/// The `dest` pointer must have enough space to store the result.
+///
+/// Even if `is_less` panics at any point during the merge process, this function will fully copy
+/// all elements from `left` and `right` into `dest` (not necessarily in sorted order).
+unsafe fn par_merge<T, F>(left: &mut [T], right: &mut [T], dest: *mut T, is_less: &F)
+where
+    T: Send,
+    F: Fn(&T, &T) -> bool + Sync,
+{
+    // Slices whose lengths sum up to this value are merged sequentially. This number is slightly
+    // larger than `CHUNK_LENGTH`, and the reason is that merging is faster than merge sorting, so
+    // merging needs a bit coarser granularity in order to hide the overhead of Rayon's task
+    // scheduling.
+    const MAX_SEQUENTIAL: usize = 5000;
+
+    let left_len = left.len();
+    let right_len = right.len();
+
+    // Intermediate state of the merge process, which serves two purposes:
+    // 1. Protects integrity of `dest` from panics in `is_less`.
+    // 2. Copies the remaining elements as soon as one of the two sides is exhausted.
+    //
+    // Panic safety:
+    //
+    // If `is_less` panics at any point during the merge process, `s` will get dropped and copy the
+    // remaining parts of `left` and `right` into `dest`.
+    let mut s = State {
+        left_start: left.as_mut_ptr(),
+        left_end: left.as_mut_ptr().add(left_len),
+        right_start: right.as_mut_ptr(),
+        right_end: right.as_mut_ptr().add(right_len),
+        dest,
+    };
+
+    if left_len == 0 || right_len == 0 || left_len + right_len < MAX_SEQUENTIAL {
+        while s.left_start < s.left_end && s.right_start < s.right_end {
+            // Consume the lesser side.
+            // If equal, prefer the left run to maintain stability.
+            let to_copy = if is_less(&*s.right_start, &*s.left_start) {
+                get_and_increment(&mut s.right_start)
+            } else {
+                get_and_increment(&mut s.left_start)
+            };
+            ptr::copy_nonoverlapping(to_copy, get_and_increment(&mut s.dest), 1);
+        }
+    } else {
+        // Function `split_for_merge` might panic. If that happens, `s` will get destructed and copy
+        // the whole `left` and `right` into `dest`.
+        let (left_mid, right_mid) = split_for_merge(left, right, is_less);
+        let (left_l, left_r) = left.split_at_mut(left_mid);
+        let (right_l, right_r) = right.split_at_mut(right_mid);
+
+        // Prevent the destructor of `s` from running. Rayon will ensure that both calls to
+        // `par_merge` happen. If one of the two calls panics, they will ensure that elements still
+        // get copied into `dest_left` and `dest_right``.
+        mem::forget(s);
+
+        // Wrap pointers in SendPtr so that they can be sent to another thread
+        // See the documentation of SendPtr for a full explanation
+        let dest_l = SendPtr(dest);
+        let dest_r = SendPtr(dest.add(left_l.len() + right_l.len()));
+        rayon_core::join(
+            move || par_merge(left_l, right_l, dest_l.get(), is_less),
+            move || par_merge(left_r, right_r, dest_r.get(), is_less),
+        );
+    }
+    // Finally, `s` gets dropped if we used sequential merge, thus copying the remaining elements
+    // all at once.
+
+    // When dropped, copies arrays `left_start..left_end` and `right_start..right_end` into `dest`,
+    // in that order.
+    struct State<T> {
+        left_start: *mut T,
+        left_end: *mut T,
+        right_start: *mut T,
+        right_end: *mut T,
+        dest: *mut T,
+    }
+
+    impl<T> Drop for State<T> {
+        fn drop(&mut self) {
+            let size = size_of::<T>();
+            let left_len = (self.left_end as usize - self.left_start as usize) / size;
+            let right_len = (self.right_end as usize - self.right_start as usize) / size;
+
+            // Copy array `left`, followed by `right`.
+            unsafe {
+                ptr::copy_nonoverlapping(self.left_start, self.dest, left_len);
+                self.dest = self.dest.add(left_len);
+                ptr::copy_nonoverlapping(self.right_start, self.dest, right_len);
+            }
+        }
+    }
+}
+
+/// Recursively merges pre-sorted chunks inside `v`.
+///
+/// Chunks of `v` are stored in `chunks` as intervals (inclusive left and exclusive right bound).
+/// Argument `buf` is an auxiliary buffer that will be used during the procedure.
+/// If `into_buf` is true, the result will be stored into `buf`, otherwise it will be in `v`.
+///
+/// # Safety
+///
+/// The number of chunks must be positive and they must be adjacent: the right bound of each chunk
+/// must equal the left bound of the following chunk.
+///
+/// The buffer must be at least as long as `v`.
+unsafe fn recurse<T, F>(
+    v: *mut T,
+    buf: *mut T,
+    chunks: &[(usize, usize)],
+    into_buf: bool,
+    is_less: &F,
+) where
+    T: Send,
+    F: Fn(&T, &T) -> bool + Sync,
+{
+    let len = chunks.len();
+    debug_assert!(len > 0);
+
+    // Base case of the algorithm.
+    // If only one chunk is remaining, there's no more work to split and merge.
+    if len == 1 {
+        if into_buf {
+            // Copy the chunk from `v` into `buf`.
+            let (start, end) = chunks[0];
+            let src = v.add(start);
+            let dest = buf.add(start);
+            ptr::copy_nonoverlapping(src, dest, end - start);
+        }
+        return;
+    }
+
+    // Split the chunks into two halves.
+    let (start, _) = chunks[0];
+    let (mid, _) = chunks[len / 2];
+    let (_, end) = chunks[len - 1];
+    let (left, right) = chunks.split_at(len / 2);
+
+    // After recursive calls finish we'll have to merge chunks `(start, mid)` and `(mid, end)` from
+    // `src` into `dest`. If the current invocation has to store the result into `buf`, we'll
+    // merge chunks from `v` into `buf`, and vice versa.
+    //
+    // Recursive calls flip `into_buf` at each level of recursion. More concretely, `par_merge`
+    // merges chunks from `buf` into `v` at the first level, from `v` into `buf` at the second
+    // level etc.
+    let (src, dest) = if into_buf { (v, buf) } else { (buf, v) };
+
+    // Panic safety:
+    //
+    // If `is_less` panics at any point during the recursive calls, the destructor of `guard` will
+    // be executed, thus copying everything from `src` into `dest`. This way we ensure that all
+    // chunks are in fact copied into `dest`, even if the merge process doesn't finish.
+    let guard = CopyOnDrop {
+        src: src.add(start),
+        dest: dest.add(start),
+        len: end - start,
+    };
+
+    // Wrap pointers in SendPtr so that they can be sent to another thread
+    // See the documentation of SendPtr for a full explanation
+    let v = SendPtr(v);
+    let buf = SendPtr(buf);
+    rayon_core::join(
+        move || recurse(v.get(), buf.get(), left, !into_buf, is_less),
+        move || recurse(v.get(), buf.get(), right, !into_buf, is_less),
+    );
+
+    // Everything went all right - recursive calls didn't panic.
+    // Forget the guard in order to prevent its destructor from running.
+    mem::forget(guard);
+
+    // Merge chunks `(start, mid)` and `(mid, end)` from `src` into `dest`.
+    let src_left = slice::from_raw_parts_mut(src.add(start), mid - start);
+    let src_right = slice::from_raw_parts_mut(src.add(mid), end - mid);
+    par_merge(src_left, src_right, dest.add(start), is_less);
+}
+
+/// Sorts `v` using merge sort in parallel.
+///
+/// The algorithm is stable, allocates memory, and `O(n log n)` worst-case.
+/// The allocated temporary buffer is of the same length as is `v`.
+pub(super) fn par_mergesort<T, F>(v: &mut [T], is_less: F)
+where
+    T: Send,
+    F: Fn(&T, &T) -> bool + Sync,
+{
+    // Slices of up to this length get sorted using insertion sort in order to avoid the cost of
+    // buffer allocation.
+    const MAX_INSERTION: usize = 20;
+    // The length of initial chunks. This number is as small as possible but so that the overhead
+    // of Rayon's task scheduling is still negligible.
+    const CHUNK_LENGTH: usize = 2000;
+
+    // Sorting has no meaningful behavior on zero-sized types.
+    if size_of::<T>() == 0 {
+        return;
+    }
+
+    let len = v.len();
+
+    // Short slices get sorted in-place via insertion sort to avoid allocations.
+    if len <= MAX_INSERTION {
+        if len >= 2 {
+            for i in (0..len - 1).rev() {
+                insert_head(&mut v[i..], &is_less);
+            }
+        }
+        return;
+    }
+
+    // Allocate a buffer to use as scratch memory. We keep the length 0 so we can keep in it
+    // shallow copies of the contents of `v` without risking the dtors running on copies if
+    // `is_less` panics.
+    let mut buf = Vec::<T>::with_capacity(len);
+    let buf = buf.as_mut_ptr();
+
+    // If the slice is not longer than one chunk would be, do sequential merge sort and return.
+    if len <= CHUNK_LENGTH {
+        let res = unsafe { mergesort(v, buf, &is_less) };
+        if res == MergesortResult::Descending {
+            v.reverse();
+        }
+        return;
+    }
+
+    // Split the slice into chunks and merge sort them in parallel.
+    // However, descending chunks will not be sorted - they will be simply left intact.
+    let mut iter = {
+        // Wrap pointer in SendPtr so that it can be sent to another thread
+        // See the documentation of SendPtr for a full explanation
+        let buf = SendPtr(buf);
+        let is_less = &is_less;
+
+        v.par_chunks_mut(CHUNK_LENGTH)
+            .with_max_len(1)
+            .enumerate()
+            .map(move |(i, chunk)| {
+                let l = CHUNK_LENGTH * i;
+                let r = l + chunk.len();
+                unsafe {
+                    let buf = buf.get().add(l);
+                    (l, r, mergesort(chunk, buf, is_less))
+                }
+            })
+            .collect::<Vec<_>>()
+            .into_iter()
+            .peekable()
+    };
+
+    // Now attempt to concatenate adjacent chunks that were left intact.
+    let mut chunks = Vec::with_capacity(iter.len());
+
+    while let Some((a, mut b, res)) = iter.next() {
+        // If this chunk was not modified by the sort procedure...
+        if res != MergesortResult::Sorted {
+            while let Some(&(x, y, r)) = iter.peek() {
+                // If the following chunk is of the same type and can be concatenated...
+                if r == res && (r == MergesortResult::Descending) == is_less(&v[x], &v[x - 1]) {
+                    // Concatenate them.
+                    b = y;
+                    iter.next();
+                } else {
+                    break;
+                }
+            }
+        }
+
+        // Descending chunks must be reversed.
+        if res == MergesortResult::Descending {
+            v[a..b].reverse();
+        }
+
+        chunks.push((a, b));
+    }
+
+    // All chunks are properly sorted.
+    // Now we just have to merge them together.
+    unsafe {
+        recurse(v.as_mut_ptr(), buf, &chunks, false, &is_less);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::split_for_merge;
+    use rand::distributions::Uniform;
+    use rand::{thread_rng, Rng};
+
+    #[test]
+    fn test_split_for_merge() {
+        fn check(left: &[u32], right: &[u32]) {
+            let (l, r) = split_for_merge(left, right, &|&a, &b| a < b);
+            assert!(left[..l]
+                .iter()
+                .all(|&x| right[r..].iter().all(|&y| x <= y)));
+            assert!(right[..r].iter().all(|&x| left[l..].iter().all(|&y| x < y)));
+        }
+
+        check(&[1, 2, 2, 2, 2, 3], &[1, 2, 2, 2, 2, 3]);
+        check(&[1, 2, 2, 2, 2, 3], &[]);
+        check(&[], &[1, 2, 2, 2, 2, 3]);
+
+        let rng = &mut thread_rng();
+
+        for _ in 0..100 {
+            let limit: u32 = rng.gen_range(1..21);
+            let left_len: usize = rng.gen_range(0..20);
+            let right_len: usize = rng.gen_range(0..20);
+
+            let mut left = rng
+                .sample_iter(&Uniform::new(0, limit))
+                .take(left_len)
+                .collect::<Vec<_>>();
+            let mut right = rng
+                .sample_iter(&Uniform::new(0, limit))
+                .take(right_len)
+                .collect::<Vec<_>>();
+
+            left.sort();
+            right.sort();
+            check(&left, &right);
+        }
+    }
+}
diff --git a/crates/rayon/src/slice/mod.rs b/crates/rayon/src/slice/mod.rs
new file mode 100644
index 0000000..dab56de
--- /dev/null
+++ b/crates/rayon/src/slice/mod.rs
@@ -0,0 +1,1041 @@
+//! Parallel iterator types for [slices][std::slice]
+//!
+//! You will rarely need to interact with this module directly unless you need
+//! to name one of the iterator types.
+//!
+//! [std::slice]: https://doc.rust-lang.org/stable/std/slice/
+
+mod chunks;
+mod mergesort;
+mod quicksort;
+mod rchunks;
+
+mod test;
+
+use self::mergesort::par_mergesort;
+use self::quicksort::par_quicksort;
+use crate::iter::plumbing::*;
+use crate::iter::*;
+use crate::split_producer::*;
+use std::cmp;
+use std::cmp::Ordering;
+use std::fmt::{self, Debug};
+use std::mem;
+
+pub use self::chunks::{Chunks, ChunksExact, ChunksExactMut, ChunksMut};
+pub use self::rchunks::{RChunks, RChunksExact, RChunksExactMut, RChunksMut};
+
+/// Parallel extensions for slices.
+pub trait ParallelSlice<T: Sync> {
+    /// Returns a plain slice, which is used to implement the rest of the
+    /// parallel methods.
+    fn as_parallel_slice(&self) -> &[T];
+
+    /// Returns a parallel iterator over subslices separated by elements that
+    /// match the separator.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    /// let smallest = [1, 2, 3, 0, 2, 4, 8, 0, 3, 6, 9]
+    ///     .par_split(|i| *i == 0)
+    ///     .map(|numbers| numbers.iter().min().unwrap())
+    ///     .min();
+    /// assert_eq!(Some(&1), smallest);
+    /// ```
+    fn par_split<P>(&self, separator: P) -> Split<'_, T, P>
+    where
+        P: Fn(&T) -> bool + Sync + Send,
+    {
+        Split {
+            slice: self.as_parallel_slice(),
+            separator,
+        }
+    }
+
+    /// Returns a parallel iterator over all contiguous windows of length
+    /// `window_size`. The windows overlap.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    /// let windows: Vec<_> = [1, 2, 3].par_windows(2).collect();
+    /// assert_eq!(vec![[1, 2], [2, 3]], windows);
+    /// ```
+    fn par_windows(&self, window_size: usize) -> Windows<'_, T> {
+        Windows {
+            window_size,
+            slice: self.as_parallel_slice(),
+        }
+    }
+
+    /// Returns a parallel iterator over at most `chunk_size` elements of
+    /// `self` at a time. The chunks do not overlap.
+    ///
+    /// If the number of elements in the iterator is not divisible by
+    /// `chunk_size`, the last chunk may be shorter than `chunk_size`.  All
+    /// other chunks will have that exact length.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    /// let chunks: Vec<_> = [1, 2, 3, 4, 5].par_chunks(2).collect();
+    /// assert_eq!(chunks, vec![&[1, 2][..], &[3, 4], &[5]]);
+    /// ```
+    #[track_caller]
+    fn par_chunks(&self, chunk_size: usize) -> Chunks<'_, T> {
+        assert!(chunk_size != 0, "chunk_size must not be zero");
+        Chunks::new(chunk_size, self.as_parallel_slice())
+    }
+
+    /// Returns a parallel iterator over `chunk_size` elements of
+    /// `self` at a time. The chunks do not overlap.
+    ///
+    /// If `chunk_size` does not divide the length of the slice, then the
+    /// last up to `chunk_size-1` elements will be omitted and can be
+    /// retrieved from the remainder function of the iterator.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    /// let chunks: Vec<_> = [1, 2, 3, 4, 5].par_chunks_exact(2).collect();
+    /// assert_eq!(chunks, vec![&[1, 2][..], &[3, 4]]);
+    /// ```
+    #[track_caller]
+    fn par_chunks_exact(&self, chunk_size: usize) -> ChunksExact<'_, T> {
+        assert!(chunk_size != 0, "chunk_size must not be zero");
+        ChunksExact::new(chunk_size, self.as_parallel_slice())
+    }
+
+    /// Returns a parallel iterator over at most `chunk_size` elements of `self` at a time,
+    /// starting at the end. The chunks do not overlap.
+    ///
+    /// If the number of elements in the iterator is not divisible by
+    /// `chunk_size`, the last chunk may be shorter than `chunk_size`.  All
+    /// other chunks will have that exact length.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    /// let chunks: Vec<_> = [1, 2, 3, 4, 5].par_rchunks(2).collect();
+    /// assert_eq!(chunks, vec![&[4, 5][..], &[2, 3], &[1]]);
+    /// ```
+    #[track_caller]
+    fn par_rchunks(&self, chunk_size: usize) -> RChunks<'_, T> {
+        assert!(chunk_size != 0, "chunk_size must not be zero");
+        RChunks::new(chunk_size, self.as_parallel_slice())
+    }
+
+    /// Returns a parallel iterator over `chunk_size` elements of `self` at a time,
+    /// starting at the end. The chunks do not overlap.
+    ///
+    /// If `chunk_size` does not divide the length of the slice, then the
+    /// last up to `chunk_size-1` elements will be omitted and can be
+    /// retrieved from the remainder function of the iterator.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    /// let chunks: Vec<_> = [1, 2, 3, 4, 5].par_rchunks_exact(2).collect();
+    /// assert_eq!(chunks, vec![&[4, 5][..], &[2, 3]]);
+    /// ```
+    #[track_caller]
+    fn par_rchunks_exact(&self, chunk_size: usize) -> RChunksExact<'_, T> {
+        assert!(chunk_size != 0, "chunk_size must not be zero");
+        RChunksExact::new(chunk_size, self.as_parallel_slice())
+    }
+}
+
+impl<T: Sync> ParallelSlice<T> for [T] {
+    #[inline]
+    fn as_parallel_slice(&self) -> &[T] {
+        self
+    }
+}
+
+/// Parallel extensions for mutable slices.
+pub trait ParallelSliceMut<T: Send> {
+    /// Returns a plain mutable slice, which is used to implement the rest of
+    /// the parallel methods.
+    fn as_parallel_slice_mut(&mut self) -> &mut [T];
+
+    /// Returns a parallel iterator over mutable subslices separated by
+    /// elements that match the separator.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    /// let mut array = [1, 2, 3, 0, 2, 4, 8, 0, 3, 6, 9];
+    /// array.par_split_mut(|i| *i == 0)
+    ///      .for_each(|slice| slice.reverse());
+    /// assert_eq!(array, [3, 2, 1, 0, 8, 4, 2, 0, 9, 6, 3]);
+    /// ```
+    fn par_split_mut<P>(&mut self, separator: P) -> SplitMut<'_, T, P>
+    where
+        P: Fn(&T) -> bool + Sync + Send,
+    {
+        SplitMut {
+            slice: self.as_parallel_slice_mut(),
+            separator,
+        }
+    }
+
+    /// Returns a parallel iterator over at most `chunk_size` elements of
+    /// `self` at a time. The chunks are mutable and do not overlap.
+    ///
+    /// If the number of elements in the iterator is not divisible by
+    /// `chunk_size`, the last chunk may be shorter than `chunk_size`.  All
+    /// other chunks will have that exact length.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    /// let mut array = [1, 2, 3, 4, 5];
+    /// array.par_chunks_mut(2)
+    ///      .for_each(|slice| slice.reverse());
+    /// assert_eq!(array, [2, 1, 4, 3, 5]);
+    /// ```
+    #[track_caller]
+    fn par_chunks_mut(&mut self, chunk_size: usize) -> ChunksMut<'_, T> {
+        assert!(chunk_size != 0, "chunk_size must not be zero");
+        ChunksMut::new(chunk_size, self.as_parallel_slice_mut())
+    }
+
+    /// Returns a parallel iterator over `chunk_size` elements of
+    /// `self` at a time. The chunks are mutable and do not overlap.
+    ///
+    /// If `chunk_size` does not divide the length of the slice, then the
+    /// last up to `chunk_size-1` elements will be omitted and can be
+    /// retrieved from the remainder function of the iterator.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    /// let mut array = [1, 2, 3, 4, 5];
+    /// array.par_chunks_exact_mut(3)
+    ///      .for_each(|slice| slice.reverse());
+    /// assert_eq!(array, [3, 2, 1, 4, 5]);
+    /// ```
+    #[track_caller]
+    fn par_chunks_exact_mut(&mut self, chunk_size: usize) -> ChunksExactMut<'_, T> {
+        assert!(chunk_size != 0, "chunk_size must not be zero");
+        ChunksExactMut::new(chunk_size, self.as_parallel_slice_mut())
+    }
+
+    /// Returns a parallel iterator over at most `chunk_size` elements of `self` at a time,
+    /// starting at the end. The chunks are mutable and do not overlap.
+    ///
+    /// If the number of elements in the iterator is not divisible by
+    /// `chunk_size`, the last chunk may be shorter than `chunk_size`.  All
+    /// other chunks will have that exact length.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    /// let mut array = [1, 2, 3, 4, 5];
+    /// array.par_rchunks_mut(2)
+    ///      .for_each(|slice| slice.reverse());
+    /// assert_eq!(array, [1, 3, 2, 5, 4]);
+    /// ```
+    #[track_caller]
+    fn par_rchunks_mut(&mut self, chunk_size: usize) -> RChunksMut<'_, T> {
+        assert!(chunk_size != 0, "chunk_size must not be zero");
+        RChunksMut::new(chunk_size, self.as_parallel_slice_mut())
+    }
+
+    /// Returns a parallel iterator over `chunk_size` elements of `self` at a time,
+    /// starting at the end. The chunks are mutable and do not overlap.
+    ///
+    /// If `chunk_size` does not divide the length of the slice, then the
+    /// last up to `chunk_size-1` elements will be omitted and can be
+    /// retrieved from the remainder function of the iterator.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    /// let mut array = [1, 2, 3, 4, 5];
+    /// array.par_rchunks_exact_mut(3)
+    ///      .for_each(|slice| slice.reverse());
+    /// assert_eq!(array, [1, 2, 5, 4, 3]);
+    /// ```
+    #[track_caller]
+    fn par_rchunks_exact_mut(&mut self, chunk_size: usize) -> RChunksExactMut<'_, T> {
+        assert!(chunk_size != 0, "chunk_size must not be zero");
+        RChunksExactMut::new(chunk_size, self.as_parallel_slice_mut())
+    }
+
+    /// Sorts the slice in parallel.
+    ///
+    /// This sort is stable (i.e., does not reorder equal elements) and *O*(*n* \* log(*n*)) worst-case.
+    ///
+    /// When applicable, unstable sorting is preferred because it is generally faster than stable
+    /// sorting and it doesn't allocate auxiliary memory.
+    /// See [`par_sort_unstable`](#method.par_sort_unstable).
+    ///
+    /// # Current implementation
+    ///
+    /// The current algorithm is an adaptive merge sort inspired by
+    /// [timsort](https://en.wikipedia.org/wiki/Timsort).
+    /// It is designed to be very fast in cases where the slice is nearly sorted, or consists of
+    /// two or more sorted sequences concatenated one after another.
+    ///
+    /// Also, it allocates temporary storage the same size as `self`, but for very short slices a
+    /// non-allocating insertion sort is used instead.
+    ///
+    /// In order to sort the slice in parallel, the slice is first divided into smaller chunks and
+    /// all chunks are sorted in parallel. Then, adjacent chunks that together form non-descending
+    /// or descending runs are concatenated. Finally, the remaining chunks are merged together using
+    /// parallel subdivision of chunks and parallel merge operation.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let mut v = [-5, 4, 1, -3, 2];
+    ///
+    /// v.par_sort();
+    /// assert_eq!(v, [-5, -3, 1, 2, 4]);
+    /// ```
+    fn par_sort(&mut self)
+    where
+        T: Ord,
+    {
+        par_mergesort(self.as_parallel_slice_mut(), T::lt);
+    }
+
+    /// Sorts the slice in parallel with a comparator function.
+    ///
+    /// This sort is stable (i.e., does not reorder equal elements) and *O*(*n* \* log(*n*)) worst-case.
+    ///
+    /// The comparator function must define a total ordering for the elements in the slice. If
+    /// the ordering is not total, the order of the elements is unspecified. An order is a
+    /// total order if it is (for all `a`, `b` and `c`):
+    ///
+    /// * total and antisymmetric: exactly one of `a < b`, `a == b` or `a > b` is true, and
+    /// * transitive, `a < b` and `b < c` implies `a < c`. The same must hold for both `==` and `>`.
+    ///
+    /// For example, while [`f64`] doesn't implement [`Ord`] because `NaN != NaN`, we can use
+    /// `partial_cmp` as our sort function when we know the slice doesn't contain a `NaN`.
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let mut floats = [5f64, 4.0, 1.0, 3.0, 2.0];
+    /// floats.par_sort_by(|a, b| a.partial_cmp(b).unwrap());
+    /// assert_eq!(floats, [1.0, 2.0, 3.0, 4.0, 5.0]);
+    /// ```
+    ///
+    /// When applicable, unstable sorting is preferred because it is generally faster than stable
+    /// sorting and it doesn't allocate auxiliary memory.
+    /// See [`par_sort_unstable_by`](#method.par_sort_unstable_by).
+    ///
+    /// # Current implementation
+    ///
+    /// The current algorithm is an adaptive merge sort inspired by
+    /// [timsort](https://en.wikipedia.org/wiki/Timsort).
+    /// It is designed to be very fast in cases where the slice is nearly sorted, or consists of
+    /// two or more sorted sequences concatenated one after another.
+    ///
+    /// Also, it allocates temporary storage the same size as `self`, but for very short slices a
+    /// non-allocating insertion sort is used instead.
+    ///
+    /// In order to sort the slice in parallel, the slice is first divided into smaller chunks and
+    /// all chunks are sorted in parallel. Then, adjacent chunks that together form non-descending
+    /// or descending runs are concatenated. Finally, the remaining chunks are merged together using
+    /// parallel subdivision of chunks and parallel merge operation.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let mut v = [5, 4, 1, 3, 2];
+    /// v.par_sort_by(|a, b| a.cmp(b));
+    /// assert_eq!(v, [1, 2, 3, 4, 5]);
+    ///
+    /// // reverse sorting
+    /// v.par_sort_by(|a, b| b.cmp(a));
+    /// assert_eq!(v, [5, 4, 3, 2, 1]);
+    /// ```
+    fn par_sort_by<F>(&mut self, compare: F)
+    where
+        F: Fn(&T, &T) -> Ordering + Sync,
+    {
+        par_mergesort(self.as_parallel_slice_mut(), |a, b| {
+            compare(a, b) == Ordering::Less
+        });
+    }
+
+    /// Sorts the slice in parallel with a key extraction function.
+    ///
+    /// This sort is stable (i.e., does not reorder equal elements) and *O*(*m* \* *n* \* log(*n*))
+    /// worst-case, where the key function is *O*(*m*).
+    ///
+    /// For expensive key functions (e.g. functions that are not simple property accesses or
+    /// basic operations), [`par_sort_by_cached_key`](#method.par_sort_by_cached_key) is likely to
+    /// be significantly faster, as it does not recompute element keys.
+    ///
+    /// When applicable, unstable sorting is preferred because it is generally faster than stable
+    /// sorting and it doesn't allocate auxiliary memory.
+    /// See [`par_sort_unstable_by_key`](#method.par_sort_unstable_by_key).
+    ///
+    /// # Current implementation
+    ///
+    /// The current algorithm is an adaptive merge sort inspired by
+    /// [timsort](https://en.wikipedia.org/wiki/Timsort).
+    /// It is designed to be very fast in cases where the slice is nearly sorted, or consists of
+    /// two or more sorted sequences concatenated one after another.
+    ///
+    /// Also, it allocates temporary storage the same size as `self`, but for very short slices a
+    /// non-allocating insertion sort is used instead.
+    ///
+    /// In order to sort the slice in parallel, the slice is first divided into smaller chunks and
+    /// all chunks are sorted in parallel. Then, adjacent chunks that together form non-descending
+    /// or descending runs are concatenated. Finally, the remaining chunks are merged together using
+    /// parallel subdivision of chunks and parallel merge operation.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let mut v = [-5i32, 4, 1, -3, 2];
+    ///
+    /// v.par_sort_by_key(|k| k.abs());
+    /// assert_eq!(v, [1, 2, -3, 4, -5]);
+    /// ```
+    fn par_sort_by_key<K, F>(&mut self, f: F)
+    where
+        K: Ord,
+        F: Fn(&T) -> K + Sync,
+    {
+        par_mergesort(self.as_parallel_slice_mut(), |a, b| f(a).lt(&f(b)));
+    }
+
+    /// Sorts the slice in parallel with a key extraction function.
+    ///
+    /// During sorting, the key function is called at most once per element, by using
+    /// temporary storage to remember the results of key evaluation.
+    /// The key function is called in parallel, so the order of calls is completely unspecified.
+    ///
+    /// This sort is stable (i.e., does not reorder equal elements) and *O*(*m* \* *n* + *n* \* log(*n*))
+    /// worst-case, where the key function is *O*(*m*).
+    ///
+    /// For simple key functions (e.g., functions that are property accesses or
+    /// basic operations), [`par_sort_by_key`](#method.par_sort_by_key) is likely to be
+    /// faster.
+    ///
+    /// # Current implementation
+    ///
+    /// The current algorithm is based on [pattern-defeating quicksort][pdqsort] by Orson Peters,
+    /// which combines the fast average case of randomized quicksort with the fast worst case of
+    /// heapsort, while achieving linear time on slices with certain patterns. It uses some
+    /// randomization to avoid degenerate cases, but with a fixed seed to always provide
+    /// deterministic behavior.
+    ///
+    /// In the worst case, the algorithm allocates temporary storage in a `Vec<(K, usize)>` the
+    /// length of the slice.
+    ///
+    /// All quicksorts work in two stages: partitioning into two halves followed by recursive
+    /// calls. The partitioning phase is sequential, but the two recursive calls are performed in
+    /// parallel. Finally, after sorting the cached keys, the item positions are updated sequentially.
+    ///
+    /// [pdqsort]: https://github.com/orlp/pdqsort
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let mut v = [-5i32, 4, 32, -3, 2];
+    ///
+    /// v.par_sort_by_cached_key(|k| k.to_string());
+    /// assert!(v == [-3, -5, 2, 32, 4]);
+    /// ```
+    fn par_sort_by_cached_key<K, F>(&mut self, f: F)
+    where
+        F: Fn(&T) -> K + Sync,
+        K: Ord + Send,
+    {
+        let slice = self.as_parallel_slice_mut();
+        let len = slice.len();
+        if len < 2 {
+            return;
+        }
+
+        // Helper macro for indexing our vector by the smallest possible type, to reduce allocation.
+        macro_rules! sort_by_key {
+            ($t:ty) => {{
+                let mut indices: Vec<_> = slice
+                    .par_iter_mut()
+                    .enumerate()
+                    .map(|(i, x)| (f(&*x), i as $t))
+                    .collect();
+                // The elements of `indices` are unique, as they are indexed, so any sort will be
+                // stable with respect to the original slice. We use `sort_unstable` here because
+                // it requires less memory allocation.
+                indices.par_sort_unstable();
+                for i in 0..len {
+                    let mut index = indices[i].1;
+                    while (index as usize) < i {
+                        index = indices[index as usize].1;
+                    }
+                    indices[i].1 = index;
+                    slice.swap(i, index as usize);
+                }
+            }};
+        }
+
+        let sz_u8 = mem::size_of::<(K, u8)>();
+        let sz_u16 = mem::size_of::<(K, u16)>();
+        let sz_u32 = mem::size_of::<(K, u32)>();
+        let sz_usize = mem::size_of::<(K, usize)>();
+
+        if sz_u8 < sz_u16 && len <= (std::u8::MAX as usize) {
+            return sort_by_key!(u8);
+        }
+        if sz_u16 < sz_u32 && len <= (std::u16::MAX as usize) {
+            return sort_by_key!(u16);
+        }
+        if sz_u32 < sz_usize && len <= (std::u32::MAX as usize) {
+            return sort_by_key!(u32);
+        }
+        sort_by_key!(usize)
+    }
+
+    /// Sorts the slice in parallel, but might not preserve the order of equal elements.
+    ///
+    /// This sort is unstable (i.e., may reorder equal elements), in-place
+    /// (i.e., does not allocate), and *O*(*n* \* log(*n*)) worst-case.
+    ///
+    /// # Current implementation
+    ///
+    /// The current algorithm is based on [pattern-defeating quicksort][pdqsort] by Orson Peters,
+    /// which combines the fast average case of randomized quicksort with the fast worst case of
+    /// heapsort, while achieving linear time on slices with certain patterns. It uses some
+    /// randomization to avoid degenerate cases, but with a fixed seed to always provide
+    /// deterministic behavior.
+    ///
+    /// It is typically faster than stable sorting, except in a few special cases, e.g., when the
+    /// slice consists of several concatenated sorted sequences.
+    ///
+    /// All quicksorts work in two stages: partitioning into two halves followed by recursive
+    /// calls. The partitioning phase is sequential, but the two recursive calls are performed in
+    /// parallel.
+    ///
+    /// [pdqsort]: https://github.com/orlp/pdqsort
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let mut v = [-5, 4, 1, -3, 2];
+    ///
+    /// v.par_sort_unstable();
+    /// assert_eq!(v, [-5, -3, 1, 2, 4]);
+    /// ```
+    fn par_sort_unstable(&mut self)
+    where
+        T: Ord,
+    {
+        par_quicksort(self.as_parallel_slice_mut(), T::lt);
+    }
+
+    /// Sorts the slice in parallel with a comparator function, but might not preserve the order of
+    /// equal elements.
+    ///
+    /// This sort is unstable (i.e., may reorder equal elements), in-place
+    /// (i.e., does not allocate), and *O*(*n* \* log(*n*)) worst-case.
+    ///
+    /// The comparator function must define a total ordering for the elements in the slice. If
+    /// the ordering is not total, the order of the elements is unspecified. An order is a
+    /// total order if it is (for all `a`, `b` and `c`):
+    ///
+    /// * total and antisymmetric: exactly one of `a < b`, `a == b` or `a > b` is true, and
+    /// * transitive, `a < b` and `b < c` implies `a < c`. The same must hold for both `==` and `>`.
+    ///
+    /// For example, while [`f64`] doesn't implement [`Ord`] because `NaN != NaN`, we can use
+    /// `partial_cmp` as our sort function when we know the slice doesn't contain a `NaN`.
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let mut floats = [5f64, 4.0, 1.0, 3.0, 2.0];
+    /// floats.par_sort_unstable_by(|a, b| a.partial_cmp(b).unwrap());
+    /// assert_eq!(floats, [1.0, 2.0, 3.0, 4.0, 5.0]);
+    /// ```
+    ///
+    /// # Current implementation
+    ///
+    /// The current algorithm is based on [pattern-defeating quicksort][pdqsort] by Orson Peters,
+    /// which combines the fast average case of randomized quicksort with the fast worst case of
+    /// heapsort, while achieving linear time on slices with certain patterns. It uses some
+    /// randomization to avoid degenerate cases, but with a fixed seed to always provide
+    /// deterministic behavior.
+    ///
+    /// It is typically faster than stable sorting, except in a few special cases, e.g., when the
+    /// slice consists of several concatenated sorted sequences.
+    ///
+    /// All quicksorts work in two stages: partitioning into two halves followed by recursive
+    /// calls. The partitioning phase is sequential, but the two recursive calls are performed in
+    /// parallel.
+    ///
+    /// [pdqsort]: https://github.com/orlp/pdqsort
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let mut v = [5, 4, 1, 3, 2];
+    /// v.par_sort_unstable_by(|a, b| a.cmp(b));
+    /// assert_eq!(v, [1, 2, 3, 4, 5]);
+    ///
+    /// // reverse sorting
+    /// v.par_sort_unstable_by(|a, b| b.cmp(a));
+    /// assert_eq!(v, [5, 4, 3, 2, 1]);
+    /// ```
+    fn par_sort_unstable_by<F>(&mut self, compare: F)
+    where
+        F: Fn(&T, &T) -> Ordering + Sync,
+    {
+        par_quicksort(self.as_parallel_slice_mut(), |a, b| {
+            compare(a, b) == Ordering::Less
+        });
+    }
+
+    /// Sorts the slice in parallel with a key extraction function, but might not preserve the order
+    /// of equal elements.
+    ///
+    /// This sort is unstable (i.e., may reorder equal elements), in-place
+    /// (i.e., does not allocate), and *O*(m \* *n* \* log(*n*)) worst-case,
+    /// where the key function is *O*(*m*).
+    ///
+    /// # Current implementation
+    ///
+    /// The current algorithm is based on [pattern-defeating quicksort][pdqsort] by Orson Peters,
+    /// which combines the fast average case of randomized quicksort with the fast worst case of
+    /// heapsort, while achieving linear time on slices with certain patterns. It uses some
+    /// randomization to avoid degenerate cases, but with a fixed seed to always provide
+    /// deterministic behavior.
+    ///
+    /// Due to its key calling strategy, `par_sort_unstable_by_key` is likely to be slower than
+    /// [`par_sort_by_cached_key`](#method.par_sort_by_cached_key) in cases where the key function
+    /// is expensive.
+    ///
+    /// All quicksorts work in two stages: partitioning into two halves followed by recursive
+    /// calls. The partitioning phase is sequential, but the two recursive calls are performed in
+    /// parallel.
+    ///
+    /// [pdqsort]: https://github.com/orlp/pdqsort
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let mut v = [-5i32, 4, 1, -3, 2];
+    ///
+    /// v.par_sort_unstable_by_key(|k| k.abs());
+    /// assert_eq!(v, [1, 2, -3, 4, -5]);
+    /// ```
+    fn par_sort_unstable_by_key<K, F>(&mut self, f: F)
+    where
+        K: Ord,
+        F: Fn(&T) -> K + Sync,
+    {
+        par_quicksort(self.as_parallel_slice_mut(), |a, b| f(a).lt(&f(b)));
+    }
+}
+
+impl<T: Send> ParallelSliceMut<T> for [T] {
+    #[inline]
+    fn as_parallel_slice_mut(&mut self) -> &mut [T] {
+        self
+    }
+}
+
+impl<'data, T: Sync + 'data> IntoParallelIterator for &'data [T] {
+    type Item = &'data T;
+    type Iter = Iter<'data, T>;
+
+    fn into_par_iter(self) -> Self::Iter {
+        Iter { slice: self }
+    }
+}
+
+impl<'data, T: Send + 'data> IntoParallelIterator for &'data mut [T] {
+    type Item = &'data mut T;
+    type Iter = IterMut<'data, T>;
+
+    fn into_par_iter(self) -> Self::Iter {
+        IterMut { slice: self }
+    }
+}
+
+/// Parallel iterator over immutable items in a slice
+#[derive(Debug)]
+pub struct Iter<'data, T: Sync> {
+    slice: &'data [T],
+}
+
+impl<'data, T: Sync> Clone for Iter<'data, T> {
+    fn clone(&self) -> Self {
+        Iter { ..*self }
+    }
+}
+
+impl<'data, T: Sync + 'data> ParallelIterator for Iter<'data, T> {
+    type Item = &'data T;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        Some(self.len())
+    }
+}
+
+impl<'data, T: Sync + 'data> IndexedParallelIterator for Iter<'data, T> {
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn len(&self) -> usize {
+        self.slice.len()
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        callback.callback(IterProducer { slice: self.slice })
+    }
+}
+
+struct IterProducer<'data, T: Sync> {
+    slice: &'data [T],
+}
+
+impl<'data, T: 'data + Sync> Producer for IterProducer<'data, T> {
+    type Item = &'data T;
+    type IntoIter = ::std::slice::Iter<'data, T>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.slice.iter()
+    }
+
+    fn split_at(self, index: usize) -> (Self, Self) {
+        let (left, right) = self.slice.split_at(index);
+        (IterProducer { slice: left }, IterProducer { slice: right })
+    }
+}
+
+/// Parallel iterator over immutable overlapping windows of a slice
+#[derive(Debug)]
+pub struct Windows<'data, T: Sync> {
+    window_size: usize,
+    slice: &'data [T],
+}
+
+impl<'data, T: Sync> Clone for Windows<'data, T> {
+    fn clone(&self) -> Self {
+        Windows { ..*self }
+    }
+}
+
+impl<'data, T: Sync + 'data> ParallelIterator for Windows<'data, T> {
+    type Item = &'data [T];
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        Some(self.len())
+    }
+}
+
+impl<'data, T: Sync + 'data> IndexedParallelIterator for Windows<'data, T> {
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn len(&self) -> usize {
+        assert!(self.window_size >= 1);
+        self.slice.len().saturating_sub(self.window_size - 1)
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        callback.callback(WindowsProducer {
+            window_size: self.window_size,
+            slice: self.slice,
+        })
+    }
+}
+
+struct WindowsProducer<'data, T: Sync> {
+    window_size: usize,
+    slice: &'data [T],
+}
+
+impl<'data, T: 'data + Sync> Producer for WindowsProducer<'data, T> {
+    type Item = &'data [T];
+    type IntoIter = ::std::slice::Windows<'data, T>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.slice.windows(self.window_size)
+    }
+
+    fn split_at(self, index: usize) -> (Self, Self) {
+        let left_index = cmp::min(self.slice.len(), index + (self.window_size - 1));
+        let left = &self.slice[..left_index];
+        let right = &self.slice[index..];
+        (
+            WindowsProducer {
+                window_size: self.window_size,
+                slice: left,
+            },
+            WindowsProducer {
+                window_size: self.window_size,
+                slice: right,
+            },
+        )
+    }
+}
+
+/// Parallel iterator over mutable items in a slice
+#[derive(Debug)]
+pub struct IterMut<'data, T: Send> {
+    slice: &'data mut [T],
+}
+
+impl<'data, T: Send + 'data> ParallelIterator for IterMut<'data, T> {
+    type Item = &'data mut T;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        Some(self.len())
+    }
+}
+
+impl<'data, T: Send + 'data> IndexedParallelIterator for IterMut<'data, T> {
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn len(&self) -> usize {
+        self.slice.len()
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        callback.callback(IterMutProducer { slice: self.slice })
+    }
+}
+
+struct IterMutProducer<'data, T: Send> {
+    slice: &'data mut [T],
+}
+
+impl<'data, T: 'data + Send> Producer for IterMutProducer<'data, T> {
+    type Item = &'data mut T;
+    type IntoIter = ::std::slice::IterMut<'data, T>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.slice.iter_mut()
+    }
+
+    fn split_at(self, index: usize) -> (Self, Self) {
+        let (left, right) = self.slice.split_at_mut(index);
+        (
+            IterMutProducer { slice: left },
+            IterMutProducer { slice: right },
+        )
+    }
+}
+
+/// Parallel iterator over slices separated by a predicate
+pub struct Split<'data, T, P> {
+    slice: &'data [T],
+    separator: P,
+}
+
+impl<'data, T, P: Clone> Clone for Split<'data, T, P> {
+    fn clone(&self) -> Self {
+        Split {
+            separator: self.separator.clone(),
+            ..*self
+        }
+    }
+}
+
+impl<'data, T: Debug, P> Debug for Split<'data, T, P> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Split").field("slice", &self.slice).finish()
+    }
+}
+
+impl<'data, T, P> ParallelIterator for Split<'data, T, P>
+where
+    P: Fn(&T) -> bool + Sync + Send,
+    T: Sync,
+{
+    type Item = &'data [T];
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        let producer = SplitProducer::new(self.slice, &self.separator);
+        bridge_unindexed(producer, consumer)
+    }
+}
+
+/// Implement support for `SplitProducer`.
+impl<'data, T, P> Fissile<P> for &'data [T]
+where
+    P: Fn(&T) -> bool,
+{
+    fn length(&self) -> usize {
+        self.len()
+    }
+
+    fn midpoint(&self, end: usize) -> usize {
+        end / 2
+    }
+
+    fn find(&self, separator: &P, start: usize, end: usize) -> Option<usize> {
+        self[start..end].iter().position(separator)
+    }
+
+    fn rfind(&self, separator: &P, end: usize) -> Option<usize> {
+        self[..end].iter().rposition(separator)
+    }
+
+    fn split_once(self, index: usize) -> (Self, Self) {
+        let (left, right) = self.split_at(index);
+        (left, &right[1..]) // skip the separator
+    }
+
+    fn fold_splits<F>(self, separator: &P, folder: F, skip_last: bool) -> F
+    where
+        F: Folder<Self>,
+        Self: Send,
+    {
+        let mut split = self.split(separator);
+        if skip_last {
+            split.next_back();
+        }
+        folder.consume_iter(split)
+    }
+}
+
+/// Parallel iterator over mutable slices separated by a predicate
+pub struct SplitMut<'data, T, P> {
+    slice: &'data mut [T],
+    separator: P,
+}
+
+impl<'data, T: Debug, P> Debug for SplitMut<'data, T, P> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("SplitMut")
+            .field("slice", &self.slice)
+            .finish()
+    }
+}
+
+impl<'data, T, P> ParallelIterator for SplitMut<'data, T, P>
+where
+    P: Fn(&T) -> bool + Sync + Send,
+    T: Send,
+{
+    type Item = &'data mut [T];
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        let producer = SplitProducer::new(self.slice, &self.separator);
+        bridge_unindexed(producer, consumer)
+    }
+}
+
+/// Implement support for `SplitProducer`.
+impl<'data, T, P> Fissile<P> for &'data mut [T]
+where
+    P: Fn(&T) -> bool,
+{
+    fn length(&self) -> usize {
+        self.len()
+    }
+
+    fn midpoint(&self, end: usize) -> usize {
+        end / 2
+    }
+
+    fn find(&self, separator: &P, start: usize, end: usize) -> Option<usize> {
+        self[start..end].iter().position(separator)
+    }
+
+    fn rfind(&self, separator: &P, end: usize) -> Option<usize> {
+        self[..end].iter().rposition(separator)
+    }
+
+    fn split_once(self, index: usize) -> (Self, Self) {
+        let (left, right) = self.split_at_mut(index);
+        (left, &mut right[1..]) // skip the separator
+    }
+
+    fn fold_splits<F>(self, separator: &P, folder: F, skip_last: bool) -> F
+    where
+        F: Folder<Self>,
+        Self: Send,
+    {
+        let mut split = self.split_mut(separator);
+        if skip_last {
+            split.next_back();
+        }
+        folder.consume_iter(split)
+    }
+}
diff --git a/crates/rayon/src/slice/quicksort.rs b/crates/rayon/src/slice/quicksort.rs
new file mode 100644
index 0000000..2bfc350
--- /dev/null
+++ b/crates/rayon/src/slice/quicksort.rs
@@ -0,0 +1,903 @@
+//! Parallel quicksort.
+//!
+//! This implementation is copied verbatim from `std::slice::sort_unstable` and then parallelized.
+//! The only difference from the original is that calls to `recurse` are executed in parallel using
+//! `rayon_core::join`.
+
+use std::cmp;
+use std::marker::PhantomData;
+use std::mem::{self, MaybeUninit};
+use std::ptr;
+
+/// When dropped, copies from `src` into `dest`.
+#[must_use]
+struct CopyOnDrop<'a, T> {
+    src: *const T,
+    dest: *mut T,
+    /// `src` is often a local pointer here, make sure we have appropriate
+    /// PhantomData so that dropck can protect us.
+    marker: PhantomData<&'a mut T>,
+}
+
+impl<'a, T> CopyOnDrop<'a, T> {
+    /// Construct from a source pointer and a destination
+    /// Assumes dest lives longer than src, since there is no easy way to
+    /// copy down lifetime information from another pointer
+    unsafe fn new(src: &'a T, dest: *mut T) -> Self {
+        CopyOnDrop {
+            src,
+            dest,
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<T> Drop for CopyOnDrop<'_, T> {
+    fn drop(&mut self) {
+        // SAFETY:  This is a helper class.
+        //          Please refer to its usage for correctness.
+        //          Namely, one must be sure that `src` and `dst` does not overlap as required by `ptr::copy_nonoverlapping`.
+        unsafe {
+            ptr::copy_nonoverlapping(self.src, self.dest, 1);
+        }
+    }
+}
+
+/// Shifts the first element to the right until it encounters a greater or equal element.
+fn shift_head<T, F>(v: &mut [T], is_less: &F)
+where
+    F: Fn(&T, &T) -> bool,
+{
+    let len = v.len();
+    // SAFETY: The unsafe operations below involves indexing without a bounds check (by offsetting a
+    // pointer) and copying memory (`ptr::copy_nonoverlapping`).
+    //
+    // a. Indexing:
+    //  1. We checked the size of the array to >=2.
+    //  2. All the indexing that we will do is always between {0 <= index < len} at most.
+    //
+    // b. Memory copying
+    //  1. We are obtaining pointers to references which are guaranteed to be valid.
+    //  2. They cannot overlap because we obtain pointers to difference indices of the slice.
+    //     Namely, `i` and `i-1`.
+    //  3. If the slice is properly aligned, the elements are properly aligned.
+    //     It is the caller's responsibility to make sure the slice is properly aligned.
+    //
+    // See comments below for further detail.
+    unsafe {
+        // If the first two elements are out-of-order...
+        if len >= 2 && is_less(v.get_unchecked(1), v.get_unchecked(0)) {
+            // Read the first element into a stack-allocated variable. If a following comparison
+            // operation panics, `hole` will get dropped and automatically write the element back
+            // into the slice.
+            let tmp = mem::ManuallyDrop::new(ptr::read(v.get_unchecked(0)));
+            let v = v.as_mut_ptr();
+            let mut hole = CopyOnDrop::new(&*tmp, v.add(1));
+            ptr::copy_nonoverlapping(v.add(1), v.add(0), 1);
+
+            for i in 2..len {
+                if !is_less(&*v.add(i), &*tmp) {
+                    break;
+                }
+
+                // Move `i`-th element one place to the left, thus shifting the hole to the right.
+                ptr::copy_nonoverlapping(v.add(i), v.add(i - 1), 1);
+                hole.dest = v.add(i);
+            }
+            // `hole` gets dropped and thus copies `tmp` into the remaining hole in `v`.
+        }
+    }
+}
+
+/// Shifts the last element to the left until it encounters a smaller or equal element.
+fn shift_tail<T, F>(v: &mut [T], is_less: &F)
+where
+    F: Fn(&T, &T) -> bool,
+{
+    let len = v.len();
+    // SAFETY: The unsafe operations below involves indexing without a bound check (by offsetting a
+    // pointer) and copying memory (`ptr::copy_nonoverlapping`).
+    //
+    // a. Indexing:
+    //  1. We checked the size of the array to >= 2.
+    //  2. All the indexing that we will do is always between `0 <= index < len-1` at most.
+    //
+    // b. Memory copying
+    //  1. We are obtaining pointers to references which are guaranteed to be valid.
+    //  2. They cannot overlap because we obtain pointers to difference indices of the slice.
+    //     Namely, `i` and `i+1`.
+    //  3. If the slice is properly aligned, the elements are properly aligned.
+    //     It is the caller's responsibility to make sure the slice is properly aligned.
+    //
+    // See comments below for further detail.
+    unsafe {
+        // If the last two elements are out-of-order...
+        if len >= 2 && is_less(v.get_unchecked(len - 1), v.get_unchecked(len - 2)) {
+            // Read the last element into a stack-allocated variable. If a following comparison
+            // operation panics, `hole` will get dropped and automatically write the element back
+            // into the slice.
+            let tmp = mem::ManuallyDrop::new(ptr::read(v.get_unchecked(len - 1)));
+            let v = v.as_mut_ptr();
+            let mut hole = CopyOnDrop::new(&*tmp, v.add(len - 2));
+            ptr::copy_nonoverlapping(v.add(len - 2), v.add(len - 1), 1);
+
+            for i in (0..len - 2).rev() {
+                if !is_less(&*tmp, &*v.add(i)) {
+                    break;
+                }
+
+                // Move `i`-th element one place to the right, thus shifting the hole to the left.
+                ptr::copy_nonoverlapping(v.add(i), v.add(i + 1), 1);
+                hole.dest = v.add(i);
+            }
+            // `hole` gets dropped and thus copies `tmp` into the remaining hole in `v`.
+        }
+    }
+}
+
+/// Partially sorts a slice by shifting several out-of-order elements around.
+///
+/// Returns `true` if the slice is sorted at the end. This function is *O*(*n*) worst-case.
+#[cold]
+fn partial_insertion_sort<T, F>(v: &mut [T], is_less: &F) -> bool
+where
+    F: Fn(&T, &T) -> bool,
+{
+    // Maximum number of adjacent out-of-order pairs that will get shifted.
+    const MAX_STEPS: usize = 5;
+    // If the slice is shorter than this, don't shift any elements.
+    const SHORTEST_SHIFTING: usize = 50;
+
+    let len = v.len();
+    let mut i = 1;
+
+    for _ in 0..MAX_STEPS {
+        // SAFETY: We already explicitly did the bound checking with `i < len`.
+        // All our subsequent indexing is only in the range `0 <= index < len`
+        unsafe {
+            // Find the next pair of adjacent out-of-order elements.
+            while i < len && !is_less(v.get_unchecked(i), v.get_unchecked(i - 1)) {
+                i += 1;
+            }
+        }
+
+        // Are we done?
+        if i == len {
+            return true;
+        }
+
+        // Don't shift elements on short arrays, that has a performance cost.
+        if len < SHORTEST_SHIFTING {
+            return false;
+        }
+
+        // Swap the found pair of elements. This puts them in correct order.
+        v.swap(i - 1, i);
+
+        // Shift the smaller element to the left.
+        shift_tail(&mut v[..i], is_less);
+        // Shift the greater element to the right.
+        shift_head(&mut v[i..], is_less);
+    }
+
+    // Didn't manage to sort the slice in the limited number of steps.
+    false
+}
+
+/// Sorts a slice using insertion sort, which is *O*(*n*^2) worst-case.
+fn insertion_sort<T, F>(v: &mut [T], is_less: &F)
+where
+    F: Fn(&T, &T) -> bool,
+{
+    for i in 1..v.len() {
+        shift_tail(&mut v[..i + 1], is_less);
+    }
+}
+
+/// Sorts `v` using heapsort, which guarantees *O*(*n* \* log(*n*)) worst-case.
+#[cold]
+fn heapsort<T, F>(v: &mut [T], is_less: &F)
+where
+    F: Fn(&T, &T) -> bool,
+{
+    // This binary heap respects the invariant `parent >= child`.
+    let sift_down = |v: &mut [T], mut node| {
+        loop {
+            // Children of `node`.
+            let mut child = 2 * node + 1;
+            if child >= v.len() {
+                break;
+            }
+
+            // Choose the greater child.
+            if child + 1 < v.len() && is_less(&v[child], &v[child + 1]) {
+                child += 1;
+            }
+
+            // Stop if the invariant holds at `node`.
+            if !is_less(&v[node], &v[child]) {
+                break;
+            }
+
+            // Swap `node` with the greater child, move one step down, and continue sifting.
+            v.swap(node, child);
+            node = child;
+        }
+    };
+
+    // Build the heap in linear time.
+    for i in (0..v.len() / 2).rev() {
+        sift_down(v, i);
+    }
+
+    // Pop maximal elements from the heap.
+    for i in (1..v.len()).rev() {
+        v.swap(0, i);
+        sift_down(&mut v[..i], 0);
+    }
+}
+
+/// Partitions `v` into elements smaller than `pivot`, followed by elements greater than or equal
+/// to `pivot`.
+///
+/// Returns the number of elements smaller than `pivot`.
+///
+/// Partitioning is performed block-by-block in order to minimize the cost of branching operations.
+/// This idea is presented in the [BlockQuicksort][pdf] paper.
+///
+/// [pdf]: https://drops.dagstuhl.de/opus/volltexte/2016/6389/pdf/LIPIcs-ESA-2016-38.pdf
+fn partition_in_blocks<T, F>(v: &mut [T], pivot: &T, is_less: &F) -> usize
+where
+    F: Fn(&T, &T) -> bool,
+{
+    // Number of elements in a typical block.
+    const BLOCK: usize = 128;
+
+    // The partitioning algorithm repeats the following steps until completion:
+    //
+    // 1. Trace a block from the left side to identify elements greater than or equal to the pivot.
+    // 2. Trace a block from the right side to identify elements smaller than the pivot.
+    // 3. Exchange the identified elements between the left and right side.
+    //
+    // We keep the following variables for a block of elements:
+    //
+    // 1. `block` - Number of elements in the block.
+    // 2. `start` - Start pointer into the `offsets` array.
+    // 3. `end` - End pointer into the `offsets` array.
+    // 4. `offsets - Indices of out-of-order elements within the block.
+
+    // The current block on the left side (from `l` to `l.add(block_l)`).
+    let mut l = v.as_mut_ptr();
+    let mut block_l = BLOCK;
+    let mut start_l = ptr::null_mut();
+    let mut end_l = ptr::null_mut();
+    let mut offsets_l = [MaybeUninit::<u8>::uninit(); BLOCK];
+
+    // The current block on the right side (from `r.sub(block_r)` to `r`).
+    // SAFETY: The documentation for .add() specifically mention that `vec.as_ptr().add(vec.len())` is always safe`
+    let mut r = unsafe { l.add(v.len()) };
+    let mut block_r = BLOCK;
+    let mut start_r = ptr::null_mut();
+    let mut end_r = ptr::null_mut();
+    let mut offsets_r = [MaybeUninit::<u8>::uninit(); BLOCK];
+
+    // FIXME: When we get VLAs, try creating one array of length `min(v.len(), 2 * BLOCK)` rather
+    // than two fixed-size arrays of length `BLOCK`. VLAs might be more cache-efficient.
+
+    // Returns the number of elements between pointers `l` (inclusive) and `r` (exclusive).
+    fn width<T>(l: *mut T, r: *mut T) -> usize {
+        assert!(mem::size_of::<T>() > 0);
+        // FIXME: this should *likely* use `offset_from`, but more
+        // investigation is needed (including running tests in miri).
+        // TODO unstable: (r.addr() - l.addr()) / mem::size_of::<T>()
+        (r as usize - l as usize) / mem::size_of::<T>()
+    }
+
+    loop {
+        // We are done with partitioning block-by-block when `l` and `r` get very close. Then we do
+        // some patch-up work in order to partition the remaining elements in between.
+        let is_done = width(l, r) <= 2 * BLOCK;
+
+        if is_done {
+            // Number of remaining elements (still not compared to the pivot).
+            let mut rem = width(l, r);
+            if start_l < end_l || start_r < end_r {
+                rem -= BLOCK;
+            }
+
+            // Adjust block sizes so that the left and right block don't overlap, but get perfectly
+            // aligned to cover the whole remaining gap.
+            if start_l < end_l {
+                block_r = rem;
+            } else if start_r < end_r {
+                block_l = rem;
+            } else {
+                // There were the same number of elements to switch on both blocks during the last
+                // iteration, so there are no remaining elements on either block. Cover the remaining
+                // items with roughly equally-sized blocks.
+                block_l = rem / 2;
+                block_r = rem - block_l;
+            }
+            debug_assert!(block_l <= BLOCK && block_r <= BLOCK);
+            debug_assert!(width(l, r) == block_l + block_r);
+        }
+
+        if start_l == end_l {
+            // Trace `block_l` elements from the left side.
+            // TODO unstable: start_l = MaybeUninit::slice_as_mut_ptr(&mut offsets_l);
+            start_l = offsets_l.as_mut_ptr() as *mut u8;
+            end_l = start_l;
+            let mut elem = l;
+
+            for i in 0..block_l {
+                // SAFETY: The unsafety operations below involve the usage of the `offset`.
+                //         According to the conditions required by the function, we satisfy them because:
+                //         1. `offsets_l` is stack-allocated, and thus considered separate allocated object.
+                //         2. The function `is_less` returns a `bool`.
+                //            Casting a `bool` will never overflow `isize`.
+                //         3. We have guaranteed that `block_l` will be `<= BLOCK`.
+                //            Plus, `end_l` was initially set to the begin pointer of `offsets_` which was declared on the stack.
+                //            Thus, we know that even in the worst case (all invocations of `is_less` returns false) we will only be at most 1 byte pass the end.
+                //        Another unsafety operation here is dereferencing `elem`.
+                //        However, `elem` was initially the begin pointer to the slice which is always valid.
+                unsafe {
+                    // Branchless comparison.
+                    *end_l = i as u8;
+                    end_l = end_l.offset(!is_less(&*elem, pivot) as isize);
+                    elem = elem.offset(1);
+                }
+            }
+        }
+
+        if start_r == end_r {
+            // Trace `block_r` elements from the right side.
+            // TODO unstable: start_r = MaybeUninit::slice_as_mut_ptr(&mut offsets_r);
+            start_r = offsets_r.as_mut_ptr() as *mut u8;
+            end_r = start_r;
+            let mut elem = r;
+
+            for i in 0..block_r {
+                // SAFETY: The unsafety operations below involve the usage of the `offset`.
+                //         According to the conditions required by the function, we satisfy them because:
+                //         1. `offsets_r` is stack-allocated, and thus considered separate allocated object.
+                //         2. The function `is_less` returns a `bool`.
+                //            Casting a `bool` will never overflow `isize`.
+                //         3. We have guaranteed that `block_r` will be `<= BLOCK`.
+                //            Plus, `end_r` was initially set to the begin pointer of `offsets_` which was declared on the stack.
+                //            Thus, we know that even in the worst case (all invocations of `is_less` returns true) we will only be at most 1 byte pass the end.
+                //        Another unsafety operation here is dereferencing `elem`.
+                //        However, `elem` was initially `1 * sizeof(T)` past the end and we decrement it by `1 * sizeof(T)` before accessing it.
+                //        Plus, `block_r` was asserted to be less than `BLOCK` and `elem` will therefore at most be pointing to the beginning of the slice.
+                unsafe {
+                    // Branchless comparison.
+                    elem = elem.offset(-1);
+                    *end_r = i as u8;
+                    end_r = end_r.offset(is_less(&*elem, pivot) as isize);
+                }
+            }
+        }
+
+        // Number of out-of-order elements to swap between the left and right side.
+        let count = cmp::min(width(start_l, end_l), width(start_r, end_r));
+
+        if count > 0 {
+            macro_rules! left {
+                () => {
+                    l.offset(*start_l as isize)
+                };
+            }
+            macro_rules! right {
+                () => {
+                    r.offset(-(*start_r as isize) - 1)
+                };
+            }
+
+            // Instead of swapping one pair at the time, it is more efficient to perform a cyclic
+            // permutation. This is not strictly equivalent to swapping, but produces a similar
+            // result using fewer memory operations.
+
+            // SAFETY: The use of `ptr::read` is valid because there is at least one element in
+            // both `offsets_l` and `offsets_r`, so `left!` is a valid pointer to read from.
+            //
+            // The uses of `left!` involve calls to `offset` on `l`, which points to the
+            // beginning of `v`. All the offsets pointed-to by `start_l` are at most `block_l`, so
+            // these `offset` calls are safe as all reads are within the block. The same argument
+            // applies for the uses of `right!`.
+            //
+            // The calls to `start_l.offset` are valid because there are at most `count-1` of them,
+            // plus the final one at the end of the unsafe block, where `count` is the minimum number
+            // of collected offsets in `offsets_l` and `offsets_r`, so there is no risk of there not
+            // being enough elements. The same reasoning applies to the calls to `start_r.offset`.
+            //
+            // The calls to `copy_nonoverlapping` are safe because `left!` and `right!` are guaranteed
+            // not to overlap, and are valid because of the reasoning above.
+            unsafe {
+                let tmp = ptr::read(left!());
+                ptr::copy_nonoverlapping(right!(), left!(), 1);
+
+                for _ in 1..count {
+                    start_l = start_l.offset(1);
+                    ptr::copy_nonoverlapping(left!(), right!(), 1);
+                    start_r = start_r.offset(1);
+                    ptr::copy_nonoverlapping(right!(), left!(), 1);
+                }
+
+                ptr::copy_nonoverlapping(&tmp, right!(), 1);
+                mem::forget(tmp);
+                start_l = start_l.offset(1);
+                start_r = start_r.offset(1);
+            }
+        }
+
+        if start_l == end_l {
+            // All out-of-order elements in the left block were moved. Move to the next block.
+
+            // block-width-guarantee
+            // SAFETY: if `!is_done` then the slice width is guaranteed to be at least `2*BLOCK` wide. There
+            // are at most `BLOCK` elements in `offsets_l` because of its size, so the `offset` operation is
+            // safe. Otherwise, the debug assertions in the `is_done` case guarantee that
+            // `width(l, r) == block_l + block_r`, namely, that the block sizes have been adjusted to account
+            // for the smaller number of remaining elements.
+            l = unsafe { l.add(block_l) };
+        }
+
+        if start_r == end_r {
+            // All out-of-order elements in the right block were moved. Move to the previous block.
+
+            // SAFETY: Same argument as [block-width-guarantee]. Either this is a full block `2*BLOCK`-wide,
+            // or `block_r` has been adjusted for the last handful of elements.
+            r = unsafe { r.offset(-(block_r as isize)) };
+        }
+
+        if is_done {
+            break;
+        }
+    }
+
+    // All that remains now is at most one block (either the left or the right) with out-of-order
+    // elements that need to be moved. Such remaining elements can be simply shifted to the end
+    // within their block.
+
+    if start_l < end_l {
+        // The left block remains.
+        // Move its remaining out-of-order elements to the far right.
+        debug_assert_eq!(width(l, r), block_l);
+        while start_l < end_l {
+            // remaining-elements-safety
+            // SAFETY: while the loop condition holds there are still elements in `offsets_l`, so it
+            // is safe to point `end_l` to the previous element.
+            //
+            // The `ptr::swap` is safe if both its arguments are valid for reads and writes:
+            //  - Per the debug assert above, the distance between `l` and `r` is `block_l`
+            //    elements, so there can be at most `block_l` remaining offsets between `start_l`
+            //    and `end_l`. This means `r` will be moved at most `block_l` steps back, which
+            //    makes the `r.offset` calls valid (at that point `l == r`).
+            //  - `offsets_l` contains valid offsets into `v` collected during the partitioning of
+            //    the last block, so the `l.offset` calls are valid.
+            unsafe {
+                end_l = end_l.offset(-1);
+                ptr::swap(l.offset(*end_l as isize), r.offset(-1));
+                r = r.offset(-1);
+            }
+        }
+        width(v.as_mut_ptr(), r)
+    } else if start_r < end_r {
+        // The right block remains.
+        // Move its remaining out-of-order elements to the far left.
+        debug_assert_eq!(width(l, r), block_r);
+        while start_r < end_r {
+            // SAFETY: See the reasoning in [remaining-elements-safety].
+            unsafe {
+                end_r = end_r.offset(-1);
+                ptr::swap(l, r.offset(-(*end_r as isize) - 1));
+                l = l.offset(1);
+            }
+        }
+        width(v.as_mut_ptr(), l)
+    } else {
+        // Nothing else to do, we're done.
+        width(v.as_mut_ptr(), l)
+    }
+}
+
+/// Partitions `v` into elements smaller than `v[pivot]`, followed by elements greater than or
+/// equal to `v[pivot]`.
+///
+/// Returns a tuple of:
+///
+/// 1. Number of elements smaller than `v[pivot]`.
+/// 2. True if `v` was already partitioned.
+fn partition<T, F>(v: &mut [T], pivot: usize, is_less: &F) -> (usize, bool)
+where
+    F: Fn(&T, &T) -> bool,
+{
+    let (mid, was_partitioned) = {
+        // Place the pivot at the beginning of slice.
+        v.swap(0, pivot);
+        let (pivot, v) = v.split_at_mut(1);
+        let pivot = &mut pivot[0];
+
+        // Read the pivot into a stack-allocated variable for efficiency. If a following comparison
+        // operation panics, the pivot will be automatically written back into the slice.
+
+        // SAFETY: `pivot` is a reference to the first element of `v`, so `ptr::read` is safe.
+        let tmp = mem::ManuallyDrop::new(unsafe { ptr::read(pivot) });
+        let _pivot_guard = unsafe { CopyOnDrop::new(&*tmp, pivot) };
+        let pivot = &*tmp;
+
+        // Find the first pair of out-of-order elements.
+        let mut l = 0;
+        let mut r = v.len();
+
+        // SAFETY: The unsafety below involves indexing an array.
+        // For the first one: We already do the bounds checking here with `l < r`.
+        // For the second one: We initially have `l == 0` and `r == v.len()` and we checked that `l < r` at every indexing operation.
+        //                     From here we know that `r` must be at least `r == l` which was shown to be valid from the first one.
+        unsafe {
+            // Find the first element greater than or equal to the pivot.
+            while l < r && is_less(v.get_unchecked(l), pivot) {
+                l += 1;
+            }
+
+            // Find the last element smaller that the pivot.
+            while l < r && !is_less(v.get_unchecked(r - 1), pivot) {
+                r -= 1;
+            }
+        }
+
+        (
+            l + partition_in_blocks(&mut v[l..r], pivot, is_less),
+            l >= r,
+        )
+
+        // `_pivot_guard` goes out of scope and writes the pivot (which is a stack-allocated
+        // variable) back into the slice where it originally was. This step is critical in ensuring
+        // safety!
+    };
+
+    // Place the pivot between the two partitions.
+    v.swap(0, mid);
+
+    (mid, was_partitioned)
+}
+
+/// Partitions `v` into elements equal to `v[pivot]` followed by elements greater than `v[pivot]`.
+///
+/// Returns the number of elements equal to the pivot. It is assumed that `v` does not contain
+/// elements smaller than the pivot.
+fn partition_equal<T, F>(v: &mut [T], pivot: usize, is_less: &F) -> usize
+where
+    F: Fn(&T, &T) -> bool,
+{
+    // Place the pivot at the beginning of slice.
+    v.swap(0, pivot);
+    let (pivot, v) = v.split_at_mut(1);
+    let pivot = &mut pivot[0];
+
+    // Read the pivot into a stack-allocated variable for efficiency. If a following comparison
+    // operation panics, the pivot will be automatically written back into the slice.
+    // SAFETY: The pointer here is valid because it is obtained from a reference to a slice.
+    let tmp = mem::ManuallyDrop::new(unsafe { ptr::read(pivot) });
+    let _pivot_guard = unsafe { CopyOnDrop::new(&*tmp, pivot) };
+    let pivot = &*tmp;
+
+    // Now partition the slice.
+    let mut l = 0;
+    let mut r = v.len();
+    loop {
+        // SAFETY: The unsafety below involves indexing an array.
+        // For the first one: We already do the bounds checking here with `l < r`.
+        // For the second one: We initially have `l == 0` and `r == v.len()` and we checked that `l < r` at every indexing operation.
+        //                     From here we know that `r` must be at least `r == l` which was shown to be valid from the first one.
+        unsafe {
+            // Find the first element greater than the pivot.
+            while l < r && !is_less(pivot, v.get_unchecked(l)) {
+                l += 1;
+            }
+
+            // Find the last element equal to the pivot.
+            while l < r && is_less(pivot, v.get_unchecked(r - 1)) {
+                r -= 1;
+            }
+
+            // Are we done?
+            if l >= r {
+                break;
+            }
+
+            // Swap the found pair of out-of-order elements.
+            r -= 1;
+            let ptr = v.as_mut_ptr();
+            ptr::swap(ptr.add(l), ptr.add(r));
+            l += 1;
+        }
+    }
+
+    // We found `l` elements equal to the pivot. Add 1 to account for the pivot itself.
+    l + 1
+
+    // `_pivot_guard` goes out of scope and writes the pivot (which is a stack-allocated variable)
+    // back into the slice where it originally was. This step is critical in ensuring safety!
+}
+
+/// Scatters some elements around in an attempt to break patterns that might cause imbalanced
+/// partitions in quicksort.
+#[cold]
+fn break_patterns<T>(v: &mut [T]) {
+    let len = v.len();
+    if len >= 8 {
+        // Pseudorandom number generator from the "Xorshift RNGs" paper by George Marsaglia.
+        let mut random = len as u32;
+        let mut gen_u32 = || {
+            random ^= random << 13;
+            random ^= random >> 17;
+            random ^= random << 5;
+            random
+        };
+        let mut gen_usize = || {
+            if usize::BITS <= 32 {
+                gen_u32() as usize
+            } else {
+                (((gen_u32() as u64) << 32) | (gen_u32() as u64)) as usize
+            }
+        };
+
+        // Take random numbers modulo this number.
+        // The number fits into `usize` because `len` is not greater than `isize::MAX`.
+        let modulus = len.next_power_of_two();
+
+        // Some pivot candidates will be in the nearby of this index. Let's randomize them.
+        let pos = len / 4 * 2;
+
+        for i in 0..3 {
+            // Generate a random number modulo `len`. However, in order to avoid costly operations
+            // we first take it modulo a power of two, and then decrease by `len` until it fits
+            // into the range `[0, len - 1]`.
+            let mut other = gen_usize() & (modulus - 1);
+
+            // `other` is guaranteed to be less than `2 * len`.
+            if other >= len {
+                other -= len;
+            }
+
+            v.swap(pos - 1 + i, other);
+        }
+    }
+}
+
+/// Chooses a pivot in `v` and returns the index and `true` if the slice is likely already sorted.
+///
+/// Elements in `v` might be reordered in the process.
+fn choose_pivot<T, F>(v: &mut [T], is_less: &F) -> (usize, bool)
+where
+    F: Fn(&T, &T) -> bool,
+{
+    // Minimum length to choose the median-of-medians method.
+    // Shorter slices use the simple median-of-three method.
+    const SHORTEST_MEDIAN_OF_MEDIANS: usize = 50;
+    // Maximum number of swaps that can be performed in this function.
+    const MAX_SWAPS: usize = 4 * 3;
+
+    let len = v.len();
+
+    // Three indices near which we are going to choose a pivot.
+    #[allow(clippy::identity_op)]
+    let mut a = len / 4 * 1;
+    let mut b = len / 4 * 2;
+    let mut c = len / 4 * 3;
+
+    // Counts the total number of swaps we are about to perform while sorting indices.
+    let mut swaps = 0;
+
+    if len >= 8 {
+        // Swaps indices so that `v[a] <= v[b]`.
+        // SAFETY: `len >= 8` so there are at least two elements in the neighborhoods of
+        // `a`, `b` and `c`. This means the three calls to `sort_adjacent` result in
+        // corresponding calls to `sort3` with valid 3-item neighborhoods around each
+        // pointer, which in turn means the calls to `sort2` are done with valid
+        // references. Thus the `v.get_unchecked` calls are safe, as is the `ptr::swap`
+        // call.
+        let mut sort2 = |a: &mut usize, b: &mut usize| unsafe {
+            if is_less(v.get_unchecked(*b), v.get_unchecked(*a)) {
+                ptr::swap(a, b);
+                swaps += 1;
+            }
+        };
+
+        // Swaps indices so that `v[a] <= v[b] <= v[c]`.
+        let mut sort3 = |a: &mut usize, b: &mut usize, c: &mut usize| {
+            sort2(a, b);
+            sort2(b, c);
+            sort2(a, b);
+        };
+
+        if len >= SHORTEST_MEDIAN_OF_MEDIANS {
+            // Finds the median of `v[a - 1], v[a], v[a + 1]` and stores the index into `a`.
+            let mut sort_adjacent = |a: &mut usize| {
+                let tmp = *a;
+                sort3(&mut (tmp - 1), a, &mut (tmp + 1));
+            };
+
+            // Find medians in the neighborhoods of `a`, `b`, and `c`.
+            sort_adjacent(&mut a);
+            sort_adjacent(&mut b);
+            sort_adjacent(&mut c);
+        }
+
+        // Find the median among `a`, `b`, and `c`.
+        sort3(&mut a, &mut b, &mut c);
+    }
+
+    if swaps < MAX_SWAPS {
+        (b, swaps == 0)
+    } else {
+        // The maximum number of swaps was performed. Chances are the slice is descending or mostly
+        // descending, so reversing will probably help sort it faster.
+        v.reverse();
+        (len - 1 - b, true)
+    }
+}
+
+/// Sorts `v` recursively.
+///
+/// If the slice had a predecessor in the original array, it is specified as `pred`.
+///
+/// `limit` is the number of allowed imbalanced partitions before switching to `heapsort`. If zero,
+/// this function will immediately switch to heapsort.
+fn recurse<'a, T, F>(mut v: &'a mut [T], is_less: &F, mut pred: Option<&'a mut T>, mut limit: u32)
+where
+    T: Send,
+    F: Fn(&T, &T) -> bool + Sync,
+{
+    // Slices of up to this length get sorted using insertion sort.
+    const MAX_INSERTION: usize = 20;
+    // If both partitions are up to this length, we continue sequentially. This number is as small
+    // as possible but so that the overhead of Rayon's task scheduling is still negligible.
+    const MAX_SEQUENTIAL: usize = 2000;
+
+    // True if the last partitioning was reasonably balanced.
+    let mut was_balanced = true;
+    // True if the last partitioning didn't shuffle elements (the slice was already partitioned).
+    let mut was_partitioned = true;
+
+    loop {
+        let len = v.len();
+
+        // Very short slices get sorted using insertion sort.
+        if len <= MAX_INSERTION {
+            insertion_sort(v, is_less);
+            return;
+        }
+
+        // If too many bad pivot choices were made, simply fall back to heapsort in order to
+        // guarantee `O(n * log(n))` worst-case.
+        if limit == 0 {
+            heapsort(v, is_less);
+            return;
+        }
+
+        // If the last partitioning was imbalanced, try breaking patterns in the slice by shuffling
+        // some elements around. Hopefully we'll choose a better pivot this time.
+        if !was_balanced {
+            break_patterns(v);
+            limit -= 1;
+        }
+
+        // Choose a pivot and try guessing whether the slice is already sorted.
+        let (pivot, likely_sorted) = choose_pivot(v, is_less);
+
+        // If the last partitioning was decently balanced and didn't shuffle elements, and if pivot
+        // selection predicts the slice is likely already sorted...
+        if was_balanced && was_partitioned && likely_sorted {
+            // Try identifying several out-of-order elements and shifting them to correct
+            // positions. If the slice ends up being completely sorted, we're done.
+            if partial_insertion_sort(v, is_less) {
+                return;
+            }
+        }
+
+        // If the chosen pivot is equal to the predecessor, then it's the smallest element in the
+        // slice. Partition the slice into elements equal to and elements greater than the pivot.
+        // This case is usually hit when the slice contains many duplicate elements.
+        if let Some(ref p) = pred {
+            if !is_less(p, &v[pivot]) {
+                let mid = partition_equal(v, pivot, is_less);
+
+                // Continue sorting elements greater than the pivot.
+                v = &mut v[mid..];
+                continue;
+            }
+        }
+
+        // Partition the slice.
+        let (mid, was_p) = partition(v, pivot, is_less);
+        was_balanced = cmp::min(mid, len - mid) >= len / 8;
+        was_partitioned = was_p;
+
+        // Split the slice into `left`, `pivot`, and `right`.
+        let (left, right) = v.split_at_mut(mid);
+        let (pivot, right) = right.split_at_mut(1);
+        let pivot = &mut pivot[0];
+
+        if cmp::max(left.len(), right.len()) <= MAX_SEQUENTIAL {
+            // Recurse into the shorter side only in order to minimize the total number of recursive
+            // calls and consume less stack space. Then just continue with the longer side (this is
+            // akin to tail recursion).
+            if left.len() < right.len() {
+                recurse(left, is_less, pred, limit);
+                v = right;
+                pred = Some(pivot);
+            } else {
+                recurse(right, is_less, Some(pivot), limit);
+                v = left;
+            }
+        } else {
+            // Sort the left and right half in parallel.
+            rayon_core::join(
+                || recurse(left, is_less, pred, limit),
+                || recurse(right, is_less, Some(pivot), limit),
+            );
+            break;
+        }
+    }
+}
+
+/// Sorts `v` using pattern-defeating quicksort in parallel.
+///
+/// The algorithm is unstable, in-place, and *O*(*n* \* log(*n*)) worst-case.
+pub(super) fn par_quicksort<T, F>(v: &mut [T], is_less: F)
+where
+    T: Send,
+    F: Fn(&T, &T) -> bool + Sync,
+{
+    // Sorting has no meaningful behavior on zero-sized types.
+    if mem::size_of::<T>() == 0 {
+        return;
+    }
+
+    // Limit the number of imbalanced partitions to `floor(log2(len)) + 1`.
+    let limit = usize::BITS - v.len().leading_zeros();
+
+    recurse(v, &is_less, None, limit);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::heapsort;
+    use rand::distributions::Uniform;
+    use rand::{thread_rng, Rng};
+
+    #[test]
+    fn test_heapsort() {
+        let rng = &mut thread_rng();
+
+        for len in (0..25).chain(500..501) {
+            for &modulus in &[5, 10, 100] {
+                let dist = Uniform::new(0, modulus);
+                for _ in 0..100 {
+                    let v: Vec<i32> = rng.sample_iter(&dist).take(len).collect();
+
+                    // Test heapsort using `<` operator.
+                    let mut tmp = v.clone();
+                    heapsort(&mut tmp, &|a, b| a < b);
+                    assert!(tmp.windows(2).all(|w| w[0] <= w[1]));
+
+                    // Test heapsort using `>` operator.
+                    let mut tmp = v.clone();
+                    heapsort(&mut tmp, &|a, b| a > b);
+                    assert!(tmp.windows(2).all(|w| w[0] >= w[1]));
+                }
+            }
+        }
+
+        // Sort using a completely random comparison function.
+        // This will reorder the elements *somehow*, but won't panic.
+        let mut v: Vec<_> = (0..100).collect();
+        heapsort(&mut v, &|_, _| thread_rng().gen());
+        heapsort(&mut v, &|a, b| a < b);
+
+        for (i, &entry) in v.iter().enumerate() {
+            assert_eq!(entry, i);
+        }
+    }
+}
diff --git a/crates/rayon/src/slice/rchunks.rs b/crates/rayon/src/slice/rchunks.rs
new file mode 100644
index 0000000..63e765d
--- /dev/null
+++ b/crates/rayon/src/slice/rchunks.rs
@@ -0,0 +1,386 @@
+use crate::iter::plumbing::*;
+use crate::iter::*;
+use crate::math::div_round_up;
+
+/// Parallel iterator over immutable non-overlapping chunks of a slice, starting at the end.
+#[derive(Debug)]
+pub struct RChunks<'data, T: Sync> {
+    chunk_size: usize,
+    slice: &'data [T],
+}
+
+impl<'data, T: Sync> RChunks<'data, T> {
+    pub(super) fn new(chunk_size: usize, slice: &'data [T]) -> Self {
+        Self { chunk_size, slice }
+    }
+}
+
+impl<'data, T: Sync> Clone for RChunks<'data, T> {
+    fn clone(&self) -> Self {
+        RChunks { ..*self }
+    }
+}
+
+impl<'data, T: Sync + 'data> ParallelIterator for RChunks<'data, T> {
+    type Item = &'data [T];
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        Some(self.len())
+    }
+}
+
+impl<'data, T: Sync + 'data> IndexedParallelIterator for RChunks<'data, T> {
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn len(&self) -> usize {
+        div_round_up(self.slice.len(), self.chunk_size)
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        callback.callback(RChunksProducer {
+            chunk_size: self.chunk_size,
+            slice: self.slice,
+        })
+    }
+}
+
+struct RChunksProducer<'data, T: Sync> {
+    chunk_size: usize,
+    slice: &'data [T],
+}
+
+impl<'data, T: 'data + Sync> Producer for RChunksProducer<'data, T> {
+    type Item = &'data [T];
+    type IntoIter = ::std::slice::RChunks<'data, T>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.slice.rchunks(self.chunk_size)
+    }
+
+    fn split_at(self, index: usize) -> (Self, Self) {
+        let elem_index = self.slice.len().saturating_sub(index * self.chunk_size);
+        let (left, right) = self.slice.split_at(elem_index);
+        (
+            RChunksProducer {
+                chunk_size: self.chunk_size,
+                slice: right,
+            },
+            RChunksProducer {
+                chunk_size: self.chunk_size,
+                slice: left,
+            },
+        )
+    }
+}
+
+/// Parallel iterator over immutable non-overlapping chunks of a slice, starting at the end.
+#[derive(Debug)]
+pub struct RChunksExact<'data, T: Sync> {
+    chunk_size: usize,
+    slice: &'data [T],
+    rem: &'data [T],
+}
+
+impl<'data, T: Sync> RChunksExact<'data, T> {
+    pub(super) fn new(chunk_size: usize, slice: &'data [T]) -> Self {
+        let rem_len = slice.len() % chunk_size;
+        let (rem, slice) = slice.split_at(rem_len);
+        Self {
+            chunk_size,
+            slice,
+            rem,
+        }
+    }
+
+    /// Return the remainder of the original slice that is not going to be
+    /// returned by the iterator. The returned slice has at most `chunk_size-1`
+    /// elements.
+    pub fn remainder(&self) -> &'data [T] {
+        self.rem
+    }
+}
+
+impl<'data, T: Sync> Clone for RChunksExact<'data, T> {
+    fn clone(&self) -> Self {
+        RChunksExact { ..*self }
+    }
+}
+
+impl<'data, T: Sync + 'data> ParallelIterator for RChunksExact<'data, T> {
+    type Item = &'data [T];
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        Some(self.len())
+    }
+}
+
+impl<'data, T: Sync + 'data> IndexedParallelIterator for RChunksExact<'data, T> {
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn len(&self) -> usize {
+        self.slice.len() / self.chunk_size
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        callback.callback(RChunksExactProducer {
+            chunk_size: self.chunk_size,
+            slice: self.slice,
+        })
+    }
+}
+
+struct RChunksExactProducer<'data, T: Sync> {
+    chunk_size: usize,
+    slice: &'data [T],
+}
+
+impl<'data, T: 'data + Sync> Producer for RChunksExactProducer<'data, T> {
+    type Item = &'data [T];
+    type IntoIter = ::std::slice::RChunksExact<'data, T>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.slice.rchunks_exact(self.chunk_size)
+    }
+
+    fn split_at(self, index: usize) -> (Self, Self) {
+        let elem_index = self.slice.len() - index * self.chunk_size;
+        let (left, right) = self.slice.split_at(elem_index);
+        (
+            RChunksExactProducer {
+                chunk_size: self.chunk_size,
+                slice: right,
+            },
+            RChunksExactProducer {
+                chunk_size: self.chunk_size,
+                slice: left,
+            },
+        )
+    }
+}
+
+/// Parallel iterator over mutable non-overlapping chunks of a slice, starting at the end.
+#[derive(Debug)]
+pub struct RChunksMut<'data, T: Send> {
+    chunk_size: usize,
+    slice: &'data mut [T],
+}
+
+impl<'data, T: Send> RChunksMut<'data, T> {
+    pub(super) fn new(chunk_size: usize, slice: &'data mut [T]) -> Self {
+        Self { chunk_size, slice }
+    }
+}
+
+impl<'data, T: Send + 'data> ParallelIterator for RChunksMut<'data, T> {
+    type Item = &'data mut [T];
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        Some(self.len())
+    }
+}
+
+impl<'data, T: Send + 'data> IndexedParallelIterator for RChunksMut<'data, T> {
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn len(&self) -> usize {
+        div_round_up(self.slice.len(), self.chunk_size)
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        callback.callback(RChunksMutProducer {
+            chunk_size: self.chunk_size,
+            slice: self.slice,
+        })
+    }
+}
+
+struct RChunksMutProducer<'data, T: Send> {
+    chunk_size: usize,
+    slice: &'data mut [T],
+}
+
+impl<'data, T: 'data + Send> Producer for RChunksMutProducer<'data, T> {
+    type Item = &'data mut [T];
+    type IntoIter = ::std::slice::RChunksMut<'data, T>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.slice.rchunks_mut(self.chunk_size)
+    }
+
+    fn split_at(self, index: usize) -> (Self, Self) {
+        let elem_index = self.slice.len().saturating_sub(index * self.chunk_size);
+        let (left, right) = self.slice.split_at_mut(elem_index);
+        (
+            RChunksMutProducer {
+                chunk_size: self.chunk_size,
+                slice: right,
+            },
+            RChunksMutProducer {
+                chunk_size: self.chunk_size,
+                slice: left,
+            },
+        )
+    }
+}
+
+/// Parallel iterator over mutable non-overlapping chunks of a slice, starting at the end.
+#[derive(Debug)]
+pub struct RChunksExactMut<'data, T: Send> {
+    chunk_size: usize,
+    slice: &'data mut [T],
+    rem: &'data mut [T],
+}
+
+impl<'data, T: Send> RChunksExactMut<'data, T> {
+    pub(super) fn new(chunk_size: usize, slice: &'data mut [T]) -> Self {
+        let rem_len = slice.len() % chunk_size;
+        let (rem, slice) = slice.split_at_mut(rem_len);
+        Self {
+            chunk_size,
+            slice,
+            rem,
+        }
+    }
+
+    /// Return the remainder of the original slice that is not going to be
+    /// returned by the iterator. The returned slice has at most `chunk_size-1`
+    /// elements.
+    ///
+    /// Note that this has to consume `self` to return the original lifetime of
+    /// the data, which prevents this from actually being used as a parallel
+    /// iterator since that also consumes. This method is provided for parity
+    /// with `std::iter::RChunksExactMut`, but consider calling `remainder()` or
+    /// `take_remainder()` as alternatives.
+    pub fn into_remainder(self) -> &'data mut [T] {
+        self.rem
+    }
+
+    /// Return the remainder of the original slice that is not going to be
+    /// returned by the iterator. The returned slice has at most `chunk_size-1`
+    /// elements.
+    ///
+    /// Consider `take_remainder()` if you need access to the data with its
+    /// original lifetime, rather than borrowing through `&mut self` here.
+    pub fn remainder(&mut self) -> &mut [T] {
+        self.rem
+    }
+
+    /// Return the remainder of the original slice that is not going to be
+    /// returned by the iterator. The returned slice has at most `chunk_size-1`
+    /// elements. Subsequent calls will return an empty slice.
+    pub fn take_remainder(&mut self) -> &'data mut [T] {
+        std::mem::take(&mut self.rem)
+    }
+}
+
+impl<'data, T: Send + 'data> ParallelIterator for RChunksExactMut<'data, T> {
+    type Item = &'data mut [T];
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        Some(self.len())
+    }
+}
+
+impl<'data, T: Send + 'data> IndexedParallelIterator for RChunksExactMut<'data, T> {
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn len(&self) -> usize {
+        self.slice.len() / self.chunk_size
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        callback.callback(RChunksExactMutProducer {
+            chunk_size: self.chunk_size,
+            slice: self.slice,
+        })
+    }
+}
+
+struct RChunksExactMutProducer<'data, T: Send> {
+    chunk_size: usize,
+    slice: &'data mut [T],
+}
+
+impl<'data, T: 'data + Send> Producer for RChunksExactMutProducer<'data, T> {
+    type Item = &'data mut [T];
+    type IntoIter = ::std::slice::RChunksExactMut<'data, T>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.slice.rchunks_exact_mut(self.chunk_size)
+    }
+
+    fn split_at(self, index: usize) -> (Self, Self) {
+        let elem_index = self.slice.len() - index * self.chunk_size;
+        let (left, right) = self.slice.split_at_mut(elem_index);
+        (
+            RChunksExactMutProducer {
+                chunk_size: self.chunk_size,
+                slice: right,
+            },
+            RChunksExactMutProducer {
+                chunk_size: self.chunk_size,
+                slice: left,
+            },
+        )
+    }
+}
diff --git a/crates/rayon/src/slice/test.rs b/crates/rayon/src/slice/test.rs
new file mode 100644
index 0000000..f74ca0f
--- /dev/null
+++ b/crates/rayon/src/slice/test.rs
@@ -0,0 +1,170 @@
+#![cfg(test)]
+
+use crate::prelude::*;
+use rand::distributions::Uniform;
+use rand::seq::SliceRandom;
+use rand::{thread_rng, Rng};
+use std::cmp::Ordering::{Equal, Greater, Less};
+
+macro_rules! sort {
+    ($f:ident, $name:ident) => {
+        #[test]
+        fn $name() {
+            let rng = &mut thread_rng();
+
+            for len in (0..25).chain(500..501) {
+                for &modulus in &[5, 10, 100] {
+                    let dist = Uniform::new(0, modulus);
+                    for _ in 0..100 {
+                        let v: Vec<i32> = rng.sample_iter(&dist).take(len).collect();
+
+                        // Test sort using `<` operator.
+                        let mut tmp = v.clone();
+                        tmp.$f(|a, b| a.cmp(b));
+                        assert!(tmp.windows(2).all(|w| w[0] <= w[1]));
+
+                        // Test sort using `>` operator.
+                        let mut tmp = v.clone();
+                        tmp.$f(|a, b| b.cmp(a));
+                        assert!(tmp.windows(2).all(|w| w[0] >= w[1]));
+                    }
+                }
+            }
+
+            // Test sort with many duplicates.
+            for &len in &[1_000, 10_000, 100_000] {
+                for &modulus in &[5, 10, 100, 10_000] {
+                    let dist = Uniform::new(0, modulus);
+                    let mut v: Vec<i32> = rng.sample_iter(&dist).take(len).collect();
+
+                    v.$f(|a, b| a.cmp(b));
+                    assert!(v.windows(2).all(|w| w[0] <= w[1]));
+                }
+            }
+
+            // Test sort with many pre-sorted runs.
+            for &len in &[1_000, 10_000, 100_000] {
+                let len_dist = Uniform::new(0, len);
+                for &modulus in &[5, 10, 1000, 50_000] {
+                    let dist = Uniform::new(0, modulus);
+                    let mut v: Vec<i32> = rng.sample_iter(&dist).take(len).collect();
+
+                    v.sort();
+                    v.reverse();
+
+                    for _ in 0..5 {
+                        let a = rng.sample(&len_dist);
+                        let b = rng.sample(&len_dist);
+                        if a < b {
+                            v[a..b].reverse();
+                        } else {
+                            v.swap(a, b);
+                        }
+                    }
+
+                    v.$f(|a, b| a.cmp(b));
+                    assert!(v.windows(2).all(|w| w[0] <= w[1]));
+                }
+            }
+
+            // Sort using a completely random comparison function.
+            // This will reorder the elements *somehow*, but won't panic.
+            let mut v: Vec<_> = (0..100).collect();
+            v.$f(|_, _| *[Less, Equal, Greater].choose(&mut thread_rng()).unwrap());
+            v.$f(|a, b| a.cmp(b));
+            for i in 0..v.len() {
+                assert_eq!(v[i], i);
+            }
+
+            // Should not panic.
+            [0i32; 0].$f(|a, b| a.cmp(b));
+            [(); 10].$f(|a, b| a.cmp(b));
+            [(); 100].$f(|a, b| a.cmp(b));
+
+            let mut v = [0xDEAD_BEEFu64];
+            v.$f(|a, b| a.cmp(b));
+            assert!(v == [0xDEAD_BEEF]);
+        }
+    };
+}
+
+sort!(par_sort_by, test_par_sort);
+sort!(par_sort_unstable_by, test_par_sort_unstable);
+
+#[test]
+fn test_par_sort_stability() {
+    for len in (2..25).chain(500..510).chain(50_000..50_010) {
+        for _ in 0..10 {
+            let mut counts = [0; 10];
+
+            // Create a vector like [(6, 1), (5, 1), (6, 2), ...],
+            // where the first item of each tuple is random, but
+            // the second item represents which occurrence of that
+            // number this element is, i.e. the second elements
+            // will occur in sorted order.
+            let mut rng = thread_rng();
+            let mut v: Vec<_> = (0..len)
+                .map(|_| {
+                    let n: usize = rng.gen_range(0..10);
+                    counts[n] += 1;
+                    (n, counts[n])
+                })
+                .collect();
+
+            // Only sort on the first element, so an unstable sort
+            // may mix up the counts.
+            v.par_sort_by(|&(a, _), &(b, _)| a.cmp(&b));
+
+            // This comparison includes the count (the second item
+            // of the tuple), so elements with equal first items
+            // will need to be ordered with increasing
+            // counts... i.e. exactly asserting that this sort is
+            // stable.
+            assert!(v.windows(2).all(|w| w[0] <= w[1]));
+        }
+    }
+}
+
+#[test]
+fn test_par_chunks_exact_remainder() {
+    let v: &[i32] = &[0, 1, 2, 3, 4];
+    let c = v.par_chunks_exact(2);
+    assert_eq!(c.remainder(), &[4]);
+    assert_eq!(c.len(), 2);
+}
+
+#[test]
+fn test_par_chunks_exact_mut_remainder() {
+    let v: &mut [i32] = &mut [0, 1, 2, 3, 4];
+    let mut c = v.par_chunks_exact_mut(2);
+    assert_eq!(c.remainder(), &[4]);
+    assert_eq!(c.len(), 2);
+    assert_eq!(c.into_remainder(), &[4]);
+
+    let mut c = v.par_chunks_exact_mut(2);
+    assert_eq!(c.take_remainder(), &[4]);
+    assert_eq!(c.take_remainder(), &[]);
+    assert_eq!(c.len(), 2);
+}
+
+#[test]
+fn test_par_rchunks_exact_remainder() {
+    let v: &[i32] = &[0, 1, 2, 3, 4];
+    let c = v.par_rchunks_exact(2);
+    assert_eq!(c.remainder(), &[0]);
+    assert_eq!(c.len(), 2);
+}
+
+#[test]
+fn test_par_rchunks_exact_mut_remainder() {
+    let v: &mut [i32] = &mut [0, 1, 2, 3, 4];
+    let mut c = v.par_rchunks_exact_mut(2);
+    assert_eq!(c.remainder(), &[0]);
+    assert_eq!(c.len(), 2);
+    assert_eq!(c.into_remainder(), &[0]);
+
+    let mut c = v.par_rchunks_exact_mut(2);
+    assert_eq!(c.take_remainder(), &[0]);
+    assert_eq!(c.take_remainder(), &[]);
+    assert_eq!(c.len(), 2);
+}
diff --git a/crates/rayon/src/split_producer.rs b/crates/rayon/src/split_producer.rs
new file mode 100644
index 0000000..568657a
--- /dev/null
+++ b/crates/rayon/src/split_producer.rs
@@ -0,0 +1,132 @@
+//! Common splitter for strings and slices
+//!
+//! This module is private, so these items are effectively `pub(super)`
+
+use crate::iter::plumbing::{Folder, UnindexedProducer};
+
+/// Common producer for splitting on a predicate.
+pub(super) struct SplitProducer<'p, P, V> {
+    data: V,
+    separator: &'p P,
+
+    /// Marks the endpoint beyond which we've already found no separators.
+    tail: usize,
+}
+
+/// Helper trait so `&str`, `&[T]`, and `&mut [T]` can share `SplitProducer`.
+pub(super) trait Fissile<P>: Sized {
+    fn length(&self) -> usize;
+    fn midpoint(&self, end: usize) -> usize;
+    fn find(&self, separator: &P, start: usize, end: usize) -> Option<usize>;
+    fn rfind(&self, separator: &P, end: usize) -> Option<usize>;
+    fn split_once(self, index: usize) -> (Self, Self);
+    fn fold_splits<F>(self, separator: &P, folder: F, skip_last: bool) -> F
+    where
+        F: Folder<Self>,
+        Self: Send;
+}
+
+impl<'p, P, V> SplitProducer<'p, P, V>
+where
+    V: Fissile<P> + Send,
+{
+    pub(super) fn new(data: V, separator: &'p P) -> Self {
+        SplitProducer {
+            tail: data.length(),
+            data,
+            separator,
+        }
+    }
+
+    /// Common `fold_with` implementation, integrating `SplitTerminator`'s
+    /// need to sometimes skip its final empty item.
+    pub(super) fn fold_with<F>(self, folder: F, skip_last: bool) -> F
+    where
+        F: Folder<V>,
+    {
+        let SplitProducer {
+            data,
+            separator,
+            tail,
+        } = self;
+
+        if tail == data.length() {
+            // No tail section, so just let `fold_splits` handle it.
+            data.fold_splits(separator, folder, skip_last)
+        } else if let Some(index) = data.rfind(separator, tail) {
+            // We found the last separator to complete the tail, so
+            // end with that slice after `fold_splits` finds the rest.
+            let (left, right) = data.split_once(index);
+            let folder = left.fold_splits(separator, folder, false);
+            if skip_last || folder.full() {
+                folder
+            } else {
+                folder.consume(right)
+            }
+        } else {
+            // We know there are no separators at all.  Return our whole data.
+            if skip_last {
+                folder
+            } else {
+                folder.consume(data)
+            }
+        }
+    }
+}
+
+impl<'p, P, V> UnindexedProducer for SplitProducer<'p, P, V>
+where
+    V: Fissile<P> + Send,
+    P: Sync,
+{
+    type Item = V;
+
+    fn split(self) -> (Self, Option<Self>) {
+        // Look forward for the separator, and failing that look backward.
+        let mid = self.data.midpoint(self.tail);
+        let index = match self.data.find(self.separator, mid, self.tail) {
+            Some(i) => Some(mid + i),
+            None => self.data.rfind(self.separator, mid),
+        };
+
+        if let Some(index) = index {
+            let len = self.data.length();
+            let (left, right) = self.data.split_once(index);
+
+            let (left_tail, right_tail) = if index < mid {
+                // If we scanned backwards to find the separator, everything in
+                // the right side is exhausted, with no separators left to find.
+                (index, 0)
+            } else {
+                let right_index = len - right.length();
+                (mid, self.tail - right_index)
+            };
+
+            // Create the left split before the separator.
+            let left = SplitProducer {
+                data: left,
+                tail: left_tail,
+                ..self
+            };
+
+            // Create the right split following the separator.
+            let right = SplitProducer {
+                data: right,
+                tail: right_tail,
+                ..self
+            };
+
+            (left, Some(right))
+        } else {
+            // The search is exhausted, no more separators...
+            (SplitProducer { tail: 0, ..self }, None)
+        }
+    }
+
+    fn fold_with<F>(self, folder: F) -> F
+    where
+        F: Folder<Self::Item>,
+    {
+        self.fold_with(folder, false)
+    }
+}
diff --git a/crates/rayon/src/str.rs b/crates/rayon/src/str.rs
new file mode 100644
index 0000000..c85754e
--- /dev/null
+++ b/crates/rayon/src/str.rs
@@ -0,0 +1,848 @@
+//! Parallel iterator types for [strings][std::str]
+//!
+//! You will rarely need to interact with this module directly unless you need
+//! to name one of the iterator types.
+//!
+//! Note: [`ParallelString::par_split()`] and [`par_split_terminator()`]
+//! reference a `Pattern` trait which is not visible outside this crate.
+//! This trait is intentionally kept private, for use only by Rayon itself.
+//! It is implemented for `char`, `&[char]`, and any function or closure
+//! `F: Fn(char) -> bool + Sync + Send`.
+//!
+//! [`ParallelString::par_split()`]: trait.ParallelString.html#method.par_split
+//! [`par_split_terminator()`]: trait.ParallelString.html#method.par_split_terminator
+//!
+//! [std::str]: https://doc.rust-lang.org/stable/std/str/
+
+use crate::iter::plumbing::*;
+use crate::iter::*;
+use crate::split_producer::*;
+
+/// Test if a byte is the start of a UTF-8 character.
+/// (extracted from `str::is_char_boundary`)
+#[inline]
+fn is_char_boundary(b: u8) -> bool {
+    // This is bit magic equivalent to: b < 128 || b >= 192
+    (b as i8) >= -0x40
+}
+
+/// Find the index of a character boundary near the midpoint.
+#[inline]
+fn find_char_midpoint(chars: &str) -> usize {
+    let mid = chars.len() / 2;
+
+    // We want to split near the midpoint, but we need to find an actual
+    // character boundary.  So we look at the raw bytes, first scanning
+    // forward from the midpoint for a boundary, then trying backward.
+    let (left, right) = chars.as_bytes().split_at(mid);
+    match right.iter().copied().position(is_char_boundary) {
+        Some(i) => mid + i,
+        None => left
+            .iter()
+            .copied()
+            .rposition(is_char_boundary)
+            .unwrap_or(0),
+    }
+}
+
+/// Try to split a string near the midpoint.
+#[inline]
+fn split(chars: &str) -> Option<(&str, &str)> {
+    let index = find_char_midpoint(chars);
+    if index > 0 {
+        Some(chars.split_at(index))
+    } else {
+        None
+    }
+}
+
+/// Parallel extensions for strings.
+pub trait ParallelString {
+    /// Returns a plain string slice, which is used to implement the rest of
+    /// the parallel methods.
+    fn as_parallel_string(&self) -> &str;
+
+    /// Returns a parallel iterator over the characters of a string.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    /// let max = "hello".par_chars().max_by_key(|c| *c as i32);
+    /// assert_eq!(Some('o'), max);
+    /// ```
+    fn par_chars(&self) -> Chars<'_> {
+        Chars {
+            chars: self.as_parallel_string(),
+        }
+    }
+
+    /// Returns a parallel iterator over the characters of a string, with their positions.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    /// let min = "hello".par_char_indices().min_by_key(|&(_i, c)| c as i32);
+    /// assert_eq!(Some((1, 'e')), min);
+    /// ```
+    fn par_char_indices(&self) -> CharIndices<'_> {
+        CharIndices {
+            chars: self.as_parallel_string(),
+        }
+    }
+
+    /// Returns a parallel iterator over the bytes of a string.
+    ///
+    /// Note that multi-byte sequences (for code points greater than `U+007F`)
+    /// are produced as separate items, but will not be split across threads.
+    /// If you would prefer an indexed iterator without that guarantee, consider
+    /// `string.as_bytes().par_iter().copied()` instead.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    /// let max = "hello".par_bytes().max();
+    /// assert_eq!(Some(b'o'), max);
+    /// ```
+    fn par_bytes(&self) -> Bytes<'_> {
+        Bytes {
+            chars: self.as_parallel_string(),
+        }
+    }
+
+    /// Returns a parallel iterator over a string encoded as UTF-16.
+    ///
+    /// Note that surrogate pairs (for code points greater than `U+FFFF`) are
+    /// produced as separate items, but will not be split across threads.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    ///
+    /// let max = "hello".par_encode_utf16().max();
+    /// assert_eq!(Some(b'o' as u16), max);
+    ///
+    /// let text = "Zażółć gęślą jaźń";
+    /// let utf8_len = text.len();
+    /// let utf16_len = text.par_encode_utf16().count();
+    /// assert!(utf16_len <= utf8_len);
+    /// ```
+    fn par_encode_utf16(&self) -> EncodeUtf16<'_> {
+        EncodeUtf16 {
+            chars: self.as_parallel_string(),
+        }
+    }
+
+    /// Returns a parallel iterator over substrings separated by a
+    /// given character or predicate, similar to `str::split`.
+    ///
+    /// Note: the `Pattern` trait is private, for use only by Rayon itself.
+    /// It is implemented for `char`, `&[char]`, and any function or closure
+    /// `F: Fn(char) -> bool + Sync + Send`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    /// let total = "1, 2, buckle, 3, 4, door"
+    ///    .par_split(',')
+    ///    .filter_map(|s| s.trim().parse::<i32>().ok())
+    ///    .sum();
+    /// assert_eq!(10, total);
+    /// ```
+    fn par_split<P: Pattern>(&self, separator: P) -> Split<'_, P> {
+        Split::new(self.as_parallel_string(), separator)
+    }
+
+    /// Returns a parallel iterator over substrings terminated by a
+    /// given character or predicate, similar to `str::split_terminator`.
+    /// It's equivalent to `par_split`, except it doesn't produce an empty
+    /// substring after a trailing terminator.
+    ///
+    /// Note: the `Pattern` trait is private, for use only by Rayon itself.
+    /// It is implemented for `char`, `&[char]`, and any function or closure
+    /// `F: Fn(char) -> bool + Sync + Send`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    /// let parts: Vec<_> = "((1 + 3) * 2)"
+    ///     .par_split_terminator(|c| c == '(' || c == ')')
+    ///     .collect();
+    /// assert_eq!(vec!["", "", "1 + 3", " * 2"], parts);
+    /// ```
+    fn par_split_terminator<P: Pattern>(&self, terminator: P) -> SplitTerminator<'_, P> {
+        SplitTerminator::new(self.as_parallel_string(), terminator)
+    }
+
+    /// Returns a parallel iterator over the lines of a string, ending with an
+    /// optional carriage return and with a newline (`\r\n` or just `\n`).
+    /// The final line ending is optional, and line endings are not included in
+    /// the output strings.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    /// let lengths: Vec<_> = "hello world\nfizbuzz"
+    ///     .par_lines()
+    ///     .map(|l| l.len())
+    ///     .collect();
+    /// assert_eq!(vec![11, 7], lengths);
+    /// ```
+    fn par_lines(&self) -> Lines<'_> {
+        Lines(self.as_parallel_string())
+    }
+
+    /// Returns a parallel iterator over the sub-slices of a string that are
+    /// separated by any amount of whitespace.
+    ///
+    /// As with `str::split_whitespace`, 'whitespace' is defined according to
+    /// the terms of the Unicode Derived Core Property `White_Space`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    /// let longest = "which is the longest word?"
+    ///     .par_split_whitespace()
+    ///     .max_by_key(|word| word.len());
+    /// assert_eq!(Some("longest"), longest);
+    /// ```
+    fn par_split_whitespace(&self) -> SplitWhitespace<'_> {
+        SplitWhitespace(self.as_parallel_string())
+    }
+
+    /// Returns a parallel iterator over substrings that match a
+    /// given character or predicate, similar to `str::matches`.
+    ///
+    /// Note: the `Pattern` trait is private, for use only by Rayon itself.
+    /// It is implemented for `char`, `&[char]`, and any function or closure
+    /// `F: Fn(char) -> bool + Sync + Send`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    /// let total = "1, 2, buckle, 3, 4, door"
+    ///    .par_matches(char::is_numeric)
+    ///    .map(|s| s.parse::<i32>().expect("digit"))
+    ///    .sum();
+    /// assert_eq!(10, total);
+    /// ```
+    fn par_matches<P: Pattern>(&self, pattern: P) -> Matches<'_, P> {
+        Matches {
+            chars: self.as_parallel_string(),
+            pattern,
+        }
+    }
+
+    /// Returns a parallel iterator over substrings that match a given character
+    /// or predicate, with their positions, similar to `str::match_indices`.
+    ///
+    /// Note: the `Pattern` trait is private, for use only by Rayon itself.
+    /// It is implemented for `char`, `&[char]`, and any function or closure
+    /// `F: Fn(char) -> bool + Sync + Send`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rayon::prelude::*;
+    /// let digits: Vec<_> = "1, 2, buckle, 3, 4, door"
+    ///    .par_match_indices(char::is_numeric)
+    ///    .collect();
+    /// assert_eq!(digits, vec![(0, "1"), (3, "2"), (14, "3"), (17, "4")]);
+    /// ```
+    fn par_match_indices<P: Pattern>(&self, pattern: P) -> MatchIndices<'_, P> {
+        MatchIndices {
+            chars: self.as_parallel_string(),
+            pattern,
+        }
+    }
+}
+
+impl ParallelString for str {
+    #[inline]
+    fn as_parallel_string(&self) -> &str {
+        self
+    }
+}
+
+// /////////////////////////////////////////////////////////////////////////
+
+/// We hide the `Pattern` trait in a private module, as its API is not meant
+/// for general consumption.  If we could have privacy on trait items, then it
+/// would be nicer to have its basic existence and implementors public while
+/// keeping all of the methods private.
+mod private {
+    use crate::iter::plumbing::Folder;
+
+    /// Pattern-matching trait for `ParallelString`, somewhat like a mix of
+    /// `std::str::pattern::{Pattern, Searcher}`.
+    ///
+    /// Implementing this trait is not permitted outside of `rayon`.
+    pub trait Pattern: Sized + Sync + Send {
+        private_decl! {}
+        fn find_in(&self, haystack: &str) -> Option<usize>;
+        fn rfind_in(&self, haystack: &str) -> Option<usize>;
+        fn is_suffix_of(&self, haystack: &str) -> bool;
+        fn fold_splits<'ch, F>(&self, haystack: &'ch str, folder: F, skip_last: bool) -> F
+        where
+            F: Folder<&'ch str>;
+        fn fold_matches<'ch, F>(&self, haystack: &'ch str, folder: F) -> F
+        where
+            F: Folder<&'ch str>;
+        fn fold_match_indices<'ch, F>(&self, haystack: &'ch str, folder: F, base: usize) -> F
+        where
+            F: Folder<(usize, &'ch str)>;
+    }
+}
+use self::private::Pattern;
+
+#[inline]
+fn offset<T>(base: usize) -> impl Fn((usize, T)) -> (usize, T) {
+    move |(i, x)| (base + i, x)
+}
+
+macro_rules! impl_pattern {
+    (&$self:ident => $pattern:expr) => {
+        private_impl! {}
+
+        #[inline]
+        fn find_in(&$self, chars: &str) -> Option<usize> {
+            chars.find($pattern)
+        }
+
+        #[inline]
+        fn rfind_in(&$self, chars: &str) -> Option<usize> {
+            chars.rfind($pattern)
+        }
+
+        #[inline]
+        fn is_suffix_of(&$self, chars: &str) -> bool {
+            chars.ends_with($pattern)
+        }
+
+        fn fold_splits<'ch, F>(&$self, chars: &'ch str, folder: F, skip_last: bool) -> F
+        where
+            F: Folder<&'ch str>,
+        {
+            let mut split = chars.split($pattern);
+            if skip_last {
+                split.next_back();
+            }
+            folder.consume_iter(split)
+        }
+
+        fn fold_matches<'ch, F>(&$self, chars: &'ch str, folder: F) -> F
+        where
+            F: Folder<&'ch str>,
+        {
+            folder.consume_iter(chars.matches($pattern))
+        }
+
+        fn fold_match_indices<'ch, F>(&$self, chars: &'ch str, folder: F, base: usize) -> F
+        where
+            F: Folder<(usize, &'ch str)>,
+        {
+            folder.consume_iter(chars.match_indices($pattern).map(offset(base)))
+        }
+    }
+}
+
+impl Pattern for char {
+    impl_pattern!(&self => *self);
+}
+
+impl Pattern for &[char] {
+    impl_pattern!(&self => *self);
+}
+
+impl<FN: Sync + Send + Fn(char) -> bool> Pattern for FN {
+    impl_pattern!(&self => self);
+}
+
+// /////////////////////////////////////////////////////////////////////////
+
+/// Parallel iterator over the characters of a string
+#[derive(Debug, Clone)]
+pub struct Chars<'ch> {
+    chars: &'ch str,
+}
+
+struct CharsProducer<'ch> {
+    chars: &'ch str,
+}
+
+impl<'ch> ParallelIterator for Chars<'ch> {
+    type Item = char;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        bridge_unindexed(CharsProducer { chars: self.chars }, consumer)
+    }
+}
+
+impl<'ch> UnindexedProducer for CharsProducer<'ch> {
+    type Item = char;
+
+    fn split(self) -> (Self, Option<Self>) {
+        match split(self.chars) {
+            Some((left, right)) => (
+                CharsProducer { chars: left },
+                Some(CharsProducer { chars: right }),
+            ),
+            None => (self, None),
+        }
+    }
+
+    fn fold_with<F>(self, folder: F) -> F
+    where
+        F: Folder<Self::Item>,
+    {
+        folder.consume_iter(self.chars.chars())
+    }
+}
+
+// /////////////////////////////////////////////////////////////////////////
+
+/// Parallel iterator over the characters of a string, with their positions
+#[derive(Debug, Clone)]
+pub struct CharIndices<'ch> {
+    chars: &'ch str,
+}
+
+struct CharIndicesProducer<'ch> {
+    index: usize,
+    chars: &'ch str,
+}
+
+impl<'ch> ParallelIterator for CharIndices<'ch> {
+    type Item = (usize, char);
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        let producer = CharIndicesProducer {
+            index: 0,
+            chars: self.chars,
+        };
+        bridge_unindexed(producer, consumer)
+    }
+}
+
+impl<'ch> UnindexedProducer for CharIndicesProducer<'ch> {
+    type Item = (usize, char);
+
+    fn split(self) -> (Self, Option<Self>) {
+        match split(self.chars) {
+            Some((left, right)) => (
+                CharIndicesProducer {
+                    chars: left,
+                    ..self
+                },
+                Some(CharIndicesProducer {
+                    chars: right,
+                    index: self.index + left.len(),
+                }),
+            ),
+            None => (self, None),
+        }
+    }
+
+    fn fold_with<F>(self, folder: F) -> F
+    where
+        F: Folder<Self::Item>,
+    {
+        let base = self.index;
+        folder.consume_iter(self.chars.char_indices().map(offset(base)))
+    }
+}
+
+// /////////////////////////////////////////////////////////////////////////
+
+/// Parallel iterator over the bytes of a string
+#[derive(Debug, Clone)]
+pub struct Bytes<'ch> {
+    chars: &'ch str,
+}
+
+struct BytesProducer<'ch> {
+    chars: &'ch str,
+}
+
+impl<'ch> ParallelIterator for Bytes<'ch> {
+    type Item = u8;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        bridge_unindexed(BytesProducer { chars: self.chars }, consumer)
+    }
+}
+
+impl<'ch> UnindexedProducer for BytesProducer<'ch> {
+    type Item = u8;
+
+    fn split(self) -> (Self, Option<Self>) {
+        match split(self.chars) {
+            Some((left, right)) => (
+                BytesProducer { chars: left },
+                Some(BytesProducer { chars: right }),
+            ),
+            None => (self, None),
+        }
+    }
+
+    fn fold_with<F>(self, folder: F) -> F
+    where
+        F: Folder<Self::Item>,
+    {
+        folder.consume_iter(self.chars.bytes())
+    }
+}
+
+// /////////////////////////////////////////////////////////////////////////
+
+/// Parallel iterator over a string encoded as UTF-16
+#[derive(Debug, Clone)]
+pub struct EncodeUtf16<'ch> {
+    chars: &'ch str,
+}
+
+struct EncodeUtf16Producer<'ch> {
+    chars: &'ch str,
+}
+
+impl<'ch> ParallelIterator for EncodeUtf16<'ch> {
+    type Item = u16;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        bridge_unindexed(EncodeUtf16Producer { chars: self.chars }, consumer)
+    }
+}
+
+impl<'ch> UnindexedProducer for EncodeUtf16Producer<'ch> {
+    type Item = u16;
+
+    fn split(self) -> (Self, Option<Self>) {
+        match split(self.chars) {
+            Some((left, right)) => (
+                EncodeUtf16Producer { chars: left },
+                Some(EncodeUtf16Producer { chars: right }),
+            ),
+            None => (self, None),
+        }
+    }
+
+    fn fold_with<F>(self, folder: F) -> F
+    where
+        F: Folder<Self::Item>,
+    {
+        folder.consume_iter(self.chars.encode_utf16())
+    }
+}
+
+// /////////////////////////////////////////////////////////////////////////
+
+/// Parallel iterator over substrings separated by a pattern
+#[derive(Debug, Clone)]
+pub struct Split<'ch, P: Pattern> {
+    chars: &'ch str,
+    separator: P,
+}
+
+impl<'ch, P: Pattern> Split<'ch, P> {
+    fn new(chars: &'ch str, separator: P) -> Self {
+        Split { chars, separator }
+    }
+}
+
+impl<'ch, P: Pattern> ParallelIterator for Split<'ch, P> {
+    type Item = &'ch str;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        let producer = SplitProducer::new(self.chars, &self.separator);
+        bridge_unindexed(producer, consumer)
+    }
+}
+
+/// Implement support for `SplitProducer`.
+impl<'ch, P: Pattern> Fissile<P> for &'ch str {
+    fn length(&self) -> usize {
+        self.len()
+    }
+
+    fn midpoint(&self, end: usize) -> usize {
+        // First find a suitable UTF-8 boundary.
+        find_char_midpoint(&self[..end])
+    }
+
+    fn find(&self, separator: &P, start: usize, end: usize) -> Option<usize> {
+        separator.find_in(&self[start..end])
+    }
+
+    fn rfind(&self, separator: &P, end: usize) -> Option<usize> {
+        separator.rfind_in(&self[..end])
+    }
+
+    fn split_once(self, index: usize) -> (Self, Self) {
+        let (left, right) = self.split_at(index);
+        let mut right_iter = right.chars();
+        right_iter.next(); // skip the separator
+        (left, right_iter.as_str())
+    }
+
+    fn fold_splits<F>(self, separator: &P, folder: F, skip_last: bool) -> F
+    where
+        F: Folder<Self>,
+    {
+        separator.fold_splits(self, folder, skip_last)
+    }
+}
+
+// /////////////////////////////////////////////////////////////////////////
+
+/// Parallel iterator over substrings separated by a terminator pattern
+#[derive(Debug, Clone)]
+pub struct SplitTerminator<'ch, P: Pattern> {
+    chars: &'ch str,
+    terminator: P,
+}
+
+struct SplitTerminatorProducer<'ch, 'sep, P: Pattern> {
+    splitter: SplitProducer<'sep, P, &'ch str>,
+    skip_last: bool,
+}
+
+impl<'ch, P: Pattern> SplitTerminator<'ch, P> {
+    fn new(chars: &'ch str, terminator: P) -> Self {
+        SplitTerminator { chars, terminator }
+    }
+}
+
+impl<'ch, 'sep, P: Pattern + 'sep> SplitTerminatorProducer<'ch, 'sep, P> {
+    fn new(chars: &'ch str, terminator: &'sep P) -> Self {
+        SplitTerminatorProducer {
+            splitter: SplitProducer::new(chars, terminator),
+            skip_last: chars.is_empty() || terminator.is_suffix_of(chars),
+        }
+    }
+}
+
+impl<'ch, P: Pattern> ParallelIterator for SplitTerminator<'ch, P> {
+    type Item = &'ch str;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        let producer = SplitTerminatorProducer::new(self.chars, &self.terminator);
+        bridge_unindexed(producer, consumer)
+    }
+}
+
+impl<'ch, 'sep, P: Pattern + 'sep> UnindexedProducer for SplitTerminatorProducer<'ch, 'sep, P> {
+    type Item = &'ch str;
+
+    fn split(mut self) -> (Self, Option<Self>) {
+        let (left, right) = self.splitter.split();
+        self.splitter = left;
+        let right = right.map(|right| {
+            let skip_last = self.skip_last;
+            self.skip_last = false;
+            SplitTerminatorProducer {
+                splitter: right,
+                skip_last,
+            }
+        });
+        (self, right)
+    }
+
+    fn fold_with<F>(self, folder: F) -> F
+    where
+        F: Folder<Self::Item>,
+    {
+        self.splitter.fold_with(folder, self.skip_last)
+    }
+}
+
+// /////////////////////////////////////////////////////////////////////////
+
+/// Parallel iterator over lines in a string
+#[derive(Debug, Clone)]
+pub struct Lines<'ch>(&'ch str);
+
+#[inline]
+fn no_carriage_return(line: &str) -> &str {
+    line.strip_suffix('\r').unwrap_or(line)
+}
+
+impl<'ch> ParallelIterator for Lines<'ch> {
+    type Item = &'ch str;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        self.0
+            .par_split_terminator('\n')
+            .map(no_carriage_return)
+            .drive_unindexed(consumer)
+    }
+}
+
+// /////////////////////////////////////////////////////////////////////////
+
+/// Parallel iterator over substrings separated by whitespace
+#[derive(Debug, Clone)]
+pub struct SplitWhitespace<'ch>(&'ch str);
+
+#[inline]
+fn not_empty(s: &&str) -> bool {
+    !s.is_empty()
+}
+
+impl<'ch> ParallelIterator for SplitWhitespace<'ch> {
+    type Item = &'ch str;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        self.0
+            .par_split(char::is_whitespace)
+            .filter(not_empty)
+            .drive_unindexed(consumer)
+    }
+}
+
+// /////////////////////////////////////////////////////////////////////////
+
+/// Parallel iterator over substrings that match a pattern
+#[derive(Debug, Clone)]
+pub struct Matches<'ch, P: Pattern> {
+    chars: &'ch str,
+    pattern: P,
+}
+
+struct MatchesProducer<'ch, 'pat, P: Pattern> {
+    chars: &'ch str,
+    pattern: &'pat P,
+}
+
+impl<'ch, P: Pattern> ParallelIterator for Matches<'ch, P> {
+    type Item = &'ch str;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        let producer = MatchesProducer {
+            chars: self.chars,
+            pattern: &self.pattern,
+        };
+        bridge_unindexed(producer, consumer)
+    }
+}
+
+impl<'ch, 'pat, P: Pattern> UnindexedProducer for MatchesProducer<'ch, 'pat, P> {
+    type Item = &'ch str;
+
+    fn split(self) -> (Self, Option<Self>) {
+        match split(self.chars) {
+            Some((left, right)) => (
+                MatchesProducer {
+                    chars: left,
+                    ..self
+                },
+                Some(MatchesProducer {
+                    chars: right,
+                    ..self
+                }),
+            ),
+            None => (self, None),
+        }
+    }
+
+    fn fold_with<F>(self, folder: F) -> F
+    where
+        F: Folder<Self::Item>,
+    {
+        self.pattern.fold_matches(self.chars, folder)
+    }
+}
+
+// /////////////////////////////////////////////////////////////////////////
+
+/// Parallel iterator over substrings that match a pattern, with their positions
+#[derive(Debug, Clone)]
+pub struct MatchIndices<'ch, P: Pattern> {
+    chars: &'ch str,
+    pattern: P,
+}
+
+struct MatchIndicesProducer<'ch, 'pat, P: Pattern> {
+    index: usize,
+    chars: &'ch str,
+    pattern: &'pat P,
+}
+
+impl<'ch, P: Pattern> ParallelIterator for MatchIndices<'ch, P> {
+    type Item = (usize, &'ch str);
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        let producer = MatchIndicesProducer {
+            index: 0,
+            chars: self.chars,
+            pattern: &self.pattern,
+        };
+        bridge_unindexed(producer, consumer)
+    }
+}
+
+impl<'ch, 'pat, P: Pattern> UnindexedProducer for MatchIndicesProducer<'ch, 'pat, P> {
+    type Item = (usize, &'ch str);
+
+    fn split(self) -> (Self, Option<Self>) {
+        match split(self.chars) {
+            Some((left, right)) => (
+                MatchIndicesProducer {
+                    chars: left,
+                    ..self
+                },
+                Some(MatchIndicesProducer {
+                    chars: right,
+                    index: self.index + left.len(),
+                    ..self
+                }),
+            ),
+            None => (self, None),
+        }
+    }
+
+    fn fold_with<F>(self, folder: F) -> F
+    where
+        F: Folder<Self::Item>,
+    {
+        self.pattern
+            .fold_match_indices(self.chars, folder, self.index)
+    }
+}
diff --git a/crates/rayon/src/string.rs b/crates/rayon/src/string.rs
new file mode 100644
index 0000000..91e69f9
--- /dev/null
+++ b/crates/rayon/src/string.rs
@@ -0,0 +1,48 @@
+//! This module contains the parallel iterator types for owned strings
+//! (`String`). You will rarely need to interact with it directly
+//! unless you have need to name one of the iterator types.
+
+use crate::iter::plumbing::*;
+use crate::math::simplify_range;
+use crate::prelude::*;
+use std::ops::{Range, RangeBounds};
+
+impl<'a> ParallelDrainRange<usize> for &'a mut String {
+    type Iter = Drain<'a>;
+    type Item = char;
+
+    fn par_drain<R: RangeBounds<usize>>(self, range: R) -> Self::Iter {
+        Drain {
+            range: simplify_range(range, self.len()),
+            string: self,
+        }
+    }
+}
+
+/// Draining parallel iterator that moves a range of characters out of a string,
+/// but keeps the total capacity.
+#[derive(Debug)]
+pub struct Drain<'a> {
+    string: &'a mut String,
+    range: Range<usize>,
+}
+
+impl<'a> ParallelIterator for Drain<'a> {
+    type Item = char;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        self.string[self.range.clone()]
+            .par_chars()
+            .drive_unindexed(consumer)
+    }
+}
+
+impl<'a> Drop for Drain<'a> {
+    fn drop(&mut self) {
+        // Remove the drained range.
+        self.string.drain(self.range.clone());
+    }
+}
diff --git a/crates/rayon/src/vec.rs b/crates/rayon/src/vec.rs
new file mode 100644
index 0000000..7892f53
--- /dev/null
+++ b/crates/rayon/src/vec.rs
@@ -0,0 +1,283 @@
+//! Parallel iterator types for [vectors][std::vec] (`Vec<T>`)
+//!
+//! You will rarely need to interact with this module directly unless you need
+//! to name one of the iterator types.
+//!
+//! [std::vec]: https://doc.rust-lang.org/stable/std/vec/
+
+use crate::iter::plumbing::*;
+use crate::iter::*;
+use crate::math::simplify_range;
+use crate::slice::{Iter, IterMut};
+use std::iter;
+use std::mem;
+use std::ops::{Range, RangeBounds};
+use std::ptr;
+use std::slice;
+
+impl<'data, T: Sync + 'data> IntoParallelIterator for &'data Vec<T> {
+    type Item = &'data T;
+    type Iter = Iter<'data, T>;
+
+    fn into_par_iter(self) -> Self::Iter {
+        <&[T]>::into_par_iter(self)
+    }
+}
+
+impl<'data, T: Send + 'data> IntoParallelIterator for &'data mut Vec<T> {
+    type Item = &'data mut T;
+    type Iter = IterMut<'data, T>;
+
+    fn into_par_iter(self) -> Self::Iter {
+        <&mut [T]>::into_par_iter(self)
+    }
+}
+
+/// Parallel iterator that moves out of a vector.
+#[derive(Debug, Clone)]
+pub struct IntoIter<T: Send> {
+    vec: Vec<T>,
+}
+
+impl<T: Send> IntoParallelIterator for Vec<T> {
+    type Item = T;
+    type Iter = IntoIter<T>;
+
+    fn into_par_iter(self) -> Self::Iter {
+        IntoIter { vec: self }
+    }
+}
+
+impl<T: Send> ParallelIterator for IntoIter<T> {
+    type Item = T;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        Some(self.len())
+    }
+}
+
+impl<T: Send> IndexedParallelIterator for IntoIter<T> {
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn len(&self) -> usize {
+        self.vec.len()
+    }
+
+    fn with_producer<CB>(mut self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        // Drain every item, and then the vector only needs to free its buffer.
+        self.vec.par_drain(..).with_producer(callback)
+    }
+}
+
+impl<'data, T: Send> ParallelDrainRange<usize> for &'data mut Vec<T> {
+    type Iter = Drain<'data, T>;
+    type Item = T;
+
+    fn par_drain<R: RangeBounds<usize>>(self, range: R) -> Self::Iter {
+        Drain {
+            orig_len: self.len(),
+            range: simplify_range(range, self.len()),
+            vec: self,
+        }
+    }
+}
+
+/// Draining parallel iterator that moves a range out of a vector, but keeps the total capacity.
+#[derive(Debug)]
+pub struct Drain<'data, T: Send> {
+    vec: &'data mut Vec<T>,
+    range: Range<usize>,
+    orig_len: usize,
+}
+
+impl<'data, T: Send> ParallelIterator for Drain<'data, T> {
+    type Item = T;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn opt_len(&self) -> Option<usize> {
+        Some(self.len())
+    }
+}
+
+impl<'data, T: Send> IndexedParallelIterator for Drain<'data, T> {
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn len(&self) -> usize {
+        self.range.len()
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        unsafe {
+            // Make the vector forget about the drained items, and temporarily the tail too.
+            self.vec.set_len(self.range.start);
+
+            // Create the producer as the exclusive "owner" of the slice.
+            let producer = DrainProducer::from_vec(self.vec, self.range.len());
+
+            // The producer will move or drop each item from the drained range.
+            callback.callback(producer)
+        }
+    }
+}
+
+impl<'data, T: Send> Drop for Drain<'data, T> {
+    fn drop(&mut self) {
+        let Range { start, end } = self.range;
+        if self.vec.len() == self.orig_len {
+            // We must not have produced, so just call a normal drain to remove the items.
+            self.vec.drain(start..end);
+        } else if start == end {
+            // Empty range, so just restore the length to its original state
+            unsafe {
+                self.vec.set_len(self.orig_len);
+            }
+        } else if end < self.orig_len {
+            // The producer was responsible for consuming the drained items.
+            // Move the tail items to their new place, then set the length to include them.
+            unsafe {
+                let ptr = self.vec.as_mut_ptr().add(start);
+                let tail_ptr = self.vec.as_ptr().add(end);
+                let tail_len = self.orig_len - end;
+                ptr::copy(tail_ptr, ptr, tail_len);
+                self.vec.set_len(start + tail_len);
+            }
+        }
+    }
+}
+
+/// ////////////////////////////////////////////////////////////////////////
+
+pub(crate) struct DrainProducer<'data, T: Send> {
+    slice: &'data mut [T],
+}
+
+impl<T: Send> DrainProducer<'_, T> {
+    /// Creates a draining producer, which *moves* items from the slice.
+    ///
+    /// Unsafe because `!Copy` data must not be read after the borrow is released.
+    pub(crate) unsafe fn new(slice: &mut [T]) -> DrainProducer<'_, T> {
+        DrainProducer { slice }
+    }
+
+    /// Creates a draining producer, which *moves* items from the tail of the vector.
+    ///
+    /// Unsafe because we're moving from beyond `vec.len()`, so the caller must ensure
+    /// that data is initialized and not read after the borrow is released.
+    unsafe fn from_vec(vec: &mut Vec<T>, len: usize) -> DrainProducer<'_, T> {
+        let start = vec.len();
+        assert!(vec.capacity() - start >= len);
+
+        // The pointer is derived from `Vec` directly, not through a `Deref`,
+        // so it has provenance over the whole allocation.
+        let ptr = vec.as_mut_ptr().add(start);
+        DrainProducer::new(slice::from_raw_parts_mut(ptr, len))
+    }
+}
+
+impl<'data, T: 'data + Send> Producer for DrainProducer<'data, T> {
+    type Item = T;
+    type IntoIter = SliceDrain<'data, T>;
+
+    fn into_iter(mut self) -> Self::IntoIter {
+        // replace the slice so we don't drop it twice
+        let slice = mem::take(&mut self.slice);
+        SliceDrain {
+            iter: slice.iter_mut(),
+        }
+    }
+
+    fn split_at(mut self, index: usize) -> (Self, Self) {
+        // replace the slice so we don't drop it twice
+        let slice = mem::take(&mut self.slice);
+        let (left, right) = slice.split_at_mut(index);
+        unsafe { (DrainProducer::new(left), DrainProducer::new(right)) }
+    }
+}
+
+impl<'data, T: 'data + Send> Drop for DrainProducer<'data, T> {
+    fn drop(&mut self) {
+        // extract the slice so we can use `Drop for [T]`
+        let slice_ptr: *mut [T] = mem::take::<&'data mut [T]>(&mut self.slice);
+        unsafe { ptr::drop_in_place::<[T]>(slice_ptr) };
+    }
+}
+
+/// ////////////////////////////////////////////////////////////////////////
+
+// like std::vec::Drain, without updating a source Vec
+pub(crate) struct SliceDrain<'data, T> {
+    iter: slice::IterMut<'data, T>,
+}
+
+impl<'data, T: 'data> Iterator for SliceDrain<'data, T> {
+    type Item = T;
+
+    fn next(&mut self) -> Option<T> {
+        // Coerce the pointer early, so we don't keep the
+        // reference that's about to be invalidated.
+        let ptr: *const T = self.iter.next()?;
+        Some(unsafe { ptr::read(ptr) })
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.iter.size_hint()
+    }
+
+    fn count(self) -> usize {
+        self.iter.len()
+    }
+}
+
+impl<'data, T: 'data> DoubleEndedIterator for SliceDrain<'data, T> {
+    fn next_back(&mut self) -> Option<Self::Item> {
+        // Coerce the pointer early, so we don't keep the
+        // reference that's about to be invalidated.
+        let ptr: *const T = self.iter.next_back()?;
+        Some(unsafe { ptr::read(ptr) })
+    }
+}
+
+impl<'data, T: 'data> ExactSizeIterator for SliceDrain<'data, T> {
+    fn len(&self) -> usize {
+        self.iter.len()
+    }
+}
+
+impl<'data, T: 'data> iter::FusedIterator for SliceDrain<'data, T> {}
+
+impl<'data, T: 'data> Drop for SliceDrain<'data, T> {
+    fn drop(&mut self) {
+        // extract the iterator so we can use `Drop for [T]`
+        let slice_ptr: *mut [T] = mem::replace(&mut self.iter, [].iter_mut()).into_slice();
+        unsafe { ptr::drop_in_place::<[T]>(slice_ptr) };
+    }
+}
diff --git a/crates/rayon/tests/chars.rs b/crates/rayon/tests/chars.rs
new file mode 100644
index 0000000..ac8e3f3
--- /dev/null
+++ b/crates/rayon/tests/chars.rs
@@ -0,0 +1,39 @@
+use rayon::prelude::*;
+use std::char;
+
+#[test]
+fn half_open_correctness() {
+    let low = char::from_u32(0xD800 - 0x7).unwrap();
+    let high = char::from_u32(0xE000 + 0x7).unwrap();
+
+    let range = low..high;
+    let mut chars: Vec<char> = range.into_par_iter().collect();
+    chars.sort();
+
+    assert_eq!(
+        chars,
+        vec![
+            '\u{D7F9}', '\u{D7FA}', '\u{D7FB}', '\u{D7FC}', '\u{D7FD}', '\u{D7FE}', '\u{D7FF}',
+            '\u{E000}', '\u{E001}', '\u{E002}', '\u{E003}', '\u{E004}', '\u{E005}', '\u{E006}',
+        ]
+    );
+}
+
+#[test]
+fn closed_correctness() {
+    let low = char::from_u32(0xD800 - 0x7).unwrap();
+    let high = char::from_u32(0xE000 + 0x7).unwrap();
+
+    let range = low..=high;
+    let mut chars: Vec<char> = range.into_par_iter().collect();
+    chars.sort();
+
+    assert_eq!(
+        chars,
+        vec![
+            '\u{D7F9}', '\u{D7FA}', '\u{D7FB}', '\u{D7FC}', '\u{D7FD}', '\u{D7FE}', '\u{D7FF}',
+            '\u{E000}', '\u{E001}', '\u{E002}', '\u{E003}', '\u{E004}', '\u{E005}', '\u{E006}',
+            '\u{E007}',
+        ]
+    );
+}
diff --git a/crates/rayon/tests/clones.rs b/crates/rayon/tests/clones.rs
new file mode 100644
index 0000000..0d6c864
--- /dev/null
+++ b/crates/rayon/tests/clones.rs
@@ -0,0 +1,216 @@
+use rayon::prelude::*;
+
+fn check<I>(iter: I)
+where
+    I: ParallelIterator + Clone,
+    I::Item: std::fmt::Debug + PartialEq,
+{
+    let a: Vec<_> = iter.clone().collect();
+    let b: Vec<_> = iter.collect();
+    assert_eq!(a, b);
+}
+
+fn check_count<I>(iter: I)
+where
+    I: ParallelIterator + Clone,
+{
+    assert_eq!(iter.clone().count(), iter.count());
+}
+
+#[test]
+fn clone_binary_heap() {
+    use std::collections::BinaryHeap;
+    let heap: BinaryHeap<_> = (0..1000).collect();
+    check(heap.par_iter());
+    check(heap.into_par_iter());
+}
+
+#[test]
+fn clone_btree_map() {
+    use std::collections::BTreeMap;
+    let map: BTreeMap<_, _> = (0..1000).enumerate().collect();
+    check(map.par_iter());
+}
+
+#[test]
+fn clone_btree_set() {
+    use std::collections::BTreeSet;
+    let set: BTreeSet<_> = (0..1000).collect();
+    check(set.par_iter());
+}
+
+#[test]
+fn clone_hash_map() {
+    use std::collections::HashMap;
+    let map: HashMap<_, _> = (0..1000).enumerate().collect();
+    check(map.par_iter());
+}
+
+#[test]
+fn clone_hash_set() {
+    use std::collections::HashSet;
+    let set: HashSet<_> = (0..1000).collect();
+    check(set.par_iter());
+}
+
+#[test]
+fn clone_linked_list() {
+    use std::collections::LinkedList;
+    let list: LinkedList<_> = (0..1000).collect();
+    check(list.par_iter());
+    check(list.into_par_iter());
+}
+
+#[test]
+fn clone_vec_deque() {
+    use std::collections::VecDeque;
+    let deque: VecDeque<_> = (0..1000).collect();
+    check(deque.par_iter());
+    check(deque.into_par_iter());
+}
+
+#[test]
+fn clone_option() {
+    let option = Some(0);
+    check(option.par_iter());
+    check(option.into_par_iter());
+}
+
+#[test]
+fn clone_result() {
+    let result = Ok::<_, ()>(0);
+    check(result.par_iter());
+    check(result.into_par_iter());
+}
+
+#[test]
+fn clone_range() {
+    check((0..1000).into_par_iter());
+}
+
+#[test]
+fn clone_range_inclusive() {
+    check((0..=1000).into_par_iter());
+}
+
+#[test]
+fn clone_str() {
+    let s = include_str!("clones.rs");
+    check(s.par_chars());
+    check(s.par_lines());
+    check(s.par_split('\n'));
+    check(s.par_split_terminator('\n'));
+    check(s.par_split_whitespace());
+}
+
+#[test]
+fn clone_vec() {
+    let v: Vec<_> = (0..1000).collect();
+    check(v.par_iter());
+    check(v.par_chunks(42));
+    check(v.par_chunks_exact(42));
+    check(v.par_rchunks(42));
+    check(v.par_rchunks_exact(42));
+    check(v.par_windows(42));
+    check(v.par_split(|x| x % 3 == 0));
+    check(v.into_par_iter());
+}
+
+#[test]
+fn clone_array() {
+    let a = [0i32; 100];
+    check(a.into_par_iter());
+}
+
+#[test]
+fn clone_adaptors() {
+    let v: Vec<_> = (0..1000).map(Some).collect();
+    check(v.par_iter().chain(&v));
+    check(v.par_iter().cloned());
+    check(v.par_iter().copied());
+    check(v.par_iter().enumerate());
+    check(v.par_iter().filter(|_| true));
+    check(v.par_iter().filter_map(|x| *x));
+    check(v.par_iter().flat_map(|x| *x));
+    check(v.par_iter().flat_map_iter(|x| *x));
+    check(v.par_iter().flatten());
+    check(v.par_iter().flatten_iter());
+    check(v.par_iter().with_max_len(1).fold(|| 0, |x, _| x));
+    check(v.par_iter().with_max_len(1).fold_with(0, |x, _| x));
+    check(v.par_iter().with_max_len(1).fold_chunks(1, || 0, |x, _| x));
+    check(
+        v.par_iter()
+            .with_max_len(1)
+            .fold_chunks_with(1, 0, |x, _| x),
+    );
+    check(v.par_iter().with_max_len(1).try_fold(|| 0, |_, &x| x));
+    check(v.par_iter().with_max_len(1).try_fold_with(0, |_, &x| x));
+    check(v.par_iter().inspect(|_| ()));
+    check(v.par_iter().update(|_| ()));
+    check(v.par_iter().interleave(&v));
+    check(v.par_iter().interleave_shortest(&v));
+    check(v.par_iter().intersperse(&None));
+    check(v.par_iter().chunks(3));
+    check(v.par_iter().map(|x| x));
+    check(v.par_iter().map_with(0, |_, x| x));
+    check(v.par_iter().map_init(|| 0, |_, x| x));
+    check(v.par_iter().panic_fuse());
+    check(v.par_iter().positions(|_| true));
+    check(v.par_iter().rev());
+    check(v.par_iter().skip(42));
+    check(v.par_iter().skip_any_while(|_| false));
+    check(v.par_iter().take(42));
+    check(v.par_iter().take_any_while(|_| true));
+    check(v.par_iter().cloned().while_some());
+    check(v.par_iter().with_max_len(1));
+    check(v.par_iter().with_min_len(1));
+    check(v.par_iter().zip(&v));
+    check(v.par_iter().zip_eq(&v));
+    check(v.par_iter().step_by(2));
+}
+
+#[test]
+fn clone_counted_adaptors() {
+    let v: Vec<_> = (0..1000).collect();
+    check_count(v.par_iter().skip_any(42));
+    check_count(v.par_iter().take_any(42));
+}
+
+#[test]
+fn clone_empty() {
+    check(rayon::iter::empty::<i32>());
+}
+
+#[test]
+fn clone_once() {
+    check(rayon::iter::once(10));
+}
+
+#[test]
+fn clone_repeat() {
+    let x: Option<i32> = None;
+    check(rayon::iter::repeat(x).while_some());
+    check(rayon::iter::repeatn(x, 1000));
+}
+
+#[test]
+fn clone_splitter() {
+    check(rayon::iter::split(0..1000, |x| (x, None)));
+}
+
+#[test]
+fn clone_multizip() {
+    let v: &Vec<_> = &(0..1000).collect();
+    check((v,).into_par_iter());
+    check((v, v).into_par_iter());
+    check((v, v, v).into_par_iter());
+    check((v, v, v, v).into_par_iter());
+    check((v, v, v, v, v).into_par_iter());
+    check((v, v, v, v, v, v).into_par_iter());
+    check((v, v, v, v, v, v, v).into_par_iter());
+    check((v, v, v, v, v, v, v, v).into_par_iter());
+    check((v, v, v, v, v, v, v, v, v).into_par_iter());
+    check((v, v, v, v, v, v, v, v, v, v).into_par_iter());
+    check((v, v, v, v, v, v, v, v, v, v, v).into_par_iter());
+    check((v, v, v, v, v, v, v, v, v, v, v, v).into_par_iter());
+}
diff --git a/crates/rayon/tests/collect.rs b/crates/rayon/tests/collect.rs
new file mode 100644
index 0000000..bfb080c
--- /dev/null
+++ b/crates/rayon/tests/collect.rs
@@ -0,0 +1,113 @@
+use rayon::prelude::*;
+
+use std::panic;
+use std::sync::atomic::AtomicUsize;
+use std::sync::atomic::Ordering;
+use std::sync::Mutex;
+
+#[test]
+#[cfg_attr(not(panic = "unwind"), ignore)]
+fn collect_drop_on_unwind() {
+    struct Recorddrop<'a>(i64, &'a Mutex<Vec<i64>>);
+
+    impl<'a> Drop for Recorddrop<'a> {
+        fn drop(&mut self) {
+            self.1.lock().unwrap().push(self.0);
+        }
+    }
+
+    let test_collect_panic = |will_panic: bool| {
+        let test_vec_len = 1024;
+        let panic_point = 740;
+
+        let mut inserts = Mutex::new(Vec::new());
+        let mut drops = Mutex::new(Vec::new());
+
+        let mut a = (0..test_vec_len).collect::<Vec<_>>();
+        let b = (0..test_vec_len).collect::<Vec<_>>();
+
+        let _result = panic::catch_unwind(panic::AssertUnwindSafe(|| {
+            let mut result = Vec::new();
+            a.par_iter_mut()
+                .zip(&b)
+                .map(|(&mut a, &b)| {
+                    if a > panic_point && will_panic {
+                        panic!("unwinding for test");
+                    }
+                    let elt = a + b;
+                    inserts.lock().unwrap().push(elt);
+                    Recorddrop(elt, &drops)
+                })
+                .collect_into_vec(&mut result);
+
+            // If we reach this point, this must pass
+            assert_eq!(a.len(), result.len());
+        }));
+
+        let inserts = inserts.get_mut().unwrap();
+        let drops = drops.get_mut().unwrap();
+        println!("{:?}", inserts);
+        println!("{:?}", drops);
+
+        assert_eq!(inserts.len(), drops.len(), "Incorrect number of drops");
+        // sort to normalize order
+        inserts.sort();
+        drops.sort();
+        assert_eq!(inserts, drops, "Incorrect elements were dropped");
+    };
+
+    for &should_panic in &[true, false] {
+        test_collect_panic(should_panic);
+    }
+}
+
+#[test]
+#[cfg_attr(not(panic = "unwind"), ignore)]
+fn collect_drop_on_unwind_zst() {
+    static INSERTS: AtomicUsize = AtomicUsize::new(0);
+    static DROPS: AtomicUsize = AtomicUsize::new(0);
+
+    struct RecorddropZst;
+
+    impl Drop for RecorddropZst {
+        fn drop(&mut self) {
+            DROPS.fetch_add(1, Ordering::SeqCst);
+        }
+    }
+
+    let test_collect_panic = |will_panic: bool| {
+        INSERTS.store(0, Ordering::SeqCst);
+        DROPS.store(0, Ordering::SeqCst);
+
+        let test_vec_len = 1024;
+        let panic_point = 740;
+
+        let a = (0..test_vec_len).collect::<Vec<_>>();
+
+        let _result = panic::catch_unwind(panic::AssertUnwindSafe(|| {
+            let mut result = Vec::new();
+            a.par_iter()
+                .map(|&a| {
+                    if a > panic_point && will_panic {
+                        panic!("unwinding for test");
+                    }
+                    INSERTS.fetch_add(1, Ordering::SeqCst);
+                    RecorddropZst
+                })
+                .collect_into_vec(&mut result);
+
+            // If we reach this point, this must pass
+            assert_eq!(a.len(), result.len());
+        }));
+
+        let inserts = INSERTS.load(Ordering::SeqCst);
+        let drops = DROPS.load(Ordering::SeqCst);
+
+        assert_eq!(inserts, drops, "Incorrect number of drops");
+        assert!(will_panic || drops == test_vec_len)
+    };
+
+    for &should_panic in &[true, false] {
+        test_collect_panic(should_panic);
+    }
+}
diff --git a/crates/rayon/tests/cross-pool.rs b/crates/rayon/tests/cross-pool.rs
new file mode 100644
index 0000000..835e2e2
--- /dev/null
+++ b/crates/rayon/tests/cross-pool.rs
@@ -0,0 +1,22 @@
+use rayon::prelude::*;
+use rayon::ThreadPoolBuilder;
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn cross_pool_busy() {
+    let pool1 = ThreadPoolBuilder::new().num_threads(1).build().unwrap();
+    let pool2 = ThreadPoolBuilder::new().num_threads(1).build().unwrap();
+
+    let n: i32 = 100;
+    let sum: i32 = pool1.install(move || {
+        // Each item will block on pool2, but pool1 can continue processing other work from the
+        // parallel iterator in the meantime. There's a chance that pool1 will still be awake to
+        // see the latch set without being tickled, and then it will drop that stack job. The latch
+        // internals must not assume that the job will still be alive after it's set!
+        (1..=n)
+            .into_par_iter()
+            .map(|i| pool2.install(move || i))
+            .sum()
+    });
+    assert_eq!(sum, n * (n + 1) / 2);
+}
diff --git a/crates/rayon/tests/debug.rs b/crates/rayon/tests/debug.rs
new file mode 100644
index 0000000..14f3791
--- /dev/null
+++ b/crates/rayon/tests/debug.rs
@@ -0,0 +1,225 @@
+use rayon::prelude::*;
+use std::fmt::Debug;
+
+fn check<I>(iter: I)
+where
+    I: ParallelIterator + Debug,
+{
+    println!("{:?}", iter);
+}
+
+#[test]
+fn debug_binary_heap() {
+    use std::collections::BinaryHeap;
+    let mut heap: BinaryHeap<_> = (0..10).collect();
+    check(heap.par_iter());
+    check(heap.par_drain());
+    check(heap.into_par_iter());
+}
+
+#[test]
+fn debug_btree_map() {
+    use std::collections::BTreeMap;
+    let mut map: BTreeMap<_, _> = (0..10).enumerate().collect();
+    check(map.par_iter());
+    check(map.par_iter_mut());
+    check(map.into_par_iter());
+}
+
+#[test]
+fn debug_btree_set() {
+    use std::collections::BTreeSet;
+    let set: BTreeSet<_> = (0..10).collect();
+    check(set.par_iter());
+    check(set.into_par_iter());
+}
+
+#[test]
+fn debug_hash_map() {
+    use std::collections::HashMap;
+    let mut map: HashMap<_, _> = (0..10).enumerate().collect();
+    check(map.par_iter());
+    check(map.par_iter_mut());
+    check(map.par_drain());
+    check(map.into_par_iter());
+}
+
+#[test]
+fn debug_hash_set() {
+    use std::collections::HashSet;
+    let mut set: HashSet<_> = (0..10).collect();
+    check(set.par_iter());
+    check(set.par_drain());
+    check(set.into_par_iter());
+}
+
+#[test]
+fn debug_linked_list() {
+    use std::collections::LinkedList;
+    let mut list: LinkedList<_> = (0..10).collect();
+    check(list.par_iter());
+    check(list.par_iter_mut());
+    check(list.into_par_iter());
+}
+
+#[test]
+fn debug_vec_deque() {
+    use std::collections::VecDeque;
+    let mut deque: VecDeque<_> = (0..10).collect();
+    check(deque.par_iter());
+    check(deque.par_iter_mut());
+    check(deque.par_drain(..));
+    check(deque.into_par_iter());
+}
+
+#[test]
+fn debug_option() {
+    let mut option = Some(0);
+    check(option.par_iter());
+    check(option.par_iter_mut());
+    check(option.into_par_iter());
+}
+
+#[test]
+fn debug_result() {
+    let mut result = Ok::<_, ()>(0);
+    check(result.par_iter());
+    check(result.par_iter_mut());
+    check(result.into_par_iter());
+}
+
+#[test]
+fn debug_range() {
+    check((0..10).into_par_iter());
+}
+
+#[test]
+fn debug_range_inclusive() {
+    check((0..=10).into_par_iter());
+}
+
+#[test]
+fn debug_str() {
+    let s = "a b c d\ne f g";
+    check(s.par_chars());
+    check(s.par_lines());
+    check(s.par_split('\n'));
+    check(s.par_split_terminator('\n'));
+    check(s.par_split_whitespace());
+}
+
+#[test]
+fn debug_string() {
+    let mut s = "a b c d\ne f g".to_string();
+    s.par_drain(..);
+}
+
+#[test]
+fn debug_vec() {
+    let mut v: Vec<_> = (0..10).collect();
+    check(v.par_iter());
+    check(v.par_iter_mut());
+    check(v.par_chunks(42));
+    check(v.par_chunks_exact(42));
+    check(v.par_chunks_mut(42));
+    check(v.par_chunks_exact_mut(42));
+    check(v.par_rchunks(42));
+    check(v.par_rchunks_exact(42));
+    check(v.par_rchunks_mut(42));
+    check(v.par_rchunks_exact_mut(42));
+    check(v.par_windows(42));
+    check(v.par_split(|x| x % 3 == 0));
+    check(v.par_split_mut(|x| x % 3 == 0));
+    check(v.par_drain(..));
+    check(v.into_par_iter());
+}
+
+#[test]
+fn debug_array() {
+    let a = [0i32; 10];
+    check(a.into_par_iter());
+}
+
+#[test]
+fn debug_adaptors() {
+    let v: Vec<_> = (0..10).collect();
+    check(v.par_iter().chain(&v));
+    check(v.par_iter().cloned());
+    check(v.par_iter().copied());
+    check(v.par_iter().enumerate());
+    check(v.par_iter().filter(|_| true));
+    check(v.par_iter().filter_map(Some));
+    check(v.par_iter().flat_map(Some));
+    check(v.par_iter().flat_map_iter(Some));
+    check(v.par_iter().map(Some).flatten());
+    check(v.par_iter().map(Some).flatten_iter());
+    check(v.par_iter().fold(|| 0, |x, _| x));
+    check(v.par_iter().fold_with(0, |x, _| x));
+    check(v.par_iter().fold_chunks(3, || 0, |x, _| x));
+    check(v.par_iter().fold_chunks_with(3, 0, |x, _| x));
+    check(v.par_iter().try_fold(|| 0, |x, _| Some(x)));
+    check(v.par_iter().try_fold_with(0, |x, _| Some(x)));
+    check(v.par_iter().inspect(|_| ()));
+    check(v.par_iter().update(|_| ()));
+    check(v.par_iter().interleave(&v));
+    check(v.par_iter().interleave_shortest(&v));
+    check(v.par_iter().intersperse(&-1));
+    check(v.par_iter().chunks(3));
+    check(v.par_iter().map(|x| x));
+    check(v.par_iter().map_with(0, |_, x| x));
+    check(v.par_iter().map_init(|| 0, |_, x| x));
+    check(v.par_iter().panic_fuse());
+    check(v.par_iter().positions(|_| true));
+    check(v.par_iter().rev());
+    check(v.par_iter().skip(1));
+    check(v.par_iter().skip_any(1));
+    check(v.par_iter().skip_any_while(|_| false));
+    check(v.par_iter().take(1));
+    check(v.par_iter().take_any(1));
+    check(v.par_iter().take_any_while(|_| true));
+    check(v.par_iter().map(Some).while_some());
+    check(v.par_iter().with_max_len(1));
+    check(v.par_iter().with_min_len(1));
+    check(v.par_iter().zip(&v));
+    check(v.par_iter().zip_eq(&v));
+    check(v.par_iter().step_by(2));
+}
+
+#[test]
+fn debug_empty() {
+    check(rayon::iter::empty::<i32>());
+}
+
+#[test]
+fn debug_once() {
+    check(rayon::iter::once(10));
+}
+
+#[test]
+fn debug_repeat() {
+    let x: Option<i32> = None;
+    check(rayon::iter::repeat(x));
+    check(rayon::iter::repeatn(x, 10));
+}
+
+#[test]
+fn debug_splitter() {
+    check(rayon::iter::split(0..10, |x| (x, None)));
+}
+
+#[test]
+fn debug_multizip() {
+    let v: &Vec<_> = &(0..10).collect();
+    check((v,).into_par_iter());
+    check((v, v).into_par_iter());
+    check((v, v, v).into_par_iter());
+    check((v, v, v, v).into_par_iter());
+    check((v, v, v, v, v).into_par_iter());
+    check((v, v, v, v, v, v).into_par_iter());
+    check((v, v, v, v, v, v, v).into_par_iter());
+    check((v, v, v, v, v, v, v, v).into_par_iter());
+    check((v, v, v, v, v, v, v, v, v).into_par_iter());
+    check((v, v, v, v, v, v, v, v, v, v).into_par_iter());
+    check((v, v, v, v, v, v, v, v, v, v, v).into_par_iter());
+    check((v, v, v, v, v, v, v, v, v, v, v, v).into_par_iter());
+}
diff --git a/crates/rayon/tests/drain_vec.rs b/crates/rayon/tests/drain_vec.rs
new file mode 100644
index 0000000..08f1120
--- /dev/null
+++ b/crates/rayon/tests/drain_vec.rs
@@ -0,0 +1,41 @@
+use rayon::prelude::*;
+
+#[test]
+fn drain_vec_yielded() {
+    let mut vec_org = vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+
+    let yielded = vec_org.par_drain(0..5).collect::<Vec<_>>();
+
+    assert_eq!(&yielded, &[0, 1, 2, 3, 4]);
+    assert_eq!(&vec_org, &[5, 6, 7, 8, 9]);
+}
+
+#[test]
+fn drain_vec_dropped() {
+    let mut vec_org = vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+
+    let yielded = vec_org.par_drain(0..5);
+
+    drop(yielded);
+    assert_eq!(&vec_org, &[5, 6, 7, 8, 9]);
+}
+
+#[test]
+fn drain_vec_empty_range_yielded() {
+    let mut vec_org = vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+
+    let yielded = vec_org.par_drain(5..5).collect::<Vec<_>>();
+
+    assert_eq!(&yielded, &[]);
+    assert_eq!(&vec_org, &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+}
+
+#[test]
+fn drain_vec_empty_range_dropped() {
+    let mut vec_org = vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+
+    let yielded = vec_org.par_drain(5..5);
+
+    drop(yielded);
+    assert_eq!(&vec_org, &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+}
diff --git a/crates/rayon/tests/intersperse.rs b/crates/rayon/tests/intersperse.rs
new file mode 100644
index 0000000..aaa5b65
--- /dev/null
+++ b/crates/rayon/tests/intersperse.rs
@@ -0,0 +1,60 @@
+use rayon::prelude::*;
+
+#[test]
+fn check_intersperse() {
+    let v: Vec<_> = (0..1000).into_par_iter().intersperse(-1).collect();
+    assert_eq!(v.len(), 1999);
+    for (i, x) in v.into_iter().enumerate() {
+        assert_eq!(x, if i % 2 == 0 { i as i32 / 2 } else { -1 });
+    }
+}
+
+#[test]
+fn check_intersperse_again() {
+    let v: Vec<_> = (0..1000)
+        .into_par_iter()
+        .intersperse(-1)
+        .intersperse(-2)
+        .collect();
+    assert_eq!(v.len(), 3997);
+    for (i, x) in v.into_iter().enumerate() {
+        let y = match i % 4 {
+            0 => i as i32 / 4,
+            2 => -1,
+            _ => -2,
+        };
+        assert_eq!(x, y);
+    }
+}
+
+#[test]
+fn check_intersperse_unindexed() {
+    let v: Vec<_> = (0..1000).map(|i| i.to_string()).collect();
+    let s = v.join(",");
+    let s2 = v.join(";");
+    let par: String = s.par_split(',').intersperse(";").collect();
+    assert_eq!(par, s2);
+}
+
+#[test]
+fn check_intersperse_producer() {
+    (0..1000)
+        .into_par_iter()
+        .intersperse(-1)
+        .zip_eq(0..1999)
+        .for_each(|(x, i)| {
+            assert_eq!(x, if i % 2 == 0 { i / 2 } else { -1 });
+        });
+}
+
+#[test]
+fn check_intersperse_rev() {
+    (0..1000)
+        .into_par_iter()
+        .intersperse(-1)
+        .zip_eq(0..1999)
+        .rev()
+        .for_each(|(x, i)| {
+            assert_eq!(x, if i % 2 == 0 { i / 2 } else { -1 });
+        });
+}
diff --git a/crates/rayon/tests/issue671-unzip.rs b/crates/rayon/tests/issue671-unzip.rs
new file mode 100644
index 0000000..c9af7e6
--- /dev/null
+++ b/crates/rayon/tests/issue671-unzip.rs
@@ -0,0 +1,17 @@
+#![type_length_limit = "10000"]
+
+use rayon::prelude::*;
+
+#[test]
+fn type_length_limit() {
+    let input = vec![1, 2, 3, 4, 5];
+    let (indexes, (squares, cubes)): (Vec<_>, (Vec<_>, Vec<_>)) = input
+        .par_iter()
+        .map(|x| (x * x, x * x * x))
+        .enumerate()
+        .unzip();
+
+    drop(indexes);
+    drop(squares);
+    drop(cubes);
+}
diff --git a/crates/rayon/tests/issue671.rs b/crates/rayon/tests/issue671.rs
new file mode 100644
index 0000000..9d0953f
--- /dev/null
+++ b/crates/rayon/tests/issue671.rs
@@ -0,0 +1,16 @@
+#![type_length_limit = "500000"]
+
+use rayon::prelude::*;
+
+#[test]
+fn type_length_limit() {
+    let _ = Vec::<Result<(), ()>>::new()
+        .into_par_iter()
+        .map(|x| x)
+        .map(|x| x)
+        .map(|x| x)
+        .map(|x| x)
+        .map(|x| x)
+        .map(|x| x)
+        .collect::<Result<(), ()>>();
+}
diff --git a/crates/rayon/tests/iter_panic.rs b/crates/rayon/tests/iter_panic.rs
new file mode 100644
index 0000000..c62a8db
--- /dev/null
+++ b/crates/rayon/tests/iter_panic.rs
@@ -0,0 +1,53 @@
+use rayon::prelude::*;
+use rayon::ThreadPoolBuilder;
+use std::ops::Range;
+use std::panic::{self, UnwindSafe};
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+const ITER: Range<i32> = 0..0x1_0000;
+const PANIC: i32 = 0xC000;
+
+fn check(&i: &i32) {
+    if i == PANIC {
+        panic!("boom")
+    }
+}
+
+#[test]
+#[should_panic(expected = "boom")]
+fn iter_panic() {
+    ITER.into_par_iter().for_each(|i| check(&i));
+}
+
+#[test]
+#[cfg_attr(not(panic = "unwind"), ignore)]
+fn iter_panic_fuse() {
+    // We only use a single thread in order to make the behavior
+    // of 'panic_fuse' deterministic
+    let pool = ThreadPoolBuilder::new().num_threads(1).build().unwrap();
+
+    pool.install(|| {
+        fn count(iter: impl ParallelIterator + UnwindSafe) -> usize {
+            let count = AtomicUsize::new(0);
+            let result = panic::catch_unwind(|| {
+                iter.for_each(|_| {
+                    count.fetch_add(1, Ordering::Relaxed);
+                });
+            });
+            assert!(result.is_err());
+            count.into_inner()
+        }
+
+        // Without `panic_fuse()`, we'll reach every item except the panicking one.
+        let expected = ITER.len() - 1;
+        let iter = ITER.into_par_iter().with_max_len(1);
+        assert_eq!(count(iter.clone().inspect(check)), expected);
+
+        // With `panic_fuse()` anywhere in the chain, we'll reach fewer items.
+        assert!(count(iter.clone().inspect(check).panic_fuse()) < expected);
+        assert!(count(iter.clone().panic_fuse().inspect(check)) < expected);
+
+        // Try in reverse to be sure we hit the producer case.
+        assert!(count(iter.panic_fuse().inspect(check).rev()) < expected);
+    });
+}
diff --git a/crates/rayon/tests/named-threads.rs b/crates/rayon/tests/named-threads.rs
new file mode 100644
index 0000000..dadb37b
--- /dev/null
+++ b/crates/rayon/tests/named-threads.rs
@@ -0,0 +1,25 @@
+use std::collections::HashSet;
+
+use rayon::prelude::*;
+use rayon::*;
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn named_threads() {
+    ThreadPoolBuilder::new()
+        .thread_name(|i| format!("hello-name-test-{}", i))
+        .build_global()
+        .unwrap();
+
+    const N: usize = 10000;
+
+    let thread_names = (0..N)
+        .into_par_iter()
+        .flat_map(|_| ::std::thread::current().name().map(str::to_owned))
+        .collect::<HashSet<String>>();
+
+    let all_contains_name = thread_names
+        .iter()
+        .all(|name| name.starts_with("hello-name-test-"));
+    assert!(all_contains_name);
+}
diff --git a/crates/rayon/tests/octillion.rs b/crates/rayon/tests/octillion.rs
new file mode 100644
index 0000000..1af9ad8
--- /dev/null
+++ b/crates/rayon/tests/octillion.rs
@@ -0,0 +1,156 @@
+use rayon::prelude::*;
+
+const OCTILLION: u128 = 1_000_000_000_000_000_000_000_000_000;
+
+/// Produce a parallel iterator for 0u128..10²⁷
+fn octillion() -> rayon::range::Iter<u128> {
+    (0..OCTILLION).into_par_iter()
+}
+
+/// Produce a parallel iterator for 0u128..=10²⁷
+fn octillion_inclusive() -> rayon::range_inclusive::Iter<u128> {
+    (0..=OCTILLION).into_par_iter()
+}
+
+/// Produce a parallel iterator for 0u128..10²⁷ using `flat_map`
+fn octillion_flat() -> impl ParallelIterator<Item = u128> {
+    (0u32..1_000_000_000)
+        .into_par_iter()
+        .with_max_len(1_000)
+        .map(|i| u64::from(i) * 1_000_000_000)
+        .flat_map(|i| {
+            (0u32..1_000_000_000)
+                .into_par_iter()
+                .with_max_len(1_000)
+                .map(move |j| i + u64::from(j))
+        })
+        .map(|i| u128::from(i) * 1_000_000_000)
+        .flat_map(|i| {
+            (0u32..1_000_000_000)
+                .into_par_iter()
+                .with_max_len(1_000)
+                .map(move |j| i + u128::from(j))
+        })
+}
+
+// NOTE: `find_first` and `find_last` currently take too long on 32-bit targets,
+// because the `AtomicUsize` match position has much too limited resolution.
+
+#[test]
+#[cfg_attr(not(target_pointer_width = "64"), ignore)]
+fn find_first_octillion() {
+    let x = octillion().find_first(|_| true);
+    assert_eq!(x, Some(0));
+}
+
+#[test]
+#[cfg_attr(not(target_pointer_width = "64"), ignore)]
+fn find_first_octillion_inclusive() {
+    let x = octillion_inclusive().find_first(|_| true);
+    assert_eq!(x, Some(0));
+}
+
+#[test]
+#[cfg_attr(not(target_pointer_width = "64"), ignore)]
+fn find_first_octillion_flat() {
+    let x = octillion_flat().find_first(|_| true);
+    assert_eq!(x, Some(0));
+}
+
+fn two_threads<F: Send + FnOnce() -> R, R: Send>(f: F) -> R {
+    // FIXME: If we don't use at least two threads, then we end up walking
+    // through the entire iterator sequentially, without the benefit of any
+    // short-circuiting.  We probably don't want testing to wait that long. ;)
+    let builder = rayon::ThreadPoolBuilder::new().num_threads(2);
+    let pool = builder.build().unwrap();
+
+    pool.install(f)
+}
+
+#[test]
+#[cfg_attr(
+    any(
+        not(target_pointer_width = "64"),
+        target_os = "emscripten",
+        target_family = "wasm"
+    ),
+    ignore
+)]
+fn find_last_octillion() {
+    // It would be nice if `find_last` could prioritize the later splits,
+    // basically flipping the `join` args, without needing indexed `rev`.
+    // (or could we have an unindexed `rev`?)
+    let x = two_threads(|| octillion().find_last(|_| true));
+    assert_eq!(x, Some(OCTILLION - 1));
+}
+
+#[test]
+#[cfg_attr(
+    any(
+        not(target_pointer_width = "64"),
+        target_os = "emscripten",
+        target_family = "wasm"
+    ),
+    ignore
+)]
+fn find_last_octillion_inclusive() {
+    let x = two_threads(|| octillion_inclusive().find_last(|_| true));
+    assert_eq!(x, Some(OCTILLION));
+}
+
+#[test]
+#[cfg_attr(
+    any(
+        not(target_pointer_width = "64"),
+        target_os = "emscripten",
+        target_family = "wasm"
+    ),
+    ignore
+)]
+fn find_last_octillion_flat() {
+    let x = two_threads(|| octillion_flat().find_last(|_| true));
+    assert_eq!(x, Some(OCTILLION - 1));
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn find_any_octillion() {
+    let x = two_threads(|| octillion().find_any(|x| *x > OCTILLION / 2));
+    assert!(x.is_some());
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn find_any_octillion_flat() {
+    let x = two_threads(|| octillion_flat().find_any(|x| *x > OCTILLION / 2));
+    assert!(x.is_some());
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn filter_find_any_octillion() {
+    let x = two_threads(|| {
+        octillion()
+            .filter(|x| *x > OCTILLION / 2)
+            .find_any(|_| true)
+    });
+    assert!(x.is_some());
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn filter_find_any_octillion_flat() {
+    let x = two_threads(|| {
+        octillion_flat()
+            .filter(|x| *x > OCTILLION / 2)
+            .find_any(|_| true)
+    });
+    assert!(x.is_some());
+}
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn fold_find_any_octillion_flat() {
+    let x = two_threads(|| octillion_flat().fold(|| (), |_, _| ()).find_any(|_| true));
+    assert!(x.is_some());
+}
diff --git a/crates/rayon/tests/par_bridge_recursion.rs b/crates/rayon/tests/par_bridge_recursion.rs
new file mode 100644
index 0000000..3a48ef1
--- /dev/null
+++ b/crates/rayon/tests/par_bridge_recursion.rs
@@ -0,0 +1,31 @@
+use rayon::prelude::*;
+use std::iter::once_with;
+
+const N: usize = 100_000;
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn par_bridge_recursion() {
+    let pool = rayon::ThreadPoolBuilder::new()
+        .num_threads(10)
+        .build()
+        .unwrap();
+
+    let seq: Vec<_> = (0..N).map(|i| (i, i.to_string())).collect();
+
+    pool.broadcast(|_| {
+        let mut par: Vec<_> = (0..N)
+            .into_par_iter()
+            .flat_map(|i| {
+                once_with(move || {
+                    // Using rayon within the serial iterator creates an opportunity for
+                    // work-stealing to make par_bridge's mutex accidentally recursive.
+                    rayon::join(move || i, move || i.to_string())
+                })
+                .par_bridge()
+            })
+            .collect();
+        par.par_sort_unstable();
+        assert_eq!(seq, par);
+    });
+}
diff --git a/crates/rayon/tests/producer_split_at.rs b/crates/rayon/tests/producer_split_at.rs
new file mode 100644
index 0000000..d710504
--- /dev/null
+++ b/crates/rayon/tests/producer_split_at.rs
@@ -0,0 +1,394 @@
+use rayon::iter::plumbing::*;
+use rayon::prelude::*;
+
+/// Stress-test indexes for `Producer::split_at`.
+fn check<F, I>(expected: &[I::Item], mut f: F)
+where
+    F: FnMut() -> I,
+    I: IntoParallelIterator,
+    I::Iter: IndexedParallelIterator,
+    I::Item: PartialEq + std::fmt::Debug,
+{
+    map_triples(expected.len() + 1, |i, j, k| {
+        Split::forward(f(), i, j, k, expected);
+        Split::reverse(f(), i, j, k, expected);
+    });
+}
+
+fn map_triples<F>(end: usize, mut f: F)
+where
+    F: FnMut(usize, usize, usize),
+{
+    for i in 0..end {
+        for j in i..end {
+            for k in j..end {
+                f(i, j, k);
+            }
+        }
+    }
+}
+
+#[derive(Debug)]
+struct Split {
+    i: usize,
+    j: usize,
+    k: usize,
+    reverse: bool,
+}
+
+impl Split {
+    fn forward<I>(iter: I, i: usize, j: usize, k: usize, expected: &[I::Item])
+    where
+        I: IntoParallelIterator,
+        I::Iter: IndexedParallelIterator,
+        I::Item: PartialEq + std::fmt::Debug,
+    {
+        let result = iter.into_par_iter().with_producer(Split {
+            i,
+            j,
+            k,
+            reverse: false,
+        });
+        assert_eq!(result, expected);
+    }
+
+    fn reverse<I>(iter: I, i: usize, j: usize, k: usize, expected: &[I::Item])
+    where
+        I: IntoParallelIterator,
+        I::Iter: IndexedParallelIterator,
+        I::Item: PartialEq + std::fmt::Debug,
+    {
+        let result = iter.into_par_iter().with_producer(Split {
+            i,
+            j,
+            k,
+            reverse: true,
+        });
+        assert!(result.iter().eq(expected.iter().rev()));
+    }
+}
+
+impl<T> ProducerCallback<T> for Split {
+    type Output = Vec<T>;
+
+    fn callback<P>(self, producer: P) -> Self::Output
+    where
+        P: Producer<Item = T>,
+    {
+        println!("{:?}", self);
+
+        // Splitting the outer indexes first gets us an arbitrary mid section,
+        // which we then split further to get full test coverage.
+        let (left, d) = producer.split_at(self.k);
+        let (a, mid) = left.split_at(self.i);
+        let (b, c) = mid.split_at(self.j - self.i);
+
+        let a = a.into_iter();
+        let b = b.into_iter();
+        let c = c.into_iter();
+        let d = d.into_iter();
+
+        check_len(&a, self.i);
+        check_len(&b, self.j - self.i);
+        check_len(&c, self.k - self.j);
+
+        let chain = a.chain(b).chain(c).chain(d);
+        if self.reverse {
+            chain.rev().collect()
+        } else {
+            chain.collect()
+        }
+    }
+}
+
+fn check_len<I: ExactSizeIterator>(iter: &I, len: usize) {
+    assert_eq!(iter.size_hint(), (len, Some(len)));
+    assert_eq!(iter.len(), len);
+}
+
+// **** Base Producers ****
+
+#[test]
+fn array() {
+    let a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+    check(&a, || a);
+}
+
+#[test]
+fn empty() {
+    let v = vec![42];
+    check(&v[..0], rayon::iter::empty);
+}
+
+#[test]
+fn once() {
+    let v = vec![42];
+    check(&v, || rayon::iter::once(42));
+}
+
+#[test]
+fn option() {
+    let v = vec![42];
+    check(&v, || Some(42));
+}
+
+#[test]
+fn range() {
+    let v: Vec<_> = (0..10).collect();
+    check(&v, || 0..10);
+}
+
+#[test]
+fn range_inclusive() {
+    let v: Vec<_> = (0u16..=10).collect();
+    check(&v, || 0u16..=10);
+}
+
+#[test]
+fn repeatn() {
+    let v: Vec<_> = std::iter::repeat(1).take(5).collect();
+    check(&v, || rayon::iter::repeatn(1, 5));
+}
+
+#[test]
+fn slice_iter() {
+    let s: Vec<_> = (0..10).collect();
+    let v: Vec<_> = s.iter().collect();
+    check(&v, || &s);
+}
+
+#[test]
+fn slice_iter_mut() {
+    let mut s: Vec<_> = (0..10).collect();
+    let mut v: Vec<_> = s.clone();
+    let expected: Vec<_> = v.iter_mut().collect();
+
+    map_triples(expected.len() + 1, |i, j, k| {
+        Split::forward(s.par_iter_mut(), i, j, k, &expected);
+        Split::reverse(s.par_iter_mut(), i, j, k, &expected);
+    });
+}
+
+#[test]
+fn slice_chunks() {
+    let s: Vec<_> = (0..10).collect();
+    for len in 1..s.len() + 2 {
+        let v: Vec<_> = s.chunks(len).collect();
+        check(&v, || s.par_chunks(len));
+    }
+}
+
+#[test]
+fn slice_chunks_exact() {
+    let s: Vec<_> = (0..10).collect();
+    for len in 1..s.len() + 2 {
+        let v: Vec<_> = s.chunks_exact(len).collect();
+        check(&v, || s.par_chunks_exact(len));
+    }
+}
+
+#[test]
+fn slice_chunks_mut() {
+    let mut s: Vec<_> = (0..10).collect();
+    let mut v: Vec<_> = s.clone();
+    for len in 1..s.len() + 2 {
+        let expected: Vec<_> = v.chunks_mut(len).collect();
+        map_triples(expected.len() + 1, |i, j, k| {
+            Split::forward(s.par_chunks_mut(len), i, j, k, &expected);
+            Split::reverse(s.par_chunks_mut(len), i, j, k, &expected);
+        });
+    }
+}
+
+#[test]
+fn slice_chunks_exact_mut() {
+    let mut s: Vec<_> = (0..10).collect();
+    let mut v: Vec<_> = s.clone();
+    for len in 1..s.len() + 2 {
+        let expected: Vec<_> = v.chunks_exact_mut(len).collect();
+        map_triples(expected.len() + 1, |i, j, k| {
+            Split::forward(s.par_chunks_exact_mut(len), i, j, k, &expected);
+            Split::reverse(s.par_chunks_exact_mut(len), i, j, k, &expected);
+        });
+    }
+}
+
+#[test]
+fn slice_rchunks() {
+    let s: Vec<_> = (0..10).collect();
+    for len in 1..s.len() + 2 {
+        let v: Vec<_> = s.rchunks(len).collect();
+        check(&v, || s.par_rchunks(len));
+    }
+}
+
+#[test]
+fn slice_rchunks_exact() {
+    let s: Vec<_> = (0..10).collect();
+    for len in 1..s.len() + 2 {
+        let v: Vec<_> = s.rchunks_exact(len).collect();
+        check(&v, || s.par_rchunks_exact(len));
+    }
+}
+
+#[test]
+fn slice_rchunks_mut() {
+    let mut s: Vec<_> = (0..10).collect();
+    let mut v: Vec<_> = s.clone();
+    for len in 1..s.len() + 2 {
+        let expected: Vec<_> = v.rchunks_mut(len).collect();
+        map_triples(expected.len() + 1, |i, j, k| {
+            Split::forward(s.par_rchunks_mut(len), i, j, k, &expected);
+            Split::reverse(s.par_rchunks_mut(len), i, j, k, &expected);
+        });
+    }
+}
+
+#[test]
+fn slice_rchunks_exact_mut() {
+    let mut s: Vec<_> = (0..10).collect();
+    let mut v: Vec<_> = s.clone();
+    for len in 1..s.len() + 2 {
+        let expected: Vec<_> = v.rchunks_exact_mut(len).collect();
+        map_triples(expected.len() + 1, |i, j, k| {
+            Split::forward(s.par_rchunks_exact_mut(len), i, j, k, &expected);
+            Split::reverse(s.par_rchunks_exact_mut(len), i, j, k, &expected);
+        });
+    }
+}
+
+#[test]
+fn slice_windows() {
+    let s: Vec<_> = (0..10).collect();
+    let v: Vec<_> = s.windows(2).collect();
+    check(&v, || s.par_windows(2));
+}
+
+#[test]
+fn vec() {
+    let v: Vec<_> = (0..10).collect();
+    check(&v, || v.clone());
+}
+
+// **** Adaptors ****
+
+#[test]
+fn chain() {
+    let v: Vec<_> = (0..10).collect();
+    check(&v, || (0..5).into_par_iter().chain(5..10));
+}
+
+#[test]
+fn cloned() {
+    let v: Vec<_> = (0..10).collect();
+    check(&v, || v.par_iter().cloned());
+}
+
+#[test]
+fn copied() {
+    let v: Vec<_> = (0..10).collect();
+    check(&v, || v.par_iter().copied());
+}
+
+#[test]
+fn enumerate() {
+    let v: Vec<_> = (0..10).enumerate().collect();
+    check(&v, || (0..10).into_par_iter().enumerate());
+}
+
+#[test]
+fn step_by() {
+    let v: Vec<_> = (0..10).step_by(2).collect();
+    check(&v, || (0..10).into_par_iter().step_by(2))
+}
+
+#[test]
+fn step_by_unaligned() {
+    let v: Vec<_> = (0..10).step_by(3).collect();
+    check(&v, || (0..10).into_par_iter().step_by(3))
+}
+
+#[test]
+fn inspect() {
+    let v: Vec<_> = (0..10).collect();
+    check(&v, || (0..10).into_par_iter().inspect(|_| ()));
+}
+
+#[test]
+fn update() {
+    let v: Vec<_> = (0..10).collect();
+    check(&v, || (0..10).into_par_iter().update(|_| ()));
+}
+
+#[test]
+fn interleave() {
+    let v = [0, 10, 1, 11, 2, 12, 3, 4];
+    check(&v, || (0..5).into_par_iter().interleave(10..13));
+    check(&v[..6], || (0..3).into_par_iter().interleave(10..13));
+
+    let v = [0, 10, 1, 11, 2, 12, 13, 14];
+    check(&v, || (0..3).into_par_iter().interleave(10..15));
+}
+
+#[test]
+fn intersperse() {
+    let v = [0, -1, 1, -1, 2, -1, 3, -1, 4];
+    check(&v, || (0..5).into_par_iter().intersperse(-1));
+}
+
+#[test]
+fn chunks() {
+    let s: Vec<_> = (0..10).collect();
+    let v: Vec<_> = s.chunks(2).map(|c| c.to_vec()).collect();
+    check(&v, || s.par_iter().cloned().chunks(2));
+}
+
+#[test]
+fn map() {
+    let v: Vec<_> = (0..10).collect();
+    check(&v, || v.par_iter().map(Clone::clone));
+}
+
+#[test]
+fn map_with() {
+    let v: Vec<_> = (0..10).collect();
+    check(&v, || v.par_iter().map_with(vec![0], |_, &x| x));
+}
+
+#[test]
+fn map_init() {
+    let v: Vec<_> = (0..10).collect();
+    check(&v, || v.par_iter().map_init(|| vec![0], |_, &x| x));
+}
+
+#[test]
+fn panic_fuse() {
+    let v: Vec<_> = (0..10).collect();
+    check(&v, || (0..10).into_par_iter().panic_fuse());
+}
+
+#[test]
+fn rev() {
+    let v: Vec<_> = (0..10).rev().collect();
+    check(&v, || (0..10).into_par_iter().rev());
+}
+
+#[test]
+fn with_max_len() {
+    let v: Vec<_> = (0..10).collect();
+    check(&v, || (0..10).into_par_iter().with_max_len(1));
+}
+
+#[test]
+fn with_min_len() {
+    let v: Vec<_> = (0..10).collect();
+    check(&v, || (0..10).into_par_iter().with_min_len(1));
+}
+
+#[test]
+fn zip() {
+    let v: Vec<_> = (0..10).zip(10..20).collect();
+    check(&v, || (0..10).into_par_iter().zip(10..20));
+    check(&v[..5], || (0..5).into_par_iter().zip(10..20));
+    check(&v[..5], || (0..10).into_par_iter().zip(10..15));
+}
diff --git a/crates/rayon/tests/sort-panic-safe.rs b/crates/rayon/tests/sort-panic-safe.rs
new file mode 100644
index 0000000..95ef88d
--- /dev/null
+++ b/crates/rayon/tests/sort-panic-safe.rs
@@ -0,0 +1,164 @@
+use rand::distributions::Uniform;
+use rand::{thread_rng, Rng};
+use rayon::prelude::*;
+use std::cell::Cell;
+use std::cmp::{self, Ordering};
+use std::panic;
+use std::sync::atomic::AtomicUsize;
+use std::sync::atomic::Ordering::Relaxed;
+use std::thread;
+
+const ZERO: AtomicUsize = AtomicUsize::new(0);
+const LEN: usize = 20_000;
+
+static VERSIONS: AtomicUsize = ZERO;
+
+static DROP_COUNTS: [AtomicUsize; LEN] = [ZERO; LEN];
+
+#[derive(Clone, Eq)]
+struct DropCounter {
+    x: u32,
+    id: usize,
+    version: Cell<usize>,
+}
+
+impl PartialEq for DropCounter {
+    fn eq(&self, other: &Self) -> bool {
+        self.partial_cmp(other) == Some(Ordering::Equal)
+    }
+}
+
+impl PartialOrd for DropCounter {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        self.version.set(self.version.get() + 1);
+        other.version.set(other.version.get() + 1);
+        VERSIONS.fetch_add(2, Relaxed);
+        self.x.partial_cmp(&other.x)
+    }
+}
+
+impl Ord for DropCounter {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.partial_cmp(other).unwrap()
+    }
+}
+
+impl Drop for DropCounter {
+    fn drop(&mut self) {
+        DROP_COUNTS[self.id].fetch_add(1, Relaxed);
+        VERSIONS.fetch_sub(self.version.get(), Relaxed);
+    }
+}
+
+macro_rules! test {
+    ($input:ident, $func:ident) => {
+        let len = $input.len();
+
+        // Work out the total number of comparisons required to sort
+        // this array...
+        let count = AtomicUsize::new(0);
+        $input.to_owned().$func(|a, b| {
+            count.fetch_add(1, Relaxed);
+            a.cmp(b)
+        });
+
+        let mut panic_countdown = count.load(Relaxed);
+        let step = if len <= 100 {
+            1
+        } else {
+            cmp::max(1, panic_countdown / 10)
+        };
+
+        // ... and then panic after each `step` comparisons.
+        loop {
+            // Refresh the counters.
+            VERSIONS.store(0, Relaxed);
+            for i in 0..len {
+                DROP_COUNTS[i].store(0, Relaxed);
+            }
+
+            let v = $input.to_owned();
+            let _ = thread::spawn(move || {
+                let mut v = v;
+                let panic_countdown = AtomicUsize::new(panic_countdown);
+                v.$func(|a, b| {
+                    if panic_countdown.fetch_sub(1, Relaxed) == 1 {
+                        SILENCE_PANIC.with(|s| s.set(true));
+                        panic!();
+                    }
+                    a.cmp(b)
+                })
+            })
+            .join();
+
+            // Check that the number of things dropped is exactly
+            // what we expect (i.e. the contents of `v`).
+            for (i, c) in DROP_COUNTS.iter().enumerate().take(len) {
+                let count = c.load(Relaxed);
+                assert!(
+                    count == 1,
+                    "found drop count == {} for i == {}, len == {}",
+                    count,
+                    i,
+                    len
+                );
+            }
+
+            // Check that the most recent versions of values were dropped.
+            assert_eq!(VERSIONS.load(Relaxed), 0);
+
+            if panic_countdown < step {
+                break;
+            }
+            panic_countdown -= step;
+        }
+    };
+}
+
+thread_local!(static SILENCE_PANIC: Cell<bool> = Cell::new(false));
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
+fn sort_panic_safe() {
+    let prev = panic::take_hook();
+    panic::set_hook(Box::new(move |info| {
+        if !SILENCE_PANIC.with(Cell::get) {
+            prev(info);
+        }
+    }));
+
+    for &len in &[1, 2, 3, 4, 5, 10, 20, 100, 500, 5_000, 20_000] {
+        let len_dist = Uniform::new(0, len);
+        for &modulus in &[5, 30, 1_000, 20_000] {
+            for &has_runs in &[false, true] {
+                let mut rng = thread_rng();
+                let mut input = (0..len)
+                    .map(|id| DropCounter {
+                        x: rng.gen_range(0..modulus),
+                        id,
+                        version: Cell::new(0),
+                    })
+                    .collect::<Vec<_>>();
+
+                if has_runs {
+                    for c in &mut input {
+                        c.x = c.id as u32;
+                    }
+
+                    for _ in 0..5 {
+                        let a = rng.sample(&len_dist);
+                        let b = rng.sample(&len_dist);
+                        if a < b {
+                            input[a..b].reverse();
+                        } else {
+                            input.swap(a, b);
+                        }
+                    }
+                }
+
+                test!(input, par_sort_by);
+                test!(input, par_sort_unstable_by);
+            }
+        }
+    }
+}
diff --git a/crates/rayon/tests/str.rs b/crates/rayon/tests/str.rs
new file mode 100644
index 0000000..f73a261
--- /dev/null
+++ b/crates/rayon/tests/str.rs
@@ -0,0 +1,134 @@
+use rand::distributions::Standard;
+use rand::{Rng, SeedableRng};
+use rand_xorshift::XorShiftRng;
+use rayon::prelude::*;
+
+fn seeded_rng() -> XorShiftRng {
+    let mut seed = <XorShiftRng as SeedableRng>::Seed::default();
+    (0..).zip(seed.as_mut()).for_each(|(i, x)| *x = i);
+    XorShiftRng::from_seed(seed)
+}
+
+#[test]
+pub fn execute_strings() {
+    let rng = seeded_rng();
+    let s: String = rng.sample_iter::<char, _>(&Standard).take(1024).collect();
+
+    let par_chars: String = s.par_chars().collect();
+    assert_eq!(s, par_chars);
+
+    let par_even: String = s.par_chars().filter(|&c| (c as u32) & 1 == 0).collect();
+    let ser_even: String = s.chars().filter(|&c| (c as u32) & 1 == 0).collect();
+    assert_eq!(par_even, ser_even);
+
+    // test `FromParallelIterator<&char> for String`
+    let vchars: Vec<char> = s.par_chars().collect();
+    let par_chars: String = vchars.par_iter().collect();
+    assert_eq!(s, par_chars);
+
+    let par_bytes: Vec<u8> = s.par_bytes().collect();
+    assert_eq!(s.as_bytes(), &*par_bytes);
+
+    let par_utf16: Vec<u16> = s.par_encode_utf16().collect();
+    let ser_utf16: Vec<u16> = s.encode_utf16().collect();
+    assert_eq!(par_utf16, ser_utf16);
+
+    let par_charind: Vec<_> = s.par_char_indices().collect();
+    let ser_charind: Vec<_> = s.char_indices().collect();
+    assert_eq!(par_charind, ser_charind);
+}
+
+#[test]
+pub fn execute_strings_split() {
+    // char testcases from examples in `str::split` etc.,
+    // plus a large self-test for good measure.
+    let tests = vec![
+        ("Mary had a little lamb", ' '),
+        ("", 'X'),
+        ("lionXXtigerXleopard", 'X'),
+        ("||||a||b|c", '|'),
+        ("(///)", '/'),
+        ("010", '0'),
+        ("    a  b c", ' '),
+        ("A.B.", '.'),
+        ("A..B..", '.'),
+        ("foo\r\nbar\n\nbaz\n", '\n'),
+        ("foo\nbar\n\r\nbaz", '\n'),
+        ("A few words", ' '),
+        (" Mary   had\ta\u{2009}little  \n\t lamb", ' '),
+        (include_str!("str.rs"), ' '),
+    ];
+
+    for &(string, separator) in &tests {
+        let serial: Vec<_> = string.split(separator).collect();
+        let parallel: Vec<_> = string.par_split(separator).collect();
+        assert_eq!(serial, parallel);
+
+        let pattern: &[char] = &['\u{0}', separator, '\u{1F980}'];
+        let serial: Vec<_> = string.split(pattern).collect();
+        let parallel: Vec<_> = string.par_split(pattern).collect();
+        assert_eq!(serial, parallel);
+
+        let serial_fn: Vec<_> = string.split(|c| c == separator).collect();
+        let parallel_fn: Vec<_> = string.par_split(|c| c == separator).collect();
+        assert_eq!(serial_fn, parallel_fn);
+    }
+
+    for &(string, separator) in &tests {
+        let serial: Vec<_> = string.split_terminator(separator).collect();
+        let parallel: Vec<_> = string.par_split_terminator(separator).collect();
+        assert_eq!(serial, parallel);
+
+        let pattern: &[char] = &['\u{0}', separator, '\u{1F980}'];
+        let serial: Vec<_> = string.split_terminator(pattern).collect();
+        let parallel: Vec<_> = string.par_split_terminator(pattern).collect();
+        assert_eq!(serial, parallel);
+
+        let serial: Vec<_> = string.split_terminator(|c| c == separator).collect();
+        let parallel: Vec<_> = string.par_split_terminator(|c| c == separator).collect();
+        assert_eq!(serial, parallel);
+    }
+
+    for &(string, _) in &tests {
+        let serial: Vec<_> = string.lines().collect();
+        let parallel: Vec<_> = string.par_lines().collect();
+        assert_eq!(serial, parallel);
+    }
+
+    for &(string, _) in &tests {
+        let serial: Vec<_> = string.split_whitespace().collect();
+        let parallel: Vec<_> = string.par_split_whitespace().collect();
+        assert_eq!(serial, parallel);
+    }
+
+    // try matching separators too!
+    for &(string, separator) in &tests {
+        let serial: Vec<_> = string.matches(separator).collect();
+        let parallel: Vec<_> = string.par_matches(separator).collect();
+        assert_eq!(serial, parallel);
+
+        let pattern: &[char] = &['\u{0}', separator, '\u{1F980}'];
+        let serial: Vec<_> = string.matches(pattern).collect();
+        let parallel: Vec<_> = string.par_matches(pattern).collect();
+        assert_eq!(serial, parallel);
+
+        let serial_fn: Vec<_> = string.matches(|c| c == separator).collect();
+        let parallel_fn: Vec<_> = string.par_matches(|c| c == separator).collect();
+        assert_eq!(serial_fn, parallel_fn);
+    }
+
+    for &(string, separator) in &tests {
+        let serial: Vec<_> = string.match_indices(separator).collect();
+        let parallel: Vec<_> = string.par_match_indices(separator).collect();
+        assert_eq!(serial, parallel);
+
+        let pattern: &[char] = &['\u{0}', separator, '\u{1F980}'];
+        let serial: Vec<_> = string.match_indices(pattern).collect();
+        let parallel: Vec<_> = string.par_match_indices(pattern).collect();
+        assert_eq!(serial, parallel);
+
+        let serial_fn: Vec<_> = string.match_indices(|c| c == separator).collect();
+        let parallel_fn: Vec<_> = string.par_match_indices(|c| c == separator).collect();
+        assert_eq!(serial_fn, parallel_fn);
+    }
+}
diff --git a/crates/regex-syntax/.cargo-checksum.json b/crates/regex-syntax/.cargo-checksum.json
new file mode 100644
index 0000000..09ad1af
--- /dev/null
+++ b/crates/regex-syntax/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"64cd89fcae533a9869fd71526374a61adeb14a0e4fd29eb8b81d6744525a817c","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"6485b8ed310d3f0340bf1ad1f47645069ce4069dcc6bb46c7d5c6faf41de1fdb","README.md":"67a3e673a9da6826fd4db5be6902841c821b52b98dc22c300f6e327872392b0a","benches/bench.rs":"d2b6ae5b939abd6093064f144b981b7739d7f474ec0698a1268052fc92406635","src/ast/mod.rs":"a306c08610968d850a4666a9775fb7e8cf6646c02bab766440e6a93ab2e38f58","src/ast/parse.rs":"150b42e944f766fdca70d654dbe32f8a17498432729c78b9eb50b73ae7f91f86","src/ast/print.rs":"d12f2cc75cd62f35623e1eb7a77ab8ac804b971752082700d2c4f550f834b249","src/ast/visitor.rs":"1a7b473147e4f6b89623ef1744a9e87f665bcf160fe08a33ce8e35011811ba71","src/either.rs":"1758e3edd056884eccadd995708d1e374ba9aa65846bd0e13b1aae852607c560","src/error.rs":"b3c5903a8937d2aff229a3ec65d4571d01ec4d9874c9a242ed6562c32702bcbd","src/hir/interval.rs":"e767fed363bebe4bbda0d78b8f07e73f321eaf4f837e2d7bd14a1617387e9a89","src/hir/literal/mod.rs":"ffe9a0aff7827f97bffd29eb2f4ba96627b16953161dce6c50a2f760e76bbd98","src/hir/mod.rs":"3a6d4e0b9ec221a98fead13ba885c8a1efbbd5601e6445a2e928aa37e7716549","src/hir/print.rs":"651b5d9776532a78612a5f9081372a57bad693890639ac19e3128b4defa96662","src/hir/translate.rs":"c7cd9693f73760263fd49a968714d27e7985ebe840211b2d83bca6686b0602a8","src/hir/visitor.rs":"e5bf7f8c09f6155e59c9d676fe25437f7e3700f9bf5d91101d7e246a64c11d5a","src/lib.rs":"a004f65196dd5745b3112e4acc8c467b18495cecac64a58d6608b35de67371cb","src/parser.rs":"0dfb553a152e008b2755f115663e553ed99c4b8e6a4dcbcad1662737534de49d","src/unicode.rs":"2ad48193433fefbede0837bd645f4288f6b39b1facb59dbb7d541bce7bf19109","src/unicode_tables/LICENSE-UNICODE":"74db5baf44a41b1000312c673544b3374e4198af5605c7f9080a402cec42cfa3","src/unicode_tables/age.rs":"2a2599a4e406fbbd0efd16aa6ce385c3f97b87c34820d6686a9f9113a5231c67","src/unicode_tables/case_folding_simple.rs":"9583803d4a10486da372b76979dbd26349b40766229467238eff972c1d78e47b","src/unicode_tables/general_category.rs":"36a93ba1cdeed96a00ff29a5ab5afd2c578a89541bf4dd8b18478146cebda0aa","src/unicode_tables/grapheme_cluster_break.rs":"39c388e9805a8391d3d3e69d74d831ce4fb99aa7e13e52c64dd2bd16d4765301","src/unicode_tables/mod.rs":"26c837099cd934c8062e24bc9a0aaecf15fe1de03f9c6da3f3e1e5ac3ca24bee","src/unicode_tables/perl_decimal.rs":"a98ea4afe71c2947023ae12bd25c46bf4c7de48eeb40979eca5c96ba62cee02e","src/unicode_tables/perl_space.rs":"ea2b3b84b4a48334082dadc6c37d9fcc9c9ded84b40e8f5c9c9314898638967e","src/unicode_tables/perl_word.rs":"6f1156bd6af32151ecffea4abe07a38fa04b1fc1b227ec1a8dac5d5f08d9d74b","src/unicode_tables/property_bool.rs":"0bd64f6e3228eaecf47824e238bdf1f8a9eef113ace6e790a57f045a8106701c","src/unicode_tables/property_names.rs":"5ca25437927eb70c62adf7d038e99a601cfb8a718677fd6de832589664d3c481","src/unicode_tables/property_values.rs":"5b4cc02392d382cf7af60455fc87b9980e97409b62a4b8d6c5843190d2e2d21d","src/unicode_tables/script.rs":"ea1d771b6d0a4b12d143f9bad2ea9342a0887878cbbe3c11262b6eabedaf2dd4","src/unicode_tables/script_extension.rs":"beeb8349703d903ff861beb8401bfd2599e457dc25df872e69d6ad1615f8b5e9","src/unicode_tables/sentence_break.rs":"2befe2a27cc4e8aecb624e310ef9f371462470dd3b2f572cec1f5873a5e30aa9","src/unicode_tables/word_break.rs":"94679177731b515f0c360eff394286a1f99b59527bdbc826cbf51d32f9666187","src/utf8.rs":"de854b3bfb3f7dbefc422f6a25935aaeef55ead2c35386c712a1fe9bf81a7b6f","test":"8a9bd1bd9fb389e08288f951319a9bbb0d4c5284a2ba63cbdab7f6afa2c2f76e"},"package":"f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"}
\ No newline at end of file
diff --git a/crates/regex-syntax/Android.bp b/crates/regex-syntax/Android.bp
new file mode 100644
index 0000000..45632ff
--- /dev/null
+++ b/crates/regex-syntax/Android.bp
@@ -0,0 +1,68 @@
+// This file is generated by cargo_embargo.
+// Do not modify this file because the changes will be overridden on upgrade.
+
+package {
+    default_applicable_licenses: ["external_rust_crates_regex-syntax_license"],
+    default_team: "trendy_team_android_rust",
+}
+
+license {
+    name: "external_rust_crates_regex-syntax_license",
+    visibility: [":__subpackages__"],
+    license_kinds: ["SPDX-license-identifier-Apache-2.0"],
+    license_text: ["LICENSE"],
+}
+
+rust_library {
+    name: "libregex_syntax",
+    host_supported: true,
+    crate_name: "regex_syntax",
+    cargo_env_compat: true,
+    cargo_pkg_version: "0.6.29",
+    crate_root: "src/lib.rs",
+    edition: "2018",
+    features: [
+        "default",
+        "unicode",
+        "unicode-age",
+        "unicode-bool",
+        "unicode-case",
+        "unicode-gencat",
+        "unicode-perl",
+        "unicode-script",
+        "unicode-segment",
+    ],
+    apex_available: [
+        "//apex_available:platform",
+        "com.android.compos",
+        "com.android.virt",
+    ],
+    product_available: true,
+    vendor_available: true,
+}
+
+rust_test {
+    name: "regex-syntax_test_src_lib",
+    host_supported: true,
+    crate_name: "regex_syntax",
+    cargo_env_compat: true,
+    cargo_pkg_version: "0.6.29",
+    crate_root: "src/lib.rs",
+    test_suites: ["general-tests"],
+    auto_gen_config: true,
+    test_options: {
+        unit_test: true,
+    },
+    edition: "2018",
+    features: [
+        "default",
+        "unicode",
+        "unicode-age",
+        "unicode-bool",
+        "unicode-case",
+        "unicode-gencat",
+        "unicode-perl",
+        "unicode-script",
+        "unicode-segment",
+    ],
+}
diff --git a/crates/regex-syntax/Cargo.lock b/crates/regex-syntax/Cargo.lock
new file mode 100644
index 0000000..819373f
--- /dev/null
+++ b/crates/regex-syntax/Cargo.lock
@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "regex-syntax"
+version = "0.6.29"
diff --git a/crates/regex-syntax/Cargo.toml b/crates/regex-syntax/Cargo.toml
new file mode 100644
index 0000000..72e9856
--- /dev/null
+++ b/crates/regex-syntax/Cargo.toml
@@ -0,0 +1,41 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2018"
+name = "regex-syntax"
+version = "0.6.29"
+authors = ["The Rust Project Developers"]
+description = "A regular expression parser."
+homepage = "https://github.com/rust-lang/regex"
+documentation = "https://docs.rs/regex-syntax"
+readme = "README.md"
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/rust-lang/regex"
+
+[features]
+default = ["unicode"]
+unicode = [
+    "unicode-age",
+    "unicode-bool",
+    "unicode-case",
+    "unicode-gencat",
+    "unicode-perl",
+    "unicode-script",
+    "unicode-segment",
+]
+unicode-age = []
+unicode-bool = []
+unicode-case = []
+unicode-gencat = []
+unicode-perl = []
+unicode-script = []
+unicode-segment = []
diff --git a/crates/regex-syntax/LICENSE b/crates/regex-syntax/LICENSE
new file mode 120000
index 0000000..6b579aa
--- /dev/null
+++ b/crates/regex-syntax/LICENSE
@@ -0,0 +1 @@
+LICENSE-APACHE
\ No newline at end of file
diff --git a/crates/regex-syntax/LICENSE-APACHE b/crates/regex-syntax/LICENSE-APACHE
new file mode 100644
index 0000000..16fe87b
--- /dev/null
+++ b/crates/regex-syntax/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/crates/regex-syntax/LICENSE-MIT b/crates/regex-syntax/LICENSE-MIT
new file mode 100644
index 0000000..39d4bdb
--- /dev/null
+++ b/crates/regex-syntax/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2014 The Rust Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/crates/regex-syntax/METADATA b/crates/regex-syntax/METADATA
new file mode 100644
index 0000000..5af87a5
--- /dev/null
+++ b/crates/regex-syntax/METADATA
@@ -0,0 +1,23 @@
+# This project was upgraded with external_updater.
+# Usage: tools/external_updater/updater.sh update rust/crates/regex-syntax
+# For more info, check https://cs.android.com/android/platform/superproject/+/master:tools/external_updater/README.md
+
+name: "regex-syntax"
+description: "A regular expression parser."
+third_party {
+  url {
+    type: HOMEPAGE
+    value: "https://crates.io/crates/regex-syntax"
+  }
+  url {
+    type: ARCHIVE
+    value: "https://static.crates.io/crates/regex-syntax/regex-syntax-0.6.29.crate"
+  }
+  version: "0.6.29"
+  license_type: NOTICE
+  last_upgrade_date {
+    year: 2023
+    month: 4
+    day: 3
+  }
+}
diff --git a/crates/regex-syntax/MODULE_LICENSE_APACHE2 b/crates/regex-syntax/MODULE_LICENSE_APACHE2
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/crates/regex-syntax/MODULE_LICENSE_APACHE2
diff --git a/crates/regex-syntax/README.md b/crates/regex-syntax/README.md
new file mode 100644
index 0000000..592f842
--- /dev/null
+++ b/crates/regex-syntax/README.md
@@ -0,0 +1,98 @@
+regex-syntax
+============
+This crate provides a robust regular expression parser.
+
+[![Build status](https://github.com/rust-lang/regex/workflows/ci/badge.svg)](https://github.com/rust-lang/regex/actions)
+[![Crates.io](https://img.shields.io/crates/v/regex-syntax.svg)](https://crates.io/crates/regex-syntax)
+[![Rust](https://img.shields.io/badge/rust-1.28.0%2B-blue.svg?maxAge=3600)](https://github.com/rust-lang/regex)
+
+
+### Documentation
+
+https://docs.rs/regex-syntax
+
+
+### Overview
+
+There are two primary types exported by this crate: `Ast` and `Hir`. The former
+is a faithful abstract syntax of a regular expression, and can convert regular
+expressions back to their concrete syntax while mostly preserving its original
+form. The latter type is a high level intermediate representation of a regular
+expression that is amenable to analysis and compilation into byte codes or
+automata. An `Hir` achieves this by drastically simplifying the syntactic
+structure of the regular expression. While an `Hir` can be converted back to
+its equivalent concrete syntax, the result is unlikely to resemble the original
+concrete syntax that produced the `Hir`.
+
+
+### Example
+
+This example shows how to parse a pattern string into its HIR:
+
+```rust
+use regex_syntax::Parser;
+use regex_syntax::hir::{self, Hir};
+
+let hir = Parser::new().parse("a|b").unwrap();
+assert_eq!(hir, Hir::alternation(vec![
+    Hir::literal(hir::Literal::Unicode('a')),
+    Hir::literal(hir::Literal::Unicode('b')),
+]));
+```
+
+
+### Safety
+
+This crate has no `unsafe` code and sets `forbid(unsafe_code)`. While it's
+possible this crate could use `unsafe` code in the future, the standard
+for doing so is extremely high. In general, most code in this crate is not
+performance critical, since it tends to be dwarfed by the time it takes to
+compile a regular expression into an automaton. Therefore, there is little need
+for extreme optimization, and therefore, use of `unsafe`.
+
+The standard for using `unsafe` in this crate is extremely high because this
+crate is intended to be reasonably safe to use with user supplied regular
+expressions. Therefore, while there may be bugs in the regex parser itself,
+they should _never_ result in memory unsafety unless there is either a bug
+in the compiler or the standard library. (Since `regex-syntax` has zero
+dependencies.)
+
+
+### Crate features
+
+By default, this crate bundles a fairly large amount of Unicode data tables
+(a source size of ~750KB). Because of their large size, one can disable some
+or all of these data tables. If a regular expression attempts to use Unicode
+data that is not available, then an error will occur when translating the `Ast`
+to the `Hir`.
+
+The full set of features one can disable are
+[in the "Crate features" section of the documentation](https://docs.rs/regex-syntax/*/#crate-features).
+
+
+### Testing
+
+Simply running `cargo test` will give you very good coverage. However, because
+of the large number of features exposed by this crate, a `test` script is
+included in this directory which will test several feature combinations. This
+is the same script that is run in CI.
+
+
+### Motivation
+
+The primary purpose of this crate is to provide the parser used by `regex`.
+Specifically, this crate is treated as an implementation detail of the `regex`,
+and is primarily developed for the needs of `regex`.
+
+Since this crate is an implementation detail of `regex`, it may experience
+breaking change releases at a different cadence from `regex`. This is only
+possible because this crate is _not_ a public dependency of `regex`.
+
+Another consequence of this de-coupling is that there is no direct way to
+compile a `regex::Regex` from a `regex_syntax::hir::Hir`. Instead, one must
+first convert the `Hir` to a string (via its `std::fmt::Display`) and then
+compile that via `Regex::new`. While this does repeat some work, compilation
+typically takes much longer than parsing.
+
+Stated differently, the coupling between `regex` and `regex-syntax` exists only
+at the level of the concrete syntax.
diff --git a/crates/regex-syntax/TEST_MAPPING b/crates/regex-syntax/TEST_MAPPING
new file mode 100644
index 0000000..afa287b
--- /dev/null
+++ b/crates/regex-syntax/TEST_MAPPING
@@ -0,0 +1,51 @@
+// Generated by update_crate_tests.py for tests that depend on this crate.
+{
+  "imports": [
+    {
+      "path": "external/rust/crates/base64"
+    },
+    {
+      "path": "external/rust/crates/clap/2.33.3"
+    },
+    {
+      "path": "external/rust/crates/libsqlite3-sys"
+    },
+    {
+      "path": "external/rust/crates/once_cell"
+    },
+    {
+      "path": "external/rust/crates/regex"
+    },
+    {
+      "path": "external/rust/crates/tinytemplate"
+    },
+    {
+      "path": "external/rust/crates/tinyvec"
+    },
+    {
+      "path": "external/rust/crates/unicode-xid"
+    },
+    {
+      "path": "packages/modules/Virtualization/virtualizationmanager"
+    },
+    {
+      "path": "system/keymint/hal"
+    },
+    {
+      "path": "system/security/keystore2"
+    },
+    {
+      "path": "system/security/keystore2/legacykeystore"
+    }
+  ],
+  "presubmit": [
+    {
+      "name": "regex-syntax_test_src_lib"
+    }
+  ],
+  "presubmit-rust": [
+    {
+      "name": "regex-syntax_test_src_lib"
+    }
+  ]
+}
diff --git a/crates/regex-syntax/benches/bench.rs b/crates/regex-syntax/benches/bench.rs
new file mode 100644
index 0000000..d4703d4
--- /dev/null
+++ b/crates/regex-syntax/benches/bench.rs
@@ -0,0 +1,63 @@
+#![feature(test)]
+
+extern crate test;
+
+use regex_syntax::Parser;
+use test::Bencher;
+
+#[bench]
+fn parse_simple1(b: &mut Bencher) {
+    b.iter(|| {
+        let re = r"^bc(d|e)*$";
+        Parser::new().parse(re).unwrap()
+    });
+}
+
+#[bench]
+fn parse_simple2(b: &mut Bencher) {
+    b.iter(|| {
+        let re = r"'[a-zA-Z_][a-zA-Z0-9_]*(')\b";
+        Parser::new().parse(re).unwrap()
+    });
+}
+
+#[bench]
+fn parse_small1(b: &mut Bencher) {
+    b.iter(|| {
+        let re = r"\p{L}|\p{N}|\s|.|\d";
+        Parser::new().parse(re).unwrap()
+    });
+}
+
+#[bench]
+fn parse_medium1(b: &mut Bencher) {
+    b.iter(|| {
+        let re = r"\pL\p{Greek}\p{Hiragana}\p{Alphabetic}\p{Hebrew}\p{Arabic}";
+        Parser::new().parse(re).unwrap()
+    });
+}
+
+#[bench]
+fn parse_medium2(b: &mut Bencher) {
+    b.iter(|| {
+        let re = r"\s\S\w\W\d\D";
+        Parser::new().parse(re).unwrap()
+    });
+}
+
+#[bench]
+fn parse_medium3(b: &mut Bencher) {
+    b.iter(|| {
+        let re =
+            r"\p{age:3.2}\p{hira}\p{scx:hira}\p{alphabetic}\p{sc:Greek}\pL";
+        Parser::new().parse(re).unwrap()
+    });
+}
+
+#[bench]
+fn parse_huge(b: &mut Bencher) {
+    b.iter(|| {
+        let re = r"\p{L}{100}";
+        Parser::new().parse(re).unwrap()
+    });
+}
diff --git a/crates/regex-syntax/cargo_embargo.json b/crates/regex-syntax/cargo_embargo.json
new file mode 100644
index 0000000..a76efe6
--- /dev/null
+++ b/crates/regex-syntax/cargo_embargo.json
@@ -0,0 +1,9 @@
+{
+  "apex_available": [
+    "//apex_available:platform",
+    "com.android.compos",
+    "com.android.virt"
+  ],
+  "run_cargo": false,
+  "tests": true
+}
diff --git a/crates/regex-syntax/src/ast/mod.rs b/crates/regex-syntax/src/ast/mod.rs
new file mode 100644
index 0000000..9db9afa
--- /dev/null
+++ b/crates/regex-syntax/src/ast/mod.rs
@@ -0,0 +1,1513 @@
+/*!
+Defines an abstract syntax for regular expressions.
+*/
+
+use std::cmp::Ordering;
+use std::error;
+use std::fmt;
+
+pub use crate::ast::visitor::{visit, Visitor};
+
+pub mod parse;
+pub mod print;
+mod visitor;
+
+/// An error that occurred while parsing a regular expression into an abstract
+/// syntax tree.
+///
+/// Note that not all ASTs represents a valid regular expression. For example,
+/// an AST is constructed without error for `\p{Quux}`, but `Quux` is not a
+/// valid Unicode property name. That particular error is reported when
+/// translating an AST to the high-level intermediate representation (`HIR`).
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Error {
+    /// The kind of error.
+    kind: ErrorKind,
+    /// The original pattern that the parser generated the error from. Every
+    /// span in an error is a valid range into this string.
+    pattern: String,
+    /// The span of this error.
+    span: Span,
+}
+
+impl Error {
+    /// Return the type of this error.
+    pub fn kind(&self) -> &ErrorKind {
+        &self.kind
+    }
+
+    /// The original pattern string in which this error occurred.
+    ///
+    /// Every span reported by this error is reported in terms of this string.
+    pub fn pattern(&self) -> &str {
+        &self.pattern
+    }
+
+    /// Return the span at which this error occurred.
+    pub fn span(&self) -> &Span {
+        &self.span
+    }
+
+    /// Return an auxiliary span. This span exists only for some errors that
+    /// benefit from being able to point to two locations in the original
+    /// regular expression. For example, "duplicate" errors will have the
+    /// main error position set to the duplicate occurrence while its
+    /// auxiliary span will be set to the initial occurrence.
+    pub fn auxiliary_span(&self) -> Option<&Span> {
+        use self::ErrorKind::*;
+        match self.kind {
+            FlagDuplicate { ref original } => Some(original),
+            FlagRepeatedNegation { ref original, .. } => Some(original),
+            GroupNameDuplicate { ref original, .. } => Some(original),
+            _ => None,
+        }
+    }
+}
+
+/// The type of an error that occurred while building an AST.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum ErrorKind {
+    /// The capturing group limit was exceeded.
+    ///
+    /// Note that this represents a limit on the total number of capturing
+    /// groups in a regex and not necessarily the number of nested capturing
+    /// groups. That is, the nest limit can be low and it is still possible for
+    /// this error to occur.
+    CaptureLimitExceeded,
+    /// An invalid escape sequence was found in a character class set.
+    ClassEscapeInvalid,
+    /// An invalid character class range was found. An invalid range is any
+    /// range where the start is greater than the end.
+    ClassRangeInvalid,
+    /// An invalid range boundary was found in a character class. Range
+    /// boundaries must be a single literal codepoint, but this error indicates
+    /// that something else was found, such as a nested class.
+    ClassRangeLiteral,
+    /// An opening `[` was found with no corresponding closing `]`.
+    ClassUnclosed,
+    /// Note that this error variant is no longer used. Namely, a decimal
+    /// number can only appear as a repetition quantifier. When the number
+    /// in a repetition quantifier is empty, then it gets its own specialized
+    /// error, `RepetitionCountDecimalEmpty`.
+    DecimalEmpty,
+    /// An invalid decimal number was given where one was expected.
+    DecimalInvalid,
+    /// A bracketed hex literal was empty.
+    EscapeHexEmpty,
+    /// A bracketed hex literal did not correspond to a Unicode scalar value.
+    EscapeHexInvalid,
+    /// An invalid hexadecimal digit was found.
+    EscapeHexInvalidDigit,
+    /// EOF was found before an escape sequence was completed.
+    EscapeUnexpectedEof,
+    /// An unrecognized escape sequence.
+    EscapeUnrecognized,
+    /// A dangling negation was used when setting flags, e.g., `i-`.
+    FlagDanglingNegation,
+    /// A flag was used twice, e.g., `i-i`.
+    FlagDuplicate {
+        /// The position of the original flag. The error position
+        /// points to the duplicate flag.
+        original: Span,
+    },
+    /// The negation operator was used twice, e.g., `-i-s`.
+    FlagRepeatedNegation {
+        /// The position of the original negation operator. The error position
+        /// points to the duplicate negation operator.
+        original: Span,
+    },
+    /// Expected a flag but got EOF, e.g., `(?`.
+    FlagUnexpectedEof,
+    /// Unrecognized flag, e.g., `a`.
+    FlagUnrecognized,
+    /// A duplicate capture name was found.
+    GroupNameDuplicate {
+        /// The position of the initial occurrence of the capture name. The
+        /// error position itself points to the duplicate occurrence.
+        original: Span,
+    },
+    /// A capture group name is empty, e.g., `(?P<>abc)`.
+    GroupNameEmpty,
+    /// An invalid character was seen for a capture group name. This includes
+    /// errors where the first character is a digit (even though subsequent
+    /// characters are allowed to be digits).
+    GroupNameInvalid,
+    /// A closing `>` could not be found for a capture group name.
+    GroupNameUnexpectedEof,
+    /// An unclosed group, e.g., `(ab`.
+    ///
+    /// The span of this error corresponds to the unclosed parenthesis.
+    GroupUnclosed,
+    /// An unopened group, e.g., `ab)`.
+    GroupUnopened,
+    /// The nest limit was exceeded. The limit stored here is the limit
+    /// configured in the parser.
+    NestLimitExceeded(u32),
+    /// The range provided in a counted repetition operator is invalid. The
+    /// range is invalid if the start is greater than the end.
+    RepetitionCountInvalid,
+    /// An opening `{` was not followed by a valid decimal value.
+    /// For example, `x{}` or `x{]}` would fail.
+    RepetitionCountDecimalEmpty,
+    /// An opening `{` was found with no corresponding closing `}`.
+    RepetitionCountUnclosed,
+    /// A repetition operator was applied to a missing sub-expression. This
+    /// occurs, for example, in the regex consisting of just a `*` or even
+    /// `(?i)*`. It is, however, possible to create a repetition operating on
+    /// an empty sub-expression. For example, `()*` is still considered valid.
+    RepetitionMissing,
+    /// The Unicode class is not valid. This typically occurs when a `\p` is
+    /// followed by something other than a `{`.
+    UnicodeClassInvalid,
+    /// When octal support is disabled, this error is produced when an octal
+    /// escape is used. The octal escape is assumed to be an invocation of
+    /// a backreference, which is the common case.
+    UnsupportedBackreference,
+    /// When syntax similar to PCRE's look-around is used, this error is
+    /// returned. Some example syntaxes that are rejected include, but are
+    /// not necessarily limited to, `(?=re)`, `(?!re)`, `(?<=re)` and
+    /// `(?<!re)`. Note that all of these syntaxes are otherwise invalid; this
+    /// error is used to improve the user experience.
+    UnsupportedLookAround,
+    /// Hints that destructuring should not be exhaustive.
+    ///
+    /// This enum may grow additional variants, so this makes sure clients
+    /// don't count on exhaustive matching. (Otherwise, adding a new variant
+    /// could break existing code.)
+    #[doc(hidden)]
+    __Nonexhaustive,
+}
+
+impl error::Error for Error {
+    // TODO: Remove this method entirely on the next breaking semver release.
+    #[allow(deprecated)]
+    fn description(&self) -> &str {
+        use self::ErrorKind::*;
+        match self.kind {
+            CaptureLimitExceeded => "capture group limit exceeded",
+            ClassEscapeInvalid => "invalid escape sequence in character class",
+            ClassRangeInvalid => "invalid character class range",
+            ClassRangeLiteral => "invalid range boundary, must be a literal",
+            ClassUnclosed => "unclosed character class",
+            DecimalEmpty => "empty decimal literal",
+            DecimalInvalid => "invalid decimal literal",
+            EscapeHexEmpty => "empty hexadecimal literal",
+            EscapeHexInvalid => "invalid hexadecimal literal",
+            EscapeHexInvalidDigit => "invalid hexadecimal digit",
+            EscapeUnexpectedEof => "unexpected eof (escape sequence)",
+            EscapeUnrecognized => "unrecognized escape sequence",
+            FlagDanglingNegation => "dangling flag negation operator",
+            FlagDuplicate { .. } => "duplicate flag",
+            FlagRepeatedNegation { .. } => "repeated negation",
+            FlagUnexpectedEof => "unexpected eof (flag)",
+            FlagUnrecognized => "unrecognized flag",
+            GroupNameDuplicate { .. } => "duplicate capture group name",
+            GroupNameEmpty => "empty capture group name",
+            GroupNameInvalid => "invalid capture group name",
+            GroupNameUnexpectedEof => "unclosed capture group name",
+            GroupUnclosed => "unclosed group",
+            GroupUnopened => "unopened group",
+            NestLimitExceeded(_) => "nest limit exceeded",
+            RepetitionCountInvalid => "invalid repetition count range",
+            RepetitionCountUnclosed => "unclosed counted repetition",
+            RepetitionMissing => "repetition operator missing expression",
+            UnicodeClassInvalid => "invalid Unicode character class",
+            UnsupportedBackreference => "backreferences are not supported",
+            UnsupportedLookAround => "look-around is not supported",
+            _ => unreachable!(),
+        }
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        crate::error::Formatter::from(self).fmt(f)
+    }
+}
+
+impl fmt::Display for ErrorKind {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use self::ErrorKind::*;
+        match *self {
+            CaptureLimitExceeded => write!(
+                f,
+                "exceeded the maximum number of \
+                 capturing groups ({})",
+                ::std::u32::MAX
+            ),
+            ClassEscapeInvalid => {
+                write!(f, "invalid escape sequence found in character class")
+            }
+            ClassRangeInvalid => write!(
+                f,
+                "invalid character class range, \
+                 the start must be <= the end"
+            ),
+            ClassRangeLiteral => {
+                write!(f, "invalid range boundary, must be a literal")
+            }
+            ClassUnclosed => write!(f, "unclosed character class"),
+            DecimalEmpty => write!(f, "decimal literal empty"),
+            DecimalInvalid => write!(f, "decimal literal invalid"),
+            EscapeHexEmpty => write!(f, "hexadecimal literal empty"),
+            EscapeHexInvalid => {
+                write!(f, "hexadecimal literal is not a Unicode scalar value")
+            }
+            EscapeHexInvalidDigit => write!(f, "invalid hexadecimal digit"),
+            EscapeUnexpectedEof => write!(
+                f,
+                "incomplete escape sequence, \
+                 reached end of pattern prematurely"
+            ),
+            EscapeUnrecognized => write!(f, "unrecognized escape sequence"),
+            FlagDanglingNegation => {
+                write!(f, "dangling flag negation operator")
+            }
+            FlagDuplicate { .. } => write!(f, "duplicate flag"),
+            FlagRepeatedNegation { .. } => {
+                write!(f, "flag negation operator repeated")
+            }
+            FlagUnexpectedEof => {
+                write!(f, "expected flag but got end of regex")
+            }
+            FlagUnrecognized => write!(f, "unrecognized flag"),
+            GroupNameDuplicate { .. } => {
+                write!(f, "duplicate capture group name")
+            }
+            GroupNameEmpty => write!(f, "empty capture group name"),
+            GroupNameInvalid => write!(f, "invalid capture group character"),
+            GroupNameUnexpectedEof => write!(f, "unclosed capture group name"),
+            GroupUnclosed => write!(f, "unclosed group"),
+            GroupUnopened => write!(f, "unopened group"),
+            NestLimitExceeded(limit) => write!(
+                f,
+                "exceed the maximum number of \
+                 nested parentheses/brackets ({})",
+                limit
+            ),
+            RepetitionCountInvalid => write!(
+                f,
+                "invalid repetition count range, \
+                 the start must be <= the end"
+            ),
+            RepetitionCountDecimalEmpty => {
+                write!(f, "repetition quantifier expects a valid decimal")
+            }
+            RepetitionCountUnclosed => {
+                write!(f, "unclosed counted repetition")
+            }
+            RepetitionMissing => {
+                write!(f, "repetition operator missing expression")
+            }
+            UnicodeClassInvalid => {
+                write!(f, "invalid Unicode character class")
+            }
+            UnsupportedBackreference => {
+                write!(f, "backreferences are not supported")
+            }
+            UnsupportedLookAround => write!(
+                f,
+                "look-around, including look-ahead and look-behind, \
+                 is not supported"
+            ),
+            _ => unreachable!(),
+        }
+    }
+}
+
+/// Span represents the position information of a single AST item.
+///
+/// All span positions are absolute byte offsets that can be used on the
+/// original regular expression that was parsed.
+#[derive(Clone, Copy, Eq, PartialEq)]
+pub struct Span {
+    /// The start byte offset.
+    pub start: Position,
+    /// The end byte offset.
+    pub end: Position,
+}
+
+impl fmt::Debug for Span {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "Span({:?}, {:?})", self.start, self.end)
+    }
+}
+
+impl Ord for Span {
+    fn cmp(&self, other: &Span) -> Ordering {
+        (&self.start, &self.end).cmp(&(&other.start, &other.end))
+    }
+}
+
+impl PartialOrd for Span {
+    fn partial_cmp(&self, other: &Span) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+/// A single position in a regular expression.
+///
+/// A position encodes one half of a span, and include the byte offset, line
+/// number and column number.
+#[derive(Clone, Copy, Eq, PartialEq)]
+pub struct Position {
+    /// The absolute offset of this position, starting at `0` from the
+    /// beginning of the regular expression pattern string.
+    pub offset: usize,
+    /// The line number, starting at `1`.
+    pub line: usize,
+    /// The approximate column number, starting at `1`.
+    pub column: usize,
+}
+
+impl fmt::Debug for Position {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "Position(o: {:?}, l: {:?}, c: {:?})",
+            self.offset, self.line, self.column
+        )
+    }
+}
+
+impl Ord for Position {
+    fn cmp(&self, other: &Position) -> Ordering {
+        self.offset.cmp(&other.offset)
+    }
+}
+
+impl PartialOrd for Position {
+    fn partial_cmp(&self, other: &Position) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Span {
+    /// Create a new span with the given positions.
+    pub fn new(start: Position, end: Position) -> Span {
+        Span { start, end }
+    }
+
+    /// Create a new span using the given position as the start and end.
+    pub fn splat(pos: Position) -> Span {
+        Span::new(pos, pos)
+    }
+
+    /// Create a new span by replacing the starting the position with the one
+    /// given.
+    pub fn with_start(self, pos: Position) -> Span {
+        Span { start: pos, ..self }
+    }
+
+    /// Create a new span by replacing the ending the position with the one
+    /// given.
+    pub fn with_end(self, pos: Position) -> Span {
+        Span { end: pos, ..self }
+    }
+
+    /// Returns true if and only if this span occurs on a single line.
+    pub fn is_one_line(&self) -> bool {
+        self.start.line == self.end.line
+    }
+
+    /// Returns true if and only if this span is empty. That is, it points to
+    /// a single position in the concrete syntax of a regular expression.
+    pub fn is_empty(&self) -> bool {
+        self.start.offset == self.end.offset
+    }
+}
+
+impl Position {
+    /// Create a new position with the given information.
+    ///
+    /// `offset` is the absolute offset of the position, starting at `0` from
+    /// the beginning of the regular expression pattern string.
+    ///
+    /// `line` is the line number, starting at `1`.
+    ///
+    /// `column` is the approximate column number, starting at `1`.
+    pub fn new(offset: usize, line: usize, column: usize) -> Position {
+        Position { offset, line, column }
+    }
+}
+
+/// An abstract syntax tree for a singular expression along with comments
+/// found.
+///
+/// Comments are not stored in the tree itself to avoid complexity. Each
+/// comment contains a span of precisely where it occurred in the original
+/// regular expression.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct WithComments {
+    /// The actual ast.
+    pub ast: Ast,
+    /// All comments found in the original regular expression.
+    pub comments: Vec<Comment>,
+}
+
+/// A comment from a regular expression with an associated span.
+///
+/// A regular expression can only contain comments when the `x` flag is
+/// enabled.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Comment {
+    /// The span of this comment, including the beginning `#` and ending `\n`.
+    pub span: Span,
+    /// The comment text, starting with the first character following the `#`
+    /// and ending with the last character preceding the `\n`.
+    pub comment: String,
+}
+
+/// An abstract syntax tree for a single regular expression.
+///
+/// An `Ast`'s `fmt::Display` implementation uses constant stack space and heap
+/// space proportional to the size of the `Ast`.
+///
+/// This type defines its own destructor that uses constant stack space and
+/// heap space proportional to the size of the `Ast`.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum Ast {
+    /// An empty regex that matches everything.
+    Empty(Span),
+    /// A set of flags, e.g., `(?is)`.
+    Flags(SetFlags),
+    /// A single character literal, which includes escape sequences.
+    Literal(Literal),
+    /// The "any character" class.
+    Dot(Span),
+    /// A single zero-width assertion.
+    Assertion(Assertion),
+    /// A single character class. This includes all forms of character classes
+    /// except for `.`. e.g., `\d`, `\pN`, `[a-z]` and `[[:alpha:]]`.
+    Class(Class),
+    /// A repetition operator applied to an arbitrary regular expression.
+    Repetition(Repetition),
+    /// A grouped regular expression.
+    Group(Group),
+    /// An alternation of regular expressions.
+    Alternation(Alternation),
+    /// A concatenation of regular expressions.
+    Concat(Concat),
+}
+
+impl Ast {
+    /// Return the span of this abstract syntax tree.
+    pub fn span(&self) -> &Span {
+        match *self {
+            Ast::Empty(ref span) => span,
+            Ast::Flags(ref x) => &x.span,
+            Ast::Literal(ref x) => &x.span,
+            Ast::Dot(ref span) => span,
+            Ast::Assertion(ref x) => &x.span,
+            Ast::Class(ref x) => x.span(),
+            Ast::Repetition(ref x) => &x.span,
+            Ast::Group(ref x) => &x.span,
+            Ast::Alternation(ref x) => &x.span,
+            Ast::Concat(ref x) => &x.span,
+        }
+    }
+
+    /// Return true if and only if this Ast is empty.
+    pub fn is_empty(&self) -> bool {
+        match *self {
+            Ast::Empty(_) => true,
+            _ => false,
+        }
+    }
+
+    /// Returns true if and only if this AST has any (including possibly empty)
+    /// subexpressions.
+    fn has_subexprs(&self) -> bool {
+        match *self {
+            Ast::Empty(_)
+            | Ast::Flags(_)
+            | Ast::Literal(_)
+            | Ast::Dot(_)
+            | Ast::Assertion(_) => false,
+            Ast::Class(_)
+            | Ast::Repetition(_)
+            | Ast::Group(_)
+            | Ast::Alternation(_)
+            | Ast::Concat(_) => true,
+        }
+    }
+}
+
+/// Print a display representation of this Ast.
+///
+/// This does not preserve any of the original whitespace formatting that may
+/// have originally been present in the concrete syntax from which this Ast
+/// was generated.
+///
+/// This implementation uses constant stack space and heap space proportional
+/// to the size of the `Ast`.
+impl fmt::Display for Ast {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use crate::ast::print::Printer;
+        Printer::new().print(self, f)
+    }
+}
+
+/// An alternation of regular expressions.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Alternation {
+    /// The span of this alternation.
+    pub span: Span,
+    /// The alternate regular expressions.
+    pub asts: Vec<Ast>,
+}
+
+impl Alternation {
+    /// Return this alternation as an AST.
+    ///
+    /// If this alternation contains zero ASTs, then Ast::Empty is
+    /// returned. If this alternation contains exactly 1 AST, then the
+    /// corresponding AST is returned. Otherwise, Ast::Alternation is returned.
+    pub fn into_ast(mut self) -> Ast {
+        match self.asts.len() {
+            0 => Ast::Empty(self.span),
+            1 => self.asts.pop().unwrap(),
+            _ => Ast::Alternation(self),
+        }
+    }
+}
+
+/// A concatenation of regular expressions.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Concat {
+    /// The span of this concatenation.
+    pub span: Span,
+    /// The concatenation regular expressions.
+    pub asts: Vec<Ast>,
+}
+
+impl Concat {
+    /// Return this concatenation as an AST.
+    ///
+    /// If this concatenation contains zero ASTs, then Ast::Empty is
+    /// returned. If this concatenation contains exactly 1 AST, then the
+    /// corresponding AST is returned. Otherwise, Ast::Concat is returned.
+    pub fn into_ast(mut self) -> Ast {
+        match self.asts.len() {
+            0 => Ast::Empty(self.span),
+            1 => self.asts.pop().unwrap(),
+            _ => Ast::Concat(self),
+        }
+    }
+}
+
+/// A single literal expression.
+///
+/// A literal corresponds to a single Unicode scalar value. Literals may be
+/// represented in their literal form, e.g., `a` or in their escaped form,
+/// e.g., `\x61`.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Literal {
+    /// The span of this literal.
+    pub span: Span,
+    /// The kind of this literal.
+    pub kind: LiteralKind,
+    /// The Unicode scalar value corresponding to this literal.
+    pub c: char,
+}
+
+impl Literal {
+    /// If this literal was written as a `\x` hex escape, then this returns
+    /// the corresponding byte value. Otherwise, this returns `None`.
+    pub fn byte(&self) -> Option<u8> {
+        let short_hex = LiteralKind::HexFixed(HexLiteralKind::X);
+        if self.c as u32 <= 255 && self.kind == short_hex {
+            Some(self.c as u8)
+        } else {
+            None
+        }
+    }
+}
+
+/// The kind of a single literal expression.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum LiteralKind {
+    /// The literal is written verbatim, e.g., `a` or `☃`.
+    Verbatim,
+    /// The literal is written as an escape because it is punctuation, e.g.,
+    /// `\*` or `\[`.
+    Punctuation,
+    /// The literal is written as an octal escape, e.g., `\141`.
+    Octal,
+    /// The literal is written as a hex code with a fixed number of digits
+    /// depending on the type of the escape, e.g., `\x61` or or `\u0061` or
+    /// `\U00000061`.
+    HexFixed(HexLiteralKind),
+    /// The literal is written as a hex code with a bracketed number of
+    /// digits. The only restriction is that the bracketed hex code must refer
+    /// to a valid Unicode scalar value.
+    HexBrace(HexLiteralKind),
+    /// The literal is written as a specially recognized escape, e.g., `\f`
+    /// or `\n`.
+    Special(SpecialLiteralKind),
+}
+
+/// The type of a special literal.
+///
+/// A special literal is a special escape sequence recognized by the regex
+/// parser, e.g., `\f` or `\n`.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum SpecialLiteralKind {
+    /// Bell, spelled `\a` (`\x07`).
+    Bell,
+    /// Form feed, spelled `\f` (`\x0C`).
+    FormFeed,
+    /// Tab, spelled `\t` (`\x09`).
+    Tab,
+    /// Line feed, spelled `\n` (`\x0A`).
+    LineFeed,
+    /// Carriage return, spelled `\r` (`\x0D`).
+    CarriageReturn,
+    /// Vertical tab, spelled `\v` (`\x0B`).
+    VerticalTab,
+    /// Space, spelled `\ ` (`\x20`). Note that this can only appear when
+    /// parsing in verbose mode.
+    Space,
+}
+
+/// The type of a Unicode hex literal.
+///
+/// Note that all variants behave the same when used with brackets. They only
+/// differ when used without brackets in the number of hex digits that must
+/// follow.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum HexLiteralKind {
+    /// A `\x` prefix. When used without brackets, this form is limited to
+    /// two digits.
+    X,
+    /// A `\u` prefix. When used without brackets, this form is limited to
+    /// four digits.
+    UnicodeShort,
+    /// A `\U` prefix. When used without brackets, this form is limited to
+    /// eight digits.
+    UnicodeLong,
+}
+
+impl HexLiteralKind {
+    /// The number of digits that must be used with this literal form when
+    /// used without brackets. When used with brackets, there is no
+    /// restriction on the number of digits.
+    pub fn digits(&self) -> u32 {
+        match *self {
+            HexLiteralKind::X => 2,
+            HexLiteralKind::UnicodeShort => 4,
+            HexLiteralKind::UnicodeLong => 8,
+        }
+    }
+}
+
+/// A single character class expression.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum Class {
+    /// A Unicode character class, e.g., `\pL` or `\p{Greek}`.
+    Unicode(ClassUnicode),
+    /// A perl character class, e.g., `\d` or `\W`.
+    Perl(ClassPerl),
+    /// A bracketed character class set, which may contain zero or more
+    /// character ranges and/or zero or more nested classes. e.g.,
+    /// `[a-zA-Z\pL]`.
+    Bracketed(ClassBracketed),
+}
+
+impl Class {
+    /// Return the span of this character class.
+    pub fn span(&self) -> &Span {
+        match *self {
+            Class::Perl(ref x) => &x.span,
+            Class::Unicode(ref x) => &x.span,
+            Class::Bracketed(ref x) => &x.span,
+        }
+    }
+}
+
+/// A Perl character class.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ClassPerl {
+    /// The span of this class.
+    pub span: Span,
+    /// The kind of Perl class.
+    pub kind: ClassPerlKind,
+    /// Whether the class is negated or not. e.g., `\d` is not negated but
+    /// `\D` is.
+    pub negated: bool,
+}
+
+/// The available Perl character classes.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum ClassPerlKind {
+    /// Decimal numbers.
+    Digit,
+    /// Whitespace.
+    Space,
+    /// Word characters.
+    Word,
+}
+
+/// An ASCII character class.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ClassAscii {
+    /// The span of this class.
+    pub span: Span,
+    /// The kind of ASCII class.
+    pub kind: ClassAsciiKind,
+    /// Whether the class is negated or not. e.g., `[[:alpha:]]` is not negated
+    /// but `[[:^alpha:]]` is.
+    pub negated: bool,
+}
+
+/// The available ASCII character classes.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum ClassAsciiKind {
+    /// `[0-9A-Za-z]`
+    Alnum,
+    /// `[A-Za-z]`
+    Alpha,
+    /// `[\x00-\x7F]`
+    Ascii,
+    /// `[ \t]`
+    Blank,
+    /// `[\x00-\x1F\x7F]`
+    Cntrl,
+    /// `[0-9]`
+    Digit,
+    /// `[!-~]`
+    Graph,
+    /// `[a-z]`
+    Lower,
+    /// `[ -~]`
+    Print,
+    /// `[!-/:-@\[-`{-~]`
+    Punct,
+    /// `[\t\n\v\f\r ]`
+    Space,
+    /// `[A-Z]`
+    Upper,
+    /// `[0-9A-Za-z_]`
+    Word,
+    /// `[0-9A-Fa-f]`
+    Xdigit,
+}
+
+impl ClassAsciiKind {
+    /// Return the corresponding ClassAsciiKind variant for the given name.
+    ///
+    /// The name given should correspond to the lowercase version of the
+    /// variant name. e.g., `cntrl` is the name for `ClassAsciiKind::Cntrl`.
+    ///
+    /// If no variant with the corresponding name exists, then `None` is
+    /// returned.
+    pub fn from_name(name: &str) -> Option<ClassAsciiKind> {
+        use self::ClassAsciiKind::*;
+        match name {
+            "alnum" => Some(Alnum),
+            "alpha" => Some(Alpha),
+            "ascii" => Some(Ascii),
+            "blank" => Some(Blank),
+            "cntrl" => Some(Cntrl),
+            "digit" => Some(Digit),
+            "graph" => Some(Graph),
+            "lower" => Some(Lower),
+            "print" => Some(Print),
+            "punct" => Some(Punct),
+            "space" => Some(Space),
+            "upper" => Some(Upper),
+            "word" => Some(Word),
+            "xdigit" => Some(Xdigit),
+            _ => None,
+        }
+    }
+}
+
+/// A Unicode character class.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ClassUnicode {
+    /// The span of this class.
+    pub span: Span,
+    /// Whether this class is negated or not.
+    ///
+    /// Note: be careful when using this attribute. This specifically refers
+    /// to whether the class is written as `\p` or `\P`, where the latter
+    /// is `negated = true`. However, it also possible to write something like
+    /// `\P{scx!=Katakana}` which is actually equivalent to
+    /// `\p{scx=Katakana}` and is therefore not actually negated even though
+    /// `negated = true` here. To test whether this class is truly negated
+    /// or not, use the `is_negated` method.
+    pub negated: bool,
+    /// The kind of Unicode class.
+    pub kind: ClassUnicodeKind,
+}
+
+impl ClassUnicode {
+    /// Returns true if this class has been negated.
+    ///
+    /// Note that this takes the Unicode op into account, if it's present.
+    /// e.g., `is_negated` for `\P{scx!=Katakana}` will return `false`.
+    pub fn is_negated(&self) -> bool {
+        match self.kind {
+            ClassUnicodeKind::NamedValue {
+                op: ClassUnicodeOpKind::NotEqual,
+                ..
+            } => !self.negated,
+            _ => self.negated,
+        }
+    }
+}
+
+/// The available forms of Unicode character classes.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum ClassUnicodeKind {
+    /// A one letter abbreviated class, e.g., `\pN`.
+    OneLetter(char),
+    /// A binary property, general category or script. The string may be
+    /// empty.
+    Named(String),
+    /// A property name and an associated value.
+    NamedValue {
+        /// The type of Unicode op used to associate `name` with `value`.
+        op: ClassUnicodeOpKind,
+        /// The property name (which may be empty).
+        name: String,
+        /// The property value (which may be empty).
+        value: String,
+    },
+}
+
+/// The type of op used in a Unicode character class.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum ClassUnicodeOpKind {
+    /// A property set to a specific value, e.g., `\p{scx=Katakana}`.
+    Equal,
+    /// A property set to a specific value using a colon, e.g.,
+    /// `\p{scx:Katakana}`.
+    Colon,
+    /// A property that isn't a particular value, e.g., `\p{scx!=Katakana}`.
+    NotEqual,
+}
+
+impl ClassUnicodeOpKind {
+    /// Whether the op is an equality op or not.
+    pub fn is_equal(&self) -> bool {
+        match *self {
+            ClassUnicodeOpKind::Equal | ClassUnicodeOpKind::Colon => true,
+            _ => false,
+        }
+    }
+}
+
+/// A bracketed character class, e.g., `[a-z0-9]`.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ClassBracketed {
+    /// The span of this class.
+    pub span: Span,
+    /// Whether this class is negated or not. e.g., `[a]` is not negated but
+    /// `[^a]` is.
+    pub negated: bool,
+    /// The type of this set. A set is either a normal union of things, e.g.,
+    /// `[abc]` or a result of applying set operations, e.g., `[\pL--c]`.
+    pub kind: ClassSet,
+}
+
+/// A character class set.
+///
+/// This type corresponds to the internal structure of a bracketed character
+/// class. That is, every bracketed character is one of two types: a union of
+/// items (literals, ranges, other bracketed classes) or a tree of binary set
+/// operations.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum ClassSet {
+    /// An item, which can be a single literal, range, nested character class
+    /// or a union of items.
+    Item(ClassSetItem),
+    /// A single binary operation (i.e., &&, -- or ~~).
+    BinaryOp(ClassSetBinaryOp),
+}
+
+impl ClassSet {
+    /// Build a set from a union.
+    pub fn union(ast: ClassSetUnion) -> ClassSet {
+        ClassSet::Item(ClassSetItem::Union(ast))
+    }
+
+    /// Return the span of this character class set.
+    pub fn span(&self) -> &Span {
+        match *self {
+            ClassSet::Item(ref x) => x.span(),
+            ClassSet::BinaryOp(ref x) => &x.span,
+        }
+    }
+
+    /// Return true if and only if this class set is empty.
+    fn is_empty(&self) -> bool {
+        match *self {
+            ClassSet::Item(ClassSetItem::Empty(_)) => true,
+            _ => false,
+        }
+    }
+}
+
+/// A single component of a character class set.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum ClassSetItem {
+    /// An empty item.
+    ///
+    /// Note that a bracketed character class cannot contain a single empty
+    /// item. Empty items can appear when using one of the binary operators.
+    /// For example, `[&&]` is the intersection of two empty classes.
+    Empty(Span),
+    /// A single literal.
+    Literal(Literal),
+    /// A range between two literals.
+    Range(ClassSetRange),
+    /// An ASCII character class, e.g., `[:alnum:]` or `[:punct:]`.
+    Ascii(ClassAscii),
+    /// A Unicode character class, e.g., `\pL` or `\p{Greek}`.
+    Unicode(ClassUnicode),
+    /// A perl character class, e.g., `\d` or `\W`.
+    Perl(ClassPerl),
+    /// A bracketed character class set, which may contain zero or more
+    /// character ranges and/or zero or more nested classes. e.g.,
+    /// `[a-zA-Z\pL]`.
+    Bracketed(Box<ClassBracketed>),
+    /// A union of items.
+    Union(ClassSetUnion),
+}
+
+impl ClassSetItem {
+    /// Return the span of this character class set item.
+    pub fn span(&self) -> &Span {
+        match *self {
+            ClassSetItem::Empty(ref span) => span,
+            ClassSetItem::Literal(ref x) => &x.span,
+            ClassSetItem::Range(ref x) => &x.span,
+            ClassSetItem::Ascii(ref x) => &x.span,
+            ClassSetItem::Perl(ref x) => &x.span,
+            ClassSetItem::Unicode(ref x) => &x.span,
+            ClassSetItem::Bracketed(ref x) => &x.span,
+            ClassSetItem::Union(ref x) => &x.span,
+        }
+    }
+}
+
+/// A single character class range in a set.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ClassSetRange {
+    /// The span of this range.
+    pub span: Span,
+    /// The start of this range.
+    pub start: Literal,
+    /// The end of this range.
+    pub end: Literal,
+}
+
+impl ClassSetRange {
+    /// Returns true if and only if this character class range is valid.
+    ///
+    /// The only case where a range is invalid is if its start is greater than
+    /// its end.
+    pub fn is_valid(&self) -> bool {
+        self.start.c <= self.end.c
+    }
+}
+
+/// A union of items inside a character class set.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ClassSetUnion {
+    /// The span of the items in this operation. e.g., the `a-z0-9` in
+    /// `[^a-z0-9]`
+    pub span: Span,
+    /// The sequence of items that make up this union.
+    pub items: Vec<ClassSetItem>,
+}
+
+impl ClassSetUnion {
+    /// Push a new item in this union.
+    ///
+    /// The ending position of this union's span is updated to the ending
+    /// position of the span of the item given. If the union is empty, then
+    /// the starting position of this union is set to the starting position
+    /// of this item.
+    ///
+    /// In other words, if you only use this method to add items to a union
+    /// and you set the spans on each item correctly, then you should never
+    /// need to adjust the span of the union directly.
+    pub fn push(&mut self, item: ClassSetItem) {
+        if self.items.is_empty() {
+            self.span.start = item.span().start;
+        }
+        self.span.end = item.span().end;
+        self.items.push(item);
+    }
+
+    /// Return this union as a character class set item.
+    ///
+    /// If this union contains zero items, then an empty union is
+    /// returned. If this concatenation contains exactly 1 item, then the
+    /// corresponding item is returned. Otherwise, ClassSetItem::Union is
+    /// returned.
+    pub fn into_item(mut self) -> ClassSetItem {
+        match self.items.len() {
+            0 => ClassSetItem::Empty(self.span),
+            1 => self.items.pop().unwrap(),
+            _ => ClassSetItem::Union(self),
+        }
+    }
+}
+
+/// A Unicode character class set operation.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ClassSetBinaryOp {
+    /// The span of this operation. e.g., the `a-z--[h-p]` in `[a-z--h-p]`.
+    pub span: Span,
+    /// The type of this set operation.
+    pub kind: ClassSetBinaryOpKind,
+    /// The left hand side of the operation.
+    pub lhs: Box<ClassSet>,
+    /// The right hand side of the operation.
+    pub rhs: Box<ClassSet>,
+}
+
+/// The type of a Unicode character class set operation.
+///
+/// Note that this doesn't explicitly represent union since there is no
+/// explicit union operator. Concatenation inside a character class corresponds
+/// to the union operation.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum ClassSetBinaryOpKind {
+    /// The intersection of two sets, e.g., `\pN&&[a-z]`.
+    Intersection,
+    /// The difference of two sets, e.g., `\pN--[0-9]`.
+    Difference,
+    /// The symmetric difference of two sets. The symmetric difference is the
+    /// set of elements belonging to one but not both sets.
+    /// e.g., `[\pL~~[:ascii:]]`.
+    SymmetricDifference,
+}
+
+/// A single zero-width assertion.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Assertion {
+    /// The span of this assertion.
+    pub span: Span,
+    /// The assertion kind, e.g., `\b` or `^`.
+    pub kind: AssertionKind,
+}
+
+/// An assertion kind.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum AssertionKind {
+    /// `^`
+    StartLine,
+    /// `$`
+    EndLine,
+    /// `\A`
+    StartText,
+    /// `\z`
+    EndText,
+    /// `\b`
+    WordBoundary,
+    /// `\B`
+    NotWordBoundary,
+}
+
+/// A repetition operation applied to a regular expression.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Repetition {
+    /// The span of this operation.
+    pub span: Span,
+    /// The actual operation.
+    pub op: RepetitionOp,
+    /// Whether this operation was applied greedily or not.
+    pub greedy: bool,
+    /// The regular expression under repetition.
+    pub ast: Box<Ast>,
+}
+
+/// The repetition operator itself.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct RepetitionOp {
+    /// The span of this operator. This includes things like `+`, `*?` and
+    /// `{m,n}`.
+    pub span: Span,
+    /// The type of operation.
+    pub kind: RepetitionKind,
+}
+
+/// The kind of a repetition operator.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum RepetitionKind {
+    /// `?`
+    ZeroOrOne,
+    /// `*`
+    ZeroOrMore,
+    /// `+`
+    OneOrMore,
+    /// `{m,n}`
+    Range(RepetitionRange),
+}
+
+/// A range repetition operator.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum RepetitionRange {
+    /// `{m}`
+    Exactly(u32),
+    /// `{m,}`
+    AtLeast(u32),
+    /// `{m,n}`
+    Bounded(u32, u32),
+}
+
+impl RepetitionRange {
+    /// Returns true if and only if this repetition range is valid.
+    ///
+    /// The only case where a repetition range is invalid is if it is bounded
+    /// and its start is greater than its end.
+    pub fn is_valid(&self) -> bool {
+        match *self {
+            RepetitionRange::Bounded(s, e) if s > e => false,
+            _ => true,
+        }
+    }
+}
+
+/// A grouped regular expression.
+///
+/// This includes both capturing and non-capturing groups. This does **not**
+/// include flag-only groups like `(?is)`, but does contain any group that
+/// contains a sub-expression, e.g., `(a)`, `(?P<name>a)`, `(?:a)` and
+/// `(?is:a)`.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Group {
+    /// The span of this group.
+    pub span: Span,
+    /// The kind of this group.
+    pub kind: GroupKind,
+    /// The regular expression in this group.
+    pub ast: Box<Ast>,
+}
+
+impl Group {
+    /// If this group is non-capturing, then this returns the (possibly empty)
+    /// set of flags. Otherwise, `None` is returned.
+    pub fn flags(&self) -> Option<&Flags> {
+        match self.kind {
+            GroupKind::NonCapturing(ref flags) => Some(flags),
+            _ => None,
+        }
+    }
+
+    /// Returns true if and only if this group is capturing.
+    pub fn is_capturing(&self) -> bool {
+        match self.kind {
+            GroupKind::CaptureIndex(_) | GroupKind::CaptureName(_) => true,
+            GroupKind::NonCapturing(_) => false,
+        }
+    }
+
+    /// Returns the capture index of this group, if this is a capturing group.
+    ///
+    /// This returns a capture index precisely when `is_capturing` is `true`.
+    pub fn capture_index(&self) -> Option<u32> {
+        match self.kind {
+            GroupKind::CaptureIndex(i) => Some(i),
+            GroupKind::CaptureName(ref x) => Some(x.index),
+            GroupKind::NonCapturing(_) => None,
+        }
+    }
+}
+
+/// The kind of a group.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum GroupKind {
+    /// `(a)`
+    CaptureIndex(u32),
+    /// `(?P<name>a)`
+    CaptureName(CaptureName),
+    /// `(?:a)` and `(?i:a)`
+    NonCapturing(Flags),
+}
+
+/// A capture name.
+///
+/// This corresponds to the name itself between the angle brackets in, e.g.,
+/// `(?P<foo>expr)`.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct CaptureName {
+    /// The span of this capture name.
+    pub span: Span,
+    /// The capture name.
+    pub name: String,
+    /// The capture index.
+    pub index: u32,
+}
+
+/// A group of flags that is not applied to a particular regular expression.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct SetFlags {
+    /// The span of these flags, including the grouping parentheses.
+    pub span: Span,
+    /// The actual sequence of flags.
+    pub flags: Flags,
+}
+
+/// A group of flags.
+///
+/// This corresponds only to the sequence of flags themselves, e.g., `is-u`.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Flags {
+    /// The span of this group of flags.
+    pub span: Span,
+    /// A sequence of flag items. Each item is either a flag or a negation
+    /// operator.
+    pub items: Vec<FlagsItem>,
+}
+
+impl Flags {
+    /// Add the given item to this sequence of flags.
+    ///
+    /// If the item was added successfully, then `None` is returned. If the
+    /// given item is a duplicate, then `Some(i)` is returned, where
+    /// `items[i].kind == item.kind`.
+    pub fn add_item(&mut self, item: FlagsItem) -> Option<usize> {
+        for (i, x) in self.items.iter().enumerate() {
+            if x.kind == item.kind {
+                return Some(i);
+            }
+        }
+        self.items.push(item);
+        None
+    }
+
+    /// Returns the state of the given flag in this set.
+    ///
+    /// If the given flag is in the set but is negated, then `Some(false)` is
+    /// returned.
+    ///
+    /// If the given flag is in the set and is not negated, then `Some(true)`
+    /// is returned.
+    ///
+    /// Otherwise, `None` is returned.
+    pub fn flag_state(&self, flag: Flag) -> Option<bool> {
+        let mut negated = false;
+        for x in &self.items {
+            match x.kind {
+                FlagsItemKind::Negation => {
+                    negated = true;
+                }
+                FlagsItemKind::Flag(ref xflag) if xflag == &flag => {
+                    return Some(!negated);
+                }
+                _ => {}
+            }
+        }
+        None
+    }
+}
+
+/// A single item in a group of flags.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct FlagsItem {
+    /// The span of this item.
+    pub span: Span,
+    /// The kind of this item.
+    pub kind: FlagsItemKind,
+}
+
+/// The kind of an item in a group of flags.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum FlagsItemKind {
+    /// A negation operator applied to all subsequent flags in the enclosing
+    /// group.
+    Negation,
+    /// A single flag in a group.
+    Flag(Flag),
+}
+
+impl FlagsItemKind {
+    /// Returns true if and only if this item is a negation operator.
+    pub fn is_negation(&self) -> bool {
+        match *self {
+            FlagsItemKind::Negation => true,
+            _ => false,
+        }
+    }
+}
+
+/// A single flag.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum Flag {
+    /// `i`
+    CaseInsensitive,
+    /// `m`
+    MultiLine,
+    /// `s`
+    DotMatchesNewLine,
+    /// `U`
+    SwapGreed,
+    /// `u`
+    Unicode,
+    /// `x`
+    IgnoreWhitespace,
+}
+
+/// A custom `Drop` impl is used for `Ast` such that it uses constant stack
+/// space but heap space proportional to the depth of the `Ast`.
+impl Drop for Ast {
+    fn drop(&mut self) {
+        use std::mem;
+
+        match *self {
+            Ast::Empty(_)
+            | Ast::Flags(_)
+            | Ast::Literal(_)
+            | Ast::Dot(_)
+            | Ast::Assertion(_)
+            // Classes are recursive, so they get their own Drop impl.
+            | Ast::Class(_) => return,
+            Ast::Repetition(ref x) if !x.ast.has_subexprs() => return,
+            Ast::Group(ref x) if !x.ast.has_subexprs() => return,
+            Ast::Alternation(ref x) if x.asts.is_empty() => return,
+            Ast::Concat(ref x) if x.asts.is_empty() => return,
+            _ => {}
+        }
+
+        let empty_span = || Span::splat(Position::new(0, 0, 0));
+        let empty_ast = || Ast::Empty(empty_span());
+        let mut stack = vec![mem::replace(self, empty_ast())];
+        while let Some(mut ast) = stack.pop() {
+            match ast {
+                Ast::Empty(_)
+                | Ast::Flags(_)
+                | Ast::Literal(_)
+                | Ast::Dot(_)
+                | Ast::Assertion(_)
+                // Classes are recursive, so they get their own Drop impl.
+                | Ast::Class(_) => {}
+                Ast::Repetition(ref mut x) => {
+                    stack.push(mem::replace(&mut x.ast, empty_ast()));
+                }
+                Ast::Group(ref mut x) => {
+                    stack.push(mem::replace(&mut x.ast, empty_ast()));
+                }
+                Ast::Alternation(ref mut x) => {
+                    stack.extend(x.asts.drain(..));
+                }
+                Ast::Concat(ref mut x) => {
+                    stack.extend(x.asts.drain(..));
+                }
+            }
+        }
+    }
+}
+
+/// A custom `Drop` impl is used for `ClassSet` such that it uses constant
+/// stack space but heap space proportional to the depth of the `ClassSet`.
+impl Drop for ClassSet {
+    fn drop(&mut self) {
+        use std::mem;
+
+        match *self {
+            ClassSet::Item(ref item) => match *item {
+                ClassSetItem::Empty(_)
+                | ClassSetItem::Literal(_)
+                | ClassSetItem::Range(_)
+                | ClassSetItem::Ascii(_)
+                | ClassSetItem::Unicode(_)
+                | ClassSetItem::Perl(_) => return,
+                ClassSetItem::Bracketed(ref x) => {
+                    if x.kind.is_empty() {
+                        return;
+                    }
+                }
+                ClassSetItem::Union(ref x) => {
+                    if x.items.is_empty() {
+                        return;
+                    }
+                }
+            },
+            ClassSet::BinaryOp(ref op) => {
+                if op.lhs.is_empty() && op.rhs.is_empty() {
+                    return;
+                }
+            }
+        }
+
+        let empty_span = || Span::splat(Position::new(0, 0, 0));
+        let empty_set = || ClassSet::Item(ClassSetItem::Empty(empty_span()));
+        let mut stack = vec![mem::replace(self, empty_set())];
+        while let Some(mut set) = stack.pop() {
+            match set {
+                ClassSet::Item(ref mut item) => match *item {
+                    ClassSetItem::Empty(_)
+                    | ClassSetItem::Literal(_)
+                    | ClassSetItem::Range(_)
+                    | ClassSetItem::Ascii(_)
+                    | ClassSetItem::Unicode(_)
+                    | ClassSetItem::Perl(_) => {}
+                    ClassSetItem::Bracketed(ref mut x) => {
+                        stack.push(mem::replace(&mut x.kind, empty_set()));
+                    }
+                    ClassSetItem::Union(ref mut x) => {
+                        stack.extend(x.items.drain(..).map(ClassSet::Item));
+                    }
+                },
+                ClassSet::BinaryOp(ref mut op) => {
+                    stack.push(mem::replace(&mut op.lhs, empty_set()));
+                    stack.push(mem::replace(&mut op.rhs, empty_set()));
+                }
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // We use a thread with an explicit stack size to test that our destructor
+    // for Ast can handle arbitrarily sized expressions in constant stack
+    // space. In case we run on a platform without threads (WASM?), we limit
+    // this test to Windows/Unix.
+    #[test]
+    #[cfg(any(unix, windows))]
+    fn no_stack_overflow_on_drop() {
+        use std::thread;
+
+        let run = || {
+            let span = || Span::splat(Position::new(0, 0, 0));
+            let mut ast = Ast::Empty(span());
+            for i in 0..200 {
+                ast = Ast::Group(Group {
+                    span: span(),
+                    kind: GroupKind::CaptureIndex(i),
+                    ast: Box::new(ast),
+                });
+            }
+            assert!(!ast.is_empty());
+        };
+
+        // We run our test on a thread with a small stack size so we can
+        // force the issue more easily.
+        //
+        // NOTE(2023-03-21): It turns out that some platforms (like FreeBSD)
+        // will just barf with very small stack sizes. So we bump this up a bit
+        // to give more room to breath. When I did this, I confirmed that if
+        // I remove the custom `Drop` impl for `Ast`, then this test does
+        // indeed still fail with a stack overflow. (At the time of writing, I
+        // had to bump it all the way up to 32K before the test would pass even
+        // without the custom `Drop` impl. So 16K seems like a safe number
+        // here.)
+        //
+        // See: https://github.com/rust-lang/regex/issues/967
+        thread::Builder::new()
+            .stack_size(16 << 10)
+            .spawn(run)
+            .unwrap()
+            .join()
+            .unwrap();
+    }
+}
diff --git a/crates/regex-syntax/src/ast/parse.rs b/crates/regex-syntax/src/ast/parse.rs
new file mode 100644
index 0000000..6e9c9ac
--- /dev/null
+++ b/crates/regex-syntax/src/ast/parse.rs
@@ -0,0 +1,5930 @@
+/*!
+This module provides a regular expression parser.
+*/
+
+use std::borrow::Borrow;
+use std::cell::{Cell, RefCell};
+use std::mem;
+use std::result;
+
+use crate::ast::{self, Ast, Position, Span};
+use crate::either::Either;
+
+use crate::is_meta_character;
+
+type Result<T> = result::Result<T, ast::Error>;
+
+/// A primitive is an expression with no sub-expressions. This includes
+/// literals, assertions and non-set character classes. This representation
+/// is used as intermediate state in the parser.
+///
+/// This does not include ASCII character classes, since they can only appear
+/// within a set character class.
+#[derive(Clone, Debug, Eq, PartialEq)]
+enum Primitive {
+    Literal(ast::Literal),
+    Assertion(ast::Assertion),
+    Dot(Span),
+    Perl(ast::ClassPerl),
+    Unicode(ast::ClassUnicode),
+}
+
+impl Primitive {
+    /// Return the span of this primitive.
+    fn span(&self) -> &Span {
+        match *self {
+            Primitive::Literal(ref x) => &x.span,
+            Primitive::Assertion(ref x) => &x.span,
+            Primitive::Dot(ref span) => span,
+            Primitive::Perl(ref x) => &x.span,
+            Primitive::Unicode(ref x) => &x.span,
+        }
+    }
+
+    /// Convert this primitive into a proper AST.
+    fn into_ast(self) -> Ast {
+        match self {
+            Primitive::Literal(lit) => Ast::Literal(lit),
+            Primitive::Assertion(assert) => Ast::Assertion(assert),
+            Primitive::Dot(span) => Ast::Dot(span),
+            Primitive::Perl(cls) => Ast::Class(ast::Class::Perl(cls)),
+            Primitive::Unicode(cls) => Ast::Class(ast::Class::Unicode(cls)),
+        }
+    }
+
+    /// Convert this primitive into an item in a character class.
+    ///
+    /// If this primitive is not a legal item (i.e., an assertion or a dot),
+    /// then return an error.
+    fn into_class_set_item<P: Borrow<Parser>>(
+        self,
+        p: &ParserI<'_, P>,
+    ) -> Result<ast::ClassSetItem> {
+        use self::Primitive::*;
+        use crate::ast::ClassSetItem;
+
+        match self {
+            Literal(lit) => Ok(ClassSetItem::Literal(lit)),
+            Perl(cls) => Ok(ClassSetItem::Perl(cls)),
+            Unicode(cls) => Ok(ClassSetItem::Unicode(cls)),
+            x => Err(p.error(*x.span(), ast::ErrorKind::ClassEscapeInvalid)),
+        }
+    }
+
+    /// Convert this primitive into a literal in a character class. In
+    /// particular, literals are the only valid items that can appear in
+    /// ranges.
+    ///
+    /// If this primitive is not a legal item (i.e., a class, assertion or a
+    /// dot), then return an error.
+    fn into_class_literal<P: Borrow<Parser>>(
+        self,
+        p: &ParserI<'_, P>,
+    ) -> Result<ast::Literal> {
+        use self::Primitive::*;
+
+        match self {
+            Literal(lit) => Ok(lit),
+            x => Err(p.error(*x.span(), ast::ErrorKind::ClassRangeLiteral)),
+        }
+    }
+}
+
+/// Returns true if the given character is a hexadecimal digit.
+fn is_hex(c: char) -> bool {
+    ('0' <= c && c <= '9') || ('a' <= c && c <= 'f') || ('A' <= c && c <= 'F')
+}
+
+/// Returns true if the given character is a valid in a capture group name.
+///
+/// If `first` is true, then `c` is treated as the first character in the
+/// group name (which must be alphabetic or underscore).
+fn is_capture_char(c: char, first: bool) -> bool {
+    c == '_'
+        || (!first
+            && (('0' <= c && c <= '9') || c == '.' || c == '[' || c == ']'))
+        || ('A' <= c && c <= 'Z')
+        || ('a' <= c && c <= 'z')
+}
+
+/// A builder for a regular expression parser.
+///
+/// This builder permits modifying configuration options for the parser.
+#[derive(Clone, Debug)]
+pub struct ParserBuilder {
+    ignore_whitespace: bool,
+    nest_limit: u32,
+    octal: bool,
+}
+
+impl Default for ParserBuilder {
+    fn default() -> ParserBuilder {
+        ParserBuilder::new()
+    }
+}
+
+impl ParserBuilder {
+    /// Create a new parser builder with a default configuration.
+    pub fn new() -> ParserBuilder {
+        ParserBuilder {
+            ignore_whitespace: false,
+            nest_limit: 250,
+            octal: false,
+        }
+    }
+
+    /// Build a parser from this configuration with the given pattern.
+    pub fn build(&self) -> Parser {
+        Parser {
+            pos: Cell::new(Position { offset: 0, line: 1, column: 1 }),
+            capture_index: Cell::new(0),
+            nest_limit: self.nest_limit,
+            octal: self.octal,
+            initial_ignore_whitespace: self.ignore_whitespace,
+            ignore_whitespace: Cell::new(self.ignore_whitespace),
+            comments: RefCell::new(vec![]),
+            stack_group: RefCell::new(vec![]),
+            stack_class: RefCell::new(vec![]),
+            capture_names: RefCell::new(vec![]),
+            scratch: RefCell::new(String::new()),
+        }
+    }
+
+    /// Set the nesting limit for this parser.
+    ///
+    /// The nesting limit controls how deep the abstract syntax tree is allowed
+    /// to be. If the AST exceeds the given limit (e.g., with too many nested
+    /// groups), then an error is returned by the parser.
+    ///
+    /// The purpose of this limit is to act as a heuristic to prevent stack
+    /// overflow for consumers that do structural induction on an `Ast` using
+    /// explicit recursion. While this crate never does this (instead using
+    /// constant stack space and moving the call stack to the heap), other
+    /// crates may.
+    ///
+    /// This limit is not checked until the entire Ast is parsed. Therefore,
+    /// if callers want to put a limit on the amount of heap space used, then
+    /// they should impose a limit on the length, in bytes, of the concrete
+    /// pattern string. In particular, this is viable since this parser
+    /// implementation will limit itself to heap space proportional to the
+    /// length of the pattern string.
+    ///
+    /// Note that a nest limit of `0` will return a nest limit error for most
+    /// patterns but not all. For example, a nest limit of `0` permits `a` but
+    /// not `ab`, since `ab` requires a concatenation, which results in a nest
+    /// depth of `1`. In general, a nest limit is not something that manifests
+    /// in an obvious way in the concrete syntax, therefore, it should not be
+    /// used in a granular way.
+    pub fn nest_limit(&mut self, limit: u32) -> &mut ParserBuilder {
+        self.nest_limit = limit;
+        self
+    }
+
+    /// Whether to support octal syntax or not.
+    ///
+    /// Octal syntax is a little-known way of uttering Unicode codepoints in
+    /// a regular expression. For example, `a`, `\x61`, `\u0061` and
+    /// `\141` are all equivalent regular expressions, where the last example
+    /// shows octal syntax.
+    ///
+    /// While supporting octal syntax isn't in and of itself a problem, it does
+    /// make good error messages harder. That is, in PCRE based regex engines,
+    /// syntax like `\0` invokes a backreference, which is explicitly
+    /// unsupported in Rust's regex engine. However, many users expect it to
+    /// be supported. Therefore, when octal support is disabled, the error
+    /// message will explicitly mention that backreferences aren't supported.
+    ///
+    /// Octal syntax is disabled by default.
+    pub fn octal(&mut self, yes: bool) -> &mut ParserBuilder {
+        self.octal = yes;
+        self
+    }
+
+    /// Enable verbose mode in the regular expression.
+    ///
+    /// When enabled, verbose mode permits insignificant whitespace in many
+    /// places in the regular expression, as well as comments. Comments are
+    /// started using `#` and continue until the end of the line.
+    ///
+    /// By default, this is disabled. It may be selectively enabled in the
+    /// regular expression by using the `x` flag regardless of this setting.
+    pub fn ignore_whitespace(&mut self, yes: bool) -> &mut ParserBuilder {
+        self.ignore_whitespace = yes;
+        self
+    }
+}
+
+/// A regular expression parser.
+///
+/// This parses a string representation of a regular expression into an
+/// abstract syntax tree. The size of the tree is proportional to the length
+/// of the regular expression pattern.
+///
+/// A `Parser` can be configured in more detail via a
+/// [`ParserBuilder`](struct.ParserBuilder.html).
+#[derive(Clone, Debug)]
+pub struct Parser {
+    /// The current position of the parser.
+    pos: Cell<Position>,
+    /// The current capture index.
+    capture_index: Cell<u32>,
+    /// The maximum number of open parens/brackets allowed. If the parser
+    /// exceeds this number, then an error is returned.
+    nest_limit: u32,
+    /// Whether to support octal syntax or not. When `false`, the parser will
+    /// return an error helpfully pointing out that backreferences are not
+    /// supported.
+    octal: bool,
+    /// The initial setting for `ignore_whitespace` as provided by
+    /// `ParserBuilder`. It is used when resetting the parser's state.
+    initial_ignore_whitespace: bool,
+    /// Whether whitespace should be ignored. When enabled, comments are
+    /// also permitted.
+    ignore_whitespace: Cell<bool>,
+    /// A list of comments, in order of appearance.
+    comments: RefCell<Vec<ast::Comment>>,
+    /// A stack of grouped sub-expressions, including alternations.
+    stack_group: RefCell<Vec<GroupState>>,
+    /// A stack of nested character classes. This is only non-empty when
+    /// parsing a class.
+    stack_class: RefCell<Vec<ClassState>>,
+    /// A sorted sequence of capture names. This is used to detect duplicate
+    /// capture names and report an error if one is detected.
+    capture_names: RefCell<Vec<ast::CaptureName>>,
+    /// A scratch buffer used in various places. Mostly this is used to
+    /// accumulate relevant characters from parts of a pattern.
+    scratch: RefCell<String>,
+}
+
+/// ParserI is the internal parser implementation.
+///
+/// We use this separate type so that we can carry the provided pattern string
+/// along with us. In particular, a `Parser` internal state is not tied to any
+/// one pattern, but `ParserI` is.
+///
+/// This type also lets us use `ParserI<&Parser>` in production code while
+/// retaining the convenience of `ParserI<Parser>` for tests, which sometimes
+/// work against the internal interface of the parser.
+#[derive(Clone, Debug)]
+struct ParserI<'s, P> {
+    /// The parser state/configuration.
+    parser: P,
+    /// The full regular expression provided by the user.
+    pattern: &'s str,
+}
+
+/// GroupState represents a single stack frame while parsing nested groups
+/// and alternations. Each frame records the state up to an opening parenthesis
+/// or a alternating bracket `|`.
+#[derive(Clone, Debug)]
+enum GroupState {
+    /// This state is pushed whenever an opening group is found.
+    Group {
+        /// The concatenation immediately preceding the opening group.
+        concat: ast::Concat,
+        /// The group that has been opened. Its sub-AST is always empty.
+        group: ast::Group,
+        /// Whether this group has the `x` flag enabled or not.
+        ignore_whitespace: bool,
+    },
+    /// This state is pushed whenever a new alternation branch is found. If
+    /// an alternation branch is found and this state is at the top of the
+    /// stack, then this state should be modified to include the new
+    /// alternation.
+    Alternation(ast::Alternation),
+}
+
+/// ClassState represents a single stack frame while parsing character classes.
+/// Each frame records the state up to an intersection, difference, symmetric
+/// difference or nested class.
+///
+/// Note that a parser's character class stack is only non-empty when parsing
+/// a character class. In all other cases, it is empty.
+#[derive(Clone, Debug)]
+enum ClassState {
+    /// This state is pushed whenever an opening bracket is found.
+    Open {
+        /// The union of class items immediately preceding this class.
+        union: ast::ClassSetUnion,
+        /// The class that has been opened. Typically this just corresponds
+        /// to the `[`, but it can also include `[^` since `^` indicates
+        /// negation of the class.
+        set: ast::ClassBracketed,
+    },
+    /// This state is pushed when a operator is seen. When popped, the stored
+    /// set becomes the left hand side of the operator.
+    Op {
+        /// The type of the operation, i.e., &&, -- or ~~.
+        kind: ast::ClassSetBinaryOpKind,
+        /// The left-hand side of the operator.
+        lhs: ast::ClassSet,
+    },
+}
+
+impl Parser {
+    /// Create a new parser with a default configuration.
+    ///
+    /// The parser can be run with either the `parse` or `parse_with_comments`
+    /// methods. The parse methods return an abstract syntax tree.
+    ///
+    /// To set configuration options on the parser, use
+    /// [`ParserBuilder`](struct.ParserBuilder.html).
+    pub fn new() -> Parser {
+        ParserBuilder::new().build()
+    }
+
+    /// Parse the regular expression into an abstract syntax tree.
+    pub fn parse(&mut self, pattern: &str) -> Result<Ast> {
+        ParserI::new(self, pattern).parse()
+    }
+
+    /// Parse the regular expression and return an abstract syntax tree with
+    /// all of the comments found in the pattern.
+    pub fn parse_with_comments(
+        &mut self,
+        pattern: &str,
+    ) -> Result<ast::WithComments> {
+        ParserI::new(self, pattern).parse_with_comments()
+    }
+
+    /// Reset the internal state of a parser.
+    ///
+    /// This is called at the beginning of every parse. This prevents the
+    /// parser from running with inconsistent state (say, if a previous
+    /// invocation returned an error and the parser is reused).
+    fn reset(&self) {
+        // These settings should be in line with the construction
+        // in `ParserBuilder::build`.
+        self.pos.set(Position { offset: 0, line: 1, column: 1 });
+        self.ignore_whitespace.set(self.initial_ignore_whitespace);
+        self.comments.borrow_mut().clear();
+        self.stack_group.borrow_mut().clear();
+        self.stack_class.borrow_mut().clear();
+    }
+}
+
+impl<'s, P: Borrow<Parser>> ParserI<'s, P> {
+    /// Build an internal parser from a parser configuration and a pattern.
+    fn new(parser: P, pattern: &'s str) -> ParserI<'s, P> {
+        ParserI { parser, pattern }
+    }
+
+    /// Return a reference to the parser state.
+    fn parser(&self) -> &Parser {
+        self.parser.borrow()
+    }
+
+    /// Return a reference to the pattern being parsed.
+    fn pattern(&self) -> &str {
+        self.pattern.borrow()
+    }
+
+    /// Create a new error with the given span and error type.
+    fn error(&self, span: Span, kind: ast::ErrorKind) -> ast::Error {
+        ast::Error { kind, pattern: self.pattern().to_string(), span }
+    }
+
+    /// Return the current offset of the parser.
+    ///
+    /// The offset starts at `0` from the beginning of the regular expression
+    /// pattern string.
+    fn offset(&self) -> usize {
+        self.parser().pos.get().offset
+    }
+
+    /// Return the current line number of the parser.
+    ///
+    /// The line number starts at `1`.
+    fn line(&self) -> usize {
+        self.parser().pos.get().line
+    }
+
+    /// Return the current column of the parser.
+    ///
+    /// The column number starts at `1` and is reset whenever a `\n` is seen.
+    fn column(&self) -> usize {
+        self.parser().pos.get().column
+    }
+
+    /// Return the next capturing index. Each subsequent call increments the
+    /// internal index.
+    ///
+    /// The span given should correspond to the location of the opening
+    /// parenthesis.
+    ///
+    /// If the capture limit is exceeded, then an error is returned.
+    fn next_capture_index(&self, span: Span) -> Result<u32> {
+        let current = self.parser().capture_index.get();
+        let i = current.checked_add(1).ok_or_else(|| {
+            self.error(span, ast::ErrorKind::CaptureLimitExceeded)
+        })?;
+        self.parser().capture_index.set(i);
+        Ok(i)
+    }
+
+    /// Adds the given capture name to this parser. If this capture name has
+    /// already been used, then an error is returned.
+    fn add_capture_name(&self, cap: &ast::CaptureName) -> Result<()> {
+        let mut names = self.parser().capture_names.borrow_mut();
+        match names
+            .binary_search_by_key(&cap.name.as_str(), |c| c.name.as_str())
+        {
+            Err(i) => {
+                names.insert(i, cap.clone());
+                Ok(())
+            }
+            Ok(i) => Err(self.error(
+                cap.span,
+                ast::ErrorKind::GroupNameDuplicate { original: names[i].span },
+            )),
+        }
+    }
+
+    /// Return whether the parser should ignore whitespace or not.
+    fn ignore_whitespace(&self) -> bool {
+        self.parser().ignore_whitespace.get()
+    }
+
+    /// Return the character at the current position of the parser.
+    ///
+    /// This panics if the current position does not point to a valid char.
+    fn char(&self) -> char {
+        self.char_at(self.offset())
+    }
+
+    /// Return the character at the given position.
+    ///
+    /// This panics if the given position does not point to a valid char.
+    fn char_at(&self, i: usize) -> char {
+        self.pattern()[i..]
+            .chars()
+            .next()
+            .unwrap_or_else(|| panic!("expected char at offset {}", i))
+    }
+
+    /// Bump the parser to the next Unicode scalar value.
+    ///
+    /// If the end of the input has been reached, then `false` is returned.
+    fn bump(&self) -> bool {
+        if self.is_eof() {
+            return false;
+        }
+        let Position { mut offset, mut line, mut column } = self.pos();
+        if self.char() == '\n' {
+            line = line.checked_add(1).unwrap();
+            column = 1;
+        } else {
+            column = column.checked_add(1).unwrap();
+        }
+        offset += self.char().len_utf8();
+        self.parser().pos.set(Position { offset, line, column });
+        self.pattern()[self.offset()..].chars().next().is_some()
+    }
+
+    /// If the substring starting at the current position of the parser has
+    /// the given prefix, then bump the parser to the character immediately
+    /// following the prefix and return true. Otherwise, don't bump the parser
+    /// and return false.
+    fn bump_if(&self, prefix: &str) -> bool {
+        if self.pattern()[self.offset()..].starts_with(prefix) {
+            for _ in 0..prefix.chars().count() {
+                self.bump();
+            }
+            true
+        } else {
+            false
+        }
+    }
+
+    /// Returns true if and only if the parser is positioned at a look-around
+    /// prefix. The conditions under which this returns true must always
+    /// correspond to a regular expression that would otherwise be consider
+    /// invalid.
+    ///
+    /// This should only be called immediately after parsing the opening of
+    /// a group or a set of flags.
+    fn is_lookaround_prefix(&self) -> bool {
+        self.bump_if("?=")
+            || self.bump_if("?!")
+            || self.bump_if("?<=")
+            || self.bump_if("?<!")
+    }
+
+    /// Bump the parser, and if the `x` flag is enabled, bump through any
+    /// subsequent spaces. Return true if and only if the parser is not at
+    /// EOF.
+    fn bump_and_bump_space(&self) -> bool {
+        if !self.bump() {
+            return false;
+        }
+        self.bump_space();
+        !self.is_eof()
+    }
+
+    /// If the `x` flag is enabled (i.e., whitespace insensitivity with
+    /// comments), then this will advance the parser through all whitespace
+    /// and comments to the next non-whitespace non-comment byte.
+    ///
+    /// If the `x` flag is disabled, then this is a no-op.
+    ///
+    /// This should be used selectively throughout the parser where
+    /// arbitrary whitespace is permitted when the `x` flag is enabled. For
+    /// example, `{   5  , 6}` is equivalent to `{5,6}`.
+    fn bump_space(&self) {
+        if !self.ignore_whitespace() {
+            return;
+        }
+        while !self.is_eof() {
+            if self.char().is_whitespace() {
+                self.bump();
+            } else if self.char() == '#' {
+                let start = self.pos();
+                let mut comment_text = String::new();
+                self.bump();
+                while !self.is_eof() {
+                    let c = self.char();
+                    self.bump();
+                    if c == '\n' {
+                        break;
+                    }
+                    comment_text.push(c);
+                }
+                let comment = ast::Comment {
+                    span: Span::new(start, self.pos()),
+                    comment: comment_text,
+                };
+                self.parser().comments.borrow_mut().push(comment);
+            } else {
+                break;
+            }
+        }
+    }
+
+    /// Peek at the next character in the input without advancing the parser.
+    ///
+    /// If the input has been exhausted, then this returns `None`.
+    fn peek(&self) -> Option<char> {
+        if self.is_eof() {
+            return None;
+        }
+        self.pattern()[self.offset() + self.char().len_utf8()..].chars().next()
+    }
+
+    /// Like peek, but will ignore spaces when the parser is in whitespace
+    /// insensitive mode.
+    fn peek_space(&self) -> Option<char> {
+        if !self.ignore_whitespace() {
+            return self.peek();
+        }
+        if self.is_eof() {
+            return None;
+        }
+        let mut start = self.offset() + self.char().len_utf8();
+        let mut in_comment = false;
+        for (i, c) in self.pattern()[start..].char_indices() {
+            if c.is_whitespace() {
+                continue;
+            } else if !in_comment && c == '#' {
+                in_comment = true;
+            } else if in_comment && c == '\n' {
+                in_comment = false;
+            } else {
+                start += i;
+                break;
+            }
+        }
+        self.pattern()[start..].chars().next()
+    }
+
+    /// Returns true if the next call to `bump` would return false.
+    fn is_eof(&self) -> bool {
+        self.offset() == self.pattern().len()
+    }
+
+    /// Return the current position of the parser, which includes the offset,
+    /// line and column.
+    fn pos(&self) -> Position {
+        self.parser().pos.get()
+    }
+
+    /// Create a span at the current position of the parser. Both the start
+    /// and end of the span are set.
+    fn span(&self) -> Span {
+        Span::splat(self.pos())
+    }
+
+    /// Create a span that covers the current character.
+    fn span_char(&self) -> Span {
+        let mut next = Position {
+            offset: self.offset().checked_add(self.char().len_utf8()).unwrap(),
+            line: self.line(),
+            column: self.column().checked_add(1).unwrap(),
+        };
+        if self.char() == '\n' {
+            next.line += 1;
+            next.column = 1;
+        }
+        Span::new(self.pos(), next)
+    }
+
+    /// Parse and push a single alternation on to the parser's internal stack.
+    /// If the top of the stack already has an alternation, then add to that
+    /// instead of pushing a new one.
+    ///
+    /// The concatenation given corresponds to a single alternation branch.
+    /// The concatenation returned starts the next branch and is empty.
+    ///
+    /// This assumes the parser is currently positioned at `|` and will advance
+    /// the parser to the character following `|`.
+    #[inline(never)]
+    fn push_alternate(&self, mut concat: ast::Concat) -> Result<ast::Concat> {
+        assert_eq!(self.char(), '|');
+        concat.span.end = self.pos();
+        self.push_or_add_alternation(concat);
+        self.bump();
+        Ok(ast::Concat { span: self.span(), asts: vec![] })
+    }
+
+    /// Pushes or adds the given branch of an alternation to the parser's
+    /// internal stack of state.
+    fn push_or_add_alternation(&self, concat: ast::Concat) {
+        use self::GroupState::*;
+
+        let mut stack = self.parser().stack_group.borrow_mut();
+        if let Some(&mut Alternation(ref mut alts)) = stack.last_mut() {
+            alts.asts.push(concat.into_ast());
+            return;
+        }
+        stack.push(Alternation(ast::Alternation {
+            span: Span::new(concat.span.start, self.pos()),
+            asts: vec![concat.into_ast()],
+        }));
+    }
+
+    /// Parse and push a group AST (and its parent concatenation) on to the
+    /// parser's internal stack. Return a fresh concatenation corresponding
+    /// to the group's sub-AST.
+    ///
+    /// If a set of flags was found (with no group), then the concatenation
+    /// is returned with that set of flags added.
+    ///
+    /// This assumes that the parser is currently positioned on the opening
+    /// parenthesis. It advances the parser to the character at the start
+    /// of the sub-expression (or adjoining expression).
+    ///
+    /// If there was a problem parsing the start of the group, then an error
+    /// is returned.
+    #[inline(never)]
+    fn push_group(&self, mut concat: ast::Concat) -> Result<ast::Concat> {
+        assert_eq!(self.char(), '(');
+        match self.parse_group()? {
+            Either::Left(set) => {
+                let ignore = set.flags.flag_state(ast::Flag::IgnoreWhitespace);
+                if let Some(v) = ignore {
+                    self.parser().ignore_whitespace.set(v);
+                }
+
+                concat.asts.push(Ast::Flags(set));
+                Ok(concat)
+            }
+            Either::Right(group) => {
+                let old_ignore_whitespace = self.ignore_whitespace();
+                let new_ignore_whitespace = group
+                    .flags()
+                    .and_then(|f| f.flag_state(ast::Flag::IgnoreWhitespace))
+                    .unwrap_or(old_ignore_whitespace);
+                self.parser().stack_group.borrow_mut().push(
+                    GroupState::Group {
+                        concat,
+                        group,
+                        ignore_whitespace: old_ignore_whitespace,
+                    },
+                );
+                self.parser().ignore_whitespace.set(new_ignore_whitespace);
+                Ok(ast::Concat { span: self.span(), asts: vec![] })
+            }
+        }
+    }
+
+    /// Pop a group AST from the parser's internal stack and set the group's
+    /// AST to the given concatenation. Return the concatenation containing
+    /// the group.
+    ///
+    /// This assumes that the parser is currently positioned on the closing
+    /// parenthesis and advances the parser to the character following the `)`.
+    ///
+    /// If no such group could be popped, then an unopened group error is
+    /// returned.
+    #[inline(never)]
+    fn pop_group(&self, mut group_concat: ast::Concat) -> Result<ast::Concat> {
+        use self::GroupState::*;
+
+        assert_eq!(self.char(), ')');
+        let mut stack = self.parser().stack_group.borrow_mut();
+        let (mut prior_concat, mut group, ignore_whitespace, alt) = match stack
+            .pop()
+        {
+            Some(Group { concat, group, ignore_whitespace }) => {
+                (concat, group, ignore_whitespace, None)
+            }
+            Some(Alternation(alt)) => match stack.pop() {
+                Some(Group { concat, group, ignore_whitespace }) => {
+                    (concat, group, ignore_whitespace, Some(alt))
+                }
+                None | Some(Alternation(_)) => {
+                    return Err(self.error(
+                        self.span_char(),
+                        ast::ErrorKind::GroupUnopened,
+                    ));
+                }
+            },
+            None => {
+                return Err(self
+                    .error(self.span_char(), ast::ErrorKind::GroupUnopened));
+            }
+        };
+        self.parser().ignore_whitespace.set(ignore_whitespace);
+        group_concat.span.end = self.pos();
+        self.bump();
+        group.span.end = self.pos();
+        match alt {
+            Some(mut alt) => {
+                alt.span.end = group_concat.span.end;
+                alt.asts.push(group_concat.into_ast());
+                group.ast = Box::new(alt.into_ast());
+            }
+            None => {
+                group.ast = Box::new(group_concat.into_ast());
+            }
+        }
+        prior_concat.asts.push(Ast::Group(group));
+        Ok(prior_concat)
+    }
+
+    /// Pop the last state from the parser's internal stack, if it exists, and
+    /// add the given concatenation to it. There either must be no state or a
+    /// single alternation item on the stack. Any other scenario produces an
+    /// error.
+    ///
+    /// This assumes that the parser has advanced to the end.
+    #[inline(never)]
+    fn pop_group_end(&self, mut concat: ast::Concat) -> Result<Ast> {
+        concat.span.end = self.pos();
+        let mut stack = self.parser().stack_group.borrow_mut();
+        let ast = match stack.pop() {
+            None => Ok(concat.into_ast()),
+            Some(GroupState::Alternation(mut alt)) => {
+                alt.span.end = self.pos();
+                alt.asts.push(concat.into_ast());
+                Ok(Ast::Alternation(alt))
+            }
+            Some(GroupState::Group { group, .. }) => {
+                return Err(
+                    self.error(group.span, ast::ErrorKind::GroupUnclosed)
+                );
+            }
+        };
+        // If we try to pop again, there should be nothing.
+        match stack.pop() {
+            None => ast,
+            Some(GroupState::Alternation(_)) => {
+                // This unreachable is unfortunate. This case can't happen
+                // because the only way we can be here is if there were two
+                // `GroupState::Alternation`s adjacent in the parser's stack,
+                // which we guarantee to never happen because we never push a
+                // `GroupState::Alternation` if one is already at the top of
+                // the stack.
+                unreachable!()
+            }
+            Some(GroupState::Group { group, .. }) => {
+                Err(self.error(group.span, ast::ErrorKind::GroupUnclosed))
+            }
+        }
+    }
+
+    /// Parse the opening of a character class and push the current class
+    /// parsing context onto the parser's stack. This assumes that the parser
+    /// is positioned at an opening `[`. The given union should correspond to
+    /// the union of set items built up before seeing the `[`.
+    ///
+    /// If there was a problem parsing the opening of the class, then an error
+    /// is returned. Otherwise, a new union of set items for the class is
+    /// returned (which may be populated with either a `]` or a `-`).
+    #[inline(never)]
+    fn push_class_open(
+        &self,
+        parent_union: ast::ClassSetUnion,
+    ) -> Result<ast::ClassSetUnion> {
+        assert_eq!(self.char(), '[');
+
+        let (nested_set, nested_union) = self.parse_set_class_open()?;
+        self.parser()
+            .stack_class
+            .borrow_mut()
+            .push(ClassState::Open { union: parent_union, set: nested_set });
+        Ok(nested_union)
+    }
+
+    /// Parse the end of a character class set and pop the character class
+    /// parser stack. The union given corresponds to the last union built
+    /// before seeing the closing `]`. The union returned corresponds to the
+    /// parent character class set with the nested class added to it.
+    ///
+    /// This assumes that the parser is positioned at a `]` and will advance
+    /// the parser to the byte immediately following the `]`.
+    ///
+    /// If the stack is empty after popping, then this returns the final
+    /// "top-level" character class AST (where a "top-level" character class
+    /// is one that is not nested inside any other character class).
+    ///
+    /// If there is no corresponding opening bracket on the parser's stack,
+    /// then an error is returned.
+    #[inline(never)]
+    fn pop_class(
+        &self,
+        nested_union: ast::ClassSetUnion,
+    ) -> Result<Either<ast::ClassSetUnion, ast::Class>> {
+        assert_eq!(self.char(), ']');
+
+        let item = ast::ClassSet::Item(nested_union.into_item());
+        let prevset = self.pop_class_op(item);
+        let mut stack = self.parser().stack_class.borrow_mut();
+        match stack.pop() {
+            None => {
+                // We can never observe an empty stack:
+                //
+                // 1) We are guaranteed to start with a non-empty stack since
+                //    the character class parser is only initiated when it sees
+                //    a `[`.
+                // 2) If we ever observe an empty stack while popping after
+                //    seeing a `]`, then we signal the character class parser
+                //    to terminate.
+                panic!("unexpected empty character class stack")
+            }
+            Some(ClassState::Op { .. }) => {
+                // This panic is unfortunate, but this case is impossible
+                // since we already popped the Op state if one exists above.
+                // Namely, every push to the class parser stack is guarded by
+                // whether an existing Op is already on the top of the stack.
+                // If it is, the existing Op is modified. That is, the stack
+                // can never have consecutive Op states.
+                panic!("unexpected ClassState::Op")
+            }
+            Some(ClassState::Open { mut union, mut set }) => {
+                self.bump();
+                set.span.end = self.pos();
+                set.kind = prevset;
+                if stack.is_empty() {
+                    Ok(Either::Right(ast::Class::Bracketed(set)))
+                } else {
+                    union.push(ast::ClassSetItem::Bracketed(Box::new(set)));
+                    Ok(Either::Left(union))
+                }
+            }
+        }
+    }
+
+    /// Return an "unclosed class" error whose span points to the most
+    /// recently opened class.
+    ///
+    /// This should only be called while parsing a character class.
+    #[inline(never)]
+    fn unclosed_class_error(&self) -> ast::Error {
+        for state in self.parser().stack_class.borrow().iter().rev() {
+            if let ClassState::Open { ref set, .. } = *state {
+                return self.error(set.span, ast::ErrorKind::ClassUnclosed);
+            }
+        }
+        // We are guaranteed to have a non-empty stack with at least
+        // one open bracket, so we should never get here.
+        panic!("no open character class found")
+    }
+
+    /// Push the current set of class items on to the class parser's stack as
+    /// the left hand side of the given operator.
+    ///
+    /// A fresh set union is returned, which should be used to build the right
+    /// hand side of this operator.
+    #[inline(never)]
+    fn push_class_op(
+        &self,
+        next_kind: ast::ClassSetBinaryOpKind,
+        next_union: ast::ClassSetUnion,
+    ) -> ast::ClassSetUnion {
+        let item = ast::ClassSet::Item(next_union.into_item());
+        let new_lhs = self.pop_class_op(item);
+        self.parser()
+            .stack_class
+            .borrow_mut()
+            .push(ClassState::Op { kind: next_kind, lhs: new_lhs });
+        ast::ClassSetUnion { span: self.span(), items: vec![] }
+    }
+
+    /// Pop a character class set from the character class parser stack. If the
+    /// top of the stack is just an item (not an operation), then return the
+    /// given set unchanged. If the top of the stack is an operation, then the
+    /// given set will be used as the rhs of the operation on the top of the
+    /// stack. In that case, the binary operation is returned as a set.
+    #[inline(never)]
+    fn pop_class_op(&self, rhs: ast::ClassSet) -> ast::ClassSet {
+        let mut stack = self.parser().stack_class.borrow_mut();
+        let (kind, lhs) = match stack.pop() {
+            Some(ClassState::Op { kind, lhs }) => (kind, lhs),
+            Some(state @ ClassState::Open { .. }) => {
+                stack.push(state);
+                return rhs;
+            }
+            None => unreachable!(),
+        };
+        let span = Span::new(lhs.span().start, rhs.span().end);
+        ast::ClassSet::BinaryOp(ast::ClassSetBinaryOp {
+            span,
+            kind,
+            lhs: Box::new(lhs),
+            rhs: Box::new(rhs),
+        })
+    }
+}
+
+impl<'s, P: Borrow<Parser>> ParserI<'s, P> {
+    /// Parse the regular expression into an abstract syntax tree.
+    fn parse(&self) -> Result<Ast> {
+        self.parse_with_comments().map(|astc| astc.ast)
+    }
+
+    /// Parse the regular expression and return an abstract syntax tree with
+    /// all of the comments found in the pattern.
+    fn parse_with_comments(&self) -> Result<ast::WithComments> {
+        assert_eq!(self.offset(), 0, "parser can only be used once");
+        self.parser().reset();
+        let mut concat = ast::Concat { span: self.span(), asts: vec![] };
+        loop {
+            self.bump_space();
+            if self.is_eof() {
+                break;
+            }
+            match self.char() {
+                '(' => concat = self.push_group(concat)?,
+                ')' => concat = self.pop_group(concat)?,
+                '|' => concat = self.push_alternate(concat)?,
+                '[' => {
+                    let class = self.parse_set_class()?;
+                    concat.asts.push(Ast::Class(class));
+                }
+                '?' => {
+                    concat = self.parse_uncounted_repetition(
+                        concat,
+                        ast::RepetitionKind::ZeroOrOne,
+                    )?;
+                }
+                '*' => {
+                    concat = self.parse_uncounted_repetition(
+                        concat,
+                        ast::RepetitionKind::ZeroOrMore,
+                    )?;
+                }
+                '+' => {
+                    concat = self.parse_uncounted_repetition(
+                        concat,
+                        ast::RepetitionKind::OneOrMore,
+                    )?;
+                }
+                '{' => {
+                    concat = self.parse_counted_repetition(concat)?;
+                }
+                _ => concat.asts.push(self.parse_primitive()?.into_ast()),
+            }
+        }
+        let ast = self.pop_group_end(concat)?;
+        NestLimiter::new(self).check(&ast)?;
+        Ok(ast::WithComments {
+            ast,
+            comments: mem::replace(
+                &mut *self.parser().comments.borrow_mut(),
+                vec![],
+            ),
+        })
+    }
+
+    /// Parses an uncounted repetition operation. An uncounted repetition
+    /// operator includes ?, * and +, but does not include the {m,n} syntax.
+    /// The given `kind` should correspond to the operator observed by the
+    /// caller.
+    ///
+    /// This assumes that the parser is currently positioned at the repetition
+    /// operator and advances the parser to the first character after the
+    /// operator. (Note that the operator may include a single additional `?`,
+    /// which makes the operator ungreedy.)
+    ///
+    /// The caller should include the concatenation that is being built. The
+    /// concatenation returned includes the repetition operator applied to the
+    /// last expression in the given concatenation.
+    #[inline(never)]
+    fn parse_uncounted_repetition(
+        &self,
+        mut concat: ast::Concat,
+        kind: ast::RepetitionKind,
+    ) -> Result<ast::Concat> {
+        assert!(
+            self.char() == '?' || self.char() == '*' || self.char() == '+'
+        );
+        let op_start = self.pos();
+        let ast = match concat.asts.pop() {
+            Some(ast) => ast,
+            None => {
+                return Err(
+                    self.error(self.span(), ast::ErrorKind::RepetitionMissing)
+                )
+            }
+        };
+        match ast {
+            Ast::Empty(_) | Ast::Flags(_) => {
+                return Err(
+                    self.error(self.span(), ast::ErrorKind::RepetitionMissing)
+                )
+            }
+            _ => {}
+        }
+        let mut greedy = true;
+        if self.bump() && self.char() == '?' {
+            greedy = false;
+            self.bump();
+        }
+        concat.asts.push(Ast::Repetition(ast::Repetition {
+            span: ast.span().with_end(self.pos()),
+            op: ast::RepetitionOp {
+                span: Span::new(op_start, self.pos()),
+                kind,
+            },
+            greedy,
+            ast: Box::new(ast),
+        }));
+        Ok(concat)
+    }
+
+    /// Parses a counted repetition operation. A counted repetition operator
+    /// corresponds to the {m,n} syntax, and does not include the ?, * or +
+    /// operators.
+    ///
+    /// This assumes that the parser is currently positioned at the opening `{`
+    /// and advances the parser to the first character after the operator.
+    /// (Note that the operator may include a single additional `?`, which
+    /// makes the operator ungreedy.)
+    ///
+    /// The caller should include the concatenation that is being built. The
+    /// concatenation returned includes the repetition operator applied to the
+    /// last expression in the given concatenation.
+    #[inline(never)]
+    fn parse_counted_repetition(
+        &self,
+        mut concat: ast::Concat,
+    ) -> Result<ast::Concat> {
+        assert!(self.char() == '{');
+        let start = self.pos();
+        let ast = match concat.asts.pop() {
+            Some(ast) => ast,
+            None => {
+                return Err(
+                    self.error(self.span(), ast::ErrorKind::RepetitionMissing)
+                )
+            }
+        };
+        match ast {
+            Ast::Empty(_) | Ast::Flags(_) => {
+                return Err(
+                    self.error(self.span(), ast::ErrorKind::RepetitionMissing)
+                )
+            }
+            _ => {}
+        }
+        if !self.bump_and_bump_space() {
+            return Err(self.error(
+                Span::new(start, self.pos()),
+                ast::ErrorKind::RepetitionCountUnclosed,
+            ));
+        }
+        let count_start = specialize_err(
+            self.parse_decimal(),
+            ast::ErrorKind::DecimalEmpty,
+            ast::ErrorKind::RepetitionCountDecimalEmpty,
+        )?;
+        let mut range = ast::RepetitionRange::Exactly(count_start);
+        if self.is_eof() {
+            return Err(self.error(
+                Span::new(start, self.pos()),
+                ast::ErrorKind::RepetitionCountUnclosed,
+            ));
+        }
+        if self.char() == ',' {
+            if !self.bump_and_bump_space() {
+                return Err(self.error(
+                    Span::new(start, self.pos()),
+                    ast::ErrorKind::RepetitionCountUnclosed,
+                ));
+            }
+            if self.char() != '}' {
+                let count_end = specialize_err(
+                    self.parse_decimal(),
+                    ast::ErrorKind::DecimalEmpty,
+                    ast::ErrorKind::RepetitionCountDecimalEmpty,
+                )?;
+                range = ast::RepetitionRange::Bounded(count_start, count_end);
+            } else {
+                range = ast::RepetitionRange::AtLeast(count_start);
+            }
+        }
+        if self.is_eof() || self.char() != '}' {
+            return Err(self.error(
+                Span::new(start, self.pos()),
+                ast::ErrorKind::RepetitionCountUnclosed,
+            ));
+        }
+
+        let mut greedy = true;
+        if self.bump_and_bump_space() && self.char() == '?' {
+            greedy = false;
+            self.bump();
+        }
+
+        let op_span = Span::new(start, self.pos());
+        if !range.is_valid() {
+            return Err(
+                self.error(op_span, ast::ErrorKind::RepetitionCountInvalid)
+            );
+        }
+        concat.asts.push(Ast::Repetition(ast::Repetition {
+            span: ast.span().with_end(self.pos()),
+            op: ast::RepetitionOp {
+                span: op_span,
+                kind: ast::RepetitionKind::Range(range),
+            },
+            greedy,
+            ast: Box::new(ast),
+        }));
+        Ok(concat)
+    }
+
+    /// Parse a group (which contains a sub-expression) or a set of flags.
+    ///
+    /// If a group was found, then it is returned with an empty AST. If a set
+    /// of flags is found, then that set is returned.
+    ///
+    /// The parser should be positioned at the opening parenthesis.
+    ///
+    /// This advances the parser to the character before the start of the
+    /// sub-expression (in the case of a group) or to the closing parenthesis
+    /// immediately following the set of flags.
+    ///
+    /// # Errors
+    ///
+    /// If flags are given and incorrectly specified, then a corresponding
+    /// error is returned.
+    ///
+    /// If a capture name is given and it is incorrectly specified, then a
+    /// corresponding error is returned.
+    #[inline(never)]
+    fn parse_group(&self) -> Result<Either<ast::SetFlags, ast::Group>> {
+        assert_eq!(self.char(), '(');
+        let open_span = self.span_char();
+        self.bump();
+        self.bump_space();
+        if self.is_lookaround_prefix() {
+            return Err(self.error(
+                Span::new(open_span.start, self.span().end),
+                ast::ErrorKind::UnsupportedLookAround,
+            ));
+        }
+        let inner_span = self.span();
+        if self.bump_if("?P<") {
+            let capture_index = self.next_capture_index(open_span)?;
+            let cap = self.parse_capture_name(capture_index)?;
+            Ok(Either::Right(ast::Group {
+                span: open_span,
+                kind: ast::GroupKind::CaptureName(cap),
+                ast: Box::new(Ast::Empty(self.span())),
+            }))
+        } else if self.bump_if("?") {
+            if self.is_eof() {
+                return Err(
+                    self.error(open_span, ast::ErrorKind::GroupUnclosed)
+                );
+            }
+            let flags = self.parse_flags()?;
+            let char_end = self.char();
+            self.bump();
+            if char_end == ')' {
+                // We don't allow empty flags, e.g., `(?)`. We instead
+                // interpret it as a repetition operator missing its argument.
+                if flags.items.is_empty() {
+                    return Err(self.error(
+                        inner_span,
+                        ast::ErrorKind::RepetitionMissing,
+                    ));
+                }
+                Ok(Either::Left(ast::SetFlags {
+                    span: Span { end: self.pos(), ..open_span },
+                    flags,
+                }))
+            } else {
+                assert_eq!(char_end, ':');
+                Ok(Either::Right(ast::Group {
+                    span: open_span,
+                    kind: ast::GroupKind::NonCapturing(flags),
+                    ast: Box::new(Ast::Empty(self.span())),
+                }))
+            }
+        } else {
+            let capture_index = self.next_capture_index(open_span)?;
+            Ok(Either::Right(ast::Group {
+                span: open_span,
+                kind: ast::GroupKind::CaptureIndex(capture_index),
+                ast: Box::new(Ast::Empty(self.span())),
+            }))
+        }
+    }
+
+    /// Parses a capture group name. Assumes that the parser is positioned at
+    /// the first character in the name following the opening `<` (and may
+    /// possibly be EOF). This advances the parser to the first character
+    /// following the closing `>`.
+    ///
+    /// The caller must provide the capture index of the group for this name.
+    #[inline(never)]
+    fn parse_capture_name(
+        &self,
+        capture_index: u32,
+    ) -> Result<ast::CaptureName> {
+        if self.is_eof() {
+            return Err(self
+                .error(self.span(), ast::ErrorKind::GroupNameUnexpectedEof));
+        }
+        let start = self.pos();
+        loop {
+            if self.char() == '>' {
+                break;
+            }
+            if !is_capture_char(self.char(), self.pos() == start) {
+                return Err(self.error(
+                    self.span_char(),
+                    ast::ErrorKind::GroupNameInvalid,
+                ));
+            }
+            if !self.bump() {
+                break;
+            }
+        }
+        let end = self.pos();
+        if self.is_eof() {
+            return Err(self
+                .error(self.span(), ast::ErrorKind::GroupNameUnexpectedEof));
+        }
+        assert_eq!(self.char(), '>');
+        self.bump();
+        let name = &self.pattern()[start.offset..end.offset];
+        if name.is_empty() {
+            return Err(self.error(
+                Span::new(start, start),
+                ast::ErrorKind::GroupNameEmpty,
+            ));
+        }
+        let capname = ast::CaptureName {
+            span: Span::new(start, end),
+            name: name.to_string(),
+            index: capture_index,
+        };
+        self.add_capture_name(&capname)?;
+        Ok(capname)
+    }
+
+    /// Parse a sequence of flags starting at the current character.
+    ///
+    /// This advances the parser to the character immediately following the
+    /// flags, which is guaranteed to be either `:` or `)`.
+    ///
+    /// # Errors
+    ///
+    /// If any flags are duplicated, then an error is returned.
+    ///
+    /// If the negation operator is used more than once, then an error is
+    /// returned.
+    ///
+    /// If no flags could be found or if the negation operation is not followed
+    /// by any flags, then an error is returned.
+    #[inline(never)]
+    fn parse_flags(&self) -> Result<ast::Flags> {
+        let mut flags = ast::Flags { span: self.span(), items: vec![] };
+        let mut last_was_negation = None;
+        while self.char() != ':' && self.char() != ')' {
+            if self.char() == '-' {
+                last_was_negation = Some(self.span_char());
+                let item = ast::FlagsItem {
+                    span: self.span_char(),
+                    kind: ast::FlagsItemKind::Negation,
+                };
+                if let Some(i) = flags.add_item(item) {
+                    return Err(self.error(
+                        self.span_char(),
+                        ast::ErrorKind::FlagRepeatedNegation {
+                            original: flags.items[i].span,
+                        },
+                    ));
+                }
+            } else {
+                last_was_negation = None;
+                let item = ast::FlagsItem {
+                    span: self.span_char(),
+                    kind: ast::FlagsItemKind::Flag(self.parse_flag()?),
+                };
+                if let Some(i) = flags.add_item(item) {
+                    return Err(self.error(
+                        self.span_char(),
+                        ast::ErrorKind::FlagDuplicate {
+                            original: flags.items[i].span,
+                        },
+                    ));
+                }
+            }
+            if !self.bump() {
+                return Err(
+                    self.error(self.span(), ast::ErrorKind::FlagUnexpectedEof)
+                );
+            }
+        }
+        if let Some(span) = last_was_negation {
+            return Err(self.error(span, ast::ErrorKind::FlagDanglingNegation));
+        }
+        flags.span.end = self.pos();
+        Ok(flags)
+    }
+
+    /// Parse the current character as a flag. Do not advance the parser.
+    ///
+    /// # Errors
+    ///
+    /// If the flag is not recognized, then an error is returned.
+    #[inline(never)]
+    fn parse_flag(&self) -> Result<ast::Flag> {
+        match self.char() {
+            'i' => Ok(ast::Flag::CaseInsensitive),
+            'm' => Ok(ast::Flag::MultiLine),
+            's' => Ok(ast::Flag::DotMatchesNewLine),
+            'U' => Ok(ast::Flag::SwapGreed),
+            'u' => Ok(ast::Flag::Unicode),
+            'x' => Ok(ast::Flag::IgnoreWhitespace),
+            _ => {
+                Err(self
+                    .error(self.span_char(), ast::ErrorKind::FlagUnrecognized))
+            }
+        }
+    }
+
+    /// Parse a primitive AST. e.g., A literal, non-set character class or
+    /// assertion.
+    ///
+    /// This assumes that the parser expects a primitive at the current
+    /// location. i.e., All other non-primitive cases have been handled.
+    /// For example, if the parser's position is at `|`, then `|` will be
+    /// treated as a literal (e.g., inside a character class).
+    ///
+    /// This advances the parser to the first character immediately following
+    /// the primitive.
+    fn parse_primitive(&self) -> Result<Primitive> {
+        match self.char() {
+            '\\' => self.parse_escape(),
+            '.' => {
+                let ast = Primitive::Dot(self.span_char());
+                self.bump();
+                Ok(ast)
+            }
+            '^' => {
+                let ast = Primitive::Assertion(ast::Assertion {
+                    span: self.span_char(),
+                    kind: ast::AssertionKind::StartLine,
+                });
+                self.bump();
+                Ok(ast)
+            }
+            '$' => {
+                let ast = Primitive::Assertion(ast::Assertion {
+                    span: self.span_char(),
+                    kind: ast::AssertionKind::EndLine,
+                });
+                self.bump();
+                Ok(ast)
+            }
+            c => {
+                let ast = Primitive::Literal(ast::Literal {
+                    span: self.span_char(),
+                    kind: ast::LiteralKind::Verbatim,
+                    c,
+                });
+                self.bump();
+                Ok(ast)
+            }
+        }
+    }
+
+    /// Parse an escape sequence as a primitive AST.
+    ///
+    /// This assumes the parser is positioned at the start of the escape
+    /// sequence, i.e., `\`. It advances the parser to the first position
+    /// immediately following the escape sequence.
+    #[inline(never)]
+    fn parse_escape(&self) -> Result<Primitive> {
+        assert_eq!(self.char(), '\\');
+        let start = self.pos();
+        if !self.bump() {
+            return Err(self.error(
+                Span::new(start, self.pos()),
+                ast::ErrorKind::EscapeUnexpectedEof,
+            ));
+        }
+        let c = self.char();
+        // Put some of the more complicated routines into helpers.
+        match c {
+            '0'..='7' => {
+                if !self.parser().octal {
+                    return Err(self.error(
+                        Span::new(start, self.span_char().end),
+                        ast::ErrorKind::UnsupportedBackreference,
+                    ));
+                }
+                let mut lit = self.parse_octal();
+                lit.span.start = start;
+                return Ok(Primitive::Literal(lit));
+            }
+            '8'..='9' if !self.parser().octal => {
+                return Err(self.error(
+                    Span::new(start, self.span_char().end),
+                    ast::ErrorKind::UnsupportedBackreference,
+                ));
+            }
+            'x' | 'u' | 'U' => {
+                let mut lit = self.parse_hex()?;
+                lit.span.start = start;
+                return Ok(Primitive::Literal(lit));
+            }
+            'p' | 'P' => {
+                let mut cls = self.parse_unicode_class()?;
+                cls.span.start = start;
+                return Ok(Primitive::Unicode(cls));
+            }
+            'd' | 's' | 'w' | 'D' | 'S' | 'W' => {
+                let mut cls = self.parse_perl_class();
+                cls.span.start = start;
+                return Ok(Primitive::Perl(cls));
+            }
+            _ => {}
+        }
+
+        // Handle all of the one letter sequences inline.
+        self.bump();
+        let span = Span::new(start, self.pos());
+        if is_meta_character(c) {
+            return Ok(Primitive::Literal(ast::Literal {
+                span,
+                kind: ast::LiteralKind::Punctuation,
+                c,
+            }));
+        }
+        let special = |kind, c| {
+            Ok(Primitive::Literal(ast::Literal {
+                span,
+                kind: ast::LiteralKind::Special(kind),
+                c,
+            }))
+        };
+        match c {
+            'a' => special(ast::SpecialLiteralKind::Bell, '\x07'),
+            'f' => special(ast::SpecialLiteralKind::FormFeed, '\x0C'),
+            't' => special(ast::SpecialLiteralKind::Tab, '\t'),
+            'n' => special(ast::SpecialLiteralKind::LineFeed, '\n'),
+            'r' => special(ast::SpecialLiteralKind::CarriageReturn, '\r'),
+            'v' => special(ast::SpecialLiteralKind::VerticalTab, '\x0B'),
+            ' ' if self.ignore_whitespace() => {
+                special(ast::SpecialLiteralKind::Space, ' ')
+            }
+            'A' => Ok(Primitive::Assertion(ast::Assertion {
+                span,
+                kind: ast::AssertionKind::StartText,
+            })),
+            'z' => Ok(Primitive::Assertion(ast::Assertion {
+                span,
+                kind: ast::AssertionKind::EndText,
+            })),
+            'b' => Ok(Primitive::Assertion(ast::Assertion {
+                span,
+                kind: ast::AssertionKind::WordBoundary,
+            })),
+            'B' => Ok(Primitive::Assertion(ast::Assertion {
+                span,
+                kind: ast::AssertionKind::NotWordBoundary,
+            })),
+            _ => Err(self.error(span, ast::ErrorKind::EscapeUnrecognized)),
+        }
+    }
+
+    /// Parse an octal representation of a Unicode codepoint up to 3 digits
+    /// long. This expects the parser to be positioned at the first octal
+    /// digit and advances the parser to the first character immediately
+    /// following the octal number. This also assumes that parsing octal
+    /// escapes is enabled.
+    ///
+    /// Assuming the preconditions are met, this routine can never fail.
+    #[inline(never)]
+    fn parse_octal(&self) -> ast::Literal {
+        use std::char;
+        use std::u32;
+
+        assert!(self.parser().octal);
+        assert!('0' <= self.char() && self.char() <= '7');
+        let start = self.pos();
+        // Parse up to two more digits.
+        while self.bump()
+            && '0' <= self.char()
+            && self.char() <= '7'
+            && self.pos().offset - start.offset <= 2
+        {}
+        let end = self.pos();
+        let octal = &self.pattern()[start.offset..end.offset];
+        // Parsing the octal should never fail since the above guarantees a
+        // valid number.
+        let codepoint =
+            u32::from_str_radix(octal, 8).expect("valid octal number");
+        // The max value for 3 digit octal is 0777 = 511 and [0, 511] has no
+        // invalid Unicode scalar values.
+        let c = char::from_u32(codepoint).expect("Unicode scalar value");
+        ast::Literal {
+            span: Span::new(start, end),
+            kind: ast::LiteralKind::Octal,
+            c,
+        }
+    }
+
+    /// Parse a hex representation of a Unicode codepoint. This handles both
+    /// hex notations, i.e., `\xFF` and `\x{FFFF}`. This expects the parser to
+    /// be positioned at the `x`, `u` or `U` prefix. The parser is advanced to
+    /// the first character immediately following the hexadecimal literal.
+    #[inline(never)]
+    fn parse_hex(&self) -> Result<ast::Literal> {
+        assert!(
+            self.char() == 'x' || self.char() == 'u' || self.char() == 'U'
+        );
+
+        let hex_kind = match self.char() {
+            'x' => ast::HexLiteralKind::X,
+            'u' => ast::HexLiteralKind::UnicodeShort,
+            _ => ast::HexLiteralKind::UnicodeLong,
+        };
+        if !self.bump_and_bump_space() {
+            return Err(
+                self.error(self.span(), ast::ErrorKind::EscapeUnexpectedEof)
+            );
+        }
+        if self.char() == '{' {
+            self.parse_hex_brace(hex_kind)
+        } else {
+            self.parse_hex_digits(hex_kind)
+        }
+    }
+
+    /// Parse an N-digit hex representation of a Unicode codepoint. This
+    /// expects the parser to be positioned at the first digit and will advance
+    /// the parser to the first character immediately following the escape
+    /// sequence.
+    ///
+    /// The number of digits given must be 2 (for `\xNN`), 4 (for `\uNNNN`)
+    /// or 8 (for `\UNNNNNNNN`).
+    #[inline(never)]
+    fn parse_hex_digits(
+        &self,
+        kind: ast::HexLiteralKind,
+    ) -> Result<ast::Literal> {
+        use std::char;
+        use std::u32;
+
+        let mut scratch = self.parser().scratch.borrow_mut();
+        scratch.clear();
+
+        let start = self.pos();
+        for i in 0..kind.digits() {
+            if i > 0 && !self.bump_and_bump_space() {
+                return Err(self
+                    .error(self.span(), ast::ErrorKind::EscapeUnexpectedEof));
+            }
+            if !is_hex(self.char()) {
+                return Err(self.error(
+                    self.span_char(),
+                    ast::ErrorKind::EscapeHexInvalidDigit,
+                ));
+            }
+            scratch.push(self.char());
+        }
+        // The final bump just moves the parser past the literal, which may
+        // be EOF.
+        self.bump_and_bump_space();
+        let end = self.pos();
+        let hex = scratch.as_str();
+        match u32::from_str_radix(hex, 16).ok().and_then(char::from_u32) {
+            None => Err(self.error(
+                Span::new(start, end),
+                ast::ErrorKind::EscapeHexInvalid,
+            )),
+            Some(c) => Ok(ast::Literal {
+                span: Span::new(start, end),
+                kind: ast::LiteralKind::HexFixed(kind),
+                c,
+            }),
+        }
+    }
+
+    /// Parse a hex representation of any Unicode scalar value. This expects
+    /// the parser to be positioned at the opening brace `{` and will advance
+    /// the parser to the first character following the closing brace `}`.
+    #[inline(never)]
+    fn parse_hex_brace(
+        &self,
+        kind: ast::HexLiteralKind,
+    ) -> Result<ast::Literal> {
+        use std::char;
+        use std::u32;
+
+        let mut scratch = self.parser().scratch.borrow_mut();
+        scratch.clear();
+
+        let brace_pos = self.pos();
+        let start = self.span_char().end;
+        while self.bump_and_bump_space() && self.char() != '}' {
+            if !is_hex(self.char()) {
+                return Err(self.error(
+                    self.span_char(),
+                    ast::ErrorKind::EscapeHexInvalidDigit,
+                ));
+            }
+            scratch.push(self.char());
+        }
+        if self.is_eof() {
+            return Err(self.error(
+                Span::new(brace_pos, self.pos()),
+                ast::ErrorKind::EscapeUnexpectedEof,
+            ));
+        }
+        let end = self.pos();
+        let hex = scratch.as_str();
+        assert_eq!(self.char(), '}');
+        self.bump_and_bump_space();
+
+        if hex.is_empty() {
+            return Err(self.error(
+                Span::new(brace_pos, self.pos()),
+                ast::ErrorKind::EscapeHexEmpty,
+            ));
+        }
+        match u32::from_str_radix(hex, 16).ok().and_then(char::from_u32) {
+            None => Err(self.error(
+                Span::new(start, end),
+                ast::ErrorKind::EscapeHexInvalid,
+            )),
+            Some(c) => Ok(ast::Literal {
+                span: Span::new(start, self.pos()),
+                kind: ast::LiteralKind::HexBrace(kind),
+                c,
+            }),
+        }
+    }
+
+    /// Parse a decimal number into a u32 while trimming leading and trailing
+    /// whitespace.
+    ///
+    /// This expects the parser to be positioned at the first position where
+    /// a decimal digit could occur. This will advance the parser to the byte
+    /// immediately following the last contiguous decimal digit.
+    ///
+    /// If no decimal digit could be found or if there was a problem parsing
+    /// the complete set of digits into a u32, then an error is returned.
+    fn parse_decimal(&self) -> Result<u32> {
+        let mut scratch = self.parser().scratch.borrow_mut();
+        scratch.clear();
+
+        while !self.is_eof() && self.char().is_whitespace() {
+            self.bump();
+        }
+        let start = self.pos();
+        while !self.is_eof() && '0' <= self.char() && self.char() <= '9' {
+            scratch.push(self.char());
+            self.bump_and_bump_space();
+        }
+        let span = Span::new(start, self.pos());
+        while !self.is_eof() && self.char().is_whitespace() {
+            self.bump_and_bump_space();
+        }
+        let digits = scratch.as_str();
+        if digits.is_empty() {
+            return Err(self.error(span, ast::ErrorKind::DecimalEmpty));
+        }
+        match u32::from_str_radix(digits, 10).ok() {
+            Some(n) => Ok(n),
+            None => Err(self.error(span, ast::ErrorKind::DecimalInvalid)),
+        }
+    }
+
+    /// Parse a standard character class consisting primarily of characters or
+    /// character ranges, but can also contain nested character classes of
+    /// any type (sans `.`).
+    ///
+    /// This assumes the parser is positioned at the opening `[`. If parsing
+    /// is successful, then the parser is advanced to the position immediately
+    /// following the closing `]`.
+    #[inline(never)]
+    fn parse_set_class(&self) -> Result<ast::Class> {
+        assert_eq!(self.char(), '[');
+
+        let mut union =
+            ast::ClassSetUnion { span: self.span(), items: vec![] };
+        loop {
+            self.bump_space();
+            if self.is_eof() {
+                return Err(self.unclosed_class_error());
+            }
+            match self.char() {
+                '[' => {
+                    // If we've already parsed the opening bracket, then
+                    // attempt to treat this as the beginning of an ASCII
+                    // class. If ASCII class parsing fails, then the parser
+                    // backs up to `[`.
+                    if !self.parser().stack_class.borrow().is_empty() {
+                        if let Some(cls) = self.maybe_parse_ascii_class() {
+                            union.push(ast::ClassSetItem::Ascii(cls));
+                            continue;
+                        }
+                    }
+                    union = self.push_class_open(union)?;
+                }
+                ']' => match self.pop_class(union)? {
+                    Either::Left(nested_union) => {
+                        union = nested_union;
+                    }
+                    Either::Right(class) => return Ok(class),
+                },
+                '&' if self.peek() == Some('&') => {
+                    assert!(self.bump_if("&&"));
+                    union = self.push_class_op(
+                        ast::ClassSetBinaryOpKind::Intersection,
+                        union,
+                    );
+                }
+                '-' if self.peek() == Some('-') => {
+                    assert!(self.bump_if("--"));
+                    union = self.push_class_op(
+                        ast::ClassSetBinaryOpKind::Difference,
+                        union,
+                    );
+                }
+                '~' if self.peek() == Some('~') => {
+                    assert!(self.bump_if("~~"));
+                    union = self.push_class_op(
+                        ast::ClassSetBinaryOpKind::SymmetricDifference,
+                        union,
+                    );
+                }
+                _ => {
+                    union.push(self.parse_set_class_range()?);
+                }
+            }
+        }
+    }
+
+    /// Parse a single primitive item in a character class set. The item to
+    /// be parsed can either be one of a simple literal character, a range
+    /// between two simple literal characters or a "primitive" character
+    /// class like \w or \p{Greek}.
+    ///
+    /// If an invalid escape is found, or if a character class is found where
+    /// a simple literal is expected (e.g., in a range), then an error is
+    /// returned.
+    #[inline(never)]
+    fn parse_set_class_range(&self) -> Result<ast::ClassSetItem> {
+        let prim1 = self.parse_set_class_item()?;
+        self.bump_space();
+        if self.is_eof() {
+            return Err(self.unclosed_class_error());
+        }
+        // If the next char isn't a `-`, then we don't have a range.
+        // There are two exceptions. If the char after a `-` is a `]`, then
+        // `-` is interpreted as a literal `-`. Alternatively, if the char
+        // after a `-` is a `-`, then `--` corresponds to a "difference"
+        // operation.
+        if self.char() != '-'
+            || self.peek_space() == Some(']')
+            || self.peek_space() == Some('-')
+        {
+            return prim1.into_class_set_item(self);
+        }
+        // OK, now we're parsing a range, so bump past the `-` and parse the
+        // second half of the range.
+        if !self.bump_and_bump_space() {
+            return Err(self.unclosed_class_error());
+        }
+        let prim2 = self.parse_set_class_item()?;
+        let range = ast::ClassSetRange {
+            span: Span::new(prim1.span().start, prim2.span().end),
+            start: prim1.into_class_literal(self)?,
+            end: prim2.into_class_literal(self)?,
+        };
+        if !range.is_valid() {
+            return Err(
+                self.error(range.span, ast::ErrorKind::ClassRangeInvalid)
+            );
+        }
+        Ok(ast::ClassSetItem::Range(range))
+    }
+
+    /// Parse a single item in a character class as a primitive, where the
+    /// primitive either consists of a verbatim literal or a single escape
+    /// sequence.
+    ///
+    /// This assumes the parser is positioned at the beginning of a primitive,
+    /// and advances the parser to the first position after the primitive if
+    /// successful.
+    ///
+    /// Note that it is the caller's responsibility to report an error if an
+    /// illegal primitive was parsed.
+    #[inline(never)]
+    fn parse_set_class_item(&self) -> Result<Primitive> {
+        if self.char() == '\\' {
+            self.parse_escape()
+        } else {
+            let x = Primitive::Literal(ast::Literal {
+                span: self.span_char(),
+                kind: ast::LiteralKind::Verbatim,
+                c: self.char(),
+            });
+            self.bump();
+            Ok(x)
+        }
+    }
+
+    /// Parses the opening of a character class set. This includes the opening
+    /// bracket along with `^` if present to indicate negation. This also
+    /// starts parsing the opening set of unioned items if applicable, since
+    /// there are special rules applied to certain characters in the opening
+    /// of a character class. For example, `[^]]` is the class of all
+    /// characters not equal to `]`. (`]` would need to be escaped in any other
+    /// position.) Similarly for `-`.
+    ///
+    /// In all cases, the op inside the returned `ast::ClassBracketed` is an
+    /// empty union. This empty union should be replaced with the actual item
+    /// when it is popped from the parser's stack.
+    ///
+    /// This assumes the parser is positioned at the opening `[` and advances
+    /// the parser to the first non-special byte of the character class.
+    ///
+    /// An error is returned if EOF is found.
+    #[inline(never)]
+    fn parse_set_class_open(
+        &self,
+    ) -> Result<(ast::ClassBracketed, ast::ClassSetUnion)> {
+        assert_eq!(self.char(), '[');
+        let start = self.pos();
+        if !self.bump_and_bump_space() {
+            return Err(self.error(
+                Span::new(start, self.pos()),
+                ast::ErrorKind::ClassUnclosed,
+            ));
+        }
+
+        let negated = if self.char() != '^' {
+            false
+        } else {
+            if !self.bump_and_bump_space() {
+                return Err(self.error(
+                    Span::new(start, self.pos()),
+                    ast::ErrorKind::ClassUnclosed,
+                ));
+            }
+            true
+        };
+        // Accept any number of `-` as literal `-`.
+        let mut union =
+            ast::ClassSetUnion { span: self.span(), items: vec![] };
+        while self.char() == '-' {
+            union.push(ast::ClassSetItem::Literal(ast::Literal {
+                span: self.span_char(),
+                kind: ast::LiteralKind::Verbatim,
+                c: '-',
+            }));
+            if !self.bump_and_bump_space() {
+                return Err(self.error(
+                    Span::new(start, start),
+                    ast::ErrorKind::ClassUnclosed,
+                ));
+            }
+        }
+        // If `]` is the *first* char in a set, then interpret it as a literal
+        // `]`. That is, an empty class is impossible to write.
+        if union.items.is_empty() && self.char() == ']' {
+            union.push(ast::ClassSetItem::Literal(ast::Literal {
+                span: self.span_char(),
+                kind: ast::LiteralKind::Verbatim,
+                c: ']',
+            }));
+            if !self.bump_and_bump_space() {
+                return Err(self.error(
+                    Span::new(start, self.pos()),
+                    ast::ErrorKind::ClassUnclosed,
+                ));
+            }
+        }
+        let set = ast::ClassBracketed {
+            span: Span::new(start, self.pos()),
+            negated,
+            kind: ast::ClassSet::union(ast::ClassSetUnion {
+                span: Span::new(union.span.start, union.span.start),
+                items: vec![],
+            }),
+        };
+        Ok((set, union))
+    }
+
+    /// Attempt to parse an ASCII character class, e.g., `[:alnum:]`.
+    ///
+    /// This assumes the parser is positioned at the opening `[`.
+    ///
+    /// If no valid ASCII character class could be found, then this does not
+    /// advance the parser and `None` is returned. Otherwise, the parser is
+    /// advanced to the first byte following the closing `]` and the
+    /// corresponding ASCII class is returned.
+    #[inline(never)]
+    fn maybe_parse_ascii_class(&self) -> Option<ast::ClassAscii> {
+        // ASCII character classes are interesting from a parsing perspective
+        // because parsing cannot fail with any interesting error. For example,
+        // in order to use an ASCII character class, it must be enclosed in
+        // double brackets, e.g., `[[:alnum:]]`. Alternatively, you might think
+        // of it as "ASCII character characters have the syntax `[:NAME:]`
+        // which can only appear within character brackets." This means that
+        // things like `[[:lower:]A]` are legal constructs.
+        //
+        // However, if one types an incorrect ASCII character class, e.g.,
+        // `[[:loower:]]`, then we treat that as a normal nested character
+        // class containing the characters `:elorw`. One might argue that we
+        // should return an error instead since the repeated colons give away
+        // the intent to write an ASCII class. But what if the user typed
+        // `[[:lower]]` instead? How can we tell that was intended to be an
+        // ASCII class and not just a normal nested class?
+        //
+        // Reasonable people can probably disagree over this, but for better
+        // or worse, we implement semantics that never fails at the expense
+        // of better failure modes.
+        assert_eq!(self.char(), '[');
+        // If parsing fails, then we back up the parser to this starting point.
+        let start = self.pos();
+        let mut negated = false;
+        if !self.bump() || self.char() != ':' {
+            self.parser().pos.set(start);
+            return None;
+        }
+        if !self.bump() {
+            self.parser().pos.set(start);
+            return None;
+        }
+        if self.char() == '^' {
+            negated = true;
+            if !self.bump() {
+                self.parser().pos.set(start);
+                return None;
+            }
+        }
+        let name_start = self.offset();
+        while self.char() != ':' && self.bump() {}
+        if self.is_eof() {
+            self.parser().pos.set(start);
+            return None;
+        }
+        let name = &self.pattern()[name_start..self.offset()];
+        if !self.bump_if(":]") {
+            self.parser().pos.set(start);
+            return None;
+        }
+        let kind = match ast::ClassAsciiKind::from_name(name) {
+            Some(kind) => kind,
+            None => {
+                self.parser().pos.set(start);
+                return None;
+            }
+        };
+        Some(ast::ClassAscii {
+            span: Span::new(start, self.pos()),
+            kind,
+            negated,
+        })
+    }
+
+    /// Parse a Unicode class in either the single character notation, `\pN`
+    /// or the multi-character bracketed notation, `\p{Greek}`. This assumes
+    /// the parser is positioned at the `p` (or `P` for negation) and will
+    /// advance the parser to the character immediately following the class.
+    ///
+    /// Note that this does not check whether the class name is valid or not.
+    #[inline(never)]
+    fn parse_unicode_class(&self) -> Result<ast::ClassUnicode> {
+        assert!(self.char() == 'p' || self.char() == 'P');
+
+        let mut scratch = self.parser().scratch.borrow_mut();
+        scratch.clear();
+
+        let negated = self.char() == 'P';
+        if !self.bump_and_bump_space() {
+            return Err(
+                self.error(self.span(), ast::ErrorKind::EscapeUnexpectedEof)
+            );
+        }
+        let (start, kind) = if self.char() == '{' {
+            let start = self.span_char().end;
+            while self.bump_and_bump_space() && self.char() != '}' {
+                scratch.push(self.char());
+            }
+            if self.is_eof() {
+                return Err(self
+                    .error(self.span(), ast::ErrorKind::EscapeUnexpectedEof));
+            }
+            assert_eq!(self.char(), '}');
+            self.bump();
+
+            let name = scratch.as_str();
+            if let Some(i) = name.find("!=") {
+                (
+                    start,
+                    ast::ClassUnicodeKind::NamedValue {
+                        op: ast::ClassUnicodeOpKind::NotEqual,
+                        name: name[..i].to_string(),
+                        value: name[i + 2..].to_string(),
+                    },
+                )
+            } else if let Some(i) = name.find(':') {
+                (
+                    start,
+                    ast::ClassUnicodeKind::NamedValue {
+                        op: ast::ClassUnicodeOpKind::Colon,
+                        name: name[..i].to_string(),
+                        value: name[i + 1..].to_string(),
+                    },
+                )
+            } else if let Some(i) = name.find('=') {
+                (
+                    start,
+                    ast::ClassUnicodeKind::NamedValue {
+                        op: ast::ClassUnicodeOpKind::Equal,
+                        name: name[..i].to_string(),
+                        value: name[i + 1..].to_string(),
+                    },
+                )
+            } else {
+                (start, ast::ClassUnicodeKind::Named(name.to_string()))
+            }
+        } else {
+            let start = self.pos();
+            let c = self.char();
+            if c == '\\' {
+                return Err(self.error(
+                    self.span_char(),
+                    ast::ErrorKind::UnicodeClassInvalid,
+                ));
+            }
+            self.bump_and_bump_space();
+            let kind = ast::ClassUnicodeKind::OneLetter(c);
+            (start, kind)
+        };
+        Ok(ast::ClassUnicode {
+            span: Span::new(start, self.pos()),
+            negated,
+            kind,
+        })
+    }
+
+    /// Parse a Perl character class, e.g., `\d` or `\W`. This assumes the
+    /// parser is currently at a valid character class name and will be
+    /// advanced to the character immediately following the class.
+    #[inline(never)]
+    fn parse_perl_class(&self) -> ast::ClassPerl {
+        let c = self.char();
+        let span = self.span_char();
+        self.bump();
+        let (negated, kind) = match c {
+            'd' => (false, ast::ClassPerlKind::Digit),
+            'D' => (true, ast::ClassPerlKind::Digit),
+            's' => (false, ast::ClassPerlKind::Space),
+            'S' => (true, ast::ClassPerlKind::Space),
+            'w' => (false, ast::ClassPerlKind::Word),
+            'W' => (true, ast::ClassPerlKind::Word),
+            c => panic!("expected valid Perl class but got '{}'", c),
+        };
+        ast::ClassPerl { span, kind, negated }
+    }
+}
+
+/// A type that traverses a fully parsed Ast and checks whether its depth
+/// exceeds the specified nesting limit. If it does, then an error is returned.
+#[derive(Debug)]
+struct NestLimiter<'p, 's, P> {
+    /// The parser that is checking the nest limit.
+    p: &'p ParserI<'s, P>,
+    /// The current depth while walking an Ast.
+    depth: u32,
+}
+
+impl<'p, 's, P: Borrow<Parser>> NestLimiter<'p, 's, P> {
+    fn new(p: &'p ParserI<'s, P>) -> NestLimiter<'p, 's, P> {
+        NestLimiter { p, depth: 0 }
+    }
+
+    #[inline(never)]
+    fn check(self, ast: &Ast) -> Result<()> {
+        ast::visit(ast, self)
+    }
+
+    fn increment_depth(&mut self, span: &Span) -> Result<()> {
+        let new = self.depth.checked_add(1).ok_or_else(|| {
+            self.p.error(
+                span.clone(),
+                ast::ErrorKind::NestLimitExceeded(::std::u32::MAX),
+            )
+        })?;
+        let limit = self.p.parser().nest_limit;
+        if new > limit {
+            return Err(self.p.error(
+                span.clone(),
+                ast::ErrorKind::NestLimitExceeded(limit),
+            ));
+        }
+        self.depth = new;
+        Ok(())
+    }
+
+    fn decrement_depth(&mut self) {
+        // Assuming the correctness of the visitor, this should never drop
+        // below 0.
+        self.depth = self.depth.checked_sub(1).unwrap();
+    }
+}
+
+impl<'p, 's, P: Borrow<Parser>> ast::Visitor for NestLimiter<'p, 's, P> {
+    type Output = ();
+    type Err = ast::Error;
+
+    fn finish(self) -> Result<()> {
+        Ok(())
+    }
+
+    fn visit_pre(&mut self, ast: &Ast) -> Result<()> {
+        let span = match *ast {
+            Ast::Empty(_)
+            | Ast::Flags(_)
+            | Ast::Literal(_)
+            | Ast::Dot(_)
+            | Ast::Assertion(_)
+            | Ast::Class(ast::Class::Unicode(_))
+            | Ast::Class(ast::Class::Perl(_)) => {
+                // These are all base cases, so we don't increment depth.
+                return Ok(());
+            }
+            Ast::Class(ast::Class::Bracketed(ref x)) => &x.span,
+            Ast::Repetition(ref x) => &x.span,
+            Ast::Group(ref x) => &x.span,
+            Ast::Alternation(ref x) => &x.span,
+            Ast::Concat(ref x) => &x.span,
+        };
+        self.increment_depth(span)
+    }
+
+    fn visit_post(&mut self, ast: &Ast) -> Result<()> {
+        match *ast {
+            Ast::Empty(_)
+            | Ast::Flags(_)
+            | Ast::Literal(_)
+            | Ast::Dot(_)
+            | Ast::Assertion(_)
+            | Ast::Class(ast::Class::Unicode(_))
+            | Ast::Class(ast::Class::Perl(_)) => {
+                // These are all base cases, so we don't decrement depth.
+                Ok(())
+            }
+            Ast::Class(ast::Class::Bracketed(_))
+            | Ast::Repetition(_)
+            | Ast::Group(_)
+            | Ast::Alternation(_)
+            | Ast::Concat(_) => {
+                self.decrement_depth();
+                Ok(())
+            }
+        }
+    }
+
+    fn visit_class_set_item_pre(
+        &mut self,
+        ast: &ast::ClassSetItem,
+    ) -> Result<()> {
+        let span = match *ast {
+            ast::ClassSetItem::Empty(_)
+            | ast::ClassSetItem::Literal(_)
+            | ast::ClassSetItem::Range(_)
+            | ast::ClassSetItem::Ascii(_)
+            | ast::ClassSetItem::Unicode(_)
+            | ast::ClassSetItem::Perl(_) => {
+                // These are all base cases, so we don't increment depth.
+                return Ok(());
+            }
+            ast::ClassSetItem::Bracketed(ref x) => &x.span,
+            ast::ClassSetItem::Union(ref x) => &x.span,
+        };
+        self.increment_depth(span)
+    }
+
+    fn visit_class_set_item_post(
+        &mut self,
+        ast: &ast::ClassSetItem,
+    ) -> Result<()> {
+        match *ast {
+            ast::ClassSetItem::Empty(_)
+            | ast::ClassSetItem::Literal(_)
+            | ast::ClassSetItem::Range(_)
+            | ast::ClassSetItem::Ascii(_)
+            | ast::ClassSetItem::Unicode(_)
+            | ast::ClassSetItem::Perl(_) => {
+                // These are all base cases, so we don't decrement depth.
+                Ok(())
+            }
+            ast::ClassSetItem::Bracketed(_) | ast::ClassSetItem::Union(_) => {
+                self.decrement_depth();
+                Ok(())
+            }
+        }
+    }
+
+    fn visit_class_set_binary_op_pre(
+        &mut self,
+        ast: &ast::ClassSetBinaryOp,
+    ) -> Result<()> {
+        self.increment_depth(&ast.span)
+    }
+
+    fn visit_class_set_binary_op_post(
+        &mut self,
+        _ast: &ast::ClassSetBinaryOp,
+    ) -> Result<()> {
+        self.decrement_depth();
+        Ok(())
+    }
+}
+
+/// When the result is an error, transforms the ast::ErrorKind from the source
+/// Result into another one. This function is used to return clearer error
+/// messages when possible.
+fn specialize_err<T>(
+    result: Result<T>,
+    from: ast::ErrorKind,
+    to: ast::ErrorKind,
+) -> Result<T> {
+    if let Err(e) = result {
+        if e.kind == from {
+            Err(ast::Error { kind: to, pattern: e.pattern, span: e.span })
+        } else {
+            Err(e)
+        }
+    } else {
+        result
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::ops::Range;
+
+    use super::{Parser, ParserBuilder, ParserI, Primitive};
+    use crate::ast::{self, Ast, Position, Span};
+
+    // Our own assert_eq, which has slightly better formatting (but honestly
+    // still kind of crappy).
+    macro_rules! assert_eq {
+        ($left:expr, $right:expr) => {{
+            match (&$left, &$right) {
+                (left_val, right_val) => {
+                    if !(*left_val == *right_val) {
+                        panic!(
+                            "assertion failed: `(left == right)`\n\n\
+                             left:  `{:?}`\nright: `{:?}`\n\n",
+                            left_val, right_val
+                        )
+                    }
+                }
+            }
+        }};
+    }
+
+    // We create these errors to compare with real ast::Errors in the tests.
+    // We define equality between TestError and ast::Error to disregard the
+    // pattern string in ast::Error, which is annoying to provide in tests.
+    #[derive(Clone, Debug)]
+    struct TestError {
+        span: Span,
+        kind: ast::ErrorKind,
+    }
+
+    impl PartialEq<ast::Error> for TestError {
+        fn eq(&self, other: &ast::Error) -> bool {
+            self.span == other.span && self.kind == other.kind
+        }
+    }
+
+    impl PartialEq<TestError> for ast::Error {
+        fn eq(&self, other: &TestError) -> bool {
+            self.span == other.span && self.kind == other.kind
+        }
+    }
+
+    fn s(str: &str) -> String {
+        str.to_string()
+    }
+
+    fn parser(pattern: &str) -> ParserI<'_, Parser> {
+        ParserI::new(Parser::new(), pattern)
+    }
+
+    fn parser_octal(pattern: &str) -> ParserI<'_, Parser> {
+        let parser = ParserBuilder::new().octal(true).build();
+        ParserI::new(parser, pattern)
+    }
+
+    fn parser_nest_limit(
+        pattern: &str,
+        nest_limit: u32,
+    ) -> ParserI<'_, Parser> {
+        let p = ParserBuilder::new().nest_limit(nest_limit).build();
+        ParserI::new(p, pattern)
+    }
+
+    fn parser_ignore_whitespace(pattern: &str) -> ParserI<'_, Parser> {
+        let p = ParserBuilder::new().ignore_whitespace(true).build();
+        ParserI::new(p, pattern)
+    }
+
+    /// Short alias for creating a new span.
+    fn nspan(start: Position, end: Position) -> Span {
+        Span::new(start, end)
+    }
+
+    /// Short alias for creating a new position.
+    fn npos(offset: usize, line: usize, column: usize) -> Position {
+        Position::new(offset, line, column)
+    }
+
+    /// Create a new span from the given offset range. This assumes a single
+    /// line and sets the columns based on the offsets. i.e., This only works
+    /// out of the box for ASCII, which is fine for most tests.
+    fn span(range: Range<usize>) -> Span {
+        let start = Position::new(range.start, 1, range.start + 1);
+        let end = Position::new(range.end, 1, range.end + 1);
+        Span::new(start, end)
+    }
+
+    /// Create a new span for the corresponding byte range in the given string.
+    fn span_range(subject: &str, range: Range<usize>) -> Span {
+        let start = Position {
+            offset: range.start,
+            line: 1 + subject[..range.start].matches('\n').count(),
+            column: 1 + subject[..range.start]
+                .chars()
+                .rev()
+                .position(|c| c == '\n')
+                .unwrap_or(subject[..range.start].chars().count()),
+        };
+        let end = Position {
+            offset: range.end,
+            line: 1 + subject[..range.end].matches('\n').count(),
+            column: 1 + subject[..range.end]
+                .chars()
+                .rev()
+                .position(|c| c == '\n')
+                .unwrap_or(subject[..range.end].chars().count()),
+        };
+        Span::new(start, end)
+    }
+
+    /// Create a verbatim literal starting at the given position.
+    fn lit(c: char, start: usize) -> Ast {
+        lit_with(c, span(start..start + c.len_utf8()))
+    }
+
+    /// Create a punctuation literal starting at the given position.
+    fn punct_lit(c: char, span: Span) -> Ast {
+        Ast::Literal(ast::Literal {
+            span,
+            kind: ast::LiteralKind::Punctuation,
+            c,
+        })
+    }
+
+    /// Create a verbatim literal with the given span.
+    fn lit_with(c: char, span: Span) -> Ast {
+        Ast::Literal(ast::Literal {
+            span,
+            kind: ast::LiteralKind::Verbatim,
+            c,
+        })
+    }
+
+    /// Create a concatenation with the given range.
+    fn concat(range: Range<usize>, asts: Vec<Ast>) -> Ast {
+        concat_with(span(range), asts)
+    }
+
+    /// Create a concatenation with the given span.
+    fn concat_with(span: Span, asts: Vec<Ast>) -> Ast {
+        Ast::Concat(ast::Concat { span, asts })
+    }
+
+    /// Create an alternation with the given span.
+    fn alt(range: Range<usize>, asts: Vec<Ast>) -> Ast {
+        Ast::Alternation(ast::Alternation { span: span(range), asts })
+    }
+
+    /// Create a capturing group with the given span.
+    fn group(range: Range<usize>, index: u32, ast: Ast) -> Ast {
+        Ast::Group(ast::Group {
+            span: span(range),
+            kind: ast::GroupKind::CaptureIndex(index),
+            ast: Box::new(ast),
+        })
+    }
+
+    /// Create an ast::SetFlags.
+    ///
+    /// The given pattern should be the full pattern string. The range given
+    /// should correspond to the byte offsets where the flag set occurs.
+    ///
+    /// If negated is true, then the set is interpreted as beginning with a
+    /// negation.
+    fn flag_set(
+        pat: &str,
+        range: Range<usize>,
+        flag: ast::Flag,
+        negated: bool,
+    ) -> Ast {
+        let mut items = vec![ast::FlagsItem {
+            span: span_range(pat, (range.end - 2)..(range.end - 1)),
+            kind: ast::FlagsItemKind::Flag(flag),
+        }];
+        if negated {
+            items.insert(
+                0,
+                ast::FlagsItem {
+                    span: span_range(pat, (range.start + 2)..(range.end - 2)),
+                    kind: ast::FlagsItemKind::Negation,
+                },
+            );
+        }
+        Ast::Flags(ast::SetFlags {
+            span: span_range(pat, range.clone()),
+            flags: ast::Flags {
+                span: span_range(pat, (range.start + 2)..(range.end - 1)),
+                items,
+            },
+        })
+    }
+
+    #[test]
+    fn parse_nest_limit() {
+        // A nest limit of 0 still allows some types of regexes.
+        assert_eq!(
+            parser_nest_limit("", 0).parse(),
+            Ok(Ast::Empty(span(0..0)))
+        );
+        assert_eq!(parser_nest_limit("a", 0).parse(), Ok(lit('a', 0)));
+
+        // Test repetition operations, which require one level of nesting.
+        assert_eq!(
+            parser_nest_limit("a+", 0).parse().unwrap_err(),
+            TestError {
+                span: span(0..2),
+                kind: ast::ErrorKind::NestLimitExceeded(0),
+            }
+        );
+        assert_eq!(
+            parser_nest_limit("a+", 1).parse(),
+            Ok(Ast::Repetition(ast::Repetition {
+                span: span(0..2),
+                op: ast::RepetitionOp {
+                    span: span(1..2),
+                    kind: ast::RepetitionKind::OneOrMore,
+                },
+                greedy: true,
+                ast: Box::new(lit('a', 0)),
+            }))
+        );
+        assert_eq!(
+            parser_nest_limit("(a)+", 1).parse().unwrap_err(),
+            TestError {
+                span: span(0..3),
+                kind: ast::ErrorKind::NestLimitExceeded(1),
+            }
+        );
+        assert_eq!(
+            parser_nest_limit("a+*", 1).parse().unwrap_err(),
+            TestError {
+                span: span(0..2),
+                kind: ast::ErrorKind::NestLimitExceeded(1),
+            }
+        );
+        assert_eq!(
+            parser_nest_limit("a+*", 2).parse(),
+            Ok(Ast::Repetition(ast::Repetition {
+                span: span(0..3),
+                op: ast::RepetitionOp {
+                    span: span(2..3),
+                    kind: ast::RepetitionKind::ZeroOrMore,
+                },
+                greedy: true,
+                ast: Box::new(Ast::Repetition(ast::Repetition {
+                    span: span(0..2),
+                    op: ast::RepetitionOp {
+                        span: span(1..2),
+                        kind: ast::RepetitionKind::OneOrMore,
+                    },
+                    greedy: true,
+                    ast: Box::new(lit('a', 0)),
+                })),
+            }))
+        );
+
+        // Test concatenations. A concatenation requires one level of nesting.
+        assert_eq!(
+            parser_nest_limit("ab", 0).parse().unwrap_err(),
+            TestError {
+                span: span(0..2),
+                kind: ast::ErrorKind::NestLimitExceeded(0),
+            }
+        );
+        assert_eq!(
+            parser_nest_limit("ab", 1).parse(),
+            Ok(concat(0..2, vec![lit('a', 0), lit('b', 1)]))
+        );
+        assert_eq!(
+            parser_nest_limit("abc", 1).parse(),
+            Ok(concat(0..3, vec![lit('a', 0), lit('b', 1), lit('c', 2)]))
+        );
+
+        // Test alternations. An alternation requires one level of nesting.
+        assert_eq!(
+            parser_nest_limit("a|b", 0).parse().unwrap_err(),
+            TestError {
+                span: span(0..3),
+                kind: ast::ErrorKind::NestLimitExceeded(0),
+            }
+        );
+        assert_eq!(
+            parser_nest_limit("a|b", 1).parse(),
+            Ok(alt(0..3, vec![lit('a', 0), lit('b', 2)]))
+        );
+        assert_eq!(
+            parser_nest_limit("a|b|c", 1).parse(),
+            Ok(alt(0..5, vec![lit('a', 0), lit('b', 2), lit('c', 4)]))
+        );
+
+        // Test character classes. Classes form their own mini-recursive
+        // syntax!
+        assert_eq!(
+            parser_nest_limit("[a]", 0).parse().unwrap_err(),
+            TestError {
+                span: span(0..3),
+                kind: ast::ErrorKind::NestLimitExceeded(0),
+            }
+        );
+        assert_eq!(
+            parser_nest_limit("[a]", 1).parse(),
+            Ok(Ast::Class(ast::Class::Bracketed(ast::ClassBracketed {
+                span: span(0..3),
+                negated: false,
+                kind: ast::ClassSet::Item(ast::ClassSetItem::Literal(
+                    ast::Literal {
+                        span: span(1..2),
+                        kind: ast::LiteralKind::Verbatim,
+                        c: 'a',
+                    }
+                )),
+            })))
+        );
+        assert_eq!(
+            parser_nest_limit("[ab]", 1).parse().unwrap_err(),
+            TestError {
+                span: span(1..3),
+                kind: ast::ErrorKind::NestLimitExceeded(1),
+            }
+        );
+        assert_eq!(
+            parser_nest_limit("[ab[cd]]", 2).parse().unwrap_err(),
+            TestError {
+                span: span(3..7),
+                kind: ast::ErrorKind::NestLimitExceeded(2),
+            }
+        );
+        assert_eq!(
+            parser_nest_limit("[ab[cd]]", 3).parse().unwrap_err(),
+            TestError {
+                span: span(4..6),
+                kind: ast::ErrorKind::NestLimitExceeded(3),
+            }
+        );
+        assert_eq!(
+            parser_nest_limit("[a--b]", 1).parse().unwrap_err(),
+            TestError {
+                span: span(1..5),
+                kind: ast::ErrorKind::NestLimitExceeded(1),
+            }
+        );
+        assert_eq!(
+            parser_nest_limit("[a--bc]", 2).parse().unwrap_err(),
+            TestError {
+                span: span(4..6),
+                kind: ast::ErrorKind::NestLimitExceeded(2),
+            }
+        );
+    }
+
+    #[test]
+    fn parse_comments() {
+        let pat = "(?x)
+# This is comment 1.
+foo # This is comment 2.
+  # This is comment 3.
+bar
+# This is comment 4.";
+        let astc = parser(pat).parse_with_comments().unwrap();
+        assert_eq!(
+            astc.ast,
+            concat_with(
+                span_range(pat, 0..pat.len()),
+                vec![
+                    flag_set(pat, 0..4, ast::Flag::IgnoreWhitespace, false),
+                    lit_with('f', span_range(pat, 26..27)),
+                    lit_with('o', span_range(pat, 27..28)),
+                    lit_with('o', span_range(pat, 28..29)),
+                    lit_with('b', span_range(pat, 74..75)),
+                    lit_with('a', span_range(pat, 75..76)),
+                    lit_with('r', span_range(pat, 76..77)),
+                ]
+            )
+        );
+        assert_eq!(
+            astc.comments,
+            vec![
+                ast::Comment {
+                    span: span_range(pat, 5..26),
+                    comment: s(" This is comment 1."),
+                },
+                ast::Comment {
+                    span: span_range(pat, 30..51),
+                    comment: s(" This is comment 2."),
+                },
+                ast::Comment {
+                    span: span_range(pat, 53..74),
+                    comment: s(" This is comment 3."),
+                },
+                ast::Comment {
+                    span: span_range(pat, 78..98),
+                    comment: s(" This is comment 4."),
+                },
+            ]
+        );
+    }
+
+    #[test]
+    fn parse_holistic() {
+        assert_eq!(parser("]").parse(), Ok(lit(']', 0)));
+        assert_eq!(
+            parser(r"\\\.\+\*\?\(\)\|\[\]\{\}\^\$\#\&\-\~").parse(),
+            Ok(concat(
+                0..36,
+                vec![
+                    punct_lit('\\', span(0..2)),
+                    punct_lit('.', span(2..4)),
+                    punct_lit('+', span(4..6)),
+                    punct_lit('*', span(6..8)),
+                    punct_lit('?', span(8..10)),
+                    punct_lit('(', span(10..12)),
+                    punct_lit(')', span(12..14)),
+                    punct_lit('|', span(14..16)),
+                    punct_lit('[', span(16..18)),
+                    punct_lit(']', span(18..20)),
+                    punct_lit('{', span(20..22)),
+                    punct_lit('}', span(22..24)),
+                    punct_lit('^', span(24..26)),
+                    punct_lit('$', span(26..28)),
+                    punct_lit('#', span(28..30)),
+                    punct_lit('&', span(30..32)),
+                    punct_lit('-', span(32..34)),
+                    punct_lit('~', span(34..36)),
+                ]
+            ))
+        );
+    }
+
+    #[test]
+    fn parse_ignore_whitespace() {
+        // Test that basic whitespace insensitivity works.
+        let pat = "(?x)a b";
+        assert_eq!(
+            parser(pat).parse(),
+            Ok(concat_with(
+                nspan(npos(0, 1, 1), npos(7, 1, 8)),
+                vec![
+                    flag_set(pat, 0..4, ast::Flag::IgnoreWhitespace, false),
+                    lit_with('a', nspan(npos(4, 1, 5), npos(5, 1, 6))),
+                    lit_with('b', nspan(npos(6, 1, 7), npos(7, 1, 8))),
+                ]
+            ))
+        );
+
+        // Test that we can toggle whitespace insensitivity.
+        let pat = "(?x)a b(?-x)a b";
+        assert_eq!(
+            parser(pat).parse(),
+            Ok(concat_with(
+                nspan(npos(0, 1, 1), npos(15, 1, 16)),
+                vec![
+                    flag_set(pat, 0..4, ast::Flag::IgnoreWhitespace, false),
+                    lit_with('a', nspan(npos(4, 1, 5), npos(5, 1, 6))),
+                    lit_with('b', nspan(npos(6, 1, 7), npos(7, 1, 8))),
+                    flag_set(pat, 7..12, ast::Flag::IgnoreWhitespace, true),
+                    lit_with('a', nspan(npos(12, 1, 13), npos(13, 1, 14))),
+                    lit_with(' ', nspan(npos(13, 1, 14), npos(14, 1, 15))),
+                    lit_with('b', nspan(npos(14, 1, 15), npos(15, 1, 16))),
+                ]
+            ))
+        );
+
+        // Test that nesting whitespace insensitive flags works.
+        let pat = "a (?x:a )a ";
+        assert_eq!(
+            parser(pat).parse(),
+            Ok(concat_with(
+                span_range(pat, 0..11),
+                vec![
+                    lit_with('a', span_range(pat, 0..1)),
+                    lit_with(' ', span_range(pat, 1..2)),
+                    Ast::Group(ast::Group {
+                        span: span_range(pat, 2..9),
+                        kind: ast::GroupKind::NonCapturing(ast::Flags {
+                            span: span_range(pat, 4..5),
+                            items: vec![ast::FlagsItem {
+                                span: span_range(pat, 4..5),
+                                kind: ast::FlagsItemKind::Flag(
+                                    ast::Flag::IgnoreWhitespace
+                                ),
+                            },],
+                        }),
+                        ast: Box::new(lit_with('a', span_range(pat, 6..7))),
+                    }),
+                    lit_with('a', span_range(pat, 9..10)),
+                    lit_with(' ', span_range(pat, 10..11)),
+                ]
+            ))
+        );
+
+        // Test that whitespace after an opening paren is insignificant.
+        let pat = "(?x)( ?P<foo> a )";
+        assert_eq!(
+            parser(pat).parse(),
+            Ok(concat_with(
+                span_range(pat, 0..pat.len()),
+                vec![
+                    flag_set(pat, 0..4, ast::Flag::IgnoreWhitespace, false),
+                    Ast::Group(ast::Group {
+                        span: span_range(pat, 4..pat.len()),
+                        kind: ast::GroupKind::CaptureName(ast::CaptureName {
+                            span: span_range(pat, 9..12),
+                            name: s("foo"),
+                            index: 1,
+                        }),
+                        ast: Box::new(lit_with('a', span_range(pat, 14..15))),
+                    }),
+                ]
+            ))
+        );
+        let pat = "(?x)(  a )";
+        assert_eq!(
+            parser(pat).parse(),
+            Ok(concat_with(
+                span_range(pat, 0..pat.len()),
+                vec![
+                    flag_set(pat, 0..4, ast::Flag::IgnoreWhitespace, false),
+                    Ast::Group(ast::Group {
+                        span: span_range(pat, 4..pat.len()),
+                        kind: ast::GroupKind::CaptureIndex(1),
+                        ast: Box::new(lit_with('a', span_range(pat, 7..8))),
+                    }),
+                ]
+            ))
+        );
+        let pat = "(?x)(  ?:  a )";
+        assert_eq!(
+            parser(pat).parse(),
+            Ok(concat_with(
+                span_range(pat, 0..pat.len()),
+                vec![
+                    flag_set(pat, 0..4, ast::Flag::IgnoreWhitespace, false),
+                    Ast::Group(ast::Group {
+                        span: span_range(pat, 4..pat.len()),
+                        kind: ast::GroupKind::NonCapturing(ast::Flags {
+                            span: span_range(pat, 8..8),
+                            items: vec![],
+                        }),
+                        ast: Box::new(lit_with('a', span_range(pat, 11..12))),
+                    }),
+                ]
+            ))
+        );
+        let pat = r"(?x)\x { 53 }";
+        assert_eq!(
+            parser(pat).parse(),
+            Ok(concat_with(
+                span_range(pat, 0..pat.len()),
+                vec![
+                    flag_set(pat, 0..4, ast::Flag::IgnoreWhitespace, false),
+                    Ast::Literal(ast::Literal {
+                        span: span(4..13),
+                        kind: ast::LiteralKind::HexBrace(
+                            ast::HexLiteralKind::X
+                        ),
+                        c: 'S',
+                    }),
+                ]
+            ))
+        );
+
+        // Test that whitespace after an escape is OK.
+        let pat = r"(?x)\ ";
+        assert_eq!(
+            parser(pat).parse(),
+            Ok(concat_with(
+                span_range(pat, 0..pat.len()),
+                vec![
+                    flag_set(pat, 0..4, ast::Flag::IgnoreWhitespace, false),
+                    Ast::Literal(ast::Literal {
+                        span: span_range(pat, 4..6),
+                        kind: ast::LiteralKind::Special(
+                            ast::SpecialLiteralKind::Space
+                        ),
+                        c: ' ',
+                    }),
+                ]
+            ))
+        );
+        // ... but only when `x` mode is enabled.
+        let pat = r"\ ";
+        assert_eq!(
+            parser(pat).parse().unwrap_err(),
+            TestError {
+                span: span_range(pat, 0..2),
+                kind: ast::ErrorKind::EscapeUnrecognized,
+            }
+        );
+    }
+
+    #[test]
+    fn parse_newlines() {
+        let pat = ".\n.";
+        assert_eq!(
+            parser(pat).parse(),
+            Ok(concat_with(
+                span_range(pat, 0..3),
+                vec![
+                    Ast::Dot(span_range(pat, 0..1)),
+                    lit_with('\n', span_range(pat, 1..2)),
+                    Ast::Dot(span_range(pat, 2..3)),
+                ]
+            ))
+        );
+
+        let pat = "foobar\nbaz\nquux\n";
+        assert_eq!(
+            parser(pat).parse(),
+            Ok(concat_with(
+                span_range(pat, 0..pat.len()),
+                vec![
+                    lit_with('f', nspan(npos(0, 1, 1), npos(1, 1, 2))),
+                    lit_with('o', nspan(npos(1, 1, 2), npos(2, 1, 3))),
+                    lit_with('o', nspan(npos(2, 1, 3), npos(3, 1, 4))),
+                    lit_with('b', nspan(npos(3, 1, 4), npos(4, 1, 5))),
+                    lit_with('a', nspan(npos(4, 1, 5), npos(5, 1, 6))),
+                    lit_with('r', nspan(npos(5, 1, 6), npos(6, 1, 7))),
+                    lit_with('\n', nspan(npos(6, 1, 7), npos(7, 2, 1))),
+                    lit_with('b', nspan(npos(7, 2, 1), npos(8, 2, 2))),
+                    lit_with('a', nspan(npos(8, 2, 2), npos(9, 2, 3))),
+                    lit_with('z', nspan(npos(9, 2, 3), npos(10, 2, 4))),
+                    lit_with('\n', nspan(npos(10, 2, 4), npos(11, 3, 1))),
+                    lit_with('q', nspan(npos(11, 3, 1), npos(12, 3, 2))),
+                    lit_with('u', nspan(npos(12, 3, 2), npos(13, 3, 3))),
+                    lit_with('u', nspan(npos(13, 3, 3), npos(14, 3, 4))),
+                    lit_with('x', nspan(npos(14, 3, 4), npos(15, 3, 5))),
+                    lit_with('\n', nspan(npos(15, 3, 5), npos(16, 4, 1))),
+                ]
+            ))
+        );
+    }
+
+    #[test]
+    fn parse_uncounted_repetition() {
+        assert_eq!(
+            parser(r"a*").parse(),
+            Ok(Ast::Repetition(ast::Repetition {
+                span: span(0..2),
+                op: ast::RepetitionOp {
+                    span: span(1..2),
+                    kind: ast::RepetitionKind::ZeroOrMore,
+                },
+                greedy: true,
+                ast: Box::new(lit('a', 0)),
+            }))
+        );
+        assert_eq!(
+            parser(r"a+").parse(),
+            Ok(Ast::Repetition(ast::Repetition {
+                span: span(0..2),
+                op: ast::RepetitionOp {
+                    span: span(1..2),
+                    kind: ast::RepetitionKind::OneOrMore,
+                },
+                greedy: true,
+                ast: Box::new(lit('a', 0)),
+            }))
+        );
+
+        assert_eq!(
+            parser(r"a?").parse(),
+            Ok(Ast::Repetition(ast::Repetition {
+                span: span(0..2),
+                op: ast::RepetitionOp {
+                    span: span(1..2),
+                    kind: ast::RepetitionKind::ZeroOrOne,
+                },
+                greedy: true,
+                ast: Box::new(lit('a', 0)),
+            }))
+        );
+        assert_eq!(
+            parser(r"a??").parse(),
+            Ok(Ast::Repetition(ast::Repetition {
+                span: span(0..3),
+                op: ast::RepetitionOp {
+                    span: span(1..3),
+                    kind: ast::RepetitionKind::ZeroOrOne,
+                },
+                greedy: false,
+                ast: Box::new(lit('a', 0)),
+            }))
+        );
+        assert_eq!(
+            parser(r"a?").parse(),
+            Ok(Ast::Repetition(ast::Repetition {
+                span: span(0..2),
+                op: ast::RepetitionOp {
+                    span: span(1..2),
+                    kind: ast::RepetitionKind::ZeroOrOne,
+                },
+                greedy: true,
+                ast: Box::new(lit('a', 0)),
+            }))
+        );
+        assert_eq!(
+            parser(r"a?b").parse(),
+            Ok(concat(
+                0..3,
+                vec![
+                    Ast::Repetition(ast::Repetition {
+                        span: span(0..2),
+                        op: ast::RepetitionOp {
+                            span: span(1..2),
+                            kind: ast::RepetitionKind::ZeroOrOne,
+                        },
+                        greedy: true,
+                        ast: Box::new(lit('a', 0)),
+                    }),
+                    lit('b', 2),
+                ]
+            ))
+        );
+        assert_eq!(
+            parser(r"a??b").parse(),
+            Ok(concat(
+                0..4,
+                vec![
+                    Ast::Repetition(ast::Repetition {
+                        span: span(0..3),
+                        op: ast::RepetitionOp {
+                            span: span(1..3),
+                            kind: ast::RepetitionKind::ZeroOrOne,
+                        },
+                        greedy: false,
+                        ast: Box::new(lit('a', 0)),
+                    }),
+                    lit('b', 3),
+                ]
+            ))
+        );
+        assert_eq!(
+            parser(r"ab?").parse(),
+            Ok(concat(
+                0..3,
+                vec![
+                    lit('a', 0),
+                    Ast::Repetition(ast::Repetition {
+                        span: span(1..3),
+                        op: ast::RepetitionOp {
+                            span: span(2..3),
+                            kind: ast::RepetitionKind::ZeroOrOne,
+                        },
+                        greedy: true,
+                        ast: Box::new(lit('b', 1)),
+                    }),
+                ]
+            ))
+        );
+        assert_eq!(
+            parser(r"(ab)?").parse(),
+            Ok(Ast::Repetition(ast::Repetition {
+                span: span(0..5),
+                op: ast::RepetitionOp {
+                    span: span(4..5),
+                    kind: ast::RepetitionKind::ZeroOrOne,
+                },
+                greedy: true,
+                ast: Box::new(group(
+                    0..4,
+                    1,
+                    concat(1..3, vec![lit('a', 1), lit('b', 2),])
+                )),
+            }))
+        );
+        assert_eq!(
+            parser(r"|a?").parse(),
+            Ok(alt(
+                0..3,
+                vec![
+                    Ast::Empty(span(0..0)),
+                    Ast::Repetition(ast::Repetition {
+                        span: span(1..3),
+                        op: ast::RepetitionOp {
+                            span: span(2..3),
+                            kind: ast::RepetitionKind::ZeroOrOne,
+                        },
+                        greedy: true,
+                        ast: Box::new(lit('a', 1)),
+                    }),
+                ]
+            ))
+        );
+
+        assert_eq!(
+            parser(r"*").parse().unwrap_err(),
+            TestError {
+                span: span(0..0),
+                kind: ast::ErrorKind::RepetitionMissing,
+            }
+        );
+        assert_eq!(
+            parser(r"(?i)*").parse().unwrap_err(),
+            TestError {
+                span: span(4..4),
+                kind: ast::ErrorKind::RepetitionMissing,
+            }
+        );
+        assert_eq!(
+            parser(r"(*)").parse().unwrap_err(),
+            TestError {
+                span: span(1..1),
+                kind: ast::ErrorKind::RepetitionMissing,
+            }
+        );
+        assert_eq!(
+            parser(r"(?:?)").parse().unwrap_err(),
+            TestError {
+                span: span(3..3),
+                kind: ast::ErrorKind::RepetitionMissing,
+            }
+        );
+        assert_eq!(
+            parser(r"+").parse().unwrap_err(),
+            TestError {
+                span: span(0..0),
+                kind: ast::ErrorKind::RepetitionMissing,
+            }
+        );
+        assert_eq!(
+            parser(r"?").parse().unwrap_err(),
+            TestError {
+                span: span(0..0),
+                kind: ast::ErrorKind::RepetitionMissing,
+            }
+        );
+        assert_eq!(
+            parser(r"(?)").parse().unwrap_err(),
+            TestError {
+                span: span(1..1),
+                kind: ast::ErrorKind::RepetitionMissing,
+            }
+        );
+        assert_eq!(
+            parser(r"|*").parse().unwrap_err(),
+            TestError {
+                span: span(1..1),
+                kind: ast::ErrorKind::RepetitionMissing,
+            }
+        );
+        assert_eq!(
+            parser(r"|+").parse().unwrap_err(),
+            TestError {
+                span: span(1..1),
+                kind: ast::ErrorKind::RepetitionMissing,
+            }
+        );
+        assert_eq!(
+            parser(r"|?").parse().unwrap_err(),
+            TestError {
+                span: span(1..1),
+                kind: ast::ErrorKind::RepetitionMissing,
+            }
+        );
+    }
+
+    #[test]
+    fn parse_counted_repetition() {
+        assert_eq!(
+            parser(r"a{5}").parse(),
+            Ok(Ast::Repetition(ast::Repetition {
+                span: span(0..4),
+                op: ast::RepetitionOp {
+                    span: span(1..4),
+                    kind: ast::RepetitionKind::Range(
+                        ast::RepetitionRange::Exactly(5)
+                    ),
+                },
+                greedy: true,
+                ast: Box::new(lit('a', 0)),
+            }))
+        );
+        assert_eq!(
+            parser(r"a{5,}").parse(),
+            Ok(Ast::Repetition(ast::Repetition {
+                span: span(0..5),
+                op: ast::RepetitionOp {
+                    span: span(1..5),
+                    kind: ast::RepetitionKind::Range(
+                        ast::RepetitionRange::AtLeast(5)
+                    ),
+                },
+                greedy: true,
+                ast: Box::new(lit('a', 0)),
+            }))
+        );
+        assert_eq!(
+            parser(r"a{5,9}").parse(),
+            Ok(Ast::Repetition(ast::Repetition {
+                span: span(0..6),
+                op: ast::RepetitionOp {
+                    span: span(1..6),
+                    kind: ast::RepetitionKind::Range(
+                        ast::RepetitionRange::Bounded(5, 9)
+                    ),
+                },
+                greedy: true,
+                ast: Box::new(lit('a', 0)),
+            }))
+        );
+        assert_eq!(
+            parser(r"a{5}?").parse(),
+            Ok(Ast::Repetition(ast::Repetition {
+                span: span(0..5),
+                op: ast::RepetitionOp {
+                    span: span(1..5),
+                    kind: ast::RepetitionKind::Range(
+                        ast::RepetitionRange::Exactly(5)
+                    ),
+                },
+                greedy: false,
+                ast: Box::new(lit('a', 0)),
+            }))
+        );
+        assert_eq!(
+            parser(r"ab{5}").parse(),
+            Ok(concat(
+                0..5,
+                vec![
+                    lit('a', 0),
+                    Ast::Repetition(ast::Repetition {
+                        span: span(1..5),
+                        op: ast::RepetitionOp {
+                            span: span(2..5),
+                            kind: ast::RepetitionKind::Range(
+                                ast::RepetitionRange::Exactly(5)
+                            ),
+                        },
+                        greedy: true,
+                        ast: Box::new(lit('b', 1)),
+                    }),
+                ]
+            ))
+        );
+        assert_eq!(
+            parser(r"ab{5}c").parse(),
+            Ok(concat(
+                0..6,
+                vec![
+                    lit('a', 0),
+                    Ast::Repetition(ast::Repetition {
+                        span: span(1..5),
+                        op: ast::RepetitionOp {
+                            span: span(2..5),
+                            kind: ast::RepetitionKind::Range(
+                                ast::RepetitionRange::Exactly(5)
+                            ),
+                        },
+                        greedy: true,
+                        ast: Box::new(lit('b', 1)),
+                    }),
+                    lit('c', 5),
+                ]
+            ))
+        );
+
+        assert_eq!(
+            parser(r"a{ 5 }").parse(),
+            Ok(Ast::Repetition(ast::Repetition {
+                span: span(0..6),
+                op: ast::RepetitionOp {
+                    span: span(1..6),
+                    kind: ast::RepetitionKind::Range(
+                        ast::RepetitionRange::Exactly(5)
+                    ),
+                },
+                greedy: true,
+                ast: Box::new(lit('a', 0)),
+            }))
+        );
+        assert_eq!(
+            parser(r"a{ 5 , 9 }").parse(),
+            Ok(Ast::Repetition(ast::Repetition {
+                span: span(0..10),
+                op: ast::RepetitionOp {
+                    span: span(1..10),
+                    kind: ast::RepetitionKind::Range(
+                        ast::RepetitionRange::Bounded(5, 9)
+                    ),
+                },
+                greedy: true,
+                ast: Box::new(lit('a', 0)),
+            }))
+        );
+        assert_eq!(
+            parser_ignore_whitespace(r"a{5,9} ?").parse(),
+            Ok(Ast::Repetition(ast::Repetition {
+                span: span(0..8),
+                op: ast::RepetitionOp {
+                    span: span(1..8),
+                    kind: ast::RepetitionKind::Range(
+                        ast::RepetitionRange::Bounded(5, 9)
+                    ),
+                },
+                greedy: false,
+                ast: Box::new(lit('a', 0)),
+            }))
+        );
+
+        assert_eq!(
+            parser(r"(?i){0}").parse().unwrap_err(),
+            TestError {
+                span: span(4..4),
+                kind: ast::ErrorKind::RepetitionMissing,
+            }
+        );
+        assert_eq!(
+            parser(r"(?m){1,1}").parse().unwrap_err(),
+            TestError {
+                span: span(4..4),
+                kind: ast::ErrorKind::RepetitionMissing,
+            }
+        );
+        assert_eq!(
+            parser(r"a{]}").parse().unwrap_err(),
+            TestError {
+                span: span(2..2),
+                kind: ast::ErrorKind::RepetitionCountDecimalEmpty,
+            }
+        );
+        assert_eq!(
+            parser(r"a{1,]}").parse().unwrap_err(),
+            TestError {
+                span: span(4..4),
+                kind: ast::ErrorKind::RepetitionCountDecimalEmpty,
+            }
+        );
+        assert_eq!(
+            parser(r"a{").parse().unwrap_err(),
+            TestError {
+                span: span(1..2),
+                kind: ast::ErrorKind::RepetitionCountUnclosed,
+            }
+        );
+        assert_eq!(
+            parser(r"a{}").parse().unwrap_err(),
+            TestError {
+                span: span(2..2),
+                kind: ast::ErrorKind::RepetitionCountDecimalEmpty,
+            }
+        );
+        assert_eq!(
+            parser(r"a{a").parse().unwrap_err(),
+            TestError {
+                span: span(2..2),
+                kind: ast::ErrorKind::RepetitionCountDecimalEmpty,
+            }
+        );
+        assert_eq!(
+            parser(r"a{9999999999}").parse().unwrap_err(),
+            TestError {
+                span: span(2..12),
+                kind: ast::ErrorKind::DecimalInvalid,
+            }
+        );
+        assert_eq!(
+            parser(r"a{9").parse().unwrap_err(),
+            TestError {
+                span: span(1..3),
+                kind: ast::ErrorKind::RepetitionCountUnclosed,
+            }
+        );
+        assert_eq!(
+            parser(r"a{9,a").parse().unwrap_err(),
+            TestError {
+                span: span(4..4),
+                kind: ast::ErrorKind::RepetitionCountDecimalEmpty,
+            }
+        );
+        assert_eq!(
+            parser(r"a{9,9999999999}").parse().unwrap_err(),
+            TestError {
+                span: span(4..14),
+                kind: ast::ErrorKind::DecimalInvalid,
+            }
+        );
+        assert_eq!(
+            parser(r"a{9,").parse().unwrap_err(),
+            TestError {
+                span: span(1..4),
+                kind: ast::ErrorKind::RepetitionCountUnclosed,
+            }
+        );
+        assert_eq!(
+            parser(r"a{9,11").parse().unwrap_err(),
+            TestError {
+                span: span(1..6),
+                kind: ast::ErrorKind::RepetitionCountUnclosed,
+            }
+        );
+        assert_eq!(
+            parser(r"a{2,1}").parse().unwrap_err(),
+            TestError {
+                span: span(1..6),
+                kind: ast::ErrorKind::RepetitionCountInvalid,
+            }
+        );
+        assert_eq!(
+            parser(r"{5}").parse().unwrap_err(),
+            TestError {
+                span: span(0..0),
+                kind: ast::ErrorKind::RepetitionMissing,
+            }
+        );
+        assert_eq!(
+            parser(r"|{5}").parse().unwrap_err(),
+            TestError {
+                span: span(1..1),
+                kind: ast::ErrorKind::RepetitionMissing,
+            }
+        );
+    }
+
+    #[test]
+    fn parse_alternate() {
+        assert_eq!(
+            parser(r"a|b").parse(),
+            Ok(Ast::Alternation(ast::Alternation {
+                span: span(0..3),
+                asts: vec![lit('a', 0), lit('b', 2)],
+            }))
+        );
+        assert_eq!(
+            parser(r"(a|b)").parse(),
+            Ok(group(
+                0..5,
+                1,
+                Ast::Alternation(ast::Alternation {
+                    span: span(1..4),
+                    asts: vec![lit('a', 1), lit('b', 3)],
+                })
+            ))
+        );
+
+        assert_eq!(
+            parser(r"a|b|c").parse(),
+            Ok(Ast::Alternation(ast::Alternation {
+                span: span(0..5),
+                asts: vec![lit('a', 0), lit('b', 2), lit('c', 4)],
+            }))
+        );
+        assert_eq!(
+            parser(r"ax|by|cz").parse(),
+            Ok(Ast::Alternation(ast::Alternation {
+                span: span(0..8),
+                asts: vec![
+                    concat(0..2, vec![lit('a', 0), lit('x', 1)]),
+                    concat(3..5, vec![lit('b', 3), lit('y', 4)]),
+                    concat(6..8, vec![lit('c', 6), lit('z', 7)]),
+                ],
+            }))
+        );
+        assert_eq!(
+            parser(r"(ax|by|cz)").parse(),
+            Ok(group(
+                0..10,
+                1,
+                Ast::Alternation(ast::Alternation {
+                    span: span(1..9),
+                    asts: vec![
+                        concat(1..3, vec![lit('a', 1), lit('x', 2)]),
+                        concat(4..6, vec![lit('b', 4), lit('y', 5)]),
+                        concat(7..9, vec![lit('c', 7), lit('z', 8)]),
+                    ],
+                })
+            ))
+        );
+        assert_eq!(
+            parser(r"(ax|(by|(cz)))").parse(),
+            Ok(group(
+                0..14,
+                1,
+                alt(
+                    1..13,
+                    vec![
+                        concat(1..3, vec![lit('a', 1), lit('x', 2)]),
+                        group(
+                            4..13,
+                            2,
+                            alt(
+                                5..12,
+                                vec![
+                                    concat(
+                                        5..7,
+                                        vec![lit('b', 5), lit('y', 6)]
+                                    ),
+                                    group(
+                                        8..12,
+                                        3,
+                                        concat(
+                                            9..11,
+                                            vec![lit('c', 9), lit('z', 10),]
+                                        )
+                                    ),
+                                ]
+                            )
+                        ),
+                    ]
+                )
+            ))
+        );
+
+        assert_eq!(
+            parser(r"|").parse(),
+            Ok(alt(
+                0..1,
+                vec![Ast::Empty(span(0..0)), Ast::Empty(span(1..1)),]
+            ))
+        );
+        assert_eq!(
+            parser(r"||").parse(),
+            Ok(alt(
+                0..2,
+                vec![
+                    Ast::Empty(span(0..0)),
+                    Ast::Empty(span(1..1)),
+                    Ast::Empty(span(2..2)),
+                ]
+            ))
+        );
+        assert_eq!(
+            parser(r"a|").parse(),
+            Ok(alt(0..2, vec![lit('a', 0), Ast::Empty(span(2..2)),]))
+        );
+        assert_eq!(
+            parser(r"|a").parse(),
+            Ok(alt(0..2, vec![Ast::Empty(span(0..0)), lit('a', 1),]))
+        );
+
+        assert_eq!(
+            parser(r"(|)").parse(),
+            Ok(group(
+                0..3,
+                1,
+                alt(
+                    1..2,
+                    vec![Ast::Empty(span(1..1)), Ast::Empty(span(2..2)),]
+                )
+            ))
+        );
+        assert_eq!(
+            parser(r"(a|)").parse(),
+            Ok(group(
+                0..4,
+                1,
+                alt(1..3, vec![lit('a', 1), Ast::Empty(span(3..3)),])
+            ))
+        );
+        assert_eq!(
+            parser(r"(|a)").parse(),
+            Ok(group(
+                0..4,
+                1,
+                alt(1..3, vec![Ast::Empty(span(1..1)), lit('a', 2),])
+            ))
+        );
+
+        assert_eq!(
+            parser(r"a|b)").parse().unwrap_err(),
+            TestError {
+                span: span(3..4),
+                kind: ast::ErrorKind::GroupUnopened,
+            }
+        );
+        assert_eq!(
+            parser(r"(a|b").parse().unwrap_err(),
+            TestError {
+                span: span(0..1),
+                kind: ast::ErrorKind::GroupUnclosed,
+            }
+        );
+    }
+
+    #[test]
+    fn parse_unsupported_lookaround() {
+        assert_eq!(
+            parser(r"(?=a)").parse().unwrap_err(),
+            TestError {
+                span: span(0..3),
+                kind: ast::ErrorKind::UnsupportedLookAround,
+            }
+        );
+        assert_eq!(
+            parser(r"(?!a)").parse().unwrap_err(),
+            TestError {
+                span: span(0..3),
+                kind: ast::ErrorKind::UnsupportedLookAround,
+            }
+        );
+        assert_eq!(
+            parser(r"(?<=a)").parse().unwrap_err(),
+            TestError {
+                span: span(0..4),
+                kind: ast::ErrorKind::UnsupportedLookAround,
+            }
+        );
+        assert_eq!(
+            parser(r"(?<!a)").parse().unwrap_err(),
+            TestError {
+                span: span(0..4),
+                kind: ast::ErrorKind::UnsupportedLookAround,
+            }
+        );
+    }
+
+    #[test]
+    fn parse_group() {
+        assert_eq!(
+            parser("(?i)").parse(),
+            Ok(Ast::Flags(ast::SetFlags {
+                span: span(0..4),
+                flags: ast::Flags {
+                    span: span(2..3),
+                    items: vec![ast::FlagsItem {
+                        span: span(2..3),
+                        kind: ast::FlagsItemKind::Flag(
+                            ast::Flag::CaseInsensitive
+                        ),
+                    }],
+                },
+            }))
+        );
+        assert_eq!(
+            parser("(?iU)").parse(),
+            Ok(Ast::Flags(ast::SetFlags {
+                span: span(0..5),
+                flags: ast::Flags {
+                    span: span(2..4),
+                    items: vec![
+                        ast::FlagsItem {
+                            span: span(2..3),
+                            kind: ast::FlagsItemKind::Flag(
+                                ast::Flag::CaseInsensitive
+                            ),
+                        },
+                        ast::FlagsItem {
+                            span: span(3..4),
+                            kind: ast::FlagsItemKind::Flag(
+                                ast::Flag::SwapGreed
+                            ),
+                        },
+                    ],
+                },
+            }))
+        );
+        assert_eq!(
+            parser("(?i-U)").parse(),
+            Ok(Ast::Flags(ast::SetFlags {
+                span: span(0..6),
+                flags: ast::Flags {
+                    span: span(2..5),
+                    items: vec![
+                        ast::FlagsItem {
+                            span: span(2..3),
+                            kind: ast::FlagsItemKind::Flag(
+                                ast::Flag::CaseInsensitive
+                            ),
+                        },
+                        ast::FlagsItem {
+                            span: span(3..4),
+                            kind: ast::FlagsItemKind::Negation,
+                        },
+                        ast::FlagsItem {
+                            span: span(4..5),
+                            kind: ast::FlagsItemKind::Flag(
+                                ast::Flag::SwapGreed
+                            ),
+                        },
+                    ],
+                },
+            }))
+        );
+
+        assert_eq!(
+            parser("()").parse(),
+            Ok(Ast::Group(ast::Group {
+                span: span(0..2),
+                kind: ast::GroupKind::CaptureIndex(1),
+                ast: Box::new(Ast::Empty(span(1..1))),
+            }))
+        );
+        assert_eq!(
+            parser("(a)").parse(),
+            Ok(Ast::Group(ast::Group {
+                span: span(0..3),
+                kind: ast::GroupKind::CaptureIndex(1),
+                ast: Box::new(lit('a', 1)),
+            }))
+        );
+        assert_eq!(
+            parser("(())").parse(),
+            Ok(Ast::Group(ast::Group {
+                span: span(0..4),
+                kind: ast::GroupKind::CaptureIndex(1),
+                ast: Box::new(Ast::Group(ast::Group {
+                    span: span(1..3),
+                    kind: ast::GroupKind::CaptureIndex(2),
+                    ast: Box::new(Ast::Empty(span(2..2))),
+                })),
+            }))
+        );
+
+        assert_eq!(
+            parser("(?:a)").parse(),
+            Ok(Ast::Group(ast::Group {
+                span: span(0..5),
+                kind: ast::GroupKind::NonCapturing(ast::Flags {
+                    span: span(2..2),
+                    items: vec![],
+                }),
+                ast: Box::new(lit('a', 3)),
+            }))
+        );
+
+        assert_eq!(
+            parser("(?i:a)").parse(),
+            Ok(Ast::Group(ast::Group {
+                span: span(0..6),
+                kind: ast::GroupKind::NonCapturing(ast::Flags {
+                    span: span(2..3),
+                    items: vec![ast::FlagsItem {
+                        span: span(2..3),
+                        kind: ast::FlagsItemKind::Flag(
+                            ast::Flag::CaseInsensitive
+                        ),
+                    },],
+                }),
+                ast: Box::new(lit('a', 4)),
+            }))
+        );
+        assert_eq!(
+            parser("(?i-U:a)").parse(),
+            Ok(Ast::Group(ast::Group {
+                span: span(0..8),
+                kind: ast::GroupKind::NonCapturing(ast::Flags {
+                    span: span(2..5),
+                    items: vec![
+                        ast::FlagsItem {
+                            span: span(2..3),
+                            kind: ast::FlagsItemKind::Flag(
+                                ast::Flag::CaseInsensitive
+                            ),
+                        },
+                        ast::FlagsItem {
+                            span: span(3..4),
+                            kind: ast::FlagsItemKind::Negation,
+                        },
+                        ast::FlagsItem {
+                            span: span(4..5),
+                            kind: ast::FlagsItemKind::Flag(
+                                ast::Flag::SwapGreed
+                            ),
+                        },
+                    ],
+                }),
+                ast: Box::new(lit('a', 6)),
+            }))
+        );
+
+        assert_eq!(
+            parser("(").parse().unwrap_err(),
+            TestError {
+                span: span(0..1),
+                kind: ast::ErrorKind::GroupUnclosed,
+            }
+        );
+        assert_eq!(
+            parser("(?").parse().unwrap_err(),
+            TestError {
+                span: span(0..1),
+                kind: ast::ErrorKind::GroupUnclosed,
+            }
+        );
+        assert_eq!(
+            parser("(?P").parse().unwrap_err(),
+            TestError {
+                span: span(2..3),
+                kind: ast::ErrorKind::FlagUnrecognized,
+            }
+        );
+        assert_eq!(
+            parser("(?P<").parse().unwrap_err(),
+            TestError {
+                span: span(4..4),
+                kind: ast::ErrorKind::GroupNameUnexpectedEof,
+            }
+        );
+        assert_eq!(
+            parser("(a").parse().unwrap_err(),
+            TestError {
+                span: span(0..1),
+                kind: ast::ErrorKind::GroupUnclosed,
+            }
+        );
+        assert_eq!(
+            parser("(()").parse().unwrap_err(),
+            TestError {
+                span: span(0..1),
+                kind: ast::ErrorKind::GroupUnclosed,
+            }
+        );
+        assert_eq!(
+            parser(")").parse().unwrap_err(),
+            TestError {
+                span: span(0..1),
+                kind: ast::ErrorKind::GroupUnopened,
+            }
+        );
+        assert_eq!(
+            parser("a)").parse().unwrap_err(),
+            TestError {
+                span: span(1..2),
+                kind: ast::ErrorKind::GroupUnopened,
+            }
+        );
+    }
+
+    #[test]
+    fn parse_capture_name() {
+        assert_eq!(
+            parser("(?P<a>z)").parse(),
+            Ok(Ast::Group(ast::Group {
+                span: span(0..8),
+                kind: ast::GroupKind::CaptureName(ast::CaptureName {
+                    span: span(4..5),
+                    name: s("a"),
+                    index: 1,
+                }),
+                ast: Box::new(lit('z', 6)),
+            }))
+        );
+        assert_eq!(
+            parser("(?P<abc>z)").parse(),
+            Ok(Ast::Group(ast::Group {
+                span: span(0..10),
+                kind: ast::GroupKind::CaptureName(ast::CaptureName {
+                    span: span(4..7),
+                    name: s("abc"),
+                    index: 1,
+                }),
+                ast: Box::new(lit('z', 8)),
+            }))
+        );
+
+        assert_eq!(
+            parser("(?P<a_1>z)").parse(),
+            Ok(Ast::Group(ast::Group {
+                span: span(0..10),
+                kind: ast::GroupKind::CaptureName(ast::CaptureName {
+                    span: span(4..7),
+                    name: s("a_1"),
+                    index: 1,
+                }),
+                ast: Box::new(lit('z', 8)),
+            }))
+        );
+
+        assert_eq!(
+            parser("(?P<a.1>z)").parse(),
+            Ok(Ast::Group(ast::Group {
+                span: span(0..10),
+                kind: ast::GroupKind::CaptureName(ast::CaptureName {
+                    span: span(4..7),
+                    name: s("a.1"),
+                    index: 1,
+                }),
+                ast: Box::new(lit('z', 8)),
+            }))
+        );
+
+        assert_eq!(
+            parser("(?P<a[1]>z)").parse(),
+            Ok(Ast::Group(ast::Group {
+                span: span(0..11),
+                kind: ast::GroupKind::CaptureName(ast::CaptureName {
+                    span: span(4..8),
+                    name: s("a[1]"),
+                    index: 1,
+                }),
+                ast: Box::new(lit('z', 9)),
+            }))
+        );
+
+        assert_eq!(
+            parser("(?P<").parse().unwrap_err(),
+            TestError {
+                span: span(4..4),
+                kind: ast::ErrorKind::GroupNameUnexpectedEof,
+            }
+        );
+        assert_eq!(
+            parser("(?P<>z)").parse().unwrap_err(),
+            TestError {
+                span: span(4..4),
+                kind: ast::ErrorKind::GroupNameEmpty,
+            }
+        );
+        assert_eq!(
+            parser("(?P<a").parse().unwrap_err(),
+            TestError {
+                span: span(5..5),
+                kind: ast::ErrorKind::GroupNameUnexpectedEof,
+            }
+        );
+        assert_eq!(
+            parser("(?P<ab").parse().unwrap_err(),
+            TestError {
+                span: span(6..6),
+                kind: ast::ErrorKind::GroupNameUnexpectedEof,
+            }
+        );
+        assert_eq!(
+            parser("(?P<0a").parse().unwrap_err(),
+            TestError {
+                span: span(4..5),
+                kind: ast::ErrorKind::GroupNameInvalid,
+            }
+        );
+        assert_eq!(
+            parser("(?P<~").parse().unwrap_err(),
+            TestError {
+                span: span(4..5),
+                kind: ast::ErrorKind::GroupNameInvalid,
+            }
+        );
+        assert_eq!(
+            parser("(?P<abc~").parse().unwrap_err(),
+            TestError {
+                span: span(7..8),
+                kind: ast::ErrorKind::GroupNameInvalid,
+            }
+        );
+        assert_eq!(
+            parser("(?P<a>y)(?P<a>z)").parse().unwrap_err(),
+            TestError {
+                span: span(12..13),
+                kind: ast::ErrorKind::GroupNameDuplicate {
+                    original: span(4..5),
+                },
+            }
+        );
+    }
+
+    #[test]
+    fn parse_flags() {
+        assert_eq!(
+            parser("i:").parse_flags(),
+            Ok(ast::Flags {
+                span: span(0..1),
+                items: vec![ast::FlagsItem {
+                    span: span(0..1),
+                    kind: ast::FlagsItemKind::Flag(ast::Flag::CaseInsensitive),
+                }],
+            })
+        );
+        assert_eq!(
+            parser("i)").parse_flags(),
+            Ok(ast::Flags {
+                span: span(0..1),
+                items: vec![ast::FlagsItem {
+                    span: span(0..1),
+                    kind: ast::FlagsItemKind::Flag(ast::Flag::CaseInsensitive),
+                }],
+            })
+        );
+
+        assert_eq!(
+            parser("isU:").parse_flags(),
+            Ok(ast::Flags {
+                span: span(0..3),
+                items: vec![
+                    ast::FlagsItem {
+                        span: span(0..1),
+                        kind: ast::FlagsItemKind::Flag(
+                            ast::Flag::CaseInsensitive
+                        ),
+                    },
+                    ast::FlagsItem {
+                        span: span(1..2),
+                        kind: ast::FlagsItemKind::Flag(
+                            ast::Flag::DotMatchesNewLine
+                        ),
+                    },
+                    ast::FlagsItem {
+                        span: span(2..3),
+                        kind: ast::FlagsItemKind::Flag(ast::Flag::SwapGreed),
+                    },
+                ],
+            })
+        );
+
+        assert_eq!(
+            parser("-isU:").parse_flags(),
+            Ok(ast::Flags {
+                span: span(0..4),
+                items: vec![
+                    ast::FlagsItem {
+                        span: span(0..1),
+                        kind: ast::FlagsItemKind::Negation,
+                    },
+                    ast::FlagsItem {
+                        span: span(1..2),
+                        kind: ast::FlagsItemKind::Flag(
+                            ast::Flag::CaseInsensitive
+                        ),
+                    },
+                    ast::FlagsItem {
+                        span: span(2..3),
+                        kind: ast::FlagsItemKind::Flag(
+                            ast::Flag::DotMatchesNewLine
+                        ),
+                    },
+                    ast::FlagsItem {
+                        span: span(3..4),
+                        kind: ast::FlagsItemKind::Flag(ast::Flag::SwapGreed),
+                    },
+                ],
+            })
+        );
+        assert_eq!(
+            parser("i-sU:").parse_flags(),
+            Ok(ast::Flags {
+                span: span(0..4),
+                items: vec![
+                    ast::FlagsItem {
+                        span: span(0..1),
+                        kind: ast::FlagsItemKind::Flag(
+                            ast::Flag::CaseInsensitive
+                        ),
+                    },
+                    ast::FlagsItem {
+                        span: span(1..2),
+                        kind: ast::FlagsItemKind::Negation,
+                    },
+                    ast::FlagsItem {
+                        span: span(2..3),
+                        kind: ast::FlagsItemKind::Flag(
+                            ast::Flag::DotMatchesNewLine
+                        ),
+                    },
+                    ast::FlagsItem {
+                        span: span(3..4),
+                        kind: ast::FlagsItemKind::Flag(ast::Flag::SwapGreed),
+                    },
+                ],
+            })
+        );
+
+        assert_eq!(
+            parser("isU").parse_flags().unwrap_err(),
+            TestError {
+                span: span(3..3),
+                kind: ast::ErrorKind::FlagUnexpectedEof,
+            }
+        );
+        assert_eq!(
+            parser("isUa:").parse_flags().unwrap_err(),
+            TestError {
+                span: span(3..4),
+                kind: ast::ErrorKind::FlagUnrecognized,
+            }
+        );
+        assert_eq!(
+            parser("isUi:").parse_flags().unwrap_err(),
+            TestError {
+                span: span(3..4),
+                kind: ast::ErrorKind::FlagDuplicate { original: span(0..1) },
+            }
+        );
+        assert_eq!(
+            parser("i-sU-i:").parse_flags().unwrap_err(),
+            TestError {
+                span: span(4..5),
+                kind: ast::ErrorKind::FlagRepeatedNegation {
+                    original: span(1..2),
+                },
+            }
+        );
+        assert_eq!(
+            parser("-)").parse_flags().unwrap_err(),
+            TestError {
+                span: span(0..1),
+                kind: ast::ErrorKind::FlagDanglingNegation,
+            }
+        );
+        assert_eq!(
+            parser("i-)").parse_flags().unwrap_err(),
+            TestError {
+                span: span(1..2),
+                kind: ast::ErrorKind::FlagDanglingNegation,
+            }
+        );
+        assert_eq!(
+            parser("iU-)").parse_flags().unwrap_err(),
+            TestError {
+                span: span(2..3),
+                kind: ast::ErrorKind::FlagDanglingNegation,
+            }
+        );
+    }
+
+    #[test]
+    fn parse_flag() {
+        assert_eq!(parser("i").parse_flag(), Ok(ast::Flag::CaseInsensitive));
+        assert_eq!(parser("m").parse_flag(), Ok(ast::Flag::MultiLine));
+        assert_eq!(parser("s").parse_flag(), Ok(ast::Flag::DotMatchesNewLine));
+        assert_eq!(parser("U").parse_flag(), Ok(ast::Flag::SwapGreed));
+        assert_eq!(parser("u").parse_flag(), Ok(ast::Flag::Unicode));
+        assert_eq!(parser("x").parse_flag(), Ok(ast::Flag::IgnoreWhitespace));
+
+        assert_eq!(
+            parser("a").parse_flag().unwrap_err(),
+            TestError {
+                span: span(0..1),
+                kind: ast::ErrorKind::FlagUnrecognized,
+            }
+        );
+        assert_eq!(
+            parser("☃").parse_flag().unwrap_err(),
+            TestError {
+                span: span_range("☃", 0..3),
+                kind: ast::ErrorKind::FlagUnrecognized,
+            }
+        );
+    }
+
+    #[test]
+    fn parse_primitive_non_escape() {
+        assert_eq!(
+            parser(r".").parse_primitive(),
+            Ok(Primitive::Dot(span(0..1)))
+        );
+        assert_eq!(
+            parser(r"^").parse_primitive(),
+            Ok(Primitive::Assertion(ast::Assertion {
+                span: span(0..1),
+                kind: ast::AssertionKind::StartLine,
+            }))
+        );
+        assert_eq!(
+            parser(r"$").parse_primitive(),
+            Ok(Primitive::Assertion(ast::Assertion {
+                span: span(0..1),
+                kind: ast::AssertionKind::EndLine,
+            }))
+        );
+
+        assert_eq!(
+            parser(r"a").parse_primitive(),
+            Ok(Primitive::Literal(ast::Literal {
+                span: span(0..1),
+                kind: ast::LiteralKind::Verbatim,
+                c: 'a',
+            }))
+        );
+        assert_eq!(
+            parser(r"|").parse_primitive(),
+            Ok(Primitive::Literal(ast::Literal {
+                span: span(0..1),
+                kind: ast::LiteralKind::Verbatim,
+                c: '|',
+            }))
+        );
+        assert_eq!(
+            parser(r"☃").parse_primitive(),
+            Ok(Primitive::Literal(ast::Literal {
+                span: span_range("☃", 0..3),
+                kind: ast::LiteralKind::Verbatim,
+                c: '☃',
+            }))
+        );
+    }
+
+    #[test]
+    fn parse_escape() {
+        assert_eq!(
+            parser(r"\|").parse_primitive(),
+            Ok(Primitive::Literal(ast::Literal {
+                span: span(0..2),
+                kind: ast::LiteralKind::Punctuation,
+                c: '|',
+            }))
+        );
+        let specials = &[
+            (r"\a", '\x07', ast::SpecialLiteralKind::Bell),
+            (r"\f", '\x0C', ast::SpecialLiteralKind::FormFeed),
+            (r"\t", '\t', ast::SpecialLiteralKind::Tab),
+            (r"\n", '\n', ast::SpecialLiteralKind::LineFeed),
+            (r"\r", '\r', ast::SpecialLiteralKind::CarriageReturn),
+            (r"\v", '\x0B', ast::SpecialLiteralKind::VerticalTab),
+        ];
+        for &(pat, c, ref kind) in specials {
+            assert_eq!(
+                parser(pat).parse_primitive(),
+                Ok(Primitive::Literal(ast::Literal {
+                    span: span(0..2),
+                    kind: ast::LiteralKind::Special(kind.clone()),
+                    c,
+                }))
+            );
+        }
+        assert_eq!(
+            parser(r"\A").parse_primitive(),
+            Ok(Primitive::Assertion(ast::Assertion {
+                span: span(0..2),
+                kind: ast::AssertionKind::StartText,
+            }))
+        );
+        assert_eq!(
+            parser(r"\z").parse_primitive(),
+            Ok(Primitive::Assertion(ast::Assertion {
+                span: span(0..2),
+                kind: ast::AssertionKind::EndText,
+            }))
+        );
+        assert_eq!(
+            parser(r"\b").parse_primitive(),
+            Ok(Primitive::Assertion(ast::Assertion {
+                span: span(0..2),
+                kind: ast::AssertionKind::WordBoundary,
+            }))
+        );
+        assert_eq!(
+            parser(r"\B").parse_primitive(),
+            Ok(Primitive::Assertion(ast::Assertion {
+                span: span(0..2),
+                kind: ast::AssertionKind::NotWordBoundary,
+            }))
+        );
+
+        assert_eq!(
+            parser(r"\").parse_escape().unwrap_err(),
+            TestError {
+                span: span(0..1),
+                kind: ast::ErrorKind::EscapeUnexpectedEof,
+            }
+        );
+        assert_eq!(
+            parser(r"\y").parse_escape().unwrap_err(),
+            TestError {
+                span: span(0..2),
+                kind: ast::ErrorKind::EscapeUnrecognized,
+            }
+        );
+    }
+
+    #[test]
+    fn parse_unsupported_backreference() {
+        assert_eq!(
+            parser(r"\0").parse_escape().unwrap_err(),
+            TestError {
+                span: span(0..2),
+                kind: ast::ErrorKind::UnsupportedBackreference,
+            }
+        );
+        assert_eq!(
+            parser(r"\9").parse_escape().unwrap_err(),
+            TestError {
+                span: span(0..2),
+                kind: ast::ErrorKind::UnsupportedBackreference,
+            }
+        );
+    }
+
+    #[test]
+    fn parse_octal() {
+        for i in 0..511 {
+            let pat = format!(r"\{:o}", i);
+            assert_eq!(
+                parser_octal(&pat).parse_escape(),
+                Ok(Primitive::Literal(ast::Literal {
+                    span: span(0..pat.len()),
+                    kind: ast::LiteralKind::Octal,
+                    c: ::std::char::from_u32(i).unwrap(),
+                }))
+            );
+        }
+        assert_eq!(
+            parser_octal(r"\778").parse_escape(),
+            Ok(Primitive::Literal(ast::Literal {
+                span: span(0..3),
+                kind: ast::LiteralKind::Octal,
+                c: '?',
+            }))
+        );
+        assert_eq!(
+            parser_octal(r"\7777").parse_escape(),
+            Ok(Primitive::Literal(ast::Literal {
+                span: span(0..4),
+                kind: ast::LiteralKind::Octal,
+                c: '\u{01FF}',
+            }))
+        );
+        assert_eq!(
+            parser_octal(r"\778").parse(),
+            Ok(Ast::Concat(ast::Concat {
+                span: span(0..4),
+                asts: vec![
+                    Ast::Literal(ast::Literal {
+                        span: span(0..3),
+                        kind: ast::LiteralKind::Octal,
+                        c: '?',
+                    }),
+                    Ast::Literal(ast::Literal {
+                        span: span(3..4),
+                        kind: ast::LiteralKind::Verbatim,
+                        c: '8',
+                    }),
+                ],
+            }))
+        );
+        assert_eq!(
+            parser_octal(r"\7777").parse(),
+            Ok(Ast::Concat(ast::Concat {
+                span: span(0..5),
+                asts: vec![
+                    Ast::Literal(ast::Literal {
+                        span: span(0..4),
+                        kind: ast::LiteralKind::Octal,
+                        c: '\u{01FF}',
+                    }),
+                    Ast::Literal(ast::Literal {
+                        span: span(4..5),
+                        kind: ast::LiteralKind::Verbatim,
+                        c: '7',
+                    }),
+                ],
+            }))
+        );
+
+        assert_eq!(
+            parser_octal(r"\8").parse_escape().unwrap_err(),
+            TestError {
+                span: span(0..2),
+                kind: ast::ErrorKind::EscapeUnrecognized,
+            }
+        );
+    }
+
+    #[test]
+    fn parse_hex_two() {
+        for i in 0..256 {
+            let pat = format!(r"\x{:02x}", i);
+            assert_eq!(
+                parser(&pat).parse_escape(),
+                Ok(Primitive::Literal(ast::Literal {
+                    span: span(0..pat.len()),
+                    kind: ast::LiteralKind::HexFixed(ast::HexLiteralKind::X),
+                    c: ::std::char::from_u32(i).unwrap(),
+                }))
+            );
+        }
+
+        assert_eq!(
+            parser(r"\xF").parse_escape().unwrap_err(),
+            TestError {
+                span: span(3..3),
+                kind: ast::ErrorKind::EscapeUnexpectedEof,
+            }
+        );
+        assert_eq!(
+            parser(r"\xG").parse_escape().unwrap_err(),
+            TestError {
+                span: span(2..3),
+                kind: ast::ErrorKind::EscapeHexInvalidDigit,
+            }
+        );
+        assert_eq!(
+            parser(r"\xFG").parse_escape().unwrap_err(),
+            TestError {
+                span: span(3..4),
+                kind: ast::ErrorKind::EscapeHexInvalidDigit,
+            }
+        );
+    }
+
+    #[test]
+    fn parse_hex_four() {
+        for i in 0..65536 {
+            let c = match ::std::char::from_u32(i) {
+                None => continue,
+                Some(c) => c,
+            };
+            let pat = format!(r"\u{:04x}", i);
+            assert_eq!(
+                parser(&pat).parse_escape(),
+                Ok(Primitive::Literal(ast::Literal {
+                    span: span(0..pat.len()),
+                    kind: ast::LiteralKind::HexFixed(
+                        ast::HexLiteralKind::UnicodeShort
+                    ),
+                    c,
+                }))
+            );
+        }
+
+        assert_eq!(
+            parser(r"\uF").parse_escape().unwrap_err(),
+            TestError {
+                span: span(3..3),
+                kind: ast::ErrorKind::EscapeUnexpectedEof,
+            }
+        );
+        assert_eq!(
+            parser(r"\uG").parse_escape().unwrap_err(),
+            TestError {
+                span: span(2..3),
+                kind: ast::ErrorKind::EscapeHexInvalidDigit,
+            }
+        );
+        assert_eq!(
+            parser(r"\uFG").parse_escape().unwrap_err(),
+            TestError {
+                span: span(3..4),
+                kind: ast::ErrorKind::EscapeHexInvalidDigit,
+            }
+        );
+        assert_eq!(
+            parser(r"\uFFG").parse_escape().unwrap_err(),
+            TestError {
+                span: span(4..5),
+                kind: ast::ErrorKind::EscapeHexInvalidDigit,
+            }
+        );
+        assert_eq!(
+            parser(r"\uFFFG").parse_escape().unwrap_err(),
+            TestError {
+                span: span(5..6),
+                kind: ast::ErrorKind::EscapeHexInvalidDigit,
+            }
+        );
+        assert_eq!(
+            parser(r"\uD800").parse_escape().unwrap_err(),
+            TestError {
+                span: span(2..6),
+                kind: ast::ErrorKind::EscapeHexInvalid,
+            }
+        );
+    }
+
+    #[test]
+    fn parse_hex_eight() {
+        for i in 0..65536 {
+            let c = match ::std::char::from_u32(i) {
+                None => continue,
+                Some(c) => c,
+            };
+            let pat = format!(r"\U{:08x}", i);
+            assert_eq!(
+                parser(&pat).parse_escape(),
+                Ok(Primitive::Literal(ast::Literal {
+                    span: span(0..pat.len()),
+                    kind: ast::LiteralKind::HexFixed(
+                        ast::HexLiteralKind::UnicodeLong
+                    ),
+                    c,
+                }))
+            );
+        }
+
+        assert_eq!(
+            parser(r"\UF").parse_escape().unwrap_err(),
+            TestError {
+                span: span(3..3),
+                kind: ast::ErrorKind::EscapeUnexpectedEof,
+            }
+        );
+        assert_eq!(
+            parser(r"\UG").parse_escape().unwrap_err(),
+            TestError {
+                span: span(2..3),
+                kind: ast::ErrorKind::EscapeHexInvalidDigit,
+            }
+        );
+        assert_eq!(
+            parser(r"\UFG").parse_escape().unwrap_err(),
+            TestError {
+                span: span(3..4),
+                kind: ast::ErrorKind::EscapeHexInvalidDigit,
+            }
+        );
+        assert_eq!(
+            parser(r"\UFFG").parse_escape().unwrap_err(),
+            TestError {
+                span: span(4..5),
+                kind: ast::ErrorKind::EscapeHexInvalidDigit,
+            }
+        );
+        assert_eq!(
+            parser(r"\UFFFG").parse_escape().unwrap_err(),
+            TestError {
+                span: span(5..6),
+                kind: ast::ErrorKind::EscapeHexInvalidDigit,
+            }
+        );
+        assert_eq!(
+            parser(r"\UFFFFG").parse_escape().unwrap_err(),
+            TestError {
+                span: span(6..7),
+                kind: ast::ErrorKind::EscapeHexInvalidDigit,
+            }
+        );
+        assert_eq!(
+            parser(r"\UFFFFFG").parse_escape().unwrap_err(),
+            TestError {
+                span: span(7..8),
+                kind: ast::ErrorKind::EscapeHexInvalidDigit,
+            }
+        );
+        assert_eq!(
+            parser(r"\UFFFFFFG").parse_escape().unwrap_err(),
+            TestError {
+                span: span(8..9),
+                kind: ast::ErrorKind::EscapeHexInvalidDigit,
+            }
+        );
+        assert_eq!(
+            parser(r"\UFFFFFFFG").parse_escape().unwrap_err(),
+            TestError {
+                span: span(9..10),
+                kind: ast::ErrorKind::EscapeHexInvalidDigit,
+            }
+        );
+    }
+
+    #[test]
+    fn parse_hex_brace() {
+        assert_eq!(
+            parser(r"\u{26c4}").parse_escape(),
+            Ok(Primitive::Literal(ast::Literal {
+                span: span(0..8),
+                kind: ast::LiteralKind::HexBrace(
+                    ast::HexLiteralKind::UnicodeShort
+                ),
+                c: '⛄',
+            }))
+        );
+        assert_eq!(
+            parser(r"\U{26c4}").parse_escape(),
+            Ok(Primitive::Literal(ast::Literal {
+                span: span(0..8),
+                kind: ast::LiteralKind::HexBrace(
+                    ast::HexLiteralKind::UnicodeLong
+                ),
+                c: '⛄',
+            }))
+        );
+        assert_eq!(
+            parser(r"\x{26c4}").parse_escape(),
+            Ok(Primitive::Literal(ast::Literal {
+                span: span(0..8),
+                kind: ast::LiteralKind::HexBrace(ast::HexLiteralKind::X),
+                c: '⛄',
+            }))
+        );
+        assert_eq!(
+            parser(r"\x{26C4}").parse_escape(),
+            Ok(Primitive::Literal(ast::Literal {
+                span: span(0..8),
+                kind: ast::LiteralKind::HexBrace(ast::HexLiteralKind::X),
+                c: '⛄',
+            }))
+        );
+        assert_eq!(
+            parser(r"\x{10fFfF}").parse_escape(),
+            Ok(Primitive::Literal(ast::Literal {
+                span: span(0..10),
+                kind: ast::LiteralKind::HexBrace(ast::HexLiteralKind::X),
+                c: '\u{10FFFF}',
+            }))
+        );
+
+        assert_eq!(
+            parser(r"\x").parse_escape().unwrap_err(),
+            TestError {
+                span: span(2..2),
+                kind: ast::ErrorKind::EscapeUnexpectedEof,
+            }
+        );
+        assert_eq!(
+            parser(r"\x{").parse_escape().unwrap_err(),
+            TestError {
+                span: span(2..3),
+                kind: ast::ErrorKind::EscapeUnexpectedEof,
+            }
+        );
+        assert_eq!(
+            parser(r"\x{FF").parse_escape().unwrap_err(),
+            TestError {
+                span: span(2..5),
+                kind: ast::ErrorKind::EscapeUnexpectedEof,
+            }
+        );
+        assert_eq!(
+            parser(r"\x{}").parse_escape().unwrap_err(),
+            TestError {
+                span: span(2..4),
+                kind: ast::ErrorKind::EscapeHexEmpty,
+            }
+        );
+        assert_eq!(
+            parser(r"\x{FGF}").parse_escape().unwrap_err(),
+            TestError {
+                span: span(4..5),
+                kind: ast::ErrorKind::EscapeHexInvalidDigit,
+            }
+        );
+        assert_eq!(
+            parser(r"\x{FFFFFF}").parse_escape().unwrap_err(),
+            TestError {
+                span: span(3..9),
+                kind: ast::ErrorKind::EscapeHexInvalid,
+            }
+        );
+        assert_eq!(
+            parser(r"\x{D800}").parse_escape().unwrap_err(),
+            TestError {
+                span: span(3..7),
+                kind: ast::ErrorKind::EscapeHexInvalid,
+            }
+        );
+        assert_eq!(
+            parser(r"\x{FFFFFFFFF}").parse_escape().unwrap_err(),
+            TestError {
+                span: span(3..12),
+                kind: ast::ErrorKind::EscapeHexInvalid,
+            }
+        );
+    }
+
+    #[test]
+    fn parse_decimal() {
+        assert_eq!(parser("123").parse_decimal(), Ok(123));
+        assert_eq!(parser("0").parse_decimal(), Ok(0));
+        assert_eq!(parser("01").parse_decimal(), Ok(1));
+
+        assert_eq!(
+            parser("-1").parse_decimal().unwrap_err(),
+            TestError { span: span(0..0), kind: ast::ErrorKind::DecimalEmpty }
+        );
+        assert_eq!(
+            parser("").parse_decimal().unwrap_err(),
+            TestError { span: span(0..0), kind: ast::ErrorKind::DecimalEmpty }
+        );
+        assert_eq!(
+            parser("9999999999").parse_decimal().unwrap_err(),
+            TestError {
+                span: span(0..10),
+                kind: ast::ErrorKind::DecimalInvalid,
+            }
+        );
+    }
+
+    #[test]
+    fn parse_set_class() {
+        fn union(span: Span, items: Vec<ast::ClassSetItem>) -> ast::ClassSet {
+            ast::ClassSet::union(ast::ClassSetUnion { span, items })
+        }
+
+        fn intersection(
+            span: Span,
+            lhs: ast::ClassSet,
+            rhs: ast::ClassSet,
+        ) -> ast::ClassSet {
+            ast::ClassSet::BinaryOp(ast::ClassSetBinaryOp {
+                span,
+                kind: ast::ClassSetBinaryOpKind::Intersection,
+                lhs: Box::new(lhs),
+                rhs: Box::new(rhs),
+            })
+        }
+
+        fn difference(
+            span: Span,
+            lhs: ast::ClassSet,
+            rhs: ast::ClassSet,
+        ) -> ast::ClassSet {
+            ast::ClassSet::BinaryOp(ast::ClassSetBinaryOp {
+                span,
+                kind: ast::ClassSetBinaryOpKind::Difference,
+                lhs: Box::new(lhs),
+                rhs: Box::new(rhs),
+            })
+        }
+
+        fn symdifference(
+            span: Span,
+            lhs: ast::ClassSet,
+            rhs: ast::ClassSet,
+        ) -> ast::ClassSet {
+            ast::ClassSet::BinaryOp(ast::ClassSetBinaryOp {
+                span,
+                kind: ast::ClassSetBinaryOpKind::SymmetricDifference,
+                lhs: Box::new(lhs),
+                rhs: Box::new(rhs),
+            })
+        }
+
+        fn itemset(item: ast::ClassSetItem) -> ast::ClassSet {
+            ast::ClassSet::Item(item)
+        }
+
+        fn item_ascii(cls: ast::ClassAscii) -> ast::ClassSetItem {
+            ast::ClassSetItem::Ascii(cls)
+        }
+
+        fn item_unicode(cls: ast::ClassUnicode) -> ast::ClassSetItem {
+            ast::ClassSetItem::Unicode(cls)
+        }
+
+        fn item_perl(cls: ast::ClassPerl) -> ast::ClassSetItem {
+            ast::ClassSetItem::Perl(cls)
+        }
+
+        fn item_bracket(cls: ast::ClassBracketed) -> ast::ClassSetItem {
+            ast::ClassSetItem::Bracketed(Box::new(cls))
+        }
+
+        fn lit(span: Span, c: char) -> ast::ClassSetItem {
+            ast::ClassSetItem::Literal(ast::Literal {
+                span,
+                kind: ast::LiteralKind::Verbatim,
+                c,
+            })
+        }
+
+        fn empty(span: Span) -> ast::ClassSetItem {
+            ast::ClassSetItem::Empty(span)
+        }
+
+        fn range(span: Span, start: char, end: char) -> ast::ClassSetItem {
+            let pos1 = Position {
+                offset: span.start.offset + start.len_utf8(),
+                column: span.start.column + 1,
+                ..span.start
+            };
+            let pos2 = Position {
+                offset: span.end.offset - end.len_utf8(),
+                column: span.end.column - 1,
+                ..span.end
+            };
+            ast::ClassSetItem::Range(ast::ClassSetRange {
+                span,
+                start: ast::Literal {
+                    span: Span { end: pos1, ..span },
+                    kind: ast::LiteralKind::Verbatim,
+                    c: start,
+                },
+                end: ast::Literal {
+                    span: Span { start: pos2, ..span },
+                    kind: ast::LiteralKind::Verbatim,
+                    c: end,
+                },
+            })
+        }
+
+        fn alnum(span: Span, negated: bool) -> ast::ClassAscii {
+            ast::ClassAscii { span, kind: ast::ClassAsciiKind::Alnum, negated }
+        }
+
+        fn lower(span: Span, negated: bool) -> ast::ClassAscii {
+            ast::ClassAscii { span, kind: ast::ClassAsciiKind::Lower, negated }
+        }
+
+        assert_eq!(
+            parser("[[:alnum:]]").parse(),
+            Ok(Ast::Class(ast::Class::Bracketed(ast::ClassBracketed {
+                span: span(0..11),
+                negated: false,
+                kind: itemset(item_ascii(alnum(span(1..10), false))),
+            })))
+        );
+        assert_eq!(
+            parser("[[[:alnum:]]]").parse(),
+            Ok(Ast::Class(ast::Class::Bracketed(ast::ClassBracketed {
+                span: span(0..13),
+                negated: false,
+                kind: itemset(item_bracket(ast::ClassBracketed {
+                    span: span(1..12),
+                    negated: false,
+                    kind: itemset(item_ascii(alnum(span(2..11), false))),
+                })),
+            })))
+        );
+        assert_eq!(
+            parser("[[:alnum:]&&[:lower:]]").parse(),
+            Ok(Ast::Class(ast::Class::Bracketed(ast::ClassBracketed {
+                span: span(0..22),
+                negated: false,
+                kind: intersection(
+                    span(1..21),
+                    itemset(item_ascii(alnum(span(1..10), false))),
+                    itemset(item_ascii(lower(span(12..21), false))),
+                ),
+            })))
+        );
+        assert_eq!(
+            parser("[[:alnum:]--[:lower:]]").parse(),
+            Ok(Ast::Class(ast::Class::Bracketed(ast::ClassBracketed {
+                span: span(0..22),
+                negated: false,
+                kind: difference(
+                    span(1..21),
+                    itemset(item_ascii(alnum(span(1..10), false))),
+                    itemset(item_ascii(lower(span(12..21), false))),
+                ),
+            })))
+        );
+        assert_eq!(
+            parser("[[:alnum:]~~[:lower:]]").parse(),
+            Ok(Ast::Class(ast::Class::Bracketed(ast::ClassBracketed {
+                span: span(0..22),
+                negated: false,
+                kind: symdifference(
+                    span(1..21),
+                    itemset(item_ascii(alnum(span(1..10), false))),
+                    itemset(item_ascii(lower(span(12..21), false))),
+                ),
+            })))
+        );
+
+        assert_eq!(
+            parser("[a]").parse(),
+            Ok(Ast::Class(ast::Class::Bracketed(ast::ClassBracketed {
+                span: span(0..3),
+                negated: false,
+                kind: itemset(lit(span(1..2), 'a')),
+            })))
+        );
+        assert_eq!(
+            parser(r"[a\]]").parse(),
+            Ok(Ast::Class(ast::Class::Bracketed(ast::ClassBracketed {
+                span: span(0..5),
+                negated: false,
+                kind: union(
+                    span(1..4),
+                    vec![
+                        lit(span(1..2), 'a'),
+                        ast::ClassSetItem::Literal(ast::Literal {
+                            span: span(2..4),
+                            kind: ast::LiteralKind::Punctuation,
+                            c: ']',
+                        }),
+                    ]
+                ),
+            })))
+        );
+        assert_eq!(
+            parser(r"[a\-z]").parse(),
+            Ok(Ast::Class(ast::Class::Bracketed(ast::ClassBracketed {
+                span: span(0..6),
+                negated: false,
+                kind: union(
+                    span(1..5),
+                    vec![
+                        lit(span(1..2), 'a'),
+                        ast::ClassSetItem::Literal(ast::Literal {
+                            span: span(2..4),
+                            kind: ast::LiteralKind::Punctuation,
+                            c: '-',
+                        }),
+                        lit(span(4..5), 'z'),
+                    ]
+                ),
+            })))
+        );
+        assert_eq!(
+            parser("[ab]").parse(),
+            Ok(Ast::Class(ast::Class::Bracketed(ast::ClassBracketed {
+                span: span(0..4),
+                negated: false,
+                kind: union(
+                    span(1..3),
+                    vec![lit(span(1..2), 'a'), lit(span(2..3), 'b'),]
+                ),
+            })))
+        );
+        assert_eq!(
+            parser("[a-]").parse(),
+            Ok(Ast::Class(ast::Class::Bracketed(ast::ClassBracketed {
+                span: span(0..4),
+                negated: false,
+                kind: union(
+                    span(1..3),
+                    vec![lit(span(1..2), 'a'), lit(span(2..3), '-'),]
+                ),
+            })))
+        );
+        assert_eq!(
+            parser("[-a]").parse(),
+            Ok(Ast::Class(ast::Class::Bracketed(ast::ClassBracketed {
+                span: span(0..4),
+                negated: false,
+                kind: union(
+                    span(1..3),
+                    vec![lit(span(1..2), '-'), lit(span(2..3), 'a'),]
+                ),
+            })))
+        );
+        assert_eq!(
+            parser(r"[\pL]").parse(),
+            Ok(Ast::Class(ast::Class::Bracketed(ast::ClassBracketed {
+                span: span(0..5),
+                negated: false,
+                kind: itemset(item_unicode(ast::ClassUnicode {
+                    span: span(1..4),
+                    negated: false,
+                    kind: ast::ClassUnicodeKind::OneLetter('L'),
+                })),
+            })))
+        );
+        assert_eq!(
+            parser(r"[\w]").parse(),
+            Ok(Ast::Class(ast::Class::Bracketed(ast::ClassBracketed {
+                span: span(0..4),
+                negated: false,
+                kind: itemset(item_perl(ast::ClassPerl {
+                    span: span(1..3),
+                    kind: ast::ClassPerlKind::Word,
+                    negated: false,
+                })),
+            })))
+        );
+        assert_eq!(
+            parser(r"[a\wz]").parse(),
+            Ok(Ast::Class(ast::Class::Bracketed(ast::ClassBracketed {
+                span: span(0..6),
+                negated: false,
+                kind: union(
+                    span(1..5),
+                    vec![
+                        lit(span(1..2), 'a'),
+                        item_perl(ast::ClassPerl {
+                            span: span(2..4),
+                            kind: ast::ClassPerlKind::Word,
+                            negated: false,
+                        }),
+                        lit(span(4..5), 'z'),
+                    ]
+                ),
+            })))
+        );
+
+        assert_eq!(
+            parser("[a-z]").parse(),
+            Ok(Ast::Class(ast::Class::Bracketed(ast::ClassBracketed {
+                span: span(0..5),
+                negated: false,
+                kind: itemset(range(span(1..4), 'a', 'z')),
+            })))
+        );
+        assert_eq!(
+            parser("[a-cx-z]").parse(),
+            Ok(Ast::Class(ast::Class::Bracketed(ast::ClassBracketed {
+                span: span(0..8),
+                negated: false,
+                kind: union(
+                    span(1..7),
+                    vec![
+                        range(span(1..4), 'a', 'c'),
+                        range(span(4..7), 'x', 'z'),
+                    ]
+                ),
+            })))
+        );
+        assert_eq!(
+            parser(r"[\w&&a-cx-z]").parse(),
+            Ok(Ast::Class(ast::Class::Bracketed(ast::ClassBracketed {
+                span: span(0..12),
+                negated: false,
+                kind: intersection(
+                    span(1..11),
+                    itemset(item_perl(ast::ClassPerl {
+                        span: span(1..3),
+                        kind: ast::ClassPerlKind::Word,
+                        negated: false,
+                    })),
+                    union(
+                        span(5..11),
+                        vec![
+                            range(span(5..8), 'a', 'c'),
+                            range(span(8..11), 'x', 'z'),
+                        ]
+                    ),
+                ),
+            })))
+        );
+        assert_eq!(
+            parser(r"[a-cx-z&&\w]").parse(),
+            Ok(Ast::Class(ast::Class::Bracketed(ast::ClassBracketed {
+                span: span(0..12),
+                negated: false,
+                kind: intersection(
+                    span(1..11),
+                    union(
+                        span(1..7),
+                        vec![
+                            range(span(1..4), 'a', 'c'),
+                            range(span(4..7), 'x', 'z'),
+                        ]
+                    ),
+                    itemset(item_perl(ast::ClassPerl {
+                        span: span(9..11),
+                        kind: ast::ClassPerlKind::Word,
+                        negated: false,
+                    })),
+                ),
+            })))
+        );
+        assert_eq!(
+            parser(r"[a--b--c]").parse(),
+            Ok(Ast::Class(ast::Class::Bracketed(ast::ClassBracketed {
+                span: span(0..9),
+                negated: false,
+                kind: difference(
+                    span(1..8),
+                    difference(
+                        span(1..5),
+                        itemset(lit(span(1..2), 'a')),
+                        itemset(lit(span(4..5), 'b')),
+                    ),
+                    itemset(lit(span(7..8), 'c')),
+                ),
+            })))
+        );
+        assert_eq!(
+            parser(r"[a~~b~~c]").parse(),
+            Ok(Ast::Class(ast::Class::Bracketed(ast::ClassBracketed {
+                span: span(0..9),
+                negated: false,
+                kind: symdifference(
+                    span(1..8),
+                    symdifference(
+                        span(1..5),
+                        itemset(lit(span(1..2), 'a')),
+                        itemset(lit(span(4..5), 'b')),
+                    ),
+                    itemset(lit(span(7..8), 'c')),
+                ),
+            })))
+        );
+        assert_eq!(
+            parser(r"[\^&&^]").parse(),
+            Ok(Ast::Class(ast::Class::Bracketed(ast::ClassBracketed {
+                span: span(0..7),
+                negated: false,
+                kind: intersection(
+                    span(1..6),
+                    itemset(ast::ClassSetItem::Literal(ast::Literal {
+                        span: span(1..3),
+                        kind: ast::LiteralKind::Punctuation,
+                        c: '^',
+                    })),
+                    itemset(lit(span(5..6), '^')),
+                ),
+            })))
+        );
+        assert_eq!(
+            parser(r"[\&&&&]").parse(),
+            Ok(Ast::Class(ast::Class::Bracketed(ast::ClassBracketed {
+                span: span(0..7),
+                negated: false,
+                kind: intersection(
+                    span(1..6),
+                    itemset(ast::ClassSetItem::Literal(ast::Literal {
+                        span: span(1..3),
+                        kind: ast::LiteralKind::Punctuation,
+                        c: '&',
+                    })),
+                    itemset(lit(span(5..6), '&')),
+                ),
+            })))
+        );
+        assert_eq!(
+            parser(r"[&&&&]").parse(),
+            Ok(Ast::Class(ast::Class::Bracketed(ast::ClassBracketed {
+                span: span(0..6),
+                negated: false,
+                kind: intersection(
+                    span(1..5),
+                    intersection(
+                        span(1..3),
+                        itemset(empty(span(1..1))),
+                        itemset(empty(span(3..3))),
+                    ),
+                    itemset(empty(span(5..5))),
+                ),
+            })))
+        );
+
+        let pat = "[☃-⛄]";
+        assert_eq!(
+            parser(pat).parse(),
+            Ok(Ast::Class(ast::Class::Bracketed(ast::ClassBracketed {
+                span: span_range(pat, 0..9),
+                negated: false,
+                kind: itemset(ast::ClassSetItem::Range(ast::ClassSetRange {
+                    span: span_range(pat, 1..8),
+                    start: ast::Literal {
+                        span: span_range(pat, 1..4),
+                        kind: ast::LiteralKind::Verbatim,
+                        c: '☃',
+                    },
+                    end: ast::Literal {
+                        span: span_range(pat, 5..8),
+                        kind: ast::LiteralKind::Verbatim,
+                        c: '⛄',
+                    },
+                })),
+            })))
+        );
+
+        assert_eq!(
+            parser(r"[]]").parse(),
+            Ok(Ast::Class(ast::Class::Bracketed(ast::ClassBracketed {
+                span: span(0..3),
+                negated: false,
+                kind: itemset(lit(span(1..2), ']')),
+            })))
+        );
+        assert_eq!(
+            parser(r"[]\[]").parse(),
+            Ok(Ast::Class(ast::Class::Bracketed(ast::ClassBracketed {
+                span: span(0..5),
+                negated: false,
+                kind: union(
+                    span(1..4),
+                    vec![
+                        lit(span(1..2), ']'),
+                        ast::ClassSetItem::Literal(ast::Literal {
+                            span: span(2..4),
+                            kind: ast::LiteralKind::Punctuation,
+                            c: '[',
+                        }),
+                    ]
+                ),
+            })))
+        );
+        assert_eq!(
+            parser(r"[\[]]").parse(),
+            Ok(concat(
+                0..5,
+                vec![
+                    Ast::Class(ast::Class::Bracketed(ast::ClassBracketed {
+                        span: span(0..4),
+                        negated: false,
+                        kind: itemset(ast::ClassSetItem::Literal(
+                            ast::Literal {
+                                span: span(1..3),
+                                kind: ast::LiteralKind::Punctuation,
+                                c: '[',
+                            }
+                        )),
+                    })),
+                    Ast::Literal(ast::Literal {
+                        span: span(4..5),
+                        kind: ast::LiteralKind::Verbatim,
+                        c: ']',
+                    }),
+                ]
+            ))
+        );
+
+        assert_eq!(
+            parser("[").parse().unwrap_err(),
+            TestError {
+                span: span(0..1),
+                kind: ast::ErrorKind::ClassUnclosed,
+            }
+        );
+        assert_eq!(
+            parser("[[").parse().unwrap_err(),
+            TestError {
+                span: span(1..2),
+                kind: ast::ErrorKind::ClassUnclosed,
+            }
+        );
+        assert_eq!(
+            parser("[[-]").parse().unwrap_err(),
+            TestError {
+                span: span(0..1),
+                kind: ast::ErrorKind::ClassUnclosed,
+            }
+        );
+        assert_eq!(
+            parser("[[[:alnum:]").parse().unwrap_err(),
+            TestError {
+                span: span(1..2),
+                kind: ast::ErrorKind::ClassUnclosed,
+            }
+        );
+        assert_eq!(
+            parser(r"[\b]").parse().unwrap_err(),
+            TestError {
+                span: span(1..3),
+                kind: ast::ErrorKind::ClassEscapeInvalid,
+            }
+        );
+        assert_eq!(
+            parser(r"[\w-a]").parse().unwrap_err(),
+            TestError {
+                span: span(1..3),
+                kind: ast::ErrorKind::ClassRangeLiteral,
+            }
+        );
+        assert_eq!(
+            parser(r"[a-\w]").parse().unwrap_err(),
+            TestError {
+                span: span(3..5),
+                kind: ast::ErrorKind::ClassRangeLiteral,
+            }
+        );
+        assert_eq!(
+            parser(r"[z-a]").parse().unwrap_err(),
+            TestError {
+                span: span(1..4),
+                kind: ast::ErrorKind::ClassRangeInvalid,
+            }
+        );
+
+        assert_eq!(
+            parser_ignore_whitespace("[a ").parse().unwrap_err(),
+            TestError {
+                span: span(0..1),
+                kind: ast::ErrorKind::ClassUnclosed,
+            }
+        );
+        assert_eq!(
+            parser_ignore_whitespace("[a- ").parse().unwrap_err(),
+            TestError {
+                span: span(0..1),
+                kind: ast::ErrorKind::ClassUnclosed,
+            }
+        );
+    }
+
+    #[test]
+    fn parse_set_class_open() {
+        assert_eq!(parser("[a]").parse_set_class_open(), {
+            let set = ast::ClassBracketed {
+                span: span(0..1),
+                negated: false,
+                kind: ast::ClassSet::union(ast::ClassSetUnion {
+                    span: span(1..1),
+                    items: vec![],
+                }),
+            };
+            let union = ast::ClassSetUnion { span: span(1..1), items: vec![] };
+            Ok((set, union))
+        });
+        assert_eq!(
+            parser_ignore_whitespace("[   a]").parse_set_class_open(),
+            {
+                let set = ast::ClassBracketed {
+                    span: span(0..4),
+                    negated: false,
+                    kind: ast::ClassSet::union(ast::ClassSetUnion {
+                        span: span(4..4),
+                        items: vec![],
+                    }),
+                };
+                let union =
+                    ast::ClassSetUnion { span: span(4..4), items: vec![] };
+                Ok((set, union))
+            }
+        );
+        assert_eq!(parser("[^a]").parse_set_class_open(), {
+            let set = ast::ClassBracketed {
+                span: span(0..2),
+                negated: true,
+                kind: ast::ClassSet::union(ast::ClassSetUnion {
+                    span: span(2..2),
+                    items: vec![],
+                }),
+            };
+            let union = ast::ClassSetUnion { span: span(2..2), items: vec![] };
+            Ok((set, union))
+        });
+        assert_eq!(
+            parser_ignore_whitespace("[ ^ a]").parse_set_class_open(),
+            {
+                let set = ast::ClassBracketed {
+                    span: span(0..4),
+                    negated: true,
+                    kind: ast::ClassSet::union(ast::ClassSetUnion {
+                        span: span(4..4),
+                        items: vec![],
+                    }),
+                };
+                let union =
+                    ast::ClassSetUnion { span: span(4..4), items: vec![] };
+                Ok((set, union))
+            }
+        );
+        assert_eq!(parser("[-a]").parse_set_class_open(), {
+            let set = ast::ClassBracketed {
+                span: span(0..2),
+                negated: false,
+                kind: ast::ClassSet::union(ast::ClassSetUnion {
+                    span: span(1..1),
+                    items: vec![],
+                }),
+            };
+            let union = ast::ClassSetUnion {
+                span: span(1..2),
+                items: vec![ast::ClassSetItem::Literal(ast::Literal {
+                    span: span(1..2),
+                    kind: ast::LiteralKind::Verbatim,
+                    c: '-',
+                })],
+            };
+            Ok((set, union))
+        });
+        assert_eq!(
+            parser_ignore_whitespace("[ - a]").parse_set_class_open(),
+            {
+                let set = ast::ClassBracketed {
+                    span: span(0..4),
+                    negated: false,
+                    kind: ast::ClassSet::union(ast::ClassSetUnion {
+                        span: span(2..2),
+                        items: vec![],
+                    }),
+                };
+                let union = ast::ClassSetUnion {
+                    span: span(2..3),
+                    items: vec![ast::ClassSetItem::Literal(ast::Literal {
+                        span: span(2..3),
+                        kind: ast::LiteralKind::Verbatim,
+                        c: '-',
+                    })],
+                };
+                Ok((set, union))
+            }
+        );
+        assert_eq!(parser("[^-a]").parse_set_class_open(), {
+            let set = ast::ClassBracketed {
+                span: span(0..3),
+                negated: true,
+                kind: ast::ClassSet::union(ast::ClassSetUnion {
+                    span: span(2..2),
+                    items: vec![],
+                }),
+            };
+            let union = ast::ClassSetUnion {
+                span: span(2..3),
+                items: vec![ast::ClassSetItem::Literal(ast::Literal {
+                    span: span(2..3),
+                    kind: ast::LiteralKind::Verbatim,
+                    c: '-',
+                })],
+            };
+            Ok((set, union))
+        });
+        assert_eq!(parser("[--a]").parse_set_class_open(), {
+            let set = ast::ClassBracketed {
+                span: span(0..3),
+                negated: false,
+                kind: ast::ClassSet::union(ast::ClassSetUnion {
+                    span: span(1..1),
+                    items: vec![],
+                }),
+            };
+            let union = ast::ClassSetUnion {
+                span: span(1..3),
+                items: vec![
+                    ast::ClassSetItem::Literal(ast::Literal {
+                        span: span(1..2),
+                        kind: ast::LiteralKind::Verbatim,
+                        c: '-',
+                    }),
+                    ast::ClassSetItem::Literal(ast::Literal {
+                        span: span(2..3),
+                        kind: ast::LiteralKind::Verbatim,
+                        c: '-',
+                    }),
+                ],
+            };
+            Ok((set, union))
+        });
+        assert_eq!(parser("[]a]").parse_set_class_open(), {
+            let set = ast::ClassBracketed {
+                span: span(0..2),
+                negated: false,
+                kind: ast::ClassSet::union(ast::ClassSetUnion {
+                    span: span(1..1),
+                    items: vec![],
+                }),
+            };
+            let union = ast::ClassSetUnion {
+                span: span(1..2),
+                items: vec![ast::ClassSetItem::Literal(ast::Literal {
+                    span: span(1..2),
+                    kind: ast::LiteralKind::Verbatim,
+                    c: ']',
+                })],
+            };
+            Ok((set, union))
+        });
+        assert_eq!(
+            parser_ignore_whitespace("[ ] a]").parse_set_class_open(),
+            {
+                let set = ast::ClassBracketed {
+                    span: span(0..4),
+                    negated: false,
+                    kind: ast::ClassSet::union(ast::ClassSetUnion {
+                        span: span(2..2),
+                        items: vec![],
+                    }),
+                };
+                let union = ast::ClassSetUnion {
+                    span: span(2..3),
+                    items: vec![ast::ClassSetItem::Literal(ast::Literal {
+                        span: span(2..3),
+                        kind: ast::LiteralKind::Verbatim,
+                        c: ']',
+                    })],
+                };
+                Ok((set, union))
+            }
+        );
+        assert_eq!(parser("[^]a]").parse_set_class_open(), {
+            let set = ast::ClassBracketed {
+                span: span(0..3),
+                negated: true,
+                kind: ast::ClassSet::union(ast::ClassSetUnion {
+                    span: span(2..2),
+                    items: vec![],
+                }),
+            };
+            let union = ast::ClassSetUnion {
+                span: span(2..3),
+                items: vec![ast::ClassSetItem::Literal(ast::Literal {
+                    span: span(2..3),
+                    kind: ast::LiteralKind::Verbatim,
+                    c: ']',
+                })],
+            };
+            Ok((set, union))
+        });
+        assert_eq!(parser("[-]a]").parse_set_class_open(), {
+            let set = ast::ClassBracketed {
+                span: span(0..2),
+                negated: false,
+                kind: ast::ClassSet::union(ast::ClassSetUnion {
+                    span: span(1..1),
+                    items: vec![],
+                }),
+            };
+            let union = ast::ClassSetUnion {
+                span: span(1..2),
+                items: vec![ast::ClassSetItem::Literal(ast::Literal {
+                    span: span(1..2),
+                    kind: ast::LiteralKind::Verbatim,
+                    c: '-',
+                })],
+            };
+            Ok((set, union))
+        });
+
+        assert_eq!(
+            parser("[").parse_set_class_open().unwrap_err(),
+            TestError {
+                span: span(0..1),
+                kind: ast::ErrorKind::ClassUnclosed,
+            }
+        );
+        assert_eq!(
+            parser_ignore_whitespace("[    ")
+                .parse_set_class_open()
+                .unwrap_err(),
+            TestError {
+                span: span(0..5),
+                kind: ast::ErrorKind::ClassUnclosed,
+            }
+        );
+        assert_eq!(
+            parser("[^").parse_set_class_open().unwrap_err(),
+            TestError {
+                span: span(0..2),
+                kind: ast::ErrorKind::ClassUnclosed,
+            }
+        );
+        assert_eq!(
+            parser("[]").parse_set_class_open().unwrap_err(),
+            TestError {
+                span: span(0..2),
+                kind: ast::ErrorKind::ClassUnclosed,
+            }
+        );
+        assert_eq!(
+            parser("[-").parse_set_class_open().unwrap_err(),
+            TestError {
+                span: span(0..0),
+                kind: ast::ErrorKind::ClassUnclosed,
+            }
+        );
+        assert_eq!(
+            parser("[--").parse_set_class_open().unwrap_err(),
+            TestError {
+                span: span(0..0),
+                kind: ast::ErrorKind::ClassUnclosed,
+            }
+        );
+
+        // See: https://github.com/rust-lang/regex/issues/792
+        assert_eq!(
+            parser("(?x)[-#]").parse_with_comments().unwrap_err(),
+            TestError {
+                span: span(4..4),
+                kind: ast::ErrorKind::ClassUnclosed,
+            }
+        );
+    }
+
+    #[test]
+    fn maybe_parse_ascii_class() {
+        assert_eq!(
+            parser(r"[:alnum:]").maybe_parse_ascii_class(),
+            Some(ast::ClassAscii {
+                span: span(0..9),
+                kind: ast::ClassAsciiKind::Alnum,
+                negated: false,
+            })
+        );
+        assert_eq!(
+            parser(r"[:alnum:]A").maybe_parse_ascii_class(),
+            Some(ast::ClassAscii {
+                span: span(0..9),
+                kind: ast::ClassAsciiKind::Alnum,
+                negated: false,
+            })
+        );
+        assert_eq!(
+            parser(r"[:^alnum:]").maybe_parse_ascii_class(),
+            Some(ast::ClassAscii {
+                span: span(0..10),
+                kind: ast::ClassAsciiKind::Alnum,
+                negated: true,
+            })
+        );
+
+        let p = parser(r"[:");
+        assert_eq!(p.maybe_parse_ascii_class(), None);
+        assert_eq!(p.offset(), 0);
+
+        let p = parser(r"[:^");
+        assert_eq!(p.maybe_parse_ascii_class(), None);
+        assert_eq!(p.offset(), 0);
+
+        let p = parser(r"[^:alnum:]");
+        assert_eq!(p.maybe_parse_ascii_class(), None);
+        assert_eq!(p.offset(), 0);
+
+        let p = parser(r"[:alnnum:]");
+        assert_eq!(p.maybe_parse_ascii_class(), None);
+        assert_eq!(p.offset(), 0);
+
+        let p = parser(r"[:alnum]");
+        assert_eq!(p.maybe_parse_ascii_class(), None);
+        assert_eq!(p.offset(), 0);
+
+        let p = parser(r"[:alnum:");
+        assert_eq!(p.maybe_parse_ascii_class(), None);
+        assert_eq!(p.offset(), 0);
+    }
+
+    #[test]
+    fn parse_unicode_class() {
+        assert_eq!(
+            parser(r"\pN").parse_escape(),
+            Ok(Primitive::Unicode(ast::ClassUnicode {
+                span: span(0..3),
+                negated: false,
+                kind: ast::ClassUnicodeKind::OneLetter('N'),
+            }))
+        );
+        assert_eq!(
+            parser(r"\PN").parse_escape(),
+            Ok(Primitive::Unicode(ast::ClassUnicode {
+                span: span(0..3),
+                negated: true,
+                kind: ast::ClassUnicodeKind::OneLetter('N'),
+            }))
+        );
+        assert_eq!(
+            parser(r"\p{N}").parse_escape(),
+            Ok(Primitive::Unicode(ast::ClassUnicode {
+                span: span(0..5),
+                negated: false,
+                kind: ast::ClassUnicodeKind::Named(s("N")),
+            }))
+        );
+        assert_eq!(
+            parser(r"\P{N}").parse_escape(),
+            Ok(Primitive::Unicode(ast::ClassUnicode {
+                span: span(0..5),
+                negated: true,
+                kind: ast::ClassUnicodeKind::Named(s("N")),
+            }))
+        );
+        assert_eq!(
+            parser(r"\p{Greek}").parse_escape(),
+            Ok(Primitive::Unicode(ast::ClassUnicode {
+                span: span(0..9),
+                negated: false,
+                kind: ast::ClassUnicodeKind::Named(s("Greek")),
+            }))
+        );
+
+        assert_eq!(
+            parser(r"\p{scx:Katakana}").parse_escape(),
+            Ok(Primitive::Unicode(ast::ClassUnicode {
+                span: span(0..16),
+                negated: false,
+                kind: ast::ClassUnicodeKind::NamedValue {
+                    op: ast::ClassUnicodeOpKind::Colon,
+                    name: s("scx"),
+                    value: s("Katakana"),
+                },
+            }))
+        );
+        assert_eq!(
+            parser(r"\p{scx=Katakana}").parse_escape(),
+            Ok(Primitive::Unicode(ast::ClassUnicode {
+                span: span(0..16),
+                negated: false,
+                kind: ast::ClassUnicodeKind::NamedValue {
+                    op: ast::ClassUnicodeOpKind::Equal,
+                    name: s("scx"),
+                    value: s("Katakana"),
+                },
+            }))
+        );
+        assert_eq!(
+            parser(r"\p{scx!=Katakana}").parse_escape(),
+            Ok(Primitive::Unicode(ast::ClassUnicode {
+                span: span(0..17),
+                negated: false,
+                kind: ast::ClassUnicodeKind::NamedValue {
+                    op: ast::ClassUnicodeOpKind::NotEqual,
+                    name: s("scx"),
+                    value: s("Katakana"),
+                },
+            }))
+        );
+
+        assert_eq!(
+            parser(r"\p{:}").parse_escape(),
+            Ok(Primitive::Unicode(ast::ClassUnicode {
+                span: span(0..5),
+                negated: false,
+                kind: ast::ClassUnicodeKind::NamedValue {
+                    op: ast::ClassUnicodeOpKind::Colon,
+                    name: s(""),
+                    value: s(""),
+                },
+            }))
+        );
+        assert_eq!(
+            parser(r"\p{=}").parse_escape(),
+            Ok(Primitive::Unicode(ast::ClassUnicode {
+                span: span(0..5),
+                negated: false,
+                kind: ast::ClassUnicodeKind::NamedValue {
+                    op: ast::ClassUnicodeOpKind::Equal,
+                    name: s(""),
+                    value: s(""),
+                },
+            }))
+        );
+        assert_eq!(
+            parser(r"\p{!=}").parse_escape(),
+            Ok(Primitive::Unicode(ast::ClassUnicode {
+                span: span(0..6),
+                negated: false,
+                kind: ast::ClassUnicodeKind::NamedValue {
+                    op: ast::ClassUnicodeOpKind::NotEqual,
+                    name: s(""),
+                    value: s(""),
+                },
+            }))
+        );
+
+        assert_eq!(
+            parser(r"\p").parse_escape().unwrap_err(),
+            TestError {
+                span: span(2..2),
+                kind: ast::ErrorKind::EscapeUnexpectedEof,
+            }
+        );
+        assert_eq!(
+            parser(r"\p{").parse_escape().unwrap_err(),
+            TestError {
+                span: span(3..3),
+                kind: ast::ErrorKind::EscapeUnexpectedEof,
+            }
+        );
+        assert_eq!(
+            parser(r"\p{N").parse_escape().unwrap_err(),
+            TestError {
+                span: span(4..4),
+                kind: ast::ErrorKind::EscapeUnexpectedEof,
+            }
+        );
+        assert_eq!(
+            parser(r"\p{Greek").parse_escape().unwrap_err(),
+            TestError {
+                span: span(8..8),
+                kind: ast::ErrorKind::EscapeUnexpectedEof,
+            }
+        );
+
+        assert_eq!(
+            parser(r"\pNz").parse(),
+            Ok(Ast::Concat(ast::Concat {
+                span: span(0..4),
+                asts: vec![
+                    Ast::Class(ast::Class::Unicode(ast::ClassUnicode {
+                        span: span(0..3),
+                        negated: false,
+                        kind: ast::ClassUnicodeKind::OneLetter('N'),
+                    })),
+                    Ast::Literal(ast::Literal {
+                        span: span(3..4),
+                        kind: ast::LiteralKind::Verbatim,
+                        c: 'z',
+                    }),
+                ],
+            }))
+        );
+        assert_eq!(
+            parser(r"\p{Greek}z").parse(),
+            Ok(Ast::Concat(ast::Concat {
+                span: span(0..10),
+                asts: vec![
+                    Ast::Class(ast::Class::Unicode(ast::ClassUnicode {
+                        span: span(0..9),
+                        negated: false,
+                        kind: ast::ClassUnicodeKind::Named(s("Greek")),
+                    })),
+                    Ast::Literal(ast::Literal {
+                        span: span(9..10),
+                        kind: ast::LiteralKind::Verbatim,
+                        c: 'z',
+                    }),
+                ],
+            }))
+        );
+        assert_eq!(
+            parser(r"\p\{").parse().unwrap_err(),
+            TestError {
+                span: span(2..3),
+                kind: ast::ErrorKind::UnicodeClassInvalid,
+            }
+        );
+        assert_eq!(
+            parser(r"\P\{").parse().unwrap_err(),
+            TestError {
+                span: span(2..3),
+                kind: ast::ErrorKind::UnicodeClassInvalid,
+            }
+        );
+    }
+
+    #[test]
+    fn parse_perl_class() {
+        assert_eq!(
+            parser(r"\d").parse_escape(),
+            Ok(Primitive::Perl(ast::ClassPerl {
+                span: span(0..2),
+                kind: ast::ClassPerlKind::Digit,
+                negated: false,
+            }))
+        );
+        assert_eq!(
+            parser(r"\D").parse_escape(),
+            Ok(Primitive::Perl(ast::ClassPerl {
+                span: span(0..2),
+                kind: ast::ClassPerlKind::Digit,
+                negated: true,
+            }))
+        );
+        assert_eq!(
+            parser(r"\s").parse_escape(),
+            Ok(Primitive::Perl(ast::ClassPerl {
+                span: span(0..2),
+                kind: ast::ClassPerlKind::Space,
+                negated: false,
+            }))
+        );
+        assert_eq!(
+            parser(r"\S").parse_escape(),
+            Ok(Primitive::Perl(ast::ClassPerl {
+                span: span(0..2),
+                kind: ast::ClassPerlKind::Space,
+                negated: true,
+            }))
+        );
+        assert_eq!(
+            parser(r"\w").parse_escape(),
+            Ok(Primitive::Perl(ast::ClassPerl {
+                span: span(0..2),
+                kind: ast::ClassPerlKind::Word,
+                negated: false,
+            }))
+        );
+        assert_eq!(
+            parser(r"\W").parse_escape(),
+            Ok(Primitive::Perl(ast::ClassPerl {
+                span: span(0..2),
+                kind: ast::ClassPerlKind::Word,
+                negated: true,
+            }))
+        );
+
+        assert_eq!(
+            parser(r"\d").parse(),
+            Ok(Ast::Class(ast::Class::Perl(ast::ClassPerl {
+                span: span(0..2),
+                kind: ast::ClassPerlKind::Digit,
+                negated: false,
+            })))
+        );
+        assert_eq!(
+            parser(r"\dz").parse(),
+            Ok(Ast::Concat(ast::Concat {
+                span: span(0..3),
+                asts: vec![
+                    Ast::Class(ast::Class::Perl(ast::ClassPerl {
+                        span: span(0..2),
+                        kind: ast::ClassPerlKind::Digit,
+                        negated: false,
+                    })),
+                    Ast::Literal(ast::Literal {
+                        span: span(2..3),
+                        kind: ast::LiteralKind::Verbatim,
+                        c: 'z',
+                    }),
+                ],
+            }))
+        );
+    }
+
+    // This tests a bug fix where the nest limit checker wasn't decrementing
+    // its depth during post-traversal, which causes long regexes to trip
+    // the default limit too aggressively.
+    #[test]
+    fn regression_454_nest_too_big() {
+        let pattern = r#"
+        2(?:
+          [45]\d{3}|
+          7(?:
+            1[0-267]|
+            2[0-289]|
+            3[0-29]|
+            4[01]|
+            5[1-3]|
+            6[013]|
+            7[0178]|
+            91
+          )|
+          8(?:
+            0[125]|
+            [139][1-6]|
+            2[0157-9]|
+            41|
+            6[1-35]|
+            7[1-5]|
+            8[1-8]|
+            90
+          )|
+          9(?:
+            0[0-2]|
+            1[0-4]|
+            2[568]|
+            3[3-6]|
+            5[5-7]|
+            6[0167]|
+            7[15]|
+            8[0146-9]
+          )
+        )\d{4}
+        "#;
+        assert!(parser_nest_limit(pattern, 50).parse().is_ok());
+    }
+
+    // This tests that we treat a trailing `-` in a character class as a
+    // literal `-` even when whitespace mode is enabled and there is whitespace
+    // after the trailing `-`.
+    #[test]
+    fn regression_455_trailing_dash_ignore_whitespace() {
+        assert!(parser("(?x)[ / - ]").parse().is_ok());
+        assert!(parser("(?x)[ a - ]").parse().is_ok());
+        assert!(parser(
+            "(?x)[
+            a
+            - ]
+        "
+        )
+        .parse()
+        .is_ok());
+        assert!(parser(
+            "(?x)[
+            a # wat
+            - ]
+        "
+        )
+        .parse()
+        .is_ok());
+
+        assert!(parser("(?x)[ / -").parse().is_err());
+        assert!(parser("(?x)[ / - ").parse().is_err());
+        assert!(parser(
+            "(?x)[
+            / -
+        "
+        )
+        .parse()
+        .is_err());
+        assert!(parser(
+            "(?x)[
+            / - # wat
+        "
+        )
+        .parse()
+        .is_err());
+    }
+}
diff --git a/crates/regex-syntax/src/ast/print.rs b/crates/regex-syntax/src/ast/print.rs
new file mode 100644
index 0000000..045de2e
--- /dev/null
+++ b/crates/regex-syntax/src/ast/print.rs
@@ -0,0 +1,568 @@
+/*!
+This module provides a regular expression printer for `Ast`.
+*/
+
+use std::fmt;
+
+use crate::ast::visitor::{self, Visitor};
+use crate::ast::{self, Ast};
+
+/// A builder for constructing a printer.
+///
+/// Note that since a printer doesn't have any configuration knobs, this type
+/// remains unexported.
+#[derive(Clone, Debug)]
+struct PrinterBuilder {
+    _priv: (),
+}
+
+impl Default for PrinterBuilder {
+    fn default() -> PrinterBuilder {
+        PrinterBuilder::new()
+    }
+}
+
+impl PrinterBuilder {
+    fn new() -> PrinterBuilder {
+        PrinterBuilder { _priv: () }
+    }
+
+    fn build(&self) -> Printer {
+        Printer { _priv: () }
+    }
+}
+
+/// A printer for a regular expression abstract syntax tree.
+///
+/// A printer converts an abstract syntax tree (AST) to a regular expression
+/// pattern string. This particular printer uses constant stack space and heap
+/// space proportional to the size of the AST.
+///
+/// This printer will not necessarily preserve the original formatting of the
+/// regular expression pattern string. For example, all whitespace and comments
+/// are ignored.
+#[derive(Debug)]
+pub struct Printer {
+    _priv: (),
+}
+
+impl Printer {
+    /// Create a new printer.
+    pub fn new() -> Printer {
+        PrinterBuilder::new().build()
+    }
+
+    /// Print the given `Ast` to the given writer. The writer must implement
+    /// `fmt::Write`. Typical implementations of `fmt::Write` that can be used
+    /// here are a `fmt::Formatter` (which is available in `fmt::Display`
+    /// implementations) or a `&mut String`.
+    pub fn print<W: fmt::Write>(&mut self, ast: &Ast, wtr: W) -> fmt::Result {
+        visitor::visit(ast, Writer { wtr })
+    }
+}
+
+#[derive(Debug)]
+struct Writer<W> {
+    wtr: W,
+}
+
+impl<W: fmt::Write> Visitor for Writer<W> {
+    type Output = ();
+    type Err = fmt::Error;
+
+    fn finish(self) -> fmt::Result {
+        Ok(())
+    }
+
+    fn visit_pre(&mut self, ast: &Ast) -> fmt::Result {
+        match *ast {
+            Ast::Group(ref x) => self.fmt_group_pre(x),
+            Ast::Class(ast::Class::Bracketed(ref x)) => {
+                self.fmt_class_bracketed_pre(x)
+            }
+            _ => Ok(()),
+        }
+    }
+
+    fn visit_post(&mut self, ast: &Ast) -> fmt::Result {
+        use crate::ast::Class;
+
+        match *ast {
+            Ast::Empty(_) => Ok(()),
+            Ast::Flags(ref x) => self.fmt_set_flags(x),
+            Ast::Literal(ref x) => self.fmt_literal(x),
+            Ast::Dot(_) => self.wtr.write_str("."),
+            Ast::Assertion(ref x) => self.fmt_assertion(x),
+            Ast::Class(Class::Perl(ref x)) => self.fmt_class_perl(x),
+            Ast::Class(Class::Unicode(ref x)) => self.fmt_class_unicode(x),
+            Ast::Class(Class::Bracketed(ref x)) => {
+                self.fmt_class_bracketed_post(x)
+            }
+            Ast::Repetition(ref x) => self.fmt_repetition(x),
+            Ast::Group(ref x) => self.fmt_group_post(x),
+            Ast::Alternation(_) => Ok(()),
+            Ast::Concat(_) => Ok(()),
+        }
+    }
+
+    fn visit_alternation_in(&mut self) -> fmt::Result {
+        self.wtr.write_str("|")
+    }
+
+    fn visit_class_set_item_pre(
+        &mut self,
+        ast: &ast::ClassSetItem,
+    ) -> Result<(), Self::Err> {
+        match *ast {
+            ast::ClassSetItem::Bracketed(ref x) => {
+                self.fmt_class_bracketed_pre(x)
+            }
+            _ => Ok(()),
+        }
+    }
+
+    fn visit_class_set_item_post(
+        &mut self,
+        ast: &ast::ClassSetItem,
+    ) -> Result<(), Self::Err> {
+        use crate::ast::ClassSetItem::*;
+
+        match *ast {
+            Empty(_) => Ok(()),
+            Literal(ref x) => self.fmt_literal(x),
+            Range(ref x) => {
+                self.fmt_literal(&x.start)?;
+                self.wtr.write_str("-")?;
+                self.fmt_literal(&x.end)?;
+                Ok(())
+            }
+            Ascii(ref x) => self.fmt_class_ascii(x),
+            Unicode(ref x) => self.fmt_class_unicode(x),
+            Perl(ref x) => self.fmt_class_perl(x),
+            Bracketed(ref x) => self.fmt_class_bracketed_post(x),
+            Union(_) => Ok(()),
+        }
+    }
+
+    fn visit_class_set_binary_op_in(
+        &mut self,
+        ast: &ast::ClassSetBinaryOp,
+    ) -> Result<(), Self::Err> {
+        self.fmt_class_set_binary_op_kind(&ast.kind)
+    }
+}
+
+impl<W: fmt::Write> Writer<W> {
+    fn fmt_group_pre(&mut self, ast: &ast::Group) -> fmt::Result {
+        use crate::ast::GroupKind::*;
+        match ast.kind {
+            CaptureIndex(_) => self.wtr.write_str("("),
+            CaptureName(ref x) => {
+                self.wtr.write_str("(?P<")?;
+                self.wtr.write_str(&x.name)?;
+                self.wtr.write_str(">")?;
+                Ok(())
+            }
+            NonCapturing(ref flags) => {
+                self.wtr.write_str("(?")?;
+                self.fmt_flags(flags)?;
+                self.wtr.write_str(":")?;
+                Ok(())
+            }
+        }
+    }
+
+    fn fmt_group_post(&mut self, _ast: &ast::Group) -> fmt::Result {
+        self.wtr.write_str(")")
+    }
+
+    fn fmt_repetition(&mut self, ast: &ast::Repetition) -> fmt::Result {
+        use crate::ast::RepetitionKind::*;
+        match ast.op.kind {
+            ZeroOrOne if ast.greedy => self.wtr.write_str("?"),
+            ZeroOrOne => self.wtr.write_str("??"),
+            ZeroOrMore if ast.greedy => self.wtr.write_str("*"),
+            ZeroOrMore => self.wtr.write_str("*?"),
+            OneOrMore if ast.greedy => self.wtr.write_str("+"),
+            OneOrMore => self.wtr.write_str("+?"),
+            Range(ref x) => {
+                self.fmt_repetition_range(x)?;
+                if !ast.greedy {
+                    self.wtr.write_str("?")?;
+                }
+                Ok(())
+            }
+        }
+    }
+
+    fn fmt_repetition_range(
+        &mut self,
+        ast: &ast::RepetitionRange,
+    ) -> fmt::Result {
+        use crate::ast::RepetitionRange::*;
+        match *ast {
+            Exactly(x) => write!(self.wtr, "{{{}}}", x),
+            AtLeast(x) => write!(self.wtr, "{{{},}}", x),
+            Bounded(x, y) => write!(self.wtr, "{{{},{}}}", x, y),
+        }
+    }
+
+    fn fmt_literal(&mut self, ast: &ast::Literal) -> fmt::Result {
+        use crate::ast::LiteralKind::*;
+
+        match ast.kind {
+            Verbatim => self.wtr.write_char(ast.c),
+            Punctuation => write!(self.wtr, r"\{}", ast.c),
+            Octal => write!(self.wtr, r"\{:o}", ast.c as u32),
+            HexFixed(ast::HexLiteralKind::X) => {
+                write!(self.wtr, r"\x{:02X}", ast.c as u32)
+            }
+            HexFixed(ast::HexLiteralKind::UnicodeShort) => {
+                write!(self.wtr, r"\u{:04X}", ast.c as u32)
+            }
+            HexFixed(ast::HexLiteralKind::UnicodeLong) => {
+                write!(self.wtr, r"\U{:08X}", ast.c as u32)
+            }
+            HexBrace(ast::HexLiteralKind::X) => {
+                write!(self.wtr, r"\x{{{:X}}}", ast.c as u32)
+            }
+            HexBrace(ast::HexLiteralKind::UnicodeShort) => {
+                write!(self.wtr, r"\u{{{:X}}}", ast.c as u32)
+            }
+            HexBrace(ast::HexLiteralKind::UnicodeLong) => {
+                write!(self.wtr, r"\U{{{:X}}}", ast.c as u32)
+            }
+            Special(ast::SpecialLiteralKind::Bell) => {
+                self.wtr.write_str(r"\a")
+            }
+            Special(ast::SpecialLiteralKind::FormFeed) => {
+                self.wtr.write_str(r"\f")
+            }
+            Special(ast::SpecialLiteralKind::Tab) => self.wtr.write_str(r"\t"),
+            Special(ast::SpecialLiteralKind::LineFeed) => {
+                self.wtr.write_str(r"\n")
+            }
+            Special(ast::SpecialLiteralKind::CarriageReturn) => {
+                self.wtr.write_str(r"\r")
+            }
+            Special(ast::SpecialLiteralKind::VerticalTab) => {
+                self.wtr.write_str(r"\v")
+            }
+            Special(ast::SpecialLiteralKind::Space) => {
+                self.wtr.write_str(r"\ ")
+            }
+        }
+    }
+
+    fn fmt_assertion(&mut self, ast: &ast::Assertion) -> fmt::Result {
+        use crate::ast::AssertionKind::*;
+        match ast.kind {
+            StartLine => self.wtr.write_str("^"),
+            EndLine => self.wtr.write_str("$"),
+            StartText => self.wtr.write_str(r"\A"),
+            EndText => self.wtr.write_str(r"\z"),
+            WordBoundary => self.wtr.write_str(r"\b"),
+            NotWordBoundary => self.wtr.write_str(r"\B"),
+        }
+    }
+
+    fn fmt_set_flags(&mut self, ast: &ast::SetFlags) -> fmt::Result {
+        self.wtr.write_str("(?")?;
+        self.fmt_flags(&ast.flags)?;
+        self.wtr.write_str(")")?;
+        Ok(())
+    }
+
+    fn fmt_flags(&mut self, ast: &ast::Flags) -> fmt::Result {
+        use crate::ast::{Flag, FlagsItemKind};
+
+        for item in &ast.items {
+            match item.kind {
+                FlagsItemKind::Negation => self.wtr.write_str("-"),
+                FlagsItemKind::Flag(ref flag) => match *flag {
+                    Flag::CaseInsensitive => self.wtr.write_str("i"),
+                    Flag::MultiLine => self.wtr.write_str("m"),
+                    Flag::DotMatchesNewLine => self.wtr.write_str("s"),
+                    Flag::SwapGreed => self.wtr.write_str("U"),
+                    Flag::Unicode => self.wtr.write_str("u"),
+                    Flag::IgnoreWhitespace => self.wtr.write_str("x"),
+                },
+            }?;
+        }
+        Ok(())
+    }
+
+    fn fmt_class_bracketed_pre(
+        &mut self,
+        ast: &ast::ClassBracketed,
+    ) -> fmt::Result {
+        if ast.negated {
+            self.wtr.write_str("[^")
+        } else {
+            self.wtr.write_str("[")
+        }
+    }
+
+    fn fmt_class_bracketed_post(
+        &mut self,
+        _ast: &ast::ClassBracketed,
+    ) -> fmt::Result {
+        self.wtr.write_str("]")
+    }
+
+    fn fmt_class_set_binary_op_kind(
+        &mut self,
+        ast: &ast::ClassSetBinaryOpKind,
+    ) -> fmt::Result {
+        use crate::ast::ClassSetBinaryOpKind::*;
+        match *ast {
+            Intersection => self.wtr.write_str("&&"),
+            Difference => self.wtr.write_str("--"),
+            SymmetricDifference => self.wtr.write_str("~~"),
+        }
+    }
+
+    fn fmt_class_perl(&mut self, ast: &ast::ClassPerl) -> fmt::Result {
+        use crate::ast::ClassPerlKind::*;
+        match ast.kind {
+            Digit if ast.negated => self.wtr.write_str(r"\D"),
+            Digit => self.wtr.write_str(r"\d"),
+            Space if ast.negated => self.wtr.write_str(r"\S"),
+            Space => self.wtr.write_str(r"\s"),
+            Word if ast.negated => self.wtr.write_str(r"\W"),
+            Word => self.wtr.write_str(r"\w"),
+        }
+    }
+
+    fn fmt_class_ascii(&mut self, ast: &ast::ClassAscii) -> fmt::Result {
+        use crate::ast::ClassAsciiKind::*;
+        match ast.kind {
+            Alnum if ast.negated => self.wtr.write_str("[:^alnum:]"),
+            Alnum => self.wtr.write_str("[:alnum:]"),
+            Alpha if ast.negated => self.wtr.write_str("[:^alpha:]"),
+            Alpha => self.wtr.write_str("[:alpha:]"),
+            Ascii if ast.negated => self.wtr.write_str("[:^ascii:]"),
+            Ascii => self.wtr.write_str("[:ascii:]"),
+            Blank if ast.negated => self.wtr.write_str("[:^blank:]"),
+            Blank => self.wtr.write_str("[:blank:]"),
+            Cntrl if ast.negated => self.wtr.write_str("[:^cntrl:]"),
+            Cntrl => self.wtr.write_str("[:cntrl:]"),
+            Digit if ast.negated => self.wtr.write_str("[:^digit:]"),
+            Digit => self.wtr.write_str("[:digit:]"),
+            Graph if ast.negated => self.wtr.write_str("[:^graph:]"),
+            Graph => self.wtr.write_str("[:graph:]"),
+            Lower if ast.negated => self.wtr.write_str("[:^lower:]"),
+            Lower => self.wtr.write_str("[:lower:]"),
+            Print if ast.negated => self.wtr.write_str("[:^print:]"),
+            Print => self.wtr.write_str("[:print:]"),
+            Punct if ast.negated => self.wtr.write_str("[:^punct:]"),
+            Punct => self.wtr.write_str("[:punct:]"),
+            Space if ast.negated => self.wtr.write_str("[:^space:]"),
+            Space => self.wtr.write_str("[:space:]"),
+            Upper if ast.negated => self.wtr.write_str("[:^upper:]"),
+            Upper => self.wtr.write_str("[:upper:]"),
+            Word if ast.negated => self.wtr.write_str("[:^word:]"),
+            Word => self.wtr.write_str("[:word:]"),
+            Xdigit if ast.negated => self.wtr.write_str("[:^xdigit:]"),
+            Xdigit => self.wtr.write_str("[:xdigit:]"),
+        }
+    }
+
+    fn fmt_class_unicode(&mut self, ast: &ast::ClassUnicode) -> fmt::Result {
+        use crate::ast::ClassUnicodeKind::*;
+        use crate::ast::ClassUnicodeOpKind::*;
+
+        if ast.negated {
+            self.wtr.write_str(r"\P")?;
+        } else {
+            self.wtr.write_str(r"\p")?;
+        }
+        match ast.kind {
+            OneLetter(c) => self.wtr.write_char(c),
+            Named(ref x) => write!(self.wtr, "{{{}}}", x),
+            NamedValue { op: Equal, ref name, ref value } => {
+                write!(self.wtr, "{{{}={}}}", name, value)
+            }
+            NamedValue { op: Colon, ref name, ref value } => {
+                write!(self.wtr, "{{{}:{}}}", name, value)
+            }
+            NamedValue { op: NotEqual, ref name, ref value } => {
+                write!(self.wtr, "{{{}!={}}}", name, value)
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Printer;
+    use crate::ast::parse::ParserBuilder;
+
+    fn roundtrip(given: &str) {
+        roundtrip_with(|b| b, given);
+    }
+
+    fn roundtrip_with<F>(mut f: F, given: &str)
+    where
+        F: FnMut(&mut ParserBuilder) -> &mut ParserBuilder,
+    {
+        let mut builder = ParserBuilder::new();
+        f(&mut builder);
+        let ast = builder.build().parse(given).unwrap();
+
+        let mut printer = Printer::new();
+        let mut dst = String::new();
+        printer.print(&ast, &mut dst).unwrap();
+        assert_eq!(given, dst);
+    }
+
+    #[test]
+    fn print_literal() {
+        roundtrip("a");
+        roundtrip(r"\[");
+        roundtrip_with(|b| b.octal(true), r"\141");
+        roundtrip(r"\x61");
+        roundtrip(r"\x7F");
+        roundtrip(r"\u0061");
+        roundtrip(r"\U00000061");
+        roundtrip(r"\x{61}");
+        roundtrip(r"\x{7F}");
+        roundtrip(r"\u{61}");
+        roundtrip(r"\U{61}");
+
+        roundtrip(r"\a");
+        roundtrip(r"\f");
+        roundtrip(r"\t");
+        roundtrip(r"\n");
+        roundtrip(r"\r");
+        roundtrip(r"\v");
+        roundtrip(r"(?x)\ ");
+    }
+
+    #[test]
+    fn print_dot() {
+        roundtrip(".");
+    }
+
+    #[test]
+    fn print_concat() {
+        roundtrip("ab");
+        roundtrip("abcde");
+        roundtrip("a(bcd)ef");
+    }
+
+    #[test]
+    fn print_alternation() {
+        roundtrip("a|b");
+        roundtrip("a|b|c|d|e");
+        roundtrip("|a|b|c|d|e");
+        roundtrip("|a|b|c|d|e|");
+        roundtrip("a(b|c|d)|e|f");
+    }
+
+    #[test]
+    fn print_assertion() {
+        roundtrip(r"^");
+        roundtrip(r"$");
+        roundtrip(r"\A");
+        roundtrip(r"\z");
+        roundtrip(r"\b");
+        roundtrip(r"\B");
+    }
+
+    #[test]
+    fn print_repetition() {
+        roundtrip("a?");
+        roundtrip("a??");
+        roundtrip("a*");
+        roundtrip("a*?");
+        roundtrip("a+");
+        roundtrip("a+?");
+        roundtrip("a{5}");
+        roundtrip("a{5}?");
+        roundtrip("a{5,}");
+        roundtrip("a{5,}?");
+        roundtrip("a{5,10}");
+        roundtrip("a{5,10}?");
+    }
+
+    #[test]
+    fn print_flags() {
+        roundtrip("(?i)");
+        roundtrip("(?-i)");
+        roundtrip("(?s-i)");
+        roundtrip("(?-si)");
+        roundtrip("(?siUmux)");
+    }
+
+    #[test]
+    fn print_group() {
+        roundtrip("(?i:a)");
+        roundtrip("(?P<foo>a)");
+        roundtrip("(a)");
+    }
+
+    #[test]
+    fn print_class() {
+        roundtrip(r"[abc]");
+        roundtrip(r"[a-z]");
+        roundtrip(r"[^a-z]");
+        roundtrip(r"[a-z0-9]");
+        roundtrip(r"[-a-z0-9]");
+        roundtrip(r"[-a-z0-9]");
+        roundtrip(r"[a-z0-9---]");
+        roundtrip(r"[a-z&&m-n]");
+        roundtrip(r"[[a-z&&m-n]]");
+        roundtrip(r"[a-z--m-n]");
+        roundtrip(r"[a-z~~m-n]");
+        roundtrip(r"[a-z[0-9]]");
+        roundtrip(r"[a-z[^0-9]]");
+
+        roundtrip(r"\d");
+        roundtrip(r"\D");
+        roundtrip(r"\s");
+        roundtrip(r"\S");
+        roundtrip(r"\w");
+        roundtrip(r"\W");
+
+        roundtrip(r"[[:alnum:]]");
+        roundtrip(r"[[:^alnum:]]");
+        roundtrip(r"[[:alpha:]]");
+        roundtrip(r"[[:^alpha:]]");
+        roundtrip(r"[[:ascii:]]");
+        roundtrip(r"[[:^ascii:]]");
+        roundtrip(r"[[:blank:]]");
+        roundtrip(r"[[:^blank:]]");
+        roundtrip(r"[[:cntrl:]]");
+        roundtrip(r"[[:^cntrl:]]");
+        roundtrip(r"[[:digit:]]");
+        roundtrip(r"[[:^digit:]]");
+        roundtrip(r"[[:graph:]]");
+        roundtrip(r"[[:^graph:]]");
+        roundtrip(r"[[:lower:]]");
+        roundtrip(r"[[:^lower:]]");
+        roundtrip(r"[[:print:]]");
+        roundtrip(r"[[:^print:]]");
+        roundtrip(r"[[:punct:]]");
+        roundtrip(r"[[:^punct:]]");
+        roundtrip(r"[[:space:]]");
+        roundtrip(r"[[:^space:]]");
+        roundtrip(r"[[:upper:]]");
+        roundtrip(r"[[:^upper:]]");
+        roundtrip(r"[[:word:]]");
+        roundtrip(r"[[:^word:]]");
+        roundtrip(r"[[:xdigit:]]");
+        roundtrip(r"[[:^xdigit:]]");
+
+        roundtrip(r"\pL");
+        roundtrip(r"\PL");
+        roundtrip(r"\p{L}");
+        roundtrip(r"\P{L}");
+        roundtrip(r"\p{X=Y}");
+        roundtrip(r"\P{X=Y}");
+        roundtrip(r"\p{X:Y}");
+        roundtrip(r"\P{X:Y}");
+        roundtrip(r"\p{X!=Y}");
+        roundtrip(r"\P{X!=Y}");
+    }
+}
diff --git a/crates/regex-syntax/src/ast/visitor.rs b/crates/regex-syntax/src/ast/visitor.rs
new file mode 100644
index 0000000..78ee487
--- /dev/null
+++ b/crates/regex-syntax/src/ast/visitor.rs
@@ -0,0 +1,517 @@
+use std::fmt;
+
+use crate::ast::{self, Ast};
+
+/// A trait for visiting an abstract syntax tree (AST) in depth first order.
+///
+/// The principle aim of this trait is to enable callers to perform case
+/// analysis on an abstract syntax tree without necessarily using recursion.
+/// In particular, this permits callers to do case analysis with constant stack
+/// usage, which can be important since the size of an abstract syntax tree
+/// may be proportional to end user input.
+///
+/// Typical usage of this trait involves providing an implementation and then
+/// running it using the [`visit`](fn.visit.html) function.
+///
+/// Note that the abstract syntax tree for a regular expression is quite
+/// complex. Unless you specifically need it, you might be able to use the
+/// much simpler
+/// [high-level intermediate representation](../hir/struct.Hir.html)
+/// and its
+/// [corresponding `Visitor` trait](../hir/trait.Visitor.html)
+/// instead.
+pub trait Visitor {
+    /// The result of visiting an AST.
+    type Output;
+    /// An error that visiting an AST might return.
+    type Err;
+
+    /// All implementors of `Visitor` must provide a `finish` method, which
+    /// yields the result of visiting the AST or an error.
+    fn finish(self) -> Result<Self::Output, Self::Err>;
+
+    /// This method is called before beginning traversal of the AST.
+    fn start(&mut self) {}
+
+    /// This method is called on an `Ast` before descending into child `Ast`
+    /// nodes.
+    fn visit_pre(&mut self, _ast: &Ast) -> Result<(), Self::Err> {
+        Ok(())
+    }
+
+    /// This method is called on an `Ast` after descending all of its child
+    /// `Ast` nodes.
+    fn visit_post(&mut self, _ast: &Ast) -> Result<(), Self::Err> {
+        Ok(())
+    }
+
+    /// This method is called between child nodes of an
+    /// [`Alternation`](struct.Alternation.html).
+    fn visit_alternation_in(&mut self) -> Result<(), Self::Err> {
+        Ok(())
+    }
+
+    /// This method is called on every
+    /// [`ClassSetItem`](enum.ClassSetItem.html)
+    /// before descending into child nodes.
+    fn visit_class_set_item_pre(
+        &mut self,
+        _ast: &ast::ClassSetItem,
+    ) -> Result<(), Self::Err> {
+        Ok(())
+    }
+
+    /// This method is called on every
+    /// [`ClassSetItem`](enum.ClassSetItem.html)
+    /// after descending into child nodes.
+    fn visit_class_set_item_post(
+        &mut self,
+        _ast: &ast::ClassSetItem,
+    ) -> Result<(), Self::Err> {
+        Ok(())
+    }
+
+    /// This method is called on every
+    /// [`ClassSetBinaryOp`](struct.ClassSetBinaryOp.html)
+    /// before descending into child nodes.
+    fn visit_class_set_binary_op_pre(
+        &mut self,
+        _ast: &ast::ClassSetBinaryOp,
+    ) -> Result<(), Self::Err> {
+        Ok(())
+    }
+
+    /// This method is called on every
+    /// [`ClassSetBinaryOp`](struct.ClassSetBinaryOp.html)
+    /// after descending into child nodes.
+    fn visit_class_set_binary_op_post(
+        &mut self,
+        _ast: &ast::ClassSetBinaryOp,
+    ) -> Result<(), Self::Err> {
+        Ok(())
+    }
+
+    /// This method is called between the left hand and right hand child nodes
+    /// of a [`ClassSetBinaryOp`](struct.ClassSetBinaryOp.html).
+    fn visit_class_set_binary_op_in(
+        &mut self,
+        _ast: &ast::ClassSetBinaryOp,
+    ) -> Result<(), Self::Err> {
+        Ok(())
+    }
+}
+
+/// Executes an implementation of `Visitor` in constant stack space.
+///
+/// This function will visit every node in the given `Ast` while calling the
+/// appropriate methods provided by the
+/// [`Visitor`](trait.Visitor.html) trait.
+///
+/// The primary use case for this method is when one wants to perform case
+/// analysis over an `Ast` without using a stack size proportional to the depth
+/// of the `Ast`. Namely, this method will instead use constant stack size, but
+/// will use heap space proportional to the size of the `Ast`. This may be
+/// desirable in cases where the size of `Ast` is proportional to end user
+/// input.
+///
+/// If the visitor returns an error at any point, then visiting is stopped and
+/// the error is returned.
+pub fn visit<V: Visitor>(ast: &Ast, visitor: V) -> Result<V::Output, V::Err> {
+    HeapVisitor::new().visit(ast, visitor)
+}
+
+/// HeapVisitor visits every item in an `Ast` recursively using constant stack
+/// size and a heap size proportional to the size of the `Ast`.
+struct HeapVisitor<'a> {
+    /// A stack of `Ast` nodes. This is roughly analogous to the call stack
+    /// used in a typical recursive visitor.
+    stack: Vec<(&'a Ast, Frame<'a>)>,
+    /// Similar to the `Ast` stack above, but is used only for character
+    /// classes. In particular, character classes embed their own mini
+    /// recursive syntax.
+    stack_class: Vec<(ClassInduct<'a>, ClassFrame<'a>)>,
+}
+
+/// Represents a single stack frame while performing structural induction over
+/// an `Ast`.
+enum Frame<'a> {
+    /// A stack frame allocated just before descending into a repetition
+    /// operator's child node.
+    Repetition(&'a ast::Repetition),
+    /// A stack frame allocated just before descending into a group's child
+    /// node.
+    Group(&'a ast::Group),
+    /// The stack frame used while visiting every child node of a concatenation
+    /// of expressions.
+    Concat {
+        /// The child node we are currently visiting.
+        head: &'a Ast,
+        /// The remaining child nodes to visit (which may be empty).
+        tail: &'a [Ast],
+    },
+    /// The stack frame used while visiting every child node of an alternation
+    /// of expressions.
+    Alternation {
+        /// The child node we are currently visiting.
+        head: &'a Ast,
+        /// The remaining child nodes to visit (which may be empty).
+        tail: &'a [Ast],
+    },
+}
+
+/// Represents a single stack frame while performing structural induction over
+/// a character class.
+enum ClassFrame<'a> {
+    /// The stack frame used while visiting every child node of a union of
+    /// character class items.
+    Union {
+        /// The child node we are currently visiting.
+        head: &'a ast::ClassSetItem,
+        /// The remaining child nodes to visit (which may be empty).
+        tail: &'a [ast::ClassSetItem],
+    },
+    /// The stack frame used while a binary class operation.
+    Binary { op: &'a ast::ClassSetBinaryOp },
+    /// A stack frame allocated just before descending into a binary operator's
+    /// left hand child node.
+    BinaryLHS {
+        op: &'a ast::ClassSetBinaryOp,
+        lhs: &'a ast::ClassSet,
+        rhs: &'a ast::ClassSet,
+    },
+    /// A stack frame allocated just before descending into a binary operator's
+    /// right hand child node.
+    BinaryRHS { op: &'a ast::ClassSetBinaryOp, rhs: &'a ast::ClassSet },
+}
+
+/// A representation of the inductive step when performing structural induction
+/// over a character class.
+///
+/// Note that there is no analogous explicit type for the inductive step for
+/// `Ast` nodes because the inductive step is just an `Ast`. For character
+/// classes, the inductive step can produce one of two possible child nodes:
+/// an item or a binary operation. (An item cannot be a binary operation
+/// because that would imply binary operations can be unioned in the concrete
+/// syntax, which is not possible.)
+enum ClassInduct<'a> {
+    Item(&'a ast::ClassSetItem),
+    BinaryOp(&'a ast::ClassSetBinaryOp),
+}
+
+impl<'a> HeapVisitor<'a> {
+    fn new() -> HeapVisitor<'a> {
+        HeapVisitor { stack: vec![], stack_class: vec![] }
+    }
+
+    fn visit<V: Visitor>(
+        &mut self,
+        mut ast: &'a Ast,
+        mut visitor: V,
+    ) -> Result<V::Output, V::Err> {
+        self.stack.clear();
+        self.stack_class.clear();
+
+        visitor.start();
+        loop {
+            visitor.visit_pre(ast)?;
+            if let Some(x) = self.induct(ast, &mut visitor)? {
+                let child = x.child();
+                self.stack.push((ast, x));
+                ast = child;
+                continue;
+            }
+            // No induction means we have a base case, so we can post visit
+            // it now.
+            visitor.visit_post(ast)?;
+
+            // At this point, we now try to pop our call stack until it is
+            // either empty or we hit another inductive case.
+            loop {
+                let (post_ast, frame) = match self.stack.pop() {
+                    None => return visitor.finish(),
+                    Some((post_ast, frame)) => (post_ast, frame),
+                };
+                // If this is a concat/alternate, then we might have additional
+                // inductive steps to process.
+                if let Some(x) = self.pop(frame) {
+                    if let Frame::Alternation { .. } = x {
+                        visitor.visit_alternation_in()?;
+                    }
+                    ast = x.child();
+                    self.stack.push((post_ast, x));
+                    break;
+                }
+                // Otherwise, we've finished visiting all the child nodes for
+                // this AST, so we can post visit it now.
+                visitor.visit_post(post_ast)?;
+            }
+        }
+    }
+
+    /// Build a stack frame for the given AST if one is needed (which occurs if
+    /// and only if there are child nodes in the AST). Otherwise, return None.
+    ///
+    /// If this visits a class, then the underlying visitor implementation may
+    /// return an error which will be passed on here.
+    fn induct<V: Visitor>(
+        &mut self,
+        ast: &'a Ast,
+        visitor: &mut V,
+    ) -> Result<Option<Frame<'a>>, V::Err> {
+        Ok(match *ast {
+            Ast::Class(ast::Class::Bracketed(ref x)) => {
+                self.visit_class(x, visitor)?;
+                None
+            }
+            Ast::Repetition(ref x) => Some(Frame::Repetition(x)),
+            Ast::Group(ref x) => Some(Frame::Group(x)),
+            Ast::Concat(ref x) if x.asts.is_empty() => None,
+            Ast::Concat(ref x) => {
+                Some(Frame::Concat { head: &x.asts[0], tail: &x.asts[1..] })
+            }
+            Ast::Alternation(ref x) if x.asts.is_empty() => None,
+            Ast::Alternation(ref x) => Some(Frame::Alternation {
+                head: &x.asts[0],
+                tail: &x.asts[1..],
+            }),
+            _ => None,
+        })
+    }
+
+    /// Pops the given frame. If the frame has an additional inductive step,
+    /// then return it, otherwise return `None`.
+    fn pop(&self, induct: Frame<'a>) -> Option<Frame<'a>> {
+        match induct {
+            Frame::Repetition(_) => None,
+            Frame::Group(_) => None,
+            Frame::Concat { tail, .. } => {
+                if tail.is_empty() {
+                    None
+                } else {
+                    Some(Frame::Concat { head: &tail[0], tail: &tail[1..] })
+                }
+            }
+            Frame::Alternation { tail, .. } => {
+                if tail.is_empty() {
+                    None
+                } else {
+                    Some(Frame::Alternation {
+                        head: &tail[0],
+                        tail: &tail[1..],
+                    })
+                }
+            }
+        }
+    }
+
+    fn visit_class<V: Visitor>(
+        &mut self,
+        ast: &'a ast::ClassBracketed,
+        visitor: &mut V,
+    ) -> Result<(), V::Err> {
+        let mut ast = ClassInduct::from_bracketed(ast);
+        loop {
+            self.visit_class_pre(&ast, visitor)?;
+            if let Some(x) = self.induct_class(&ast) {
+                let child = x.child();
+                self.stack_class.push((ast, x));
+                ast = child;
+                continue;
+            }
+            self.visit_class_post(&ast, visitor)?;
+
+            // At this point, we now try to pop our call stack until it is
+            // either empty or we hit another inductive case.
+            loop {
+                let (post_ast, frame) = match self.stack_class.pop() {
+                    None => return Ok(()),
+                    Some((post_ast, frame)) => (post_ast, frame),
+                };
+                // If this is a union or a binary op, then we might have
+                // additional inductive steps to process.
+                if let Some(x) = self.pop_class(frame) {
+                    if let ClassFrame::BinaryRHS { ref op, .. } = x {
+                        visitor.visit_class_set_binary_op_in(op)?;
+                    }
+                    ast = x.child();
+                    self.stack_class.push((post_ast, x));
+                    break;
+                }
+                // Otherwise, we've finished visiting all the child nodes for
+                // this class node, so we can post visit it now.
+                self.visit_class_post(&post_ast, visitor)?;
+            }
+        }
+    }
+
+    /// Call the appropriate `Visitor` methods given an inductive step.
+    fn visit_class_pre<V: Visitor>(
+        &self,
+        ast: &ClassInduct<'a>,
+        visitor: &mut V,
+    ) -> Result<(), V::Err> {
+        match *ast {
+            ClassInduct::Item(item) => {
+                visitor.visit_class_set_item_pre(item)?;
+            }
+            ClassInduct::BinaryOp(op) => {
+                visitor.visit_class_set_binary_op_pre(op)?;
+            }
+        }
+        Ok(())
+    }
+
+    /// Call the appropriate `Visitor` methods given an inductive step.
+    fn visit_class_post<V: Visitor>(
+        &self,
+        ast: &ClassInduct<'a>,
+        visitor: &mut V,
+    ) -> Result<(), V::Err> {
+        match *ast {
+            ClassInduct::Item(item) => {
+                visitor.visit_class_set_item_post(item)?;
+            }
+            ClassInduct::BinaryOp(op) => {
+                visitor.visit_class_set_binary_op_post(op)?;
+            }
+        }
+        Ok(())
+    }
+
+    /// Build a stack frame for the given class node if one is needed (which
+    /// occurs if and only if there are child nodes). Otherwise, return None.
+    fn induct_class(&self, ast: &ClassInduct<'a>) -> Option<ClassFrame<'a>> {
+        match *ast {
+            ClassInduct::Item(&ast::ClassSetItem::Bracketed(ref x)) => {
+                match x.kind {
+                    ast::ClassSet::Item(ref item) => {
+                        Some(ClassFrame::Union { head: item, tail: &[] })
+                    }
+                    ast::ClassSet::BinaryOp(ref op) => {
+                        Some(ClassFrame::Binary { op })
+                    }
+                }
+            }
+            ClassInduct::Item(&ast::ClassSetItem::Union(ref x)) => {
+                if x.items.is_empty() {
+                    None
+                } else {
+                    Some(ClassFrame::Union {
+                        head: &x.items[0],
+                        tail: &x.items[1..],
+                    })
+                }
+            }
+            ClassInduct::BinaryOp(op) => {
+                Some(ClassFrame::BinaryLHS { op, lhs: &op.lhs, rhs: &op.rhs })
+            }
+            _ => None,
+        }
+    }
+
+    /// Pops the given frame. If the frame has an additional inductive step,
+    /// then return it, otherwise return `None`.
+    fn pop_class(&self, induct: ClassFrame<'a>) -> Option<ClassFrame<'a>> {
+        match induct {
+            ClassFrame::Union { tail, .. } => {
+                if tail.is_empty() {
+                    None
+                } else {
+                    Some(ClassFrame::Union {
+                        head: &tail[0],
+                        tail: &tail[1..],
+                    })
+                }
+            }
+            ClassFrame::Binary { .. } => None,
+            ClassFrame::BinaryLHS { op, rhs, .. } => {
+                Some(ClassFrame::BinaryRHS { op, rhs })
+            }
+            ClassFrame::BinaryRHS { .. } => None,
+        }
+    }
+}
+
+impl<'a> Frame<'a> {
+    /// Perform the next inductive step on this frame and return the next
+    /// child AST node to visit.
+    fn child(&self) -> &'a Ast {
+        match *self {
+            Frame::Repetition(rep) => &rep.ast,
+            Frame::Group(group) => &group.ast,
+            Frame::Concat { head, .. } => head,
+            Frame::Alternation { head, .. } => head,
+        }
+    }
+}
+
+impl<'a> ClassFrame<'a> {
+    /// Perform the next inductive step on this frame and return the next
+    /// child class node to visit.
+    fn child(&self) -> ClassInduct<'a> {
+        match *self {
+            ClassFrame::Union { head, .. } => ClassInduct::Item(head),
+            ClassFrame::Binary { op, .. } => ClassInduct::BinaryOp(op),
+            ClassFrame::BinaryLHS { ref lhs, .. } => {
+                ClassInduct::from_set(lhs)
+            }
+            ClassFrame::BinaryRHS { ref rhs, .. } => {
+                ClassInduct::from_set(rhs)
+            }
+        }
+    }
+}
+
+impl<'a> ClassInduct<'a> {
+    fn from_bracketed(ast: &'a ast::ClassBracketed) -> ClassInduct<'a> {
+        ClassInduct::from_set(&ast.kind)
+    }
+
+    fn from_set(ast: &'a ast::ClassSet) -> ClassInduct<'a> {
+        match *ast {
+            ast::ClassSet::Item(ref item) => ClassInduct::Item(item),
+            ast::ClassSet::BinaryOp(ref op) => ClassInduct::BinaryOp(op),
+        }
+    }
+}
+
+impl<'a> fmt::Debug for ClassFrame<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let x = match *self {
+            ClassFrame::Union { .. } => "Union",
+            ClassFrame::Binary { .. } => "Binary",
+            ClassFrame::BinaryLHS { .. } => "BinaryLHS",
+            ClassFrame::BinaryRHS { .. } => "BinaryRHS",
+        };
+        write!(f, "{}", x)
+    }
+}
+
+impl<'a> fmt::Debug for ClassInduct<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let x = match *self {
+            ClassInduct::Item(it) => match *it {
+                ast::ClassSetItem::Empty(_) => "Item(Empty)",
+                ast::ClassSetItem::Literal(_) => "Item(Literal)",
+                ast::ClassSetItem::Range(_) => "Item(Range)",
+                ast::ClassSetItem::Ascii(_) => "Item(Ascii)",
+                ast::ClassSetItem::Perl(_) => "Item(Perl)",
+                ast::ClassSetItem::Unicode(_) => "Item(Unicode)",
+                ast::ClassSetItem::Bracketed(_) => "Item(Bracketed)",
+                ast::ClassSetItem::Union(_) => "Item(Union)",
+            },
+            ClassInduct::BinaryOp(it) => match it.kind {
+                ast::ClassSetBinaryOpKind::Intersection => {
+                    "BinaryOp(Intersection)"
+                }
+                ast::ClassSetBinaryOpKind::Difference => {
+                    "BinaryOp(Difference)"
+                }
+                ast::ClassSetBinaryOpKind::SymmetricDifference => {
+                    "BinaryOp(SymmetricDifference)"
+                }
+            },
+        };
+        write!(f, "{}", x)
+    }
+}
diff --git a/crates/regex-syntax/src/either.rs b/crates/regex-syntax/src/either.rs
new file mode 100644
index 0000000..7ae41e4
--- /dev/null
+++ b/crates/regex-syntax/src/either.rs
@@ -0,0 +1,8 @@
+/// A simple binary sum type.
+///
+/// This is occasionally useful in an ad hoc fashion.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum Either<Left, Right> {
+    Left(Left),
+    Right(Right),
+}
diff --git a/crates/regex-syntax/src/error.rs b/crates/regex-syntax/src/error.rs
new file mode 100644
index 0000000..1230d2f
--- /dev/null
+++ b/crates/regex-syntax/src/error.rs
@@ -0,0 +1,324 @@
+use std::cmp;
+use std::error;
+use std::fmt;
+use std::result;
+
+use crate::ast;
+use crate::hir;
+
+/// A type alias for dealing with errors returned by this crate.
+pub type Result<T> = result::Result<T, Error>;
+
+/// This error type encompasses any error that can be returned by this crate.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum Error {
+    /// An error that occurred while translating concrete syntax into abstract
+    /// syntax (AST).
+    Parse(ast::Error),
+    /// An error that occurred while translating abstract syntax into a high
+    /// level intermediate representation (HIR).
+    Translate(hir::Error),
+    /// Hints that destructuring should not be exhaustive.
+    ///
+    /// This enum may grow additional variants, so this makes sure clients
+    /// don't count on exhaustive matching. (Otherwise, adding a new variant
+    /// could break existing code.)
+    #[doc(hidden)]
+    __Nonexhaustive,
+}
+
+impl From<ast::Error> for Error {
+    fn from(err: ast::Error) -> Error {
+        Error::Parse(err)
+    }
+}
+
+impl From<hir::Error> for Error {
+    fn from(err: hir::Error) -> Error {
+        Error::Translate(err)
+    }
+}
+
+impl error::Error for Error {
+    // TODO: Remove this method entirely on the next breaking semver release.
+    #[allow(deprecated)]
+    fn description(&self) -> &str {
+        match *self {
+            Error::Parse(ref x) => x.description(),
+            Error::Translate(ref x) => x.description(),
+            _ => unreachable!(),
+        }
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            Error::Parse(ref x) => x.fmt(f),
+            Error::Translate(ref x) => x.fmt(f),
+            _ => unreachable!(),
+        }
+    }
+}
+
+/// A helper type for formatting nice error messages.
+///
+/// This type is responsible for reporting regex parse errors in a nice human
+/// readable format. Most of its complexity is from interspersing notational
+/// markers pointing out the position where an error occurred.
+#[derive(Debug)]
+pub struct Formatter<'e, E> {
+    /// The original regex pattern in which the error occurred.
+    pattern: &'e str,
+    /// The error kind. It must impl fmt::Display.
+    err: &'e E,
+    /// The primary span of the error.
+    span: &'e ast::Span,
+    /// An auxiliary and optional span, in case the error needs to point to
+    /// two locations (e.g., when reporting a duplicate capture group name).
+    aux_span: Option<&'e ast::Span>,
+}
+
+impl<'e> From<&'e ast::Error> for Formatter<'e, ast::ErrorKind> {
+    fn from(err: &'e ast::Error) -> Self {
+        Formatter {
+            pattern: err.pattern(),
+            err: err.kind(),
+            span: err.span(),
+            aux_span: err.auxiliary_span(),
+        }
+    }
+}
+
+impl<'e> From<&'e hir::Error> for Formatter<'e, hir::ErrorKind> {
+    fn from(err: &'e hir::Error) -> Self {
+        Formatter {
+            pattern: err.pattern(),
+            err: err.kind(),
+            span: err.span(),
+            aux_span: None,
+        }
+    }
+}
+
+impl<'e, E: fmt::Display> fmt::Display for Formatter<'e, E> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let spans = Spans::from_formatter(self);
+        if self.pattern.contains('\n') {
+            let divider = repeat_char('~', 79);
+
+            writeln!(f, "regex parse error:")?;
+            writeln!(f, "{}", divider)?;
+            let notated = spans.notate();
+            write!(f, "{}", notated)?;
+            writeln!(f, "{}", divider)?;
+            // If we have error spans that cover multiple lines, then we just
+            // note the line numbers.
+            if !spans.multi_line.is_empty() {
+                let mut notes = vec![];
+                for span in &spans.multi_line {
+                    notes.push(format!(
+                        "on line {} (column {}) through line {} (column {})",
+                        span.start.line,
+                        span.start.column,
+                        span.end.line,
+                        span.end.column - 1
+                    ));
+                }
+                writeln!(f, "{}", notes.join("\n"))?;
+            }
+            write!(f, "error: {}", self.err)?;
+        } else {
+            writeln!(f, "regex parse error:")?;
+            let notated = Spans::from_formatter(self).notate();
+            write!(f, "{}", notated)?;
+            write!(f, "error: {}", self.err)?;
+        }
+        Ok(())
+    }
+}
+
+/// This type represents an arbitrary number of error spans in a way that makes
+/// it convenient to notate the regex pattern. ("Notate" means "point out
+/// exactly where the error occurred in the regex pattern.")
+///
+/// Technically, we can only ever have two spans given our current error
+/// structure. However, after toiling with a specific algorithm for handling
+/// two spans, it became obvious that an algorithm to handle an arbitrary
+/// number of spans was actually much simpler.
+struct Spans<'p> {
+    /// The original regex pattern string.
+    pattern: &'p str,
+    /// The total width that should be used for line numbers. The width is
+    /// used for left padding the line numbers for alignment.
+    ///
+    /// A value of `0` means line numbers should not be displayed. That is,
+    /// the pattern is itself only one line.
+    line_number_width: usize,
+    /// All error spans that occur on a single line. This sequence always has
+    /// length equivalent to the number of lines in `pattern`, where the index
+    /// of the sequence represents a line number, starting at `0`. The spans
+    /// in each line are sorted in ascending order.
+    by_line: Vec<Vec<ast::Span>>,
+    /// All error spans that occur over one or more lines. That is, the start
+    /// and end position of the span have different line numbers. The spans are
+    /// sorted in ascending order.
+    multi_line: Vec<ast::Span>,
+}
+
+impl<'p> Spans<'p> {
+    /// Build a sequence of spans from a formatter.
+    fn from_formatter<'e, E: fmt::Display>(
+        fmter: &'p Formatter<'e, E>,
+    ) -> Spans<'p> {
+        let mut line_count = fmter.pattern.lines().count();
+        // If the pattern ends with a `\n` literal, then our line count is
+        // off by one, since a span can occur immediately after the last `\n`,
+        // which is consider to be an additional line.
+        if fmter.pattern.ends_with('\n') {
+            line_count += 1;
+        }
+        let line_number_width =
+            if line_count <= 1 { 0 } else { line_count.to_string().len() };
+        let mut spans = Spans {
+            pattern: &fmter.pattern,
+            line_number_width,
+            by_line: vec![vec![]; line_count],
+            multi_line: vec![],
+        };
+        spans.add(fmter.span.clone());
+        if let Some(span) = fmter.aux_span {
+            spans.add(span.clone());
+        }
+        spans
+    }
+
+    /// Add the given span to this sequence, putting it in the right place.
+    fn add(&mut self, span: ast::Span) {
+        // This is grossly inefficient since we sort after each add, but right
+        // now, we only ever add two spans at most.
+        if span.is_one_line() {
+            let i = span.start.line - 1; // because lines are 1-indexed
+            self.by_line[i].push(span);
+            self.by_line[i].sort();
+        } else {
+            self.multi_line.push(span);
+            self.multi_line.sort();
+        }
+    }
+
+    /// Notate the pattern string with carents (`^`) pointing at each span
+    /// location. This only applies to spans that occur within a single line.
+    fn notate(&self) -> String {
+        let mut notated = String::new();
+        for (i, line) in self.pattern.lines().enumerate() {
+            if self.line_number_width > 0 {
+                notated.push_str(&self.left_pad_line_number(i + 1));
+                notated.push_str(": ");
+            } else {
+                notated.push_str("    ");
+            }
+            notated.push_str(line);
+            notated.push('\n');
+            if let Some(notes) = self.notate_line(i) {
+                notated.push_str(&notes);
+                notated.push('\n');
+            }
+        }
+        notated
+    }
+
+    /// Return notes for the line indexed at `i` (zero-based). If there are no
+    /// spans for the given line, then `None` is returned. Otherwise, an
+    /// appropriately space padded string with correctly positioned `^` is
+    /// returned, accounting for line numbers.
+    fn notate_line(&self, i: usize) -> Option<String> {
+        let spans = &self.by_line[i];
+        if spans.is_empty() {
+            return None;
+        }
+        let mut notes = String::new();
+        for _ in 0..self.line_number_padding() {
+            notes.push(' ');
+        }
+        let mut pos = 0;
+        for span in spans {
+            for _ in pos..(span.start.column - 1) {
+                notes.push(' ');
+                pos += 1;
+            }
+            let note_len = span.end.column.saturating_sub(span.start.column);
+            for _ in 0..cmp::max(1, note_len) {
+                notes.push('^');
+                pos += 1;
+            }
+        }
+        Some(notes)
+    }
+
+    /// Left pad the given line number with spaces such that it is aligned with
+    /// other line numbers.
+    fn left_pad_line_number(&self, n: usize) -> String {
+        let n = n.to_string();
+        let pad = self.line_number_width.checked_sub(n.len()).unwrap();
+        let mut result = repeat_char(' ', pad);
+        result.push_str(&n);
+        result
+    }
+
+    /// Return the line number padding beginning at the start of each line of
+    /// the pattern.
+    ///
+    /// If the pattern is only one line, then this returns a fixed padding
+    /// for visual indentation.
+    fn line_number_padding(&self) -> usize {
+        if self.line_number_width == 0 {
+            4
+        } else {
+            2 + self.line_number_width
+        }
+    }
+}
+
+fn repeat_char(c: char, count: usize) -> String {
+    ::std::iter::repeat(c).take(count).collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::ast::parse::Parser;
+
+    fn assert_panic_message(pattern: &str, expected_msg: &str) {
+        let result = Parser::new().parse(pattern);
+        match result {
+            Ok(_) => {
+                panic!("regex should not have parsed");
+            }
+            Err(err) => {
+                assert_eq!(err.to_string(), expected_msg.trim());
+            }
+        }
+    }
+
+    // See: https://github.com/rust-lang/regex/issues/464
+    #[test]
+    fn regression_464() {
+        let err = Parser::new().parse("a{\n").unwrap_err();
+        // This test checks that the error formatter doesn't panic.
+        assert!(!err.to_string().is_empty());
+    }
+
+    // See: https://github.com/rust-lang/regex/issues/545
+    #[test]
+    fn repetition_quantifier_expects_a_valid_decimal() {
+        assert_panic_message(
+            r"\\u{[^}]*}",
+            r#"
+regex parse error:
+    \\u{[^}]*}
+        ^
+error: repetition quantifier expects a valid decimal
+"#,
+        );
+    }
+}
diff --git a/crates/regex-syntax/src/hir/interval.rs b/crates/regex-syntax/src/hir/interval.rs
new file mode 100644
index 0000000..56698c5
--- /dev/null
+++ b/crates/regex-syntax/src/hir/interval.rs
@@ -0,0 +1,520 @@
+use std::char;
+use std::cmp;
+use std::fmt::Debug;
+use std::slice;
+use std::u8;
+
+use crate::unicode;
+
+// This module contains an *internal* implementation of interval sets.
+//
+// The primary invariant that interval sets guards is canonical ordering. That
+// is, every interval set contains an ordered sequence of intervals where
+// no two intervals are overlapping or adjacent. While this invariant is
+// occasionally broken within the implementation, it should be impossible for
+// callers to observe it.
+//
+// Since case folding (as implemented below) breaks that invariant, we roll
+// that into this API even though it is a little out of place in an otherwise
+// generic interval set. (Hence the reason why the `unicode` module is imported
+// here.)
+//
+// Some of the implementation complexity here is a result of me wanting to
+// preserve the sequential representation without using additional memory.
+// In many cases, we do use linear extra memory, but it is at most 2x and it
+// is amortized. If we relaxed the memory requirements, this implementation
+// could become much simpler. The extra memory is honestly probably OK, but
+// character classes (especially of the Unicode variety) can become quite
+// large, and it would be nice to keep regex compilation snappy even in debug
+// builds. (In the past, I have been careless with this area of code and it has
+// caused slow regex compilations in debug mode, so this isn't entirely
+// unwarranted.)
+//
+// Tests on this are relegated to the public API of HIR in src/hir.rs.
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct IntervalSet<I> {
+    ranges: Vec<I>,
+}
+
+impl<I: Interval> IntervalSet<I> {
+    /// Create a new set from a sequence of intervals. Each interval is
+    /// specified as a pair of bounds, where both bounds are inclusive.
+    ///
+    /// The given ranges do not need to be in any specific order, and ranges
+    /// may overlap.
+    pub fn new<T: IntoIterator<Item = I>>(intervals: T) -> IntervalSet<I> {
+        let mut set = IntervalSet { ranges: intervals.into_iter().collect() };
+        set.canonicalize();
+        set
+    }
+
+    /// Add a new interval to this set.
+    pub fn push(&mut self, interval: I) {
+        // TODO: This could be faster. e.g., Push the interval such that
+        // it preserves canonicalization.
+        self.ranges.push(interval);
+        self.canonicalize();
+    }
+
+    /// Return an iterator over all intervals in this set.
+    ///
+    /// The iterator yields intervals in ascending order.
+    pub fn iter(&self) -> IntervalSetIter<'_, I> {
+        IntervalSetIter(self.ranges.iter())
+    }
+
+    /// Return an immutable slice of intervals in this set.
+    ///
+    /// The sequence returned is in canonical ordering.
+    pub fn intervals(&self) -> &[I] {
+        &self.ranges
+    }
+
+    /// Expand this interval set such that it contains all case folded
+    /// characters. For example, if this class consists of the range `a-z`,
+    /// then applying case folding will result in the class containing both the
+    /// ranges `a-z` and `A-Z`.
+    ///
+    /// This returns an error if the necessary case mapping data is not
+    /// available.
+    pub fn case_fold_simple(&mut self) -> Result<(), unicode::CaseFoldError> {
+        let len = self.ranges.len();
+        for i in 0..len {
+            let range = self.ranges[i];
+            if let Err(err) = range.case_fold_simple(&mut self.ranges) {
+                self.canonicalize();
+                return Err(err);
+            }
+        }
+        self.canonicalize();
+        Ok(())
+    }
+
+    /// Union this set with the given set, in place.
+    pub fn union(&mut self, other: &IntervalSet<I>) {
+        // This could almost certainly be done more efficiently.
+        self.ranges.extend(&other.ranges);
+        self.canonicalize();
+    }
+
+    /// Intersect this set with the given set, in place.
+    pub fn intersect(&mut self, other: &IntervalSet<I>) {
+        if self.ranges.is_empty() {
+            return;
+        }
+        if other.ranges.is_empty() {
+            self.ranges.clear();
+            return;
+        }
+
+        // There should be a way to do this in-place with constant memory,
+        // but I couldn't figure out a simple way to do it. So just append
+        // the intersection to the end of this range, and then drain it before
+        // we're done.
+        let drain_end = self.ranges.len();
+
+        let mut ita = 0..drain_end;
+        let mut itb = 0..other.ranges.len();
+        let mut a = ita.next().unwrap();
+        let mut b = itb.next().unwrap();
+        loop {
+            if let Some(ab) = self.ranges[a].intersect(&other.ranges[b]) {
+                self.ranges.push(ab);
+            }
+            let (it, aorb) =
+                if self.ranges[a].upper() < other.ranges[b].upper() {
+                    (&mut ita, &mut a)
+                } else {
+                    (&mut itb, &mut b)
+                };
+            match it.next() {
+                Some(v) => *aorb = v,
+                None => break,
+            }
+        }
+        self.ranges.drain(..drain_end);
+    }
+
+    /// Subtract the given set from this set, in place.
+    pub fn difference(&mut self, other: &IntervalSet<I>) {
+        if self.ranges.is_empty() || other.ranges.is_empty() {
+            return;
+        }
+
+        // This algorithm is (to me) surprisingly complex. A search of the
+        // interwebs indicate that this is a potentially interesting problem.
+        // Folks seem to suggest interval or segment trees, but I'd like to
+        // avoid the overhead (both runtime and conceptual) of that.
+        //
+        // The following is basically my Shitty First Draft. Therefore, in
+        // order to grok it, you probably need to read each line carefully.
+        // Simplifications are most welcome!
+        //
+        // Remember, we can assume the canonical format invariant here, which
+        // says that all ranges are sorted, not overlapping and not adjacent in
+        // each class.
+        let drain_end = self.ranges.len();
+        let (mut a, mut b) = (0, 0);
+        'LOOP: while a < drain_end && b < other.ranges.len() {
+            // Basically, the easy cases are when neither range overlaps with
+            // each other. If the `b` range is less than our current `a`
+            // range, then we can skip it and move on.
+            if other.ranges[b].upper() < self.ranges[a].lower() {
+                b += 1;
+                continue;
+            }
+            // ... similarly for the `a` range. If it's less than the smallest
+            // `b` range, then we can add it as-is.
+            if self.ranges[a].upper() < other.ranges[b].lower() {
+                let range = self.ranges[a];
+                self.ranges.push(range);
+                a += 1;
+                continue;
+            }
+            // Otherwise, we have overlapping ranges.
+            assert!(!self.ranges[a].is_intersection_empty(&other.ranges[b]));
+
+            // This part is tricky and was non-obvious to me without looking
+            // at explicit examples (see the tests). The trickiness stems from
+            // two things: 1) subtracting a range from another range could
+            // yield two ranges and 2) after subtracting a range, it's possible
+            // that future ranges can have an impact. The loop below advances
+            // the `b` ranges until they can't possible impact the current
+            // range.
+            //
+            // For example, if our `a` range is `a-t` and our next three `b`
+            // ranges are `a-c`, `g-i`, `r-t` and `x-z`, then we need to apply
+            // subtraction three times before moving on to the next `a` range.
+            let mut range = self.ranges[a];
+            while b < other.ranges.len()
+                && !range.is_intersection_empty(&other.ranges[b])
+            {
+                let old_range = range;
+                range = match range.difference(&other.ranges[b]) {
+                    (None, None) => {
+                        // We lost the entire range, so move on to the next
+                        // without adding this one.
+                        a += 1;
+                        continue 'LOOP;
+                    }
+                    (Some(range1), None) | (None, Some(range1)) => range1,
+                    (Some(range1), Some(range2)) => {
+                        self.ranges.push(range1);
+                        range2
+                    }
+                };
+                // It's possible that the `b` range has more to contribute
+                // here. In particular, if it is greater than the original
+                // range, then it might impact the next `a` range *and* it
+                // has impacted the current `a` range as much as possible,
+                // so we can quit. We don't bump `b` so that the next `a`
+                // range can apply it.
+                if other.ranges[b].upper() > old_range.upper() {
+                    break;
+                }
+                // Otherwise, the next `b` range might apply to the current
+                // `a` range.
+                b += 1;
+            }
+            self.ranges.push(range);
+            a += 1;
+        }
+        while a < drain_end {
+            let range = self.ranges[a];
+            self.ranges.push(range);
+            a += 1;
+        }
+        self.ranges.drain(..drain_end);
+    }
+
+    /// Compute the symmetric difference of the two sets, in place.
+    ///
+    /// This computes the symmetric difference of two interval sets. This
+    /// removes all elements in this set that are also in the given set,
+    /// but also adds all elements from the given set that aren't in this
+    /// set. That is, the set will contain all elements in either set,
+    /// but will not contain any elements that are in both sets.
+    pub fn symmetric_difference(&mut self, other: &IntervalSet<I>) {
+        // TODO(burntsushi): Fix this so that it amortizes allocation.
+        let mut intersection = self.clone();
+        intersection.intersect(other);
+        self.union(other);
+        self.difference(&intersection);
+    }
+
+    /// Negate this interval set.
+    ///
+    /// For all `x` where `x` is any element, if `x` was in this set, then it
+    /// will not be in this set after negation.
+    pub fn negate(&mut self) {
+        if self.ranges.is_empty() {
+            let (min, max) = (I::Bound::min_value(), I::Bound::max_value());
+            self.ranges.push(I::create(min, max));
+            return;
+        }
+
+        // There should be a way to do this in-place with constant memory,
+        // but I couldn't figure out a simple way to do it. So just append
+        // the negation to the end of this range, and then drain it before
+        // we're done.
+        let drain_end = self.ranges.len();
+
+        // We do checked arithmetic below because of the canonical ordering
+        // invariant.
+        if self.ranges[0].lower() > I::Bound::min_value() {
+            let upper = self.ranges[0].lower().decrement();
+            self.ranges.push(I::create(I::Bound::min_value(), upper));
+        }
+        for i in 1..drain_end {
+            let lower = self.ranges[i - 1].upper().increment();
+            let upper = self.ranges[i].lower().decrement();
+            self.ranges.push(I::create(lower, upper));
+        }
+        if self.ranges[drain_end - 1].upper() < I::Bound::max_value() {
+            let lower = self.ranges[drain_end - 1].upper().increment();
+            self.ranges.push(I::create(lower, I::Bound::max_value()));
+        }
+        self.ranges.drain(..drain_end);
+    }
+
+    /// Converts this set into a canonical ordering.
+    fn canonicalize(&mut self) {
+        if self.is_canonical() {
+            return;
+        }
+        self.ranges.sort();
+        assert!(!self.ranges.is_empty());
+
+        // Is there a way to do this in-place with constant memory? I couldn't
+        // figure out a way to do it. So just append the canonicalization to
+        // the end of this range, and then drain it before we're done.
+        let drain_end = self.ranges.len();
+        for oldi in 0..drain_end {
+            // If we've added at least one new range, then check if we can
+            // merge this range in the previously added range.
+            if self.ranges.len() > drain_end {
+                let (last, rest) = self.ranges.split_last_mut().unwrap();
+                if let Some(union) = last.union(&rest[oldi]) {
+                    *last = union;
+                    continue;
+                }
+            }
+            let range = self.ranges[oldi];
+            self.ranges.push(range);
+        }
+        self.ranges.drain(..drain_end);
+    }
+
+    /// Returns true if and only if this class is in a canonical ordering.
+    fn is_canonical(&self) -> bool {
+        for pair in self.ranges.windows(2) {
+            if pair[0] >= pair[1] {
+                return false;
+            }
+            if pair[0].is_contiguous(&pair[1]) {
+                return false;
+            }
+        }
+        true
+    }
+}
+
+/// An iterator over intervals.
+#[derive(Debug)]
+pub struct IntervalSetIter<'a, I>(slice::Iter<'a, I>);
+
+impl<'a, I> Iterator for IntervalSetIter<'a, I> {
+    type Item = &'a I;
+
+    fn next(&mut self) -> Option<&'a I> {
+        self.0.next()
+    }
+}
+
+pub trait Interval:
+    Clone + Copy + Debug + Default + Eq + PartialEq + PartialOrd + Ord
+{
+    type Bound: Bound;
+
+    fn lower(&self) -> Self::Bound;
+    fn upper(&self) -> Self::Bound;
+    fn set_lower(&mut self, bound: Self::Bound);
+    fn set_upper(&mut self, bound: Self::Bound);
+    fn case_fold_simple(
+        &self,
+        intervals: &mut Vec<Self>,
+    ) -> Result<(), unicode::CaseFoldError>;
+
+    /// Create a new interval.
+    fn create(lower: Self::Bound, upper: Self::Bound) -> Self {
+        let mut int = Self::default();
+        if lower <= upper {
+            int.set_lower(lower);
+            int.set_upper(upper);
+        } else {
+            int.set_lower(upper);
+            int.set_upper(lower);
+        }
+        int
+    }
+
+    /// Union the given overlapping range into this range.
+    ///
+    /// If the two ranges aren't contiguous, then this returns `None`.
+    fn union(&self, other: &Self) -> Option<Self> {
+        if !self.is_contiguous(other) {
+            return None;
+        }
+        let lower = cmp::min(self.lower(), other.lower());
+        let upper = cmp::max(self.upper(), other.upper());
+        Some(Self::create(lower, upper))
+    }
+
+    /// Intersect this range with the given range and return the result.
+    ///
+    /// If the intersection is empty, then this returns `None`.
+    fn intersect(&self, other: &Self) -> Option<Self> {
+        let lower = cmp::max(self.lower(), other.lower());
+        let upper = cmp::min(self.upper(), other.upper());
+        if lower <= upper {
+            Some(Self::create(lower, upper))
+        } else {
+            None
+        }
+    }
+
+    /// Subtract the given range from this range and return the resulting
+    /// ranges.
+    ///
+    /// If subtraction would result in an empty range, then no ranges are
+    /// returned.
+    fn difference(&self, other: &Self) -> (Option<Self>, Option<Self>) {
+        if self.is_subset(other) {
+            return (None, None);
+        }
+        if self.is_intersection_empty(other) {
+            return (Some(self.clone()), None);
+        }
+        let add_lower = other.lower() > self.lower();
+        let add_upper = other.upper() < self.upper();
+        // We know this because !self.is_subset(other) and the ranges have
+        // a non-empty intersection.
+        assert!(add_lower || add_upper);
+        let mut ret = (None, None);
+        if add_lower {
+            let upper = other.lower().decrement();
+            ret.0 = Some(Self::create(self.lower(), upper));
+        }
+        if add_upper {
+            let lower = other.upper().increment();
+            let range = Self::create(lower, self.upper());
+            if ret.0.is_none() {
+                ret.0 = Some(range);
+            } else {
+                ret.1 = Some(range);
+            }
+        }
+        ret
+    }
+
+    /// Compute the symmetric difference the given range from this range. This
+    /// returns the union of the two ranges minus its intersection.
+    fn symmetric_difference(
+        &self,
+        other: &Self,
+    ) -> (Option<Self>, Option<Self>) {
+        let union = match self.union(other) {
+            None => return (Some(self.clone()), Some(other.clone())),
+            Some(union) => union,
+        };
+        let intersection = match self.intersect(other) {
+            None => return (Some(self.clone()), Some(other.clone())),
+            Some(intersection) => intersection,
+        };
+        union.difference(&intersection)
+    }
+
+    /// Returns true if and only if the two ranges are contiguous. Two ranges
+    /// are contiguous if and only if the ranges are either overlapping or
+    /// adjacent.
+    fn is_contiguous(&self, other: &Self) -> bool {
+        let lower1 = self.lower().as_u32();
+        let upper1 = self.upper().as_u32();
+        let lower2 = other.lower().as_u32();
+        let upper2 = other.upper().as_u32();
+        cmp::max(lower1, lower2) <= cmp::min(upper1, upper2).saturating_add(1)
+    }
+
+    /// Returns true if and only if the intersection of this range and the
+    /// other range is empty.
+    fn is_intersection_empty(&self, other: &Self) -> bool {
+        let (lower1, upper1) = (self.lower(), self.upper());
+        let (lower2, upper2) = (other.lower(), other.upper());
+        cmp::max(lower1, lower2) > cmp::min(upper1, upper2)
+    }
+
+    /// Returns true if and only if this range is a subset of the other range.
+    fn is_subset(&self, other: &Self) -> bool {
+        let (lower1, upper1) = (self.lower(), self.upper());
+        let (lower2, upper2) = (other.lower(), other.upper());
+        (lower2 <= lower1 && lower1 <= upper2)
+            && (lower2 <= upper1 && upper1 <= upper2)
+    }
+}
+
+pub trait Bound:
+    Copy + Clone + Debug + Eq + PartialEq + PartialOrd + Ord
+{
+    fn min_value() -> Self;
+    fn max_value() -> Self;
+    fn as_u32(self) -> u32;
+    fn increment(self) -> Self;
+    fn decrement(self) -> Self;
+}
+
+impl Bound for u8 {
+    fn min_value() -> Self {
+        u8::MIN
+    }
+    fn max_value() -> Self {
+        u8::MAX
+    }
+    fn as_u32(self) -> u32 {
+        self as u32
+    }
+    fn increment(self) -> Self {
+        self.checked_add(1).unwrap()
+    }
+    fn decrement(self) -> Self {
+        self.checked_sub(1).unwrap()
+    }
+}
+
+impl Bound for char {
+    fn min_value() -> Self {
+        '\x00'
+    }
+    fn max_value() -> Self {
+        '\u{10FFFF}'
+    }
+    fn as_u32(self) -> u32 {
+        self as u32
+    }
+
+    fn increment(self) -> Self {
+        match self {
+            '\u{D7FF}' => '\u{E000}',
+            c => char::from_u32((c as u32).checked_add(1).unwrap()).unwrap(),
+        }
+    }
+
+    fn decrement(self) -> Self {
+        match self {
+            '\u{E000}' => '\u{D7FF}',
+            c => char::from_u32((c as u32).checked_sub(1).unwrap()).unwrap(),
+        }
+    }
+}
+
+// Tests for interval sets are written in src/hir.rs against the public API.
diff --git a/crates/regex-syntax/src/hir/literal/mod.rs b/crates/regex-syntax/src/hir/literal/mod.rs
new file mode 100644
index 0000000..fbc5d3c
--- /dev/null
+++ b/crates/regex-syntax/src/hir/literal/mod.rs
@@ -0,0 +1,1686 @@
+/*!
+Provides routines for extracting literal prefixes and suffixes from an `Hir`.
+*/
+
+use std::cmp;
+use std::fmt;
+use std::iter;
+use std::mem;
+use std::ops;
+
+use crate::hir::{self, Hir, HirKind};
+
+/// A set of literal byte strings extracted from a regular expression.
+///
+/// Every member of the set is a `Literal`, which is represented by a
+/// `Vec<u8>`. (Notably, it may contain invalid UTF-8.) Every member is
+/// said to be either *complete* or *cut*. A complete literal means that
+/// it extends until the beginning (or end) of the regular expression. In
+/// some circumstances, this can be used to indicate a match in the regular
+/// expression.
+///
+/// A key aspect of literal extraction is knowing when to stop. It is not
+/// feasible to blindly extract all literals from a regular expression, even if
+/// there are finitely many. For example, the regular expression `[0-9]{10}`
+/// has `10^10` distinct literals. For this reason, literal extraction is
+/// bounded to some low number by default using heuristics, but the limits can
+/// be tweaked.
+///
+/// **WARNING**: Literal extraction uses stack space proportional to the size
+/// of the `Hir` expression. At some point, this drawback will be eliminated.
+/// To protect yourself, set a reasonable
+/// [`nest_limit` on your `Parser`](../../struct.ParserBuilder.html#method.nest_limit).
+/// This is done for you by default.
+#[derive(Clone, Eq, PartialEq)]
+pub struct Literals {
+    lits: Vec<Literal>,
+    limit_size: usize,
+    limit_class: usize,
+}
+
+/// A single member of a set of literals extracted from a regular expression.
+///
+/// This type has `Deref` and `DerefMut` impls to `Vec<u8>` so that all slice
+/// and `Vec` operations are available.
+#[derive(Clone, Eq, Ord)]
+pub struct Literal {
+    v: Vec<u8>,
+    cut: bool,
+}
+
+impl Literals {
+    /// Returns a new empty set of literals using default limits.
+    pub fn empty() -> Literals {
+        Literals { lits: vec![], limit_size: 250, limit_class: 10 }
+    }
+
+    /// Returns a set of literal prefixes extracted from the given `Hir`.
+    pub fn prefixes(expr: &Hir) -> Literals {
+        let mut lits = Literals::empty();
+        lits.union_prefixes(expr);
+        lits
+    }
+
+    /// Returns a set of literal suffixes extracted from the given `Hir`.
+    pub fn suffixes(expr: &Hir) -> Literals {
+        let mut lits = Literals::empty();
+        lits.union_suffixes(expr);
+        lits
+    }
+
+    /// Get the approximate size limit (in bytes) of this set.
+    pub fn limit_size(&self) -> usize {
+        self.limit_size
+    }
+
+    /// Set the approximate size limit (in bytes) of this set.
+    ///
+    /// If extracting a literal would put the set over this limit, then
+    /// extraction stops.
+    ///
+    /// The new limits will only apply to additions to this set. Existing
+    /// members remain unchanged, even if the set exceeds the new limit.
+    pub fn set_limit_size(&mut self, size: usize) -> &mut Literals {
+        self.limit_size = size;
+        self
+    }
+
+    /// Get the character class size limit for this set.
+    pub fn limit_class(&self) -> usize {
+        self.limit_class
+    }
+
+    /// Limits the size of character(or byte) classes considered.
+    ///
+    /// A value of `0` prevents all character classes from being considered.
+    ///
+    /// This limit also applies to case insensitive literals, since each
+    /// character in the case insensitive literal is converted to a class, and
+    /// then case folded.
+    ///
+    /// The new limits will only apply to additions to this set. Existing
+    /// members remain unchanged, even if the set exceeds the new limit.
+    pub fn set_limit_class(&mut self, size: usize) -> &mut Literals {
+        self.limit_class = size;
+        self
+    }
+
+    /// Returns the set of literals as a slice. Its order is unspecified.
+    pub fn literals(&self) -> &[Literal] {
+        &self.lits
+    }
+
+    /// Returns the length of the smallest literal.
+    ///
+    /// Returns None is there are no literals in the set.
+    pub fn min_len(&self) -> Option<usize> {
+        let mut min = None;
+        for lit in &self.lits {
+            match min {
+                None => min = Some(lit.len()),
+                Some(m) if lit.len() < m => min = Some(lit.len()),
+                _ => {}
+            }
+        }
+        min
+    }
+
+    /// Returns true if all members in this set are complete.
+    pub fn all_complete(&self) -> bool {
+        !self.lits.is_empty() && self.lits.iter().all(|l| !l.is_cut())
+    }
+
+    /// Returns true if any member in this set is complete.
+    pub fn any_complete(&self) -> bool {
+        self.lits.iter().any(|lit| !lit.is_cut())
+    }
+
+    /// Returns true if this set contains an empty literal.
+    pub fn contains_empty(&self) -> bool {
+        self.lits.iter().any(|lit| lit.is_empty())
+    }
+
+    /// Returns true if this set is empty or if all of its members is empty.
+    pub fn is_empty(&self) -> bool {
+        self.lits.is_empty() || self.lits.iter().all(|lit| lit.is_empty())
+    }
+
+    /// Returns a new empty set of literals using this set's limits.
+    pub fn to_empty(&self) -> Literals {
+        let mut lits = Literals::empty();
+        lits.set_limit_size(self.limit_size).set_limit_class(self.limit_class);
+        lits
+    }
+
+    /// Returns the longest common prefix of all members in this set.
+    pub fn longest_common_prefix(&self) -> &[u8] {
+        if self.is_empty() {
+            return &[];
+        }
+        let lit0 = &*self.lits[0];
+        let mut len = lit0.len();
+        for lit in &self.lits[1..] {
+            len = cmp::min(
+                len,
+                lit.iter().zip(lit0).take_while(|&(a, b)| a == b).count(),
+            );
+        }
+        &self.lits[0][..len]
+    }
+
+    /// Returns the longest common suffix of all members in this set.
+    pub fn longest_common_suffix(&self) -> &[u8] {
+        if self.is_empty() {
+            return &[];
+        }
+        let lit0 = &*self.lits[0];
+        let mut len = lit0.len();
+        for lit in &self.lits[1..] {
+            len = cmp::min(
+                len,
+                lit.iter()
+                    .rev()
+                    .zip(lit0.iter().rev())
+                    .take_while(|&(a, b)| a == b)
+                    .count(),
+            );
+        }
+        &self.lits[0][self.lits[0].len() - len..]
+    }
+
+    /// Returns a new set of literals with the given number of bytes trimmed
+    /// from the suffix of each literal.
+    ///
+    /// If any literal would be cut out completely by trimming, then None is
+    /// returned.
+    ///
+    /// Any duplicates that are created as a result of this transformation are
+    /// removed.
+    pub fn trim_suffix(&self, num_bytes: usize) -> Option<Literals> {
+        if self.min_len().map(|len| len <= num_bytes).unwrap_or(true) {
+            return None;
+        }
+        let mut new = self.to_empty();
+        for mut lit in self.lits.iter().cloned() {
+            let new_len = lit.len() - num_bytes;
+            lit.truncate(new_len);
+            lit.cut();
+            new.lits.push(lit);
+        }
+        new.lits.sort();
+        new.lits.dedup();
+        Some(new)
+    }
+
+    /// Returns a new set of prefixes of this set of literals that are
+    /// guaranteed to be unambiguous.
+    ///
+    /// Any substring match with a member of the set is returned is guaranteed
+    /// to never overlap with a substring match of another member of the set
+    /// at the same starting position.
+    ///
+    /// Given any two members of the returned set, neither is a substring of
+    /// the other.
+    pub fn unambiguous_prefixes(&self) -> Literals {
+        if self.lits.is_empty() {
+            return self.to_empty();
+        }
+        let mut old = self.lits.to_vec();
+        let mut new = self.to_empty();
+        'OUTER: while let Some(mut candidate) = old.pop() {
+            if candidate.is_empty() {
+                continue;
+            }
+            if new.lits.is_empty() {
+                new.lits.push(candidate);
+                continue;
+            }
+            for lit2 in &mut new.lits {
+                if lit2.is_empty() {
+                    continue;
+                }
+                if &candidate == lit2 {
+                    // If the literal is already in the set, then we can
+                    // just drop it. But make sure that cut literals are
+                    // infectious!
+                    candidate.cut = candidate.cut || lit2.cut;
+                    lit2.cut = candidate.cut;
+                    continue 'OUTER;
+                }
+                if candidate.len() < lit2.len() {
+                    if let Some(i) = position(&candidate, &lit2) {
+                        candidate.cut();
+                        let mut lit3 = lit2.clone();
+                        lit3.truncate(i);
+                        lit3.cut();
+                        old.push(lit3);
+                        lit2.clear();
+                    }
+                } else if let Some(i) = position(&lit2, &candidate) {
+                    lit2.cut();
+                    let mut new_candidate = candidate.clone();
+                    new_candidate.truncate(i);
+                    new_candidate.cut();
+                    old.push(new_candidate);
+                    candidate.clear();
+                }
+                // Oops, the candidate is already represented in the set.
+                if candidate.is_empty() {
+                    continue 'OUTER;
+                }
+            }
+            new.lits.push(candidate);
+        }
+        new.lits.retain(|lit| !lit.is_empty());
+        new.lits.sort();
+        new.lits.dedup();
+        new
+    }
+
+    /// Returns a new set of suffixes of this set of literals that are
+    /// guaranteed to be unambiguous.
+    ///
+    /// Any substring match with a member of the set is returned is guaranteed
+    /// to never overlap with a substring match of another member of the set
+    /// at the same ending position.
+    ///
+    /// Given any two members of the returned set, neither is a substring of
+    /// the other.
+    pub fn unambiguous_suffixes(&self) -> Literals {
+        // This is a touch wasteful...
+        let mut lits = self.clone();
+        lits.reverse();
+        let mut unamb = lits.unambiguous_prefixes();
+        unamb.reverse();
+        unamb
+    }
+
+    /// Unions the prefixes from the given expression to this set.
+    ///
+    /// If prefixes could not be added (for example, this set would exceed its
+    /// size limits or the set of prefixes from `expr` includes the empty
+    /// string), then false is returned.
+    ///
+    /// Note that prefix literals extracted from `expr` are said to be complete
+    /// if and only if the literal extends from the beginning of `expr` to the
+    /// end of `expr`.
+    pub fn union_prefixes(&mut self, expr: &Hir) -> bool {
+        let mut lits = self.to_empty();
+        prefixes(expr, &mut lits);
+        !lits.is_empty() && !lits.contains_empty() && self.union(lits)
+    }
+
+    /// Unions the suffixes from the given expression to this set.
+    ///
+    /// If suffixes could not be added (for example, this set would exceed its
+    /// size limits or the set of suffixes from `expr` includes the empty
+    /// string), then false is returned.
+    ///
+    /// Note that prefix literals extracted from `expr` are said to be complete
+    /// if and only if the literal extends from the end of `expr` to the
+    /// beginning of `expr`.
+    pub fn union_suffixes(&mut self, expr: &Hir) -> bool {
+        let mut lits = self.to_empty();
+        suffixes(expr, &mut lits);
+        lits.reverse();
+        !lits.is_empty() && !lits.contains_empty() && self.union(lits)
+    }
+
+    /// Unions this set with another set.
+    ///
+    /// If the union would cause the set to exceed its limits, then the union
+    /// is skipped and it returns false. Otherwise, if the union succeeds, it
+    /// returns true.
+    pub fn union(&mut self, lits: Literals) -> bool {
+        if self.num_bytes() + lits.num_bytes() > self.limit_size {
+            return false;
+        }
+        if lits.is_empty() {
+            self.lits.push(Literal::empty());
+        } else {
+            self.lits.extend(lits.lits);
+        }
+        true
+    }
+
+    /// Extends this set with another set.
+    ///
+    /// The set of literals is extended via a cross product.
+    ///
+    /// If a cross product would cause this set to exceed its limits, then the
+    /// cross product is skipped and it returns false. Otherwise, if the cross
+    /// product succeeds, it returns true.
+    pub fn cross_product(&mut self, lits: &Literals) -> bool {
+        if lits.is_empty() {
+            return true;
+        }
+        // Check that we make sure we stay in our limits.
+        let mut size_after;
+        if self.is_empty() || !self.any_complete() {
+            size_after = self.num_bytes();
+            for lits_lit in lits.literals() {
+                size_after += lits_lit.len();
+            }
+        } else {
+            size_after = self.lits.iter().fold(0, |accum, lit| {
+                accum + if lit.is_cut() { lit.len() } else { 0 }
+            });
+            for lits_lit in lits.literals() {
+                for self_lit in self.literals() {
+                    if !self_lit.is_cut() {
+                        size_after += self_lit.len() + lits_lit.len();
+                    }
+                }
+            }
+        }
+        if size_after > self.limit_size {
+            return false;
+        }
+
+        let mut base = self.remove_complete();
+        if base.is_empty() {
+            base = vec![Literal::empty()];
+        }
+        for lits_lit in lits.literals() {
+            for mut self_lit in base.clone() {
+                self_lit.extend(&**lits_lit);
+                self_lit.cut = lits_lit.cut;
+                self.lits.push(self_lit);
+            }
+        }
+        true
+    }
+
+    /// Extends each literal in this set with the bytes given.
+    ///
+    /// If the set is empty, then the given literal is added to the set.
+    ///
+    /// If adding any number of bytes to all members of this set causes a limit
+    /// to be exceeded, then no bytes are added and false is returned. If a
+    /// prefix of `bytes` can be fit into this set, then it is used and all
+    /// resulting literals are cut.
+    pub fn cross_add(&mut self, bytes: &[u8]) -> bool {
+        // N.B. This could be implemented by simply calling cross_product with
+        // a literal set containing just `bytes`, but we can be smarter about
+        // taking shorter prefixes of `bytes` if they'll fit.
+        if bytes.is_empty() {
+            return true;
+        }
+        if self.lits.is_empty() {
+            let i = cmp::min(self.limit_size, bytes.len());
+            self.lits.push(Literal::new(bytes[..i].to_owned()));
+            self.lits[0].cut = i < bytes.len();
+            return !self.lits[0].is_cut();
+        }
+        let size = self.num_bytes();
+        if size + self.lits.len() >= self.limit_size {
+            return false;
+        }
+        let mut i = 1;
+        while size + (i * self.lits.len()) <= self.limit_size
+            && i < bytes.len()
+        {
+            i += 1;
+        }
+        for lit in &mut self.lits {
+            if !lit.is_cut() {
+                lit.extend(&bytes[..i]);
+                if i < bytes.len() {
+                    lit.cut();
+                }
+            }
+        }
+        true
+    }
+
+    /// Adds the given literal to this set.
+    ///
+    /// Returns false if adding this literal would cause the class to be too
+    /// big.
+    pub fn add(&mut self, lit: Literal) -> bool {
+        if self.num_bytes() + lit.len() > self.limit_size {
+            return false;
+        }
+        self.lits.push(lit);
+        true
+    }
+
+    /// Extends each literal in this set with the character class given.
+    ///
+    /// Returns false if the character class was too big to add.
+    pub fn add_char_class(&mut self, cls: &hir::ClassUnicode) -> bool {
+        self._add_char_class(cls, false)
+    }
+
+    /// Extends each literal in this set with the character class given,
+    /// writing the bytes of each character in reverse.
+    ///
+    /// Returns false if the character class was too big to add.
+    fn add_char_class_reverse(&mut self, cls: &hir::ClassUnicode) -> bool {
+        self._add_char_class(cls, true)
+    }
+
+    fn _add_char_class(
+        &mut self,
+        cls: &hir::ClassUnicode,
+        reverse: bool,
+    ) -> bool {
+        use std::char;
+
+        if self.class_exceeds_limits(cls_char_count(cls)) {
+            return false;
+        }
+        let mut base = self.remove_complete();
+        if base.is_empty() {
+            base = vec![Literal::empty()];
+        }
+        for r in cls.iter() {
+            let (s, e) = (r.start as u32, r.end as u32 + 1);
+            for c in (s..e).filter_map(char::from_u32) {
+                for mut lit in base.clone() {
+                    let mut bytes = c.to_string().into_bytes();
+                    if reverse {
+                        bytes.reverse();
+                    }
+                    lit.extend(&bytes);
+                    self.lits.push(lit);
+                }
+            }
+        }
+        true
+    }
+
+    /// Extends each literal in this set with the byte class given.
+    ///
+    /// Returns false if the byte class was too big to add.
+    pub fn add_byte_class(&mut self, cls: &hir::ClassBytes) -> bool {
+        if self.class_exceeds_limits(cls_byte_count(cls)) {
+            return false;
+        }
+        let mut base = self.remove_complete();
+        if base.is_empty() {
+            base = vec![Literal::empty()];
+        }
+        for r in cls.iter() {
+            let (s, e) = (r.start as u32, r.end as u32 + 1);
+            for b in (s..e).map(|b| b as u8) {
+                for mut lit in base.clone() {
+                    lit.push(b);
+                    self.lits.push(lit);
+                }
+            }
+        }
+        true
+    }
+
+    /// Cuts every member of this set. When a member is cut, it can never
+    /// be extended.
+    pub fn cut(&mut self) {
+        for lit in &mut self.lits {
+            lit.cut();
+        }
+    }
+
+    /// Reverses all members in place.
+    pub fn reverse(&mut self) {
+        for lit in &mut self.lits {
+            lit.reverse();
+        }
+    }
+
+    /// Clears this set of all members.
+    pub fn clear(&mut self) {
+        self.lits.clear();
+    }
+
+    /// Pops all complete literals out of this set.
+    fn remove_complete(&mut self) -> Vec<Literal> {
+        let mut base = vec![];
+        for lit in mem::replace(&mut self.lits, vec![]) {
+            if lit.is_cut() {
+                self.lits.push(lit);
+            } else {
+                base.push(lit);
+            }
+        }
+        base
+    }
+
+    /// Returns the total number of bytes in this set.
+    fn num_bytes(&self) -> usize {
+        self.lits.iter().fold(0, |accum, lit| accum + lit.len())
+    }
+
+    /// Returns true if a character class with the given size would cause this
+    /// set to exceed its limits.
+    ///
+    /// The size given should correspond to the number of items in the class.
+    fn class_exceeds_limits(&self, size: usize) -> bool {
+        if size > self.limit_class {
+            return true;
+        }
+        // This is an approximation since codepoints in a char class can encode
+        // to 1-4 bytes.
+        let new_byte_count = if self.lits.is_empty() {
+            size
+        } else {
+            self.lits.iter().fold(0, |accum, lit| {
+                accum
+                    + if lit.is_cut() {
+                        // If the literal is cut, then we'll never add
+                        // anything to it, so don't count it.
+                        0
+                    } else {
+                        (lit.len() + 1) * size
+                    }
+            })
+        };
+        new_byte_count > self.limit_size
+    }
+}
+
+fn prefixes(expr: &Hir, lits: &mut Literals) {
+    match *expr.kind() {
+        HirKind::Literal(hir::Literal::Unicode(c)) => {
+            let mut buf = [0; 4];
+            lits.cross_add(c.encode_utf8(&mut buf).as_bytes());
+        }
+        HirKind::Literal(hir::Literal::Byte(b)) => {
+            lits.cross_add(&[b]);
+        }
+        HirKind::Class(hir::Class::Unicode(ref cls)) => {
+            if !lits.add_char_class(cls) {
+                lits.cut();
+            }
+        }
+        HirKind::Class(hir::Class::Bytes(ref cls)) => {
+            if !lits.add_byte_class(cls) {
+                lits.cut();
+            }
+        }
+        HirKind::Group(hir::Group { ref hir, .. }) => {
+            prefixes(&**hir, lits);
+        }
+        HirKind::Repetition(ref x) => match x.kind {
+            hir::RepetitionKind::ZeroOrOne => {
+                repeat_zero_or_one_literals(&x.hir, lits, prefixes);
+            }
+            hir::RepetitionKind::ZeroOrMore => {
+                repeat_zero_or_more_literals(&x.hir, lits, prefixes);
+            }
+            hir::RepetitionKind::OneOrMore => {
+                repeat_one_or_more_literals(&x.hir, lits, prefixes);
+            }
+            hir::RepetitionKind::Range(ref rng) => {
+                let (min, max) = match *rng {
+                    hir::RepetitionRange::Exactly(m) => (m, Some(m)),
+                    hir::RepetitionRange::AtLeast(m) => (m, None),
+                    hir::RepetitionRange::Bounded(m, n) => (m, Some(n)),
+                };
+                repeat_range_literals(
+                    &x.hir, min, max, x.greedy, lits, prefixes,
+                )
+            }
+        },
+        HirKind::Concat(ref es) if es.is_empty() => {}
+        HirKind::Concat(ref es) if es.len() == 1 => prefixes(&es[0], lits),
+        HirKind::Concat(ref es) => {
+            for e in es {
+                if let HirKind::Anchor(hir::Anchor::StartText) = *e.kind() {
+                    if !lits.is_empty() {
+                        lits.cut();
+                        break;
+                    }
+                    lits.add(Literal::empty());
+                    continue;
+                }
+                let mut lits2 = lits.to_empty();
+                prefixes(e, &mut lits2);
+                if !lits.cross_product(&lits2) || !lits2.any_complete() {
+                    // If this expression couldn't yield any literal that
+                    // could be extended, then we need to quit. Since we're
+                    // short-circuiting, we also need to freeze every member.
+                    lits.cut();
+                    break;
+                }
+            }
+        }
+        HirKind::Alternation(ref es) => {
+            alternate_literals(es, lits, prefixes);
+        }
+        _ => lits.cut(),
+    }
+}
+
+fn suffixes(expr: &Hir, lits: &mut Literals) {
+    match *expr.kind() {
+        HirKind::Literal(hir::Literal::Unicode(c)) => {
+            let mut buf = [0u8; 4];
+            let i = c.encode_utf8(&mut buf).len();
+            let buf = &mut buf[..i];
+            buf.reverse();
+            lits.cross_add(buf);
+        }
+        HirKind::Literal(hir::Literal::Byte(b)) => {
+            lits.cross_add(&[b]);
+        }
+        HirKind::Class(hir::Class::Unicode(ref cls)) => {
+            if !lits.add_char_class_reverse(cls) {
+                lits.cut();
+            }
+        }
+        HirKind::Class(hir::Class::Bytes(ref cls)) => {
+            if !lits.add_byte_class(cls) {
+                lits.cut();
+            }
+        }
+        HirKind::Group(hir::Group { ref hir, .. }) => {
+            suffixes(&**hir, lits);
+        }
+        HirKind::Repetition(ref x) => match x.kind {
+            hir::RepetitionKind::ZeroOrOne => {
+                repeat_zero_or_one_literals(&x.hir, lits, suffixes);
+            }
+            hir::RepetitionKind::ZeroOrMore => {
+                repeat_zero_or_more_literals(&x.hir, lits, suffixes);
+            }
+            hir::RepetitionKind::OneOrMore => {
+                repeat_one_or_more_literals(&x.hir, lits, suffixes);
+            }
+            hir::RepetitionKind::Range(ref rng) => {
+                let (min, max) = match *rng {
+                    hir::RepetitionRange::Exactly(m) => (m, Some(m)),
+                    hir::RepetitionRange::AtLeast(m) => (m, None),
+                    hir::RepetitionRange::Bounded(m, n) => (m, Some(n)),
+                };
+                repeat_range_literals(
+                    &x.hir, min, max, x.greedy, lits, suffixes,
+                )
+            }
+        },
+        HirKind::Concat(ref es) if es.is_empty() => {}
+        HirKind::Concat(ref es) if es.len() == 1 => suffixes(&es[0], lits),
+        HirKind::Concat(ref es) => {
+            for e in es.iter().rev() {
+                if let HirKind::Anchor(hir::Anchor::EndText) = *e.kind() {
+                    if !lits.is_empty() {
+                        lits.cut();
+                        break;
+                    }
+                    lits.add(Literal::empty());
+                    continue;
+                }
+                let mut lits2 = lits.to_empty();
+                suffixes(e, &mut lits2);
+                if !lits.cross_product(&lits2) || !lits2.any_complete() {
+                    // If this expression couldn't yield any literal that
+                    // could be extended, then we need to quit. Since we're
+                    // short-circuiting, we also need to freeze every member.
+                    lits.cut();
+                    break;
+                }
+            }
+        }
+        HirKind::Alternation(ref es) => {
+            alternate_literals(es, lits, suffixes);
+        }
+        _ => lits.cut(),
+    }
+}
+
+fn repeat_zero_or_one_literals<F: FnMut(&Hir, &mut Literals)>(
+    e: &Hir,
+    lits: &mut Literals,
+    mut f: F,
+) {
+    f(
+        &Hir::repetition(hir::Repetition {
+            kind: hir::RepetitionKind::ZeroOrMore,
+            // FIXME: Our literal extraction doesn't care about greediness.
+            // Which is partially why we're treating 'e?' as 'e*'. Namely,
+            // 'ab??' yields [Complete(ab), Complete(a)], but it should yield
+            // [Complete(a), Complete(ab)] because of the non-greediness.
+            greedy: true,
+            hir: Box::new(e.clone()),
+        }),
+        lits,
+    );
+}
+
+fn repeat_zero_or_more_literals<F: FnMut(&Hir, &mut Literals)>(
+    e: &Hir,
+    lits: &mut Literals,
+    mut f: F,
+) {
+    let (mut lits2, mut lits3) = (lits.clone(), lits.to_empty());
+    lits3.set_limit_size(lits.limit_size() / 2);
+    f(e, &mut lits3);
+
+    if lits3.is_empty() || !lits2.cross_product(&lits3) {
+        lits.cut();
+        return;
+    }
+    lits2.cut();
+    lits2.add(Literal::empty());
+    if !lits.union(lits2) {
+        lits.cut();
+    }
+}
+
+fn repeat_one_or_more_literals<F: FnMut(&Hir, &mut Literals)>(
+    e: &Hir,
+    lits: &mut Literals,
+    mut f: F,
+) {
+    f(e, lits);
+    lits.cut();
+}
+
+fn repeat_range_literals<F: FnMut(&Hir, &mut Literals)>(
+    e: &Hir,
+    min: u32,
+    max: Option<u32>,
+    greedy: bool,
+    lits: &mut Literals,
+    mut f: F,
+) {
+    if min == 0 {
+        // This is a bit conservative. If `max` is set, then we could
+        // treat this as a finite set of alternations. For now, we
+        // just treat it as `e*`.
+        f(
+            &Hir::repetition(hir::Repetition {
+                kind: hir::RepetitionKind::ZeroOrMore,
+                greedy,
+                hir: Box::new(e.clone()),
+            }),
+            lits,
+        );
+    } else {
+        if min > 0 {
+            let n = cmp::min(lits.limit_size, min as usize);
+            let es = iter::repeat(e.clone()).take(n).collect();
+            f(&Hir::concat(es), lits);
+            if n < min as usize || lits.contains_empty() {
+                lits.cut();
+            }
+        }
+        if max.map_or(true, |max| min < max) {
+            lits.cut();
+        }
+    }
+}
+
+fn alternate_literals<F: FnMut(&Hir, &mut Literals)>(
+    es: &[Hir],
+    lits: &mut Literals,
+    mut f: F,
+) {
+    let mut lits2 = lits.to_empty();
+    for e in es {
+        let mut lits3 = lits.to_empty();
+        lits3.set_limit_size(lits.limit_size() / 5);
+        f(e, &mut lits3);
+        if lits3.is_empty() || !lits2.union(lits3) {
+            // If we couldn't find suffixes for *any* of the
+            // alternates, then the entire alternation has to be thrown
+            // away and any existing members must be frozen. Similarly,
+            // if the union couldn't complete, stop and freeze.
+            lits.cut();
+            return;
+        }
+    }
+    if !lits.cross_product(&lits2) {
+        lits.cut();
+    }
+}
+
+impl fmt::Debug for Literals {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Literals")
+            .field("lits", &self.lits)
+            .field("limit_size", &self.limit_size)
+            .field("limit_class", &self.limit_class)
+            .finish()
+    }
+}
+
+impl Literal {
+    /// Returns a new complete literal with the bytes given.
+    pub fn new(bytes: Vec<u8>) -> Literal {
+        Literal { v: bytes, cut: false }
+    }
+
+    /// Returns a new complete empty literal.
+    pub fn empty() -> Literal {
+        Literal { v: vec![], cut: false }
+    }
+
+    /// Returns true if this literal was "cut."
+    pub fn is_cut(&self) -> bool {
+        self.cut
+    }
+
+    /// Cuts this literal.
+    pub fn cut(&mut self) {
+        self.cut = true;
+    }
+}
+
+impl PartialEq for Literal {
+    fn eq(&self, other: &Literal) -> bool {
+        self.v == other.v
+    }
+}
+
+impl PartialOrd for Literal {
+    fn partial_cmp(&self, other: &Literal) -> Option<cmp::Ordering> {
+        self.v.partial_cmp(&other.v)
+    }
+}
+
+impl fmt::Debug for Literal {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if self.is_cut() {
+            write!(f, "Cut({})", escape_unicode(&self.v))
+        } else {
+            write!(f, "Complete({})", escape_unicode(&self.v))
+        }
+    }
+}
+
+impl AsRef<[u8]> for Literal {
+    fn as_ref(&self) -> &[u8] {
+        &self.v
+    }
+}
+
+impl ops::Deref for Literal {
+    type Target = Vec<u8>;
+    fn deref(&self) -> &Vec<u8> {
+        &self.v
+    }
+}
+
+impl ops::DerefMut for Literal {
+    fn deref_mut(&mut self) -> &mut Vec<u8> {
+        &mut self.v
+    }
+}
+
+fn position(needle: &[u8], mut haystack: &[u8]) -> Option<usize> {
+    let mut i = 0;
+    while haystack.len() >= needle.len() {
+        if needle == &haystack[..needle.len()] {
+            return Some(i);
+        }
+        i += 1;
+        haystack = &haystack[1..];
+    }
+    None
+}
+
+fn escape_unicode(bytes: &[u8]) -> String {
+    let show = match ::std::str::from_utf8(bytes) {
+        Ok(v) => v.to_string(),
+        Err(_) => escape_bytes(bytes),
+    };
+    let mut space_escaped = String::new();
+    for c in show.chars() {
+        if c.is_whitespace() {
+            let escaped = if c as u32 <= 0x7F {
+                escape_byte(c as u8)
+            } else if c as u32 <= 0xFFFF {
+                format!(r"\u{{{:04x}}}", c as u32)
+            } else {
+                format!(r"\U{{{:08x}}}", c as u32)
+            };
+            space_escaped.push_str(&escaped);
+        } else {
+            space_escaped.push(c);
+        }
+    }
+    space_escaped
+}
+
+fn escape_bytes(bytes: &[u8]) -> String {
+    let mut s = String::new();
+    for &b in bytes {
+        s.push_str(&escape_byte(b));
+    }
+    s
+}
+
+fn escape_byte(byte: u8) -> String {
+    use std::ascii::escape_default;
+
+    let escaped: Vec<u8> = escape_default(byte).collect();
+    String::from_utf8_lossy(&escaped).into_owned()
+}
+
+fn cls_char_count(cls: &hir::ClassUnicode) -> usize {
+    cls.iter().map(|&r| 1 + (r.end as u32) - (r.start as u32)).sum::<u32>()
+        as usize
+}
+
+fn cls_byte_count(cls: &hir::ClassBytes) -> usize {
+    cls.iter().map(|&r| 1 + (r.end as u32) - (r.start as u32)).sum::<u32>()
+        as usize
+}
+
+#[cfg(test)]
+mod tests {
+    use std::fmt;
+
+    use super::{escape_bytes, Literal, Literals};
+    use crate::hir::Hir;
+    use crate::ParserBuilder;
+
+    // To make test failures easier to read.
+    #[derive(Debug, Eq, PartialEq)]
+    struct Bytes(Vec<ULiteral>);
+    #[derive(Debug, Eq, PartialEq)]
+    struct Unicode(Vec<ULiteral>);
+
+    fn escape_lits(blits: &[Literal]) -> Vec<ULiteral> {
+        let mut ulits = vec![];
+        for blit in blits {
+            ulits
+                .push(ULiteral { v: escape_bytes(&blit), cut: blit.is_cut() });
+        }
+        ulits
+    }
+
+    fn create_lits<I: IntoIterator<Item = Literal>>(it: I) -> Literals {
+        Literals {
+            lits: it.into_iter().collect(),
+            limit_size: 0,
+            limit_class: 0,
+        }
+    }
+
+    // Needs to be pub for 1.3?
+    #[derive(Clone, Eq, PartialEq)]
+    pub struct ULiteral {
+        v: String,
+        cut: bool,
+    }
+
+    impl ULiteral {
+        fn is_cut(&self) -> bool {
+            self.cut
+        }
+    }
+
+    impl fmt::Debug for ULiteral {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            if self.is_cut() {
+                write!(f, "Cut({})", self.v)
+            } else {
+                write!(f, "Complete({})", self.v)
+            }
+        }
+    }
+
+    impl PartialEq<Literal> for ULiteral {
+        fn eq(&self, other: &Literal) -> bool {
+            self.v.as_bytes() == &*other.v && self.is_cut() == other.is_cut()
+        }
+    }
+
+    impl PartialEq<ULiteral> for Literal {
+        fn eq(&self, other: &ULiteral) -> bool {
+            &*self.v == other.v.as_bytes() && self.is_cut() == other.is_cut()
+        }
+    }
+
+    #[allow(non_snake_case)]
+    fn C(s: &'static str) -> ULiteral {
+        ULiteral { v: s.to_owned(), cut: true }
+    }
+    #[allow(non_snake_case)]
+    fn M(s: &'static str) -> ULiteral {
+        ULiteral { v: s.to_owned(), cut: false }
+    }
+
+    fn prefixes(lits: &mut Literals, expr: &Hir) {
+        lits.union_prefixes(expr);
+    }
+
+    fn suffixes(lits: &mut Literals, expr: &Hir) {
+        lits.union_suffixes(expr);
+    }
+
+    macro_rules! assert_lit_eq {
+        ($which:ident, $got_lits:expr, $($expected_lit:expr),*) => {{
+            let expected: Vec<ULiteral> = vec![$($expected_lit),*];
+            let lits = $got_lits;
+            assert_eq!(
+                $which(expected.clone()),
+                $which(escape_lits(lits.literals())));
+            assert_eq!(
+                !expected.is_empty() && expected.iter().all(|l| !l.is_cut()),
+                lits.all_complete());
+            assert_eq!(
+                expected.iter().any(|l| !l.is_cut()),
+                lits.any_complete());
+        }};
+    }
+
+    macro_rules! test_lit {
+        ($name:ident, $which:ident, $re:expr) => {
+            test_lit!($name, $which, $re,);
+        };
+        ($name:ident, $which:ident, $re:expr, $($lit:expr),*) => {
+            #[test]
+            fn $name() {
+                let expr = ParserBuilder::new()
+                    .build()
+                    .parse($re)
+                    .unwrap();
+                let lits = Literals::$which(&expr);
+                assert_lit_eq!(Unicode, lits, $($lit),*);
+
+                let expr = ParserBuilder::new()
+                    .allow_invalid_utf8(true)
+                    .unicode(false)
+                    .build()
+                    .parse($re)
+                    .unwrap();
+                let lits = Literals::$which(&expr);
+                assert_lit_eq!(Bytes, lits, $($lit),*);
+            }
+        };
+    }
+
+    // ************************************************************************
+    // Tests for prefix literal extraction.
+    // ************************************************************************
+
+    // Elementary tests.
+    test_lit!(pfx_one_lit1, prefixes, "a", M("a"));
+    test_lit!(pfx_one_lit2, prefixes, "abc", M("abc"));
+    test_lit!(pfx_one_lit3, prefixes, "(?u)☃", M("\\xe2\\x98\\x83"));
+    #[cfg(feature = "unicode-case")]
+    test_lit!(pfx_one_lit4, prefixes, "(?ui)☃", M("\\xe2\\x98\\x83"));
+    test_lit!(pfx_class1, prefixes, "[1-4]", M("1"), M("2"), M("3"), M("4"));
+    test_lit!(
+        pfx_class2,
+        prefixes,
+        "(?u)[☃Ⅰ]",
+        M("\\xe2\\x85\\xa0"),
+        M("\\xe2\\x98\\x83")
+    );
+    #[cfg(feature = "unicode-case")]
+    test_lit!(
+        pfx_class3,
+        prefixes,
+        "(?ui)[☃Ⅰ]",
+        M("\\xe2\\x85\\xa0"),
+        M("\\xe2\\x85\\xb0"),
+        M("\\xe2\\x98\\x83")
+    );
+    test_lit!(pfx_one_lit_casei1, prefixes, "(?i-u)a", M("A"), M("a"));
+    test_lit!(
+        pfx_one_lit_casei2,
+        prefixes,
+        "(?i-u)abc",
+        M("ABC"),
+        M("aBC"),
+        M("AbC"),
+        M("abC"),
+        M("ABc"),
+        M("aBc"),
+        M("Abc"),
+        M("abc")
+    );
+    test_lit!(pfx_group1, prefixes, "(a)", M("a"));
+    test_lit!(pfx_rep_zero_or_one1, prefixes, "a?");
+    test_lit!(pfx_rep_zero_or_one2, prefixes, "(?:abc)?");
+    test_lit!(pfx_rep_zero_or_one_cat1, prefixes, "ab?", C("ab"), M("a"));
+    // FIXME: This should return [M("a"), M("ab")] because of the non-greedy
+    // repetition. As a work-around, we rewrite ab?? as ab*?, and thus we get
+    // a cut literal.
+    test_lit!(pfx_rep_zero_or_one_cat2, prefixes, "ab??", C("ab"), M("a"));
+    test_lit!(pfx_rep_zero_or_more1, prefixes, "a*");
+    test_lit!(pfx_rep_zero_or_more2, prefixes, "(?:abc)*");
+    test_lit!(pfx_rep_one_or_more1, prefixes, "a+", C("a"));
+    test_lit!(pfx_rep_one_or_more2, prefixes, "(?:abc)+", C("abc"));
+    test_lit!(pfx_rep_nested_one_or_more, prefixes, "(?:a+)+", C("a"));
+    test_lit!(pfx_rep_range1, prefixes, "a{0}");
+    test_lit!(pfx_rep_range2, prefixes, "a{0,}");
+    test_lit!(pfx_rep_range3, prefixes, "a{0,1}");
+    test_lit!(pfx_rep_range4, prefixes, "a{1}", M("a"));
+    test_lit!(pfx_rep_range5, prefixes, "a{2}", M("aa"));
+    test_lit!(pfx_rep_range6, prefixes, "a{1,2}", C("a"));
+    test_lit!(pfx_rep_range7, prefixes, "a{2,3}", C("aa"));
+
+    // Test regexes with concatenations.
+    test_lit!(pfx_cat1, prefixes, "(?:a)(?:b)", M("ab"));
+    test_lit!(pfx_cat2, prefixes, "[ab]z", M("az"), M("bz"));
+    test_lit!(
+        pfx_cat3,
+        prefixes,
+        "(?i-u)[ab]z",
+        M("AZ"),
+        M("BZ"),
+        M("aZ"),
+        M("bZ"),
+        M("Az"),
+        M("Bz"),
+        M("az"),
+        M("bz")
+    );
+    test_lit!(
+        pfx_cat4,
+        prefixes,
+        "[ab][yz]",
+        M("ay"),
+        M("by"),
+        M("az"),
+        M("bz")
+    );
+    test_lit!(pfx_cat5, prefixes, "a*b", C("a"), M("b"));
+    test_lit!(pfx_cat6, prefixes, "a*b*c", C("a"), C("b"), M("c"));
+    test_lit!(pfx_cat7, prefixes, "a*b*c+", C("a"), C("b"), C("c"));
+    test_lit!(pfx_cat8, prefixes, "a*b+c", C("a"), C("b"));
+    test_lit!(pfx_cat9, prefixes, "a*b+c*", C("a"), C("b"));
+    test_lit!(pfx_cat10, prefixes, "ab*", C("ab"), M("a"));
+    test_lit!(pfx_cat11, prefixes, "ab*c", C("ab"), M("ac"));
+    test_lit!(pfx_cat12, prefixes, "ab+", C("ab"));
+    test_lit!(pfx_cat13, prefixes, "ab+c", C("ab"));
+    test_lit!(pfx_cat14, prefixes, "a^", C("a"));
+    test_lit!(pfx_cat15, prefixes, "$a");
+    test_lit!(pfx_cat16, prefixes, r"ab*c", C("ab"), M("ac"));
+    test_lit!(pfx_cat17, prefixes, r"ab+c", C("ab"));
+    test_lit!(pfx_cat18, prefixes, r"z*azb", C("z"), M("azb"));
+    test_lit!(pfx_cat19, prefixes, "a.z", C("a"));
+
+    // Test regexes with alternations.
+    test_lit!(pfx_alt1, prefixes, "a|b", M("a"), M("b"));
+    test_lit!(pfx_alt2, prefixes, "[1-3]|b", M("1"), M("2"), M("3"), M("b"));
+    test_lit!(pfx_alt3, prefixes, "y(?:a|b)z", M("yaz"), M("ybz"));
+    test_lit!(pfx_alt4, prefixes, "a|b*");
+    test_lit!(pfx_alt5, prefixes, "a|b+", M("a"), C("b"));
+    test_lit!(pfx_alt6, prefixes, "a|(?:b|c*)");
+    test_lit!(
+        pfx_alt7,
+        prefixes,
+        "(a|b)*c|(a|ab)*c",
+        C("a"),
+        C("b"),
+        M("c"),
+        C("a"),
+        C("ab"),
+        M("c")
+    );
+    test_lit!(pfx_alt8, prefixes, "a*b|c", C("a"), M("b"), M("c"));
+
+    // Test regexes with empty assertions.
+    test_lit!(pfx_empty1, prefixes, "^a", M("a"));
+    test_lit!(pfx_empty2, prefixes, "a${2}", C("a"));
+    test_lit!(pfx_empty3, prefixes, "^abc", M("abc"));
+    test_lit!(pfx_empty4, prefixes, "(?:^abc)|(?:^z)", M("abc"), M("z"));
+
+    // Make sure some curious regexes have no prefixes.
+    test_lit!(pfx_nothing1, prefixes, ".");
+    test_lit!(pfx_nothing2, prefixes, "(?s).");
+    test_lit!(pfx_nothing3, prefixes, "^");
+    test_lit!(pfx_nothing4, prefixes, "$");
+    test_lit!(pfx_nothing6, prefixes, "(?m)$");
+    test_lit!(pfx_nothing7, prefixes, r"\b");
+    test_lit!(pfx_nothing8, prefixes, r"\B");
+
+    // Test a few regexes that defeat any prefix literal detection.
+    test_lit!(pfx_defeated1, prefixes, ".a");
+    test_lit!(pfx_defeated2, prefixes, "(?s).a");
+    test_lit!(pfx_defeated3, prefixes, "a*b*c*");
+    test_lit!(pfx_defeated4, prefixes, "a|.");
+    test_lit!(pfx_defeated5, prefixes, ".|a");
+    test_lit!(pfx_defeated6, prefixes, "a|^");
+    test_lit!(pfx_defeated7, prefixes, ".(?:a(?:b)(?:c))");
+    test_lit!(pfx_defeated8, prefixes, "$a");
+    test_lit!(pfx_defeated9, prefixes, "(?m)$a");
+    test_lit!(pfx_defeated10, prefixes, r"\ba");
+    test_lit!(pfx_defeated11, prefixes, r"\Ba");
+    test_lit!(pfx_defeated12, prefixes, "^*a");
+    test_lit!(pfx_defeated13, prefixes, "^+a");
+
+    test_lit!(
+        pfx_crazy1,
+        prefixes,
+        r"M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]",
+        C("Mo\\'"),
+        C("Mu\\'"),
+        C("Moam"),
+        C("Muam")
+    );
+
+    // ************************************************************************
+    // Tests for quiting prefix literal search.
+    // ************************************************************************
+
+    macro_rules! test_exhausted {
+        ($name:ident, $which:ident, $re:expr) => {
+            test_exhausted!($name, $which, $re,);
+        };
+        ($name:ident, $which:ident, $re:expr, $($lit:expr),*) => {
+            #[test]
+            fn $name() {
+                let expr = ParserBuilder::new()
+                    .build()
+                    .parse($re)
+                    .unwrap();
+                let mut lits = Literals::empty();
+                lits.set_limit_size(20).set_limit_class(10);
+                $which(&mut lits, &expr);
+                assert_lit_eq!(Unicode, lits, $($lit),*);
+
+                let expr = ParserBuilder::new()
+                    .allow_invalid_utf8(true)
+                    .unicode(false)
+                    .build()
+                    .parse($re)
+                    .unwrap();
+                let mut lits = Literals::empty();
+                lits.set_limit_size(20).set_limit_class(10);
+                $which(&mut lits, &expr);
+                assert_lit_eq!(Bytes, lits, $($lit),*);
+            }
+        };
+    }
+
+    // These test use a much lower limit than the default so that we can
+    // write test cases of reasonable size.
+    test_exhausted!(pfx_exhausted1, prefixes, "[a-z]");
+    test_exhausted!(pfx_exhausted2, prefixes, "[a-z]*A");
+    test_exhausted!(pfx_exhausted3, prefixes, "A[a-z]Z", C("A"));
+    test_exhausted!(
+        pfx_exhausted4,
+        prefixes,
+        "(?i-u)foobar",
+        C("FO"),
+        C("fO"),
+        C("Fo"),
+        C("fo")
+    );
+    test_exhausted!(
+        pfx_exhausted5,
+        prefixes,
+        "(?:ab){100}",
+        C("abababababababababab")
+    );
+    test_exhausted!(
+        pfx_exhausted6,
+        prefixes,
+        "(?:(?:ab){100})*cd",
+        C("ababababab"),
+        M("cd")
+    );
+    test_exhausted!(
+        pfx_exhausted7,
+        prefixes,
+        "z(?:(?:ab){100})*cd",
+        C("zababababab"),
+        M("zcd")
+    );
+    test_exhausted!(
+        pfx_exhausted8,
+        prefixes,
+        "aaaaaaaaaaaaaaaaaaaaz",
+        C("aaaaaaaaaaaaaaaaaaaa")
+    );
+
+    // ************************************************************************
+    // Tests for suffix literal extraction.
+    // ************************************************************************
+
+    // Elementary tests.
+    test_lit!(sfx_one_lit1, suffixes, "a", M("a"));
+    test_lit!(sfx_one_lit2, suffixes, "abc", M("abc"));
+    test_lit!(sfx_one_lit3, suffixes, "(?u)☃", M("\\xe2\\x98\\x83"));
+    #[cfg(feature = "unicode-case")]
+    test_lit!(sfx_one_lit4, suffixes, "(?ui)☃", M("\\xe2\\x98\\x83"));
+    test_lit!(sfx_class1, suffixes, "[1-4]", M("1"), M("2"), M("3"), M("4"));
+    test_lit!(
+        sfx_class2,
+        suffixes,
+        "(?u)[☃Ⅰ]",
+        M("\\xe2\\x85\\xa0"),
+        M("\\xe2\\x98\\x83")
+    );
+    #[cfg(feature = "unicode-case")]
+    test_lit!(
+        sfx_class3,
+        suffixes,
+        "(?ui)[☃Ⅰ]",
+        M("\\xe2\\x85\\xa0"),
+        M("\\xe2\\x85\\xb0"),
+        M("\\xe2\\x98\\x83")
+    );
+    test_lit!(sfx_one_lit_casei1, suffixes, "(?i-u)a", M("A"), M("a"));
+    test_lit!(
+        sfx_one_lit_casei2,
+        suffixes,
+        "(?i-u)abc",
+        M("ABC"),
+        M("ABc"),
+        M("AbC"),
+        M("Abc"),
+        M("aBC"),
+        M("aBc"),
+        M("abC"),
+        M("abc")
+    );
+    test_lit!(sfx_group1, suffixes, "(a)", M("a"));
+    test_lit!(sfx_rep_zero_or_one1, suffixes, "a?");
+    test_lit!(sfx_rep_zero_or_one2, suffixes, "(?:abc)?");
+    test_lit!(sfx_rep_zero_or_more1, suffixes, "a*");
+    test_lit!(sfx_rep_zero_or_more2, suffixes, "(?:abc)*");
+    test_lit!(sfx_rep_one_or_more1, suffixes, "a+", C("a"));
+    test_lit!(sfx_rep_one_or_more2, suffixes, "(?:abc)+", C("abc"));
+    test_lit!(sfx_rep_nested_one_or_more, suffixes, "(?:a+)+", C("a"));
+    test_lit!(sfx_rep_range1, suffixes, "a{0}");
+    test_lit!(sfx_rep_range2, suffixes, "a{0,}");
+    test_lit!(sfx_rep_range3, suffixes, "a{0,1}");
+    test_lit!(sfx_rep_range4, suffixes, "a{1}", M("a"));
+    test_lit!(sfx_rep_range5, suffixes, "a{2}", M("aa"));
+    test_lit!(sfx_rep_range6, suffixes, "a{1,2}", C("a"));
+    test_lit!(sfx_rep_range7, suffixes, "a{2,3}", C("aa"));
+
+    // Test regexes with concatenations.
+    test_lit!(sfx_cat1, suffixes, "(?:a)(?:b)", M("ab"));
+    test_lit!(sfx_cat2, suffixes, "[ab]z", M("az"), M("bz"));
+    test_lit!(
+        sfx_cat3,
+        suffixes,
+        "(?i-u)[ab]z",
+        M("AZ"),
+        M("Az"),
+        M("BZ"),
+        M("Bz"),
+        M("aZ"),
+        M("az"),
+        M("bZ"),
+        M("bz")
+    );
+    test_lit!(
+        sfx_cat4,
+        suffixes,
+        "[ab][yz]",
+        M("ay"),
+        M("az"),
+        M("by"),
+        M("bz")
+    );
+    test_lit!(sfx_cat5, suffixes, "a*b", C("ab"), M("b"));
+    test_lit!(sfx_cat6, suffixes, "a*b*c", C("bc"), C("ac"), M("c"));
+    test_lit!(sfx_cat7, suffixes, "a*b*c+", C("c"));
+    test_lit!(sfx_cat8, suffixes, "a*b+c", C("bc"));
+    test_lit!(sfx_cat9, suffixes, "a*b+c*", C("c"), C("b"));
+    test_lit!(sfx_cat10, suffixes, "ab*", C("b"), M("a"));
+    test_lit!(sfx_cat11, suffixes, "ab*c", C("bc"), M("ac"));
+    test_lit!(sfx_cat12, suffixes, "ab+", C("b"));
+    test_lit!(sfx_cat13, suffixes, "ab+c", C("bc"));
+    test_lit!(sfx_cat14, suffixes, "a^");
+    test_lit!(sfx_cat15, suffixes, "$a", C("a"));
+    test_lit!(sfx_cat16, suffixes, r"ab*c", C("bc"), M("ac"));
+    test_lit!(sfx_cat17, suffixes, r"ab+c", C("bc"));
+    test_lit!(sfx_cat18, suffixes, r"z*azb", C("zazb"), M("azb"));
+    test_lit!(sfx_cat19, suffixes, "a.z", C("z"));
+
+    // Test regexes with alternations.
+    test_lit!(sfx_alt1, suffixes, "a|b", M("a"), M("b"));
+    test_lit!(sfx_alt2, suffixes, "[1-3]|b", M("1"), M("2"), M("3"), M("b"));
+    test_lit!(sfx_alt3, suffixes, "y(?:a|b)z", M("yaz"), M("ybz"));
+    test_lit!(sfx_alt4, suffixes, "a|b*");
+    test_lit!(sfx_alt5, suffixes, "a|b+", M("a"), C("b"));
+    test_lit!(sfx_alt6, suffixes, "a|(?:b|c*)");
+    test_lit!(
+        sfx_alt7,
+        suffixes,
+        "(a|b)*c|(a|ab)*c",
+        C("ac"),
+        C("bc"),
+        M("c"),
+        C("ac"),
+        C("abc"),
+        M("c")
+    );
+    test_lit!(sfx_alt8, suffixes, "a*b|c", C("ab"), M("b"), M("c"));
+
+    // Test regexes with empty assertions.
+    test_lit!(sfx_empty1, suffixes, "a$", M("a"));
+    test_lit!(sfx_empty2, suffixes, "${2}a", C("a"));
+
+    // Make sure some curious regexes have no suffixes.
+    test_lit!(sfx_nothing1, suffixes, ".");
+    test_lit!(sfx_nothing2, suffixes, "(?s).");
+    test_lit!(sfx_nothing3, suffixes, "^");
+    test_lit!(sfx_nothing4, suffixes, "$");
+    test_lit!(sfx_nothing6, suffixes, "(?m)$");
+    test_lit!(sfx_nothing7, suffixes, r"\b");
+    test_lit!(sfx_nothing8, suffixes, r"\B");
+
+    // Test a few regexes that defeat any suffix literal detection.
+    test_lit!(sfx_defeated1, suffixes, "a.");
+    test_lit!(sfx_defeated2, suffixes, "(?s)a.");
+    test_lit!(sfx_defeated3, suffixes, "a*b*c*");
+    test_lit!(sfx_defeated4, suffixes, "a|.");
+    test_lit!(sfx_defeated5, suffixes, ".|a");
+    test_lit!(sfx_defeated6, suffixes, "a|^");
+    test_lit!(sfx_defeated7, suffixes, "(?:a(?:b)(?:c)).");
+    test_lit!(sfx_defeated8, suffixes, "a^");
+    test_lit!(sfx_defeated9, suffixes, "(?m)a$");
+    test_lit!(sfx_defeated10, suffixes, r"a\b");
+    test_lit!(sfx_defeated11, suffixes, r"a\B");
+    test_lit!(sfx_defeated12, suffixes, "a^*");
+    test_lit!(sfx_defeated13, suffixes, "a^+");
+
+    // These test use a much lower limit than the default so that we can
+    // write test cases of reasonable size.
+    test_exhausted!(sfx_exhausted1, suffixes, "[a-z]");
+    test_exhausted!(sfx_exhausted2, suffixes, "A[a-z]*");
+    test_exhausted!(sfx_exhausted3, suffixes, "A[a-z]Z", C("Z"));
+    test_exhausted!(
+        sfx_exhausted4,
+        suffixes,
+        "(?i-u)foobar",
+        C("AR"),
+        C("Ar"),
+        C("aR"),
+        C("ar")
+    );
+    test_exhausted!(
+        sfx_exhausted5,
+        suffixes,
+        "(?:ab){100}",
+        C("abababababababababab")
+    );
+    test_exhausted!(
+        sfx_exhausted6,
+        suffixes,
+        "cd(?:(?:ab){100})*",
+        C("ababababab"),
+        M("cd")
+    );
+    test_exhausted!(
+        sfx_exhausted7,
+        suffixes,
+        "cd(?:(?:ab){100})*z",
+        C("abababababz"),
+        M("cdz")
+    );
+    test_exhausted!(
+        sfx_exhausted8,
+        suffixes,
+        "zaaaaaaaaaaaaaaaaaaaa",
+        C("aaaaaaaaaaaaaaaaaaaa")
+    );
+
+    // ************************************************************************
+    // Tests for generating unambiguous literal sets.
+    // ************************************************************************
+
+    macro_rules! test_unamb {
+        ($name:ident, $given:expr, $expected:expr) => {
+            #[test]
+            fn $name() {
+                let given: Vec<Literal> = $given
+                    .into_iter()
+                    .map(|ul| {
+                        let cut = ul.is_cut();
+                        Literal { v: ul.v.into_bytes(), cut: cut }
+                    })
+                    .collect();
+                let lits = create_lits(given);
+                let got = lits.unambiguous_prefixes();
+                assert_eq!($expected, escape_lits(got.literals()));
+            }
+        };
+    }
+
+    test_unamb!(unambiguous1, vec![M("z"), M("azb")], vec![C("a"), C("z")]);
+    test_unamb!(
+        unambiguous2,
+        vec![M("zaaaaaa"), M("aa")],
+        vec![C("aa"), C("z")]
+    );
+    test_unamb!(
+        unambiguous3,
+        vec![M("Sherlock"), M("Watson")],
+        vec![M("Sherlock"), M("Watson")]
+    );
+    test_unamb!(unambiguous4, vec![M("abc"), M("bc")], vec![C("a"), C("bc")]);
+    test_unamb!(unambiguous5, vec![M("bc"), M("abc")], vec![C("a"), C("bc")]);
+    test_unamb!(unambiguous6, vec![M("a"), M("aa")], vec![C("a")]);
+    test_unamb!(unambiguous7, vec![M("aa"), M("a")], vec![C("a")]);
+    test_unamb!(unambiguous8, vec![M("ab"), M("a")], vec![C("a")]);
+    test_unamb!(
+        unambiguous9,
+        vec![M("ac"), M("bc"), M("c"), M("ac"), M("abc"), M("c")],
+        vec![C("a"), C("b"), C("c")]
+    );
+    test_unamb!(
+        unambiguous10,
+        vec![M("Mo'"), M("Mu'"), M("Mo"), M("Mu")],
+        vec![C("Mo"), C("Mu")]
+    );
+    test_unamb!(
+        unambiguous11,
+        vec![M("zazb"), M("azb")],
+        vec![C("a"), C("z")]
+    );
+    test_unamb!(unambiguous12, vec![M("foo"), C("foo")], vec![C("foo")]);
+    test_unamb!(
+        unambiguous13,
+        vec![M("ABCX"), M("CDAX"), M("BCX")],
+        vec![C("A"), C("BCX"), C("CD")]
+    );
+    test_unamb!(
+        unambiguous14,
+        vec![M("IMGX"), M("MVIX"), M("MGX"), M("DSX")],
+        vec![M("DSX"), C("I"), C("MGX"), C("MV")]
+    );
+    test_unamb!(
+        unambiguous15,
+        vec![M("IMG_"), M("MG_"), M("CIMG")],
+        vec![C("C"), C("I"), C("MG_")]
+    );
+
+    // ************************************************************************
+    // Tests for suffix trimming.
+    // ************************************************************************
+    macro_rules! test_trim {
+        ($name:ident, $trim:expr, $given:expr, $expected:expr) => {
+            #[test]
+            fn $name() {
+                let given: Vec<Literal> = $given
+                    .into_iter()
+                    .map(|ul| {
+                        let cut = ul.is_cut();
+                        Literal { v: ul.v.into_bytes(), cut: cut }
+                    })
+                    .collect();
+                let lits = create_lits(given);
+                let got = lits.trim_suffix($trim).unwrap();
+                assert_eq!($expected, escape_lits(got.literals()));
+            }
+        };
+    }
+
+    test_trim!(trim1, 1, vec![M("ab"), M("yz")], vec![C("a"), C("y")]);
+    test_trim!(trim2, 1, vec![M("abc"), M("abd")], vec![C("ab")]);
+    test_trim!(trim3, 2, vec![M("abc"), M("abd")], vec![C("a")]);
+    test_trim!(trim4, 2, vec![M("abc"), M("ghij")], vec![C("a"), C("gh")]);
+
+    // ************************************************************************
+    // Tests for longest common prefix.
+    // ************************************************************************
+
+    macro_rules! test_lcp {
+        ($name:ident, $given:expr, $expected:expr) => {
+            #[test]
+            fn $name() {
+                let given: Vec<Literal> = $given
+                    .into_iter()
+                    .map(|s: &str| Literal {
+                        v: s.to_owned().into_bytes(),
+                        cut: false,
+                    })
+                    .collect();
+                let lits = create_lits(given);
+                let got = lits.longest_common_prefix();
+                assert_eq!($expected, escape_bytes(got));
+            }
+        };
+    }
+
+    test_lcp!(lcp1, vec!["a"], "a");
+    test_lcp!(lcp2, vec![], "");
+    test_lcp!(lcp3, vec!["a", "b"], "");
+    test_lcp!(lcp4, vec!["ab", "ab"], "ab");
+    test_lcp!(lcp5, vec!["ab", "a"], "a");
+    test_lcp!(lcp6, vec!["a", "ab"], "a");
+    test_lcp!(lcp7, vec!["ab", "b"], "");
+    test_lcp!(lcp8, vec!["b", "ab"], "");
+    test_lcp!(lcp9, vec!["foobar", "foobaz"], "fooba");
+    test_lcp!(lcp10, vec!["foobar", "foobaz", "a"], "");
+    test_lcp!(lcp11, vec!["a", "foobar", "foobaz"], "");
+    test_lcp!(lcp12, vec!["foo", "flub", "flab", "floo"], "f");
+
+    // ************************************************************************
+    // Tests for longest common suffix.
+    // ************************************************************************
+
+    macro_rules! test_lcs {
+        ($name:ident, $given:expr, $expected:expr) => {
+            #[test]
+            fn $name() {
+                let given: Vec<Literal> = $given
+                    .into_iter()
+                    .map(|s: &str| Literal {
+                        v: s.to_owned().into_bytes(),
+                        cut: false,
+                    })
+                    .collect();
+                let lits = create_lits(given);
+                let got = lits.longest_common_suffix();
+                assert_eq!($expected, escape_bytes(got));
+            }
+        };
+    }
+
+    test_lcs!(lcs1, vec!["a"], "a");
+    test_lcs!(lcs2, vec![], "");
+    test_lcs!(lcs3, vec!["a", "b"], "");
+    test_lcs!(lcs4, vec!["ab", "ab"], "ab");
+    test_lcs!(lcs5, vec!["ab", "a"], "");
+    test_lcs!(lcs6, vec!["a", "ab"], "");
+    test_lcs!(lcs7, vec!["ab", "b"], "b");
+    test_lcs!(lcs8, vec!["b", "ab"], "b");
+    test_lcs!(lcs9, vec!["barfoo", "bazfoo"], "foo");
+    test_lcs!(lcs10, vec!["barfoo", "bazfoo", "a"], "");
+    test_lcs!(lcs11, vec!["a", "barfoo", "bazfoo"], "");
+    test_lcs!(lcs12, vec!["flub", "bub", "boob", "dub"], "b");
+}
diff --git a/crates/regex-syntax/src/hir/mod.rs b/crates/regex-syntax/src/hir/mod.rs
new file mode 100644
index 0000000..156bcc2
--- /dev/null
+++ b/crates/regex-syntax/src/hir/mod.rs
@@ -0,0 +1,2299 @@
+/*!
+Defines a high-level intermediate representation for regular expressions.
+*/
+use std::char;
+use std::cmp;
+use std::error;
+use std::fmt;
+use std::result;
+use std::u8;
+
+use crate::ast::Span;
+use crate::hir::interval::{Interval, IntervalSet, IntervalSetIter};
+use crate::unicode;
+
+pub use crate::hir::visitor::{visit, Visitor};
+pub use crate::unicode::CaseFoldError;
+
+mod interval;
+pub mod literal;
+pub mod print;
+pub mod translate;
+mod visitor;
+
+/// An error that can occur while translating an `Ast` to a `Hir`.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Error {
+    /// The kind of error.
+    kind: ErrorKind,
+    /// The original pattern that the translator's Ast was parsed from. Every
+    /// span in an error is a valid range into this string.
+    pattern: String,
+    /// The span of this error, derived from the Ast given to the translator.
+    span: Span,
+}
+
+impl Error {
+    /// Return the type of this error.
+    pub fn kind(&self) -> &ErrorKind {
+        &self.kind
+    }
+
+    /// The original pattern string in which this error occurred.
+    ///
+    /// Every span reported by this error is reported in terms of this string.
+    pub fn pattern(&self) -> &str {
+        &self.pattern
+    }
+
+    /// Return the span at which this error occurred.
+    pub fn span(&self) -> &Span {
+        &self.span
+    }
+}
+
+/// The type of an error that occurred while building an `Hir`.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum ErrorKind {
+    /// This error occurs when a Unicode feature is used when Unicode
+    /// support is disabled. For example `(?-u:\pL)` would trigger this error.
+    UnicodeNotAllowed,
+    /// This error occurs when translating a pattern that could match a byte
+    /// sequence that isn't UTF-8 and `allow_invalid_utf8` was disabled.
+    InvalidUtf8,
+    /// This occurs when an unrecognized Unicode property name could not
+    /// be found.
+    UnicodePropertyNotFound,
+    /// This occurs when an unrecognized Unicode property value could not
+    /// be found.
+    UnicodePropertyValueNotFound,
+    /// This occurs when a Unicode-aware Perl character class (`\w`, `\s` or
+    /// `\d`) could not be found. This can occur when the `unicode-perl`
+    /// crate feature is not enabled.
+    UnicodePerlClassNotFound,
+    /// This occurs when the Unicode simple case mapping tables are not
+    /// available, and the regular expression required Unicode aware case
+    /// insensitivity.
+    UnicodeCaseUnavailable,
+    /// This occurs when the translator attempts to construct a character class
+    /// that is empty.
+    ///
+    /// Note that this restriction in the translator may be removed in the
+    /// future.
+    EmptyClassNotAllowed,
+    /// Hints that destructuring should not be exhaustive.
+    ///
+    /// This enum may grow additional variants, so this makes sure clients
+    /// don't count on exhaustive matching. (Otherwise, adding a new variant
+    /// could break existing code.)
+    #[doc(hidden)]
+    __Nonexhaustive,
+}
+
+impl ErrorKind {
+    // TODO: Remove this method entirely on the next breaking semver release.
+    #[allow(deprecated)]
+    fn description(&self) -> &str {
+        use self::ErrorKind::*;
+        match *self {
+            UnicodeNotAllowed => "Unicode not allowed here",
+            InvalidUtf8 => "pattern can match invalid UTF-8",
+            UnicodePropertyNotFound => "Unicode property not found",
+            UnicodePropertyValueNotFound => "Unicode property value not found",
+            UnicodePerlClassNotFound => {
+                "Unicode-aware Perl class not found \
+                 (make sure the unicode-perl feature is enabled)"
+            }
+            UnicodeCaseUnavailable => {
+                "Unicode-aware case insensitivity matching is not available \
+                 (make sure the unicode-case feature is enabled)"
+            }
+            EmptyClassNotAllowed => "empty character classes are not allowed",
+            __Nonexhaustive => unreachable!(),
+        }
+    }
+}
+
+impl error::Error for Error {
+    // TODO: Remove this method entirely on the next breaking semver release.
+    #[allow(deprecated)]
+    fn description(&self) -> &str {
+        self.kind.description()
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        crate::error::Formatter::from(self).fmt(f)
+    }
+}
+
+impl fmt::Display for ErrorKind {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        // TODO: Remove this on the next breaking semver release.
+        #[allow(deprecated)]
+        f.write_str(self.description())
+    }
+}
+
+/// A high-level intermediate representation (HIR) for a regular expression.
+///
+/// The HIR of a regular expression represents an intermediate step between its
+/// abstract syntax (a structured description of the concrete syntax) and
+/// compiled byte codes. The purpose of HIR is to make regular expressions
+/// easier to analyze. In particular, the AST is much more complex than the
+/// HIR. For example, while an AST supports arbitrarily nested character
+/// classes, the HIR will flatten all nested classes into a single set. The HIR
+/// will also "compile away" every flag present in the concrete syntax. For
+/// example, users of HIR expressions never need to worry about case folding;
+/// it is handled automatically by the translator (e.g., by translating `(?i)A`
+/// to `[aA]`).
+///
+/// If the HIR was produced by a translator that disallows invalid UTF-8, then
+/// the HIR is guaranteed to match UTF-8 exclusively.
+///
+/// This type defines its own destructor that uses constant stack space and
+/// heap space proportional to the size of the HIR.
+///
+/// The specific type of an HIR expression can be accessed via its `kind`
+/// or `into_kind` methods. This extra level of indirection exists for two
+/// reasons:
+///
+/// 1. Construction of an HIR expression *must* use the constructor methods
+///    on this `Hir` type instead of building the `HirKind` values directly.
+///    This permits construction to enforce invariants like "concatenations
+///    always consist of two or more sub-expressions."
+/// 2. Every HIR expression contains attributes that are defined inductively,
+///    and can be computed cheaply during the construction process. For
+///    example, one such attribute is whether the expression must match at the
+///    beginning of the text.
+///
+/// Also, an `Hir`'s `fmt::Display` implementation prints an HIR as a regular
+/// expression pattern string, and uses constant stack space and heap space
+/// proportional to the size of the `Hir`.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Hir {
+    /// The underlying HIR kind.
+    kind: HirKind,
+    /// Analysis info about this HIR, computed during construction.
+    info: HirInfo,
+}
+
+/// The kind of an arbitrary `Hir` expression.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum HirKind {
+    /// The empty regular expression, which matches everything, including the
+    /// empty string.
+    Empty,
+    /// A single literal character that matches exactly this character.
+    Literal(Literal),
+    /// A single character class that matches any of the characters in the
+    /// class. A class can either consist of Unicode scalar values as
+    /// characters, or it can use bytes.
+    Class(Class),
+    /// An anchor assertion. An anchor assertion match always has zero length.
+    Anchor(Anchor),
+    /// A word boundary assertion, which may or may not be Unicode aware. A
+    /// word boundary assertion match always has zero length.
+    WordBoundary(WordBoundary),
+    /// A repetition operation applied to a child expression.
+    Repetition(Repetition),
+    /// A possibly capturing group, which contains a child expression.
+    Group(Group),
+    /// A concatenation of expressions. A concatenation always has at least two
+    /// child expressions.
+    ///
+    /// A concatenation matches only if each of its child expression matches
+    /// one after the other.
+    Concat(Vec<Hir>),
+    /// An alternation of expressions. An alternation always has at least two
+    /// child expressions.
+    ///
+    /// An alternation matches only if at least one of its child expression
+    /// matches. If multiple expressions match, then the leftmost is preferred.
+    Alternation(Vec<Hir>),
+}
+
+impl Hir {
+    /// Returns a reference to the underlying HIR kind.
+    pub fn kind(&self) -> &HirKind {
+        &self.kind
+    }
+
+    /// Consumes ownership of this HIR expression and returns its underlying
+    /// `HirKind`.
+    pub fn into_kind(mut self) -> HirKind {
+        use std::mem;
+        mem::replace(&mut self.kind, HirKind::Empty)
+    }
+
+    /// Returns an empty HIR expression.
+    ///
+    /// An empty HIR expression always matches, including the empty string.
+    pub fn empty() -> Hir {
+        let mut info = HirInfo::new();
+        info.set_always_utf8(true);
+        info.set_all_assertions(true);
+        info.set_anchored_start(false);
+        info.set_anchored_end(false);
+        info.set_line_anchored_start(false);
+        info.set_line_anchored_end(false);
+        info.set_any_anchored_start(false);
+        info.set_any_anchored_end(false);
+        info.set_match_empty(true);
+        info.set_literal(false);
+        info.set_alternation_literal(false);
+        Hir { kind: HirKind::Empty, info }
+    }
+
+    /// Creates a literal HIR expression.
+    ///
+    /// If the given literal has a `Byte` variant with an ASCII byte, then this
+    /// method panics. This enforces the invariant that `Byte` variants are
+    /// only used to express matching of invalid UTF-8.
+    pub fn literal(lit: Literal) -> Hir {
+        if let Literal::Byte(b) = lit {
+            assert!(b > 0x7F);
+        }
+
+        let mut info = HirInfo::new();
+        info.set_always_utf8(lit.is_unicode());
+        info.set_all_assertions(false);
+        info.set_anchored_start(false);
+        info.set_anchored_end(false);
+        info.set_line_anchored_start(false);
+        info.set_line_anchored_end(false);
+        info.set_any_anchored_start(false);
+        info.set_any_anchored_end(false);
+        info.set_match_empty(false);
+        info.set_literal(true);
+        info.set_alternation_literal(true);
+        Hir { kind: HirKind::Literal(lit), info }
+    }
+
+    /// Creates a class HIR expression.
+    pub fn class(class: Class) -> Hir {
+        let mut info = HirInfo::new();
+        info.set_always_utf8(class.is_always_utf8());
+        info.set_all_assertions(false);
+        info.set_anchored_start(false);
+        info.set_anchored_end(false);
+        info.set_line_anchored_start(false);
+        info.set_line_anchored_end(false);
+        info.set_any_anchored_start(false);
+        info.set_any_anchored_end(false);
+        info.set_match_empty(false);
+        info.set_literal(false);
+        info.set_alternation_literal(false);
+        Hir { kind: HirKind::Class(class), info }
+    }
+
+    /// Creates an anchor assertion HIR expression.
+    pub fn anchor(anchor: Anchor) -> Hir {
+        let mut info = HirInfo::new();
+        info.set_always_utf8(true);
+        info.set_all_assertions(true);
+        info.set_anchored_start(false);
+        info.set_anchored_end(false);
+        info.set_line_anchored_start(false);
+        info.set_line_anchored_end(false);
+        info.set_any_anchored_start(false);
+        info.set_any_anchored_end(false);
+        info.set_match_empty(true);
+        info.set_literal(false);
+        info.set_alternation_literal(false);
+        if let Anchor::StartText = anchor {
+            info.set_anchored_start(true);
+            info.set_line_anchored_start(true);
+            info.set_any_anchored_start(true);
+        }
+        if let Anchor::EndText = anchor {
+            info.set_anchored_end(true);
+            info.set_line_anchored_end(true);
+            info.set_any_anchored_end(true);
+        }
+        if let Anchor::StartLine = anchor {
+            info.set_line_anchored_start(true);
+        }
+        if let Anchor::EndLine = anchor {
+            info.set_line_anchored_end(true);
+        }
+        Hir { kind: HirKind::Anchor(anchor), info }
+    }
+
+    /// Creates a word boundary assertion HIR expression.
+    pub fn word_boundary(word_boundary: WordBoundary) -> Hir {
+        let mut info = HirInfo::new();
+        info.set_always_utf8(true);
+        info.set_all_assertions(true);
+        info.set_anchored_start(false);
+        info.set_anchored_end(false);
+        info.set_line_anchored_start(false);
+        info.set_line_anchored_end(false);
+        info.set_any_anchored_start(false);
+        info.set_any_anchored_end(false);
+        info.set_literal(false);
+        info.set_alternation_literal(false);
+        // A negated word boundary matches '', so that's fine. But \b does not
+        // match \b, so why do we say it can match the empty string? Well,
+        // because, if you search for \b against 'a', it will report [0, 0) and
+        // [1, 1) as matches, and both of those matches correspond to the empty
+        // string. Thus, only *certain* empty strings match \b, which similarly
+        // applies to \B.
+        info.set_match_empty(true);
+        // Negated ASCII word boundaries can match invalid UTF-8.
+        if let WordBoundary::AsciiNegate = word_boundary {
+            info.set_always_utf8(false);
+        }
+        Hir { kind: HirKind::WordBoundary(word_boundary), info }
+    }
+
+    /// Creates a repetition HIR expression.
+    pub fn repetition(rep: Repetition) -> Hir {
+        let mut info = HirInfo::new();
+        info.set_always_utf8(rep.hir.is_always_utf8());
+        info.set_all_assertions(rep.hir.is_all_assertions());
+        // If this operator can match the empty string, then it can never
+        // be anchored.
+        info.set_anchored_start(
+            !rep.is_match_empty() && rep.hir.is_anchored_start(),
+        );
+        info.set_anchored_end(
+            !rep.is_match_empty() && rep.hir.is_anchored_end(),
+        );
+        info.set_line_anchored_start(
+            !rep.is_match_empty() && rep.hir.is_anchored_start(),
+        );
+        info.set_line_anchored_end(
+            !rep.is_match_empty() && rep.hir.is_anchored_end(),
+        );
+        info.set_any_anchored_start(rep.hir.is_any_anchored_start());
+        info.set_any_anchored_end(rep.hir.is_any_anchored_end());
+        info.set_match_empty(rep.is_match_empty() || rep.hir.is_match_empty());
+        info.set_literal(false);
+        info.set_alternation_literal(false);
+        Hir { kind: HirKind::Repetition(rep), info }
+    }
+
+    /// Creates a group HIR expression.
+    pub fn group(group: Group) -> Hir {
+        let mut info = HirInfo::new();
+        info.set_always_utf8(group.hir.is_always_utf8());
+        info.set_all_assertions(group.hir.is_all_assertions());
+        info.set_anchored_start(group.hir.is_anchored_start());
+        info.set_anchored_end(group.hir.is_anchored_end());
+        info.set_line_anchored_start(group.hir.is_line_anchored_start());
+        info.set_line_anchored_end(group.hir.is_line_anchored_end());
+        info.set_any_anchored_start(group.hir.is_any_anchored_start());
+        info.set_any_anchored_end(group.hir.is_any_anchored_end());
+        info.set_match_empty(group.hir.is_match_empty());
+        info.set_literal(false);
+        info.set_alternation_literal(false);
+        Hir { kind: HirKind::Group(group), info }
+    }
+
+    /// Returns the concatenation of the given expressions.
+    ///
+    /// This flattens the concatenation as appropriate.
+    pub fn concat(mut exprs: Vec<Hir>) -> Hir {
+        match exprs.len() {
+            0 => Hir::empty(),
+            1 => exprs.pop().unwrap(),
+            _ => {
+                let mut info = HirInfo::new();
+                info.set_always_utf8(true);
+                info.set_all_assertions(true);
+                info.set_any_anchored_start(false);
+                info.set_any_anchored_end(false);
+                info.set_match_empty(true);
+                info.set_literal(true);
+                info.set_alternation_literal(true);
+
+                // Some attributes require analyzing all sub-expressions.
+                for e in &exprs {
+                    let x = info.is_always_utf8() && e.is_always_utf8();
+                    info.set_always_utf8(x);
+
+                    let x = info.is_all_assertions() && e.is_all_assertions();
+                    info.set_all_assertions(x);
+
+                    let x = info.is_any_anchored_start()
+                        || e.is_any_anchored_start();
+                    info.set_any_anchored_start(x);
+
+                    let x =
+                        info.is_any_anchored_end() || e.is_any_anchored_end();
+                    info.set_any_anchored_end(x);
+
+                    let x = info.is_match_empty() && e.is_match_empty();
+                    info.set_match_empty(x);
+
+                    let x = info.is_literal() && e.is_literal();
+                    info.set_literal(x);
+
+                    let x = info.is_alternation_literal()
+                        && e.is_alternation_literal();
+                    info.set_alternation_literal(x);
+                }
+                // Anchored attributes require something slightly more
+                // sophisticated. Normally, WLOG, to determine whether an
+                // expression is anchored to the start, we'd only need to check
+                // the first expression of a concatenation. However,
+                // expressions like `$\b^` are still anchored to the start,
+                // but the first expression in the concatenation *isn't*
+                // anchored to the start. So the "first" expression to look at
+                // is actually one that is either not an assertion or is
+                // specifically the StartText assertion.
+                info.set_anchored_start(
+                    exprs
+                        .iter()
+                        .take_while(|e| {
+                            e.is_anchored_start() || e.is_all_assertions()
+                        })
+                        .any(|e| e.is_anchored_start()),
+                );
+                // Similarly for the end anchor, but in reverse.
+                info.set_anchored_end(
+                    exprs
+                        .iter()
+                        .rev()
+                        .take_while(|e| {
+                            e.is_anchored_end() || e.is_all_assertions()
+                        })
+                        .any(|e| e.is_anchored_end()),
+                );
+                // Repeat the process for line anchors.
+                info.set_line_anchored_start(
+                    exprs
+                        .iter()
+                        .take_while(|e| {
+                            e.is_line_anchored_start() || e.is_all_assertions()
+                        })
+                        .any(|e| e.is_line_anchored_start()),
+                );
+                info.set_line_anchored_end(
+                    exprs
+                        .iter()
+                        .rev()
+                        .take_while(|e| {
+                            e.is_line_anchored_end() || e.is_all_assertions()
+                        })
+                        .any(|e| e.is_line_anchored_end()),
+                );
+                Hir { kind: HirKind::Concat(exprs), info }
+            }
+        }
+    }
+
+    /// Returns the alternation of the given expressions.
+    ///
+    /// This flattens the alternation as appropriate.
+    pub fn alternation(mut exprs: Vec<Hir>) -> Hir {
+        match exprs.len() {
+            0 => Hir::empty(),
+            1 => exprs.pop().unwrap(),
+            _ => {
+                let mut info = HirInfo::new();
+                info.set_always_utf8(true);
+                info.set_all_assertions(true);
+                info.set_anchored_start(true);
+                info.set_anchored_end(true);
+                info.set_line_anchored_start(true);
+                info.set_line_anchored_end(true);
+                info.set_any_anchored_start(false);
+                info.set_any_anchored_end(false);
+                info.set_match_empty(false);
+                info.set_literal(false);
+                info.set_alternation_literal(true);
+
+                // Some attributes require analyzing all sub-expressions.
+                for e in &exprs {
+                    let x = info.is_always_utf8() && e.is_always_utf8();
+                    info.set_always_utf8(x);
+
+                    let x = info.is_all_assertions() && e.is_all_assertions();
+                    info.set_all_assertions(x);
+
+                    let x = info.is_anchored_start() && e.is_anchored_start();
+                    info.set_anchored_start(x);
+
+                    let x = info.is_anchored_end() && e.is_anchored_end();
+                    info.set_anchored_end(x);
+
+                    let x = info.is_line_anchored_start()
+                        && e.is_line_anchored_start();
+                    info.set_line_anchored_start(x);
+
+                    let x = info.is_line_anchored_end()
+                        && e.is_line_anchored_end();
+                    info.set_line_anchored_end(x);
+
+                    let x = info.is_any_anchored_start()
+                        || e.is_any_anchored_start();
+                    info.set_any_anchored_start(x);
+
+                    let x =
+                        info.is_any_anchored_end() || e.is_any_anchored_end();
+                    info.set_any_anchored_end(x);
+
+                    let x = info.is_match_empty() || e.is_match_empty();
+                    info.set_match_empty(x);
+
+                    let x = info.is_alternation_literal() && e.is_literal();
+                    info.set_alternation_literal(x);
+                }
+                Hir { kind: HirKind::Alternation(exprs), info }
+            }
+        }
+    }
+
+    /// Build an HIR expression for `.`.
+    ///
+    /// A `.` expression matches any character except for `\n`. To build an
+    /// expression that matches any character, including `\n`, use the `any`
+    /// method.
+    ///
+    /// If `bytes` is `true`, then this assumes characters are limited to a
+    /// single byte.
+    pub fn dot(bytes: bool) -> Hir {
+        if bytes {
+            let mut cls = ClassBytes::empty();
+            cls.push(ClassBytesRange::new(b'\0', b'\x09'));
+            cls.push(ClassBytesRange::new(b'\x0B', b'\xFF'));
+            Hir::class(Class::Bytes(cls))
+        } else {
+            let mut cls = ClassUnicode::empty();
+            cls.push(ClassUnicodeRange::new('\0', '\x09'));
+            cls.push(ClassUnicodeRange::new('\x0B', '\u{10FFFF}'));
+            Hir::class(Class::Unicode(cls))
+        }
+    }
+
+    /// Build an HIR expression for `(?s).`.
+    ///
+    /// A `(?s).` expression matches any character, including `\n`. To build an
+    /// expression that matches any character except for `\n`, then use the
+    /// `dot` method.
+    ///
+    /// If `bytes` is `true`, then this assumes characters are limited to a
+    /// single byte.
+    pub fn any(bytes: bool) -> Hir {
+        if bytes {
+            let mut cls = ClassBytes::empty();
+            cls.push(ClassBytesRange::new(b'\0', b'\xFF'));
+            Hir::class(Class::Bytes(cls))
+        } else {
+            let mut cls = ClassUnicode::empty();
+            cls.push(ClassUnicodeRange::new('\0', '\u{10FFFF}'));
+            Hir::class(Class::Unicode(cls))
+        }
+    }
+
+    /// Return true if and only if this HIR will always match valid UTF-8.
+    ///
+    /// When this returns false, then it is possible for this HIR expression
+    /// to match invalid UTF-8.
+    pub fn is_always_utf8(&self) -> bool {
+        self.info.is_always_utf8()
+    }
+
+    /// Returns true if and only if this entire HIR expression is made up of
+    /// zero-width assertions.
+    ///
+    /// This includes expressions like `^$\b\A\z` and even `((\b)+())*^`, but
+    /// not `^a`.
+    pub fn is_all_assertions(&self) -> bool {
+        self.info.is_all_assertions()
+    }
+
+    /// Return true if and only if this HIR is required to match from the
+    /// beginning of text. This includes expressions like `^foo`, `^(foo|bar)`,
+    /// `^foo|^bar` but not `^foo|bar`.
+    pub fn is_anchored_start(&self) -> bool {
+        self.info.is_anchored_start()
+    }
+
+    /// Return true if and only if this HIR is required to match at the end
+    /// of text. This includes expressions like `foo$`, `(foo|bar)$`,
+    /// `foo$|bar$` but not `foo$|bar`.
+    pub fn is_anchored_end(&self) -> bool {
+        self.info.is_anchored_end()
+    }
+
+    /// Return true if and only if this HIR is required to match from the
+    /// beginning of text or the beginning of a line. This includes expressions
+    /// like `^foo`, `(?m)^foo`, `^(foo|bar)`, `^(foo|bar)`, `(?m)^foo|^bar`
+    /// but not `^foo|bar` or `(?m)^foo|bar`.
+    ///
+    /// Note that if `is_anchored_start` is `true`, then
+    /// `is_line_anchored_start` will also be `true`. The reverse implication
+    /// is not true. For example, `(?m)^foo` is line anchored, but not
+    /// `is_anchored_start`.
+    pub fn is_line_anchored_start(&self) -> bool {
+        self.info.is_line_anchored_start()
+    }
+
+    /// Return true if and only if this HIR is required to match at the
+    /// end of text or the end of a line. This includes expressions like
+    /// `foo$`, `(?m)foo$`, `(foo|bar)$`, `(?m)(foo|bar)$`, `foo$|bar$`,
+    /// `(?m)(foo|bar)$`, but not `foo$|bar` or `(?m)foo$|bar`.
+    ///
+    /// Note that if `is_anchored_end` is `true`, then
+    /// `is_line_anchored_end` will also be `true`. The reverse implication
+    /// is not true. For example, `(?m)foo$` is line anchored, but not
+    /// `is_anchored_end`.
+    pub fn is_line_anchored_end(&self) -> bool {
+        self.info.is_line_anchored_end()
+    }
+
+    /// Return true if and only if this HIR contains any sub-expression that
+    /// is required to match at the beginning of text. Specifically, this
+    /// returns true if the `^` symbol (when multiline mode is disabled) or the
+    /// `\A` escape appear anywhere in the regex.
+    pub fn is_any_anchored_start(&self) -> bool {
+        self.info.is_any_anchored_start()
+    }
+
+    /// Return true if and only if this HIR contains any sub-expression that is
+    /// required to match at the end of text. Specifically, this returns true
+    /// if the `$` symbol (when multiline mode is disabled) or the `\z` escape
+    /// appear anywhere in the regex.
+    pub fn is_any_anchored_end(&self) -> bool {
+        self.info.is_any_anchored_end()
+    }
+
+    /// Return true if and only if the empty string is part of the language
+    /// matched by this regular expression.
+    ///
+    /// This includes `a*`, `a?b*`, `a{0}`, `()`, `()+`, `^$`, `a|b?`, `\b`
+    /// and `\B`, but not `a` or `a+`.
+    pub fn is_match_empty(&self) -> bool {
+        self.info.is_match_empty()
+    }
+
+    /// Return true if and only if this HIR is a simple literal. This is only
+    /// true when this HIR expression is either itself a `Literal` or a
+    /// concatenation of only `Literal`s.
+    ///
+    /// For example, `f` and `foo` are literals, but `f+`, `(foo)`, `foo()`,
+    /// `` are not (even though that contain sub-expressions that are literals).
+    pub fn is_literal(&self) -> bool {
+        self.info.is_literal()
+    }
+
+    /// Return true if and only if this HIR is either a simple literal or an
+    /// alternation of simple literals. This is only
+    /// true when this HIR expression is either itself a `Literal` or a
+    /// concatenation of only `Literal`s or an alternation of only `Literal`s.
+    ///
+    /// For example, `f`, `foo`, `a|b|c`, and `foo|bar|baz` are alternation
+    /// literals, but `f+`, `(foo)`, `foo()`, ``
+    /// are not (even though that contain sub-expressions that are literals).
+    pub fn is_alternation_literal(&self) -> bool {
+        self.info.is_alternation_literal()
+    }
+}
+
+impl HirKind {
+    /// Return true if and only if this HIR is the empty regular expression.
+    ///
+    /// Note that this is not defined inductively. That is, it only tests if
+    /// this kind is the `Empty` variant. To get the inductive definition,
+    /// use the `is_match_empty` method on [`Hir`](struct.Hir.html).
+    pub fn is_empty(&self) -> bool {
+        match *self {
+            HirKind::Empty => true,
+            _ => false,
+        }
+    }
+
+    /// Returns true if and only if this kind has any (including possibly
+    /// empty) subexpressions.
+    pub fn has_subexprs(&self) -> bool {
+        match *self {
+            HirKind::Empty
+            | HirKind::Literal(_)
+            | HirKind::Class(_)
+            | HirKind::Anchor(_)
+            | HirKind::WordBoundary(_) => false,
+            HirKind::Group(_)
+            | HirKind::Repetition(_)
+            | HirKind::Concat(_)
+            | HirKind::Alternation(_) => true,
+        }
+    }
+}
+
+/// Print a display representation of this Hir.
+///
+/// The result of this is a valid regular expression pattern string.
+///
+/// This implementation uses constant stack space and heap space proportional
+/// to the size of the `Hir`.
+impl fmt::Display for Hir {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use crate::hir::print::Printer;
+        Printer::new().print(self, f)
+    }
+}
+
+/// The high-level intermediate representation of a literal.
+///
+/// A literal corresponds to a single character, where a character is either
+/// defined by a Unicode scalar value or an arbitrary byte. Unicode characters
+/// are preferred whenever possible. In particular, a `Byte` variant is only
+/// ever produced when it could match invalid UTF-8.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum Literal {
+    /// A single character represented by a Unicode scalar value.
+    Unicode(char),
+    /// A single character represented by an arbitrary byte.
+    Byte(u8),
+}
+
+impl Literal {
+    /// Returns true if and only if this literal corresponds to a Unicode
+    /// scalar value.
+    pub fn is_unicode(&self) -> bool {
+        match *self {
+            Literal::Unicode(_) => true,
+            Literal::Byte(b) if b <= 0x7F => true,
+            Literal::Byte(_) => false,
+        }
+    }
+}
+
+/// The high-level intermediate representation of a character class.
+///
+/// A character class corresponds to a set of characters. A character is either
+/// defined by a Unicode scalar value or a byte. Unicode characters are used
+/// by default, while bytes are used when Unicode mode (via the `u` flag) is
+/// disabled.
+///
+/// A character class, regardless of its character type, is represented by a
+/// sequence of non-overlapping non-adjacent ranges of characters.
+///
+/// Note that unlike [`Literal`](enum.Literal.html), a `Bytes` variant may
+/// be produced even when it exclusively matches valid UTF-8. This is because
+/// a `Bytes` variant represents an intention by the author of the regular
+/// expression to disable Unicode mode, which in turn impacts the semantics of
+/// case insensitive matching. For example, `(?i)k` and `(?i-u)k` will not
+/// match the same set of strings.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum Class {
+    /// A set of characters represented by Unicode scalar values.
+    Unicode(ClassUnicode),
+    /// A set of characters represented by arbitrary bytes (one byte per
+    /// character).
+    Bytes(ClassBytes),
+}
+
+impl Class {
+    /// Apply Unicode simple case folding to this character class, in place.
+    /// The character class will be expanded to include all simple case folded
+    /// character variants.
+    ///
+    /// If this is a byte oriented character class, then this will be limited
+    /// to the ASCII ranges `A-Z` and `a-z`.
+    pub fn case_fold_simple(&mut self) {
+        match *self {
+            Class::Unicode(ref mut x) => x.case_fold_simple(),
+            Class::Bytes(ref mut x) => x.case_fold_simple(),
+        }
+    }
+
+    /// Negate this character class in place.
+    ///
+    /// After completion, this character class will contain precisely the
+    /// characters that weren't previously in the class.
+    pub fn negate(&mut self) {
+        match *self {
+            Class::Unicode(ref mut x) => x.negate(),
+            Class::Bytes(ref mut x) => x.negate(),
+        }
+    }
+
+    /// Returns true if and only if this character class will only ever match
+    /// valid UTF-8.
+    ///
+    /// A character class can match invalid UTF-8 only when the following
+    /// conditions are met:
+    ///
+    /// 1. The translator was configured to permit generating an expression
+    ///    that can match invalid UTF-8. (By default, this is disabled.)
+    /// 2. Unicode mode (via the `u` flag) was disabled either in the concrete
+    ///    syntax or in the parser builder. By default, Unicode mode is
+    ///    enabled.
+    pub fn is_always_utf8(&self) -> bool {
+        match *self {
+            Class::Unicode(_) => true,
+            Class::Bytes(ref x) => x.is_all_ascii(),
+        }
+    }
+}
+
+/// A set of characters represented by Unicode scalar values.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ClassUnicode {
+    set: IntervalSet<ClassUnicodeRange>,
+}
+
+impl ClassUnicode {
+    /// Create a new class from a sequence of ranges.
+    ///
+    /// The given ranges do not need to be in any specific order, and ranges
+    /// may overlap.
+    pub fn new<I>(ranges: I) -> ClassUnicode
+    where
+        I: IntoIterator<Item = ClassUnicodeRange>,
+    {
+        ClassUnicode { set: IntervalSet::new(ranges) }
+    }
+
+    /// Create a new class with no ranges.
+    pub fn empty() -> ClassUnicode {
+        ClassUnicode::new(vec![])
+    }
+
+    /// Add a new range to this set.
+    pub fn push(&mut self, range: ClassUnicodeRange) {
+        self.set.push(range);
+    }
+
+    /// Return an iterator over all ranges in this class.
+    ///
+    /// The iterator yields ranges in ascending order.
+    pub fn iter(&self) -> ClassUnicodeIter<'_> {
+        ClassUnicodeIter(self.set.iter())
+    }
+
+    /// Return the underlying ranges as a slice.
+    pub fn ranges(&self) -> &[ClassUnicodeRange] {
+        self.set.intervals()
+    }
+
+    /// Expand this character class such that it contains all case folded
+    /// characters, according to Unicode's "simple" mapping. For example, if
+    /// this class consists of the range `a-z`, then applying case folding will
+    /// result in the class containing both the ranges `a-z` and `A-Z`.
+    ///
+    /// # Panics
+    ///
+    /// This routine panics when the case mapping data necessary for this
+    /// routine to complete is unavailable. This occurs when the `unicode-case`
+    /// feature is not enabled.
+    ///
+    /// Callers should prefer using `try_case_fold_simple` instead, which will
+    /// return an error instead of panicking.
+    pub fn case_fold_simple(&mut self) {
+        self.set
+            .case_fold_simple()
+            .expect("unicode-case feature must be enabled");
+    }
+
+    /// Expand this character class such that it contains all case folded
+    /// characters, according to Unicode's "simple" mapping. For example, if
+    /// this class consists of the range `a-z`, then applying case folding will
+    /// result in the class containing both the ranges `a-z` and `A-Z`.
+    ///
+    /// # Error
+    ///
+    /// This routine returns an error when the case mapping data necessary
+    /// for this routine to complete is unavailable. This occurs when the
+    /// `unicode-case` feature is not enabled.
+    pub fn try_case_fold_simple(
+        &mut self,
+    ) -> result::Result<(), CaseFoldError> {
+        self.set.case_fold_simple()
+    }
+
+    /// Negate this character class.
+    ///
+    /// For all `c` where `c` is a Unicode scalar value, if `c` was in this
+    /// set, then it will not be in this set after negation.
+    pub fn negate(&mut self) {
+        self.set.negate();
+    }
+
+    /// Union this character class with the given character class, in place.
+    pub fn union(&mut self, other: &ClassUnicode) {
+        self.set.union(&other.set);
+    }
+
+    /// Intersect this character class with the given character class, in
+    /// place.
+    pub fn intersect(&mut self, other: &ClassUnicode) {
+        self.set.intersect(&other.set);
+    }
+
+    /// Subtract the given character class from this character class, in place.
+    pub fn difference(&mut self, other: &ClassUnicode) {
+        self.set.difference(&other.set);
+    }
+
+    /// Compute the symmetric difference of the given character classes, in
+    /// place.
+    ///
+    /// This computes the symmetric difference of two character classes. This
+    /// removes all elements in this class that are also in the given class,
+    /// but all adds all elements from the given class that aren't in this
+    /// class. That is, the class will contain all elements in either class,
+    /// but will not contain any elements that are in both classes.
+    pub fn symmetric_difference(&mut self, other: &ClassUnicode) {
+        self.set.symmetric_difference(&other.set);
+    }
+
+    /// Returns true if and only if this character class will either match
+    /// nothing or only ASCII bytes. Stated differently, this returns false
+    /// if and only if this class contains a non-ASCII codepoint.
+    pub fn is_all_ascii(&self) -> bool {
+        self.set.intervals().last().map_or(true, |r| r.end <= '\x7F')
+    }
+}
+
+/// An iterator over all ranges in a Unicode character class.
+///
+/// The lifetime `'a` refers to the lifetime of the underlying class.
+#[derive(Debug)]
+pub struct ClassUnicodeIter<'a>(IntervalSetIter<'a, ClassUnicodeRange>);
+
+impl<'a> Iterator for ClassUnicodeIter<'a> {
+    type Item = &'a ClassUnicodeRange;
+
+    fn next(&mut self) -> Option<&'a ClassUnicodeRange> {
+        self.0.next()
+    }
+}
+
+/// A single range of characters represented by Unicode scalar values.
+///
+/// The range is closed. That is, the start and end of the range are included
+/// in the range.
+#[derive(Clone, Copy, Default, Eq, PartialEq, PartialOrd, Ord)]
+pub struct ClassUnicodeRange {
+    start: char,
+    end: char,
+}
+
+impl fmt::Debug for ClassUnicodeRange {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let start = if !self.start.is_whitespace() && !self.start.is_control()
+        {
+            self.start.to_string()
+        } else {
+            format!("0x{:X}", self.start as u32)
+        };
+        let end = if !self.end.is_whitespace() && !self.end.is_control() {
+            self.end.to_string()
+        } else {
+            format!("0x{:X}", self.end as u32)
+        };
+        f.debug_struct("ClassUnicodeRange")
+            .field("start", &start)
+            .field("end", &end)
+            .finish()
+    }
+}
+
+impl Interval for ClassUnicodeRange {
+    type Bound = char;
+
+    #[inline]
+    fn lower(&self) -> char {
+        self.start
+    }
+    #[inline]
+    fn upper(&self) -> char {
+        self.end
+    }
+    #[inline]
+    fn set_lower(&mut self, bound: char) {
+        self.start = bound;
+    }
+    #[inline]
+    fn set_upper(&mut self, bound: char) {
+        self.end = bound;
+    }
+
+    /// Apply simple case folding to this Unicode scalar value range.
+    ///
+    /// Additional ranges are appended to the given vector. Canonical ordering
+    /// is *not* maintained in the given vector.
+    fn case_fold_simple(
+        &self,
+        ranges: &mut Vec<ClassUnicodeRange>,
+    ) -> Result<(), unicode::CaseFoldError> {
+        if !unicode::contains_simple_case_mapping(self.start, self.end)? {
+            return Ok(());
+        }
+        let start = self.start as u32;
+        let end = (self.end as u32).saturating_add(1);
+        let mut next_simple_cp = None;
+        for cp in (start..end).filter_map(char::from_u32) {
+            if next_simple_cp.map_or(false, |next| cp < next) {
+                continue;
+            }
+            let it = match unicode::simple_fold(cp)? {
+                Ok(it) => it,
+                Err(next) => {
+                    next_simple_cp = next;
+                    continue;
+                }
+            };
+            for cp_folded in it {
+                ranges.push(ClassUnicodeRange::new(cp_folded, cp_folded));
+            }
+        }
+        Ok(())
+    }
+}
+
+impl ClassUnicodeRange {
+    /// Create a new Unicode scalar value range for a character class.
+    ///
+    /// The returned range is always in a canonical form. That is, the range
+    /// returned always satisfies the invariant that `start <= end`.
+    pub fn new(start: char, end: char) -> ClassUnicodeRange {
+        ClassUnicodeRange::create(start, end)
+    }
+
+    /// Return the start of this range.
+    ///
+    /// The start of a range is always less than or equal to the end of the
+    /// range.
+    pub fn start(&self) -> char {
+        self.start
+    }
+
+    /// Return the end of this range.
+    ///
+    /// The end of a range is always greater than or equal to the start of the
+    /// range.
+    pub fn end(&self) -> char {
+        self.end
+    }
+}
+
+/// A set of characters represented by arbitrary bytes (where one byte
+/// corresponds to one character).
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ClassBytes {
+    set: IntervalSet<ClassBytesRange>,
+}
+
+impl ClassBytes {
+    /// Create a new class from a sequence of ranges.
+    ///
+    /// The given ranges do not need to be in any specific order, and ranges
+    /// may overlap.
+    pub fn new<I>(ranges: I) -> ClassBytes
+    where
+        I: IntoIterator<Item = ClassBytesRange>,
+    {
+        ClassBytes { set: IntervalSet::new(ranges) }
+    }
+
+    /// Create a new class with no ranges.
+    pub fn empty() -> ClassBytes {
+        ClassBytes::new(vec![])
+    }
+
+    /// Add a new range to this set.
+    pub fn push(&mut self, range: ClassBytesRange) {
+        self.set.push(range);
+    }
+
+    /// Return an iterator over all ranges in this class.
+    ///
+    /// The iterator yields ranges in ascending order.
+    pub fn iter(&self) -> ClassBytesIter<'_> {
+        ClassBytesIter(self.set.iter())
+    }
+
+    /// Return the underlying ranges as a slice.
+    pub fn ranges(&self) -> &[ClassBytesRange] {
+        self.set.intervals()
+    }
+
+    /// Expand this character class such that it contains all case folded
+    /// characters. For example, if this class consists of the range `a-z`,
+    /// then applying case folding will result in the class containing both the
+    /// ranges `a-z` and `A-Z`.
+    ///
+    /// Note that this only applies ASCII case folding, which is limited to the
+    /// characters `a-z` and `A-Z`.
+    pub fn case_fold_simple(&mut self) {
+        self.set.case_fold_simple().expect("ASCII case folding never fails");
+    }
+
+    /// Negate this byte class.
+    ///
+    /// For all `b` where `b` is a any byte, if `b` was in this set, then it
+    /// will not be in this set after negation.
+    pub fn negate(&mut self) {
+        self.set.negate();
+    }
+
+    /// Union this byte class with the given byte class, in place.
+    pub fn union(&mut self, other: &ClassBytes) {
+        self.set.union(&other.set);
+    }
+
+    /// Intersect this byte class with the given byte class, in place.
+    pub fn intersect(&mut self, other: &ClassBytes) {
+        self.set.intersect(&other.set);
+    }
+
+    /// Subtract the given byte class from this byte class, in place.
+    pub fn difference(&mut self, other: &ClassBytes) {
+        self.set.difference(&other.set);
+    }
+
+    /// Compute the symmetric difference of the given byte classes, in place.
+    ///
+    /// This computes the symmetric difference of two byte classes. This
+    /// removes all elements in this class that are also in the given class,
+    /// but all adds all elements from the given class that aren't in this
+    /// class. That is, the class will contain all elements in either class,
+    /// but will not contain any elements that are in both classes.
+    pub fn symmetric_difference(&mut self, other: &ClassBytes) {
+        self.set.symmetric_difference(&other.set);
+    }
+
+    /// Returns true if and only if this character class will either match
+    /// nothing or only ASCII bytes. Stated differently, this returns false
+    /// if and only if this class contains a non-ASCII byte.
+    pub fn is_all_ascii(&self) -> bool {
+        self.set.intervals().last().map_or(true, |r| r.end <= 0x7F)
+    }
+}
+
+/// An iterator over all ranges in a byte character class.
+///
+/// The lifetime `'a` refers to the lifetime of the underlying class.
+#[derive(Debug)]
+pub struct ClassBytesIter<'a>(IntervalSetIter<'a, ClassBytesRange>);
+
+impl<'a> Iterator for ClassBytesIter<'a> {
+    type Item = &'a ClassBytesRange;
+
+    fn next(&mut self) -> Option<&'a ClassBytesRange> {
+        self.0.next()
+    }
+}
+
+/// A single range of characters represented by arbitrary bytes.
+///
+/// The range is closed. That is, the start and end of the range are included
+/// in the range.
+#[derive(Clone, Copy, Default, Eq, PartialEq, PartialOrd, Ord)]
+pub struct ClassBytesRange {
+    start: u8,
+    end: u8,
+}
+
+impl Interval for ClassBytesRange {
+    type Bound = u8;
+
+    #[inline]
+    fn lower(&self) -> u8 {
+        self.start
+    }
+    #[inline]
+    fn upper(&self) -> u8 {
+        self.end
+    }
+    #[inline]
+    fn set_lower(&mut self, bound: u8) {
+        self.start = bound;
+    }
+    #[inline]
+    fn set_upper(&mut self, bound: u8) {
+        self.end = bound;
+    }
+
+    /// Apply simple case folding to this byte range. Only ASCII case mappings
+    /// (for a-z) are applied.
+    ///
+    /// Additional ranges are appended to the given vector. Canonical ordering
+    /// is *not* maintained in the given vector.
+    fn case_fold_simple(
+        &self,
+        ranges: &mut Vec<ClassBytesRange>,
+    ) -> Result<(), unicode::CaseFoldError> {
+        if !ClassBytesRange::new(b'a', b'z').is_intersection_empty(self) {
+            let lower = cmp::max(self.start, b'a');
+            let upper = cmp::min(self.end, b'z');
+            ranges.push(ClassBytesRange::new(lower - 32, upper - 32));
+        }
+        if !ClassBytesRange::new(b'A', b'Z').is_intersection_empty(self) {
+            let lower = cmp::max(self.start, b'A');
+            let upper = cmp::min(self.end, b'Z');
+            ranges.push(ClassBytesRange::new(lower + 32, upper + 32));
+        }
+        Ok(())
+    }
+}
+
+impl ClassBytesRange {
+    /// Create a new byte range for a character class.
+    ///
+    /// The returned range is always in a canonical form. That is, the range
+    /// returned always satisfies the invariant that `start <= end`.
+    pub fn new(start: u8, end: u8) -> ClassBytesRange {
+        ClassBytesRange::create(start, end)
+    }
+
+    /// Return the start of this range.
+    ///
+    /// The start of a range is always less than or equal to the end of the
+    /// range.
+    pub fn start(&self) -> u8 {
+        self.start
+    }
+
+    /// Return the end of this range.
+    ///
+    /// The end of a range is always greater than or equal to the start of the
+    /// range.
+    pub fn end(&self) -> u8 {
+        self.end
+    }
+}
+
+impl fmt::Debug for ClassBytesRange {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut debug = f.debug_struct("ClassBytesRange");
+        if self.start <= 0x7F {
+            debug.field("start", &(self.start as char));
+        } else {
+            debug.field("start", &self.start);
+        }
+        if self.end <= 0x7F {
+            debug.field("end", &(self.end as char));
+        } else {
+            debug.field("end", &self.end);
+        }
+        debug.finish()
+    }
+}
+
+/// The high-level intermediate representation for an anchor assertion.
+///
+/// A matching anchor assertion is always zero-length.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum Anchor {
+    /// Match the beginning of a line or the beginning of text. Specifically,
+    /// this matches at the starting position of the input, or at the position
+    /// immediately following a `\n` character.
+    StartLine,
+    /// Match the end of a line or the end of text. Specifically,
+    /// this matches at the end position of the input, or at the position
+    /// immediately preceding a `\n` character.
+    EndLine,
+    /// Match the beginning of text. Specifically, this matches at the starting
+    /// position of the input.
+    StartText,
+    /// Match the end of text. Specifically, this matches at the ending
+    /// position of the input.
+    EndText,
+}
+
+/// The high-level intermediate representation for a word-boundary assertion.
+///
+/// A matching word boundary assertion is always zero-length.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum WordBoundary {
+    /// Match a Unicode-aware word boundary. That is, this matches a position
+    /// where the left adjacent character and right adjacent character
+    /// correspond to a word and non-word or a non-word and word character.
+    Unicode,
+    /// Match a Unicode-aware negation of a word boundary.
+    UnicodeNegate,
+    /// Match an ASCII-only word boundary. That is, this matches a position
+    /// where the left adjacent character and right adjacent character
+    /// correspond to a word and non-word or a non-word and word character.
+    Ascii,
+    /// Match an ASCII-only negation of a word boundary.
+    AsciiNegate,
+}
+
+impl WordBoundary {
+    /// Returns true if and only if this word boundary assertion is negated.
+    pub fn is_negated(&self) -> bool {
+        match *self {
+            WordBoundary::Unicode | WordBoundary::Ascii => false,
+            WordBoundary::UnicodeNegate | WordBoundary::AsciiNegate => true,
+        }
+    }
+}
+
+/// The high-level intermediate representation for a group.
+///
+/// This represents one of three possible group types:
+///
+/// 1. A non-capturing group (e.g., `(?:expr)`).
+/// 2. A capturing group (e.g., `(expr)`).
+/// 3. A named capturing group (e.g., `(?P<name>expr)`).
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Group {
+    /// The kind of this group. If it is a capturing group, then the kind
+    /// contains the capture group index (and the name, if it is a named
+    /// group).
+    pub kind: GroupKind,
+    /// The expression inside the capturing group, which may be empty.
+    pub hir: Box<Hir>,
+}
+
+/// The kind of group.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum GroupKind {
+    /// A normal unnamed capturing group.
+    ///
+    /// The value is the capture index of the group.
+    CaptureIndex(u32),
+    /// A named capturing group.
+    CaptureName {
+        /// The name of the group.
+        name: String,
+        /// The capture index of the group.
+        index: u32,
+    },
+    /// A non-capturing group.
+    NonCapturing,
+}
+
+/// The high-level intermediate representation of a repetition operator.
+///
+/// A repetition operator permits the repetition of an arbitrary
+/// sub-expression.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Repetition {
+    /// The kind of this repetition operator.
+    pub kind: RepetitionKind,
+    /// Whether this repetition operator is greedy or not. A greedy operator
+    /// will match as much as it can. A non-greedy operator will match as
+    /// little as it can.
+    ///
+    /// Typically, operators are greedy by default and are only non-greedy when
+    /// a `?` suffix is used, e.g., `(expr)*` is greedy while `(expr)*?` is
+    /// not. However, this can be inverted via the `U` "ungreedy" flag.
+    pub greedy: bool,
+    /// The expression being repeated.
+    pub hir: Box<Hir>,
+}
+
+impl Repetition {
+    /// Returns true if and only if this repetition operator makes it possible
+    /// to match the empty string.
+    ///
+    /// Note that this is not defined inductively. For example, while `a*`
+    /// will report `true`, `()+` will not, even though `()` matches the empty
+    /// string and one or more occurrences of something that matches the empty
+    /// string will always match the empty string. In order to get the
+    /// inductive definition, see the corresponding method on
+    /// [`Hir`](struct.Hir.html).
+    pub fn is_match_empty(&self) -> bool {
+        match self.kind {
+            RepetitionKind::ZeroOrOne => true,
+            RepetitionKind::ZeroOrMore => true,
+            RepetitionKind::OneOrMore => false,
+            RepetitionKind::Range(RepetitionRange::Exactly(m)) => m == 0,
+            RepetitionKind::Range(RepetitionRange::AtLeast(m)) => m == 0,
+            RepetitionKind::Range(RepetitionRange::Bounded(m, _)) => m == 0,
+        }
+    }
+}
+
+/// The kind of a repetition operator.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum RepetitionKind {
+    /// Matches a sub-expression zero or one times.
+    ZeroOrOne,
+    /// Matches a sub-expression zero or more times.
+    ZeroOrMore,
+    /// Matches a sub-expression one or more times.
+    OneOrMore,
+    /// Matches a sub-expression within a bounded range of times.
+    Range(RepetitionRange),
+}
+
+/// The kind of a counted repetition operator.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum RepetitionRange {
+    /// Matches a sub-expression exactly this many times.
+    Exactly(u32),
+    /// Matches a sub-expression at least this many times.
+    AtLeast(u32),
+    /// Matches a sub-expression at least `m` times and at most `n` times.
+    Bounded(u32, u32),
+}
+
+/// A custom `Drop` impl is used for `HirKind` such that it uses constant stack
+/// space but heap space proportional to the depth of the total `Hir`.
+impl Drop for Hir {
+    fn drop(&mut self) {
+        use std::mem;
+
+        match *self.kind() {
+            HirKind::Empty
+            | HirKind::Literal(_)
+            | HirKind::Class(_)
+            | HirKind::Anchor(_)
+            | HirKind::WordBoundary(_) => return,
+            HirKind::Group(ref x) if !x.hir.kind.has_subexprs() => return,
+            HirKind::Repetition(ref x) if !x.hir.kind.has_subexprs() => return,
+            HirKind::Concat(ref x) if x.is_empty() => return,
+            HirKind::Alternation(ref x) if x.is_empty() => return,
+            _ => {}
+        }
+
+        let mut stack = vec![mem::replace(self, Hir::empty())];
+        while let Some(mut expr) = stack.pop() {
+            match expr.kind {
+                HirKind::Empty
+                | HirKind::Literal(_)
+                | HirKind::Class(_)
+                | HirKind::Anchor(_)
+                | HirKind::WordBoundary(_) => {}
+                HirKind::Group(ref mut x) => {
+                    stack.push(mem::replace(&mut x.hir, Hir::empty()));
+                }
+                HirKind::Repetition(ref mut x) => {
+                    stack.push(mem::replace(&mut x.hir, Hir::empty()));
+                }
+                HirKind::Concat(ref mut x) => {
+                    stack.extend(x.drain(..));
+                }
+                HirKind::Alternation(ref mut x) => {
+                    stack.extend(x.drain(..));
+                }
+            }
+        }
+    }
+}
+
+/// A type that documents various attributes of an HIR expression.
+///
+/// These attributes are typically defined inductively on the HIR.
+#[derive(Clone, Debug, Eq, PartialEq)]
+struct HirInfo {
+    /// Represent yes/no questions by a bitfield to conserve space, since
+    /// this is included in every HIR expression.
+    ///
+    /// If more attributes need to be added, it is OK to increase the size of
+    /// this as appropriate.
+    bools: u16,
+}
+
+// A simple macro for defining bitfield accessors/mutators.
+macro_rules! define_bool {
+    ($bit:expr, $is_fn_name:ident, $set_fn_name:ident) => {
+        fn $is_fn_name(&self) -> bool {
+            self.bools & (0b1 << $bit) > 0
+        }
+
+        fn $set_fn_name(&mut self, yes: bool) {
+            if yes {
+                self.bools |= 1 << $bit;
+            } else {
+                self.bools &= !(1 << $bit);
+            }
+        }
+    };
+}
+
+impl HirInfo {
+    fn new() -> HirInfo {
+        HirInfo { bools: 0 }
+    }
+
+    define_bool!(0, is_always_utf8, set_always_utf8);
+    define_bool!(1, is_all_assertions, set_all_assertions);
+    define_bool!(2, is_anchored_start, set_anchored_start);
+    define_bool!(3, is_anchored_end, set_anchored_end);
+    define_bool!(4, is_line_anchored_start, set_line_anchored_start);
+    define_bool!(5, is_line_anchored_end, set_line_anchored_end);
+    define_bool!(6, is_any_anchored_start, set_any_anchored_start);
+    define_bool!(7, is_any_anchored_end, set_any_anchored_end);
+    define_bool!(8, is_match_empty, set_match_empty);
+    define_bool!(9, is_literal, set_literal);
+    define_bool!(10, is_alternation_literal, set_alternation_literal);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn uclass(ranges: &[(char, char)]) -> ClassUnicode {
+        let ranges: Vec<ClassUnicodeRange> = ranges
+            .iter()
+            .map(|&(s, e)| ClassUnicodeRange::new(s, e))
+            .collect();
+        ClassUnicode::new(ranges)
+    }
+
+    fn bclass(ranges: &[(u8, u8)]) -> ClassBytes {
+        let ranges: Vec<ClassBytesRange> =
+            ranges.iter().map(|&(s, e)| ClassBytesRange::new(s, e)).collect();
+        ClassBytes::new(ranges)
+    }
+
+    fn uranges(cls: &ClassUnicode) -> Vec<(char, char)> {
+        cls.iter().map(|x| (x.start(), x.end())).collect()
+    }
+
+    #[cfg(feature = "unicode-case")]
+    fn ucasefold(cls: &ClassUnicode) -> ClassUnicode {
+        let mut cls_ = cls.clone();
+        cls_.case_fold_simple();
+        cls_
+    }
+
+    fn uunion(cls1: &ClassUnicode, cls2: &ClassUnicode) -> ClassUnicode {
+        let mut cls_ = cls1.clone();
+        cls_.union(cls2);
+        cls_
+    }
+
+    fn uintersect(cls1: &ClassUnicode, cls2: &ClassUnicode) -> ClassUnicode {
+        let mut cls_ = cls1.clone();
+        cls_.intersect(cls2);
+        cls_
+    }
+
+    fn udifference(cls1: &ClassUnicode, cls2: &ClassUnicode) -> ClassUnicode {
+        let mut cls_ = cls1.clone();
+        cls_.difference(cls2);
+        cls_
+    }
+
+    fn usymdifference(
+        cls1: &ClassUnicode,
+        cls2: &ClassUnicode,
+    ) -> ClassUnicode {
+        let mut cls_ = cls1.clone();
+        cls_.symmetric_difference(cls2);
+        cls_
+    }
+
+    fn unegate(cls: &ClassUnicode) -> ClassUnicode {
+        let mut cls_ = cls.clone();
+        cls_.negate();
+        cls_
+    }
+
+    fn branges(cls: &ClassBytes) -> Vec<(u8, u8)> {
+        cls.iter().map(|x| (x.start(), x.end())).collect()
+    }
+
+    fn bcasefold(cls: &ClassBytes) -> ClassBytes {
+        let mut cls_ = cls.clone();
+        cls_.case_fold_simple();
+        cls_
+    }
+
+    fn bunion(cls1: &ClassBytes, cls2: &ClassBytes) -> ClassBytes {
+        let mut cls_ = cls1.clone();
+        cls_.union(cls2);
+        cls_
+    }
+
+    fn bintersect(cls1: &ClassBytes, cls2: &ClassBytes) -> ClassBytes {
+        let mut cls_ = cls1.clone();
+        cls_.intersect(cls2);
+        cls_
+    }
+
+    fn bdifference(cls1: &ClassBytes, cls2: &ClassBytes) -> ClassBytes {
+        let mut cls_ = cls1.clone();
+        cls_.difference(cls2);
+        cls_
+    }
+
+    fn bsymdifference(cls1: &ClassBytes, cls2: &ClassBytes) -> ClassBytes {
+        let mut cls_ = cls1.clone();
+        cls_.symmetric_difference(cls2);
+        cls_
+    }
+
+    fn bnegate(cls: &ClassBytes) -> ClassBytes {
+        let mut cls_ = cls.clone();
+        cls_.negate();
+        cls_
+    }
+
+    #[test]
+    fn class_range_canonical_unicode() {
+        let range = ClassUnicodeRange::new('\u{00FF}', '\0');
+        assert_eq!('\0', range.start());
+        assert_eq!('\u{00FF}', range.end());
+    }
+
+    #[test]
+    fn class_range_canonical_bytes() {
+        let range = ClassBytesRange::new(b'\xFF', b'\0');
+        assert_eq!(b'\0', range.start());
+        assert_eq!(b'\xFF', range.end());
+    }
+
+    #[test]
+    fn class_canonicalize_unicode() {
+        let cls = uclass(&[('a', 'c'), ('x', 'z')]);
+        let expected = vec![('a', 'c'), ('x', 'z')];
+        assert_eq!(expected, uranges(&cls));
+
+        let cls = uclass(&[('x', 'z'), ('a', 'c')]);
+        let expected = vec![('a', 'c'), ('x', 'z')];
+        assert_eq!(expected, uranges(&cls));
+
+        let cls = uclass(&[('x', 'z'), ('w', 'y')]);
+        let expected = vec![('w', 'z')];
+        assert_eq!(expected, uranges(&cls));
+
+        let cls = uclass(&[
+            ('c', 'f'),
+            ('a', 'g'),
+            ('d', 'j'),
+            ('a', 'c'),
+            ('m', 'p'),
+            ('l', 's'),
+        ]);
+        let expected = vec![('a', 'j'), ('l', 's')];
+        assert_eq!(expected, uranges(&cls));
+
+        let cls = uclass(&[('x', 'z'), ('u', 'w')]);
+        let expected = vec![('u', 'z')];
+        assert_eq!(expected, uranges(&cls));
+
+        let cls = uclass(&[('\x00', '\u{10FFFF}'), ('\x00', '\u{10FFFF}')]);
+        let expected = vec![('\x00', '\u{10FFFF}')];
+        assert_eq!(expected, uranges(&cls));
+
+        let cls = uclass(&[('a', 'a'), ('b', 'b')]);
+        let expected = vec![('a', 'b')];
+        assert_eq!(expected, uranges(&cls));
+    }
+
+    #[test]
+    fn class_canonicalize_bytes() {
+        let cls = bclass(&[(b'a', b'c'), (b'x', b'z')]);
+        let expected = vec![(b'a', b'c'), (b'x', b'z')];
+        assert_eq!(expected, branges(&cls));
+
+        let cls = bclass(&[(b'x', b'z'), (b'a', b'c')]);
+        let expected = vec![(b'a', b'c'), (b'x', b'z')];
+        assert_eq!(expected, branges(&cls));
+
+        let cls = bclass(&[(b'x', b'z'), (b'w', b'y')]);
+        let expected = vec![(b'w', b'z')];
+        assert_eq!(expected, branges(&cls));
+
+        let cls = bclass(&[
+            (b'c', b'f'),
+            (b'a', b'g'),
+            (b'd', b'j'),
+            (b'a', b'c'),
+            (b'm', b'p'),
+            (b'l', b's'),
+        ]);
+        let expected = vec![(b'a', b'j'), (b'l', b's')];
+        assert_eq!(expected, branges(&cls));
+
+        let cls = bclass(&[(b'x', b'z'), (b'u', b'w')]);
+        let expected = vec![(b'u', b'z')];
+        assert_eq!(expected, branges(&cls));
+
+        let cls = bclass(&[(b'\x00', b'\xFF'), (b'\x00', b'\xFF')]);
+        let expected = vec![(b'\x00', b'\xFF')];
+        assert_eq!(expected, branges(&cls));
+
+        let cls = bclass(&[(b'a', b'a'), (b'b', b'b')]);
+        let expected = vec![(b'a', b'b')];
+        assert_eq!(expected, branges(&cls));
+    }
+
+    #[test]
+    #[cfg(feature = "unicode-case")]
+    fn class_case_fold_unicode() {
+        let cls = uclass(&[
+            ('C', 'F'),
+            ('A', 'G'),
+            ('D', 'J'),
+            ('A', 'C'),
+            ('M', 'P'),
+            ('L', 'S'),
+            ('c', 'f'),
+        ]);
+        let expected = uclass(&[
+            ('A', 'J'),
+            ('L', 'S'),
+            ('a', 'j'),
+            ('l', 's'),
+            ('\u{17F}', '\u{17F}'),
+        ]);
+        assert_eq!(expected, ucasefold(&cls));
+
+        let cls = uclass(&[('A', 'Z')]);
+        let expected = uclass(&[
+            ('A', 'Z'),
+            ('a', 'z'),
+            ('\u{17F}', '\u{17F}'),
+            ('\u{212A}', '\u{212A}'),
+        ]);
+        assert_eq!(expected, ucasefold(&cls));
+
+        let cls = uclass(&[('a', 'z')]);
+        let expected = uclass(&[
+            ('A', 'Z'),
+            ('a', 'z'),
+            ('\u{17F}', '\u{17F}'),
+            ('\u{212A}', '\u{212A}'),
+        ]);
+        assert_eq!(expected, ucasefold(&cls));
+
+        let cls = uclass(&[('A', 'A'), ('_', '_')]);
+        let expected = uclass(&[('A', 'A'), ('_', '_'), ('a', 'a')]);
+        assert_eq!(expected, ucasefold(&cls));
+
+        let cls = uclass(&[('A', 'A'), ('=', '=')]);
+        let expected = uclass(&[('=', '='), ('A', 'A'), ('a', 'a')]);
+        assert_eq!(expected, ucasefold(&cls));
+
+        let cls = uclass(&[('\x00', '\x10')]);
+        assert_eq!(cls, ucasefold(&cls));
+
+        let cls = uclass(&[('k', 'k')]);
+        let expected =
+            uclass(&[('K', 'K'), ('k', 'k'), ('\u{212A}', '\u{212A}')]);
+        assert_eq!(expected, ucasefold(&cls));
+
+        let cls = uclass(&[('@', '@')]);
+        assert_eq!(cls, ucasefold(&cls));
+    }
+
+    #[test]
+    #[cfg(not(feature = "unicode-case"))]
+    fn class_case_fold_unicode_disabled() {
+        let mut cls = uclass(&[
+            ('C', 'F'),
+            ('A', 'G'),
+            ('D', 'J'),
+            ('A', 'C'),
+            ('M', 'P'),
+            ('L', 'S'),
+            ('c', 'f'),
+        ]);
+        assert!(cls.try_case_fold_simple().is_err());
+    }
+
+    #[test]
+    #[should_panic]
+    #[cfg(not(feature = "unicode-case"))]
+    fn class_case_fold_unicode_disabled_panics() {
+        let mut cls = uclass(&[
+            ('C', 'F'),
+            ('A', 'G'),
+            ('D', 'J'),
+            ('A', 'C'),
+            ('M', 'P'),
+            ('L', 'S'),
+            ('c', 'f'),
+        ]);
+        cls.case_fold_simple();
+    }
+
+    #[test]
+    fn class_case_fold_bytes() {
+        let cls = bclass(&[
+            (b'C', b'F'),
+            (b'A', b'G'),
+            (b'D', b'J'),
+            (b'A', b'C'),
+            (b'M', b'P'),
+            (b'L', b'S'),
+            (b'c', b'f'),
+        ]);
+        let expected =
+            bclass(&[(b'A', b'J'), (b'L', b'S'), (b'a', b'j'), (b'l', b's')]);
+        assert_eq!(expected, bcasefold(&cls));
+
+        let cls = bclass(&[(b'A', b'Z')]);
+        let expected = bclass(&[(b'A', b'Z'), (b'a', b'z')]);
+        assert_eq!(expected, bcasefold(&cls));
+
+        let cls = bclass(&[(b'a', b'z')]);
+        let expected = bclass(&[(b'A', b'Z'), (b'a', b'z')]);
+        assert_eq!(expected, bcasefold(&cls));
+
+        let cls = bclass(&[(b'A', b'A'), (b'_', b'_')]);
+        let expected = bclass(&[(b'A', b'A'), (b'_', b'_'), (b'a', b'a')]);
+        assert_eq!(expected, bcasefold(&cls));
+
+        let cls = bclass(&[(b'A', b'A'), (b'=', b'=')]);
+        let expected = bclass(&[(b'=', b'='), (b'A', b'A'), (b'a', b'a')]);
+        assert_eq!(expected, bcasefold(&cls));
+
+        let cls = bclass(&[(b'\x00', b'\x10')]);
+        assert_eq!(cls, bcasefold(&cls));
+
+        let cls = bclass(&[(b'k', b'k')]);
+        let expected = bclass(&[(b'K', b'K'), (b'k', b'k')]);
+        assert_eq!(expected, bcasefold(&cls));
+
+        let cls = bclass(&[(b'@', b'@')]);
+        assert_eq!(cls, bcasefold(&cls));
+    }
+
+    #[test]
+    fn class_negate_unicode() {
+        let cls = uclass(&[('a', 'a')]);
+        let expected = uclass(&[('\x00', '\x60'), ('\x62', '\u{10FFFF}')]);
+        assert_eq!(expected, unegate(&cls));
+
+        let cls = uclass(&[('a', 'a'), ('b', 'b')]);
+        let expected = uclass(&[('\x00', '\x60'), ('\x63', '\u{10FFFF}')]);
+        assert_eq!(expected, unegate(&cls));
+
+        let cls = uclass(&[('a', 'c'), ('x', 'z')]);
+        let expected = uclass(&[
+            ('\x00', '\x60'),
+            ('\x64', '\x77'),
+            ('\x7B', '\u{10FFFF}'),
+        ]);
+        assert_eq!(expected, unegate(&cls));
+
+        let cls = uclass(&[('\x00', 'a')]);
+        let expected = uclass(&[('\x62', '\u{10FFFF}')]);
+        assert_eq!(expected, unegate(&cls));
+
+        let cls = uclass(&[('a', '\u{10FFFF}')]);
+        let expected = uclass(&[('\x00', '\x60')]);
+        assert_eq!(expected, unegate(&cls));
+
+        let cls = uclass(&[('\x00', '\u{10FFFF}')]);
+        let expected = uclass(&[]);
+        assert_eq!(expected, unegate(&cls));
+
+        let cls = uclass(&[]);
+        let expected = uclass(&[('\x00', '\u{10FFFF}')]);
+        assert_eq!(expected, unegate(&cls));
+
+        let cls =
+            uclass(&[('\x00', '\u{10FFFD}'), ('\u{10FFFF}', '\u{10FFFF}')]);
+        let expected = uclass(&[('\u{10FFFE}', '\u{10FFFE}')]);
+        assert_eq!(expected, unegate(&cls));
+
+        let cls = uclass(&[('\x00', '\u{D7FF}')]);
+        let expected = uclass(&[('\u{E000}', '\u{10FFFF}')]);
+        assert_eq!(expected, unegate(&cls));
+
+        let cls = uclass(&[('\x00', '\u{D7FE}')]);
+        let expected = uclass(&[('\u{D7FF}', '\u{10FFFF}')]);
+        assert_eq!(expected, unegate(&cls));
+
+        let cls = uclass(&[('\u{E000}', '\u{10FFFF}')]);
+        let expected = uclass(&[('\x00', '\u{D7FF}')]);
+        assert_eq!(expected, unegate(&cls));
+
+        let cls = uclass(&[('\u{E001}', '\u{10FFFF}')]);
+        let expected = uclass(&[('\x00', '\u{E000}')]);
+        assert_eq!(expected, unegate(&cls));
+    }
+
+    #[test]
+    fn class_negate_bytes() {
+        let cls = bclass(&[(b'a', b'a')]);
+        let expected = bclass(&[(b'\x00', b'\x60'), (b'\x62', b'\xFF')]);
+        assert_eq!(expected, bnegate(&cls));
+
+        let cls = bclass(&[(b'a', b'a'), (b'b', b'b')]);
+        let expected = bclass(&[(b'\x00', b'\x60'), (b'\x63', b'\xFF')]);
+        assert_eq!(expected, bnegate(&cls));
+
+        let cls = bclass(&[(b'a', b'c'), (b'x', b'z')]);
+        let expected = bclass(&[
+            (b'\x00', b'\x60'),
+            (b'\x64', b'\x77'),
+            (b'\x7B', b'\xFF'),
+        ]);
+        assert_eq!(expected, bnegate(&cls));
+
+        let cls = bclass(&[(b'\x00', b'a')]);
+        let expected = bclass(&[(b'\x62', b'\xFF')]);
+        assert_eq!(expected, bnegate(&cls));
+
+        let cls = bclass(&[(b'a', b'\xFF')]);
+        let expected = bclass(&[(b'\x00', b'\x60')]);
+        assert_eq!(expected, bnegate(&cls));
+
+        let cls = bclass(&[(b'\x00', b'\xFF')]);
+        let expected = bclass(&[]);
+        assert_eq!(expected, bnegate(&cls));
+
+        let cls = bclass(&[]);
+        let expected = bclass(&[(b'\x00', b'\xFF')]);
+        assert_eq!(expected, bnegate(&cls));
+
+        let cls = bclass(&[(b'\x00', b'\xFD'), (b'\xFF', b'\xFF')]);
+        let expected = bclass(&[(b'\xFE', b'\xFE')]);
+        assert_eq!(expected, bnegate(&cls));
+    }
+
+    #[test]
+    fn class_union_unicode() {
+        let cls1 = uclass(&[('a', 'g'), ('m', 't'), ('A', 'C')]);
+        let cls2 = uclass(&[('a', 'z')]);
+        let expected = uclass(&[('a', 'z'), ('A', 'C')]);
+        assert_eq!(expected, uunion(&cls1, &cls2));
+    }
+
+    #[test]
+    fn class_union_bytes() {
+        let cls1 = bclass(&[(b'a', b'g'), (b'm', b't'), (b'A', b'C')]);
+        let cls2 = bclass(&[(b'a', b'z')]);
+        let expected = bclass(&[(b'a', b'z'), (b'A', b'C')]);
+        assert_eq!(expected, bunion(&cls1, &cls2));
+    }
+
+    #[test]
+    fn class_intersect_unicode() {
+        let cls1 = uclass(&[]);
+        let cls2 = uclass(&[('a', 'a')]);
+        let expected = uclass(&[]);
+        assert_eq!(expected, uintersect(&cls1, &cls2));
+
+        let cls1 = uclass(&[('a', 'a')]);
+        let cls2 = uclass(&[('a', 'a')]);
+        let expected = uclass(&[('a', 'a')]);
+        assert_eq!(expected, uintersect(&cls1, &cls2));
+
+        let cls1 = uclass(&[('a', 'a')]);
+        let cls2 = uclass(&[('b', 'b')]);
+        let expected = uclass(&[]);
+        assert_eq!(expected, uintersect(&cls1, &cls2));
+
+        let cls1 = uclass(&[('a', 'a')]);
+        let cls2 = uclass(&[('a', 'c')]);
+        let expected = uclass(&[('a', 'a')]);
+        assert_eq!(expected, uintersect(&cls1, &cls2));
+
+        let cls1 = uclass(&[('a', 'b')]);
+        let cls2 = uclass(&[('a', 'c')]);
+        let expected = uclass(&[('a', 'b')]);
+        assert_eq!(expected, uintersect(&cls1, &cls2));
+
+        let cls1 = uclass(&[('a', 'b')]);
+        let cls2 = uclass(&[('b', 'c')]);
+        let expected = uclass(&[('b', 'b')]);
+        assert_eq!(expected, uintersect(&cls1, &cls2));
+
+        let cls1 = uclass(&[('a', 'b')]);
+        let cls2 = uclass(&[('c', 'd')]);
+        let expected = uclass(&[]);
+        assert_eq!(expected, uintersect(&cls1, &cls2));
+
+        let cls1 = uclass(&[('b', 'c')]);
+        let cls2 = uclass(&[('a', 'd')]);
+        let expected = uclass(&[('b', 'c')]);
+        assert_eq!(expected, uintersect(&cls1, &cls2));
+
+        let cls1 = uclass(&[('a', 'b'), ('d', 'e'), ('g', 'h')]);
+        let cls2 = uclass(&[('a', 'h')]);
+        let expected = uclass(&[('a', 'b'), ('d', 'e'), ('g', 'h')]);
+        assert_eq!(expected, uintersect(&cls1, &cls2));
+
+        let cls1 = uclass(&[('a', 'b'), ('d', 'e'), ('g', 'h')]);
+        let cls2 = uclass(&[('a', 'b'), ('d', 'e'), ('g', 'h')]);
+        let expected = uclass(&[('a', 'b'), ('d', 'e'), ('g', 'h')]);
+        assert_eq!(expected, uintersect(&cls1, &cls2));
+
+        let cls1 = uclass(&[('a', 'b'), ('g', 'h')]);
+        let cls2 = uclass(&[('d', 'e'), ('k', 'l')]);
+        let expected = uclass(&[]);
+        assert_eq!(expected, uintersect(&cls1, &cls2));
+
+        let cls1 = uclass(&[('a', 'b'), ('d', 'e'), ('g', 'h')]);
+        let cls2 = uclass(&[('h', 'h')]);
+        let expected = uclass(&[('h', 'h')]);
+        assert_eq!(expected, uintersect(&cls1, &cls2));
+
+        let cls1 = uclass(&[('a', 'b'), ('e', 'f'), ('i', 'j')]);
+        let cls2 = uclass(&[('c', 'd'), ('g', 'h'), ('k', 'l')]);
+        let expected = uclass(&[]);
+        assert_eq!(expected, uintersect(&cls1, &cls2));
+
+        let cls1 = uclass(&[('a', 'b'), ('c', 'd'), ('e', 'f')]);
+        let cls2 = uclass(&[('b', 'c'), ('d', 'e'), ('f', 'g')]);
+        let expected = uclass(&[('b', 'f')]);
+        assert_eq!(expected, uintersect(&cls1, &cls2));
+    }
+
+    #[test]
+    fn class_intersect_bytes() {
+        let cls1 = bclass(&[]);
+        let cls2 = bclass(&[(b'a', b'a')]);
+        let expected = bclass(&[]);
+        assert_eq!(expected, bintersect(&cls1, &cls2));
+
+        let cls1 = bclass(&[(b'a', b'a')]);
+        let cls2 = bclass(&[(b'a', b'a')]);
+        let expected = bclass(&[(b'a', b'a')]);
+        assert_eq!(expected, bintersect(&cls1, &cls2));
+
+        let cls1 = bclass(&[(b'a', b'a')]);
+        let cls2 = bclass(&[(b'b', b'b')]);
+        let expected = bclass(&[]);
+        assert_eq!(expected, bintersect(&cls1, &cls2));
+
+        let cls1 = bclass(&[(b'a', b'a')]);
+        let cls2 = bclass(&[(b'a', b'c')]);
+        let expected = bclass(&[(b'a', b'a')]);
+        assert_eq!(expected, bintersect(&cls1, &cls2));
+
+        let cls1 = bclass(&[(b'a', b'b')]);
+        let cls2 = bclass(&[(b'a', b'c')]);
+        let expected = bclass(&[(b'a', b'b')]);
+        assert_eq!(expected, bintersect(&cls1, &cls2));
+
+        let cls1 = bclass(&[(b'a', b'b')]);
+        let cls2 = bclass(&[(b'b', b'c')]);
+        let expected = bclass(&[(b'b', b'b')]);
+        assert_eq!(expected, bintersect(&cls1, &cls2));
+
+        let cls1 = bclass(&[(b'a', b'b')]);
+        let cls2 = bclass(&[(b'c', b'd')]);
+        let expected = bclass(&[]);
+        assert_eq!(expected, bintersect(&cls1, &cls2));
+
+        let cls1 = bclass(&[(b'b', b'c')]);
+        let cls2 = bclass(&[(b'a', b'd')]);
+        let expected = bclass(&[(b'b', b'c')]);
+        assert_eq!(expected, bintersect(&cls1, &cls2));
+
+        let cls1 = bclass(&[(b'a', b'b'), (b'd', b'e'), (b'g', b'h')]);
+        let cls2 = bclass(&[(b'a', b'h')]);
+        let expected = bclass(&[(b'a', b'b'), (b'd', b'e'), (b'g', b'h')]);
+        assert_eq!(expected, bintersect(&cls1, &cls2));
+
+        let cls1 = bclass(&[(b'a', b'b'), (b'd', b'e'), (b'g', b'h')]);
+        let cls2 = bclass(&[(b'a', b'b'), (b'd', b'e'), (b'g', b'h')]);
+        let expected = bclass(&[(b'a', b'b'), (b'd', b'e'), (b'g', b'h')]);
+        assert_eq!(expected, bintersect(&cls1, &cls2));
+
+        let cls1 = bclass(&[(b'a', b'b'), (b'g', b'h')]);
+        let cls2 = bclass(&[(b'd', b'e'), (b'k', b'l')]);
+        let expected = bclass(&[]);
+        assert_eq!(expected, bintersect(&cls1, &cls2));
+
+        let cls1 = bclass(&[(b'a', b'b'), (b'd', b'e'), (b'g', b'h')]);
+        let cls2 = bclass(&[(b'h', b'h')]);
+        let expected = bclass(&[(b'h', b'h')]);
+        assert_eq!(expected, bintersect(&cls1, &cls2));
+
+        let cls1 = bclass(&[(b'a', b'b'), (b'e', b'f'), (b'i', b'j')]);
+        let cls2 = bclass(&[(b'c', b'd'), (b'g', b'h'), (b'k', b'l')]);
+        let expected = bclass(&[]);
+        assert_eq!(expected, bintersect(&cls1, &cls2));
+
+        let cls1 = bclass(&[(b'a', b'b'), (b'c', b'd'), (b'e', b'f')]);
+        let cls2 = bclass(&[(b'b', b'c'), (b'd', b'e'), (b'f', b'g')]);
+        let expected = bclass(&[(b'b', b'f')]);
+        assert_eq!(expected, bintersect(&cls1, &cls2));
+    }
+
+    #[test]
+    fn class_difference_unicode() {
+        let cls1 = uclass(&[('a', 'a')]);
+        let cls2 = uclass(&[('a', 'a')]);
+        let expected = uclass(&[]);
+        assert_eq!(expected, udifference(&cls1, &cls2));
+
+        let cls1 = uclass(&[('a', 'a')]);
+        let cls2 = uclass(&[]);
+        let expected = uclass(&[('a', 'a')]);
+        assert_eq!(expected, udifference(&cls1, &cls2));
+
+        let cls1 = uclass(&[]);
+        let cls2 = uclass(&[('a', 'a')]);
+        let expected = uclass(&[]);
+        assert_eq!(expected, udifference(&cls1, &cls2));
+
+        let cls1 = uclass(&[('a', 'z')]);
+        let cls2 = uclass(&[('a', 'a')]);
+        let expected = uclass(&[('b', 'z')]);
+        assert_eq!(expected, udifference(&cls1, &cls2));
+
+        let cls1 = uclass(&[('a', 'z')]);
+        let cls2 = uclass(&[('z', 'z')]);
+        let expected = uclass(&[('a', 'y')]);
+        assert_eq!(expected, udifference(&cls1, &cls2));
+
+        let cls1 = uclass(&[('a', 'z')]);
+        let cls2 = uclass(&[('m', 'm')]);
+        let expected = uclass(&[('a', 'l'), ('n', 'z')]);
+        assert_eq!(expected, udifference(&cls1, &cls2));
+
+        let cls1 = uclass(&[('a', 'c'), ('g', 'i'), ('r', 't')]);
+        let cls2 = uclass(&[('a', 'z')]);
+        let expected = uclass(&[]);
+        assert_eq!(expected, udifference(&cls1, &cls2));
+
+        let cls1 = uclass(&[('a', 'c'), ('g', 'i'), ('r', 't')]);
+        let cls2 = uclass(&[('d', 'v')]);
+        let expected = uclass(&[('a', 'c')]);
+        assert_eq!(expected, udifference(&cls1, &cls2));
+
+        let cls1 = uclass(&[('a', 'c'), ('g', 'i'), ('r', 't')]);
+        let cls2 = uclass(&[('b', 'g'), ('s', 'u')]);
+        let expected = uclass(&[('a', 'a'), ('h', 'i'), ('r', 'r')]);
+        assert_eq!(expected, udifference(&cls1, &cls2));
+
+        let cls1 = uclass(&[('a', 'c'), ('g', 'i'), ('r', 't')]);
+        let cls2 = uclass(&[('b', 'd'), ('e', 'g'), ('s', 'u')]);
+        let expected = uclass(&[('a', 'a'), ('h', 'i'), ('r', 'r')]);
+        assert_eq!(expected, udifference(&cls1, &cls2));
+
+        let cls1 = uclass(&[('x', 'z')]);
+        let cls2 = uclass(&[('a', 'c'), ('e', 'g'), ('s', 'u')]);
+        let expected = uclass(&[('x', 'z')]);
+        assert_eq!(expected, udifference(&cls1, &cls2));
+
+        let cls1 = uclass(&[('a', 'z')]);
+        let cls2 = uclass(&[('a', 'c'), ('e', 'g'), ('s', 'u')]);
+        let expected = uclass(&[('d', 'd'), ('h', 'r'), ('v', 'z')]);
+        assert_eq!(expected, udifference(&cls1, &cls2));
+    }
+
+    #[test]
+    fn class_difference_bytes() {
+        let cls1 = bclass(&[(b'a', b'a')]);
+        let cls2 = bclass(&[(b'a', b'a')]);
+        let expected = bclass(&[]);
+        assert_eq!(expected, bdifference(&cls1, &cls2));
+
+        let cls1 = bclass(&[(b'a', b'a')]);
+        let cls2 = bclass(&[]);
+        let expected = bclass(&[(b'a', b'a')]);
+        assert_eq!(expected, bdifference(&cls1, &cls2));
+
+        let cls1 = bclass(&[]);
+        let cls2 = bclass(&[(b'a', b'a')]);
+        let expected = bclass(&[]);
+        assert_eq!(expected, bdifference(&cls1, &cls2));
+
+        let cls1 = bclass(&[(b'a', b'z')]);
+        let cls2 = bclass(&[(b'a', b'a')]);
+        let expected = bclass(&[(b'b', b'z')]);
+        assert_eq!(expected, bdifference(&cls1, &cls2));
+
+        let cls1 = bclass(&[(b'a', b'z')]);
+        let cls2 = bclass(&[(b'z', b'z')]);
+        let expected = bclass(&[(b'a', b'y')]);
+        assert_eq!(expected, bdifference(&cls1, &cls2));
+
+        let cls1 = bclass(&[(b'a', b'z')]);
+        let cls2 = bclass(&[(b'm', b'm')]);
+        let expected = bclass(&[(b'a', b'l'), (b'n', b'z')]);
+        assert_eq!(expected, bdifference(&cls1, &cls2));
+
+        let cls1 = bclass(&[(b'a', b'c'), (b'g', b'i'), (b'r', b't')]);
+        let cls2 = bclass(&[(b'a', b'z')]);
+        let expected = bclass(&[]);
+        assert_eq!(expected, bdifference(&cls1, &cls2));
+
+        let cls1 = bclass(&[(b'a', b'c'), (b'g', b'i'), (b'r', b't')]);
+        let cls2 = bclass(&[(b'd', b'v')]);
+        let expected = bclass(&[(b'a', b'c')]);
+        assert_eq!(expected, bdifference(&cls1, &cls2));
+
+        let cls1 = bclass(&[(b'a', b'c'), (b'g', b'i'), (b'r', b't')]);
+        let cls2 = bclass(&[(b'b', b'g'), (b's', b'u')]);
+        let expected = bclass(&[(b'a', b'a'), (b'h', b'i'), (b'r', b'r')]);
+        assert_eq!(expected, bdifference(&cls1, &cls2));
+
+        let cls1 = bclass(&[(b'a', b'c'), (b'g', b'i'), (b'r', b't')]);
+        let cls2 = bclass(&[(b'b', b'd'), (b'e', b'g'), (b's', b'u')]);
+        let expected = bclass(&[(b'a', b'a'), (b'h', b'i'), (b'r', b'r')]);
+        assert_eq!(expected, bdifference(&cls1, &cls2));
+
+        let cls1 = bclass(&[(b'x', b'z')]);
+        let cls2 = bclass(&[(b'a', b'c'), (b'e', b'g'), (b's', b'u')]);
+        let expected = bclass(&[(b'x', b'z')]);
+        assert_eq!(expected, bdifference(&cls1, &cls2));
+
+        let cls1 = bclass(&[(b'a', b'z')]);
+        let cls2 = bclass(&[(b'a', b'c'), (b'e', b'g'), (b's', b'u')]);
+        let expected = bclass(&[(b'd', b'd'), (b'h', b'r'), (b'v', b'z')]);
+        assert_eq!(expected, bdifference(&cls1, &cls2));
+    }
+
+    #[test]
+    fn class_symmetric_difference_unicode() {
+        let cls1 = uclass(&[('a', 'm')]);
+        let cls2 = uclass(&[('g', 't')]);
+        let expected = uclass(&[('a', 'f'), ('n', 't')]);
+        assert_eq!(expected, usymdifference(&cls1, &cls2));
+    }
+
+    #[test]
+    fn class_symmetric_difference_bytes() {
+        let cls1 = bclass(&[(b'a', b'm')]);
+        let cls2 = bclass(&[(b'g', b't')]);
+        let expected = bclass(&[(b'a', b'f'), (b'n', b't')]);
+        assert_eq!(expected, bsymdifference(&cls1, &cls2));
+    }
+
+    #[test]
+    #[should_panic]
+    fn hir_byte_literal_non_ascii() {
+        Hir::literal(Literal::Byte(b'a'));
+    }
+
+    // We use a thread with an explicit stack size to test that our destructor
+    // for Hir can handle arbitrarily sized expressions in constant stack
+    // space. In case we run on a platform without threads (WASM?), we limit
+    // this test to Windows/Unix.
+    #[test]
+    #[cfg(any(unix, windows))]
+    fn no_stack_overflow_on_drop() {
+        use std::thread;
+
+        let run = || {
+            let mut expr = Hir::empty();
+            for _ in 0..100 {
+                expr = Hir::group(Group {
+                    kind: GroupKind::NonCapturing,
+                    hir: Box::new(expr),
+                });
+                expr = Hir::repetition(Repetition {
+                    kind: RepetitionKind::ZeroOrOne,
+                    greedy: true,
+                    hir: Box::new(expr),
+                });
+
+                expr = Hir {
+                    kind: HirKind::Concat(vec![expr]),
+                    info: HirInfo::new(),
+                };
+                expr = Hir {
+                    kind: HirKind::Alternation(vec![expr]),
+                    info: HirInfo::new(),
+                };
+            }
+            assert!(!expr.kind.is_empty());
+        };
+
+        // We run our test on a thread with a small stack size so we can
+        // force the issue more easily.
+        //
+        // NOTE(2023-03-21): See the corresponding test in 'crate::ast::tests'
+        // for context on the specific stack size chosen here.
+        thread::Builder::new()
+            .stack_size(16 << 10)
+            .spawn(run)
+            .unwrap()
+            .join()
+            .unwrap();
+    }
+}
diff --git a/crates/regex-syntax/src/hir/print.rs b/crates/regex-syntax/src/hir/print.rs
new file mode 100644
index 0000000..b71f389
--- /dev/null
+++ b/crates/regex-syntax/src/hir/print.rs
@@ -0,0 +1,367 @@
+/*!
+This module provides a regular expression printer for `Hir`.
+*/
+
+use std::fmt;
+
+use crate::hir::visitor::{self, Visitor};
+use crate::hir::{self, Hir, HirKind};
+use crate::is_meta_character;
+
+/// A builder for constructing a printer.
+///
+/// Note that since a printer doesn't have any configuration knobs, this type
+/// remains unexported.
+#[derive(Clone, Debug)]
+struct PrinterBuilder {
+    _priv: (),
+}
+
+impl Default for PrinterBuilder {
+    fn default() -> PrinterBuilder {
+        PrinterBuilder::new()
+    }
+}
+
+impl PrinterBuilder {
+    fn new() -> PrinterBuilder {
+        PrinterBuilder { _priv: () }
+    }
+
+    fn build(&self) -> Printer {
+        Printer { _priv: () }
+    }
+}
+
+/// A printer for a regular expression's high-level intermediate
+/// representation.
+///
+/// A printer converts a high-level intermediate representation (HIR) to a
+/// regular expression pattern string. This particular printer uses constant
+/// stack space and heap space proportional to the size of the HIR.
+///
+/// Since this printer is only using the HIR, the pattern it prints will likely
+/// not resemble the original pattern at all. For example, a pattern like
+/// `\pL` will have its entire class written out.
+///
+/// The purpose of this printer is to provide a means to mutate an HIR and then
+/// build a regular expression from the result of that mutation. (A regex
+/// library could provide a constructor from this HIR explicitly, but that
+/// creates an unnecessary public coupling between the regex library and this
+/// specific HIR representation.)
+#[derive(Debug)]
+pub struct Printer {
+    _priv: (),
+}
+
+impl Printer {
+    /// Create a new printer.
+    pub fn new() -> Printer {
+        PrinterBuilder::new().build()
+    }
+
+    /// Print the given `Ast` to the given writer. The writer must implement
+    /// `fmt::Write`. Typical implementations of `fmt::Write` that can be used
+    /// here are a `fmt::Formatter` (which is available in `fmt::Display`
+    /// implementations) or a `&mut String`.
+    pub fn print<W: fmt::Write>(&mut self, hir: &Hir, wtr: W) -> fmt::Result {
+        visitor::visit(hir, Writer { wtr })
+    }
+}
+
+#[derive(Debug)]
+struct Writer<W> {
+    wtr: W,
+}
+
+impl<W: fmt::Write> Visitor for Writer<W> {
+    type Output = ();
+    type Err = fmt::Error;
+
+    fn finish(self) -> fmt::Result {
+        Ok(())
+    }
+
+    fn visit_pre(&mut self, hir: &Hir) -> fmt::Result {
+        match *hir.kind() {
+            HirKind::Empty
+            | HirKind::Repetition(_)
+            | HirKind::Concat(_)
+            | HirKind::Alternation(_) => {}
+            HirKind::Literal(hir::Literal::Unicode(c)) => {
+                self.write_literal_char(c)?;
+            }
+            HirKind::Literal(hir::Literal::Byte(b)) => {
+                self.write_literal_byte(b)?;
+            }
+            HirKind::Class(hir::Class::Unicode(ref cls)) => {
+                self.wtr.write_str("[")?;
+                for range in cls.iter() {
+                    if range.start() == range.end() {
+                        self.write_literal_char(range.start())?;
+                    } else {
+                        self.write_literal_char(range.start())?;
+                        self.wtr.write_str("-")?;
+                        self.write_literal_char(range.end())?;
+                    }
+                }
+                self.wtr.write_str("]")?;
+            }
+            HirKind::Class(hir::Class::Bytes(ref cls)) => {
+                self.wtr.write_str("(?-u:[")?;
+                for range in cls.iter() {
+                    if range.start() == range.end() {
+                        self.write_literal_class_byte(range.start())?;
+                    } else {
+                        self.write_literal_class_byte(range.start())?;
+                        self.wtr.write_str("-")?;
+                        self.write_literal_class_byte(range.end())?;
+                    }
+                }
+                self.wtr.write_str("])")?;
+            }
+            HirKind::Anchor(hir::Anchor::StartLine) => {
+                self.wtr.write_str("(?m:^)")?;
+            }
+            HirKind::Anchor(hir::Anchor::EndLine) => {
+                self.wtr.write_str("(?m:$)")?;
+            }
+            HirKind::Anchor(hir::Anchor::StartText) => {
+                self.wtr.write_str(r"\A")?;
+            }
+            HirKind::Anchor(hir::Anchor::EndText) => {
+                self.wtr.write_str(r"\z")?;
+            }
+            HirKind::WordBoundary(hir::WordBoundary::Unicode) => {
+                self.wtr.write_str(r"\b")?;
+            }
+            HirKind::WordBoundary(hir::WordBoundary::UnicodeNegate) => {
+                self.wtr.write_str(r"\B")?;
+            }
+            HirKind::WordBoundary(hir::WordBoundary::Ascii) => {
+                self.wtr.write_str(r"(?-u:\b)")?;
+            }
+            HirKind::WordBoundary(hir::WordBoundary::AsciiNegate) => {
+                self.wtr.write_str(r"(?-u:\B)")?;
+            }
+            HirKind::Group(ref x) => match x.kind {
+                hir::GroupKind::CaptureIndex(_) => {
+                    self.wtr.write_str("(")?;
+                }
+                hir::GroupKind::CaptureName { ref name, .. } => {
+                    write!(self.wtr, "(?P<{}>", name)?;
+                }
+                hir::GroupKind::NonCapturing => {
+                    self.wtr.write_str("(?:")?;
+                }
+            },
+        }
+        Ok(())
+    }
+
+    fn visit_post(&mut self, hir: &Hir) -> fmt::Result {
+        match *hir.kind() {
+            // Handled during visit_pre
+            HirKind::Empty
+            | HirKind::Literal(_)
+            | HirKind::Class(_)
+            | HirKind::Anchor(_)
+            | HirKind::WordBoundary(_)
+            | HirKind::Concat(_)
+            | HirKind::Alternation(_) => {}
+            HirKind::Repetition(ref x) => {
+                match x.kind {
+                    hir::RepetitionKind::ZeroOrOne => {
+                        self.wtr.write_str("?")?;
+                    }
+                    hir::RepetitionKind::ZeroOrMore => {
+                        self.wtr.write_str("*")?;
+                    }
+                    hir::RepetitionKind::OneOrMore => {
+                        self.wtr.write_str("+")?;
+                    }
+                    hir::RepetitionKind::Range(ref x) => match *x {
+                        hir::RepetitionRange::Exactly(m) => {
+                            write!(self.wtr, "{{{}}}", m)?;
+                        }
+                        hir::RepetitionRange::AtLeast(m) => {
+                            write!(self.wtr, "{{{},}}", m)?;
+                        }
+                        hir::RepetitionRange::Bounded(m, n) => {
+                            write!(self.wtr, "{{{},{}}}", m, n)?;
+                        }
+                    },
+                }
+                if !x.greedy {
+                    self.wtr.write_str("?")?;
+                }
+            }
+            HirKind::Group(_) => {
+                self.wtr.write_str(")")?;
+            }
+        }
+        Ok(())
+    }
+
+    fn visit_alternation_in(&mut self) -> fmt::Result {
+        self.wtr.write_str("|")
+    }
+}
+
+impl<W: fmt::Write> Writer<W> {
+    fn write_literal_char(&mut self, c: char) -> fmt::Result {
+        if is_meta_character(c) {
+            self.wtr.write_str("\\")?;
+        }
+        self.wtr.write_char(c)
+    }
+
+    fn write_literal_byte(&mut self, b: u8) -> fmt::Result {
+        let c = b as char;
+        if c <= 0x7F as char && !c.is_control() && !c.is_whitespace() {
+            self.write_literal_char(c)
+        } else {
+            write!(self.wtr, "(?-u:\\x{:02X})", b)
+        }
+    }
+
+    fn write_literal_class_byte(&mut self, b: u8) -> fmt::Result {
+        let c = b as char;
+        if c <= 0x7F as char && !c.is_control() && !c.is_whitespace() {
+            self.write_literal_char(c)
+        } else {
+            write!(self.wtr, "\\x{:02X}", b)
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Printer;
+    use crate::ParserBuilder;
+
+    fn roundtrip(given: &str, expected: &str) {
+        roundtrip_with(|b| b, given, expected);
+    }
+
+    fn roundtrip_bytes(given: &str, expected: &str) {
+        roundtrip_with(|b| b.allow_invalid_utf8(true), given, expected);
+    }
+
+    fn roundtrip_with<F>(mut f: F, given: &str, expected: &str)
+    where
+        F: FnMut(&mut ParserBuilder) -> &mut ParserBuilder,
+    {
+        let mut builder = ParserBuilder::new();
+        f(&mut builder);
+        let hir = builder.build().parse(given).unwrap();
+
+        let mut printer = Printer::new();
+        let mut dst = String::new();
+        printer.print(&hir, &mut dst).unwrap();
+
+        // Check that the result is actually valid.
+        builder.build().parse(&dst).unwrap();
+
+        assert_eq!(expected, dst);
+    }
+
+    #[test]
+    fn print_literal() {
+        roundtrip("a", "a");
+        roundtrip(r"\xff", "\u{FF}");
+        roundtrip_bytes(r"\xff", "\u{FF}");
+        roundtrip_bytes(r"(?-u)\xff", r"(?-u:\xFF)");
+        roundtrip("☃", "☃");
+    }
+
+    #[test]
+    fn print_class() {
+        roundtrip(r"[a]", r"[a]");
+        roundtrip(r"[a-z]", r"[a-z]");
+        roundtrip(r"[a-z--b-c--x-y]", r"[ad-wz]");
+        roundtrip(r"[^\x01-\u{10FFFF}]", "[\u{0}]");
+        roundtrip(r"[-]", r"[\-]");
+        roundtrip(r"[☃-⛄]", r"[☃-⛄]");
+
+        roundtrip(r"(?-u)[a]", r"(?-u:[a])");
+        roundtrip(r"(?-u)[a-z]", r"(?-u:[a-z])");
+        roundtrip_bytes(r"(?-u)[a-\xFF]", r"(?-u:[a-\xFF])");
+
+        // The following test that the printer escapes meta characters
+        // in character classes.
+        roundtrip(r"[\[]", r"[\[]");
+        roundtrip(r"[Z-_]", r"[Z-_]");
+        roundtrip(r"[Z-_--Z]", r"[\[-_]");
+
+        // The following test that the printer escapes meta characters
+        // in byte oriented character classes.
+        roundtrip_bytes(r"(?-u)[\[]", r"(?-u:[\[])");
+        roundtrip_bytes(r"(?-u)[Z-_]", r"(?-u:[Z-_])");
+        roundtrip_bytes(r"(?-u)[Z-_--Z]", r"(?-u:[\[-_])");
+    }
+
+    #[test]
+    fn print_anchor() {
+        roundtrip(r"^", r"\A");
+        roundtrip(r"$", r"\z");
+        roundtrip(r"(?m)^", r"(?m:^)");
+        roundtrip(r"(?m)$", r"(?m:$)");
+    }
+
+    #[test]
+    fn print_word_boundary() {
+        roundtrip(r"\b", r"\b");
+        roundtrip(r"\B", r"\B");
+        roundtrip(r"(?-u)\b", r"(?-u:\b)");
+        roundtrip_bytes(r"(?-u)\B", r"(?-u:\B)");
+    }
+
+    #[test]
+    fn print_repetition() {
+        roundtrip("a?", "a?");
+        roundtrip("a??", "a??");
+        roundtrip("(?U)a?", "a??");
+
+        roundtrip("a*", "a*");
+        roundtrip("a*?", "a*?");
+        roundtrip("(?U)a*", "a*?");
+
+        roundtrip("a+", "a+");
+        roundtrip("a+?", "a+?");
+        roundtrip("(?U)a+", "a+?");
+
+        roundtrip("a{1}", "a{1}");
+        roundtrip("a{1,}", "a{1,}");
+        roundtrip("a{1,5}", "a{1,5}");
+        roundtrip("a{1}?", "a{1}?");
+        roundtrip("a{1,}?", "a{1,}?");
+        roundtrip("a{1,5}?", "a{1,5}?");
+        roundtrip("(?U)a{1}", "a{1}?");
+        roundtrip("(?U)a{1,}", "a{1,}?");
+        roundtrip("(?U)a{1,5}", "a{1,5}?");
+    }
+
+    #[test]
+    fn print_group() {
+        roundtrip("()", "()");
+        roundtrip("(?P<foo>)", "(?P<foo>)");
+        roundtrip("(?:)", "(?:)");
+
+        roundtrip("(a)", "(a)");
+        roundtrip("(?P<foo>a)", "(?P<foo>a)");
+        roundtrip("(?:a)", "(?:a)");
+
+        roundtrip("((((a))))", "((((a))))");
+    }
+
+    #[test]
+    fn print_alternation() {
+        roundtrip("|", "|");
+        roundtrip("||", "||");
+
+        roundtrip("a|b", "a|b");
+        roundtrip("a|b|c", "a|b|c");
+        roundtrip("foo|bar|quux", "foo|bar|quux");
+    }
+}
diff --git a/crates/regex-syntax/src/hir/translate.rs b/crates/regex-syntax/src/hir/translate.rs
new file mode 100644
index 0000000..890e160
--- /dev/null
+++ b/crates/regex-syntax/src/hir/translate.rs
@@ -0,0 +1,3207 @@
+/*!
+Defines a translator that converts an `Ast` to an `Hir`.
+*/
+
+use std::cell::{Cell, RefCell};
+use std::result;
+
+use crate::ast::{self, Ast, Span, Visitor};
+use crate::hir::{self, Error, ErrorKind, Hir};
+use crate::unicode::{self, ClassQuery};
+
+type Result<T> = result::Result<T, Error>;
+
+/// A builder for constructing an AST->HIR translator.
+#[derive(Clone, Debug)]
+pub struct TranslatorBuilder {
+    allow_invalid_utf8: bool,
+    flags: Flags,
+}
+
+impl Default for TranslatorBuilder {
+    fn default() -> TranslatorBuilder {
+        TranslatorBuilder::new()
+    }
+}
+
+impl TranslatorBuilder {
+    /// Create a new translator builder with a default c onfiguration.
+    pub fn new() -> TranslatorBuilder {
+        TranslatorBuilder {
+            allow_invalid_utf8: false,
+            flags: Flags::default(),
+        }
+    }
+
+    /// Build a translator using the current configuration.
+    pub fn build(&self) -> Translator {
+        Translator {
+            stack: RefCell::new(vec![]),
+            flags: Cell::new(self.flags),
+            allow_invalid_utf8: self.allow_invalid_utf8,
+        }
+    }
+
+    /// When enabled, translation will permit the construction of a regular
+    /// expression that may match invalid UTF-8.
+    ///
+    /// When disabled (the default), the translator is guaranteed to produce
+    /// an expression that will only ever match valid UTF-8 (otherwise, the
+    /// translator will return an error).
+    ///
+    /// Perhaps surprisingly, when invalid UTF-8 isn't allowed, a negated ASCII
+    /// word boundary (uttered as `(?-u:\B)` in the concrete syntax) will cause
+    /// the parser to return an error. Namely, a negated ASCII word boundary
+    /// can result in matching positions that aren't valid UTF-8 boundaries.
+    pub fn allow_invalid_utf8(&mut self, yes: bool) -> &mut TranslatorBuilder {
+        self.allow_invalid_utf8 = yes;
+        self
+    }
+
+    /// Enable or disable the case insensitive flag (`i`) by default.
+    pub fn case_insensitive(&mut self, yes: bool) -> &mut TranslatorBuilder {
+        self.flags.case_insensitive = if yes { Some(true) } else { None };
+        self
+    }
+
+    /// Enable or disable the multi-line matching flag (`m`) by default.
+    pub fn multi_line(&mut self, yes: bool) -> &mut TranslatorBuilder {
+        self.flags.multi_line = if yes { Some(true) } else { None };
+        self
+    }
+
+    /// Enable or disable the "dot matches any character" flag (`s`) by
+    /// default.
+    pub fn dot_matches_new_line(
+        &mut self,
+        yes: bool,
+    ) -> &mut TranslatorBuilder {
+        self.flags.dot_matches_new_line = if yes { Some(true) } else { None };
+        self
+    }
+
+    /// Enable or disable the "swap greed" flag (`U`) by default.
+    pub fn swap_greed(&mut self, yes: bool) -> &mut TranslatorBuilder {
+        self.flags.swap_greed = if yes { Some(true) } else { None };
+        self
+    }
+
+    /// Enable or disable the Unicode flag (`u`) by default.
+    pub fn unicode(&mut self, yes: bool) -> &mut TranslatorBuilder {
+        self.flags.unicode = if yes { None } else { Some(false) };
+        self
+    }
+}
+
+/// A translator maps abstract syntax to a high level intermediate
+/// representation.
+///
+/// A translator may be benefit from reuse. That is, a translator can translate
+/// many abstract syntax trees.
+///
+/// A `Translator` can be configured in more detail via a
+/// [`TranslatorBuilder`](struct.TranslatorBuilder.html).
+#[derive(Clone, Debug)]
+pub struct Translator {
+    /// Our call stack, but on the heap.
+    stack: RefCell<Vec<HirFrame>>,
+    /// The current flag settings.
+    flags: Cell<Flags>,
+    /// Whether we're allowed to produce HIR that can match arbitrary bytes.
+    allow_invalid_utf8: bool,
+}
+
+impl Translator {
+    /// Create a new translator using the default configuration.
+    pub fn new() -> Translator {
+        TranslatorBuilder::new().build()
+    }
+
+    /// Translate the given abstract syntax tree (AST) into a high level
+    /// intermediate representation (HIR).
+    ///
+    /// If there was a problem doing the translation, then an HIR-specific
+    /// error is returned.
+    ///
+    /// The original pattern string used to produce the `Ast` *must* also be
+    /// provided. The translator does not use the pattern string during any
+    /// correct translation, but is used for error reporting.
+    pub fn translate(&mut self, pattern: &str, ast: &Ast) -> Result<Hir> {
+        ast::visit(ast, TranslatorI::new(self, pattern))
+    }
+}
+
+/// An HirFrame is a single stack frame, represented explicitly, which is
+/// created for each item in the Ast that we traverse.
+///
+/// Note that technically, this type doesn't represent our entire stack
+/// frame. In particular, the Ast visitor represents any state associated with
+/// traversing the Ast itself.
+#[derive(Clone, Debug)]
+enum HirFrame {
+    /// An arbitrary HIR expression. These get pushed whenever we hit a base
+    /// case in the Ast. They get popped after an inductive (i.e., recursive)
+    /// step is complete.
+    Expr(Hir),
+    /// A Unicode character class. This frame is mutated as we descend into
+    /// the Ast of a character class (which is itself its own mini recursive
+    /// structure).
+    ClassUnicode(hir::ClassUnicode),
+    /// A byte-oriented character class. This frame is mutated as we descend
+    /// into the Ast of a character class (which is itself its own mini
+    /// recursive structure).
+    ///
+    /// Byte character classes are created when Unicode mode (`u`) is disabled.
+    /// If `allow_invalid_utf8` is disabled (the default), then a byte
+    /// character is only permitted to match ASCII text.
+    ClassBytes(hir::ClassBytes),
+    /// This is pushed on to the stack upon first seeing any kind of group,
+    /// indicated by parentheses (including non-capturing groups). It is popped
+    /// upon leaving a group.
+    Group {
+        /// The old active flags when this group was opened.
+        ///
+        /// If this group sets flags, then the new active flags are set to the
+        /// result of merging the old flags with the flags introduced by this
+        /// group. If the group doesn't set any flags, then this is simply
+        /// equivalent to whatever flags were set when the group was opened.
+        ///
+        /// When this group is popped, the active flags should be restored to
+        /// the flags set here.
+        ///
+        /// The "active" flags correspond to whatever flags are set in the
+        /// Translator.
+        old_flags: Flags,
+    },
+    /// This is pushed whenever a concatenation is observed. After visiting
+    /// every sub-expression in the concatenation, the translator's stack is
+    /// popped until it sees a Concat frame.
+    Concat,
+    /// This is pushed whenever an alternation is observed. After visiting
+    /// every sub-expression in the alternation, the translator's stack is
+    /// popped until it sees an Alternation frame.
+    Alternation,
+}
+
+impl HirFrame {
+    /// Assert that the current stack frame is an Hir expression and return it.
+    fn unwrap_expr(self) -> Hir {
+        match self {
+            HirFrame::Expr(expr) => expr,
+            _ => panic!("tried to unwrap expr from HirFrame, got: {:?}", self),
+        }
+    }
+
+    /// Assert that the current stack frame is a Unicode class expression and
+    /// return it.
+    fn unwrap_class_unicode(self) -> hir::ClassUnicode {
+        match self {
+            HirFrame::ClassUnicode(cls) => cls,
+            _ => panic!(
+                "tried to unwrap Unicode class \
+                 from HirFrame, got: {:?}",
+                self
+            ),
+        }
+    }
+
+    /// Assert that the current stack frame is a byte class expression and
+    /// return it.
+    fn unwrap_class_bytes(self) -> hir::ClassBytes {
+        match self {
+            HirFrame::ClassBytes(cls) => cls,
+            _ => panic!(
+                "tried to unwrap byte class \
+                 from HirFrame, got: {:?}",
+                self
+            ),
+        }
+    }
+
+    /// Assert that the current stack frame is a group indicator and return
+    /// its corresponding flags (the flags that were active at the time the
+    /// group was entered).
+    fn unwrap_group(self) -> Flags {
+        match self {
+            HirFrame::Group { old_flags } => old_flags,
+            _ => {
+                panic!("tried to unwrap group from HirFrame, got: {:?}", self)
+            }
+        }
+    }
+}
+
+impl<'t, 'p> Visitor for TranslatorI<'t, 'p> {
+    type Output = Hir;
+    type Err = Error;
+
+    fn finish(self) -> Result<Hir> {
+        // ... otherwise, we should have exactly one HIR on the stack.
+        assert_eq!(self.trans().stack.borrow().len(), 1);
+        Ok(self.pop().unwrap().unwrap_expr())
+    }
+
+    fn visit_pre(&mut self, ast: &Ast) -> Result<()> {
+        match *ast {
+            Ast::Class(ast::Class::Bracketed(_)) => {
+                if self.flags().unicode() {
+                    let cls = hir::ClassUnicode::empty();
+                    self.push(HirFrame::ClassUnicode(cls));
+                } else {
+                    let cls = hir::ClassBytes::empty();
+                    self.push(HirFrame::ClassBytes(cls));
+                }
+            }
+            Ast::Group(ref x) => {
+                let old_flags = x
+                    .flags()
+                    .map(|ast| self.set_flags(ast))
+                    .unwrap_or_else(|| self.flags());
+                self.push(HirFrame::Group { old_flags });
+            }
+            Ast::Concat(ref x) if x.asts.is_empty() => {}
+            Ast::Concat(_) => {
+                self.push(HirFrame::Concat);
+            }
+            Ast::Alternation(ref x) if x.asts.is_empty() => {}
+            Ast::Alternation(_) => {
+                self.push(HirFrame::Alternation);
+            }
+            _ => {}
+        }
+        Ok(())
+    }
+
+    fn visit_post(&mut self, ast: &Ast) -> Result<()> {
+        match *ast {
+            Ast::Empty(_) => {
+                self.push(HirFrame::Expr(Hir::empty()));
+            }
+            Ast::Flags(ref x) => {
+                self.set_flags(&x.flags);
+                // Flags in the AST are generally considered directives and
+                // not actual sub-expressions. However, they can be used in
+                // the concrete syntax like `((?i))`, and we need some kind of
+                // indication of an expression there, and Empty is the correct
+                // choice.
+                //
+                // There can also be things like `(?i)+`, but we rule those out
+                // in the parser. In the future, we might allow them for
+                // consistency sake.
+                self.push(HirFrame::Expr(Hir::empty()));
+            }
+            Ast::Literal(ref x) => {
+                self.push(HirFrame::Expr(self.hir_literal(x)?));
+            }
+            Ast::Dot(span) => {
+                self.push(HirFrame::Expr(self.hir_dot(span)?));
+            }
+            Ast::Assertion(ref x) => {
+                self.push(HirFrame::Expr(self.hir_assertion(x)?));
+            }
+            Ast::Class(ast::Class::Perl(ref x)) => {
+                if self.flags().unicode() {
+                    let cls = self.hir_perl_unicode_class(x)?;
+                    let hcls = hir::Class::Unicode(cls);
+                    self.push(HirFrame::Expr(Hir::class(hcls)));
+                } else {
+                    let cls = self.hir_perl_byte_class(x);
+                    let hcls = hir::Class::Bytes(cls);
+                    self.push(HirFrame::Expr(Hir::class(hcls)));
+                }
+            }
+            Ast::Class(ast::Class::Unicode(ref x)) => {
+                let cls = hir::Class::Unicode(self.hir_unicode_class(x)?);
+                self.push(HirFrame::Expr(Hir::class(cls)));
+            }
+            Ast::Class(ast::Class::Bracketed(ref ast)) => {
+                if self.flags().unicode() {
+                    let mut cls = self.pop().unwrap().unwrap_class_unicode();
+                    self.unicode_fold_and_negate(
+                        &ast.span,
+                        ast.negated,
+                        &mut cls,
+                    )?;
+                    if cls.ranges().is_empty() {
+                        return Err(self.error(
+                            ast.span,
+                            ErrorKind::EmptyClassNotAllowed,
+                        ));
+                    }
+                    let expr = Hir::class(hir::Class::Unicode(cls));
+                    self.push(HirFrame::Expr(expr));
+                } else {
+                    let mut cls = self.pop().unwrap().unwrap_class_bytes();
+                    self.bytes_fold_and_negate(
+                        &ast.span,
+                        ast.negated,
+                        &mut cls,
+                    )?;
+                    if cls.ranges().is_empty() {
+                        return Err(self.error(
+                            ast.span,
+                            ErrorKind::EmptyClassNotAllowed,
+                        ));
+                    }
+
+                    let expr = Hir::class(hir::Class::Bytes(cls));
+                    self.push(HirFrame::Expr(expr));
+                }
+            }
+            Ast::Repetition(ref x) => {
+                let expr = self.pop().unwrap().unwrap_expr();
+                self.push(HirFrame::Expr(self.hir_repetition(x, expr)));
+            }
+            Ast::Group(ref x) => {
+                let expr = self.pop().unwrap().unwrap_expr();
+                let old_flags = self.pop().unwrap().unwrap_group();
+                self.trans().flags.set(old_flags);
+                self.push(HirFrame::Expr(self.hir_group(x, expr)));
+            }
+            Ast::Concat(_) => {
+                let mut exprs = vec![];
+                while let Some(HirFrame::Expr(expr)) = self.pop() {
+                    if !expr.kind().is_empty() {
+                        exprs.push(expr);
+                    }
+                }
+                exprs.reverse();
+                self.push(HirFrame::Expr(Hir::concat(exprs)));
+            }
+            Ast::Alternation(_) => {
+                let mut exprs = vec![];
+                while let Some(HirFrame::Expr(expr)) = self.pop() {
+                    exprs.push(expr);
+                }
+                exprs.reverse();
+                self.push(HirFrame::Expr(Hir::alternation(exprs)));
+            }
+        }
+        Ok(())
+    }
+
+    fn visit_class_set_item_pre(
+        &mut self,
+        ast: &ast::ClassSetItem,
+    ) -> Result<()> {
+        match *ast {
+            ast::ClassSetItem::Bracketed(_) => {
+                if self.flags().unicode() {
+                    let cls = hir::ClassUnicode::empty();
+                    self.push(HirFrame::ClassUnicode(cls));
+                } else {
+                    let cls = hir::ClassBytes::empty();
+                    self.push(HirFrame::ClassBytes(cls));
+                }
+            }
+            // We needn't handle the Union case here since the visitor will
+            // do it for us.
+            _ => {}
+        }
+        Ok(())
+    }
+
+    fn visit_class_set_item_post(
+        &mut self,
+        ast: &ast::ClassSetItem,
+    ) -> Result<()> {
+        match *ast {
+            ast::ClassSetItem::Empty(_) => {}
+            ast::ClassSetItem::Literal(ref x) => {
+                if self.flags().unicode() {
+                    let mut cls = self.pop().unwrap().unwrap_class_unicode();
+                    cls.push(hir::ClassUnicodeRange::new(x.c, x.c));
+                    self.push(HirFrame::ClassUnicode(cls));
+                } else {
+                    let mut cls = self.pop().unwrap().unwrap_class_bytes();
+                    let byte = self.class_literal_byte(x)?;
+                    cls.push(hir::ClassBytesRange::new(byte, byte));
+                    self.push(HirFrame::ClassBytes(cls));
+                }
+            }
+            ast::ClassSetItem::Range(ref x) => {
+                if self.flags().unicode() {
+                    let mut cls = self.pop().unwrap().unwrap_class_unicode();
+                    cls.push(hir::ClassUnicodeRange::new(x.start.c, x.end.c));
+                    self.push(HirFrame::ClassUnicode(cls));
+                } else {
+                    let mut cls = self.pop().unwrap().unwrap_class_bytes();
+                    let start = self.class_literal_byte(&x.start)?;
+                    let end = self.class_literal_byte(&x.end)?;
+                    cls.push(hir::ClassBytesRange::new(start, end));
+                    self.push(HirFrame::ClassBytes(cls));
+                }
+            }
+            ast::ClassSetItem::Ascii(ref x) => {
+                if self.flags().unicode() {
+                    let xcls = self.hir_ascii_unicode_class(x)?;
+                    let mut cls = self.pop().unwrap().unwrap_class_unicode();
+                    cls.union(&xcls);
+                    self.push(HirFrame::ClassUnicode(cls));
+                } else {
+                    let xcls = self.hir_ascii_byte_class(x)?;
+                    let mut cls = self.pop().unwrap().unwrap_class_bytes();
+                    cls.union(&xcls);
+                    self.push(HirFrame::ClassBytes(cls));
+                }
+            }
+            ast::ClassSetItem::Unicode(ref x) => {
+                let xcls = self.hir_unicode_class(x)?;
+                let mut cls = self.pop().unwrap().unwrap_class_unicode();
+                cls.union(&xcls);
+                self.push(HirFrame::ClassUnicode(cls));
+            }
+            ast::ClassSetItem::Perl(ref x) => {
+                if self.flags().unicode() {
+                    let xcls = self.hir_perl_unicode_class(x)?;
+                    let mut cls = self.pop().unwrap().unwrap_class_unicode();
+                    cls.union(&xcls);
+                    self.push(HirFrame::ClassUnicode(cls));
+                } else {
+                    let xcls = self.hir_perl_byte_class(x);
+                    let mut cls = self.pop().unwrap().unwrap_class_bytes();
+                    cls.union(&xcls);
+                    self.push(HirFrame::ClassBytes(cls));
+                }
+            }
+            ast::ClassSetItem::Bracketed(ref ast) => {
+                if self.flags().unicode() {
+                    let mut cls1 = self.pop().unwrap().unwrap_class_unicode();
+                    self.unicode_fold_and_negate(
+                        &ast.span,
+                        ast.negated,
+                        &mut cls1,
+                    )?;
+
+                    let mut cls2 = self.pop().unwrap().unwrap_class_unicode();
+                    cls2.union(&cls1);
+                    self.push(HirFrame::ClassUnicode(cls2));
+                } else {
+                    let mut cls1 = self.pop().unwrap().unwrap_class_bytes();
+                    self.bytes_fold_and_negate(
+                        &ast.span,
+                        ast.negated,
+                        &mut cls1,
+                    )?;
+
+                    let mut cls2 = self.pop().unwrap().unwrap_class_bytes();
+                    cls2.union(&cls1);
+                    self.push(HirFrame::ClassBytes(cls2));
+                }
+            }
+            // This is handled automatically by the visitor.
+            ast::ClassSetItem::Union(_) => {}
+        }
+        Ok(())
+    }
+
+    fn visit_class_set_binary_op_pre(
+        &mut self,
+        _op: &ast::ClassSetBinaryOp,
+    ) -> Result<()> {
+        if self.flags().unicode() {
+            let cls = hir::ClassUnicode::empty();
+            self.push(HirFrame::ClassUnicode(cls));
+        } else {
+            let cls = hir::ClassBytes::empty();
+            self.push(HirFrame::ClassBytes(cls));
+        }
+        Ok(())
+    }
+
+    fn visit_class_set_binary_op_in(
+        &mut self,
+        _op: &ast::ClassSetBinaryOp,
+    ) -> Result<()> {
+        if self.flags().unicode() {
+            let cls = hir::ClassUnicode::empty();
+            self.push(HirFrame::ClassUnicode(cls));
+        } else {
+            let cls = hir::ClassBytes::empty();
+            self.push(HirFrame::ClassBytes(cls));
+        }
+        Ok(())
+    }
+
+    fn visit_class_set_binary_op_post(
+        &mut self,
+        op: &ast::ClassSetBinaryOp,
+    ) -> Result<()> {
+        use crate::ast::ClassSetBinaryOpKind::*;
+
+        if self.flags().unicode() {
+            let mut rhs = self.pop().unwrap().unwrap_class_unicode();
+            let mut lhs = self.pop().unwrap().unwrap_class_unicode();
+            let mut cls = self.pop().unwrap().unwrap_class_unicode();
+            if self.flags().case_insensitive() {
+                rhs.try_case_fold_simple().map_err(|_| {
+                    self.error(
+                        op.rhs.span().clone(),
+                        ErrorKind::UnicodeCaseUnavailable,
+                    )
+                })?;
+                lhs.try_case_fold_simple().map_err(|_| {
+                    self.error(
+                        op.lhs.span().clone(),
+                        ErrorKind::UnicodeCaseUnavailable,
+                    )
+                })?;
+            }
+            match op.kind {
+                Intersection => lhs.intersect(&rhs),
+                Difference => lhs.difference(&rhs),
+                SymmetricDifference => lhs.symmetric_difference(&rhs),
+            }
+            cls.union(&lhs);
+            self.push(HirFrame::ClassUnicode(cls));
+        } else {
+            let mut rhs = self.pop().unwrap().unwrap_class_bytes();
+            let mut lhs = self.pop().unwrap().unwrap_class_bytes();
+            let mut cls = self.pop().unwrap().unwrap_class_bytes();
+            if self.flags().case_insensitive() {
+                rhs.case_fold_simple();
+                lhs.case_fold_simple();
+            }
+            match op.kind {
+                Intersection => lhs.intersect(&rhs),
+                Difference => lhs.difference(&rhs),
+                SymmetricDifference => lhs.symmetric_difference(&rhs),
+            }
+            cls.union(&lhs);
+            self.push(HirFrame::ClassBytes(cls));
+        }
+        Ok(())
+    }
+}
+
+/// The internal implementation of a translator.
+///
+/// This type is responsible for carrying around the original pattern string,
+/// which is not tied to the internal state of a translator.
+///
+/// A TranslatorI exists for the time it takes to translate a single Ast.
+#[derive(Clone, Debug)]
+struct TranslatorI<'t, 'p> {
+    trans: &'t Translator,
+    pattern: &'p str,
+}
+
+impl<'t, 'p> TranslatorI<'t, 'p> {
+    /// Build a new internal translator.
+    fn new(trans: &'t Translator, pattern: &'p str) -> TranslatorI<'t, 'p> {
+        TranslatorI { trans, pattern }
+    }
+
+    /// Return a reference to the underlying translator.
+    fn trans(&self) -> &Translator {
+        &self.trans
+    }
+
+    /// Push the given frame on to the call stack.
+    fn push(&self, frame: HirFrame) {
+        self.trans().stack.borrow_mut().push(frame);
+    }
+
+    /// Pop the top of the call stack. If the call stack is empty, return None.
+    fn pop(&self) -> Option<HirFrame> {
+        self.trans().stack.borrow_mut().pop()
+    }
+
+    /// Create a new error with the given span and error type.
+    fn error(&self, span: Span, kind: ErrorKind) -> Error {
+        Error { kind, pattern: self.pattern.to_string(), span }
+    }
+
+    /// Return a copy of the active flags.
+    fn flags(&self) -> Flags {
+        self.trans().flags.get()
+    }
+
+    /// Set the flags of this translator from the flags set in the given AST.
+    /// Then, return the old flags.
+    fn set_flags(&self, ast_flags: &ast::Flags) -> Flags {
+        let old_flags = self.flags();
+        let mut new_flags = Flags::from_ast(ast_flags);
+        new_flags.merge(&old_flags);
+        self.trans().flags.set(new_flags);
+        old_flags
+    }
+
+    fn hir_literal(&self, lit: &ast::Literal) -> Result<Hir> {
+        let ch = match self.literal_to_char(lit)? {
+            byte @ hir::Literal::Byte(_) => return Ok(Hir::literal(byte)),
+            hir::Literal::Unicode(ch) => ch,
+        };
+        if self.flags().case_insensitive() {
+            self.hir_from_char_case_insensitive(lit.span, ch)
+        } else {
+            self.hir_from_char(lit.span, ch)
+        }
+    }
+
+    /// Convert an Ast literal to its scalar representation.
+    ///
+    /// When Unicode mode is enabled, then this always succeeds and returns a
+    /// `char` (Unicode scalar value).
+    ///
+    /// When Unicode mode is disabled, then a raw byte is returned. If that
+    /// byte is not ASCII and invalid UTF-8 is not allowed, then this returns
+    /// an error.
+    fn literal_to_char(&self, lit: &ast::Literal) -> Result<hir::Literal> {
+        if self.flags().unicode() {
+            return Ok(hir::Literal::Unicode(lit.c));
+        }
+        let byte = match lit.byte() {
+            None => return Ok(hir::Literal::Unicode(lit.c)),
+            Some(byte) => byte,
+        };
+        if byte <= 0x7F {
+            return Ok(hir::Literal::Unicode(byte as char));
+        }
+        if !self.trans().allow_invalid_utf8 {
+            return Err(self.error(lit.span, ErrorKind::InvalidUtf8));
+        }
+        Ok(hir::Literal::Byte(byte))
+    }
+
+    fn hir_from_char(&self, span: Span, c: char) -> Result<Hir> {
+        if !self.flags().unicode() && c.len_utf8() > 1 {
+            return Err(self.error(span, ErrorKind::UnicodeNotAllowed));
+        }
+        Ok(Hir::literal(hir::Literal::Unicode(c)))
+    }
+
+    fn hir_from_char_case_insensitive(
+        &self,
+        span: Span,
+        c: char,
+    ) -> Result<Hir> {
+        if self.flags().unicode() {
+            // If case folding won't do anything, then don't bother trying.
+            let map =
+                unicode::contains_simple_case_mapping(c, c).map_err(|_| {
+                    self.error(span, ErrorKind::UnicodeCaseUnavailable)
+                })?;
+            if !map {
+                return self.hir_from_char(span, c);
+            }
+            let mut cls =
+                hir::ClassUnicode::new(vec![hir::ClassUnicodeRange::new(
+                    c, c,
+                )]);
+            cls.try_case_fold_simple().map_err(|_| {
+                self.error(span, ErrorKind::UnicodeCaseUnavailable)
+            })?;
+            Ok(Hir::class(hir::Class::Unicode(cls)))
+        } else {
+            if c.len_utf8() > 1 {
+                return Err(self.error(span, ErrorKind::UnicodeNotAllowed));
+            }
+            // If case folding won't do anything, then don't bother trying.
+            match c {
+                'A'..='Z' | 'a'..='z' => {}
+                _ => return self.hir_from_char(span, c),
+            }
+            let mut cls =
+                hir::ClassBytes::new(vec![hir::ClassBytesRange::new(
+                    c as u8, c as u8,
+                )]);
+            cls.case_fold_simple();
+            Ok(Hir::class(hir::Class::Bytes(cls)))
+        }
+    }
+
+    fn hir_dot(&self, span: Span) -> Result<Hir> {
+        let unicode = self.flags().unicode();
+        if !unicode && !self.trans().allow_invalid_utf8 {
+            return Err(self.error(span, ErrorKind::InvalidUtf8));
+        }
+        Ok(if self.flags().dot_matches_new_line() {
+            Hir::any(!unicode)
+        } else {
+            Hir::dot(!unicode)
+        })
+    }
+
+    fn hir_assertion(&self, asst: &ast::Assertion) -> Result<Hir> {
+        let unicode = self.flags().unicode();
+        let multi_line = self.flags().multi_line();
+        Ok(match asst.kind {
+            ast::AssertionKind::StartLine => Hir::anchor(if multi_line {
+                hir::Anchor::StartLine
+            } else {
+                hir::Anchor::StartText
+            }),
+            ast::AssertionKind::EndLine => Hir::anchor(if multi_line {
+                hir::Anchor::EndLine
+            } else {
+                hir::Anchor::EndText
+            }),
+            ast::AssertionKind::StartText => {
+                Hir::anchor(hir::Anchor::StartText)
+            }
+            ast::AssertionKind::EndText => Hir::anchor(hir::Anchor::EndText),
+            ast::AssertionKind::WordBoundary => {
+                Hir::word_boundary(if unicode {
+                    hir::WordBoundary::Unicode
+                } else {
+                    hir::WordBoundary::Ascii
+                })
+            }
+            ast::AssertionKind::NotWordBoundary => {
+                Hir::word_boundary(if unicode {
+                    hir::WordBoundary::UnicodeNegate
+                } else {
+                    // It is possible for negated ASCII word boundaries to
+                    // match at invalid UTF-8 boundaries, even when searching
+                    // valid UTF-8.
+                    if !self.trans().allow_invalid_utf8 {
+                        return Err(
+                            self.error(asst.span, ErrorKind::InvalidUtf8)
+                        );
+                    }
+                    hir::WordBoundary::AsciiNegate
+                })
+            }
+        })
+    }
+
+    fn hir_group(&self, group: &ast::Group, expr: Hir) -> Hir {
+        let kind = match group.kind {
+            ast::GroupKind::CaptureIndex(idx) => {
+                hir::GroupKind::CaptureIndex(idx)
+            }
+            ast::GroupKind::CaptureName(ref capname) => {
+                hir::GroupKind::CaptureName {
+                    name: capname.name.clone(),
+                    index: capname.index,
+                }
+            }
+            ast::GroupKind::NonCapturing(_) => hir::GroupKind::NonCapturing,
+        };
+        Hir::group(hir::Group { kind, hir: Box::new(expr) })
+    }
+
+    fn hir_repetition(&self, rep: &ast::Repetition, expr: Hir) -> Hir {
+        let kind = match rep.op.kind {
+            ast::RepetitionKind::ZeroOrOne => hir::RepetitionKind::ZeroOrOne,
+            ast::RepetitionKind::ZeroOrMore => hir::RepetitionKind::ZeroOrMore,
+            ast::RepetitionKind::OneOrMore => hir::RepetitionKind::OneOrMore,
+            ast::RepetitionKind::Range(ast::RepetitionRange::Exactly(m)) => {
+                hir::RepetitionKind::Range(hir::RepetitionRange::Exactly(m))
+            }
+            ast::RepetitionKind::Range(ast::RepetitionRange::AtLeast(m)) => {
+                hir::RepetitionKind::Range(hir::RepetitionRange::AtLeast(m))
+            }
+            ast::RepetitionKind::Range(ast::RepetitionRange::Bounded(
+                m,
+                n,
+            )) => {
+                hir::RepetitionKind::Range(hir::RepetitionRange::Bounded(m, n))
+            }
+        };
+        let greedy =
+            if self.flags().swap_greed() { !rep.greedy } else { rep.greedy };
+        Hir::repetition(hir::Repetition { kind, greedy, hir: Box::new(expr) })
+    }
+
+    fn hir_unicode_class(
+        &self,
+        ast_class: &ast::ClassUnicode,
+    ) -> Result<hir::ClassUnicode> {
+        use crate::ast::ClassUnicodeKind::*;
+
+        if !self.flags().unicode() {
+            return Err(
+                self.error(ast_class.span, ErrorKind::UnicodeNotAllowed)
+            );
+        }
+        let query = match ast_class.kind {
+            OneLetter(name) => ClassQuery::OneLetter(name),
+            Named(ref name) => ClassQuery::Binary(name),
+            NamedValue { ref name, ref value, .. } => ClassQuery::ByValue {
+                property_name: name,
+                property_value: value,
+            },
+        };
+        let mut result = self.convert_unicode_class_error(
+            &ast_class.span,
+            unicode::class(query),
+        );
+        if let Ok(ref mut class) = result {
+            self.unicode_fold_and_negate(
+                &ast_class.span,
+                ast_class.negated,
+                class,
+            )?;
+            if class.ranges().is_empty() {
+                let err = self
+                    .error(ast_class.span, ErrorKind::EmptyClassNotAllowed);
+                return Err(err);
+            }
+        }
+        result
+    }
+
+    fn hir_ascii_unicode_class(
+        &self,
+        ast: &ast::ClassAscii,
+    ) -> Result<hir::ClassUnicode> {
+        let mut cls = hir::ClassUnicode::new(
+            ascii_class(&ast.kind)
+                .iter()
+                .map(|&(s, e)| hir::ClassUnicodeRange::new(s, e)),
+        );
+        self.unicode_fold_and_negate(&ast.span, ast.negated, &mut cls)?;
+        Ok(cls)
+    }
+
+    fn hir_ascii_byte_class(
+        &self,
+        ast: &ast::ClassAscii,
+    ) -> Result<hir::ClassBytes> {
+        let mut cls = hir::ClassBytes::new(
+            ascii_class(&ast.kind)
+                .iter()
+                .map(|&(s, e)| hir::ClassBytesRange::new(s as u8, e as u8)),
+        );
+        self.bytes_fold_and_negate(&ast.span, ast.negated, &mut cls)?;
+        Ok(cls)
+    }
+
+    fn hir_perl_unicode_class(
+        &self,
+        ast_class: &ast::ClassPerl,
+    ) -> Result<hir::ClassUnicode> {
+        use crate::ast::ClassPerlKind::*;
+
+        assert!(self.flags().unicode());
+        let result = match ast_class.kind {
+            Digit => unicode::perl_digit(),
+            Space => unicode::perl_space(),
+            Word => unicode::perl_word(),
+        };
+        let mut class =
+            self.convert_unicode_class_error(&ast_class.span, result)?;
+        // We needn't apply case folding here because the Perl Unicode classes
+        // are already closed under Unicode simple case folding.
+        if ast_class.negated {
+            class.negate();
+        }
+        Ok(class)
+    }
+
+    fn hir_perl_byte_class(
+        &self,
+        ast_class: &ast::ClassPerl,
+    ) -> hir::ClassBytes {
+        use crate::ast::ClassPerlKind::*;
+
+        assert!(!self.flags().unicode());
+        let mut class = match ast_class.kind {
+            Digit => hir_ascii_class_bytes(&ast::ClassAsciiKind::Digit),
+            Space => hir_ascii_class_bytes(&ast::ClassAsciiKind::Space),
+            Word => hir_ascii_class_bytes(&ast::ClassAsciiKind::Word),
+        };
+        // We needn't apply case folding here because the Perl ASCII classes
+        // are already closed (under ASCII case folding).
+        if ast_class.negated {
+            class.negate();
+        }
+        class
+    }
+
+    /// Converts the given Unicode specific error to an HIR translation error.
+    ///
+    /// The span given should approximate the position at which an error would
+    /// occur.
+    fn convert_unicode_class_error(
+        &self,
+        span: &Span,
+        result: unicode::Result<hir::ClassUnicode>,
+    ) -> Result<hir::ClassUnicode> {
+        result.map_err(|err| {
+            let sp = span.clone();
+            match err {
+                unicode::Error::PropertyNotFound => {
+                    self.error(sp, ErrorKind::UnicodePropertyNotFound)
+                }
+                unicode::Error::PropertyValueNotFound => {
+                    self.error(sp, ErrorKind::UnicodePropertyValueNotFound)
+                }
+                unicode::Error::PerlClassNotFound => {
+                    self.error(sp, ErrorKind::UnicodePerlClassNotFound)
+                }
+            }
+        })
+    }
+
+    fn unicode_fold_and_negate(
+        &self,
+        span: &Span,
+        negated: bool,
+        class: &mut hir::ClassUnicode,
+    ) -> Result<()> {
+        // Note that we must apply case folding before negation!
+        // Consider `(?i)[^x]`. If we applied negation field, then
+        // the result would be the character class that matched any
+        // Unicode scalar value.
+        if self.flags().case_insensitive() {
+            class.try_case_fold_simple().map_err(|_| {
+                self.error(span.clone(), ErrorKind::UnicodeCaseUnavailable)
+            })?;
+        }
+        if negated {
+            class.negate();
+        }
+        Ok(())
+    }
+
+    fn bytes_fold_and_negate(
+        &self,
+        span: &Span,
+        negated: bool,
+        class: &mut hir::ClassBytes,
+    ) -> Result<()> {
+        // Note that we must apply case folding before negation!
+        // Consider `(?i)[^x]`. If we applied negation first, then
+        // the result would be the character class that matched any
+        // Unicode scalar value.
+        if self.flags().case_insensitive() {
+            class.case_fold_simple();
+        }
+        if negated {
+            class.negate();
+        }
+        if !self.trans().allow_invalid_utf8 && !class.is_all_ascii() {
+            return Err(self.error(span.clone(), ErrorKind::InvalidUtf8));
+        }
+        Ok(())
+    }
+
+    /// Return a scalar byte value suitable for use as a literal in a byte
+    /// character class.
+    fn class_literal_byte(&self, ast: &ast::Literal) -> Result<u8> {
+        match self.literal_to_char(ast)? {
+            hir::Literal::Byte(byte) => Ok(byte),
+            hir::Literal::Unicode(ch) => {
+                if ch <= 0x7F as char {
+                    Ok(ch as u8)
+                } else {
+                    // We can't feasibly support Unicode in
+                    // byte oriented classes. Byte classes don't
+                    // do Unicode case folding.
+                    Err(self.error(ast.span, ErrorKind::UnicodeNotAllowed))
+                }
+            }
+        }
+    }
+}
+
+/// A translator's representation of a regular expression's flags at any given
+/// moment in time.
+///
+/// Each flag can be in one of three states: absent, present but disabled or
+/// present but enabled.
+#[derive(Clone, Copy, Debug, Default)]
+struct Flags {
+    case_insensitive: Option<bool>,
+    multi_line: Option<bool>,
+    dot_matches_new_line: Option<bool>,
+    swap_greed: Option<bool>,
+    unicode: Option<bool>,
+    // Note that `ignore_whitespace` is omitted here because it is handled
+    // entirely in the parser.
+}
+
+impl Flags {
+    fn from_ast(ast: &ast::Flags) -> Flags {
+        let mut flags = Flags::default();
+        let mut enable = true;
+        for item in &ast.items {
+            match item.kind {
+                ast::FlagsItemKind::Negation => {
+                    enable = false;
+                }
+                ast::FlagsItemKind::Flag(ast::Flag::CaseInsensitive) => {
+                    flags.case_insensitive = Some(enable);
+                }
+                ast::FlagsItemKind::Flag(ast::Flag::MultiLine) => {
+                    flags.multi_line = Some(enable);
+                }
+                ast::FlagsItemKind::Flag(ast::Flag::DotMatchesNewLine) => {
+                    flags.dot_matches_new_line = Some(enable);
+                }
+                ast::FlagsItemKind::Flag(ast::Flag::SwapGreed) => {
+                    flags.swap_greed = Some(enable);
+                }
+                ast::FlagsItemKind::Flag(ast::Flag::Unicode) => {
+                    flags.unicode = Some(enable);
+                }
+                ast::FlagsItemKind::Flag(ast::Flag::IgnoreWhitespace) => {}
+            }
+        }
+        flags
+    }
+
+    fn merge(&mut self, previous: &Flags) {
+        if self.case_insensitive.is_none() {
+            self.case_insensitive = previous.case_insensitive;
+        }
+        if self.multi_line.is_none() {
+            self.multi_line = previous.multi_line;
+        }
+        if self.dot_matches_new_line.is_none() {
+            self.dot_matches_new_line = previous.dot_matches_new_line;
+        }
+        if self.swap_greed.is_none() {
+            self.swap_greed = previous.swap_greed;
+        }
+        if self.unicode.is_none() {
+            self.unicode = previous.unicode;
+        }
+    }
+
+    fn case_insensitive(&self) -> bool {
+        self.case_insensitive.unwrap_or(false)
+    }
+
+    fn multi_line(&self) -> bool {
+        self.multi_line.unwrap_or(false)
+    }
+
+    fn dot_matches_new_line(&self) -> bool {
+        self.dot_matches_new_line.unwrap_or(false)
+    }
+
+    fn swap_greed(&self) -> bool {
+        self.swap_greed.unwrap_or(false)
+    }
+
+    fn unicode(&self) -> bool {
+        self.unicode.unwrap_or(true)
+    }
+}
+
+fn hir_ascii_class_bytes(kind: &ast::ClassAsciiKind) -> hir::ClassBytes {
+    let ranges: Vec<_> = ascii_class(kind)
+        .iter()
+        .cloned()
+        .map(|(s, e)| hir::ClassBytesRange::new(s as u8, e as u8))
+        .collect();
+    hir::ClassBytes::new(ranges)
+}
+
+fn ascii_class(kind: &ast::ClassAsciiKind) -> &'static [(char, char)] {
+    use crate::ast::ClassAsciiKind::*;
+    match *kind {
+        Alnum => &[('0', '9'), ('A', 'Z'), ('a', 'z')],
+        Alpha => &[('A', 'Z'), ('a', 'z')],
+        Ascii => &[('\x00', '\x7F')],
+        Blank => &[('\t', '\t'), (' ', ' ')],
+        Cntrl => &[('\x00', '\x1F'), ('\x7F', '\x7F')],
+        Digit => &[('0', '9')],
+        Graph => &[('!', '~')],
+        Lower => &[('a', 'z')],
+        Print => &[(' ', '~')],
+        Punct => &[('!', '/'), (':', '@'), ('[', '`'), ('{', '~')],
+        Space => &[
+            ('\t', '\t'),
+            ('\n', '\n'),
+            ('\x0B', '\x0B'),
+            ('\x0C', '\x0C'),
+            ('\r', '\r'),
+            (' ', ' '),
+        ],
+        Upper => &[('A', 'Z')],
+        Word => &[('0', '9'), ('A', 'Z'), ('_', '_'), ('a', 'z')],
+        Xdigit => &[('0', '9'), ('A', 'F'), ('a', 'f')],
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::ast::parse::ParserBuilder;
+    use crate::ast::{self, Ast, Position, Span};
+    use crate::hir::{self, Hir, HirKind};
+    use crate::unicode::{self, ClassQuery};
+
+    use super::{ascii_class, TranslatorBuilder};
+
+    // We create these errors to compare with real hir::Errors in the tests.
+    // We define equality between TestError and hir::Error to disregard the
+    // pattern string in hir::Error, which is annoying to provide in tests.
+    #[derive(Clone, Debug)]
+    struct TestError {
+        span: Span,
+        kind: hir::ErrorKind,
+    }
+
+    impl PartialEq<hir::Error> for TestError {
+        fn eq(&self, other: &hir::Error) -> bool {
+            self.span == other.span && self.kind == other.kind
+        }
+    }
+
+    impl PartialEq<TestError> for hir::Error {
+        fn eq(&self, other: &TestError) -> bool {
+            self.span == other.span && self.kind == other.kind
+        }
+    }
+
+    fn parse(pattern: &str) -> Ast {
+        ParserBuilder::new().octal(true).build().parse(pattern).unwrap()
+    }
+
+    fn t(pattern: &str) -> Hir {
+        TranslatorBuilder::new()
+            .allow_invalid_utf8(false)
+            .build()
+            .translate(pattern, &parse(pattern))
+            .unwrap()
+    }
+
+    fn t_err(pattern: &str) -> hir::Error {
+        TranslatorBuilder::new()
+            .allow_invalid_utf8(false)
+            .build()
+            .translate(pattern, &parse(pattern))
+            .unwrap_err()
+    }
+
+    fn t_bytes(pattern: &str) -> Hir {
+        TranslatorBuilder::new()
+            .allow_invalid_utf8(true)
+            .build()
+            .translate(pattern, &parse(pattern))
+            .unwrap()
+    }
+
+    fn hir_lit(s: &str) -> Hir {
+        match s.len() {
+            0 => Hir::empty(),
+            _ => {
+                let lits = s
+                    .chars()
+                    .map(hir::Literal::Unicode)
+                    .map(Hir::literal)
+                    .collect();
+                Hir::concat(lits)
+            }
+        }
+    }
+
+    fn hir_blit(s: &[u8]) -> Hir {
+        match s.len() {
+            0 => Hir::empty(),
+            1 => Hir::literal(hir::Literal::Byte(s[0])),
+            _ => {
+                let lits = s
+                    .iter()
+                    .cloned()
+                    .map(hir::Literal::Byte)
+                    .map(Hir::literal)
+                    .collect();
+                Hir::concat(lits)
+            }
+        }
+    }
+
+    fn hir_group(i: u32, expr: Hir) -> Hir {
+        Hir::group(hir::Group {
+            kind: hir::GroupKind::CaptureIndex(i),
+            hir: Box::new(expr),
+        })
+    }
+
+    fn hir_group_name(i: u32, name: &str, expr: Hir) -> Hir {
+        Hir::group(hir::Group {
+            kind: hir::GroupKind::CaptureName {
+                name: name.to_string(),
+                index: i,
+            },
+            hir: Box::new(expr),
+        })
+    }
+
+    fn hir_group_nocap(expr: Hir) -> Hir {
+        Hir::group(hir::Group {
+            kind: hir::GroupKind::NonCapturing,
+            hir: Box::new(expr),
+        })
+    }
+
+    fn hir_quest(greedy: bool, expr: Hir) -> Hir {
+        Hir::repetition(hir::Repetition {
+            kind: hir::RepetitionKind::ZeroOrOne,
+            greedy,
+            hir: Box::new(expr),
+        })
+    }
+
+    fn hir_star(greedy: bool, expr: Hir) -> Hir {
+        Hir::repetition(hir::Repetition {
+            kind: hir::RepetitionKind::ZeroOrMore,
+            greedy,
+            hir: Box::new(expr),
+        })
+    }
+
+    fn hir_plus(greedy: bool, expr: Hir) -> Hir {
+        Hir::repetition(hir::Repetition {
+            kind: hir::RepetitionKind::OneOrMore,
+            greedy,
+            hir: Box::new(expr),
+        })
+    }
+
+    fn hir_range(greedy: bool, range: hir::RepetitionRange, expr: Hir) -> Hir {
+        Hir::repetition(hir::Repetition {
+            kind: hir::RepetitionKind::Range(range),
+            greedy,
+            hir: Box::new(expr),
+        })
+    }
+
+    fn hir_alt(alts: Vec<Hir>) -> Hir {
+        Hir::alternation(alts)
+    }
+
+    fn hir_cat(exprs: Vec<Hir>) -> Hir {
+        Hir::concat(exprs)
+    }
+
+    #[allow(dead_code)]
+    fn hir_uclass_query(query: ClassQuery<'_>) -> Hir {
+        Hir::class(hir::Class::Unicode(unicode::class(query).unwrap()))
+    }
+
+    #[allow(dead_code)]
+    fn hir_uclass_perl_word() -> Hir {
+        Hir::class(hir::Class::Unicode(unicode::perl_word().unwrap()))
+    }
+
+    fn hir_uclass(ranges: &[(char, char)]) -> Hir {
+        let ranges: Vec<hir::ClassUnicodeRange> = ranges
+            .iter()
+            .map(|&(s, e)| hir::ClassUnicodeRange::new(s, e))
+            .collect();
+        Hir::class(hir::Class::Unicode(hir::ClassUnicode::new(ranges)))
+    }
+
+    fn hir_bclass(ranges: &[(u8, u8)]) -> Hir {
+        let ranges: Vec<hir::ClassBytesRange> = ranges
+            .iter()
+            .map(|&(s, e)| hir::ClassBytesRange::new(s, e))
+            .collect();
+        Hir::class(hir::Class::Bytes(hir::ClassBytes::new(ranges)))
+    }
+
+    fn hir_bclass_from_char(ranges: &[(char, char)]) -> Hir {
+        let ranges: Vec<hir::ClassBytesRange> = ranges
+            .iter()
+            .map(|&(s, e)| {
+                assert!(s as u32 <= 0x7F);
+                assert!(e as u32 <= 0x7F);
+                hir::ClassBytesRange::new(s as u8, e as u8)
+            })
+            .collect();
+        Hir::class(hir::Class::Bytes(hir::ClassBytes::new(ranges)))
+    }
+
+    fn hir_case_fold(expr: Hir) -> Hir {
+        match expr.into_kind() {
+            HirKind::Class(mut cls) => {
+                cls.case_fold_simple();
+                Hir::class(cls)
+            }
+            _ => panic!("cannot case fold non-class Hir expr"),
+        }
+    }
+
+    fn hir_negate(expr: Hir) -> Hir {
+        match expr.into_kind() {
+            HirKind::Class(mut cls) => {
+                cls.negate();
+                Hir::class(cls)
+            }
+            _ => panic!("cannot negate non-class Hir expr"),
+        }
+    }
+
+    #[allow(dead_code)]
+    fn hir_union(expr1: Hir, expr2: Hir) -> Hir {
+        use crate::hir::Class::{Bytes, Unicode};
+
+        match (expr1.into_kind(), expr2.into_kind()) {
+            (HirKind::Class(Unicode(mut c1)), HirKind::Class(Unicode(c2))) => {
+                c1.union(&c2);
+                Hir::class(hir::Class::Unicode(c1))
+            }
+            (HirKind::Class(Bytes(mut c1)), HirKind::Class(Bytes(c2))) => {
+                c1.union(&c2);
+                Hir::class(hir::Class::Bytes(c1))
+            }
+            _ => panic!("cannot union non-class Hir exprs"),
+        }
+    }
+
+    #[allow(dead_code)]
+    fn hir_difference(expr1: Hir, expr2: Hir) -> Hir {
+        use crate::hir::Class::{Bytes, Unicode};
+
+        match (expr1.into_kind(), expr2.into_kind()) {
+            (HirKind::Class(Unicode(mut c1)), HirKind::Class(Unicode(c2))) => {
+                c1.difference(&c2);
+                Hir::class(hir::Class::Unicode(c1))
+            }
+            (HirKind::Class(Bytes(mut c1)), HirKind::Class(Bytes(c2))) => {
+                c1.difference(&c2);
+                Hir::class(hir::Class::Bytes(c1))
+            }
+            _ => panic!("cannot difference non-class Hir exprs"),
+        }
+    }
+
+    fn hir_anchor(anchor: hir::Anchor) -> Hir {
+        Hir::anchor(anchor)
+    }
+
+    fn hir_word(wb: hir::WordBoundary) -> Hir {
+        Hir::word_boundary(wb)
+    }
+
+    #[test]
+    fn empty() {
+        assert_eq!(t(""), Hir::empty());
+        assert_eq!(t("(?i)"), Hir::empty());
+        assert_eq!(t("()"), hir_group(1, Hir::empty()));
+        assert_eq!(t("(?:)"), hir_group_nocap(Hir::empty()));
+        assert_eq!(t("(?P<wat>)"), hir_group_name(1, "wat", Hir::empty()));
+        assert_eq!(t("|"), hir_alt(vec![Hir::empty(), Hir::empty()]));
+        assert_eq!(
+            t("()|()"),
+            hir_alt(vec![
+                hir_group(1, Hir::empty()),
+                hir_group(2, Hir::empty()),
+            ])
+        );
+        assert_eq!(
+            t("(|b)"),
+            hir_group(1, hir_alt(vec![Hir::empty(), hir_lit("b"),]))
+        );
+        assert_eq!(
+            t("(a|)"),
+            hir_group(1, hir_alt(vec![hir_lit("a"), Hir::empty(),]))
+        );
+        assert_eq!(
+            t("(a||c)"),
+            hir_group(
+                1,
+                hir_alt(vec![hir_lit("a"), Hir::empty(), hir_lit("c"),])
+            )
+        );
+        assert_eq!(
+            t("(||)"),
+            hir_group(
+                1,
+                hir_alt(vec![Hir::empty(), Hir::empty(), Hir::empty(),])
+            )
+        );
+    }
+
+    #[test]
+    fn literal() {
+        assert_eq!(t("a"), hir_lit("a"));
+        assert_eq!(t("(?-u)a"), hir_lit("a"));
+        assert_eq!(t("☃"), hir_lit("☃"));
+        assert_eq!(t("abcd"), hir_lit("abcd"));
+
+        assert_eq!(t_bytes("(?-u)a"), hir_lit("a"));
+        assert_eq!(t_bytes("(?-u)\x61"), hir_lit("a"));
+        assert_eq!(t_bytes(r"(?-u)\x61"), hir_lit("a"));
+        assert_eq!(t_bytes(r"(?-u)\xFF"), hir_blit(b"\xFF"));
+
+        assert_eq!(
+            t_err("(?-u)☃"),
+            TestError {
+                kind: hir::ErrorKind::UnicodeNotAllowed,
+                span: Span::new(
+                    Position::new(5, 1, 6),
+                    Position::new(8, 1, 7)
+                ),
+            }
+        );
+        assert_eq!(
+            t_err(r"(?-u)\xFF"),
+            TestError {
+                kind: hir::ErrorKind::InvalidUtf8,
+                span: Span::new(
+                    Position::new(5, 1, 6),
+                    Position::new(9, 1, 10)
+                ),
+            }
+        );
+    }
+
+    #[test]
+    fn literal_case_insensitive() {
+        #[cfg(feature = "unicode-case")]
+        assert_eq!(t("(?i)a"), hir_uclass(&[('A', 'A'), ('a', 'a'),]));
+        #[cfg(feature = "unicode-case")]
+        assert_eq!(
+            t("(?i:a)"),
+            hir_group_nocap(hir_uclass(&[('A', 'A'), ('a', 'a')],))
+        );
+        #[cfg(feature = "unicode-case")]
+        assert_eq!(
+            t("a(?i)a(?-i)a"),
+            hir_cat(vec![
+                hir_lit("a"),
+                hir_uclass(&[('A', 'A'), ('a', 'a')]),
+                hir_lit("a"),
+            ])
+        );
+        #[cfg(feature = "unicode-case")]
+        assert_eq!(
+            t("(?i)ab@c"),
+            hir_cat(vec![
+                hir_uclass(&[('A', 'A'), ('a', 'a')]),
+                hir_uclass(&[('B', 'B'), ('b', 'b')]),
+                hir_lit("@"),
+                hir_uclass(&[('C', 'C'), ('c', 'c')]),
+            ])
+        );
+        #[cfg(feature = "unicode-case")]
+        assert_eq!(
+            t("(?i)β"),
+            hir_uclass(&[('Β', 'Β'), ('β', 'β'), ('ϐ', 'ϐ'),])
+        );
+
+        assert_eq!(t("(?i-u)a"), hir_bclass(&[(b'A', b'A'), (b'a', b'a'),]));
+        #[cfg(feature = "unicode-case")]
+        assert_eq!(
+            t("(?-u)a(?i)a(?-i)a"),
+            hir_cat(vec![
+                hir_lit("a"),
+                hir_bclass(&[(b'A', b'A'), (b'a', b'a')]),
+                hir_lit("a"),
+            ])
+        );
+        assert_eq!(
+            t("(?i-u)ab@c"),
+            hir_cat(vec![
+                hir_bclass(&[(b'A', b'A'), (b'a', b'a')]),
+                hir_bclass(&[(b'B', b'B'), (b'b', b'b')]),
+                hir_lit("@"),
+                hir_bclass(&[(b'C', b'C'), (b'c', b'c')]),
+            ])
+        );
+
+        assert_eq!(
+            t_bytes("(?i-u)a"),
+            hir_bclass(&[(b'A', b'A'), (b'a', b'a'),])
+        );
+        assert_eq!(
+            t_bytes("(?i-u)\x61"),
+            hir_bclass(&[(b'A', b'A'), (b'a', b'a'),])
+        );
+        assert_eq!(
+            t_bytes(r"(?i-u)\x61"),
+            hir_bclass(&[(b'A', b'A'), (b'a', b'a'),])
+        );
+        assert_eq!(t_bytes(r"(?i-u)\xFF"), hir_blit(b"\xFF"));
+
+        assert_eq!(
+            t_err("(?i-u)β"),
+            TestError {
+                kind: hir::ErrorKind::UnicodeNotAllowed,
+                span: Span::new(
+                    Position::new(6, 1, 7),
+                    Position::new(8, 1, 8),
+                ),
+            }
+        );
+    }
+
+    #[test]
+    fn dot() {
+        assert_eq!(
+            t("."),
+            hir_uclass(&[('\0', '\t'), ('\x0B', '\u{10FFFF}'),])
+        );
+        assert_eq!(t("(?s)."), hir_uclass(&[('\0', '\u{10FFFF}'),]));
+        assert_eq!(
+            t_bytes("(?-u)."),
+            hir_bclass(&[(b'\0', b'\t'), (b'\x0B', b'\xFF'),])
+        );
+        assert_eq!(t_bytes("(?s-u)."), hir_bclass(&[(b'\0', b'\xFF'),]));
+
+        // If invalid UTF-8 isn't allowed, then non-Unicode `.` isn't allowed.
+        assert_eq!(
+            t_err("(?-u)."),
+            TestError {
+                kind: hir::ErrorKind::InvalidUtf8,
+                span: Span::new(
+                    Position::new(5, 1, 6),
+                    Position::new(6, 1, 7)
+                ),
+            }
+        );
+        assert_eq!(
+            t_err("(?s-u)."),
+            TestError {
+                kind: hir::ErrorKind::InvalidUtf8,
+                span: Span::new(
+                    Position::new(6, 1, 7),
+                    Position::new(7, 1, 8)
+                ),
+            }
+        );
+    }
+
+    #[test]
+    fn assertions() {
+        assert_eq!(t("^"), hir_anchor(hir::Anchor::StartText));
+        assert_eq!(t("$"), hir_anchor(hir::Anchor::EndText));
+        assert_eq!(t(r"\A"), hir_anchor(hir::Anchor::StartText));
+        assert_eq!(t(r"\z"), hir_anchor(hir::Anchor::EndText));
+        assert_eq!(t("(?m)^"), hir_anchor(hir::Anchor::StartLine));
+        assert_eq!(t("(?m)$"), hir_anchor(hir::Anchor::EndLine));
+        assert_eq!(t(r"(?m)\A"), hir_anchor(hir::Anchor::StartText));
+        assert_eq!(t(r"(?m)\z"), hir_anchor(hir::Anchor::EndText));
+
+        assert_eq!(t(r"\b"), hir_word(hir::WordBoundary::Unicode));
+        assert_eq!(t(r"\B"), hir_word(hir::WordBoundary::UnicodeNegate));
+        assert_eq!(t(r"(?-u)\b"), hir_word(hir::WordBoundary::Ascii));
+        assert_eq!(
+            t_bytes(r"(?-u)\B"),
+            hir_word(hir::WordBoundary::AsciiNegate)
+        );
+
+        assert_eq!(
+            t_err(r"(?-u)\B"),
+            TestError {
+                kind: hir::ErrorKind::InvalidUtf8,
+                span: Span::new(
+                    Position::new(5, 1, 6),
+                    Position::new(7, 1, 8)
+                ),
+            }
+        );
+    }
+
+    #[test]
+    fn group() {
+        assert_eq!(t("(a)"), hir_group(1, hir_lit("a")));
+        assert_eq!(
+            t("(a)(b)"),
+            hir_cat(vec![
+                hir_group(1, hir_lit("a")),
+                hir_group(2, hir_lit("b")),
+            ])
+        );
+        assert_eq!(
+            t("(a)|(b)"),
+            hir_alt(vec![
+                hir_group(1, hir_lit("a")),
+                hir_group(2, hir_lit("b")),
+            ])
+        );
+        assert_eq!(t("(?P<foo>)"), hir_group_name(1, "foo", Hir::empty()));
+        assert_eq!(t("(?P<foo>a)"), hir_group_name(1, "foo", hir_lit("a")));
+        assert_eq!(
+            t("(?P<foo>a)(?P<bar>b)"),
+            hir_cat(vec![
+                hir_group_name(1, "foo", hir_lit("a")),
+                hir_group_name(2, "bar", hir_lit("b")),
+            ])
+        );
+        assert_eq!(t("(?:)"), hir_group_nocap(Hir::empty()));
+        assert_eq!(t("(?:a)"), hir_group_nocap(hir_lit("a")));
+        assert_eq!(
+            t("(?:a)(b)"),
+            hir_cat(vec![
+                hir_group_nocap(hir_lit("a")),
+                hir_group(1, hir_lit("b")),
+            ])
+        );
+        assert_eq!(
+            t("(a)(?:b)(c)"),
+            hir_cat(vec![
+                hir_group(1, hir_lit("a")),
+                hir_group_nocap(hir_lit("b")),
+                hir_group(2, hir_lit("c")),
+            ])
+        );
+        assert_eq!(
+            t("(a)(?P<foo>b)(c)"),
+            hir_cat(vec![
+                hir_group(1, hir_lit("a")),
+                hir_group_name(2, "foo", hir_lit("b")),
+                hir_group(3, hir_lit("c")),
+            ])
+        );
+        assert_eq!(t("()"), hir_group(1, Hir::empty()));
+        assert_eq!(t("((?i))"), hir_group(1, Hir::empty()));
+        assert_eq!(t("((?x))"), hir_group(1, Hir::empty()));
+        assert_eq!(t("(((?x)))"), hir_group(1, hir_group(2, Hir::empty())));
+    }
+
+    #[test]
+    fn flags() {
+        #[cfg(feature = "unicode-case")]
+        assert_eq!(
+            t("(?i:a)a"),
+            hir_cat(vec![
+                hir_group_nocap(hir_uclass(&[('A', 'A'), ('a', 'a')])),
+                hir_lit("a"),
+            ])
+        );
+        assert_eq!(
+            t("(?i-u:a)β"),
+            hir_cat(vec![
+                hir_group_nocap(hir_bclass(&[(b'A', b'A'), (b'a', b'a')])),
+                hir_lit("β"),
+            ])
+        );
+        assert_eq!(
+            t("(?:(?i-u)a)b"),
+            hir_cat(vec![
+                hir_group_nocap(hir_bclass(&[(b'A', b'A'), (b'a', b'a')])),
+                hir_lit("b"),
+            ])
+        );
+        assert_eq!(
+            t("((?i-u)a)b"),
+            hir_cat(vec![
+                hir_group(1, hir_bclass(&[(b'A', b'A'), (b'a', b'a')])),
+                hir_lit("b"),
+            ])
+        );
+        #[cfg(feature = "unicode-case")]
+        assert_eq!(
+            t("(?i)(?-i:a)a"),
+            hir_cat(vec![
+                hir_group_nocap(hir_lit("a")),
+                hir_uclass(&[('A', 'A'), ('a', 'a')]),
+            ])
+        );
+        #[cfg(feature = "unicode-case")]
+        assert_eq!(
+            t("(?im)a^"),
+            hir_cat(vec![
+                hir_uclass(&[('A', 'A'), ('a', 'a')]),
+                hir_anchor(hir::Anchor::StartLine),
+            ])
+        );
+        #[cfg(feature = "unicode-case")]
+        assert_eq!(
+            t("(?im)a^(?i-m)a^"),
+            hir_cat(vec![
+                hir_uclass(&[('A', 'A'), ('a', 'a')]),
+                hir_anchor(hir::Anchor::StartLine),
+                hir_uclass(&[('A', 'A'), ('a', 'a')]),
+                hir_anchor(hir::Anchor::StartText),
+            ])
+        );
+        assert_eq!(
+            t("(?U)a*a*?(?-U)a*a*?"),
+            hir_cat(vec![
+                hir_star(false, hir_lit("a")),
+                hir_star(true, hir_lit("a")),
+                hir_star(true, hir_lit("a")),
+                hir_star(false, hir_lit("a")),
+            ])
+        );
+        #[cfg(feature = "unicode-case")]
+        assert_eq!(
+            t("(?:a(?i)a)a"),
+            hir_cat(vec![
+                hir_group_nocap(hir_cat(vec![
+                    hir_lit("a"),
+                    hir_uclass(&[('A', 'A'), ('a', 'a')]),
+                ])),
+                hir_lit("a"),
+            ])
+        );
+        #[cfg(feature = "unicode-case")]
+        assert_eq!(
+            t("(?i)(?:a(?-i)a)a"),
+            hir_cat(vec![
+                hir_group_nocap(hir_cat(vec![
+                    hir_uclass(&[('A', 'A'), ('a', 'a')]),
+                    hir_lit("a"),
+                ])),
+                hir_uclass(&[('A', 'A'), ('a', 'a')]),
+            ])
+        );
+    }
+
+    #[test]
+    fn escape() {
+        assert_eq!(
+            t(r"\\\.\+\*\?\(\)\|\[\]\{\}\^\$\#"),
+            hir_lit(r"\.+*?()|[]{}^$#")
+        );
+    }
+
+    #[test]
+    fn repetition() {
+        assert_eq!(t("a?"), hir_quest(true, hir_lit("a")));
+        assert_eq!(t("a*"), hir_star(true, hir_lit("a")));
+        assert_eq!(t("a+"), hir_plus(true, hir_lit("a")));
+        assert_eq!(t("a??"), hir_quest(false, hir_lit("a")));
+        assert_eq!(t("a*?"), hir_star(false, hir_lit("a")));
+        assert_eq!(t("a+?"), hir_plus(false, hir_lit("a")));
+
+        assert_eq!(
+            t("a{1}"),
+            hir_range(true, hir::RepetitionRange::Exactly(1), hir_lit("a"),)
+        );
+        assert_eq!(
+            t("a{1,}"),
+            hir_range(true, hir::RepetitionRange::AtLeast(1), hir_lit("a"),)
+        );
+        assert_eq!(
+            t("a{1,2}"),
+            hir_range(true, hir::RepetitionRange::Bounded(1, 2), hir_lit("a"),)
+        );
+        assert_eq!(
+            t("a{1}?"),
+            hir_range(false, hir::RepetitionRange::Exactly(1), hir_lit("a"),)
+        );
+        assert_eq!(
+            t("a{1,}?"),
+            hir_range(false, hir::RepetitionRange::AtLeast(1), hir_lit("a"),)
+        );
+        assert_eq!(
+            t("a{1,2}?"),
+            hir_range(
+                false,
+                hir::RepetitionRange::Bounded(1, 2),
+                hir_lit("a"),
+            )
+        );
+
+        assert_eq!(
+            t("ab?"),
+            hir_cat(vec![hir_lit("a"), hir_quest(true, hir_lit("b")),])
+        );
+        assert_eq!(
+            t("(ab)?"),
+            hir_quest(
+                true,
+                hir_group(1, hir_cat(vec![hir_lit("a"), hir_lit("b"),]))
+            )
+        );
+        assert_eq!(
+            t("a|b?"),
+            hir_alt(vec![hir_lit("a"), hir_quest(true, hir_lit("b")),])
+        );
+    }
+
+    #[test]
+    fn cat_alt() {
+        assert_eq!(
+            t("(ab)"),
+            hir_group(1, hir_cat(vec![hir_lit("a"), hir_lit("b"),]))
+        );
+        assert_eq!(t("a|b"), hir_alt(vec![hir_lit("a"), hir_lit("b"),]));
+        assert_eq!(
+            t("a|b|c"),
+            hir_alt(vec![hir_lit("a"), hir_lit("b"), hir_lit("c"),])
+        );
+        assert_eq!(
+            t("ab|bc|cd"),
+            hir_alt(vec![hir_lit("ab"), hir_lit("bc"), hir_lit("cd"),])
+        );
+        assert_eq!(
+            t("(a|b)"),
+            hir_group(1, hir_alt(vec![hir_lit("a"), hir_lit("b"),]))
+        );
+        assert_eq!(
+            t("(a|b|c)"),
+            hir_group(
+                1,
+                hir_alt(vec![hir_lit("a"), hir_lit("b"), hir_lit("c"),])
+            )
+        );
+        assert_eq!(
+            t("(ab|bc|cd)"),
+            hir_group(
+                1,
+                hir_alt(vec![hir_lit("ab"), hir_lit("bc"), hir_lit("cd"),])
+            )
+        );
+        assert_eq!(
+            t("(ab|(bc|(cd)))"),
+            hir_group(
+                1,
+                hir_alt(vec![
+                    hir_lit("ab"),
+                    hir_group(
+                        2,
+                        hir_alt(vec![
+                            hir_lit("bc"),
+                            hir_group(3, hir_lit("cd")),
+                        ])
+                    ),
+                ])
+            )
+        );
+    }
+
+    #[test]
+    fn class_ascii() {
+        assert_eq!(
+            t("[[:alnum:]]"),
+            hir_uclass(ascii_class(&ast::ClassAsciiKind::Alnum))
+        );
+        assert_eq!(
+            t("[[:alpha:]]"),
+            hir_uclass(ascii_class(&ast::ClassAsciiKind::Alpha))
+        );
+        assert_eq!(
+            t("[[:ascii:]]"),
+            hir_uclass(ascii_class(&ast::ClassAsciiKind::Ascii))
+        );
+        assert_eq!(
+            t("[[:blank:]]"),
+            hir_uclass(ascii_class(&ast::ClassAsciiKind::Blank))
+        );
+        assert_eq!(
+            t("[[:cntrl:]]"),
+            hir_uclass(ascii_class(&ast::ClassAsciiKind::Cntrl))
+        );
+        assert_eq!(
+            t("[[:digit:]]"),
+            hir_uclass(ascii_class(&ast::ClassAsciiKind::Digit))
+        );
+        assert_eq!(
+            t("[[:graph:]]"),
+            hir_uclass(ascii_class(&ast::ClassAsciiKind::Graph))
+        );
+        assert_eq!(
+            t("[[:lower:]]"),
+            hir_uclass(ascii_class(&ast::ClassAsciiKind::Lower))
+        );
+        assert_eq!(
+            t("[[:print:]]"),
+            hir_uclass(ascii_class(&ast::ClassAsciiKind::Print))
+        );
+        assert_eq!(
+            t("[[:punct:]]"),
+            hir_uclass(ascii_class(&ast::ClassAsciiKind::Punct))
+        );
+        assert_eq!(
+            t("[[:space:]]"),
+            hir_uclass(ascii_class(&ast::ClassAsciiKind::Space))
+        );
+        assert_eq!(
+            t("[[:upper:]]"),
+            hir_uclass(ascii_class(&ast::ClassAsciiKind::Upper))
+        );
+        assert_eq!(
+            t("[[:word:]]"),
+            hir_uclass(ascii_class(&ast::ClassAsciiKind::Word))
+        );
+        assert_eq!(
+            t("[[:xdigit:]]"),
+            hir_uclass(ascii_class(&ast::ClassAsciiKind::Xdigit))
+        );
+
+        assert_eq!(
+            t("[[:^lower:]]"),
+            hir_negate(hir_uclass(ascii_class(&ast::ClassAsciiKind::Lower)))
+        );
+        #[cfg(feature = "unicode-case")]
+        assert_eq!(
+            t("(?i)[[:lower:]]"),
+            hir_uclass(&[
+                ('A', 'Z'),
+                ('a', 'z'),
+                ('\u{17F}', '\u{17F}'),
+                ('\u{212A}', '\u{212A}'),
+            ])
+        );
+
+        assert_eq!(
+            t("(?-u)[[:lower:]]"),
+            hir_bclass_from_char(ascii_class(&ast::ClassAsciiKind::Lower))
+        );
+        assert_eq!(
+            t("(?i-u)[[:lower:]]"),
+            hir_case_fold(hir_bclass_from_char(ascii_class(
+                &ast::ClassAsciiKind::Lower
+            )))
+        );
+
+        assert_eq!(
+            t_err("(?-u)[[:^lower:]]"),
+            TestError {
+                kind: hir::ErrorKind::InvalidUtf8,
+                span: Span::new(
+                    Position::new(6, 1, 7),
+                    Position::new(16, 1, 17)
+                ),
+            }
+        );
+        assert_eq!(
+            t_err("(?i-u)[[:^lower:]]"),
+            TestError {
+                kind: hir::ErrorKind::InvalidUtf8,
+                span: Span::new(
+                    Position::new(7, 1, 8),
+                    Position::new(17, 1, 18)
+                ),
+            }
+        );
+    }
+
+    #[test]
+    fn class_ascii_multiple() {
+        // See: https://github.com/rust-lang/regex/issues/680
+        assert_eq!(
+            t("[[:alnum:][:^ascii:]]"),
+            hir_union(
+                hir_uclass(ascii_class(&ast::ClassAsciiKind::Alnum)),
+                hir_uclass(&[('\u{80}', '\u{10FFFF}')]),
+            ),
+        );
+        assert_eq!(
+            t_bytes("(?-u)[[:alnum:][:^ascii:]]"),
+            hir_union(
+                hir_bclass_from_char(ascii_class(&ast::ClassAsciiKind::Alnum)),
+                hir_bclass(&[(0x80, 0xFF)]),
+            ),
+        );
+    }
+
+    #[test]
+    #[cfg(feature = "unicode-perl")]
+    fn class_perl() {
+        // Unicode
+        assert_eq!(t(r"\d"), hir_uclass_query(ClassQuery::Binary("digit")));
+        assert_eq!(t(r"\s"), hir_uclass_query(ClassQuery::Binary("space")));
+        assert_eq!(t(r"\w"), hir_uclass_perl_word());
+        #[cfg(feature = "unicode-case")]
+        assert_eq!(
+            t(r"(?i)\d"),
+            hir_uclass_query(ClassQuery::Binary("digit"))
+        );
+        #[cfg(feature = "unicode-case")]
+        assert_eq!(
+            t(r"(?i)\s"),
+            hir_uclass_query(ClassQuery::Binary("space"))
+        );
+        #[cfg(feature = "unicode-case")]
+        assert_eq!(t(r"(?i)\w"), hir_uclass_perl_word());
+
+        // Unicode, negated
+        assert_eq!(
+            t(r"\D"),
+            hir_negate(hir_uclass_query(ClassQuery::Binary("digit")))
+        );
+        assert_eq!(
+            t(r"\S"),
+            hir_negate(hir_uclass_query(ClassQuery::Binary("space")))
+        );
+        assert_eq!(t(r"\W"), hir_negate(hir_uclass_perl_word()));
+        #[cfg(feature = "unicode-case")]
+        assert_eq!(
+            t(r"(?i)\D"),
+            hir_negate(hir_uclass_query(ClassQuery::Binary("digit")))
+        );
+        #[cfg(feature = "unicode-case")]
+        assert_eq!(
+            t(r"(?i)\S"),
+            hir_negate(hir_uclass_query(ClassQuery::Binary("space")))
+        );
+        #[cfg(feature = "unicode-case")]
+        assert_eq!(t(r"(?i)\W"), hir_negate(hir_uclass_perl_word()));
+
+        // ASCII only
+        assert_eq!(
+            t(r"(?-u)\d"),
+            hir_bclass_from_char(ascii_class(&ast::ClassAsciiKind::Digit))
+        );
+        assert_eq!(
+            t(r"(?-u)\s"),
+            hir_bclass_from_char(ascii_class(&ast::ClassAsciiKind::Space))
+        );
+        assert_eq!(
+            t(r"(?-u)\w"),
+            hir_bclass_from_char(ascii_class(&ast::ClassAsciiKind::Word))
+        );
+        assert_eq!(
+            t(r"(?i-u)\d"),
+            hir_bclass_from_char(ascii_class(&ast::ClassAsciiKind::Digit))
+        );
+        assert_eq!(
+            t(r"(?i-u)\s"),
+            hir_bclass_from_char(ascii_class(&ast::ClassAsciiKind::Space))
+        );
+        assert_eq!(
+            t(r"(?i-u)\w"),
+            hir_bclass_from_char(ascii_class(&ast::ClassAsciiKind::Word))
+        );
+
+        // ASCII only, negated
+        assert_eq!(
+            t(r"(?-u)\D"),
+            hir_negate(hir_bclass_from_char(ascii_class(
+                &ast::ClassAsciiKind::Digit
+            )))
+        );
+        assert_eq!(
+            t(r"(?-u)\S"),
+            hir_negate(hir_bclass_from_char(ascii_class(
+                &ast::ClassAsciiKind::Space
+            )))
+        );
+        assert_eq!(
+            t(r"(?-u)\W"),
+            hir_negate(hir_bclass_from_char(ascii_class(
+                &ast::ClassAsciiKind::Word
+            )))
+        );
+        assert_eq!(
+            t(r"(?i-u)\D"),
+            hir_negate(hir_bclass_from_char(ascii_class(
+                &ast::ClassAsciiKind::Digit
+            )))
+        );
+        assert_eq!(
+            t(r"(?i-u)\S"),
+            hir_negate(hir_bclass_from_char(ascii_class(
+                &ast::ClassAsciiKind::Space
+            )))
+        );
+        assert_eq!(
+            t(r"(?i-u)\W"),
+            hir_negate(hir_bclass_from_char(ascii_class(
+                &ast::ClassAsciiKind::Word
+            )))
+        );
+    }
+
+    #[test]
+    #[cfg(not(feature = "unicode-perl"))]
+    fn class_perl_word_disabled() {
+        assert_eq!(
+            t_err(r"\w"),
+            TestError {
+                kind: hir::ErrorKind::UnicodePerlClassNotFound,
+                span: Span::new(
+                    Position::new(0, 1, 1),
+                    Position::new(2, 1, 3)
+                ),
+            }
+        );
+    }
+
+    #[test]
+    #[cfg(all(not(feature = "unicode-perl"), not(feature = "unicode-bool")))]
+    fn class_perl_space_disabled() {
+        assert_eq!(
+            t_err(r"\s"),
+            TestError {
+                kind: hir::ErrorKind::UnicodePerlClassNotFound,
+                span: Span::new(
+                    Position::new(0, 1, 1),
+                    Position::new(2, 1, 3)
+                ),
+            }
+        );
+    }
+
+    #[test]
+    #[cfg(all(
+        not(feature = "unicode-perl"),
+        not(feature = "unicode-gencat")
+    ))]
+    fn class_perl_digit_disabled() {
+        assert_eq!(
+            t_err(r"\d"),
+            TestError {
+                kind: hir::ErrorKind::UnicodePerlClassNotFound,
+                span: Span::new(
+                    Position::new(0, 1, 1),
+                    Position::new(2, 1, 3)
+                ),
+            }
+        );
+    }
+
+    #[test]
+    #[cfg(feature = "unicode-gencat")]
+    fn class_unicode_gencat() {
+        assert_eq!(t(r"\pZ"), hir_uclass_query(ClassQuery::Binary("Z")));
+        assert_eq!(t(r"\pz"), hir_uclass_query(ClassQuery::Binary("Z")));
+        assert_eq!(
+            t(r"\p{Separator}"),
+            hir_uclass_query(ClassQuery::Binary("Z"))
+        );
+        assert_eq!(
+            t(r"\p{se      PaRa ToR}"),
+            hir_uclass_query(ClassQuery::Binary("Z"))
+        );
+        assert_eq!(
+            t(r"\p{gc:Separator}"),
+            hir_uclass_query(ClassQuery::Binary("Z"))
+        );
+        assert_eq!(
+            t(r"\p{gc=Separator}"),
+            hir_uclass_query(ClassQuery::Binary("Z"))
+        );
+        assert_eq!(
+            t(r"\p{Other}"),
+            hir_uclass_query(ClassQuery::Binary("Other"))
+        );
+        assert_eq!(t(r"\pC"), hir_uclass_query(ClassQuery::Binary("Other")));
+
+        assert_eq!(
+            t(r"\PZ"),
+            hir_negate(hir_uclass_query(ClassQuery::Binary("Z")))
+        );
+        assert_eq!(
+            t(r"\P{separator}"),
+            hir_negate(hir_uclass_query(ClassQuery::Binary("Z")))
+        );
+        assert_eq!(
+            t(r"\P{gc!=separator}"),
+            hir_negate(hir_uclass_query(ClassQuery::Binary("Z")))
+        );
+
+        assert_eq!(t(r"\p{any}"), hir_uclass_query(ClassQuery::Binary("Any")));
+        assert_eq!(
+            t(r"\p{assigned}"),
+            hir_uclass_query(ClassQuery::Binary("Assigned"))
+        );
+        assert_eq!(
+            t(r"\p{ascii}"),
+            hir_uclass_query(ClassQuery::Binary("ASCII"))
+        );
+        assert_eq!(
+            t(r"\p{gc:any}"),
+            hir_uclass_query(ClassQuery::Binary("Any"))
+        );
+        assert_eq!(
+            t(r"\p{gc:assigned}"),
+            hir_uclass_query(ClassQuery::Binary("Assigned"))
+        );
+        assert_eq!(
+            t(r"\p{gc:ascii}"),
+            hir_uclass_query(ClassQuery::Binary("ASCII"))
+        );
+
+        assert_eq!(
+            t_err(r"(?-u)\pZ"),
+            TestError {
+                kind: hir::ErrorKind::UnicodeNotAllowed,
+                span: Span::new(
+                    Position::new(5, 1, 6),
+                    Position::new(8, 1, 9)
+                ),
+            }
+        );
+        assert_eq!(
+            t_err(r"(?-u)\p{Separator}"),
+            TestError {
+                kind: hir::ErrorKind::UnicodeNotAllowed,
+                span: Span::new(
+                    Position::new(5, 1, 6),
+                    Position::new(18, 1, 19)
+                ),
+            }
+        );
+        assert_eq!(
+            t_err(r"\pE"),
+            TestError {
+                kind: hir::ErrorKind::UnicodePropertyNotFound,
+                span: Span::new(
+                    Position::new(0, 1, 1),
+                    Position::new(3, 1, 4)
+                ),
+            }
+        );
+        assert_eq!(
+            t_err(r"\p{Foo}"),
+            TestError {
+                kind: hir::ErrorKind::UnicodePropertyNotFound,
+                span: Span::new(
+                    Position::new(0, 1, 1),
+                    Position::new(7, 1, 8)
+                ),
+            }
+        );
+        assert_eq!(
+            t_err(r"\p{gc:Foo}"),
+            TestError {
+                kind: hir::ErrorKind::UnicodePropertyValueNotFound,
+                span: Span::new(
+                    Position::new(0, 1, 1),
+                    Position::new(10, 1, 11)
+                ),
+            }
+        );
+    }
+
+    #[test]
+    #[cfg(not(feature = "unicode-gencat"))]
+    fn class_unicode_gencat_disabled() {
+        assert_eq!(
+            t_err(r"\p{Separator}"),
+            TestError {
+                kind: hir::ErrorKind::UnicodePropertyNotFound,
+                span: Span::new(
+                    Position::new(0, 1, 1),
+                    Position::new(13, 1, 14)
+                ),
+            }
+        );
+
+        assert_eq!(
+            t_err(r"\p{Any}"),
+            TestError {
+                kind: hir::ErrorKind::UnicodePropertyNotFound,
+                span: Span::new(
+                    Position::new(0, 1, 1),
+                    Position::new(7, 1, 8)
+                ),
+            }
+        );
+    }
+
+    #[test]
+    #[cfg(feature = "unicode-script")]
+    fn class_unicode_script() {
+        assert_eq!(
+            t(r"\p{Greek}"),
+            hir_uclass_query(ClassQuery::Binary("Greek"))
+        );
+        #[cfg(feature = "unicode-case")]
+        assert_eq!(
+            t(r"(?i)\p{Greek}"),
+            hir_case_fold(hir_uclass_query(ClassQuery::Binary("Greek")))
+        );
+        #[cfg(feature = "unicode-case")]
+        assert_eq!(
+            t(r"(?i)\P{Greek}"),
+            hir_negate(hir_case_fold(hir_uclass_query(ClassQuery::Binary(
+                "Greek"
+            ))))
+        );
+
+        assert_eq!(
+            t_err(r"\p{sc:Foo}"),
+            TestError {
+                kind: hir::ErrorKind::UnicodePropertyValueNotFound,
+                span: Span::new(
+                    Position::new(0, 1, 1),
+                    Position::new(10, 1, 11)
+                ),
+            }
+        );
+        assert_eq!(
+            t_err(r"\p{scx:Foo}"),
+            TestError {
+                kind: hir::ErrorKind::UnicodePropertyValueNotFound,
+                span: Span::new(
+                    Position::new(0, 1, 1),
+                    Position::new(11, 1, 12)
+                ),
+            }
+        );
+    }
+
+    #[test]
+    #[cfg(not(feature = "unicode-script"))]
+    fn class_unicode_script_disabled() {
+        assert_eq!(
+            t_err(r"\p{Greek}"),
+            TestError {
+                kind: hir::ErrorKind::UnicodePropertyNotFound,
+                span: Span::new(
+                    Position::new(0, 1, 1),
+                    Position::new(9, 1, 10)
+                ),
+            }
+        );
+
+        assert_eq!(
+            t_err(r"\p{scx:Greek}"),
+            TestError {
+                kind: hir::ErrorKind::UnicodePropertyNotFound,
+                span: Span::new(
+                    Position::new(0, 1, 1),
+                    Position::new(13, 1, 14)
+                ),
+            }
+        );
+    }
+
+    #[test]
+    #[cfg(feature = "unicode-age")]
+    fn class_unicode_age() {
+        assert_eq!(
+            t_err(r"\p{age:Foo}"),
+            TestError {
+                kind: hir::ErrorKind::UnicodePropertyValueNotFound,
+                span: Span::new(
+                    Position::new(0, 1, 1),
+                    Position::new(11, 1, 12)
+                ),
+            }
+        );
+    }
+
+    #[test]
+    #[cfg(feature = "unicode-gencat")]
+    fn class_unicode_any_empty() {
+        assert_eq!(
+            t_err(r"\P{any}"),
+            TestError {
+                kind: hir::ErrorKind::EmptyClassNotAllowed,
+                span: Span::new(
+                    Position::new(0, 1, 1),
+                    Position::new(7, 1, 8)
+                ),
+            }
+        );
+    }
+
+    #[test]
+    #[cfg(not(feature = "unicode-age"))]
+    fn class_unicode_age_disabled() {
+        assert_eq!(
+            t_err(r"\p{age:3.0}"),
+            TestError {
+                kind: hir::ErrorKind::UnicodePropertyNotFound,
+                span: Span::new(
+                    Position::new(0, 1, 1),
+                    Position::new(11, 1, 12)
+                ),
+            }
+        );
+    }
+
+    #[test]
+    fn class_bracketed() {
+        assert_eq!(t("[a]"), hir_uclass(&[('a', 'a')]));
+        assert_eq!(t("[^[a]]"), hir_negate(hir_uclass(&[('a', 'a')])));
+        assert_eq!(t("[a-z]"), hir_uclass(&[('a', 'z')]));
+        assert_eq!(t("[a-fd-h]"), hir_uclass(&[('a', 'h')]));
+        assert_eq!(t("[a-fg-m]"), hir_uclass(&[('a', 'm')]));
+        assert_eq!(t(r"[\x00]"), hir_uclass(&[('\0', '\0')]));
+        assert_eq!(t(r"[\n]"), hir_uclass(&[('\n', '\n')]));
+        assert_eq!(t("[\n]"), hir_uclass(&[('\n', '\n')]));
+        #[cfg(any(feature = "unicode-perl", feature = "unicode-gencat"))]
+        assert_eq!(t(r"[\d]"), hir_uclass_query(ClassQuery::Binary("digit")));
+        #[cfg(feature = "unicode-gencat")]
+        assert_eq!(
+            t(r"[\pZ]"),
+            hir_uclass_query(ClassQuery::Binary("separator"))
+        );
+        #[cfg(feature = "unicode-gencat")]
+        assert_eq!(
+            t(r"[\p{separator}]"),
+            hir_uclass_query(ClassQuery::Binary("separator"))
+        );
+        #[cfg(any(feature = "unicode-perl", feature = "unicode-gencat"))]
+        assert_eq!(t(r"[^\D]"), hir_uclass_query(ClassQuery::Binary("digit")));
+        #[cfg(feature = "unicode-gencat")]
+        assert_eq!(
+            t(r"[^\PZ]"),
+            hir_uclass_query(ClassQuery::Binary("separator"))
+        );
+        #[cfg(feature = "unicode-gencat")]
+        assert_eq!(
+            t(r"[^\P{separator}]"),
+            hir_uclass_query(ClassQuery::Binary("separator"))
+        );
+        #[cfg(all(
+            feature = "unicode-case",
+            any(feature = "unicode-perl", feature = "unicode-gencat")
+        ))]
+        assert_eq!(
+            t(r"(?i)[^\D]"),
+            hir_uclass_query(ClassQuery::Binary("digit"))
+        );
+        #[cfg(all(feature = "unicode-case", feature = "unicode-script"))]
+        assert_eq!(
+            t(r"(?i)[^\P{greek}]"),
+            hir_case_fold(hir_uclass_query(ClassQuery::Binary("greek")))
+        );
+
+        assert_eq!(t("(?-u)[a]"), hir_bclass(&[(b'a', b'a')]));
+        assert_eq!(t(r"(?-u)[\x00]"), hir_bclass(&[(b'\0', b'\0')]));
+        assert_eq!(t_bytes(r"(?-u)[\xFF]"), hir_bclass(&[(b'\xFF', b'\xFF')]));
+
+        #[cfg(feature = "unicode-case")]
+        assert_eq!(t("(?i)[a]"), hir_uclass(&[('A', 'A'), ('a', 'a')]));
+        #[cfg(feature = "unicode-case")]
+        assert_eq!(
+            t("(?i)[k]"),
+            hir_uclass(&[('K', 'K'), ('k', 'k'), ('\u{212A}', '\u{212A}'),])
+        );
+        #[cfg(feature = "unicode-case")]
+        assert_eq!(
+            t("(?i)[β]"),
+            hir_uclass(&[('Β', 'Β'), ('β', 'β'), ('ϐ', 'ϐ'),])
+        );
+        assert_eq!(t("(?i-u)[k]"), hir_bclass(&[(b'K', b'K'), (b'k', b'k'),]));
+
+        assert_eq!(t("[^a]"), hir_negate(hir_uclass(&[('a', 'a')])));
+        assert_eq!(t(r"[^\x00]"), hir_negate(hir_uclass(&[('\0', '\0')])));
+        assert_eq!(
+            t_bytes("(?-u)[^a]"),
+            hir_negate(hir_bclass(&[(b'a', b'a')]))
+        );
+        #[cfg(any(feature = "unicode-perl", feature = "unicode-gencat"))]
+        assert_eq!(
+            t(r"[^\d]"),
+            hir_negate(hir_uclass_query(ClassQuery::Binary("digit")))
+        );
+        #[cfg(feature = "unicode-gencat")]
+        assert_eq!(
+            t(r"[^\pZ]"),
+            hir_negate(hir_uclass_query(ClassQuery::Binary("separator")))
+        );
+        #[cfg(feature = "unicode-gencat")]
+        assert_eq!(
+            t(r"[^\p{separator}]"),
+            hir_negate(hir_uclass_query(ClassQuery::Binary("separator")))
+        );
+        #[cfg(all(feature = "unicode-case", feature = "unicode-script"))]
+        assert_eq!(
+            t(r"(?i)[^\p{greek}]"),
+            hir_negate(hir_case_fold(hir_uclass_query(ClassQuery::Binary(
+                "greek"
+            ))))
+        );
+        #[cfg(all(feature = "unicode-case", feature = "unicode-script"))]
+        assert_eq!(
+            t(r"(?i)[\P{greek}]"),
+            hir_negate(hir_case_fold(hir_uclass_query(ClassQuery::Binary(
+                "greek"
+            ))))
+        );
+
+        // Test some weird cases.
+        assert_eq!(t(r"[\[]"), hir_uclass(&[('[', '[')]));
+
+        assert_eq!(t(r"[&]"), hir_uclass(&[('&', '&')]));
+        assert_eq!(t(r"[\&]"), hir_uclass(&[('&', '&')]));
+        assert_eq!(t(r"[\&\&]"), hir_uclass(&[('&', '&')]));
+        assert_eq!(t(r"[\x00-&]"), hir_uclass(&[('\0', '&')]));
+        assert_eq!(t(r"[&-\xFF]"), hir_uclass(&[('&', '\u{FF}')]));
+
+        assert_eq!(t(r"[~]"), hir_uclass(&[('~', '~')]));
+        assert_eq!(t(r"[\~]"), hir_uclass(&[('~', '~')]));
+        assert_eq!(t(r"[\~\~]"), hir_uclass(&[('~', '~')]));
+        assert_eq!(t(r"[\x00-~]"), hir_uclass(&[('\0', '~')]));
+        assert_eq!(t(r"[~-\xFF]"), hir_uclass(&[('~', '\u{FF}')]));
+
+        assert_eq!(t(r"[-]"), hir_uclass(&[('-', '-')]));
+        assert_eq!(t(r"[\-]"), hir_uclass(&[('-', '-')]));
+        assert_eq!(t(r"[\-\-]"), hir_uclass(&[('-', '-')]));
+        assert_eq!(t(r"[\x00-\-]"), hir_uclass(&[('\0', '-')]));
+        assert_eq!(t(r"[\--\xFF]"), hir_uclass(&[('-', '\u{FF}')]));
+
+        assert_eq!(
+            t_err("(?-u)[^a]"),
+            TestError {
+                kind: hir::ErrorKind::InvalidUtf8,
+                span: Span::new(
+                    Position::new(5, 1, 6),
+                    Position::new(9, 1, 10)
+                ),
+            }
+        );
+        #[cfg(any(feature = "unicode-perl", feature = "unicode-bool"))]
+        assert_eq!(
+            t_err(r"[^\s\S]"),
+            TestError {
+                kind: hir::ErrorKind::EmptyClassNotAllowed,
+                span: Span::new(
+                    Position::new(0, 1, 1),
+                    Position::new(7, 1, 8)
+                ),
+            }
+        );
+        #[cfg(any(feature = "unicode-perl", feature = "unicode-bool"))]
+        assert_eq!(
+            t_err(r"(?-u)[^\s\S]"),
+            TestError {
+                kind: hir::ErrorKind::EmptyClassNotAllowed,
+                span: Span::new(
+                    Position::new(5, 1, 6),
+                    Position::new(12, 1, 13)
+                ),
+            }
+        );
+    }
+
+    #[test]
+    fn class_bracketed_union() {
+        assert_eq!(t("[a-zA-Z]"), hir_uclass(&[('A', 'Z'), ('a', 'z')]));
+        #[cfg(feature = "unicode-gencat")]
+        assert_eq!(
+            t(r"[a\pZb]"),
+            hir_union(
+                hir_uclass(&[('a', 'b')]),
+                hir_uclass_query(ClassQuery::Binary("separator"))
+            )
+        );
+        #[cfg(all(feature = "unicode-gencat", feature = "unicode-script"))]
+        assert_eq!(
+            t(r"[\pZ\p{Greek}]"),
+            hir_union(
+                hir_uclass_query(ClassQuery::Binary("greek")),
+                hir_uclass_query(ClassQuery::Binary("separator"))
+            )
+        );
+        #[cfg(all(
+            feature = "unicode-age",
+            feature = "unicode-gencat",
+            feature = "unicode-script"
+        ))]
+        assert_eq!(
+            t(r"[\p{age:3.0}\pZ\p{Greek}]"),
+            hir_union(
+                hir_uclass_query(ClassQuery::ByValue {
+                    property_name: "age",
+                    property_value: "3.0",
+                }),
+                hir_union(
+                    hir_uclass_query(ClassQuery::Binary("greek")),
+                    hir_uclass_query(ClassQuery::Binary("separator"))
+                )
+            )
+        );
+        #[cfg(all(
+            feature = "unicode-age",
+            feature = "unicode-gencat",
+            feature = "unicode-script"
+        ))]
+        assert_eq!(
+            t(r"[[[\p{age:3.0}\pZ]\p{Greek}][\p{Cyrillic}]]"),
+            hir_union(
+                hir_uclass_query(ClassQuery::ByValue {
+                    property_name: "age",
+                    property_value: "3.0",
+                }),
+                hir_union(
+                    hir_uclass_query(ClassQuery::Binary("cyrillic")),
+                    hir_union(
+                        hir_uclass_query(ClassQuery::Binary("greek")),
+                        hir_uclass_query(ClassQuery::Binary("separator"))
+                    )
+                )
+            )
+        );
+
+        #[cfg(all(
+            feature = "unicode-age",
+            feature = "unicode-case",
+            feature = "unicode-gencat",
+            feature = "unicode-script"
+        ))]
+        assert_eq!(
+            t(r"(?i)[\p{age:3.0}\pZ\p{Greek}]"),
+            hir_case_fold(hir_union(
+                hir_uclass_query(ClassQuery::ByValue {
+                    property_name: "age",
+                    property_value: "3.0",
+                }),
+                hir_union(
+                    hir_uclass_query(ClassQuery::Binary("greek")),
+                    hir_uclass_query(ClassQuery::Binary("separator"))
+                )
+            ))
+        );
+        #[cfg(all(
+            feature = "unicode-age",
+            feature = "unicode-gencat",
+            feature = "unicode-script"
+        ))]
+        assert_eq!(
+            t(r"[^\p{age:3.0}\pZ\p{Greek}]"),
+            hir_negate(hir_union(
+                hir_uclass_query(ClassQuery::ByValue {
+                    property_name: "age",
+                    property_value: "3.0",
+                }),
+                hir_union(
+                    hir_uclass_query(ClassQuery::Binary("greek")),
+                    hir_uclass_query(ClassQuery::Binary("separator"))
+                )
+            ))
+        );
+        #[cfg(all(
+            feature = "unicode-age",
+            feature = "unicode-case",
+            feature = "unicode-gencat",
+            feature = "unicode-script"
+        ))]
+        assert_eq!(
+            t(r"(?i)[^\p{age:3.0}\pZ\p{Greek}]"),
+            hir_negate(hir_case_fold(hir_union(
+                hir_uclass_query(ClassQuery::ByValue {
+                    property_name: "age",
+                    property_value: "3.0",
+                }),
+                hir_union(
+                    hir_uclass_query(ClassQuery::Binary("greek")),
+                    hir_uclass_query(ClassQuery::Binary("separator"))
+                )
+            )))
+        );
+    }
+
+    #[test]
+    fn class_bracketed_nested() {
+        assert_eq!(t(r"[a[^c]]"), hir_negate(hir_uclass(&[('c', 'c')])));
+        assert_eq!(t(r"[a-b[^c]]"), hir_negate(hir_uclass(&[('c', 'c')])));
+        assert_eq!(t(r"[a-c[^c]]"), hir_negate(hir_uclass(&[])));
+
+        assert_eq!(t(r"[^a[^c]]"), hir_uclass(&[('c', 'c')]));
+        assert_eq!(t(r"[^a-b[^c]]"), hir_uclass(&[('c', 'c')]));
+
+        #[cfg(feature = "unicode-case")]
+        assert_eq!(
+            t(r"(?i)[a[^c]]"),
+            hir_negate(hir_case_fold(hir_uclass(&[('c', 'c')])))
+        );
+        #[cfg(feature = "unicode-case")]
+        assert_eq!(
+            t(r"(?i)[a-b[^c]]"),
+            hir_negate(hir_case_fold(hir_uclass(&[('c', 'c')])))
+        );
+
+        #[cfg(feature = "unicode-case")]
+        assert_eq!(t(r"(?i)[^a[^c]]"), hir_uclass(&[('C', 'C'), ('c', 'c')]));
+        #[cfg(feature = "unicode-case")]
+        assert_eq!(
+            t(r"(?i)[^a-b[^c]]"),
+            hir_uclass(&[('C', 'C'), ('c', 'c')])
+        );
+
+        assert_eq!(
+            t_err(r"[^a-c[^c]]"),
+            TestError {
+                kind: hir::ErrorKind::EmptyClassNotAllowed,
+                span: Span::new(
+                    Position::new(0, 1, 1),
+                    Position::new(10, 1, 11)
+                ),
+            }
+        );
+        #[cfg(feature = "unicode-case")]
+        assert_eq!(
+            t_err(r"(?i)[^a-c[^c]]"),
+            TestError {
+                kind: hir::ErrorKind::EmptyClassNotAllowed,
+                span: Span::new(
+                    Position::new(4, 1, 5),
+                    Position::new(14, 1, 15)
+                ),
+            }
+        );
+    }
+
+    #[test]
+    fn class_bracketed_intersect() {
+        assert_eq!(t("[abc&&b-c]"), hir_uclass(&[('b', 'c')]));
+        assert_eq!(t("[abc&&[b-c]]"), hir_uclass(&[('b', 'c')]));
+        assert_eq!(t("[[abc]&&[b-c]]"), hir_uclass(&[('b', 'c')]));
+        assert_eq!(t("[a-z&&b-y&&c-x]"), hir_uclass(&[('c', 'x')]));
+        assert_eq!(t("[c-da-b&&a-d]"), hir_uclass(&[('a', 'd')]));
+        assert_eq!(t("[a-d&&c-da-b]"), hir_uclass(&[('a', 'd')]));
+        assert_eq!(t(r"[a-z&&a-c]"), hir_uclass(&[('a', 'c')]));
+        assert_eq!(t(r"[[a-z&&a-c]]"), hir_uclass(&[('a', 'c')]));
+        assert_eq!(t(r"[^[a-z&&a-c]]"), hir_negate(hir_uclass(&[('a', 'c')])));
+
+        assert_eq!(t("(?-u)[abc&&b-c]"), hir_bclass(&[(b'b', b'c')]));
+        assert_eq!(t("(?-u)[abc&&[b-c]]"), hir_bclass(&[(b'b', b'c')]));
+        assert_eq!(t("(?-u)[[abc]&&[b-c]]"), hir_bclass(&[(b'b', b'c')]));
+        assert_eq!(t("(?-u)[a-z&&b-y&&c-x]"), hir_bclass(&[(b'c', b'x')]));
+        assert_eq!(t("(?-u)[c-da-b&&a-d]"), hir_bclass(&[(b'a', b'd')]));
+        assert_eq!(t("(?-u)[a-d&&c-da-b]"), hir_bclass(&[(b'a', b'd')]));
+
+        #[cfg(feature = "unicode-case")]
+        assert_eq!(
+            t("(?i)[abc&&b-c]"),
+            hir_case_fold(hir_uclass(&[('b', 'c')]))
+        );
+        #[cfg(feature = "unicode-case")]
+        assert_eq!(
+            t("(?i)[abc&&[b-c]]"),
+            hir_case_fold(hir_uclass(&[('b', 'c')]))
+        );
+        #[cfg(feature = "unicode-case")]
+        assert_eq!(
+            t("(?i)[[abc]&&[b-c]]"),
+            hir_case_fold(hir_uclass(&[('b', 'c')]))
+        );
+        #[cfg(feature = "unicode-case")]
+        assert_eq!(
+            t("(?i)[a-z&&b-y&&c-x]"),
+            hir_case_fold(hir_uclass(&[('c', 'x')]))
+        );
+        #[cfg(feature = "unicode-case")]
+        assert_eq!(
+            t("(?i)[c-da-b&&a-d]"),
+            hir_case_fold(hir_uclass(&[('a', 'd')]))
+        );
+        #[cfg(feature = "unicode-case")]
+        assert_eq!(
+            t("(?i)[a-d&&c-da-b]"),
+            hir_case_fold(hir_uclass(&[('a', 'd')]))
+        );
+
+        assert_eq!(
+            t("(?i-u)[abc&&b-c]"),
+            hir_case_fold(hir_bclass(&[(b'b', b'c')]))
+        );
+        assert_eq!(
+            t("(?i-u)[abc&&[b-c]]"),
+            hir_case_fold(hir_bclass(&[(b'b', b'c')]))
+        );
+        assert_eq!(
+            t("(?i-u)[[abc]&&[b-c]]"),
+            hir_case_fold(hir_bclass(&[(b'b', b'c')]))
+        );
+        assert_eq!(
+            t("(?i-u)[a-z&&b-y&&c-x]"),
+            hir_case_fold(hir_bclass(&[(b'c', b'x')]))
+        );
+        assert_eq!(
+            t("(?i-u)[c-da-b&&a-d]"),
+            hir_case_fold(hir_bclass(&[(b'a', b'd')]))
+        );
+        assert_eq!(
+            t("(?i-u)[a-d&&c-da-b]"),
+            hir_case_fold(hir_bclass(&[(b'a', b'd')]))
+        );
+
+        // In `[a^]`, `^` does not need to be escaped, so it makes sense that
+        // `^` is also allowed to be unescaped after `&&`.
+        assert_eq!(t(r"[\^&&^]"), hir_uclass(&[('^', '^')]));
+        // `]` needs to be escaped after `&&` since it's not at start of class.
+        assert_eq!(t(r"[]&&\]]"), hir_uclass(&[(']', ']')]));
+        assert_eq!(t(r"[-&&-]"), hir_uclass(&[('-', '-')]));
+        assert_eq!(t(r"[\&&&&]"), hir_uclass(&[('&', '&')]));
+        assert_eq!(t(r"[\&&&\&]"), hir_uclass(&[('&', '&')]));
+        // Test precedence.
+        assert_eq!(
+            t(r"[a-w&&[^c-g]z]"),
+            hir_uclass(&[('a', 'b'), ('h', 'w')])
+        );
+    }
+
+    #[test]
+    fn class_bracketed_intersect_negate() {
+        #[cfg(feature = "unicode-perl")]
+        assert_eq!(
+            t(r"[^\w&&\d]"),
+            hir_negate(hir_uclass_query(ClassQuery::Binary("digit")))
+        );
+        assert_eq!(t(r"[^[a-z&&a-c]]"), hir_negate(hir_uclass(&[('a', 'c')])));
+        #[cfg(feature = "unicode-perl")]
+        assert_eq!(
+            t(r"[^[\w&&\d]]"),
+            hir_negate(hir_uclass_query(ClassQuery::Binary("digit")))
+        );
+        #[cfg(feature = "unicode-perl")]
+        assert_eq!(
+            t(r"[^[^\w&&\d]]"),
+            hir_uclass_query(ClassQuery::Binary("digit"))
+        );
+        #[cfg(feature = "unicode-perl")]
+        assert_eq!(t(r"[[[^\w]&&[^\d]]]"), hir_negate(hir_uclass_perl_word()));
+
+        #[cfg(feature = "unicode-perl")]
+        assert_eq!(
+            t_bytes(r"(?-u)[^\w&&\d]"),
+            hir_negate(hir_bclass_from_char(ascii_class(
+                &ast::ClassAsciiKind::Digit
+            )))
+        );
+        assert_eq!(
+            t_bytes(r"(?-u)[^[a-z&&a-c]]"),
+            hir_negate(hir_bclass(&[(b'a', b'c')]))
+        );
+        assert_eq!(
+            t_bytes(r"(?-u)[^[\w&&\d]]"),
+            hir_negate(hir_bclass_from_char(ascii_class(
+                &ast::ClassAsciiKind::Digit
+            )))
+        );
+        assert_eq!(
+            t_bytes(r"(?-u)[^[^\w&&\d]]"),
+            hir_bclass_from_char(ascii_class(&ast::ClassAsciiKind::Digit))
+        );
+        assert_eq!(
+            t_bytes(r"(?-u)[[[^\w]&&[^\d]]]"),
+            hir_negate(hir_bclass_from_char(ascii_class(
+                &ast::ClassAsciiKind::Word
+            )))
+        );
+    }
+
+    #[test]
+    fn class_bracketed_difference() {
+        #[cfg(feature = "unicode-gencat")]
+        assert_eq!(
+            t(r"[\pL--[:ascii:]]"),
+            hir_difference(
+                hir_uclass_query(ClassQuery::Binary("letter")),
+                hir_uclass(&[('\0', '\x7F')])
+            )
+        );
+
+        assert_eq!(
+            t(r"(?-u)[[:alpha:]--[:lower:]]"),
+            hir_bclass(&[(b'A', b'Z')])
+        );
+    }
+
+    #[test]
+    fn class_bracketed_symmetric_difference() {
+        #[cfg(feature = "unicode-script")]
+        assert_eq!(
+            t(r"[\p{sc:Greek}~~\p{scx:Greek}]"),
+            hir_uclass(&[
+                ('\u{0342}', '\u{0342}'),
+                ('\u{0345}', '\u{0345}'),
+                ('\u{1DC0}', '\u{1DC1}'),
+            ])
+        );
+        assert_eq!(t(r"[a-g~~c-j]"), hir_uclass(&[('a', 'b'), ('h', 'j')]));
+
+        assert_eq!(
+            t(r"(?-u)[a-g~~c-j]"),
+            hir_bclass(&[(b'a', b'b'), (b'h', b'j')])
+        );
+    }
+
+    #[test]
+    fn ignore_whitespace() {
+        assert_eq!(t(r"(?x)\12 3"), hir_lit("\n3"));
+        assert_eq!(t(r"(?x)\x { 53 }"), hir_lit("S"));
+        assert_eq!(
+            t(r"(?x)\x # comment
+{ # comment
+    53 # comment
+} #comment"),
+            hir_lit("S")
+        );
+
+        assert_eq!(t(r"(?x)\x 53"), hir_lit("S"));
+        assert_eq!(
+            t(r"(?x)\x # comment
+        53 # comment"),
+            hir_lit("S")
+        );
+        assert_eq!(t(r"(?x)\x5 3"), hir_lit("S"));
+
+        #[cfg(feature = "unicode-gencat")]
+        assert_eq!(
+            t(r"(?x)\p # comment
+{ # comment
+    Separator # comment
+} # comment"),
+            hir_uclass_query(ClassQuery::Binary("separator"))
+        );
+
+        assert_eq!(
+            t(r"(?x)a # comment
+{ # comment
+    5 # comment
+    , # comment
+    10 # comment
+} # comment"),
+            hir_range(
+                true,
+                hir::RepetitionRange::Bounded(5, 10),
+                hir_lit("a")
+            )
+        );
+
+        assert_eq!(t(r"(?x)a\  # hi there"), hir_lit("a "));
+    }
+
+    #[test]
+    fn analysis_is_always_utf8() {
+        // Positive examples.
+        assert!(t_bytes(r"a").is_always_utf8());
+        assert!(t_bytes(r"ab").is_always_utf8());
+        assert!(t_bytes(r"(?-u)a").is_always_utf8());
+        assert!(t_bytes(r"(?-u)ab").is_always_utf8());
+        assert!(t_bytes(r"\xFF").is_always_utf8());
+        assert!(t_bytes(r"\xFF\xFF").is_always_utf8());
+        assert!(t_bytes(r"[^a]").is_always_utf8());
+        assert!(t_bytes(r"[^a][^a]").is_always_utf8());
+        assert!(t_bytes(r"\b").is_always_utf8());
+        assert!(t_bytes(r"\B").is_always_utf8());
+        assert!(t_bytes(r"(?-u)\b").is_always_utf8());
+
+        // Negative examples.
+        assert!(!t_bytes(r"(?-u)\xFF").is_always_utf8());
+        assert!(!t_bytes(r"(?-u)\xFF\xFF").is_always_utf8());
+        assert!(!t_bytes(r"(?-u)[^a]").is_always_utf8());
+        assert!(!t_bytes(r"(?-u)[^a][^a]").is_always_utf8());
+        assert!(!t_bytes(r"(?-u)\B").is_always_utf8());
+    }
+
+    #[test]
+    fn analysis_is_all_assertions() {
+        // Positive examples.
+        assert!(t(r"\b").is_all_assertions());
+        assert!(t(r"\B").is_all_assertions());
+        assert!(t(r"^").is_all_assertions());
+        assert!(t(r"$").is_all_assertions());
+        assert!(t(r"\A").is_all_assertions());
+        assert!(t(r"\z").is_all_assertions());
+        assert!(t(r"$^\z\A\b\B").is_all_assertions());
+        assert!(t(r"$|^|\z|\A|\b|\B").is_all_assertions());
+        assert!(t(r"^$|$^").is_all_assertions());
+        assert!(t(r"((\b)+())*^").is_all_assertions());
+
+        // Negative examples.
+        assert!(!t(r"^a").is_all_assertions());
+    }
+
+    #[test]
+    fn analysis_is_anchored() {
+        // Positive examples.
+        assert!(t(r"^").is_anchored_start());
+        assert!(t(r"$").is_anchored_end());
+        assert!(t(r"^").is_line_anchored_start());
+        assert!(t(r"$").is_line_anchored_end());
+
+        assert!(t(r"^^").is_anchored_start());
+        assert!(t(r"$$").is_anchored_end());
+        assert!(t(r"^^").is_line_anchored_start());
+        assert!(t(r"$$").is_line_anchored_end());
+
+        assert!(t(r"^$").is_anchored_start());
+        assert!(t(r"^$").is_anchored_end());
+        assert!(t(r"^$").is_line_anchored_start());
+        assert!(t(r"^$").is_line_anchored_end());
+
+        assert!(t(r"^foo").is_anchored_start());
+        assert!(t(r"foo$").is_anchored_end());
+        assert!(t(r"^foo").is_line_anchored_start());
+        assert!(t(r"foo$").is_line_anchored_end());
+
+        assert!(t(r"^foo|^bar").is_anchored_start());
+        assert!(t(r"foo$|bar$").is_anchored_end());
+        assert!(t(r"^foo|^bar").is_line_anchored_start());
+        assert!(t(r"foo$|bar$").is_line_anchored_end());
+
+        assert!(t(r"^(foo|bar)").is_anchored_start());
+        assert!(t(r"(foo|bar)$").is_anchored_end());
+        assert!(t(r"^(foo|bar)").is_line_anchored_start());
+        assert!(t(r"(foo|bar)$").is_line_anchored_end());
+
+        assert!(t(r"^+").is_anchored_start());
+        assert!(t(r"$+").is_anchored_end());
+        assert!(t(r"^+").is_line_anchored_start());
+        assert!(t(r"$+").is_line_anchored_end());
+        assert!(t(r"^++").is_anchored_start());
+        assert!(t(r"$++").is_anchored_end());
+        assert!(t(r"^++").is_line_anchored_start());
+        assert!(t(r"$++").is_line_anchored_end());
+        assert!(t(r"(^)+").is_anchored_start());
+        assert!(t(r"($)+").is_anchored_end());
+        assert!(t(r"(^)+").is_line_anchored_start());
+        assert!(t(r"($)+").is_line_anchored_end());
+
+        assert!(t(r"$^").is_anchored_start());
+        assert!(t(r"$^").is_anchored_start());
+        assert!(t(r"$^").is_line_anchored_end());
+        assert!(t(r"$^").is_line_anchored_end());
+        assert!(t(r"$^|^$").is_anchored_start());
+        assert!(t(r"$^|^$").is_anchored_end());
+        assert!(t(r"$^|^$").is_line_anchored_start());
+        assert!(t(r"$^|^$").is_line_anchored_end());
+
+        assert!(t(r"\b^").is_anchored_start());
+        assert!(t(r"$\b").is_anchored_end());
+        assert!(t(r"\b^").is_line_anchored_start());
+        assert!(t(r"$\b").is_line_anchored_end());
+        assert!(t(r"^(?m:^)").is_anchored_start());
+        assert!(t(r"(?m:$)$").is_anchored_end());
+        assert!(t(r"^(?m:^)").is_line_anchored_start());
+        assert!(t(r"(?m:$)$").is_line_anchored_end());
+        assert!(t(r"(?m:^)^").is_anchored_start());
+        assert!(t(r"$(?m:$)").is_anchored_end());
+        assert!(t(r"(?m:^)^").is_line_anchored_start());
+        assert!(t(r"$(?m:$)").is_line_anchored_end());
+
+        // Negative examples.
+        assert!(!t(r"(?m)^").is_anchored_start());
+        assert!(!t(r"(?m)$").is_anchored_end());
+        assert!(!t(r"(?m:^$)|$^").is_anchored_start());
+        assert!(!t(r"(?m:^$)|$^").is_anchored_end());
+        assert!(!t(r"$^|(?m:^$)").is_anchored_start());
+        assert!(!t(r"$^|(?m:^$)").is_anchored_end());
+
+        assert!(!t(r"a^").is_anchored_start());
+        assert!(!t(r"$a").is_anchored_start());
+        assert!(!t(r"a^").is_line_anchored_start());
+        assert!(!t(r"$a").is_line_anchored_start());
+
+        assert!(!t(r"a^").is_anchored_end());
+        assert!(!t(r"$a").is_anchored_end());
+        assert!(!t(r"a^").is_line_anchored_end());
+        assert!(!t(r"$a").is_line_anchored_end());
+
+        assert!(!t(r"^foo|bar").is_anchored_start());
+        assert!(!t(r"foo|bar$").is_anchored_end());
+        assert!(!t(r"^foo|bar").is_line_anchored_start());
+        assert!(!t(r"foo|bar$").is_line_anchored_end());
+
+        assert!(!t(r"^*").is_anchored_start());
+        assert!(!t(r"$*").is_anchored_end());
+        assert!(!t(r"^*").is_line_anchored_start());
+        assert!(!t(r"$*").is_line_anchored_end());
+        assert!(!t(r"^*+").is_anchored_start());
+        assert!(!t(r"$*+").is_anchored_end());
+        assert!(!t(r"^*+").is_line_anchored_start());
+        assert!(!t(r"$*+").is_line_anchored_end());
+        assert!(!t(r"^+*").is_anchored_start());
+        assert!(!t(r"$+*").is_anchored_end());
+        assert!(!t(r"^+*").is_line_anchored_start());
+        assert!(!t(r"$+*").is_line_anchored_end());
+        assert!(!t(r"(^)*").is_anchored_start());
+        assert!(!t(r"($)*").is_anchored_end());
+        assert!(!t(r"(^)*").is_line_anchored_start());
+        assert!(!t(r"($)*").is_line_anchored_end());
+    }
+
+    #[test]
+    fn analysis_is_line_anchored() {
+        assert!(t(r"(?m)^(foo|bar)").is_line_anchored_start());
+        assert!(t(r"(?m)(foo|bar)$").is_line_anchored_end());
+
+        assert!(t(r"(?m)^foo|^bar").is_line_anchored_start());
+        assert!(t(r"(?m)foo$|bar$").is_line_anchored_end());
+
+        assert!(t(r"(?m)^").is_line_anchored_start());
+        assert!(t(r"(?m)$").is_line_anchored_end());
+
+        assert!(t(r"(?m:^$)|$^").is_line_anchored_start());
+        assert!(t(r"(?m:^$)|$^").is_line_anchored_end());
+
+        assert!(t(r"$^|(?m:^$)").is_line_anchored_start());
+        assert!(t(r"$^|(?m:^$)").is_line_anchored_end());
+    }
+
+    #[test]
+    fn analysis_is_any_anchored() {
+        // Positive examples.
+        assert!(t(r"^").is_any_anchored_start());
+        assert!(t(r"$").is_any_anchored_end());
+        assert!(t(r"\A").is_any_anchored_start());
+        assert!(t(r"\z").is_any_anchored_end());
+
+        // Negative examples.
+        assert!(!t(r"(?m)^").is_any_anchored_start());
+        assert!(!t(r"(?m)$").is_any_anchored_end());
+        assert!(!t(r"$").is_any_anchored_start());
+        assert!(!t(r"^").is_any_anchored_end());
+    }
+
+    #[test]
+    fn analysis_is_match_empty() {
+        // Positive examples.
+        assert!(t(r"").is_match_empty());
+        assert!(t(r"()").is_match_empty());
+        assert!(t(r"()*").is_match_empty());
+        assert!(t(r"()+").is_match_empty());
+        assert!(t(r"()?").is_match_empty());
+        assert!(t(r"a*").is_match_empty());
+        assert!(t(r"a?").is_match_empty());
+        assert!(t(r"a{0}").is_match_empty());
+        assert!(t(r"a{0,}").is_match_empty());
+        assert!(t(r"a{0,1}").is_match_empty());
+        assert!(t(r"a{0,10}").is_match_empty());
+        #[cfg(feature = "unicode-gencat")]
+        assert!(t(r"\pL*").is_match_empty());
+        assert!(t(r"a*|b").is_match_empty());
+        assert!(t(r"b|a*").is_match_empty());
+        assert!(t(r"a|").is_match_empty());
+        assert!(t(r"|a").is_match_empty());
+        assert!(t(r"a||b").is_match_empty());
+        assert!(t(r"a*a?(abcd)*").is_match_empty());
+        assert!(t(r"^").is_match_empty());
+        assert!(t(r"$").is_match_empty());
+        assert!(t(r"(?m)^").is_match_empty());
+        assert!(t(r"(?m)$").is_match_empty());
+        assert!(t(r"\A").is_match_empty());
+        assert!(t(r"\z").is_match_empty());
+        assert!(t(r"\B").is_match_empty());
+        assert!(t_bytes(r"(?-u)\B").is_match_empty());
+        assert!(t(r"\b").is_match_empty());
+        assert!(t(r"(?-u)\b").is_match_empty());
+
+        // Negative examples.
+        assert!(!t(r"a+").is_match_empty());
+        assert!(!t(r"a{1}").is_match_empty());
+        assert!(!t(r"a{1,}").is_match_empty());
+        assert!(!t(r"a{1,2}").is_match_empty());
+        assert!(!t(r"a{1,10}").is_match_empty());
+        assert!(!t(r"b|a").is_match_empty());
+        assert!(!t(r"a*a+(abcd)*").is_match_empty());
+    }
+
+    #[test]
+    fn analysis_is_literal() {
+        // Positive examples.
+        assert!(t(r"a").is_literal());
+        assert!(t(r"ab").is_literal());
+        assert!(t(r"abc").is_literal());
+        assert!(t(r"(?m)abc").is_literal());
+
+        // Negative examples.
+        assert!(!t(r"").is_literal());
+        assert!(!t(r"^").is_literal());
+        assert!(!t(r"a|b").is_literal());
+        assert!(!t(r"(a)").is_literal());
+        assert!(!t(r"a+").is_literal());
+        assert!(!t(r"foo(a)").is_literal());
+        assert!(!t(r"(a)foo").is_literal());
+        assert!(!t(r"[a]").is_literal());
+    }
+
+    #[test]
+    fn analysis_is_alternation_literal() {
+        // Positive examples.
+        assert!(t(r"a").is_alternation_literal());
+        assert!(t(r"ab").is_alternation_literal());
+        assert!(t(r"abc").is_alternation_literal());
+        assert!(t(r"(?m)abc").is_alternation_literal());
+        assert!(t(r"a|b").is_alternation_literal());
+        assert!(t(r"a|b|c").is_alternation_literal());
+        assert!(t(r"foo|bar").is_alternation_literal());
+        assert!(t(r"foo|bar|baz").is_alternation_literal());
+
+        // Negative examples.
+        assert!(!t(r"").is_alternation_literal());
+        assert!(!t(r"^").is_alternation_literal());
+        assert!(!t(r"(a)").is_alternation_literal());
+        assert!(!t(r"a+").is_alternation_literal());
+        assert!(!t(r"foo(a)").is_alternation_literal());
+        assert!(!t(r"(a)foo").is_alternation_literal());
+        assert!(!t(r"[a]").is_alternation_literal());
+        assert!(!t(r"[a]|b").is_alternation_literal());
+        assert!(!t(r"a|[b]").is_alternation_literal());
+        assert!(!t(r"(a)|b").is_alternation_literal());
+        assert!(!t(r"a|(b)").is_alternation_literal());
+    }
+}
diff --git a/crates/regex-syntax/src/hir/visitor.rs b/crates/regex-syntax/src/hir/visitor.rs
new file mode 100644
index 0000000..4f5a709
--- /dev/null
+++ b/crates/regex-syntax/src/hir/visitor.rs
@@ -0,0 +1,203 @@
+use crate::hir::{self, Hir, HirKind};
+
+/// A trait for visiting the high-level IR (HIR) in depth first order.
+///
+/// The principle aim of this trait is to enable callers to perform case
+/// analysis on a high-level intermediate representation of a regular
+/// expression without necessarily using recursion. In particular, this permits
+/// callers to do case analysis with constant stack usage, which can be
+/// important since the size of an HIR may be proportional to end user input.
+///
+/// Typical usage of this trait involves providing an implementation and then
+/// running it using the [`visit`](fn.visit.html) function.
+pub trait Visitor {
+    /// The result of visiting an HIR.
+    type Output;
+    /// An error that visiting an HIR might return.
+    type Err;
+
+    /// All implementors of `Visitor` must provide a `finish` method, which
+    /// yields the result of visiting the HIR or an error.
+    fn finish(self) -> Result<Self::Output, Self::Err>;
+
+    /// This method is called before beginning traversal of the HIR.
+    fn start(&mut self) {}
+
+    /// This method is called on an `Hir` before descending into child `Hir`
+    /// nodes.
+    fn visit_pre(&mut self, _hir: &Hir) -> Result<(), Self::Err> {
+        Ok(())
+    }
+
+    /// This method is called on an `Hir` after descending all of its child
+    /// `Hir` nodes.
+    fn visit_post(&mut self, _hir: &Hir) -> Result<(), Self::Err> {
+        Ok(())
+    }
+
+    /// This method is called between child nodes of an alternation.
+    fn visit_alternation_in(&mut self) -> Result<(), Self::Err> {
+        Ok(())
+    }
+}
+
+/// Executes an implementation of `Visitor` in constant stack space.
+///
+/// This function will visit every node in the given `Hir` while calling
+/// appropriate methods provided by the
+/// [`Visitor`](trait.Visitor.html) trait.
+///
+/// The primary use case for this method is when one wants to perform case
+/// analysis over an `Hir` without using a stack size proportional to the depth
+/// of the `Hir`. Namely, this method will instead use constant stack space,
+/// but will use heap space proportional to the size of the `Hir`. This may be
+/// desirable in cases where the size of `Hir` is proportional to end user
+/// input.
+///
+/// If the visitor returns an error at any point, then visiting is stopped and
+/// the error is returned.
+pub fn visit<V: Visitor>(hir: &Hir, visitor: V) -> Result<V::Output, V::Err> {
+    HeapVisitor::new().visit(hir, visitor)
+}
+
+/// HeapVisitor visits every item in an `Hir` recursively using constant stack
+/// size and a heap size proportional to the size of the `Hir`.
+struct HeapVisitor<'a> {
+    /// A stack of `Hir` nodes. This is roughly analogous to the call stack
+    /// used in a typical recursive visitor.
+    stack: Vec<(&'a Hir, Frame<'a>)>,
+}
+
+/// Represents a single stack frame while performing structural induction over
+/// an `Hir`.
+enum Frame<'a> {
+    /// A stack frame allocated just before descending into a repetition
+    /// operator's child node.
+    Repetition(&'a hir::Repetition),
+    /// A stack frame allocated just before descending into a group's child
+    /// node.
+    Group(&'a hir::Group),
+    /// The stack frame used while visiting every child node of a concatenation
+    /// of expressions.
+    Concat {
+        /// The child node we are currently visiting.
+        head: &'a Hir,
+        /// The remaining child nodes to visit (which may be empty).
+        tail: &'a [Hir],
+    },
+    /// The stack frame used while visiting every child node of an alternation
+    /// of expressions.
+    Alternation {
+        /// The child node we are currently visiting.
+        head: &'a Hir,
+        /// The remaining child nodes to visit (which may be empty).
+        tail: &'a [Hir],
+    },
+}
+
+impl<'a> HeapVisitor<'a> {
+    fn new() -> HeapVisitor<'a> {
+        HeapVisitor { stack: vec![] }
+    }
+
+    fn visit<V: Visitor>(
+        &mut self,
+        mut hir: &'a Hir,
+        mut visitor: V,
+    ) -> Result<V::Output, V::Err> {
+        self.stack.clear();
+
+        visitor.start();
+        loop {
+            visitor.visit_pre(hir)?;
+            if let Some(x) = self.induct(hir) {
+                let child = x.child();
+                self.stack.push((hir, x));
+                hir = child;
+                continue;
+            }
+            // No induction means we have a base case, so we can post visit
+            // it now.
+            visitor.visit_post(hir)?;
+
+            // At this point, we now try to pop our call stack until it is
+            // either empty or we hit another inductive case.
+            loop {
+                let (post_hir, frame) = match self.stack.pop() {
+                    None => return visitor.finish(),
+                    Some((post_hir, frame)) => (post_hir, frame),
+                };
+                // If this is a concat/alternate, then we might have additional
+                // inductive steps to process.
+                if let Some(x) = self.pop(frame) {
+                    if let Frame::Alternation { .. } = x {
+                        visitor.visit_alternation_in()?;
+                    }
+                    hir = x.child();
+                    self.stack.push((post_hir, x));
+                    break;
+                }
+                // Otherwise, we've finished visiting all the child nodes for
+                // this HIR, so we can post visit it now.
+                visitor.visit_post(post_hir)?;
+            }
+        }
+    }
+
+    /// Build a stack frame for the given HIR if one is needed (which occurs if
+    /// and only if there are child nodes in the HIR). Otherwise, return None.
+    fn induct(&mut self, hir: &'a Hir) -> Option<Frame<'a>> {
+        match *hir.kind() {
+            HirKind::Repetition(ref x) => Some(Frame::Repetition(x)),
+            HirKind::Group(ref x) => Some(Frame::Group(x)),
+            HirKind::Concat(ref x) if x.is_empty() => None,
+            HirKind::Concat(ref x) => {
+                Some(Frame::Concat { head: &x[0], tail: &x[1..] })
+            }
+            HirKind::Alternation(ref x) if x.is_empty() => None,
+            HirKind::Alternation(ref x) => {
+                Some(Frame::Alternation { head: &x[0], tail: &x[1..] })
+            }
+            _ => None,
+        }
+    }
+
+    /// Pops the given frame. If the frame has an additional inductive step,
+    /// then return it, otherwise return `None`.
+    fn pop(&self, induct: Frame<'a>) -> Option<Frame<'a>> {
+        match induct {
+            Frame::Repetition(_) => None,
+            Frame::Group(_) => None,
+            Frame::Concat { tail, .. } => {
+                if tail.is_empty() {
+                    None
+                } else {
+                    Some(Frame::Concat { head: &tail[0], tail: &tail[1..] })
+                }
+            }
+            Frame::Alternation { tail, .. } => {
+                if tail.is_empty() {
+                    None
+                } else {
+                    Some(Frame::Alternation {
+                        head: &tail[0],
+                        tail: &tail[1..],
+                    })
+                }
+            }
+        }
+    }
+}
+
+impl<'a> Frame<'a> {
+    /// Perform the next inductive step on this frame and return the next
+    /// child HIR node to visit.
+    fn child(&self) -> &'a Hir {
+        match *self {
+            Frame::Repetition(rep) => &rep.hir,
+            Frame::Group(group) => &group.hir,
+            Frame::Concat { head, .. } => head,
+            Frame::Alternation { head, .. } => head,
+        }
+    }
+}
diff --git a/crates/regex-syntax/src/lib.rs b/crates/regex-syntax/src/lib.rs
new file mode 100644
index 0000000..1dfb38a
--- /dev/null
+++ b/crates/regex-syntax/src/lib.rs
@@ -0,0 +1,312 @@
+/*!
+This crate provides a robust regular expression parser.
+
+This crate defines two primary types:
+
+* [`Ast`](ast/enum.Ast.html) is the abstract syntax of a regular expression.
+  An abstract syntax corresponds to a *structured representation* of the
+  concrete syntax of a regular expression, where the concrete syntax is the
+  pattern string itself (e.g., `foo(bar)+`). Given some abstract syntax, it
+  can be converted back to the original concrete syntax (modulo some details,
+  like whitespace). To a first approximation, the abstract syntax is complex
+  and difficult to analyze.
+* [`Hir`](hir/struct.Hir.html) is the high-level intermediate representation
+  ("HIR" or "high-level IR" for short) of regular expression. It corresponds to
+  an intermediate state of a regular expression that sits between the abstract
+  syntax and the low level compiled opcodes that are eventually responsible for
+  executing a regular expression search. Given some high-level IR, it is not
+  possible to produce the original concrete syntax (although it is possible to
+  produce an equivalent concrete syntax, but it will likely scarcely resemble
+  the original pattern). To a first approximation, the high-level IR is simple
+  and easy to analyze.
+
+These two types come with conversion routines:
+
+* An [`ast::parse::Parser`](ast/parse/struct.Parser.html) converts concrete
+  syntax (a `&str`) to an [`Ast`](ast/enum.Ast.html).
+* A [`hir::translate::Translator`](hir/translate/struct.Translator.html)
+  converts an [`Ast`](ast/enum.Ast.html) to a [`Hir`](hir/struct.Hir.html).
+
+As a convenience, the above two conversion routines are combined into one via
+the top-level [`Parser`](struct.Parser.html) type. This `Parser` will first
+convert your pattern to an `Ast` and then convert the `Ast` to an `Hir`.
+
+
+# Example
+
+This example shows how to parse a pattern string into its HIR:
+
+```
+use regex_syntax::Parser;
+use regex_syntax::hir::{self, Hir};
+
+let hir = Parser::new().parse("a|b").unwrap();
+assert_eq!(hir, Hir::alternation(vec![
+    Hir::literal(hir::Literal::Unicode('a')),
+    Hir::literal(hir::Literal::Unicode('b')),
+]));
+```
+
+
+# Concrete syntax supported
+
+The concrete syntax is documented as part of the public API of the
+[`regex` crate](https://docs.rs/regex/%2A/regex/#syntax).
+
+
+# Input safety
+
+A key feature of this library is that it is safe to use with end user facing
+input. This plays a significant role in the internal implementation. In
+particular:
+
+1. Parsers provide a `nest_limit` option that permits callers to control how
+   deeply nested a regular expression is allowed to be. This makes it possible
+   to do case analysis over an `Ast` or an `Hir` using recursion without
+   worrying about stack overflow.
+2. Since relying on a particular stack size is brittle, this crate goes to
+   great lengths to ensure that all interactions with both the `Ast` and the
+   `Hir` do not use recursion. Namely, they use constant stack space and heap
+   space proportional to the size of the original pattern string (in bytes).
+   This includes the type's corresponding destructors. (One exception to this
+   is literal extraction, but this will eventually get fixed.)
+
+
+# Error reporting
+
+The `Display` implementations on all `Error` types exposed in this library
+provide nice human readable errors that are suitable for showing to end users
+in a monospace font.
+
+
+# Literal extraction
+
+This crate provides limited support for
+[literal extraction from `Hir` values](hir/literal/struct.Literals.html).
+Be warned that literal extraction currently uses recursion, and therefore,
+stack size proportional to the size of the `Hir`.
+
+The purpose of literal extraction is to speed up searches. That is, if you
+know a regular expression must match a prefix or suffix literal, then it is
+often quicker to search for instances of that literal, and then confirm or deny
+the match using the full regular expression engine. These optimizations are
+done automatically in the `regex` crate.
+
+
+# Crate features
+
+An important feature provided by this crate is its Unicode support. This
+includes things like case folding, boolean properties, general categories,
+scripts and Unicode-aware support for the Perl classes `\w`, `\s` and `\d`.
+However, a downside of this support is that it requires bundling several
+Unicode data tables that are substantial in size.
+
+A fair number of use cases do not require full Unicode support. For this
+reason, this crate exposes a number of features to control which Unicode
+data is available.
+
+If a regular expression attempts to use a Unicode feature that is not available
+because the corresponding crate feature was disabled, then translating that
+regular expression to an `Hir` will return an error. (It is still possible
+construct an `Ast` for such a regular expression, since Unicode data is not
+used until translation to an `Hir`.) Stated differently, enabling or disabling
+any of the features below can only add or subtract from the total set of valid
+regular expressions. Enabling or disabling a feature will never modify the
+match semantics of a regular expression.
+
+The following features are available:
+
+* **unicode** -
+  Enables all Unicode features. This feature is enabled by default, and will
+  always cover all Unicode features, even if more are added in the future.
+* **unicode-age** -
+  Provide the data for the
+  [Unicode `Age` property](https://www.unicode.org/reports/tr44/tr44-24.html#Character_Age).
+  This makes it possible to use classes like `\p{Age:6.0}` to refer to all
+  codepoints first introduced in Unicode 6.0
+* **unicode-bool** -
+  Provide the data for numerous Unicode boolean properties. The full list
+  is not included here, but contains properties like `Alphabetic`, `Emoji`,
+  `Lowercase`, `Math`, `Uppercase` and `White_Space`.
+* **unicode-case** -
+  Provide the data for case insensitive matching using
+  [Unicode's "simple loose matches" specification](https://www.unicode.org/reports/tr18/#Simple_Loose_Matches).
+* **unicode-gencat** -
+  Provide the data for
+  [Uncode general categories](https://www.unicode.org/reports/tr44/tr44-24.html#General_Category_Values).
+  This includes, but is not limited to, `Decimal_Number`, `Letter`,
+  `Math_Symbol`, `Number` and `Punctuation`.
+* **unicode-perl** -
+  Provide the data for supporting the Unicode-aware Perl character classes,
+  corresponding to `\w`, `\s` and `\d`. This is also necessary for using
+  Unicode-aware word boundary assertions. Note that if this feature is
+  disabled, the `\s` and `\d` character classes are still available if the
+  `unicode-bool` and `unicode-gencat` features are enabled, respectively.
+* **unicode-script** -
+  Provide the data for
+  [Unicode scripts and script extensions](https://www.unicode.org/reports/tr24/).
+  This includes, but is not limited to, `Arabic`, `Cyrillic`, `Hebrew`,
+  `Latin` and `Thai`.
+* **unicode-segment** -
+  Provide the data necessary to provide the properties used to implement the
+  [Unicode text segmentation algorithms](https://www.unicode.org/reports/tr29/).
+  This enables using classes like `\p{gcb=Extend}`, `\p{wb=Katakana}` and
+  `\p{sb=ATerm}`.
+*/
+
+#![deny(missing_docs)]
+#![warn(missing_debug_implementations)]
+#![forbid(unsafe_code)]
+
+pub use crate::error::{Error, Result};
+pub use crate::parser::{Parser, ParserBuilder};
+pub use crate::unicode::UnicodeWordError;
+
+pub mod ast;
+mod either;
+mod error;
+pub mod hir;
+mod parser;
+mod unicode;
+mod unicode_tables;
+pub mod utf8;
+
+/// Escapes all regular expression meta characters in `text`.
+///
+/// The string returned may be safely used as a literal in a regular
+/// expression.
+pub fn escape(text: &str) -> String {
+    let mut quoted = String::new();
+    escape_into(text, &mut quoted);
+    quoted
+}
+
+/// Escapes all meta characters in `text` and writes the result into `buf`.
+///
+/// This will append escape characters into the given buffer. The characters
+/// that are appended are safe to use as a literal in a regular expression.
+pub fn escape_into(text: &str, buf: &mut String) {
+    buf.reserve(text.len());
+    for c in text.chars() {
+        if is_meta_character(c) {
+            buf.push('\\');
+        }
+        buf.push(c);
+    }
+}
+
+/// Returns true if the given character has significance in a regex.
+///
+/// These are the only characters that are allowed to be escaped, with one
+/// exception: an ASCII space character may be escaped when extended mode (with
+/// the `x` flag) is enabled. In particular, `is_meta_character(' ')` returns
+/// `false`.
+///
+/// Note that the set of characters for which this function returns `true` or
+/// `false` is fixed and won't change in a semver compatible release.
+pub fn is_meta_character(c: char) -> bool {
+    match c {
+        '\\' | '.' | '+' | '*' | '?' | '(' | ')' | '|' | '[' | ']' | '{'
+        | '}' | '^' | '$' | '#' | '&' | '-' | '~' => true,
+        _ => false,
+    }
+}
+
+/// Returns true if and only if the given character is a Unicode word
+/// character.
+///
+/// A Unicode word character is defined by
+/// [UTS#18 Annex C](https://unicode.org/reports/tr18/#Compatibility_Properties).
+/// In particular, a character
+/// is considered a word character if it is in either of the `Alphabetic` or
+/// `Join_Control` properties, or is in one of the `Decimal_Number`, `Mark`
+/// or `Connector_Punctuation` general categories.
+///
+/// # Panics
+///
+/// If the `unicode-perl` feature is not enabled, then this function panics.
+/// For this reason, it is recommended that callers use
+/// [`try_is_word_character`](fn.try_is_word_character.html)
+/// instead.
+pub fn is_word_character(c: char) -> bool {
+    try_is_word_character(c).expect("unicode-perl feature must be enabled")
+}
+
+/// Returns true if and only if the given character is a Unicode word
+/// character.
+///
+/// A Unicode word character is defined by
+/// [UTS#18 Annex C](https://unicode.org/reports/tr18/#Compatibility_Properties).
+/// In particular, a character
+/// is considered a word character if it is in either of the `Alphabetic` or
+/// `Join_Control` properties, or is in one of the `Decimal_Number`, `Mark`
+/// or `Connector_Punctuation` general categories.
+///
+/// # Errors
+///
+/// If the `unicode-perl` feature is not enabled, then this function always
+/// returns an error.
+pub fn try_is_word_character(
+    c: char,
+) -> std::result::Result<bool, UnicodeWordError> {
+    unicode::is_word_character(c)
+}
+
+/// Returns true if and only if the given character is an ASCII word character.
+///
+/// An ASCII word character is defined by the following character class:
+/// `[_0-9a-zA-Z]'.
+pub fn is_word_byte(c: u8) -> bool {
+    match c {
+        b'_' | b'0'..=b'9' | b'a'..=b'z' | b'A'..=b'Z' => true,
+        _ => false,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn escape_meta() {
+        assert_eq!(
+            escape(r"\.+*?()|[]{}^$#&-~"),
+            r"\\\.\+\*\?\(\)\|\[\]\{\}\^\$\#\&\-\~".to_string()
+        );
+    }
+
+    #[test]
+    fn word_byte() {
+        assert!(is_word_byte(b'a'));
+        assert!(!is_word_byte(b'-'));
+    }
+
+    #[test]
+    #[cfg(feature = "unicode-perl")]
+    fn word_char() {
+        assert!(is_word_character('a'), "ASCII");
+        assert!(is_word_character('à'), "Latin-1");
+        assert!(is_word_character('β'), "Greek");
+        assert!(is_word_character('\u{11011}'), "Brahmi (Unicode 6.0)");
+        assert!(is_word_character('\u{11611}'), "Modi (Unicode 7.0)");
+        assert!(is_word_character('\u{11711}'), "Ahom (Unicode 8.0)");
+        assert!(is_word_character('\u{17828}'), "Tangut (Unicode 9.0)");
+        assert!(is_word_character('\u{1B1B1}'), "Nushu (Unicode 10.0)");
+        assert!(is_word_character('\u{16E40}'), "Medefaidrin (Unicode 11.0)");
+        assert!(!is_word_character('-'));
+        assert!(!is_word_character('☃'));
+    }
+
+    #[test]
+    #[should_panic]
+    #[cfg(not(feature = "unicode-perl"))]
+    fn word_char_disabled_panic() {
+        assert!(is_word_character('a'));
+    }
+
+    #[test]
+    #[cfg(not(feature = "unicode-perl"))]
+    fn word_char_disabled_error() {
+        assert!(try_is_word_character('a').is_err());
+    }
+}
diff --git a/crates/regex-syntax/src/parser.rs b/crates/regex-syntax/src/parser.rs
new file mode 100644
index 0000000..ded95b2
--- /dev/null
+++ b/crates/regex-syntax/src/parser.rs
@@ -0,0 +1,200 @@
+use crate::ast;
+use crate::hir;
+
+use crate::Result;
+
+/// A builder for a regular expression parser.
+///
+/// This builder permits modifying configuration options for the parser.
+///
+/// This type combines the builder options for both the
+/// [AST `ParserBuilder`](ast/parse/struct.ParserBuilder.html)
+/// and the
+/// [HIR `TranslatorBuilder`](hir/translate/struct.TranslatorBuilder.html).
+#[derive(Clone, Debug, Default)]
+pub struct ParserBuilder {
+    ast: ast::parse::ParserBuilder,
+    hir: hir::translate::TranslatorBuilder,
+}
+
+impl ParserBuilder {
+    /// Create a new parser builder with a default configuration.
+    pub fn new() -> ParserBuilder {
+        ParserBuilder::default()
+    }
+
+    /// Build a parser from this configuration with the given pattern.
+    pub fn build(&self) -> Parser {
+        Parser { ast: self.ast.build(), hir: self.hir.build() }
+    }
+
+    /// Set the nesting limit for this parser.
+    ///
+    /// The nesting limit controls how deep the abstract syntax tree is allowed
+    /// to be. If the AST exceeds the given limit (e.g., with too many nested
+    /// groups), then an error is returned by the parser.
+    ///
+    /// The purpose of this limit is to act as a heuristic to prevent stack
+    /// overflow for consumers that do structural induction on an `Ast` using
+    /// explicit recursion. While this crate never does this (instead using
+    /// constant stack space and moving the call stack to the heap), other
+    /// crates may.
+    ///
+    /// This limit is not checked until the entire Ast is parsed. Therefore,
+    /// if callers want to put a limit on the amount of heap space used, then
+    /// they should impose a limit on the length, in bytes, of the concrete
+    /// pattern string. In particular, this is viable since this parser
+    /// implementation will limit itself to heap space proportional to the
+    /// length of the pattern string.
+    ///
+    /// Note that a nest limit of `0` will return a nest limit error for most
+    /// patterns but not all. For example, a nest limit of `0` permits `a` but
+    /// not `ab`, since `ab` requires a concatenation, which results in a nest
+    /// depth of `1`. In general, a nest limit is not something that manifests
+    /// in an obvious way in the concrete syntax, therefore, it should not be
+    /// used in a granular way.
+    pub fn nest_limit(&mut self, limit: u32) -> &mut ParserBuilder {
+        self.ast.nest_limit(limit);
+        self
+    }
+
+    /// Whether to support octal syntax or not.
+    ///
+    /// Octal syntax is a little-known way of uttering Unicode codepoints in
+    /// a regular expression. For example, `a`, `\x61`, `\u0061` and
+    /// `\141` are all equivalent regular expressions, where the last example
+    /// shows octal syntax.
+    ///
+    /// While supporting octal syntax isn't in and of itself a problem, it does
+    /// make good error messages harder. That is, in PCRE based regex engines,
+    /// syntax like `\0` invokes a backreference, which is explicitly
+    /// unsupported in Rust's regex engine. However, many users expect it to
+    /// be supported. Therefore, when octal support is disabled, the error
+    /// message will explicitly mention that backreferences aren't supported.
+    ///
+    /// Octal syntax is disabled by default.
+    pub fn octal(&mut self, yes: bool) -> &mut ParserBuilder {
+        self.ast.octal(yes);
+        self
+    }
+
+    /// When enabled, the parser will permit the construction of a regular
+    /// expression that may match invalid UTF-8.
+    ///
+    /// When disabled (the default), the parser is guaranteed to produce
+    /// an expression that will only ever match valid UTF-8 (otherwise, the
+    /// parser will return an error).
+    ///
+    /// Perhaps surprisingly, when invalid UTF-8 isn't allowed, a negated ASCII
+    /// word boundary (uttered as `(?-u:\B)` in the concrete syntax) will cause
+    /// the parser to return an error. Namely, a negated ASCII word boundary
+    /// can result in matching positions that aren't valid UTF-8 boundaries.
+    pub fn allow_invalid_utf8(&mut self, yes: bool) -> &mut ParserBuilder {
+        self.hir.allow_invalid_utf8(yes);
+        self
+    }
+
+    /// Enable verbose mode in the regular expression.
+    ///
+    /// When enabled, verbose mode permits insignificant whitespace in many
+    /// places in the regular expression, as well as comments. Comments are
+    /// started using `#` and continue until the end of the line.
+    ///
+    /// By default, this is disabled. It may be selectively enabled in the
+    /// regular expression by using the `x` flag regardless of this setting.
+    pub fn ignore_whitespace(&mut self, yes: bool) -> &mut ParserBuilder {
+        self.ast.ignore_whitespace(yes);
+        self
+    }
+
+    /// Enable or disable the case insensitive flag by default.
+    ///
+    /// By default this is disabled. It may alternatively be selectively
+    /// enabled in the regular expression itself via the `i` flag.
+    pub fn case_insensitive(&mut self, yes: bool) -> &mut ParserBuilder {
+        self.hir.case_insensitive(yes);
+        self
+    }
+
+    /// Enable or disable the multi-line matching flag by default.
+    ///
+    /// By default this is disabled. It may alternatively be selectively
+    /// enabled in the regular expression itself via the `m` flag.
+    pub fn multi_line(&mut self, yes: bool) -> &mut ParserBuilder {
+        self.hir.multi_line(yes);
+        self
+    }
+
+    /// Enable or disable the "dot matches any character" flag by default.
+    ///
+    /// By default this is disabled. It may alternatively be selectively
+    /// enabled in the regular expression itself via the `s` flag.
+    pub fn dot_matches_new_line(&mut self, yes: bool) -> &mut ParserBuilder {
+        self.hir.dot_matches_new_line(yes);
+        self
+    }
+
+    /// Enable or disable the "swap greed" flag by default.
+    ///
+    /// By default this is disabled. It may alternatively be selectively
+    /// enabled in the regular expression itself via the `U` flag.
+    pub fn swap_greed(&mut self, yes: bool) -> &mut ParserBuilder {
+        self.hir.swap_greed(yes);
+        self
+    }
+
+    /// Enable or disable the Unicode flag (`u`) by default.
+    ///
+    /// By default this is **enabled**. It may alternatively be selectively
+    /// disabled in the regular expression itself via the `u` flag.
+    ///
+    /// Note that unless `allow_invalid_utf8` is enabled (it's disabled by
+    /// default), a regular expression will fail to parse if Unicode mode is
+    /// disabled and a sub-expression could possibly match invalid UTF-8.
+    pub fn unicode(&mut self, yes: bool) -> &mut ParserBuilder {
+        self.hir.unicode(yes);
+        self
+    }
+}
+
+/// A convenience parser for regular expressions.
+///
+/// This parser takes as input a regular expression pattern string (the
+/// "concrete syntax") and returns a high-level intermediate representation
+/// (the HIR) suitable for most types of analysis. In particular, this parser
+/// hides the intermediate state of producing an AST (the "abstract syntax").
+/// The AST is itself far more complex than the HIR, so this parser serves as a
+/// convenience for never having to deal with it at all.
+///
+/// If callers have more fine grained use cases that need an AST, then please
+/// see the [`ast::parse`](ast/parse/index.html) module.
+///
+/// A `Parser` can be configured in more detail via a
+/// [`ParserBuilder`](struct.ParserBuilder.html).
+#[derive(Clone, Debug)]
+pub struct Parser {
+    ast: ast::parse::Parser,
+    hir: hir::translate::Translator,
+}
+
+impl Parser {
+    /// Create a new parser with a default configuration.
+    ///
+    /// The parser can be run with `parse` method. The parse method returns
+    /// a high level intermediate representation of the given regular
+    /// expression.
+    ///
+    /// To set configuration options on the parser, use
+    /// [`ParserBuilder`](struct.ParserBuilder.html).
+    pub fn new() -> Parser {
+        ParserBuilder::new().build()
+    }
+
+    /// Parse the regular expression into a high level intermediate
+    /// representation.
+    pub fn parse(&mut self, pattern: &str) -> Result<hir::Hir> {
+        let ast = self.ast.parse(pattern)?;
+        let hir = self.hir.translate(pattern, &ast)?;
+        Ok(hir)
+    }
+}
diff --git a/crates/regex-syntax/src/unicode.rs b/crates/regex-syntax/src/unicode.rs
new file mode 100644
index 0000000..8194d7f
--- /dev/null
+++ b/crates/regex-syntax/src/unicode.rs
@@ -0,0 +1,1001 @@
+use std::error;
+use std::fmt;
+use std::result;
+
+use crate::hir;
+
+/// A type alias for errors specific to Unicode handling of classes.
+pub type Result<T> = result::Result<T, Error>;
+
+/// An inclusive range of codepoints from a generated file (hence the static
+/// lifetime).
+type Range = &'static [(char, char)];
+
+/// An error that occurs when dealing with Unicode.
+///
+/// We don't impl the Error trait here because these always get converted
+/// into other public errors. (This error type isn't exported.)
+#[derive(Debug)]
+pub enum Error {
+    PropertyNotFound,
+    PropertyValueNotFound,
+    // Not used when unicode-perl is enabled.
+    #[allow(dead_code)]
+    PerlClassNotFound,
+}
+
+/// A type alias for errors specific to Unicode case folding.
+pub type FoldResult<T> = result::Result<T, CaseFoldError>;
+
+/// An error that occurs when Unicode-aware simple case folding fails.
+///
+/// This error can occur when the case mapping tables necessary for Unicode
+/// aware case folding are unavailable. This only occurs when the
+/// `unicode-case` feature is disabled. (The feature is enabled by default.)
+#[derive(Debug)]
+pub struct CaseFoldError(());
+
+impl error::Error for CaseFoldError {}
+
+impl fmt::Display for CaseFoldError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "Unicode-aware case folding is not available \
+             (probably because the unicode-case feature is not enabled)"
+        )
+    }
+}
+
+/// An error that occurs when the Unicode-aware `\w` class is unavailable.
+///
+/// This error can occur when the data tables necessary for the Unicode aware
+/// Perl character class `\w` are unavailable. This only occurs when the
+/// `unicode-perl` feature is disabled. (The feature is enabled by default.)
+#[derive(Debug)]
+pub struct UnicodeWordError(());
+
+impl error::Error for UnicodeWordError {}
+
+impl fmt::Display for UnicodeWordError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "Unicode-aware \\w class is not available \
+             (probably because the unicode-perl feature is not enabled)"
+        )
+    }
+}
+
+/// Return an iterator over the equivalence class of simple case mappings
+/// for the given codepoint. The equivalence class does not include the
+/// given codepoint.
+///
+/// If the equivalence class is empty, then this returns the next scalar
+/// value that has a non-empty equivalence class, if it exists. If no such
+/// scalar value exists, then `None` is returned. The point of this behavior
+/// is to permit callers to avoid calling `simple_fold` more than they need
+/// to, since there is some cost to fetching the equivalence class.
+///
+/// This returns an error if the Unicode case folding tables are not available.
+pub fn simple_fold(
+    c: char,
+) -> FoldResult<result::Result<impl Iterator<Item = char>, Option<char>>> {
+    #[cfg(not(feature = "unicode-case"))]
+    fn imp(
+        _: char,
+    ) -> FoldResult<result::Result<impl Iterator<Item = char>, Option<char>>>
+    {
+        use std::option::IntoIter;
+        Err::<result::Result<IntoIter<char>, _>, _>(CaseFoldError(()))
+    }
+
+    #[cfg(feature = "unicode-case")]
+    fn imp(
+        c: char,
+    ) -> FoldResult<result::Result<impl Iterator<Item = char>, Option<char>>>
+    {
+        use crate::unicode_tables::case_folding_simple::CASE_FOLDING_SIMPLE;
+
+        Ok(CASE_FOLDING_SIMPLE
+            .binary_search_by_key(&c, |&(c1, _)| c1)
+            .map(|i| CASE_FOLDING_SIMPLE[i].1.iter().copied())
+            .map_err(|i| {
+                if i >= CASE_FOLDING_SIMPLE.len() {
+                    None
+                } else {
+                    Some(CASE_FOLDING_SIMPLE[i].0)
+                }
+            }))
+    }
+
+    imp(c)
+}
+
+/// Returns true if and only if the given (inclusive) range contains at least
+/// one Unicode scalar value that has a non-empty non-trivial simple case
+/// mapping.
+///
+/// This function panics if `end < start`.
+///
+/// This returns an error if the Unicode case folding tables are not available.
+pub fn contains_simple_case_mapping(
+    start: char,
+    end: char,
+) -> FoldResult<bool> {
+    #[cfg(not(feature = "unicode-case"))]
+    fn imp(_: char, _: char) -> FoldResult<bool> {
+        Err(CaseFoldError(()))
+    }
+
+    #[cfg(feature = "unicode-case")]
+    fn imp(start: char, end: char) -> FoldResult<bool> {
+        use crate::unicode_tables::case_folding_simple::CASE_FOLDING_SIMPLE;
+        use std::cmp::Ordering;
+
+        assert!(start <= end);
+        Ok(CASE_FOLDING_SIMPLE
+            .binary_search_by(|&(c, _)| {
+                if start <= c && c <= end {
+                    Ordering::Equal
+                } else if c > end {
+                    Ordering::Greater
+                } else {
+                    Ordering::Less
+                }
+            })
+            .is_ok())
+    }
+
+    imp(start, end)
+}
+
+/// A query for finding a character class defined by Unicode. This supports
+/// either use of a property name directly, or lookup by property value. The
+/// former generally refers to Binary properties (see UTS#44, Table 8), but
+/// as a special exception (see UTS#18, Section 1.2) both general categories
+/// (an enumeration) and scripts (a catalog) are supported as if each of their
+/// possible values were a binary property.
+///
+/// In all circumstances, property names and values are normalized and
+/// canonicalized. That is, `GC == gc == GeneralCategory == general_category`.
+///
+/// The lifetime `'a` refers to the shorter of the lifetimes of property name
+/// and property value.
+#[derive(Debug)]
+pub enum ClassQuery<'a> {
+    /// Return a class corresponding to a Unicode binary property, named by
+    /// a single letter.
+    OneLetter(char),
+    /// Return a class corresponding to a Unicode binary property.
+    ///
+    /// Note that, by special exception (see UTS#18, Section 1.2), both
+    /// general category values and script values are permitted here as if
+    /// they were a binary property.
+    Binary(&'a str),
+    /// Return a class corresponding to all codepoints whose property
+    /// (identified by `property_name`) corresponds to the given value
+    /// (identified by `property_value`).
+    ByValue {
+        /// A property name.
+        property_name: &'a str,
+        /// A property value.
+        property_value: &'a str,
+    },
+}
+
+impl<'a> ClassQuery<'a> {
+    fn canonicalize(&self) -> Result<CanonicalClassQuery> {
+        match *self {
+            ClassQuery::OneLetter(c) => self.canonical_binary(&c.to_string()),
+            ClassQuery::Binary(name) => self.canonical_binary(name),
+            ClassQuery::ByValue { property_name, property_value } => {
+                let property_name = symbolic_name_normalize(property_name);
+                let property_value = symbolic_name_normalize(property_value);
+
+                let canon_name = match canonical_prop(&property_name)? {
+                    None => return Err(Error::PropertyNotFound),
+                    Some(canon_name) => canon_name,
+                };
+                Ok(match canon_name {
+                    "General_Category" => {
+                        let canon = match canonical_gencat(&property_value)? {
+                            None => return Err(Error::PropertyValueNotFound),
+                            Some(canon) => canon,
+                        };
+                        CanonicalClassQuery::GeneralCategory(canon)
+                    }
+                    "Script" => {
+                        let canon = match canonical_script(&property_value)? {
+                            None => return Err(Error::PropertyValueNotFound),
+                            Some(canon) => canon,
+                        };
+                        CanonicalClassQuery::Script(canon)
+                    }
+                    _ => {
+                        let vals = match property_values(canon_name)? {
+                            None => return Err(Error::PropertyValueNotFound),
+                            Some(vals) => vals,
+                        };
+                        let canon_val =
+                            match canonical_value(vals, &property_value) {
+                                None => {
+                                    return Err(Error::PropertyValueNotFound)
+                                }
+                                Some(canon_val) => canon_val,
+                            };
+                        CanonicalClassQuery::ByValue {
+                            property_name: canon_name,
+                            property_value: canon_val,
+                        }
+                    }
+                })
+            }
+        }
+    }
+
+    fn canonical_binary(&self, name: &str) -> Result<CanonicalClassQuery> {
+        let norm = symbolic_name_normalize(name);
+
+        // This is a special case where 'cf' refers to the 'Format' general
+        // category, but where the 'cf' abbreviation is also an abbreviation
+        // for the 'Case_Folding' property. But we want to treat it as
+        // a general category. (Currently, we don't even support the
+        // 'Case_Folding' property. But if we do in the future, users will be
+        // required to spell it out.)
+        if norm != "cf" {
+            if let Some(canon) = canonical_prop(&norm)? {
+                return Ok(CanonicalClassQuery::Binary(canon));
+            }
+        }
+        if let Some(canon) = canonical_gencat(&norm)? {
+            return Ok(CanonicalClassQuery::GeneralCategory(canon));
+        }
+        if let Some(canon) = canonical_script(&norm)? {
+            return Ok(CanonicalClassQuery::Script(canon));
+        }
+        Err(Error::PropertyNotFound)
+    }
+}
+
+/// Like ClassQuery, but its parameters have been canonicalized. This also
+/// differentiates binary properties from flattened general categories and
+/// scripts.
+#[derive(Debug, Eq, PartialEq)]
+enum CanonicalClassQuery {
+    /// The canonical binary property name.
+    Binary(&'static str),
+    /// The canonical general category name.
+    GeneralCategory(&'static str),
+    /// The canonical script name.
+    Script(&'static str),
+    /// An arbitrary association between property and value, both of which
+    /// have been canonicalized.
+    ///
+    /// Note that by construction, the property name of ByValue will never
+    /// be General_Category or Script. Those two cases are subsumed by the
+    /// eponymous variants.
+    ByValue {
+        /// The canonical property name.
+        property_name: &'static str,
+        /// The canonical property value.
+        property_value: &'static str,
+    },
+}
+
+/// Looks up a Unicode class given a query. If one doesn't exist, then
+/// `None` is returned.
+pub fn class(query: ClassQuery<'_>) -> Result<hir::ClassUnicode> {
+    use self::CanonicalClassQuery::*;
+
+    match query.canonicalize()? {
+        Binary(name) => bool_property(name),
+        GeneralCategory(name) => gencat(name),
+        Script(name) => script(name),
+        ByValue { property_name: "Age", property_value } => {
+            let mut class = hir::ClassUnicode::empty();
+            for set in ages(property_value)? {
+                class.union(&hir_class(set));
+            }
+            Ok(class)
+        }
+        ByValue { property_name: "Script_Extensions", property_value } => {
+            script_extension(property_value)
+        }
+        ByValue {
+            property_name: "Grapheme_Cluster_Break",
+            property_value,
+        } => gcb(property_value),
+        ByValue { property_name: "Sentence_Break", property_value } => {
+            sb(property_value)
+        }
+        ByValue { property_name: "Word_Break", property_value } => {
+            wb(property_value)
+        }
+        _ => {
+            // What else should we support?
+            Err(Error::PropertyNotFound)
+        }
+    }
+}
+
+/// Returns a Unicode aware class for \w.
+///
+/// This returns an error if the data is not available for \w.
+pub fn perl_word() -> Result<hir::ClassUnicode> {
+    #[cfg(not(feature = "unicode-perl"))]
+    fn imp() -> Result<hir::ClassUnicode> {
+        Err(Error::PerlClassNotFound)
+    }
+
+    #[cfg(feature = "unicode-perl")]
+    fn imp() -> Result<hir::ClassUnicode> {
+        use crate::unicode_tables::perl_word::PERL_WORD;
+        Ok(hir_class(PERL_WORD))
+    }
+
+    imp()
+}
+
+/// Returns a Unicode aware class for \s.
+///
+/// This returns an error if the data is not available for \s.
+pub fn perl_space() -> Result<hir::ClassUnicode> {
+    #[cfg(not(any(feature = "unicode-perl", feature = "unicode-bool")))]
+    fn imp() -> Result<hir::ClassUnicode> {
+        Err(Error::PerlClassNotFound)
+    }
+
+    #[cfg(all(feature = "unicode-perl", not(feature = "unicode-bool")))]
+    fn imp() -> Result<hir::ClassUnicode> {
+        use crate::unicode_tables::perl_space::WHITE_SPACE;
+        Ok(hir_class(WHITE_SPACE))
+    }
+
+    #[cfg(feature = "unicode-bool")]
+    fn imp() -> Result<hir::ClassUnicode> {
+        use crate::unicode_tables::property_bool::WHITE_SPACE;
+        Ok(hir_class(WHITE_SPACE))
+    }
+
+    imp()
+}
+
+/// Returns a Unicode aware class for \d.
+///
+/// This returns an error if the data is not available for \d.
+pub fn perl_digit() -> Result<hir::ClassUnicode> {
+    #[cfg(not(any(feature = "unicode-perl", feature = "unicode-gencat")))]
+    fn imp() -> Result<hir::ClassUnicode> {
+        Err(Error::PerlClassNotFound)
+    }
+
+    #[cfg(all(feature = "unicode-perl", not(feature = "unicode-gencat")))]
+    fn imp() -> Result<hir::ClassUnicode> {
+        use crate::unicode_tables::perl_decimal::DECIMAL_NUMBER;
+        Ok(hir_class(DECIMAL_NUMBER))
+    }
+
+    #[cfg(feature = "unicode-gencat")]
+    fn imp() -> Result<hir::ClassUnicode> {
+        use crate::unicode_tables::general_category::DECIMAL_NUMBER;
+        Ok(hir_class(DECIMAL_NUMBER))
+    }
+
+    imp()
+}
+
+/// Build a Unicode HIR class from a sequence of Unicode scalar value ranges.
+pub fn hir_class(ranges: &[(char, char)]) -> hir::ClassUnicode {
+    let hir_ranges: Vec<hir::ClassUnicodeRange> = ranges
+        .iter()
+        .map(|&(s, e)| hir::ClassUnicodeRange::new(s, e))
+        .collect();
+    hir::ClassUnicode::new(hir_ranges)
+}
+
+/// Returns true only if the given codepoint is in the `\w` character class.
+///
+/// If the `unicode-perl` feature is not enabled, then this returns an error.
+pub fn is_word_character(c: char) -> result::Result<bool, UnicodeWordError> {
+    #[cfg(not(feature = "unicode-perl"))]
+    fn imp(_: char) -> result::Result<bool, UnicodeWordError> {
+        Err(UnicodeWordError(()))
+    }
+
+    #[cfg(feature = "unicode-perl")]
+    fn imp(c: char) -> result::Result<bool, UnicodeWordError> {
+        use crate::is_word_byte;
+        use crate::unicode_tables::perl_word::PERL_WORD;
+        use std::cmp::Ordering;
+
+        if c <= 0x7F as char && is_word_byte(c as u8) {
+            return Ok(true);
+        }
+        Ok(PERL_WORD
+            .binary_search_by(|&(start, end)| {
+                if start <= c && c <= end {
+                    Ordering::Equal
+                } else if start > c {
+                    Ordering::Greater
+                } else {
+                    Ordering::Less
+                }
+            })
+            .is_ok())
+    }
+
+    imp(c)
+}
+
+/// A mapping of property values for a specific property.
+///
+/// The first element of each tuple is a normalized property value while the
+/// second element of each tuple is the corresponding canonical property
+/// value.
+type PropertyValues = &'static [(&'static str, &'static str)];
+
+fn canonical_gencat(normalized_value: &str) -> Result<Option<&'static str>> {
+    Ok(match normalized_value {
+        "any" => Some("Any"),
+        "assigned" => Some("Assigned"),
+        "ascii" => Some("ASCII"),
+        _ => {
+            let gencats = property_values("General_Category")?.unwrap();
+            canonical_value(gencats, normalized_value)
+        }
+    })
+}
+
+fn canonical_script(normalized_value: &str) -> Result<Option<&'static str>> {
+    let scripts = property_values("Script")?.unwrap();
+    Ok(canonical_value(scripts, normalized_value))
+}
+
+/// Find the canonical property name for the given normalized property name.
+///
+/// If no such property exists, then `None` is returned.
+///
+/// The normalized property name must have been normalized according to
+/// UAX44 LM3, which can be done using `symbolic_name_normalize`.
+///
+/// If the property names data is not available, then an error is returned.
+fn canonical_prop(normalized_name: &str) -> Result<Option<&'static str>> {
+    #[cfg(not(any(
+        feature = "unicode-age",
+        feature = "unicode-bool",
+        feature = "unicode-gencat",
+        feature = "unicode-perl",
+        feature = "unicode-script",
+        feature = "unicode-segment",
+    )))]
+    fn imp(_: &str) -> Result<Option<&'static str>> {
+        Err(Error::PropertyNotFound)
+    }
+
+    #[cfg(any(
+        feature = "unicode-age",
+        feature = "unicode-bool",
+        feature = "unicode-gencat",
+        feature = "unicode-perl",
+        feature = "unicode-script",
+        feature = "unicode-segment",
+    ))]
+    fn imp(name: &str) -> Result<Option<&'static str>> {
+        use crate::unicode_tables::property_names::PROPERTY_NAMES;
+
+        Ok(PROPERTY_NAMES
+            .binary_search_by_key(&name, |&(n, _)| n)
+            .ok()
+            .map(|i| PROPERTY_NAMES[i].1))
+    }
+
+    imp(normalized_name)
+}
+
+/// Find the canonical property value for the given normalized property
+/// value.
+///
+/// The given property values should correspond to the values for the property
+/// under question, which can be found using `property_values`.
+///
+/// If no such property value exists, then `None` is returned.
+///
+/// The normalized property value must have been normalized according to
+/// UAX44 LM3, which can be done using `symbolic_name_normalize`.
+fn canonical_value(
+    vals: PropertyValues,
+    normalized_value: &str,
+) -> Option<&'static str> {
+    vals.binary_search_by_key(&normalized_value, |&(n, _)| n)
+        .ok()
+        .map(|i| vals[i].1)
+}
+
+/// Return the table of property values for the given property name.
+///
+/// If the property values data is not available, then an error is returned.
+fn property_values(
+    canonical_property_name: &'static str,
+) -> Result<Option<PropertyValues>> {
+    #[cfg(not(any(
+        feature = "unicode-age",
+        feature = "unicode-bool",
+        feature = "unicode-gencat",
+        feature = "unicode-perl",
+        feature = "unicode-script",
+        feature = "unicode-segment",
+    )))]
+    fn imp(_: &'static str) -> Result<Option<PropertyValues>> {
+        Err(Error::PropertyValueNotFound)
+    }
+
+    #[cfg(any(
+        feature = "unicode-age",
+        feature = "unicode-bool",
+        feature = "unicode-gencat",
+        feature = "unicode-perl",
+        feature = "unicode-script",
+        feature = "unicode-segment",
+    ))]
+    fn imp(name: &'static str) -> Result<Option<PropertyValues>> {
+        use crate::unicode_tables::property_values::PROPERTY_VALUES;
+
+        Ok(PROPERTY_VALUES
+            .binary_search_by_key(&name, |&(n, _)| n)
+            .ok()
+            .map(|i| PROPERTY_VALUES[i].1))
+    }
+
+    imp(canonical_property_name)
+}
+
+// This is only used in some cases, but small enough to just let it be dead
+// instead of figuring out (and maintaining) the right set of features.
+#[allow(dead_code)]
+fn property_set(
+    name_map: &'static [(&'static str, Range)],
+    canonical: &'static str,
+) -> Option<Range> {
+    name_map
+        .binary_search_by_key(&canonical, |x| x.0)
+        .ok()
+        .map(|i| name_map[i].1)
+}
+
+/// Returns an iterator over Unicode Age sets. Each item corresponds to a set
+/// of codepoints that were added in a particular revision of Unicode. The
+/// iterator yields items in chronological order.
+///
+/// If the given age value isn't valid or if the data isn't available, then an
+/// error is returned instead.
+fn ages(canonical_age: &str) -> Result<impl Iterator<Item = Range>> {
+    #[cfg(not(feature = "unicode-age"))]
+    fn imp(_: &str) -> Result<impl Iterator<Item = Range>> {
+        use std::option::IntoIter;
+        Err::<IntoIter<Range>, _>(Error::PropertyNotFound)
+    }
+
+    #[cfg(feature = "unicode-age")]
+    fn imp(canonical_age: &str) -> Result<impl Iterator<Item = Range>> {
+        use crate::unicode_tables::age;
+
+        const AGES: &[(&str, Range)] = &[
+            ("V1_1", age::V1_1),
+            ("V2_0", age::V2_0),
+            ("V2_1", age::V2_1),
+            ("V3_0", age::V3_0),
+            ("V3_1", age::V3_1),
+            ("V3_2", age::V3_2),
+            ("V4_0", age::V4_0),
+            ("V4_1", age::V4_1),
+            ("V5_0", age::V5_0),
+            ("V5_1", age::V5_1),
+            ("V5_2", age::V5_2),
+            ("V6_0", age::V6_0),
+            ("V6_1", age::V6_1),
+            ("V6_2", age::V6_2),
+            ("V6_3", age::V6_3),
+            ("V7_0", age::V7_0),
+            ("V8_0", age::V8_0),
+            ("V9_0", age::V9_0),
+            ("V10_0", age::V10_0),
+            ("V11_0", age::V11_0),
+            ("V12_0", age::V12_0),
+            ("V12_1", age::V12_1),
+            ("V13_0", age::V13_0),
+            ("V14_0", age::V14_0),
+            ("V15_0", age::V15_0),
+        ];
+        assert_eq!(AGES.len(), age::BY_NAME.len(), "ages are out of sync");
+
+        let pos = AGES.iter().position(|&(age, _)| canonical_age == age);
+        match pos {
+            None => Err(Error::PropertyValueNotFound),
+            Some(i) => Ok(AGES[..=i].iter().map(|&(_, classes)| classes)),
+        }
+    }
+
+    imp(canonical_age)
+}
+
+/// Returns the Unicode HIR class corresponding to the given general category.
+///
+/// Name canonicalization is assumed to be performed by the caller.
+///
+/// If the given general category could not be found, or if the general
+/// category data is not available, then an error is returned.
+fn gencat(canonical_name: &'static str) -> Result<hir::ClassUnicode> {
+    #[cfg(not(feature = "unicode-gencat"))]
+    fn imp(_: &'static str) -> Result<hir::ClassUnicode> {
+        Err(Error::PropertyNotFound)
+    }
+
+    #[cfg(feature = "unicode-gencat")]
+    fn imp(name: &'static str) -> Result<hir::ClassUnicode> {
+        use crate::unicode_tables::general_category::BY_NAME;
+        match name {
+            "ASCII" => Ok(hir_class(&[('\0', '\x7F')])),
+            "Any" => Ok(hir_class(&[('\0', '\u{10FFFF}')])),
+            "Assigned" => {
+                let mut cls = gencat("Unassigned")?;
+                cls.negate();
+                Ok(cls)
+            }
+            name => property_set(BY_NAME, name)
+                .map(hir_class)
+                .ok_or(Error::PropertyValueNotFound),
+        }
+    }
+
+    match canonical_name {
+        "Decimal_Number" => perl_digit(),
+        name => imp(name),
+    }
+}
+
+/// Returns the Unicode HIR class corresponding to the given script.
+///
+/// Name canonicalization is assumed to be performed by the caller.
+///
+/// If the given script could not be found, or if the script data is not
+/// available, then an error is returned.
+fn script(canonical_name: &'static str) -> Result<hir::ClassUnicode> {
+    #[cfg(not(feature = "unicode-script"))]
+    fn imp(_: &'static str) -> Result<hir::ClassUnicode> {
+        Err(Error::PropertyNotFound)
+    }
+
+    #[cfg(feature = "unicode-script")]
+    fn imp(name: &'static str) -> Result<hir::ClassUnicode> {
+        use crate::unicode_tables::script::BY_NAME;
+        property_set(BY_NAME, name)
+            .map(hir_class)
+            .ok_or(Error::PropertyValueNotFound)
+    }
+
+    imp(canonical_name)
+}
+
+/// Returns the Unicode HIR class corresponding to the given script extension.
+///
+/// Name canonicalization is assumed to be performed by the caller.
+///
+/// If the given script extension could not be found, or if the script data is
+/// not available, then an error is returned.
+fn script_extension(
+    canonical_name: &'static str,
+) -> Result<hir::ClassUnicode> {
+    #[cfg(not(feature = "unicode-script"))]
+    fn imp(_: &'static str) -> Result<hir::ClassUnicode> {
+        Err(Error::PropertyNotFound)
+    }
+
+    #[cfg(feature = "unicode-script")]
+    fn imp(name: &'static str) -> Result<hir::ClassUnicode> {
+        use crate::unicode_tables::script_extension::BY_NAME;
+        property_set(BY_NAME, name)
+            .map(hir_class)
+            .ok_or(Error::PropertyValueNotFound)
+    }
+
+    imp(canonical_name)
+}
+
+/// Returns the Unicode HIR class corresponding to the given Unicode boolean
+/// property.
+///
+/// Name canonicalization is assumed to be performed by the caller.
+///
+/// If the given boolean property could not be found, or if the boolean
+/// property data is not available, then an error is returned.
+fn bool_property(canonical_name: &'static str) -> Result<hir::ClassUnicode> {
+    #[cfg(not(feature = "unicode-bool"))]
+    fn imp(_: &'static str) -> Result<hir::ClassUnicode> {
+        Err(Error::PropertyNotFound)
+    }
+
+    #[cfg(feature = "unicode-bool")]
+    fn imp(name: &'static str) -> Result<hir::ClassUnicode> {
+        use crate::unicode_tables::property_bool::BY_NAME;
+        property_set(BY_NAME, name)
+            .map(hir_class)
+            .ok_or(Error::PropertyNotFound)
+    }
+
+    match canonical_name {
+        "Decimal_Number" => perl_digit(),
+        "White_Space" => perl_space(),
+        name => imp(name),
+    }
+}
+
+/// Returns the Unicode HIR class corresponding to the given grapheme cluster
+/// break property.
+///
+/// Name canonicalization is assumed to be performed by the caller.
+///
+/// If the given property could not be found, or if the corresponding data is
+/// not available, then an error is returned.
+fn gcb(canonical_name: &'static str) -> Result<hir::ClassUnicode> {
+    #[cfg(not(feature = "unicode-segment"))]
+    fn imp(_: &'static str) -> Result<hir::ClassUnicode> {
+        Err(Error::PropertyNotFound)
+    }
+
+    #[cfg(feature = "unicode-segment")]
+    fn imp(name: &'static str) -> Result<hir::ClassUnicode> {
+        use crate::unicode_tables::grapheme_cluster_break::BY_NAME;
+        property_set(BY_NAME, name)
+            .map(hir_class)
+            .ok_or(Error::PropertyValueNotFound)
+    }
+
+    imp(canonical_name)
+}
+
+/// Returns the Unicode HIR class corresponding to the given word break
+/// property.
+///
+/// Name canonicalization is assumed to be performed by the caller.
+///
+/// If the given property could not be found, or if the corresponding data is
+/// not available, then an error is returned.
+fn wb(canonical_name: &'static str) -> Result<hir::ClassUnicode> {
+    #[cfg(not(feature = "unicode-segment"))]
+    fn imp(_: &'static str) -> Result<hir::ClassUnicode> {
+        Err(Error::PropertyNotFound)
+    }
+
+    #[cfg(feature = "unicode-segment")]
+    fn imp(name: &'static str) -> Result<hir::ClassUnicode> {
+        use crate::unicode_tables::word_break::BY_NAME;
+        property_set(BY_NAME, name)
+            .map(hir_class)
+            .ok_or(Error::PropertyValueNotFound)
+    }
+
+    imp(canonical_name)
+}
+
+/// Returns the Unicode HIR class corresponding to the given sentence
+/// break property.
+///
+/// Name canonicalization is assumed to be performed by the caller.
+///
+/// If the given property could not be found, or if the corresponding data is
+/// not available, then an error is returned.
+fn sb(canonical_name: &'static str) -> Result<hir::ClassUnicode> {
+    #[cfg(not(feature = "unicode-segment"))]
+    fn imp(_: &'static str) -> Result<hir::ClassUnicode> {
+        Err(Error::PropertyNotFound)
+    }
+
+    #[cfg(feature = "unicode-segment")]
+    fn imp(name: &'static str) -> Result<hir::ClassUnicode> {
+        use crate::unicode_tables::sentence_break::BY_NAME;
+        property_set(BY_NAME, name)
+            .map(hir_class)
+            .ok_or(Error::PropertyValueNotFound)
+    }
+
+    imp(canonical_name)
+}
+
+/// Like symbolic_name_normalize_bytes, but operates on a string.
+fn symbolic_name_normalize(x: &str) -> String {
+    let mut tmp = x.as_bytes().to_vec();
+    let len = symbolic_name_normalize_bytes(&mut tmp).len();
+    tmp.truncate(len);
+    // This should always succeed because `symbolic_name_normalize_bytes`
+    // guarantees that `&tmp[..len]` is always valid UTF-8.
+    //
+    // N.B. We could avoid the additional UTF-8 check here, but it's unlikely
+    // to be worth skipping the additional safety check. A benchmark must
+    // justify it first.
+    String::from_utf8(tmp).unwrap()
+}
+
+/// Normalize the given symbolic name in place according to UAX44-LM3.
+///
+/// A "symbolic name" typically corresponds to property names and property
+/// value aliases. Note, though, that it should not be applied to property
+/// string values.
+///
+/// The slice returned is guaranteed to be valid UTF-8 for all possible values
+/// of `slice`.
+///
+/// See: https://unicode.org/reports/tr44/#UAX44-LM3
+fn symbolic_name_normalize_bytes(slice: &mut [u8]) -> &mut [u8] {
+    // I couldn't find a place in the standard that specified that property
+    // names/aliases had a particular structure (unlike character names), but
+    // we assume that it's ASCII only and drop anything that isn't ASCII.
+    let mut start = 0;
+    let mut starts_with_is = false;
+    if slice.len() >= 2 {
+        // Ignore any "is" prefix.
+        starts_with_is = slice[0..2] == b"is"[..]
+            || slice[0..2] == b"IS"[..]
+            || slice[0..2] == b"iS"[..]
+            || slice[0..2] == b"Is"[..];
+        if starts_with_is {
+            start = 2;
+        }
+    }
+    let mut next_write = 0;
+    for i in start..slice.len() {
+        // VALIDITY ARGUMENT: To guarantee that the resulting slice is valid
+        // UTF-8, we ensure that the slice contains only ASCII bytes. In
+        // particular, we drop every non-ASCII byte from the normalized string.
+        let b = slice[i];
+        if b == b' ' || b == b'_' || b == b'-' {
+            continue;
+        } else if b'A' <= b && b <= b'Z' {
+            slice[next_write] = b + (b'a' - b'A');
+            next_write += 1;
+        } else if b <= 0x7F {
+            slice[next_write] = b;
+            next_write += 1;
+        }
+    }
+    // Special case: ISO_Comment has a 'isc' abbreviation. Since we generally
+    // ignore 'is' prefixes, the 'isc' abbreviation gets caught in the cross
+    // fire and ends up creating an alias for 'c' to 'ISO_Comment', but it
+    // is actually an alias for the 'Other' general category.
+    if starts_with_is && next_write == 1 && slice[0] == b'c' {
+        slice[0] = b'i';
+        slice[1] = b's';
+        slice[2] = b'c';
+        next_write = 3;
+    }
+    &mut slice[..next_write]
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        contains_simple_case_mapping, simple_fold, symbolic_name_normalize,
+        symbolic_name_normalize_bytes,
+    };
+
+    #[cfg(feature = "unicode-case")]
+    fn simple_fold_ok(c: char) -> impl Iterator<Item = char> {
+        simple_fold(c).unwrap().unwrap()
+    }
+
+    #[cfg(feature = "unicode-case")]
+    fn simple_fold_err(c: char) -> Option<char> {
+        match simple_fold(c).unwrap() {
+            Ok(_) => unreachable!("simple_fold returned Ok iterator"),
+            Err(next) => next,
+        }
+    }
+
+    #[cfg(feature = "unicode-case")]
+    fn contains_case_map(start: char, end: char) -> bool {
+        contains_simple_case_mapping(start, end).unwrap()
+    }
+
+    #[test]
+    #[cfg(feature = "unicode-case")]
+    fn simple_fold_k() {
+        let xs: Vec<char> = simple_fold_ok('k').collect();
+        assert_eq!(xs, vec!['K', 'K']);
+
+        let xs: Vec<char> = simple_fold_ok('K').collect();
+        assert_eq!(xs, vec!['k', 'K']);
+
+        let xs: Vec<char> = simple_fold_ok('K').collect();
+        assert_eq!(xs, vec!['K', 'k']);
+    }
+
+    #[test]
+    #[cfg(feature = "unicode-case")]
+    fn simple_fold_a() {
+        let xs: Vec<char> = simple_fold_ok('a').collect();
+        assert_eq!(xs, vec!['A']);
+
+        let xs: Vec<char> = simple_fold_ok('A').collect();
+        assert_eq!(xs, vec!['a']);
+    }
+
+    #[test]
+    #[cfg(feature = "unicode-case")]
+    fn simple_fold_empty() {
+        assert_eq!(Some('A'), simple_fold_err('?'));
+        assert_eq!(Some('A'), simple_fold_err('@'));
+        assert_eq!(Some('a'), simple_fold_err('['));
+        assert_eq!(Some('Ⰰ'), simple_fold_err('☃'));
+    }
+
+    #[test]
+    #[cfg(feature = "unicode-case")]
+    fn simple_fold_max() {
+        assert_eq!(None, simple_fold_err('\u{10FFFE}'));
+        assert_eq!(None, simple_fold_err('\u{10FFFF}'));
+    }
+
+    #[test]
+    #[cfg(not(feature = "unicode-case"))]
+    fn simple_fold_disabled() {
+        assert!(simple_fold('a').is_err());
+    }
+
+    #[test]
+    #[cfg(feature = "unicode-case")]
+    fn range_contains() {
+        assert!(contains_case_map('A', 'A'));
+        assert!(contains_case_map('Z', 'Z'));
+        assert!(contains_case_map('A', 'Z'));
+        assert!(contains_case_map('@', 'A'));
+        assert!(contains_case_map('Z', '['));
+        assert!(contains_case_map('☃', 'Ⰰ'));
+
+        assert!(!contains_case_map('[', '['));
+        assert!(!contains_case_map('[', '`'));
+
+        assert!(!contains_case_map('☃', '☃'));
+    }
+
+    #[test]
+    #[cfg(not(feature = "unicode-case"))]
+    fn range_contains_disabled() {
+        assert!(contains_simple_case_mapping('a', 'a').is_err());
+    }
+
+    #[test]
+    #[cfg(feature = "unicode-gencat")]
+    fn regression_466() {
+        use super::{CanonicalClassQuery, ClassQuery};
+
+        let q = ClassQuery::OneLetter('C');
+        assert_eq!(
+            q.canonicalize().unwrap(),
+            CanonicalClassQuery::GeneralCategory("Other")
+        );
+    }
+
+    #[test]
+    fn sym_normalize() {
+        let sym_norm = symbolic_name_normalize;
+
+        assert_eq!(sym_norm("Line_Break"), "linebreak");
+        assert_eq!(sym_norm("Line-break"), "linebreak");
+        assert_eq!(sym_norm("linebreak"), "linebreak");
+        assert_eq!(sym_norm("BA"), "ba");
+        assert_eq!(sym_norm("ba"), "ba");
+        assert_eq!(sym_norm("Greek"), "greek");
+        assert_eq!(sym_norm("isGreek"), "greek");
+        assert_eq!(sym_norm("IS_Greek"), "greek");
+        assert_eq!(sym_norm("isc"), "isc");
+        assert_eq!(sym_norm("is c"), "isc");
+        assert_eq!(sym_norm("is_c"), "isc");
+    }
+
+    #[test]
+    fn valid_utf8_symbolic() {
+        let mut x = b"abc\xFFxyz".to_vec();
+        let y = symbolic_name_normalize_bytes(&mut x);
+        assert_eq!(y, b"abcxyz");
+    }
+}
diff --git a/crates/regex-syntax/src/unicode_tables/LICENSE-UNICODE b/crates/regex-syntax/src/unicode_tables/LICENSE-UNICODE
new file mode 100644
index 0000000..b82826b
--- /dev/null
+++ b/crates/regex-syntax/src/unicode_tables/LICENSE-UNICODE
@@ -0,0 +1,57 @@
+UNICODE, INC. LICENSE AGREEMENT - DATA FILES AND SOFTWARE
+
+Unicode Data Files include all data files under the directories
+http://www.unicode.org/Public/, http://www.unicode.org/reports/,
+http://www.unicode.org/cldr/data/, http://source.icu-project.org/repos/icu/, and
+http://www.unicode.org/utility/trac/browser/.
+
+Unicode Data Files do not include PDF online code charts under the
+directory http://www.unicode.org/Public/.
+
+Software includes any source code published in the Unicode Standard
+or under the directories
+http://www.unicode.org/Public/, http://www.unicode.org/reports/,
+http://www.unicode.org/cldr/data/, http://source.icu-project.org/repos/icu/, and
+http://www.unicode.org/utility/trac/browser/.
+
+NOTICE TO USER: Carefully read the following legal agreement.
+BY DOWNLOADING, INSTALLING, COPYING OR OTHERWISE USING UNICODE INC.'S
+DATA FILES ("DATA FILES"), AND/OR SOFTWARE ("SOFTWARE"),
+YOU UNEQUIVOCALLY ACCEPT, AND AGREE TO BE BOUND BY, ALL OF THE
+TERMS AND CONDITIONS OF THIS AGREEMENT.
+IF YOU DO NOT AGREE, DO NOT DOWNLOAD, INSTALL, COPY, DISTRIBUTE OR USE
+THE DATA FILES OR SOFTWARE.
+
+COPYRIGHT AND PERMISSION NOTICE
+
+Copyright © 1991-2018 Unicode, Inc. All rights reserved.
+Distributed under the Terms of Use in http://www.unicode.org/copyright.html.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Unicode data files and any associated documentation
+(the "Data Files") or Unicode software and any associated documentation
+(the "Software") to deal in the Data Files or Software
+without restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, and/or sell copies of
+the Data Files or Software, and to permit persons to whom the Data Files
+or Software are furnished to do so, provided that either
+(a) this copyright and permission notice appear with all copies
+of the Data Files or Software, or
+(b) this copyright and permission notice appear in associated
+Documentation.
+
+THE DATA FILES AND SOFTWARE ARE PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT OF THIRD PARTY RIGHTS.
+IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS
+NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL
+DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THE DATA FILES OR SOFTWARE.
+
+Except as contained in this notice, the name of a copyright holder
+shall not be used in advertising or otherwise to promote the sale,
+use or other dealings in these Data Files or Software without prior
+written authorization of the copyright holder.
diff --git a/crates/regex-syntax/src/unicode_tables/age.rs b/crates/regex-syntax/src/unicode_tables/age.rs
new file mode 100644
index 0000000..71f4861
--- /dev/null
+++ b/crates/regex-syntax/src/unicode_tables/age.rs
@@ -0,0 +1,1791 @@
+// DO NOT EDIT THIS FILE. IT WAS AUTOMATICALLY GENERATED BY:
+//
+//   ucd-generate age ucd-15.0.0 --chars
+//
+// Unicode version: 15.0.0.
+//
+// ucd-generate 0.2.14 is available on crates.io.
+
+pub const BY_NAME: &'static [(&'static str, &'static [(char, char)])] = &[
+    ("V10_0", V10_0),
+    ("V11_0", V11_0),
+    ("V12_0", V12_0),
+    ("V12_1", V12_1),
+    ("V13_0", V13_0),
+    ("V14_0", V14_0),
+    ("V15_0", V15_0),
+    ("V1_1", V1_1),
+    ("V2_0", V2_0),
+    ("V2_1", V2_1),
+    ("V3_0", V3_0),
+    ("V3_1", V3_1),
+    ("V3_2", V3_2),
+    ("V4_0", V4_0),
+    ("V4_1", V4_1),
+    ("V5_0", V5_0),
+    ("V5_1", V5_1),
+    ("V5_2", V5_2),
+    ("V6_0", V6_0),
+    ("V6_1", V6_1),
+    ("V6_2", V6_2),
+    ("V6_3", V6_3),
+    ("V7_0", V7_0),
+    ("V8_0", V8_0),
+    ("V9_0", V9_0),
+];
+
+pub const V10_0: &'static [(char, char)] = &[
+    ('ࡠ', 'ࡪ'),
+    ('ৼ', '৽'),
+    ('\u{afa}', '\u{aff}'),
+    ('\u{d00}', '\u{d00}'),
+    ('\u{d3b}', '\u{d3c}'),
+    ('᳷', '᳷'),
+    ('\u{1df6}', '\u{1df9}'),
+    ('₿', '₿'),
+    ('⏿', '⏿'),
+    ('⯒', '⯒'),
+    ('⹅', '⹉'),
+    ('ㄮ', 'ㄮ'),
+    ('鿖', '鿪'),
+    ('𐌭', '𐌯'),
+    ('𑨀', '\u{11a47}'),
+    ('𑩐', '𑪃'),
+    ('𑪆', '𑪜'),
+    ('𑪞', '𑪢'),
+    ('𑴀', '𑴆'),
+    ('𑴈', '𑴉'),
+    ('𑴋', '\u{11d36}'),
+    ('\u{11d3a}', '\u{11d3a}'),
+    ('\u{11d3c}', '\u{11d3d}'),
+    ('\u{11d3f}', '\u{11d47}'),
+    ('𑵐', '𑵙'),
+    ('𖿡', '𖿡'),
+    ('𛀂', '𛄞'),
+    ('𛅰', '𛋻'),
+    ('🉠', '🉥'),
+    ('🛓', '🛔'),
+    ('🛷', '🛸'),
+    ('🤀', '🤋'),
+    ('🤟', '🤟'),
+    ('🤨', '🤯'),
+    ('🤱', '🤲'),
+    ('🥌', '🥌'),
+    ('🥟', '🥫'),
+    ('🦒', '🦗'),
+    ('🧐', '🧦'),
+    ('𬺰', '𮯠'),
+];
+
+pub const V11_0: &'static [(char, char)] = &[
+    ('ՠ', 'ՠ'),
+    ('ֈ', 'ֈ'),
+    ('ׯ', 'ׯ'),
+    ('\u{7fd}', '߿'),
+    ('\u{8d3}', '\u{8d3}'),
+    ('\u{9fe}', '\u{9fe}'),
+    ('੶', '੶'),
+    ('\u{c04}', '\u{c04}'),
+    ('಄', '಄'),
+    ('ᡸ', 'ᡸ'),
+    ('Ა', 'Ჺ'),
+    ('Ჽ', 'Ჿ'),
+    ('⮺', '⮼'),
+    ('⯓', '⯫'),
+    ('⯰', '⯾'),
+    ('⹊', '⹎'),
+    ('ㄯ', 'ㄯ'),
+    ('鿫', '鿯'),
+    ('ꞯ', 'ꞯ'),
+    ('Ꞹ', 'ꞹ'),
+    ('ꣾ', '\u{a8ff}'),
+    ('𐨴', '𐨵'),
+    ('𐩈', '𐩈'),
+    ('𐴀', '\u{10d27}'),
+    ('𐴰', '𐴹'),
+    ('𐼀', '𐼧'),
+    ('𐼰', '𐽙'),
+    ('\u{110cd}', '\u{110cd}'),
+    ('𑅄', '𑅆'),
+    ('\u{1133b}', '\u{1133b}'),
+    ('\u{1145e}', '\u{1145e}'),
+    ('𑜚', '𑜚'),
+    ('𑠀', '𑠻'),
+    ('𑪝', '𑪝'),
+    ('𑵠', '𑵥'),
+    ('𑵧', '𑵨'),
+    ('𑵪', '𑶎'),
+    ('\u{11d90}', '\u{11d91}'),
+    ('𑶓', '𑶘'),
+    ('𑶠', '𑶩'),
+    ('𑻠', '𑻸'),
+    ('𖹀', '𖺚'),
+    ('𘟭', '𘟱'),
+    ('𝋠', '𝋳'),
+    ('𝍲', '𝍸'),
+    ('𞱱', '𞲴'),
+    ('🄯', '🄯'),
+    ('🛹', '🛹'),
+    ('🟕', '🟘'),
+    ('🥍', '🥏'),
+    ('🥬', '🥰'),
+    ('🥳', '🥶'),
+    ('🥺', '🥺'),
+    ('🥼', '🥿'),
+    ('🦘', '🦢'),
+    ('🦰', '🦹'),
+    ('🧁', '🧂'),
+    ('🧧', '🧿'),
+    ('🩠', '🩭'),
+];
+
+pub const V12_0: &'static [(char, char)] = &[
+    ('౷', '౷'),
+    ('ຆ', 'ຆ'),
+    ('ຉ', 'ຉ'),
+    ('ຌ', 'ຌ'),
+    ('ຎ', 'ຓ'),
+    ('ຘ', 'ຘ'),
+    ('ຠ', 'ຠ'),
+    ('ຨ', 'ຩ'),
+    ('ຬ', 'ຬ'),
+    ('\u{eba}', '\u{eba}'),
+    ('ᳺ', 'ᳺ'),
+    ('⯉', '⯉'),
+    ('⯿', '⯿'),
+    ('⹏', '⹏'),
+    ('Ꞻ', 'ꞿ'),
+    ('Ꟃ', 'Ᶎ'),
+    ('ꭦ', 'ꭧ'),
+    ('𐿠', '𐿶'),
+    ('𑑟', '𑑟'),
+    ('𑚸', '𑚸'),
+    ('𑦠', '𑦧'),
+    ('𑦪', '\u{119d7}'),
+    ('\u{119da}', '𑧤'),
+    ('𑪄', '𑪅'),
+    ('𑿀', '𑿱'),
+    ('𑿿', '𑿿'),
+    ('\u{13430}', '\u{13438}'),
+    ('𖽅', '𖽊'),
+    ('\u{16f4f}', '\u{16f4f}'),
+    ('𖽿', '𖾇'),
+    ('𖿢', '𖿣'),
+    ('𘟲', '𘟷'),
+    ('𛅐', '𛅒'),
+    ('𛅤', '𛅧'),
+    ('𞄀', '𞄬'),
+    ('\u{1e130}', '𞄽'),
+    ('𞅀', '𞅉'),
+    ('𞅎', '𞅏'),
+    ('𞋀', '𞋹'),
+    ('𞋿', '𞋿'),
+    ('𞥋', '𞥋'),
+    ('𞴁', '𞴽'),
+    ('🅬', '🅬'),
+    ('🛕', '🛕'),
+    ('🛺', '🛺'),
+    ('🟠', '🟫'),
+    ('🤍', '🤏'),
+    ('🤿', '🤿'),
+    ('🥱', '🥱'),
+    ('🥻', '🥻'),
+    ('🦥', '🦪'),
+    ('🦮', '🦯'),
+    ('🦺', '🦿'),
+    ('🧃', '🧊'),
+    ('🧍', '🧏'),
+    ('🨀', '🩓'),
+    ('🩰', '🩳'),
+    ('🩸', '🩺'),
+    ('🪀', '🪂'),
+    ('🪐', '🪕'),
+];
+
+pub const V12_1: &'static [(char, char)] = &[('㋿', '㋿')];
+
+pub const V13_0: &'static [(char, char)] = &[
+    ('ࢾ', 'ࣇ'),
+    ('\u{b55}', '\u{b55}'),
+    ('ഄ', 'ഄ'),
+    ('\u{d81}', '\u{d81}'),
+    ('\u{1abf}', '\u{1ac0}'),
+    ('⮗', '⮗'),
+    ('⹐', '⹒'),
+    ('ㆻ', 'ㆿ'),
+    ('䶶', '䶿'),
+    ('鿰', '鿼'),
+    ('Ꟈ', 'ꟊ'),
+    ('Ꟶ', 'ꟶ'),
+    ('\u{a82c}', '\u{a82c}'),
+    ('ꭨ', '꭫'),
+    ('𐆜', '𐆜'),
+    ('𐺀', '𐺩'),
+    ('\u{10eab}', '𐺭'),
+    ('𐺰', '𐺱'),
+    ('𐾰', '𐿋'),
+    ('𑅇', '𑅇'),
+    ('𑇎', '\u{111cf}'),
+    ('𑑚', '𑑚'),
+    ('𑑠', '𑑡'),
+    ('𑤀', '𑤆'),
+    ('𑤉', '𑤉'),
+    ('𑤌', '𑤓'),
+    ('𑤕', '𑤖'),
+    ('𑤘', '𑤵'),
+    ('𑤷', '𑤸'),
+    ('\u{1193b}', '𑥆'),
+    ('𑥐', '𑥙'),
+    ('𑾰', '𑾰'),
+    ('\u{16fe4}', '\u{16fe4}'),
+    ('𖿰', '𖿱'),
+    ('𘫳', '𘳕'),
+    ('𘴀', '𘴈'),
+    ('🄍', '🄏'),
+    ('🅭', '🅯'),
+    ('🆭', '🆭'),
+    ('🛖', '🛗'),
+    ('🛻', '🛼'),
+    ('🢰', '🢱'),
+    ('🤌', '🤌'),
+    ('🥲', '🥲'),
+    ('🥷', '🥸'),
+    ('🦣', '🦤'),
+    ('🦫', '🦭'),
+    ('🧋', '🧋'),
+    ('🩴', '🩴'),
+    ('🪃', '🪆'),
+    ('🪖', '🪨'),
+    ('🪰', '🪶'),
+    ('🫀', '🫂'),
+    ('🫐', '🫖'),
+    ('🬀', '🮒'),
+    ('🮔', '🯊'),
+    ('🯰', '🯹'),
+    ('𪛗', '𪛝'),
+    ('𰀀', '𱍊'),
+];
+
+pub const V14_0: &'static [(char, char)] = &[
+    ('؝', '؝'),
+    ('ࡰ', 'ࢎ'),
+    ('\u{890}', '\u{891}'),
+    ('\u{898}', '\u{89f}'),
+    ('ࢵ', 'ࢵ'),
+    ('ࣈ', '\u{8d2}'),
+    ('\u{c3c}', '\u{c3c}'),
+    ('ౝ', 'ౝ'),
+    ('ೝ', 'ೝ'),
+    ('ᜍ', 'ᜍ'),
+    ('᜕', '᜕'),
+    ('ᜟ', 'ᜟ'),
+    ('\u{180f}', '\u{180f}'),
+    ('\u{1ac1}', '\u{1ace}'),
+    ('ᭌ', 'ᭌ'),
+    ('᭽', '᭾'),
+    ('\u{1dfa}', '\u{1dfa}'),
+    ('⃀', '⃀'),
+    ('Ⱟ', 'Ⱟ'),
+    ('ⱟ', 'ⱟ'),
+    ('⹓', '⹝'),
+    ('鿽', '鿿'),
+    ('Ꟁ', 'ꟁ'),
+    ('Ꟑ', 'ꟑ'),
+    ('ꟓ', 'ꟓ'),
+    ('ꟕ', 'ꟙ'),
+    ('ꟲ', 'ꟴ'),
+    ('﯂', '﯂'),
+    ('﵀', '﵏'),
+    ('﷏', '﷏'),
+    ('﷾', '﷿'),
+    ('𐕰', '𐕺'),
+    ('𐕼', '𐖊'),
+    ('𐖌', '𐖒'),
+    ('𐖔', '𐖕'),
+    ('𐖗', '𐖡'),
+    ('𐖣', '𐖱'),
+    ('𐖳', '𐖹'),
+    ('𐖻', '𐖼'),
+    ('𐞀', '𐞅'),
+    ('𐞇', '𐞰'),
+    ('𐞲', '𐞺'),
+    ('𐽰', '𐾉'),
+    ('\u{11070}', '𑁵'),
+    ('\u{110c2}', '\u{110c2}'),
+    ('𑚹', '𑚹'),
+    ('𑝀', '𑝆'),
+    ('𑪰', '𑪿'),
+    ('𒾐', '𒿲'),
+    ('𖩰', '𖪾'),
+    ('𖫀', '𖫉'),
+    ('𚿰', '𚿳'),
+    ('𚿵', '𚿻'),
+    ('𚿽', '𚿾'),
+    ('𛄟', '𛄢'),
+    ('\u{1cf00}', '\u{1cf2d}'),
+    ('\u{1cf30}', '\u{1cf46}'),
+    ('𜽐', '𜿃'),
+    ('𝇩', '𝇪'),
+    ('𝼀', '𝼞'),
+    ('𞊐', '\u{1e2ae}'),
+    ('𞟠', '𞟦'),
+    ('𞟨', '𞟫'),
+    ('𞟭', '𞟮'),
+    ('𞟰', '𞟾'),
+    ('🛝', '🛟'),
+    ('🟰', '🟰'),
+    ('🥹', '🥹'),
+    ('🧌', '🧌'),
+    ('🩻', '🩼'),
+    ('🪩', '🪬'),
+    ('🪷', '🪺'),
+    ('🫃', '🫅'),
+    ('🫗', '🫙'),
+    ('🫠', '🫧'),
+    ('🫰', '🫶'),
+    ('𪛞', '𪛟'),
+    ('𫜵', '𫜸'),
+];
+
+pub const V15_0: &'static [(char, char)] = &[
+    ('ೳ', 'ೳ'),
+    ('\u{ece}', '\u{ece}'),
+    ('\u{10efd}', '\u{10eff}'),
+    ('𑈿', '\u{11241}'),
+    ('𑬀', '𑬉'),
+    ('\u{11f00}', '𑼐'),
+    ('𑼒', '\u{11f3a}'),
+    ('𑼾', '𑽙'),
+    ('𓐯', '𓐯'),
+    ('\u{13439}', '\u{13455}'),
+    ('𛄲', '𛄲'),
+    ('𛅕', '𛅕'),
+    ('𝋀', '𝋓'),
+    ('𝼥', '𝼪'),
+    ('𞀰', '𞁭'),
+    ('\u{1e08f}', '\u{1e08f}'),
+    ('𞓐', '𞓹'),
+    ('🛜', '🛜'),
+    ('🝴', '🝶'),
+    ('🝻', '🝿'),
+    ('🟙', '🟙'),
+    ('🩵', '🩷'),
+    ('🪇', '🪈'),
+    ('🪭', '🪯'),
+    ('🪻', '🪽'),
+    ('🪿', '🪿'),
+    ('🫎', '🫏'),
+    ('🫚', '🫛'),
+    ('🫨', '🫨'),
+    ('🫷', '🫸'),
+    ('𫜹', '𫜹'),
+    ('𱍐', '𲎯'),
+];
+
+pub const V1_1: &'static [(char, char)] = &[
+    ('\0', 'ǵ'),
+    ('Ǻ', 'ȗ'),
+    ('ɐ', 'ʨ'),
+    ('ʰ', '˞'),
+    ('ˠ', '˩'),
+    ('\u{300}', '\u{345}'),
+    ('\u{360}', '\u{361}'),
+    ('ʹ', '͵'),
+    ('ͺ', 'ͺ'),
+    (';', ';'),
+    ('΄', 'Ί'),
+    ('Ό', 'Ό'),
+    ('Ύ', 'Ρ'),
+    ('Σ', 'ώ'),
+    ('ϐ', 'ϖ'),
+    ('Ϛ', 'Ϛ'),
+    ('Ϝ', 'Ϝ'),
+    ('Ϟ', 'Ϟ'),
+    ('Ϡ', 'Ϡ'),
+    ('Ϣ', 'ϳ'),
+    ('Ё', 'Ќ'),
+    ('Ў', 'я'),
+    ('ё', 'ќ'),
+    ('ў', '\u{486}'),
+    ('Ґ', 'ӄ'),
+    ('Ӈ', 'ӈ'),
+    ('Ӌ', 'ӌ'),
+    ('Ӑ', 'ӫ'),
+    ('Ӯ', 'ӵ'),
+    ('Ӹ', 'ӹ'),
+    ('Ա', 'Ֆ'),
+    ('ՙ', '՟'),
+    ('ա', 'և'),
+    ('։', '։'),
+    ('\u{5b0}', '\u{5b9}'),
+    ('\u{5bb}', '׃'),
+    ('א', 'ת'),
+    ('װ', '״'),
+    ('،', '،'),
+    ('؛', '؛'),
+    ('؟', '؟'),
+    ('ء', 'غ'),
+    ('ـ', '\u{652}'),
+    ('٠', '٭'),
+    ('\u{670}', 'ڷ'),
+    ('ں', 'ھ'),
+    ('ۀ', 'ێ'),
+    ('ې', '\u{6ed}'),
+    ('۰', '۹'),
+    ('\u{901}', 'ः'),
+    ('अ', 'ह'),
+    ('\u{93c}', '\u{94d}'),
+    ('ॐ', '\u{954}'),
+    ('क़', '॰'),
+    ('\u{981}', 'ঃ'),
+    ('অ', 'ঌ'),
+    ('এ', 'ঐ'),
+    ('ও', 'ন'),
+    ('প', 'র'),
+    ('ল', 'ল'),
+    ('শ', 'হ'),
+    ('\u{9bc}', '\u{9bc}'),
+    ('\u{9be}', '\u{9c4}'),
+    ('ে', 'ৈ'),
+    ('ো', '\u{9cd}'),
+    ('\u{9d7}', '\u{9d7}'),
+    ('ড়', 'ঢ়'),
+    ('য়', '\u{9e3}'),
+    ('০', '৺'),
+    ('\u{a02}', '\u{a02}'),
+    ('ਅ', 'ਊ'),
+    ('ਏ', 'ਐ'),
+    ('ਓ', 'ਨ'),
+    ('ਪ', 'ਰ'),
+    ('ਲ', 'ਲ਼'),
+    ('ਵ', 'ਸ਼'),
+    ('ਸ', 'ਹ'),
+    ('\u{a3c}', '\u{a3c}'),
+    ('ਾ', '\u{a42}'),
+    ('\u{a47}', '\u{a48}'),
+    ('\u{a4b}', '\u{a4d}'),
+    ('ਖ਼', 'ੜ'),
+    ('ਫ਼', 'ਫ਼'),
+    ('੦', 'ੴ'),
+    ('\u{a81}', 'ઃ'),
+    ('અ', 'ઋ'),
+    ('ઍ', 'ઍ'),
+    ('એ', 'ઑ'),
+    ('ઓ', 'ન'),
+    ('પ', 'ર'),
+    ('લ', 'ળ'),
+    ('વ', 'હ'),
+    ('\u{abc}', '\u{ac5}'),
+    ('\u{ac7}', 'ૉ'),
+    ('ો', '\u{acd}'),
+    ('ૐ', 'ૐ'),
+    ('ૠ', 'ૠ'),
+    ('૦', '૯'),
+    ('\u{b01}', 'ଃ'),
+    ('ଅ', 'ଌ'),
+    ('ଏ', 'ଐ'),
+    ('ଓ', 'ନ'),
+    ('ପ', 'ର'),
+    ('ଲ', 'ଳ'),
+    ('ଶ', 'ହ'),
+    ('\u{b3c}', '\u{b43}'),
+    ('େ', 'ୈ'),
+    ('ୋ', '\u{b4d}'),
+    ('\u{b56}', '\u{b57}'),
+    ('ଡ଼', 'ଢ଼'),
+    ('ୟ', 'ୡ'),
+    ('୦', '୰'),
+    ('\u{b82}', 'ஃ'),
+    ('அ', 'ஊ'),
+    ('எ', 'ஐ'),
+    ('ஒ', 'க'),
+    ('ங', 'ச'),
+    ('ஜ', 'ஜ'),
+    ('ஞ', 'ட'),
+    ('ண', 'த'),
+    ('ந', 'ப'),
+    ('ம', 'வ'),
+    ('ஷ', 'ஹ'),
+    ('\u{bbe}', 'ூ'),
+    ('ெ', 'ை'),
+    ('ொ', '\u{bcd}'),
+    ('\u{bd7}', '\u{bd7}'),
+    ('௧', '௲'),
+    ('ఁ', 'ః'),
+    ('అ', 'ఌ'),
+    ('ఎ', 'ఐ'),
+    ('ఒ', 'న'),
+    ('ప', 'ళ'),
+    ('వ', 'హ'),
+    ('\u{c3e}', 'ౄ'),
+    ('\u{c46}', '\u{c48}'),
+    ('\u{c4a}', '\u{c4d}'),
+    ('\u{c55}', '\u{c56}'),
+    ('ౠ', 'ౡ'),
+    ('౦', '౯'),
+    ('ಂ', 'ಃ'),
+    ('ಅ', 'ಌ'),
+    ('ಎ', 'ಐ'),
+    ('ಒ', 'ನ'),
+    ('ಪ', 'ಳ'),
+    ('ವ', 'ಹ'),
+    ('ಾ', 'ೄ'),
+    ('\u{cc6}', 'ೈ'),
+    ('ೊ', '\u{ccd}'),
+    ('\u{cd5}', '\u{cd6}'),
+    ('ೞ', 'ೞ'),
+    ('ೠ', 'ೡ'),
+    ('೦', '೯'),
+    ('ം', 'ഃ'),
+    ('അ', 'ഌ'),
+    ('എ', 'ഐ'),
+    ('ഒ', 'ന'),
+    ('പ', 'ഹ'),
+    ('\u{d3e}', '\u{d43}'),
+    ('െ', 'ൈ'),
+    ('ൊ', '\u{d4d}'),
+    ('\u{d57}', '\u{d57}'),
+    ('ൠ', 'ൡ'),
+    ('൦', '൯'),
+    ('ก', '\u{e3a}'),
+    ('฿', '๛'),
+    ('ກ', 'ຂ'),
+    ('ຄ', 'ຄ'),
+    ('ງ', 'ຈ'),
+    ('ຊ', 'ຊ'),
+    ('ຍ', 'ຍ'),
+    ('ດ', 'ທ'),
+    ('ນ', 'ຟ'),
+    ('ມ', 'ຣ'),
+    ('ລ', 'ລ'),
+    ('ວ', 'ວ'),
+    ('ສ', 'ຫ'),
+    ('ອ', '\u{eb9}'),
+    ('\u{ebb}', 'ຽ'),
+    ('ເ', 'ໄ'),
+    ('ໆ', 'ໆ'),
+    ('\u{ec8}', '\u{ecd}'),
+    ('໐', '໙'),
+    ('ໜ', 'ໝ'),
+    ('Ⴀ', 'Ⴥ'),
+    ('ა', 'ჶ'),
+    ('჻', '჻'),
+    ('ᄀ', 'ᅙ'),
+    ('ᅟ', 'ᆢ'),
+    ('ᆨ', 'ᇹ'),
+    ('Ḁ', 'ẚ'),
+    ('Ạ', 'ỹ'),
+    ('ἀ', 'ἕ'),
+    ('Ἐ', 'Ἕ'),
+    ('ἠ', 'ὅ'),
+    ('Ὀ', 'Ὅ'),
+    ('ὐ', 'ὗ'),
+    ('Ὑ', 'Ὑ'),
+    ('Ὓ', 'Ὓ'),
+    ('Ὕ', 'Ὕ'),
+    ('Ὗ', 'ώ'),
+    ('ᾀ', 'ᾴ'),
+    ('ᾶ', 'ῄ'),
+    ('ῆ', 'ΐ'),
+    ('ῖ', 'Ί'),
+    ('῝', '`'),
+    ('ῲ', 'ῴ'),
+    ('ῶ', '῾'),
+    ('\u{2000}', '\u{202e}'),
+    ('‰', '⁆'),
+    ('\u{206a}', '⁰'),
+    ('⁴', '₎'),
+    ('₠', '₪'),
+    ('\u{20d0}', '\u{20e1}'),
+    ('℀', 'ℸ'),
+    ('⅓', 'ↂ'),
+    ('←', '⇪'),
+    ('∀', '⋱'),
+    ('⌀', '⌀'),
+    ('⌂', '⍺'),
+    ('␀', '␤'),
+    ('⑀', '⑊'),
+    ('①', '⓪'),
+    ('─', '▕'),
+    ('■', '◯'),
+    ('☀', '☓'),
+    ('☚', '♯'),
+    ('✁', '✄'),
+    ('✆', '✉'),
+    ('✌', '✧'),
+    ('✩', '❋'),
+    ('❍', '❍'),
+    ('❏', '❒'),
+    ('❖', '❖'),
+    ('❘', '❞'),
+    ('❡', '❧'),
+    ('❶', '➔'),
+    ('➘', '➯'),
+    ('➱', '➾'),
+    ('\u{3000}', '〷'),
+    ('〿', '〿'),
+    ('ぁ', 'ゔ'),
+    ('\u{3099}', 'ゞ'),
+    ('ァ', 'ヾ'),
+    ('ㄅ', 'ㄬ'),
+    ('ㄱ', 'ㆎ'),
+    ('㆐', '㆟'),
+    ('㈀', '㈜'),
+    ('㈠', '㉃'),
+    ('㉠', '㉻'),
+    ('㉿', '㊰'),
+    ('㋀', '㋋'),
+    ('㋐', '㋾'),
+    ('㌀', '㍶'),
+    ('㍻', '㏝'),
+    ('㏠', '㏾'),
+    ('一', '龥'),
+    ('\u{e000}', '鶴'),
+    ('ﬀ', 'ﬆ'),
+    ('ﬓ', 'ﬗ'),
+    ('\u{fb1e}', 'זּ'),
+    ('טּ', 'לּ'),
+    ('מּ', 'מּ'),
+    ('נּ', 'סּ'),
+    ('ףּ', 'פּ'),
+    ('צּ', 'ﮱ'),
+    ('ﯓ', '﴿'),
+    ('ﵐ', 'ﶏ'),
+    ('ﶒ', 'ﷇ'),
+    ('ﷰ', 'ﷻ'),
+    ('\u{fe20}', '\u{fe23}'),
+    ('︰', '﹄'),
+    ('﹉', '﹒'),
+    ('﹔', '﹦'),
+    ('﹨', '﹫'),
+    ('ﹰ', 'ﹲ'),
+    ('ﹴ', 'ﹴ'),
+    ('ﹶ', 'ﻼ'),
+    ('\u{feff}', '\u{feff}'),
+    ('！', '～'),
+    ('｡', 'ﾾ'),
+    ('ￂ', 'ￇ'),
+    ('ￊ', 'ￏ'),
+    ('ￒ', 'ￗ'),
+    ('ￚ', 'ￜ'),
+    ('￠', '￦'),
+    ('￨', '￮'),
+    ('�', '\u{ffff}'),
+];
+
+pub const V2_0: &'static [(char, char)] = &[
+    ('\u{591}', '\u{5a1}'),
+    ('\u{5a3}', '\u{5af}'),
+    ('\u{5c4}', '\u{5c4}'),
+    ('ༀ', 'ཇ'),
+    ('ཉ', 'ཀྵ'),
+    ('\u{f71}', 'ྋ'),
+    ('\u{f90}', '\u{f95}'),
+    ('\u{f97}', '\u{f97}'),
+    ('\u{f99}', '\u{fad}'),
+    ('\u{fb1}', '\u{fb7}'),
+    ('\u{fb9}', '\u{fb9}'),
+    ('ẛ', 'ẛ'),
+    ('₫', '₫'),
+    ('가', '힣'),
+    ('\u{1fffe}', '\u{1ffff}'),
+    ('\u{2fffe}', '\u{2ffff}'),
+    ('\u{3fffe}', '\u{3ffff}'),
+    ('\u{4fffe}', '\u{4ffff}'),
+    ('\u{5fffe}', '\u{5ffff}'),
+    ('\u{6fffe}', '\u{6ffff}'),
+    ('\u{7fffe}', '\u{7ffff}'),
+    ('\u{8fffe}', '\u{8ffff}'),
+    ('\u{9fffe}', '\u{9ffff}'),
+    ('\u{afffe}', '\u{affff}'),
+    ('\u{bfffe}', '\u{bffff}'),
+    ('\u{cfffe}', '\u{cffff}'),
+    ('\u{dfffe}', '\u{dffff}'),
+    ('\u{efffe}', '\u{10ffff}'),
+];
+
+pub const V2_1: &'static [(char, char)] = &[('€', '€'), ('￼', '￼')];
+
+pub const V3_0: &'static [(char, char)] = &[
+    ('Ƕ', 'ǹ'),
+    ('Ș', 'ȟ'),
+    ('Ȣ', 'ȳ'),
+    ('ʩ', 'ʭ'),
+    ('˟', '˟'),
+    ('˪', 'ˮ'),
+    ('\u{346}', '\u{34e}'),
+    ('\u{362}', '\u{362}'),
+    ('ϗ', 'ϗ'),
+    ('ϛ', 'ϛ'),
+    ('ϝ', 'ϝ'),
+    ('ϟ', 'ϟ'),
+    ('ϡ', 'ϡ'),
+    ('Ѐ', 'Ѐ'),
+    ('Ѝ', 'Ѝ'),
+    ('ѐ', 'ѐ'),
+    ('ѝ', 'ѝ'),
+    ('\u{488}', '\u{489}'),
+    ('Ҍ', 'ҏ'),
+    ('Ӭ', 'ӭ'),
+    ('֊', '֊'),
+    ('\u{653}', '\u{655}'),
+    ('ڸ', 'ڹ'),
+    ('ڿ', 'ڿ'),
+    ('ۏ', 'ۏ'),
+    ('ۺ', '۾'),
+    ('܀', '܍'),
+    ('\u{70f}', 'ܬ'),
+    ('\u{730}', '\u{74a}'),
+    ('ހ', '\u{7b0}'),
+    ('ං', 'ඃ'),
+    ('අ', 'ඖ'),
+    ('ක', 'න'),
+    ('ඳ', 'ර'),
+    ('ල', 'ල'),
+    ('ව', 'ෆ'),
+    ('\u{dca}', '\u{dca}'),
+    ('\u{dcf}', '\u{dd4}'),
+    ('\u{dd6}', '\u{dd6}'),
+    ('ෘ', '\u{ddf}'),
+    ('ෲ', '෴'),
+    ('ཪ', 'ཪ'),
+    ('\u{f96}', '\u{f96}'),
+    ('\u{fae}', '\u{fb0}'),
+    ('\u{fb8}', '\u{fb8}'),
+    ('\u{fba}', '\u{fbc}'),
+    ('྾', '࿌'),
+    ('࿏', '࿏'),
+    ('က', 'အ'),
+    ('ဣ', 'ဧ'),
+    ('ဩ', 'ဪ'),
+    ('ာ', '\u{1032}'),
+    ('\u{1036}', '\u{1039}'),
+    ('၀', '\u{1059}'),
+    ('ሀ', 'ሆ'),
+    ('ለ', 'ቆ'),
+    ('ቈ', 'ቈ'),
+    ('ቊ', 'ቍ'),
+    ('ቐ', 'ቖ'),
+    ('ቘ', 'ቘ'),
+    ('ቚ', 'ቝ'),
+    ('በ', 'ኆ'),
+    ('ኈ', 'ኈ'),
+    ('ኊ', 'ኍ'),
+    ('ነ', 'ኮ'),
+    ('ኰ', 'ኰ'),
+    ('ኲ', 'ኵ'),
+    ('ኸ', 'ኾ'),
+    ('ዀ', 'ዀ'),
+    ('ዂ', 'ዅ'),
+    ('ወ', 'ዎ'),
+    ('ዐ', 'ዖ'),
+    ('ዘ', 'ዮ'),
+    ('ደ', 'ጎ'),
+    ('ጐ', 'ጐ'),
+    ('ጒ', 'ጕ'),
+    ('ጘ', 'ጞ'),
+    ('ጠ', 'ፆ'),
+    ('ፈ', 'ፚ'),
+    ('፡', '፼'),
+    ('Ꭰ', 'Ᏼ'),
+    ('ᐁ', 'ᙶ'),
+    ('\u{1680}', '᚜'),
+    ('ᚠ', 'ᛰ'),
+    ('ក', 'ៜ'),
+    ('០', '៩'),
+    ('᠀', '\u{180e}'),
+    ('᠐', '᠙'),
+    ('ᠠ', 'ᡷ'),
+    ('ᢀ', '\u{18a9}'),
+    ('\u{202f}', '\u{202f}'),
+    ('⁈', '⁍'),
+    ('₭', '₯'),
+    ('\u{20e2}', '\u{20e3}'),
+    ('ℹ', '℺'),
+    ('Ↄ', 'Ↄ'),
+    ('⇫', '⇳'),
+    ('⌁', '⌁'),
+    ('⍻', '⍻'),
+    ('⍽', '⎚'),
+    ('␥', '␦'),
+    ('◰', '◷'),
+    ('☙', '☙'),
+    ('♰', '♱'),
+    ('⠀', '⣿'),
+    ('⺀', '⺙'),
+    ('⺛', '⻳'),
+    ('⼀', '⿕'),
+    ('⿰', '⿻'),
+    ('〸', '〺'),
+    ('〾', '〾'),
+    ('ㆠ', 'ㆷ'),
+    ('㐀', '䶵'),
+    ('ꀀ', 'ꒌ'),
+    ('꒐', '꒡'),
+    ('꒤', '꒳'),
+    ('꒵', '꓀'),
+    ('꓂', '꓄'),
+    ('꓆', '꓆'),
+    ('יִ', 'יִ'),
+    ('\u{fff9}', '\u{fffb}'),
+];
+
+pub const V3_1: &'static [(char, char)] = &[
+    ('ϴ', 'ϵ'),
+    ('\u{fdd0}', '\u{fdef}'),
+    ('𐌀', '𐌞'),
+    ('𐌠', '𐌣'),
+    ('𐌰', '𐍊'),
+    ('𐐀', '𐐥'),
+    ('𐐨', '𐑍'),
+    ('𝀀', '𝃵'),
+    ('𝄀', '𝄦'),
+    ('𝄪', '𝇝'),
+    ('𝐀', '𝑔'),
+    ('𝑖', '𝒜'),
+    ('𝒞', '𝒟'),
+    ('𝒢', '𝒢'),
+    ('𝒥', '𝒦'),
+    ('𝒩', '𝒬'),
+    ('𝒮', '𝒹'),
+    ('𝒻', '𝒻'),
+    ('𝒽', '𝓀'),
+    ('𝓂', '𝓃'),
+    ('𝓅', '𝔅'),
+    ('𝔇', '𝔊'),
+    ('𝔍', '𝔔'),
+    ('𝔖', '𝔜'),
+    ('𝔞', '𝔹'),
+    ('𝔻', '𝔾'),
+    ('𝕀', '𝕄'),
+    ('𝕆', '𝕆'),
+    ('𝕊', '𝕐'),
+    ('𝕒', '𝚣'),
+    ('𝚨', '𝟉'),
+    ('𝟎', '𝟿'),
+    ('𠀀', '𪛖'),
+    ('丽', '𪘀'),
+    ('\u{e0001}', '\u{e0001}'),
+    ('\u{e0020}', '\u{e007f}'),
+];
+
+pub const V3_2: &'static [(char, char)] = &[
+    ('Ƞ', 'Ƞ'),
+    ('\u{34f}', '\u{34f}'),
+    ('\u{363}', '\u{36f}'),
+    ('Ϙ', 'ϙ'),
+    ('϶', '϶'),
+    ('Ҋ', 'ҋ'),
+    ('Ӆ', 'ӆ'),
+    ('Ӊ', 'ӊ'),
+    ('Ӎ', 'ӎ'),
+    ('Ԁ', 'ԏ'),
+    ('ٮ', 'ٯ'),
+    ('ޱ', 'ޱ'),
+    ('ჷ', 'ჸ'),
+    ('ᜀ', 'ᜌ'),
+    ('ᜎ', '\u{1714}'),
+    ('ᜠ', '᜶'),
+    ('ᝀ', '\u{1753}'),
+    ('ᝠ', 'ᝬ'),
+    ('ᝮ', 'ᝰ'),
+    ('\u{1772}', '\u{1773}'),
+    ('⁇', '⁇'),
+    ('⁎', '⁒'),
+    ('⁗', '⁗'),
+    ('\u{205f}', '\u{2063}'),
+    ('ⁱ', 'ⁱ'),
+    ('₰', '₱'),
+    ('\u{20e4}', '\u{20ea}'),
+    ('ℽ', '⅋'),
+    ('⇴', '⇿'),
+    ('⋲', '⋿'),
+    ('⍼', '⍼'),
+    ('⎛', '⏎'),
+    ('⓫', '⓾'),
+    ('▖', '▟'),
+    ('◸', '◿'),
+    ('☖', '☗'),
+    ('♲', '♽'),
+    ('⚀', '⚉'),
+    ('❨', '❵'),
+    ('⟐', '⟫'),
+    ('⟰', '⟿'),
+    ('⤀', '⫿'),
+    ('〻', '〽'),
+    ('ゕ', 'ゖ'),
+    ('ゟ', '゠'),
+    ('ヿ', 'ヿ'),
+    ('ㇰ', 'ㇿ'),
+    ('㉑', '㉟'),
+    ('㊱', '㊿'),
+    ('꒢', '꒣'),
+    ('꒴', '꒴'),
+    ('꓁', '꓁'),
+    ('꓅', '꓅'),
+    ('侮', '頻'),
+    ('﷼', '﷼'),
+    ('\u{fe00}', '\u{fe0f}'),
+    ('﹅', '﹆'),
+    ('ﹳ', 'ﹳ'),
+    ('｟', '｠'),
+];
+
+pub const V4_0: &'static [(char, char)] = &[
+    ('ȡ', 'ȡ'),
+    ('ȴ', 'ȶ'),
+    ('ʮ', 'ʯ'),
+    ('˯', '˿'),
+    ('\u{350}', '\u{357}'),
+    ('\u{35d}', '\u{35f}'),
+    ('Ϸ', 'ϻ'),
+    ('\u{600}', '\u{603}'),
+    ('؍', '\u{615}'),
+    ('\u{656}', '\u{658}'),
+    ('ۮ', 'ۯ'),
+    ('ۿ', 'ۿ'),
+    ('ܭ', 'ܯ'),
+    ('ݍ', 'ݏ'),
+    ('ऄ', 'ऄ'),
+    ('ঽ', 'ঽ'),
+    ('\u{a01}', '\u{a01}'),
+    ('ਃ', 'ਃ'),
+    ('ઌ', 'ઌ'),
+    ('ૡ', '\u{ae3}'),
+    ('૱', '૱'),
+    ('ଵ', 'ଵ'),
+    ('ୱ', 'ୱ'),
+    ('௳', '௺'),
+    ('\u{cbc}', 'ಽ'),
+    ('\u{17dd}', '\u{17dd}'),
+    ('៰', '៹'),
+    ('ᤀ', 'ᤜ'),
+    ('\u{1920}', 'ᤫ'),
+    ('ᤰ', '\u{193b}'),
+    ('᥀', '᥀'),
+    ('᥄', 'ᥭ'),
+    ('ᥰ', 'ᥴ'),
+    ('᧠', '᧿'),
+    ('ᴀ', 'ᵫ'),
+    ('⁓', '⁔'),
+    ('℻', '℻'),
+    ('⏏', '⏐'),
+    ('⓿', '⓿'),
+    ('☔', '☕'),
+    ('⚊', '⚑'),
+    ('⚠', '⚡'),
+    ('⬀', '⬍'),
+    ('㈝', '㈞'),
+    ('㉐', '㉐'),
+    ('㉼', '㉽'),
+    ('㋌', '㋏'),
+    ('㍷', '㍺'),
+    ('㏞', '㏟'),
+    ('㏿', '㏿'),
+    ('䷀', '䷿'),
+    ('﷽', '﷽'),
+    ('﹇', '﹈'),
+    ('𐀀', '𐀋'),
+    ('𐀍', '𐀦'),
+    ('𐀨', '𐀺'),
+    ('𐀼', '𐀽'),
+    ('𐀿', '𐁍'),
+    ('𐁐', '𐁝'),
+    ('𐂀', '𐃺'),
+    ('𐄀', '𐄂'),
+    ('𐄇', '𐄳'),
+    ('𐄷', '𐄿'),
+    ('𐎀', '𐎝'),
+    ('𐎟', '𐎟'),
+    ('𐐦', '𐐧'),
+    ('𐑎', '𐒝'),
+    ('𐒠', '𐒩'),
+    ('𐠀', '𐠅'),
+    ('𐠈', '𐠈'),
+    ('𐠊', '𐠵'),
+    ('𐠷', '𐠸'),
+    ('𐠼', '𐠼'),
+    ('𐠿', '𐠿'),
+    ('𝌀', '𝍖'),
+    ('𝓁', '𝓁'),
+    ('\u{e0100}', '\u{e01ef}'),
+];
+
+pub const V4_1: &'static [(char, char)] = &[
+    ('ȷ', 'Ɂ'),
+    ('\u{358}', '\u{35c}'),
+    ('ϼ', 'Ͽ'),
+    ('Ӷ', 'ӷ'),
+    ('\u{5a2}', '\u{5a2}'),
+    ('\u{5c5}', '\u{5c7}'),
+    ('؋', '؋'),
+    ('؞', '؞'),
+    ('\u{659}', '\u{65e}'),
+    ('ݐ', 'ݭ'),
+    ('ॽ', 'ॽ'),
+    ('ৎ', 'ৎ'),
+    ('ஶ', 'ஶ'),
+    ('௦', '௦'),
+    ('࿐', '࿑'),
+    ('ჹ', 'ჺ'),
+    ('ჼ', 'ჼ'),
+    ('ሇ', 'ሇ'),
+    ('ቇ', 'ቇ'),
+    ('ኇ', 'ኇ'),
+    ('ኯ', 'ኯ'),
+    ('ዏ', 'ዏ'),
+    ('ዯ', 'ዯ'),
+    ('ጏ', 'ጏ'),
+    ('ጟ', 'ጟ'),
+    ('ፇ', 'ፇ'),
+    ('\u{135f}', '፠'),
+    ('ᎀ', '᎙'),
+    ('ᦀ', 'ᦩ'),
+    ('ᦰ', 'ᧉ'),
+    ('᧐', '᧙'),
+    ('᧞', '᧟'),
+    ('ᨀ', '\u{1a1b}'),
+    ('᨞', '᨟'),
+    ('ᵬ', '\u{1dc3}'),
+    ('⁕', '⁖'),
+    ('⁘', '⁞'),
+    ('ₐ', 'ₔ'),
+    ('₲', '₵'),
+    ('\u{20eb}', '\u{20eb}'),
+    ('ℼ', 'ℼ'),
+    ('⅌', '⅌'),
+    ('⏑', '⏛'),
+    ('☘', '☘'),
+    ('♾', '♿'),
+    ('⚒', '⚜'),
+    ('⚢', '⚱'),
+    ('⟀', '⟆'),
+    ('⬎', '⬓'),
+    ('Ⰰ', 'Ⱞ'),
+    ('ⰰ', 'ⱞ'),
+    ('Ⲁ', '⳪'),
+    ('⳹', 'ⴥ'),
+    ('ⴰ', 'ⵥ'),
+    ('ⵯ', 'ⵯ'),
+    ('ⶀ', 'ⶖ'),
+    ('ⶠ', 'ⶦ'),
+    ('ⶨ', 'ⶮ'),
+    ('ⶰ', 'ⶶ'),
+    ('ⶸ', 'ⶾ'),
+    ('ⷀ', 'ⷆ'),
+    ('ⷈ', 'ⷎ'),
+    ('ⷐ', 'ⷖ'),
+    ('ⷘ', 'ⷞ'),
+    ('⸀', '⸗'),
+    ('⸜', '⸝'),
+    ('㇀', '㇏'),
+    ('㉾', '㉾'),
+    ('龦', '龻'),
+    ('꜀', '꜖'),
+    ('ꠀ', '꠫'),
+    ('並', '龎'),
+    ('︐', '︙'),
+    ('𐅀', '𐆊'),
+    ('𐎠', '𐏃'),
+    ('𐏈', '𐏕'),
+    ('𐨀', '\u{10a03}'),
+    ('\u{10a05}', '\u{10a06}'),
+    ('\u{10a0c}', '𐨓'),
+    ('𐨕', '𐨗'),
+    ('𐨙', '𐨳'),
+    ('\u{10a38}', '\u{10a3a}'),
+    ('\u{10a3f}', '𐩇'),
+    ('𐩐', '𐩘'),
+    ('𝈀', '𝉅'),
+    ('𝚤', '𝚥'),
+];
+
+pub const V5_0: &'static [(char, char)] = &[
+    ('ɂ', 'ɏ'),
+    ('ͻ', 'ͽ'),
+    ('ӏ', 'ӏ'),
+    ('Ӻ', 'ӿ'),
+    ('Ԑ', 'ԓ'),
+    ('\u{5ba}', '\u{5ba}'),
+    ('߀', 'ߺ'),
+    ('ॻ', 'ॼ'),
+    ('ॾ', 'ॿ'),
+    ('\u{ce2}', '\u{ce3}'),
+    ('ೱ', 'ೲ'),
+    ('\u{1b00}', 'ᭋ'),
+    ('᭐', '᭼'),
+    ('\u{1dc4}', '\u{1dca}'),
+    ('\u{1dfe}', '\u{1dff}'),
+    ('\u{20ec}', '\u{20ef}'),
+    ('⅍', 'ⅎ'),
+    ('ↄ', 'ↄ'),
+    ('⏜', '⏧'),
+    ('⚲', '⚲'),
+    ('⟇', '⟊'),
+    ('⬔', '⬚'),
+    ('⬠', '⬣'),
+    ('Ⱡ', 'ⱬ'),
+    ('ⱴ', 'ⱷ'),
+    ('ꜗ', 'ꜚ'),
+    ('꜠', '꜡'),
+    ('ꡀ', '꡷'),
+    ('𐤀', '𐤙'),
+    ('𐤟', '𐤟'),
+    ('𒀀', '𒍮'),
+    ('𒐀', '𒑢'),
+    ('𒑰', '𒑳'),
+    ('𝍠', '𝍱'),
+    ('𝟊', '𝟋'),
+];
+
+pub const V5_1: &'static [(char, char)] = &[
+    ('Ͱ', 'ͳ'),
+    ('Ͷ', 'ͷ'),
+    ('Ϗ', 'Ϗ'),
+    ('\u{487}', '\u{487}'),
+    ('Ԕ', 'ԣ'),
+    ('؆', '؊'),
+    ('\u{616}', '\u{61a}'),
+    ('ػ', 'ؿ'),
+    ('ݮ', 'ݿ'),
+    ('ॱ', 'ॲ'),
+    ('\u{a51}', '\u{a51}'),
+    ('\u{a75}', '\u{a75}'),
+    ('\u{b44}', '\u{b44}'),
+    ('\u{b62}', '\u{b63}'),
+    ('ௐ', 'ௐ'),
+    ('ఽ', 'ఽ'),
+    ('ౘ', 'ౙ'),
+    ('\u{c62}', '\u{c63}'),
+    ('౸', '౿'),
+    ('ഽ', 'ഽ'),
+    ('\u{d44}', '\u{d44}'),
+    ('\u{d62}', '\u{d63}'),
+    ('൰', '൵'),
+    ('൹', 'ൿ'),
+    ('ཫ', 'ཬ'),
+    ('࿎', '࿎'),
+    ('࿒', '࿔'),
+    ('ဢ', 'ဢ'),
+    ('ဨ', 'ဨ'),
+    ('ါ', 'ါ'),
+    ('\u{1033}', '\u{1035}'),
+    ('\u{103a}', 'ဿ'),
+    ('ၚ', '႙'),
+    ('႞', '႟'),
+    ('ᢪ', 'ᢪ'),
+    ('\u{1b80}', '᮪'),
+    ('ᮮ', '᮹'),
+    ('ᰀ', '\u{1c37}'),
+    ('᰻', '᱉'),
+    ('ᱍ', '᱿'),
+    ('\u{1dcb}', '\u{1de6}'),
+    ('ẜ', 'ẟ'),
+    ('Ỻ', 'ỿ'),
+    ('\u{2064}', '\u{2064}'),
+    ('\u{20f0}', '\u{20f0}'),
+    ('⅏', '⅏'),
+    ('ↅ', 'ↈ'),
+    ('⚝', '⚝'),
+    ('⚳', '⚼'),
+    ('⛀', '⛃'),
+    ('⟌', '⟌'),
+    ('⟬', '⟯'),
+    ('⬛', '⬟'),
+    ('⬤', '⭌'),
+    ('⭐', '⭔'),
+    ('Ɑ', 'Ɐ'),
+    ('ⱱ', 'ⱳ'),
+    ('ⱸ', 'ⱽ'),
+    ('\u{2de0}', '\u{2dff}'),
+    ('⸘', '⸛'),
+    ('⸞', '⸰'),
+    ('ㄭ', 'ㄭ'),
+    ('㇐', '㇣'),
+    ('龼', '鿃'),
+    ('ꔀ', 'ꘫ'),
+    ('Ꙁ', 'ꙟ'),
+    ('Ꙣ', '꙳'),
+    ('\u{a67c}', 'ꚗ'),
+    ('ꜛ', 'ꜟ'),
+    ('Ꜣ', 'ꞌ'),
+    ('ꟻ', 'ꟿ'),
+    ('ꢀ', '\u{a8c4}'),
+    ('꣎', '꣙'),
+    ('꤀', '꥓'),
+    ('꥟', '꥟'),
+    ('ꨀ', '\u{aa36}'),
+    ('ꩀ', 'ꩍ'),
+    ('꩐', '꩙'),
+    ('꩜', '꩟'),
+    ('\u{fe24}', '\u{fe26}'),
+    ('𐆐', '𐆛'),
+    ('𐇐', '\u{101fd}'),
+    ('𐊀', '𐊜'),
+    ('𐊠', '𐋐'),
+    ('𐤠', '𐤹'),
+    ('𐤿', '𐤿'),
+    ('𝄩', '𝄩'),
+    ('🀀', '🀫'),
+    ('🀰', '🂓'),
+];
+
+pub const V5_2: &'static [(char, char)] = &[
+    ('Ԥ', 'ԥ'),
+    ('ࠀ', '\u{82d}'),
+    ('࠰', '࠾'),
+    ('\u{900}', '\u{900}'),
+    ('ॎ', 'ॎ'),
+    ('\u{955}', '\u{955}'),
+    ('ॹ', 'ॺ'),
+    ('৻', '৻'),
+    ('࿕', '࿘'),
+    ('ႚ', '\u{109d}'),
+    ('ᅚ', 'ᅞ'),
+    ('ᆣ', 'ᆧ'),
+    ('ᇺ', 'ᇿ'),
+    ('᐀', '᐀'),
+    ('ᙷ', 'ᙿ'),
+    ('ᢰ', 'ᣵ'),
+    ('ᦪ', 'ᦫ'),
+    ('᧚', '᧚'),
+    ('ᨠ', '\u{1a5e}'),
+    ('\u{1a60}', '\u{1a7c}'),
+    ('\u{1a7f}', '᪉'),
+    ('᪐', '᪙'),
+    ('᪠', '᪭'),
+    ('\u{1cd0}', 'ᳲ'),
+    ('\u{1dfd}', '\u{1dfd}'),
+    ('₶', '₸'),
+    ('⅐', '⅒'),
+    ('↉', '↉'),
+    ('⏨', '⏨'),
+    ('⚞', '⚟'),
+    ('⚽', '⚿'),
+    ('⛄', '⛍'),
+    ('⛏', '⛡'),
+    ('⛣', '⛣'),
+    ('⛨', '⛿'),
+    ('❗', '❗'),
+    ('⭕', '⭙'),
+    ('Ɒ', 'Ɒ'),
+    ('Ȿ', 'Ɀ'),
+    ('Ⳬ', '\u{2cf1}'),
+    ('⸱', '⸱'),
+    ('㉄', '㉏'),
+    ('鿄', '鿋'),
+    ('ꓐ', '꓿'),
+    ('ꚠ', '꛷'),
+    ('꠰', '꠹'),
+    ('\u{a8e0}', 'ꣻ'),
+    ('ꥠ', 'ꥼ'),
+    ('\u{a980}', '꧍'),
+    ('ꧏ', '꧙'),
+    ('꧞', '꧟'),
+    ('ꩠ', 'ꩻ'),
+    ('ꪀ', 'ꫂ'),
+    ('ꫛ', '꫟'),
+    ('ꯀ', '\u{abed}'),
+    ('꯰', '꯹'),
+    ('ힰ', 'ퟆ'),
+    ('ퟋ', 'ퟻ'),
+    ('恵', '舘'),
+    ('𐡀', '𐡕'),
+    ('𐡗', '𐡟'),
+    ('𐤚', '𐤛'),
+    ('𐩠', '𐩿'),
+    ('𐬀', '𐬵'),
+    ('𐬹', '𐭕'),
+    ('𐭘', '𐭲'),
+    ('𐭸', '𐭿'),
+    ('𐰀', '𐱈'),
+    ('𐹠', '𐹾'),
+    ('\u{11080}', '𑃁'),
+    ('𓀀', '𓐮'),
+    ('🄀', '🄊'),
+    ('🄐', '🄮'),
+    ('🄱', '🄱'),
+    ('🄽', '🄽'),
+    ('🄿', '🄿'),
+    ('🅂', '🅂'),
+    ('🅆', '🅆'),
+    ('🅊', '🅎'),
+    ('🅗', '🅗'),
+    ('🅟', '🅟'),
+    ('🅹', '🅹'),
+    ('🅻', '🅼'),
+    ('🅿', '🅿'),
+    ('🆊', '🆍'),
+    ('🆐', '🆐'),
+    ('🈀', '🈀'),
+    ('🈐', '🈱'),
+    ('🉀', '🉈'),
+    ('𪜀', '𫜴'),
+];
+
+pub const V6_0: &'static [(char, char)] = &[
+    ('Ԧ', 'ԧ'),
+    ('ؠ', 'ؠ'),
+    ('\u{65f}', '\u{65f}'),
+    ('ࡀ', '\u{85b}'),
+    ('࡞', '࡞'),
+    ('\u{93a}', 'ऻ'),
+    ('ॏ', 'ॏ'),
+    ('\u{956}', '\u{957}'),
+    ('ॳ', 'ॷ'),
+    ('୲', '୷'),
+    ('ഩ', 'ഩ'),
+    ('ഺ', 'ഺ'),
+    ('ൎ', 'ൎ'),
+    ('ྌ', '\u{f8f}'),
+    ('࿙', '࿚'),
+    ('\u{135d}', '\u{135e}'),
+    ('ᯀ', '᯳'),
+    ('᯼', '᯿'),
+    ('\u{1dfc}', '\u{1dfc}'),
+    ('ₕ', 'ₜ'),
+    ('₹', '₹'),
+    ('⏩', '⏳'),
+    ('⛎', '⛎'),
+    ('⛢', '⛢'),
+    ('⛤', '⛧'),
+    ('✅', '✅'),
+    ('✊', '✋'),
+    ('✨', '✨'),
+    ('❌', '❌'),
+    ('❎', '❎'),
+    ('❓', '❕'),
+    ('❟', '❠'),
+    ('➕', '➗'),
+    ('➰', '➰'),
+    ('➿', '➿'),
+    ('⟎', '⟏'),
+    ('⵰', '⵰'),
+    ('\u{2d7f}', '\u{2d7f}'),
+    ('ㆸ', 'ㆺ'),
+    ('Ꙡ', 'ꙡ'),
+    ('Ɥ', 'ꞎ'),
+    ('Ꞑ', 'ꞑ'),
+    ('Ꞡ', 'ꞩ'),
+    ('ꟺ', 'ꟺ'),
+    ('ꬁ', 'ꬆ'),
+    ('ꬉ', 'ꬎ'),
+    ('ꬑ', 'ꬖ'),
+    ('ꬠ', 'ꬦ'),
+    ('ꬨ', 'ꬮ'),
+    ('﮲', '﯁'),
+    ('𑀀', '𑁍'),
+    ('𑁒', '𑁯'),
+    ('𖠀', '𖨸'),
+    ('𛀀', '𛀁'),
+    ('🂠', '🂮'),
+    ('🂱', '🂾'),
+    ('🃁', '🃏'),
+    ('🃑', '🃟'),
+    ('🄰', '🄰'),
+    ('🄲', '🄼'),
+    ('🄾', '🄾'),
+    ('🅀', '🅁'),
+    ('🅃', '🅅'),
+    ('🅇', '🅉'),
+    ('🅏', '🅖'),
+    ('🅘', '🅞'),
+    ('🅠', '🅩'),
+    ('🅰', '🅸'),
+    ('🅺', '🅺'),
+    ('🅽', '🅾'),
+    ('🆀', '🆉'),
+    ('🆎', '🆏'),
+    ('🆑', '🆚'),
+    ('🇦', '🇿'),
+    ('🈁', '🈂'),
+    ('🈲', '🈺'),
+    ('🉐', '🉑'),
+    ('🌀', '🌠'),
+    ('🌰', '🌵'),
+    ('🌷', '🍼'),
+    ('🎀', '🎓'),
+    ('🎠', '🏄'),
+    ('🏆', '🏊'),
+    ('🏠', '🏰'),
+    ('🐀', '🐾'),
+    ('👀', '👀'),
+    ('👂', '📷'),
+    ('📹', '📼'),
+    ('🔀', '🔽'),
+    ('🕐', '🕧'),
+    ('🗻', '🗿'),
+    ('😁', '😐'),
+    ('😒', '😔'),
+    ('😖', '😖'),
+    ('😘', '😘'),
+    ('😚', '😚'),
+    ('😜', '😞'),
+    ('😠', '😥'),
+    ('😨', '😫'),
+    ('😭', '😭'),
+    ('😰', '😳'),
+    ('😵', '🙀'),
+    ('🙅', '🙏'),
+    ('🚀', '🛅'),
+    ('🜀', '🝳'),
+    ('𫝀', '𫠝'),
+];
+
+pub const V6_1: &'static [(char, char)] = &[
+    ('֏', '֏'),
+    ('\u{604}', '\u{604}'),
+    ('ࢠ', 'ࢠ'),
+    ('ࢢ', 'ࢬ'),
+    ('\u{8e4}', '\u{8fe}'),
+    ('૰', '૰'),
+    ('ໞ', 'ໟ'),
+    ('Ⴧ', 'Ⴧ'),
+    ('Ⴭ', 'Ⴭ'),
+    ('ჽ', 'ჿ'),
+    ('\u{1bab}', '\u{1bad}'),
+    ('ᮺ', 'ᮿ'),
+    ('᳀', '᳇'),
+    ('ᳳ', 'ᳶ'),
+    ('⟋', '⟋'),
+    ('⟍', '⟍'),
+    ('Ⳳ', 'ⳳ'),
+    ('ⴧ', 'ⴧ'),
+    ('ⴭ', 'ⴭ'),
+    ('ⵦ', 'ⵧ'),
+    ('⸲', '⸻'),
+    ('鿌', '鿌'),
+    ('\u{a674}', '\u{a67b}'),
+    ('\u{a69f}', '\u{a69f}'),
+    ('Ꞓ', 'ꞓ'),
+    ('Ɦ', 'Ɦ'),
+    ('ꟸ', 'ꟹ'),
+    ('ꫠ', '\u{aaf6}'),
+    ('郞', '隷'),
+    ('𐦀', '𐦷'),
+    ('𐦾', '𐦿'),
+    ('𑃐', '𑃨'),
+    ('𑃰', '𑃹'),
+    ('\u{11100}', '\u{11134}'),
+    ('𑄶', '𑅃'),
+    ('\u{11180}', '𑇈'),
+    ('𑇐', '𑇙'),
+    ('𑚀', '\u{116b7}'),
+    ('𑛀', '𑛉'),
+    ('𖼀', '𖽄'),
+    ('𖽐', '𖽾'),
+    ('\u{16f8f}', '𖾟'),
+    ('𞸀', '𞸃'),
+    ('𞸅', '𞸟'),
+    ('𞸡', '𞸢'),
+    ('𞸤', '𞸤'),
+    ('𞸧', '𞸧'),
+    ('𞸩', '𞸲'),
+    ('𞸴', '𞸷'),
+    ('𞸹', '𞸹'),
+    ('𞸻', '𞸻'),
+    ('𞹂', '𞹂'),
+    ('𞹇', '𞹇'),
+    ('𞹉', '𞹉'),
+    ('𞹋', '𞹋'),
+    ('𞹍', '𞹏'),
+    ('𞹑', '𞹒'),
+    ('𞹔', '𞹔'),
+    ('𞹗', '𞹗'),
+    ('𞹙', '𞹙'),
+    ('𞹛', '𞹛'),
+    ('𞹝', '𞹝'),
+    ('𞹟', '𞹟'),
+    ('𞹡', '𞹢'),
+    ('𞹤', '𞹤'),
+    ('𞹧', '𞹪'),
+    ('𞹬', '𞹲'),
+    ('𞹴', '𞹷'),
+    ('𞹹', '𞹼'),
+    ('𞹾', '𞹾'),
+    ('𞺀', '𞺉'),
+    ('𞺋', '𞺛'),
+    ('𞺡', '𞺣'),
+    ('𞺥', '𞺩'),
+    ('𞺫', '𞺻'),
+    ('𞻰', '𞻱'),
+    ('🅪', '🅫'),
+    ('🕀', '🕃'),
+    ('😀', '😀'),
+    ('😑', '😑'),
+    ('😕', '😕'),
+    ('😗', '😗'),
+    ('😙', '😙'),
+    ('😛', '😛'),
+    ('😟', '😟'),
+    ('😦', '😧'),
+    ('😬', '😬'),
+    ('😮', '😯'),
+    ('😴', '😴'),
+];
+
+pub const V6_2: &'static [(char, char)] = &[('₺', '₺')];
+
+pub const V6_3: &'static [(char, char)] =
+    &[('\u{61c}', '\u{61c}'), ('\u{2066}', '\u{2069}')];
+
+pub const V7_0: &'static [(char, char)] = &[
+    ('Ϳ', 'Ϳ'),
+    ('Ԩ', 'ԯ'),
+    ('֍', '֎'),
+    ('\u{605}', '\u{605}'),
+    ('ࢡ', 'ࢡ'),
+    ('ࢭ', 'ࢲ'),
+    ('\u{8ff}', '\u{8ff}'),
+    ('ॸ', 'ॸ'),
+    ('ঀ', 'ঀ'),
+    ('\u{c00}', '\u{c00}'),
+    ('ఴ', 'ఴ'),
+    ('\u{c81}', '\u{c81}'),
+    ('\u{d01}', '\u{d01}'),
+    ('෦', '෯'),
+    ('ᛱ', 'ᛸ'),
+    ('ᤝ', 'ᤞ'),
+    ('\u{1ab0}', '\u{1abe}'),
+    ('\u{1cf8}', '\u{1cf9}'),
+    ('\u{1de7}', '\u{1df5}'),
+    ('₻', '₽'),
+    ('⏴', '⏺'),
+    ('✀', '✀'),
+    ('⭍', '⭏'),
+    ('⭚', '⭳'),
+    ('⭶', '⮕'),
+    ('⮘', '⮹'),
+    ('⮽', '⯈'),
+    ('⯊', '⯑'),
+    ('⸼', '⹂'),
+    ('Ꚙ', 'ꚝ'),
+    ('ꞔ', 'ꞟ'),
+    ('Ɜ', 'Ɬ'),
+    ('Ʞ', 'Ʇ'),
+    ('ꟷ', 'ꟷ'),
+    ('ꧠ', 'ꧾ'),
+    ('\u{aa7c}', 'ꩿ'),
+    ('ꬰ', 'ꭟ'),
+    ('ꭤ', 'ꭥ'),
+    ('\u{fe27}', '\u{fe2d}'),
+    ('𐆋', '𐆌'),
+    ('𐆠', '𐆠'),
+    ('\u{102e0}', '𐋻'),
+    ('𐌟', '𐌟'),
+    ('𐍐', '\u{1037a}'),
+    ('𐔀', '𐔧'),
+    ('𐔰', '𐕣'),
+    ('𐕯', '𐕯'),
+    ('𐘀', '𐜶'),
+    ('𐝀', '𐝕'),
+    ('𐝠', '𐝧'),
+    ('𐡠', '𐢞'),
+    ('𐢧', '𐢯'),
+    ('𐪀', '𐪟'),
+    ('𐫀', '\u{10ae6}'),
+    ('𐫫', '𐫶'),
+    ('𐮀', '𐮑'),
+    ('𐮙', '𐮜'),
+    ('𐮩', '𐮯'),
+    ('\u{1107f}', '\u{1107f}'),
+    ('𑅐', '𑅶'),
+    ('𑇍', '𑇍'),
+    ('𑇚', '𑇚'),
+    ('𑇡', '𑇴'),
+    ('𑈀', '𑈑'),
+    ('𑈓', '𑈽'),
+    ('𑊰', '\u{112ea}'),
+    ('𑋰', '𑋹'),
+    ('\u{11301}', '𑌃'),
+    ('𑌅', '𑌌'),
+    ('𑌏', '𑌐'),
+    ('𑌓', '𑌨'),
+    ('𑌪', '𑌰'),
+    ('𑌲', '𑌳'),
+    ('𑌵', '𑌹'),
+    ('\u{1133c}', '𑍄'),
+    ('𑍇', '𑍈'),
+    ('𑍋', '𑍍'),
+    ('\u{11357}', '\u{11357}'),
+    ('𑍝', '𑍣'),
+    ('\u{11366}', '\u{1136c}'),
+    ('\u{11370}', '\u{11374}'),
+    ('𑒀', '𑓇'),
+    ('𑓐', '𑓙'),
+    ('𑖀', '\u{115b5}'),
+    ('𑖸', '𑗉'),
+    ('𑘀', '𑙄'),
+    ('𑙐', '𑙙'),
+    ('𑢠', '𑣲'),
+    ('𑣿', '𑣿'),
+    ('𑫀', '𑫸'),
+    ('𒍯', '𒎘'),
+    ('𒑣', '𒑮'),
+    ('𒑴', '𒑴'),
+    ('𖩀', '𖩞'),
+    ('𖩠', '𖩩'),
+    ('𖩮', '𖩯'),
+    ('𖫐', '𖫭'),
+    ('\u{16af0}', '𖫵'),
+    ('𖬀', '𖭅'),
+    ('𖭐', '𖭙'),
+    ('𖭛', '𖭡'),
+    ('𖭣', '𖭷'),
+    ('𖭽', '𖮏'),
+    ('𛰀', '𛱪'),
+    ('𛱰', '𛱼'),
+    ('𛲀', '𛲈'),
+    ('𛲐', '𛲙'),
+    ('𛲜', '\u{1bca3}'),
+    ('𞠀', '𞣄'),
+    ('𞣇', '\u{1e8d6}'),
+    ('🂿', '🂿'),
+    ('🃠', '🃵'),
+    ('🄋', '🄌'),
+    ('🌡', '🌬'),
+    ('🌶', '🌶'),
+    ('🍽', '🍽'),
+    ('🎔', '🎟'),
+    ('🏅', '🏅'),
+    ('🏋', '🏎'),
+    ('🏔', '🏟'),
+    ('🏱', '🏷'),
+    ('🐿', '🐿'),
+    ('👁', '👁'),
+    ('📸', '📸'),
+    ('📽', '📾'),
+    ('🔾', '🔿'),
+    ('🕄', '🕊'),
+    ('🕨', '🕹'),
+    ('🕻', '🖣'),
+    ('🖥', '🗺'),
+    ('🙁', '🙂'),
+    ('🙐', '🙿'),
+    ('🛆', '🛏'),
+    ('🛠', '🛬'),
+    ('🛰', '🛳'),
+    ('🞀', '🟔'),
+    ('🠀', '🠋'),
+    ('🠐', '🡇'),
+    ('🡐', '🡙'),
+    ('🡠', '🢇'),
+    ('🢐', '🢭'),
+];
+
+pub const V8_0: &'static [(char, char)] = &[
+    ('ࢳ', 'ࢴ'),
+    ('\u{8e3}', '\u{8e3}'),
+    ('ૹ', 'ૹ'),
+    ('ౚ', 'ౚ'),
+    ('ൟ', 'ൟ'),
+    ('Ᏽ', 'Ᏽ'),
+    ('ᏸ', 'ᏽ'),
+    ('₾', '₾'),
+    ('↊', '↋'),
+    ('⯬', '⯯'),
+    ('鿍', '鿕'),
+    ('\u{a69e}', '\u{a69e}'),
+    ('ꞏ', 'ꞏ'),
+    ('Ʝ', 'ꞷ'),
+    ('꣼', 'ꣽ'),
+    ('ꭠ', 'ꭣ'),
+    ('ꭰ', 'ꮿ'),
+    ('\u{fe2e}', '\u{fe2f}'),
+    ('𐣠', '𐣲'),
+    ('𐣴', '𐣵'),
+    ('𐣻', '𐣿'),
+    ('𐦼', '𐦽'),
+    ('𐧀', '𐧏'),
+    ('𐧒', '𐧿'),
+    ('𐲀', '𐲲'),
+    ('𐳀', '𐳲'),
+    ('𐳺', '𐳿'),
+    ('\u{111c9}', '\u{111cc}'),
+    ('𑇛', '𑇟'),
+    ('𑊀', '𑊆'),
+    ('𑊈', '𑊈'),
+    ('𑊊', '𑊍'),
+    ('𑊏', '𑊝'),
+    ('𑊟', '𑊩'),
+    ('\u{11300}', '\u{11300}'),
+    ('𑍐', '𑍐'),
+    ('𑗊', '\u{115dd}'),
+    ('𑜀', '𑜙'),
+    ('\u{1171d}', '\u{1172b}'),
+    ('𑜰', '𑜿'),
+    ('𒎙', '𒎙'),
+    ('𒒀', '𒕃'),
+    ('𔐀', '𔙆'),
+    ('𝇞', '𝇨'),
+    ('𝠀', '𝪋'),
+    ('\u{1da9b}', '\u{1da9f}'),
+    ('\u{1daa1}', '\u{1daaf}'),
+    ('🌭', '🌯'),
+    ('🍾', '🍿'),
+    ('🏏', '🏓'),
+    ('🏸', '🏿'),
+    ('📿', '📿'),
+    ('🕋', '🕏'),
+    ('🙃', '🙄'),
+    ('🛐', '🛐'),
+    ('🤐', '🤘'),
+    ('🦀', '🦄'),
+    ('🧀', '🧀'),
+    ('𫠠', '𬺡'),
+];
+
+pub const V9_0: &'static [(char, char)] = &[
+    ('ࢶ', 'ࢽ'),
+    ('\u{8d4}', '\u{8e2}'),
+    ('ಀ', 'ಀ'),
+    ('൏', '൏'),
+    ('ൔ', 'ൖ'),
+    ('൘', '൞'),
+    ('൶', '൸'),
+    ('ᲀ', 'ᲈ'),
+    ('\u{1dfb}', '\u{1dfb}'),
+    ('⏻', '⏾'),
+    ('⹃', '⹄'),
+    ('Ɪ', 'Ɪ'),
+    ('\u{a8c5}', '\u{a8c5}'),
+    ('𐆍', '𐆎'),
+    ('𐒰', '𐓓'),
+    ('𐓘', '𐓻'),
+    ('\u{1123e}', '\u{1123e}'),
+    ('𑐀', '𑑙'),
+    ('𑑛', '𑑛'),
+    ('𑑝', '𑑝'),
+    ('𑙠', '𑙬'),
+    ('𑰀', '𑰈'),
+    ('𑰊', '\u{11c36}'),
+    ('\u{11c38}', '𑱅'),
+    ('𑱐', '𑱬'),
+    ('𑱰', '𑲏'),
+    ('\u{11c92}', '\u{11ca7}'),
+    ('𑲩', '\u{11cb6}'),
+    ('𖿠', '𖿠'),
+    ('𗀀', '𘟬'),
+    ('𘠀', '𘫲'),
+    ('\u{1e000}', '\u{1e006}'),
+    ('\u{1e008}', '\u{1e018}'),
+    ('\u{1e01b}', '\u{1e021}'),
+    ('\u{1e023}', '\u{1e024}'),
+    ('\u{1e026}', '\u{1e02a}'),
+    ('𞤀', '\u{1e94a}'),
+    ('𞥐', '𞥙'),
+    ('𞥞', '𞥟'),
+    ('🆛', '🆬'),
+    ('🈻', '🈻'),
+    ('🕺', '🕺'),
+    ('🖤', '🖤'),
+    ('🛑', '🛒'),
+    ('🛴', '🛶'),
+    ('🤙', '🤞'),
+    ('🤠', '🤧'),
+    ('🤰', '🤰'),
+    ('🤳', '🤾'),
+    ('🥀', '🥋'),
+    ('🥐', '🥞'),
+    ('🦅', '🦑'),
+];
diff --git a/crates/regex-syntax/src/unicode_tables/case_folding_simple.rs b/crates/regex-syntax/src/unicode_tables/case_folding_simple.rs
new file mode 100644
index 0000000..23f9364
--- /dev/null
+++ b/crates/regex-syntax/src/unicode_tables/case_folding_simple.rs
@@ -0,0 +1,2888 @@
+// DO NOT EDIT THIS FILE. IT WAS AUTOMATICALLY GENERATED BY:
+//
+//   ucd-generate case-folding-simple ucd-15.0.0 --chars --all-pairs
+//
+// Unicode version: 15.0.0.
+//
+// ucd-generate 0.2.14 is available on crates.io.
+
+pub const CASE_FOLDING_SIMPLE: &'static [(char, &'static [char])] = &[
+    ('A', &['a']),
+    ('B', &['b']),
+    ('C', &['c']),
+    ('D', &['d']),
+    ('E', &['e']),
+    ('F', &['f']),
+    ('G', &['g']),
+    ('H', &['h']),
+    ('I', &['i']),
+    ('J', &['j']),
+    ('K', &['k', 'K']),
+    ('L', &['l']),
+    ('M', &['m']),
+    ('N', &['n']),
+    ('O', &['o']),
+    ('P', &['p']),
+    ('Q', &['q']),
+    ('R', &['r']),
+    ('S', &['s', 'ſ']),
+    ('T', &['t']),
+    ('U', &['u']),
+    ('V', &['v']),
+    ('W', &['w']),
+    ('X', &['x']),
+    ('Y', &['y']),
+    ('Z', &['z']),
+    ('a', &['A']),
+    ('b', &['B']),
+    ('c', &['C']),
+    ('d', &['D']),
+    ('e', &['E']),
+    ('f', &['F']),
+    ('g', &['G']),
+    ('h', &['H']),
+    ('i', &['I']),
+    ('j', &['J']),
+    ('k', &['K', 'K']),
+    ('l', &['L']),
+    ('m', &['M']),
+    ('n', &['N']),
+    ('o', &['O']),
+    ('p', &['P']),
+    ('q', &['Q']),
+    ('r', &['R']),
+    ('s', &['S', 'ſ']),
+    ('t', &['T']),
+    ('u', &['U']),
+    ('v', &['V']),
+    ('w', &['W']),
+    ('x', &['X']),
+    ('y', &['Y']),
+    ('z', &['Z']),
+    ('µ', &['Μ', 'μ']),
+    ('À', &['à']),
+    ('Á', &['á']),
+    ('Â', &['â']),
+    ('Ã', &['ã']),
+    ('Ä', &['ä']),
+    ('Å', &['å', 'Å']),
+    ('Æ', &['æ']),
+    ('Ç', &['ç']),
+    ('È', &['è']),
+    ('É', &['é']),
+    ('Ê', &['ê']),
+    ('Ë', &['ë']),
+    ('Ì', &['ì']),
+    ('Í', &['í']),
+    ('Î', &['î']),
+    ('Ï', &['ï']),
+    ('Ð', &['ð']),
+    ('Ñ', &['ñ']),
+    ('Ò', &['ò']),
+    ('Ó', &['ó']),
+    ('Ô', &['ô']),
+    ('Õ', &['õ']),
+    ('Ö', &['ö']),
+    ('Ø', &['ø']),
+    ('Ù', &['ù']),
+    ('Ú', &['ú']),
+    ('Û', &['û']),
+    ('Ü', &['ü']),
+    ('Ý', &['ý']),
+    ('Þ', &['þ']),
+    ('ß', &['ẞ']),
+    ('à', &['À']),
+    ('á', &['Á']),
+    ('â', &['Â']),
+    ('ã', &['Ã']),
+    ('ä', &['Ä']),
+    ('å', &['Å', 'Å']),
+    ('æ', &['Æ']),
+    ('ç', &['Ç']),
+    ('è', &['È']),
+    ('é', &['É']),
+    ('ê', &['Ê']),
+    ('ë', &['Ë']),
+    ('ì', &['Ì']),
+    ('í', &['Í']),
+    ('î', &['Î']),
+    ('ï', &['Ï']),
+    ('ð', &['Ð']),
+    ('ñ', &['Ñ']),
+    ('ò', &['Ò']),
+    ('ó', &['Ó']),
+    ('ô', &['Ô']),
+    ('õ', &['Õ']),
+    ('ö', &['Ö']),
+    ('ø', &['Ø']),
+    ('ù', &['Ù']),
+    ('ú', &['Ú']),
+    ('û', &['Û']),
+    ('ü', &['Ü']),
+    ('ý', &['Ý']),
+    ('þ', &['Þ']),
+    ('ÿ', &['Ÿ']),
+    ('Ā', &['ā']),
+    ('ā', &['Ā']),
+    ('Ă', &['ă']),
+    ('ă', &['Ă']),
+    ('Ą', &['ą']),
+    ('ą', &['Ą']),
+    ('Ć', &['ć']),
+    ('ć', &['Ć']),
+    ('Ĉ', &['ĉ']),
+    ('ĉ', &['Ĉ']),
+    ('Ċ', &['ċ']),
+    ('ċ', &['Ċ']),
+    ('Č', &['č']),
+    ('č', &['Č']),
+    ('Ď', &['ď']),
+    ('ď', &['Ď']),
+    ('Đ', &['đ']),
+    ('đ', &['Đ']),
+    ('Ē', &['ē']),
+    ('ē', &['Ē']),
+    ('Ĕ', &['ĕ']),
+    ('ĕ', &['Ĕ']),
+    ('Ė', &['ė']),
+    ('ė', &['Ė']),
+    ('Ę', &['ę']),
+    ('ę', &['Ę']),
+    ('Ě', &['ě']),
+    ('ě', &['Ě']),
+    ('Ĝ', &['ĝ']),
+    ('ĝ', &['Ĝ']),
+    ('Ğ', &['ğ']),
+    ('ğ', &['Ğ']),
+    ('Ġ', &['ġ']),
+    ('ġ', &['Ġ']),
+    ('Ģ', &['ģ']),
+    ('ģ', &['Ģ']),
+    ('Ĥ', &['ĥ']),
+    ('ĥ', &['Ĥ']),
+    ('Ħ', &['ħ']),
+    ('ħ', &['Ħ']),
+    ('Ĩ', &['ĩ']),
+    ('ĩ', &['Ĩ']),
+    ('Ī', &['ī']),
+    ('ī', &['Ī']),
+    ('Ĭ', &['ĭ']),
+    ('ĭ', &['Ĭ']),
+    ('Į', &['į']),
+    ('į', &['Į']),
+    ('Ĳ', &['ĳ']),
+    ('ĳ', &['Ĳ']),
+    ('Ĵ', &['ĵ']),
+    ('ĵ', &['Ĵ']),
+    ('Ķ', &['ķ']),
+    ('ķ', &['Ķ']),
+    ('Ĺ', &['ĺ']),
+    ('ĺ', &['Ĺ']),
+    ('Ļ', &['ļ']),
+    ('ļ', &['Ļ']),
+    ('Ľ', &['ľ']),
+    ('ľ', &['Ľ']),
+    ('Ŀ', &['ŀ']),
+    ('ŀ', &['Ŀ']),
+    ('Ł', &['ł']),
+    ('ł', &['Ł']),
+    ('Ń', &['ń']),
+    ('ń', &['Ń']),
+    ('Ņ', &['ņ']),
+    ('ņ', &['Ņ']),
+    ('Ň', &['ň']),
+    ('ň', &['Ň']),
+    ('Ŋ', &['ŋ']),
+    ('ŋ', &['Ŋ']),
+    ('Ō', &['ō']),
+    ('ō', &['Ō']),
+    ('Ŏ', &['ŏ']),
+    ('ŏ', &['Ŏ']),
+    ('Ő', &['ő']),
+    ('ő', &['Ő']),
+    ('Œ', &['œ']),
+    ('œ', &['Œ']),
+    ('Ŕ', &['ŕ']),
+    ('ŕ', &['Ŕ']),
+    ('Ŗ', &['ŗ']),
+    ('ŗ', &['Ŗ']),
+    ('Ř', &['ř']),
+    ('ř', &['Ř']),
+    ('Ś', &['ś']),
+    ('ś', &['Ś']),
+    ('Ŝ', &['ŝ']),
+    ('ŝ', &['Ŝ']),
+    ('Ş', &['ş']),
+    ('ş', &['Ş']),
+    ('Š', &['š']),
+    ('š', &['Š']),
+    ('Ţ', &['ţ']),
+    ('ţ', &['Ţ']),
+    ('Ť', &['ť']),
+    ('ť', &['Ť']),
+    ('Ŧ', &['ŧ']),
+    ('ŧ', &['Ŧ']),
+    ('Ũ', &['ũ']),
+    ('ũ', &['Ũ']),
+    ('Ū', &['ū']),
+    ('ū', &['Ū']),
+    ('Ŭ', &['ŭ']),
+    ('ŭ', &['Ŭ']),
+    ('Ů', &['ů']),
+    ('ů', &['Ů']),
+    ('Ű', &['ű']),
+    ('ű', &['Ű']),
+    ('Ų', &['ų']),
+    ('ų', &['Ų']),
+    ('Ŵ', &['ŵ']),
+    ('ŵ', &['Ŵ']),
+    ('Ŷ', &['ŷ']),
+    ('ŷ', &['Ŷ']),
+    ('Ÿ', &['ÿ']),
+    ('Ź', &['ź']),
+    ('ź', &['Ź']),
+    ('Ż', &['ż']),
+    ('ż', &['Ż']),
+    ('Ž', &['ž']),
+    ('ž', &['Ž']),
+    ('ſ', &['S', 's']),
+    ('ƀ', &['Ƀ']),
+    ('Ɓ', &['ɓ']),
+    ('Ƃ', &['ƃ']),
+    ('ƃ', &['Ƃ']),
+    ('Ƅ', &['ƅ']),
+    ('ƅ', &['Ƅ']),
+    ('Ɔ', &['ɔ']),
+    ('Ƈ', &['ƈ']),
+    ('ƈ', &['Ƈ']),
+    ('Ɖ', &['ɖ']),
+    ('Ɗ', &['ɗ']),
+    ('Ƌ', &['ƌ']),
+    ('ƌ', &['Ƌ']),
+    ('Ǝ', &['ǝ']),
+    ('Ə', &['ə']),
+    ('Ɛ', &['ɛ']),
+    ('Ƒ', &['ƒ']),
+    ('ƒ', &['Ƒ']),
+    ('Ɠ', &['ɠ']),
+    ('Ɣ', &['ɣ']),
+    ('ƕ', &['Ƕ']),
+    ('Ɩ', &['ɩ']),
+    ('Ɨ', &['ɨ']),
+    ('Ƙ', &['ƙ']),
+    ('ƙ', &['Ƙ']),
+    ('ƚ', &['Ƚ']),
+    ('Ɯ', &['ɯ']),
+    ('Ɲ', &['ɲ']),
+    ('ƞ', &['Ƞ']),
+    ('Ɵ', &['ɵ']),
+    ('Ơ', &['ơ']),
+    ('ơ', &['Ơ']),
+    ('Ƣ', &['ƣ']),
+    ('ƣ', &['Ƣ']),
+    ('Ƥ', &['ƥ']),
+    ('ƥ', &['Ƥ']),
+    ('Ʀ', &['ʀ']),
+    ('Ƨ', &['ƨ']),
+    ('ƨ', &['Ƨ']),
+    ('Ʃ', &['ʃ']),
+    ('Ƭ', &['ƭ']),
+    ('ƭ', &['Ƭ']),
+    ('Ʈ', &['ʈ']),
+    ('Ư', &['ư']),
+    ('ư', &['Ư']),
+    ('Ʊ', &['ʊ']),
+    ('Ʋ', &['ʋ']),
+    ('Ƴ', &['ƴ']),
+    ('ƴ', &['Ƴ']),
+    ('Ƶ', &['ƶ']),
+    ('ƶ', &['Ƶ']),
+    ('Ʒ', &['ʒ']),
+    ('Ƹ', &['ƹ']),
+    ('ƹ', &['Ƹ']),
+    ('Ƽ', &['ƽ']),
+    ('ƽ', &['Ƽ']),
+    ('ƿ', &['Ƿ']),
+    ('Ǆ', &['ǅ', 'ǆ']),
+    ('ǅ', &['Ǆ', 'ǆ']),
+    ('ǆ', &['Ǆ', 'ǅ']),
+    ('Ǉ', &['ǈ', 'ǉ']),
+    ('ǈ', &['Ǉ', 'ǉ']),
+    ('ǉ', &['Ǉ', 'ǈ']),
+    ('Ǌ', &['ǋ', 'ǌ']),
+    ('ǋ', &['Ǌ', 'ǌ']),
+    ('ǌ', &['Ǌ', 'ǋ']),
+    ('Ǎ', &['ǎ']),
+    ('ǎ', &['Ǎ']),
+    ('Ǐ', &['ǐ']),
+    ('ǐ', &['Ǐ']),
+    ('Ǒ', &['ǒ']),
+    ('ǒ', &['Ǒ']),
+    ('Ǔ', &['ǔ']),
+    ('ǔ', &['Ǔ']),
+    ('Ǖ', &['ǖ']),
+    ('ǖ', &['Ǖ']),
+    ('Ǘ', &['ǘ']),
+    ('ǘ', &['Ǘ']),
+    ('Ǚ', &['ǚ']),
+    ('ǚ', &['Ǚ']),
+    ('Ǜ', &['ǜ']),
+    ('ǜ', &['Ǜ']),
+    ('ǝ', &['Ǝ']),
+    ('Ǟ', &['ǟ']),
+    ('ǟ', &['Ǟ']),
+    ('Ǡ', &['ǡ']),
+    ('ǡ', &['Ǡ']),
+    ('Ǣ', &['ǣ']),
+    ('ǣ', &['Ǣ']),
+    ('Ǥ', &['ǥ']),
+    ('ǥ', &['Ǥ']),
+    ('Ǧ', &['ǧ']),
+    ('ǧ', &['Ǧ']),
+    ('Ǩ', &['ǩ']),
+    ('ǩ', &['Ǩ']),
+    ('Ǫ', &['ǫ']),
+    ('ǫ', &['Ǫ']),
+    ('Ǭ', &['ǭ']),
+    ('ǭ', &['Ǭ']),
+    ('Ǯ', &['ǯ']),
+    ('ǯ', &['Ǯ']),
+    ('Ǳ', &['ǲ', 'ǳ']),
+    ('ǲ', &['Ǳ', 'ǳ']),
+    ('ǳ', &['Ǳ', 'ǲ']),
+    ('Ǵ', &['ǵ']),
+    ('ǵ', &['Ǵ']),
+    ('Ƕ', &['ƕ']),
+    ('Ƿ', &['ƿ']),
+    ('Ǹ', &['ǹ']),
+    ('ǹ', &['Ǹ']),
+    ('Ǻ', &['ǻ']),
+    ('ǻ', &['Ǻ']),
+    ('Ǽ', &['ǽ']),
+    ('ǽ', &['Ǽ']),
+    ('Ǿ', &['ǿ']),
+    ('ǿ', &['Ǿ']),
+    ('Ȁ', &['ȁ']),
+    ('ȁ', &['Ȁ']),
+    ('Ȃ', &['ȃ']),
+    ('ȃ', &['Ȃ']),
+    ('Ȅ', &['ȅ']),
+    ('ȅ', &['Ȅ']),
+    ('Ȇ', &['ȇ']),
+    ('ȇ', &['Ȇ']),
+    ('Ȉ', &['ȉ']),
+    ('ȉ', &['Ȉ']),
+    ('Ȋ', &['ȋ']),
+    ('ȋ', &['Ȋ']),
+    ('Ȍ', &['ȍ']),
+    ('ȍ', &['Ȍ']),
+    ('Ȏ', &['ȏ']),
+    ('ȏ', &['Ȏ']),
+    ('Ȑ', &['ȑ']),
+    ('ȑ', &['Ȑ']),
+    ('Ȓ', &['ȓ']),
+    ('ȓ', &['Ȓ']),
+    ('Ȕ', &['ȕ']),
+    ('ȕ', &['Ȕ']),
+    ('Ȗ', &['ȗ']),
+    ('ȗ', &['Ȗ']),
+    ('Ș', &['ș']),
+    ('ș', &['Ș']),
+    ('Ț', &['ț']),
+    ('ț', &['Ț']),
+    ('Ȝ', &['ȝ']),
+    ('ȝ', &['Ȝ']),
+    ('Ȟ', &['ȟ']),
+    ('ȟ', &['Ȟ']),
+    ('Ƞ', &['ƞ']),
+    ('Ȣ', &['ȣ']),
+    ('ȣ', &['Ȣ']),
+    ('Ȥ', &['ȥ']),
+    ('ȥ', &['Ȥ']),
+    ('Ȧ', &['ȧ']),
+    ('ȧ', &['Ȧ']),
+    ('Ȩ', &['ȩ']),
+    ('ȩ', &['Ȩ']),
+    ('Ȫ', &['ȫ']),
+    ('ȫ', &['Ȫ']),
+    ('Ȭ', &['ȭ']),
+    ('ȭ', &['Ȭ']),
+    ('Ȯ', &['ȯ']),
+    ('ȯ', &['Ȯ']),
+    ('Ȱ', &['ȱ']),
+    ('ȱ', &['Ȱ']),
+    ('Ȳ', &['ȳ']),
+    ('ȳ', &['Ȳ']),
+    ('Ⱥ', &['ⱥ']),
+    ('Ȼ', &['ȼ']),
+    ('ȼ', &['Ȼ']),
+    ('Ƚ', &['ƚ']),
+    ('Ⱦ', &['ⱦ']),
+    ('ȿ', &['Ȿ']),
+    ('ɀ', &['Ɀ']),
+    ('Ɂ', &['ɂ']),
+    ('ɂ', &['Ɂ']),
+    ('Ƀ', &['ƀ']),
+    ('Ʉ', &['ʉ']),
+    ('Ʌ', &['ʌ']),
+    ('Ɇ', &['ɇ']),
+    ('ɇ', &['Ɇ']),
+    ('Ɉ', &['ɉ']),
+    ('ɉ', &['Ɉ']),
+    ('Ɋ', &['ɋ']),
+    ('ɋ', &['Ɋ']),
+    ('Ɍ', &['ɍ']),
+    ('ɍ', &['Ɍ']),
+    ('Ɏ', &['ɏ']),
+    ('ɏ', &['Ɏ']),
+    ('ɐ', &['Ɐ']),
+    ('ɑ', &['Ɑ']),
+    ('ɒ', &['Ɒ']),
+    ('ɓ', &['Ɓ']),
+    ('ɔ', &['Ɔ']),
+    ('ɖ', &['Ɖ']),
+    ('ɗ', &['Ɗ']),
+    ('ə', &['Ə']),
+    ('ɛ', &['Ɛ']),
+    ('ɜ', &['Ɜ']),
+    ('ɠ', &['Ɠ']),
+    ('ɡ', &['Ɡ']),
+    ('ɣ', &['Ɣ']),
+    ('ɥ', &['Ɥ']),
+    ('ɦ', &['Ɦ']),
+    ('ɨ', &['Ɨ']),
+    ('ɩ', &['Ɩ']),
+    ('ɪ', &['Ɪ']),
+    ('ɫ', &['Ɫ']),
+    ('ɬ', &['Ɬ']),
+    ('ɯ', &['Ɯ']),
+    ('ɱ', &['Ɱ']),
+    ('ɲ', &['Ɲ']),
+    ('ɵ', &['Ɵ']),
+    ('ɽ', &['Ɽ']),
+    ('ʀ', &['Ʀ']),
+    ('ʂ', &['Ʂ']),
+    ('ʃ', &['Ʃ']),
+    ('ʇ', &['Ʇ']),
+    ('ʈ', &['Ʈ']),
+    ('ʉ', &['Ʉ']),
+    ('ʊ', &['Ʊ']),
+    ('ʋ', &['Ʋ']),
+    ('ʌ', &['Ʌ']),
+    ('ʒ', &['Ʒ']),
+    ('ʝ', &['Ʝ']),
+    ('ʞ', &['Ʞ']),
+    ('\u{345}', &['Ι', 'ι', 'ι']),
+    ('Ͱ', &['ͱ']),
+    ('ͱ', &['Ͱ']),
+    ('Ͳ', &['ͳ']),
+    ('ͳ', &['Ͳ']),
+    ('Ͷ', &['ͷ']),
+    ('ͷ', &['Ͷ']),
+    ('ͻ', &['Ͻ']),
+    ('ͼ', &['Ͼ']),
+    ('ͽ', &['Ͽ']),
+    ('Ϳ', &['ϳ']),
+    ('Ά', &['ά']),
+    ('Έ', &['έ']),
+    ('Ή', &['ή']),
+    ('Ί', &['ί']),
+    ('Ό', &['ό']),
+    ('Ύ', &['ύ']),
+    ('Ώ', &['ώ']),
+    ('Α', &['α']),
+    ('Β', &['β', 'ϐ']),
+    ('Γ', &['γ']),
+    ('Δ', &['δ']),
+    ('Ε', &['ε', 'ϵ']),
+    ('Ζ', &['ζ']),
+    ('Η', &['η']),
+    ('Θ', &['θ', 'ϑ', 'ϴ']),
+    ('Ι', &['\u{345}', 'ι', 'ι']),
+    ('Κ', &['κ', 'ϰ']),
+    ('Λ', &['λ']),
+    ('Μ', &['µ', 'μ']),
+    ('Ν', &['ν']),
+    ('Ξ', &['ξ']),
+    ('Ο', &['ο']),
+    ('Π', &['π', 'ϖ']),
+    ('Ρ', &['ρ', 'ϱ']),
+    ('Σ', &['ς', 'σ']),
+    ('Τ', &['τ']),
+    ('Υ', &['υ']),
+    ('Φ', &['φ', 'ϕ']),
+    ('Χ', &['χ']),
+    ('Ψ', &['ψ']),
+    ('Ω', &['ω', 'Ω']),
+    ('Ϊ', &['ϊ']),
+    ('Ϋ', &['ϋ']),
+    ('ά', &['Ά']),
+    ('έ', &['Έ']),
+    ('ή', &['Ή']),
+    ('ί', &['Ί']),
+    ('α', &['Α']),
+    ('β', &['Β', 'ϐ']),
+    ('γ', &['Γ']),
+    ('δ', &['Δ']),
+    ('ε', &['Ε', 'ϵ']),
+    ('ζ', &['Ζ']),
+    ('η', &['Η']),
+    ('θ', &['Θ', 'ϑ', 'ϴ']),
+    ('ι', &['\u{345}', 'Ι', 'ι']),
+    ('κ', &['Κ', 'ϰ']),
+    ('λ', &['Λ']),
+    ('μ', &['µ', 'Μ']),
+    ('ν', &['Ν']),
+    ('ξ', &['Ξ']),
+    ('ο', &['Ο']),
+    ('π', &['Π', 'ϖ']),
+    ('ρ', &['Ρ', 'ϱ']),
+    ('ς', &['Σ', 'σ']),
+    ('σ', &['Σ', 'ς']),
+    ('τ', &['Τ']),
+    ('υ', &['Υ']),
+    ('φ', &['Φ', 'ϕ']),
+    ('χ', &['Χ']),
+    ('ψ', &['Ψ']),
+    ('ω', &['Ω', 'Ω']),
+    ('ϊ', &['Ϊ']),
+    ('ϋ', &['Ϋ']),
+    ('ό', &['Ό']),
+    ('ύ', &['Ύ']),
+    ('ώ', &['Ώ']),
+    ('Ϗ', &['ϗ']),
+    ('ϐ', &['Β', 'β']),
+    ('ϑ', &['Θ', 'θ', 'ϴ']),
+    ('ϕ', &['Φ', 'φ']),
+    ('ϖ', &['Π', 'π']),
+    ('ϗ', &['Ϗ']),
+    ('Ϙ', &['ϙ']),
+    ('ϙ', &['Ϙ']),
+    ('Ϛ', &['ϛ']),
+    ('ϛ', &['Ϛ']),
+    ('Ϝ', &['ϝ']),
+    ('ϝ', &['Ϝ']),
+    ('Ϟ', &['ϟ']),
+    ('ϟ', &['Ϟ']),
+    ('Ϡ', &['ϡ']),
+    ('ϡ', &['Ϡ']),
+    ('Ϣ', &['ϣ']),
+    ('ϣ', &['Ϣ']),
+    ('Ϥ', &['ϥ']),
+    ('ϥ', &['Ϥ']),
+    ('Ϧ', &['ϧ']),
+    ('ϧ', &['Ϧ']),
+    ('Ϩ', &['ϩ']),
+    ('ϩ', &['Ϩ']),
+    ('Ϫ', &['ϫ']),
+    ('ϫ', &['Ϫ']),
+    ('Ϭ', &['ϭ']),
+    ('ϭ', &['Ϭ']),
+    ('Ϯ', &['ϯ']),
+    ('ϯ', &['Ϯ']),
+    ('ϰ', &['Κ', 'κ']),
+    ('ϱ', &['Ρ', 'ρ']),
+    ('ϲ', &['Ϲ']),
+    ('ϳ', &['Ϳ']),
+    ('ϴ', &['Θ', 'θ', 'ϑ']),
+    ('ϵ', &['Ε', 'ε']),
+    ('Ϸ', &['ϸ']),
+    ('ϸ', &['Ϸ']),
+    ('Ϲ', &['ϲ']),
+    ('Ϻ', &['ϻ']),
+    ('ϻ', &['Ϻ']),
+    ('Ͻ', &['ͻ']),
+    ('Ͼ', &['ͼ']),
+    ('Ͽ', &['ͽ']),
+    ('Ѐ', &['ѐ']),
+    ('Ё', &['ё']),
+    ('Ђ', &['ђ']),
+    ('Ѓ', &['ѓ']),
+    ('Є', &['є']),
+    ('Ѕ', &['ѕ']),
+    ('І', &['і']),
+    ('Ї', &['ї']),
+    ('Ј', &['ј']),
+    ('Љ', &['љ']),
+    ('Њ', &['њ']),
+    ('Ћ', &['ћ']),
+    ('Ќ', &['ќ']),
+    ('Ѝ', &['ѝ']),
+    ('Ў', &['ў']),
+    ('Џ', &['џ']),
+    ('А', &['а']),
+    ('Б', &['б']),
+    ('В', &['в', 'ᲀ']),
+    ('Г', &['г']),
+    ('Д', &['д', 'ᲁ']),
+    ('Е', &['е']),
+    ('Ж', &['ж']),
+    ('З', &['з']),
+    ('И', &['и']),
+    ('Й', &['й']),
+    ('К', &['к']),
+    ('Л', &['л']),
+    ('М', &['м']),
+    ('Н', &['н']),
+    ('О', &['о', 'ᲂ']),
+    ('П', &['п']),
+    ('Р', &['р']),
+    ('С', &['с', 'ᲃ']),
+    ('Т', &['т', 'ᲄ', 'ᲅ']),
+    ('У', &['у']),
+    ('Ф', &['ф']),
+    ('Х', &['х']),
+    ('Ц', &['ц']),
+    ('Ч', &['ч']),
+    ('Ш', &['ш']),
+    ('Щ', &['щ']),
+    ('Ъ', &['ъ', 'ᲆ']),
+    ('Ы', &['ы']),
+    ('Ь', &['ь']),
+    ('Э', &['э']),
+    ('Ю', &['ю']),
+    ('Я', &['я']),
+    ('а', &['А']),
+    ('б', &['Б']),
+    ('в', &['В', 'ᲀ']),
+    ('г', &['Г']),
+    ('д', &['Д', 'ᲁ']),
+    ('е', &['Е']),
+    ('ж', &['Ж']),
+    ('з', &['З']),
+    ('и', &['И']),
+    ('й', &['Й']),
+    ('к', &['К']),
+    ('л', &['Л']),
+    ('м', &['М']),
+    ('н', &['Н']),
+    ('о', &['О', 'ᲂ']),
+    ('п', &['П']),
+    ('р', &['Р']),
+    ('с', &['С', 'ᲃ']),
+    ('т', &['Т', 'ᲄ', 'ᲅ']),
+    ('у', &['У']),
+    ('ф', &['Ф']),
+    ('х', &['Х']),
+    ('ц', &['Ц']),
+    ('ч', &['Ч']),
+    ('ш', &['Ш']),
+    ('щ', &['Щ']),
+    ('ъ', &['Ъ', 'ᲆ']),
+    ('ы', &['Ы']),
+    ('ь', &['Ь']),
+    ('э', &['Э']),
+    ('ю', &['Ю']),
+    ('я', &['Я']),
+    ('ѐ', &['Ѐ']),
+    ('ё', &['Ё']),
+    ('ђ', &['Ђ']),
+    ('ѓ', &['Ѓ']),
+    ('є', &['Є']),
+    ('ѕ', &['Ѕ']),
+    ('і', &['І']),
+    ('ї', &['Ї']),
+    ('ј', &['Ј']),
+    ('љ', &['Љ']),
+    ('њ', &['Њ']),
+    ('ћ', &['Ћ']),
+    ('ќ', &['Ќ']),
+    ('ѝ', &['Ѝ']),
+    ('ў', &['Ў']),
+    ('џ', &['Џ']),
+    ('Ѡ', &['ѡ']),
+    ('ѡ', &['Ѡ']),
+    ('Ѣ', &['ѣ', 'ᲇ']),
+    ('ѣ', &['Ѣ', 'ᲇ']),
+    ('Ѥ', &['ѥ']),
+    ('ѥ', &['Ѥ']),
+    ('Ѧ', &['ѧ']),
+    ('ѧ', &['Ѧ']),
+    ('Ѩ', &['ѩ']),
+    ('ѩ', &['Ѩ']),
+    ('Ѫ', &['ѫ']),
+    ('ѫ', &['Ѫ']),
+    ('Ѭ', &['ѭ']),
+    ('ѭ', &['Ѭ']),
+    ('Ѯ', &['ѯ']),
+    ('ѯ', &['Ѯ']),
+    ('Ѱ', &['ѱ']),
+    ('ѱ', &['Ѱ']),
+    ('Ѳ', &['ѳ']),
+    ('ѳ', &['Ѳ']),
+    ('Ѵ', &['ѵ']),
+    ('ѵ', &['Ѵ']),
+    ('Ѷ', &['ѷ']),
+    ('ѷ', &['Ѷ']),
+    ('Ѹ', &['ѹ']),
+    ('ѹ', &['Ѹ']),
+    ('Ѻ', &['ѻ']),
+    ('ѻ', &['Ѻ']),
+    ('Ѽ', &['ѽ']),
+    ('ѽ', &['Ѽ']),
+    ('Ѿ', &['ѿ']),
+    ('ѿ', &['Ѿ']),
+    ('Ҁ', &['ҁ']),
+    ('ҁ', &['Ҁ']),
+    ('Ҋ', &['ҋ']),
+    ('ҋ', &['Ҋ']),
+    ('Ҍ', &['ҍ']),
+    ('ҍ', &['Ҍ']),
+    ('Ҏ', &['ҏ']),
+    ('ҏ', &['Ҏ']),
+    ('Ґ', &['ґ']),
+    ('ґ', &['Ґ']),
+    ('Ғ', &['ғ']),
+    ('ғ', &['Ғ']),
+    ('Ҕ', &['ҕ']),
+    ('ҕ', &['Ҕ']),
+    ('Җ', &['җ']),
+    ('җ', &['Җ']),
+    ('Ҙ', &['ҙ']),
+    ('ҙ', &['Ҙ']),
+    ('Қ', &['қ']),
+    ('қ', &['Қ']),
+    ('Ҝ', &['ҝ']),
+    ('ҝ', &['Ҝ']),
+    ('Ҟ', &['ҟ']),
+    ('ҟ', &['Ҟ']),
+    ('Ҡ', &['ҡ']),
+    ('ҡ', &['Ҡ']),
+    ('Ң', &['ң']),
+    ('ң', &['Ң']),
+    ('Ҥ', &['ҥ']),
+    ('ҥ', &['Ҥ']),
+    ('Ҧ', &['ҧ']),
+    ('ҧ', &['Ҧ']),
+    ('Ҩ', &['ҩ']),
+    ('ҩ', &['Ҩ']),
+    ('Ҫ', &['ҫ']),
+    ('ҫ', &['Ҫ']),
+    ('Ҭ', &['ҭ']),
+    ('ҭ', &['Ҭ']),
+    ('Ү', &['ү']),
+    ('ү', &['Ү']),
+    ('Ұ', &['ұ']),
+    ('ұ', &['Ұ']),
+    ('Ҳ', &['ҳ']),
+    ('ҳ', &['Ҳ']),
+    ('Ҵ', &['ҵ']),
+    ('ҵ', &['Ҵ']),
+    ('Ҷ', &['ҷ']),
+    ('ҷ', &['Ҷ']),
+    ('Ҹ', &['ҹ']),
+    ('ҹ', &['Ҹ']),
+    ('Һ', &['һ']),
+    ('һ', &['Һ']),
+    ('Ҽ', &['ҽ']),
+    ('ҽ', &['Ҽ']),
+    ('Ҿ', &['ҿ']),
+    ('ҿ', &['Ҿ']),
+    ('Ӏ', &['ӏ']),
+    ('Ӂ', &['ӂ']),
+    ('ӂ', &['Ӂ']),
+    ('Ӄ', &['ӄ']),
+    ('ӄ', &['Ӄ']),
+    ('Ӆ', &['ӆ']),
+    ('ӆ', &['Ӆ']),
+    ('Ӈ', &['ӈ']),
+    ('ӈ', &['Ӈ']),
+    ('Ӊ', &['ӊ']),
+    ('ӊ', &['Ӊ']),
+    ('Ӌ', &['ӌ']),
+    ('ӌ', &['Ӌ']),
+    ('Ӎ', &['ӎ']),
+    ('ӎ', &['Ӎ']),
+    ('ӏ', &['Ӏ']),
+    ('Ӑ', &['ӑ']),
+    ('ӑ', &['Ӑ']),
+    ('Ӓ', &['ӓ']),
+    ('ӓ', &['Ӓ']),
+    ('Ӕ', &['ӕ']),
+    ('ӕ', &['Ӕ']),
+    ('Ӗ', &['ӗ']),
+    ('ӗ', &['Ӗ']),
+    ('Ә', &['ә']),
+    ('ә', &['Ә']),
+    ('Ӛ', &['ӛ']),
+    ('ӛ', &['Ӛ']),
+    ('Ӝ', &['ӝ']),
+    ('ӝ', &['Ӝ']),
+    ('Ӟ', &['ӟ']),
+    ('ӟ', &['Ӟ']),
+    ('Ӡ', &['ӡ']),
+    ('ӡ', &['Ӡ']),
+    ('Ӣ', &['ӣ']),
+    ('ӣ', &['Ӣ']),
+    ('Ӥ', &['ӥ']),
+    ('ӥ', &['Ӥ']),
+    ('Ӧ', &['ӧ']),
+    ('ӧ', &['Ӧ']),
+    ('Ө', &['ө']),
+    ('ө', &['Ө']),
+    ('Ӫ', &['ӫ']),
+    ('ӫ', &['Ӫ']),
+    ('Ӭ', &['ӭ']),
+    ('ӭ', &['Ӭ']),
+    ('Ӯ', &['ӯ']),
+    ('ӯ', &['Ӯ']),
+    ('Ӱ', &['ӱ']),
+    ('ӱ', &['Ӱ']),
+    ('Ӳ', &['ӳ']),
+    ('ӳ', &['Ӳ']),
+    ('Ӵ', &['ӵ']),
+    ('ӵ', &['Ӵ']),
+    ('Ӷ', &['ӷ']),
+    ('ӷ', &['Ӷ']),
+    ('Ӹ', &['ӹ']),
+    ('ӹ', &['Ӹ']),
+    ('Ӻ', &['ӻ']),
+    ('ӻ', &['Ӻ']),
+    ('Ӽ', &['ӽ']),
+    ('ӽ', &['Ӽ']),
+    ('Ӿ', &['ӿ']),
+    ('ӿ', &['Ӿ']),
+    ('Ԁ', &['ԁ']),
+    ('ԁ', &['Ԁ']),
+    ('Ԃ', &['ԃ']),
+    ('ԃ', &['Ԃ']),
+    ('Ԅ', &['ԅ']),
+    ('ԅ', &['Ԅ']),
+    ('Ԇ', &['ԇ']),
+    ('ԇ', &['Ԇ']),
+    ('Ԉ', &['ԉ']),
+    ('ԉ', &['Ԉ']),
+    ('Ԋ', &['ԋ']),
+    ('ԋ', &['Ԋ']),
+    ('Ԍ', &['ԍ']),
+    ('ԍ', &['Ԍ']),
+    ('Ԏ', &['ԏ']),
+    ('ԏ', &['Ԏ']),
+    ('Ԑ', &['ԑ']),
+    ('ԑ', &['Ԑ']),
+    ('Ԓ', &['ԓ']),
+    ('ԓ', &['Ԓ']),
+    ('Ԕ', &['ԕ']),
+    ('ԕ', &['Ԕ']),
+    ('Ԗ', &['ԗ']),
+    ('ԗ', &['Ԗ']),
+    ('Ԙ', &['ԙ']),
+    ('ԙ', &['Ԙ']),
+    ('Ԛ', &['ԛ']),
+    ('ԛ', &['Ԛ']),
+    ('Ԝ', &['ԝ']),
+    ('ԝ', &['Ԝ']),
+    ('Ԟ', &['ԟ']),
+    ('ԟ', &['Ԟ']),
+    ('Ԡ', &['ԡ']),
+    ('ԡ', &['Ԡ']),
+    ('Ԣ', &['ԣ']),
+    ('ԣ', &['Ԣ']),
+    ('Ԥ', &['ԥ']),
+    ('ԥ', &['Ԥ']),
+    ('Ԧ', &['ԧ']),
+    ('ԧ', &['Ԧ']),
+    ('Ԩ', &['ԩ']),
+    ('ԩ', &['Ԩ']),
+    ('Ԫ', &['ԫ']),
+    ('ԫ', &['Ԫ']),
+    ('Ԭ', &['ԭ']),
+    ('ԭ', &['Ԭ']),
+    ('Ԯ', &['ԯ']),
+    ('ԯ', &['Ԯ']),
+    ('Ա', &['ա']),
+    ('Բ', &['բ']),
+    ('Գ', &['գ']),
+    ('Դ', &['դ']),
+    ('Ե', &['ե']),
+    ('Զ', &['զ']),
+    ('Է', &['է']),
+    ('Ը', &['ը']),
+    ('Թ', &['թ']),
+    ('Ժ', &['ժ']),
+    ('Ի', &['ի']),
+    ('Լ', &['լ']),
+    ('Խ', &['խ']),
+    ('Ծ', &['ծ']),
+    ('Կ', &['կ']),
+    ('Հ', &['հ']),
+    ('Ձ', &['ձ']),
+    ('Ղ', &['ղ']),
+    ('Ճ', &['ճ']),
+    ('Մ', &['մ']),
+    ('Յ', &['յ']),
+    ('Ն', &['ն']),
+    ('Շ', &['շ']),
+    ('Ո', &['ո']),
+    ('Չ', &['չ']),
+    ('Պ', &['պ']),
+    ('Ջ', &['ջ']),
+    ('Ռ', &['ռ']),
+    ('Ս', &['ս']),
+    ('Վ', &['վ']),
+    ('Տ', &['տ']),
+    ('Ր', &['ր']),
+    ('Ց', &['ց']),
+    ('Ւ', &['ւ']),
+    ('Փ', &['փ']),
+    ('Ք', &['ք']),
+    ('Օ', &['օ']),
+    ('Ֆ', &['ֆ']),
+    ('ա', &['Ա']),
+    ('բ', &['Բ']),
+    ('գ', &['Գ']),
+    ('դ', &['Դ']),
+    ('ե', &['Ե']),
+    ('զ', &['Զ']),
+    ('է', &['Է']),
+    ('ը', &['Ը']),
+    ('թ', &['Թ']),
+    ('ժ', &['Ժ']),
+    ('ի', &['Ի']),
+    ('լ', &['Լ']),
+    ('խ', &['Խ']),
+    ('ծ', &['Ծ']),
+    ('կ', &['Կ']),
+    ('հ', &['Հ']),
+    ('ձ', &['Ձ']),
+    ('ղ', &['Ղ']),
+    ('ճ', &['Ճ']),
+    ('մ', &['Մ']),
+    ('յ', &['Յ']),
+    ('ն', &['Ն']),
+    ('շ', &['Շ']),
+    ('ո', &['Ո']),
+    ('չ', &['Չ']),
+    ('պ', &['Պ']),
+    ('ջ', &['Ջ']),
+    ('ռ', &['Ռ']),
+    ('ս', &['Ս']),
+    ('վ', &['Վ']),
+    ('տ', &['Տ']),
+    ('ր', &['Ր']),
+    ('ց', &['Ց']),
+    ('ւ', &['Ւ']),
+    ('փ', &['Փ']),
+    ('ք', &['Ք']),
+    ('օ', &['Օ']),
+    ('ֆ', &['Ֆ']),
+    ('Ⴀ', &['ⴀ']),
+    ('Ⴁ', &['ⴁ']),
+    ('Ⴂ', &['ⴂ']),
+    ('Ⴃ', &['ⴃ']),
+    ('Ⴄ', &['ⴄ']),
+    ('Ⴅ', &['ⴅ']),
+    ('Ⴆ', &['ⴆ']),
+    ('Ⴇ', &['ⴇ']),
+    ('Ⴈ', &['ⴈ']),
+    ('Ⴉ', &['ⴉ']),
+    ('Ⴊ', &['ⴊ']),
+    ('Ⴋ', &['ⴋ']),
+    ('Ⴌ', &['ⴌ']),
+    ('Ⴍ', &['ⴍ']),
+    ('Ⴎ', &['ⴎ']),
+    ('Ⴏ', &['ⴏ']),
+    ('Ⴐ', &['ⴐ']),
+    ('Ⴑ', &['ⴑ']),
+    ('Ⴒ', &['ⴒ']),
+    ('Ⴓ', &['ⴓ']),
+    ('Ⴔ', &['ⴔ']),
+    ('Ⴕ', &['ⴕ']),
+    ('Ⴖ', &['ⴖ']),
+    ('Ⴗ', &['ⴗ']),
+    ('Ⴘ', &['ⴘ']),
+    ('Ⴙ', &['ⴙ']),
+    ('Ⴚ', &['ⴚ']),
+    ('Ⴛ', &['ⴛ']),
+    ('Ⴜ', &['ⴜ']),
+    ('Ⴝ', &['ⴝ']),
+    ('Ⴞ', &['ⴞ']),
+    ('Ⴟ', &['ⴟ']),
+    ('Ⴠ', &['ⴠ']),
+    ('Ⴡ', &['ⴡ']),
+    ('Ⴢ', &['ⴢ']),
+    ('Ⴣ', &['ⴣ']),
+    ('Ⴤ', &['ⴤ']),
+    ('Ⴥ', &['ⴥ']),
+    ('Ⴧ', &['ⴧ']),
+    ('Ⴭ', &['ⴭ']),
+    ('ა', &['Ა']),
+    ('ბ', &['Ბ']),
+    ('გ', &['Გ']),
+    ('დ', &['Დ']),
+    ('ე', &['Ე']),
+    ('ვ', &['Ვ']),
+    ('ზ', &['Ზ']),
+    ('თ', &['Თ']),
+    ('ი', &['Ი']),
+    ('კ', &['Კ']),
+    ('ლ', &['Ლ']),
+    ('მ', &['Მ']),
+    ('ნ', &['Ნ']),
+    ('ო', &['Ო']),
+    ('პ', &['Პ']),
+    ('ჟ', &['Ჟ']),
+    ('რ', &['Რ']),
+    ('ს', &['Ს']),
+    ('ტ', &['Ტ']),
+    ('უ', &['Უ']),
+    ('ფ', &['Ფ']),
+    ('ქ', &['Ქ']),
+    ('ღ', &['Ღ']),
+    ('ყ', &['Ყ']),
+    ('შ', &['Შ']),
+    ('ჩ', &['Ჩ']),
+    ('ც', &['Ც']),
+    ('ძ', &['Ძ']),
+    ('წ', &['Წ']),
+    ('ჭ', &['Ჭ']),
+    ('ხ', &['Ხ']),
+    ('ჯ', &['Ჯ']),
+    ('ჰ', &['Ჰ']),
+    ('ჱ', &['Ჱ']),
+    ('ჲ', &['Ჲ']),
+    ('ჳ', &['Ჳ']),
+    ('ჴ', &['Ჴ']),
+    ('ჵ', &['Ჵ']),
+    ('ჶ', &['Ჶ']),
+    ('ჷ', &['Ჷ']),
+    ('ჸ', &['Ჸ']),
+    ('ჹ', &['Ჹ']),
+    ('ჺ', &['Ჺ']),
+    ('ჽ', &['Ჽ']),
+    ('ჾ', &['Ჾ']),
+    ('ჿ', &['Ჿ']),
+    ('Ꭰ', &['ꭰ']),
+    ('Ꭱ', &['ꭱ']),
+    ('Ꭲ', &['ꭲ']),
+    ('Ꭳ', &['ꭳ']),
+    ('Ꭴ', &['ꭴ']),
+    ('Ꭵ', &['ꭵ']),
+    ('Ꭶ', &['ꭶ']),
+    ('Ꭷ', &['ꭷ']),
+    ('Ꭸ', &['ꭸ']),
+    ('Ꭹ', &['ꭹ']),
+    ('Ꭺ', &['ꭺ']),
+    ('Ꭻ', &['ꭻ']),
+    ('Ꭼ', &['ꭼ']),
+    ('Ꭽ', &['ꭽ']),
+    ('Ꭾ', &['ꭾ']),
+    ('Ꭿ', &['ꭿ']),
+    ('Ꮀ', &['ꮀ']),
+    ('Ꮁ', &['ꮁ']),
+    ('Ꮂ', &['ꮂ']),
+    ('Ꮃ', &['ꮃ']),
+    ('Ꮄ', &['ꮄ']),
+    ('Ꮅ', &['ꮅ']),
+    ('Ꮆ', &['ꮆ']),
+    ('Ꮇ', &['ꮇ']),
+    ('Ꮈ', &['ꮈ']),
+    ('Ꮉ', &['ꮉ']),
+    ('Ꮊ', &['ꮊ']),
+    ('Ꮋ', &['ꮋ']),
+    ('Ꮌ', &['ꮌ']),
+    ('Ꮍ', &['ꮍ']),
+    ('Ꮎ', &['ꮎ']),
+    ('Ꮏ', &['ꮏ']),
+    ('Ꮐ', &['ꮐ']),
+    ('Ꮑ', &['ꮑ']),
+    ('Ꮒ', &['ꮒ']),
+    ('Ꮓ', &['ꮓ']),
+    ('Ꮔ', &['ꮔ']),
+    ('Ꮕ', &['ꮕ']),
+    ('Ꮖ', &['ꮖ']),
+    ('Ꮗ', &['ꮗ']),
+    ('Ꮘ', &['ꮘ']),
+    ('Ꮙ', &['ꮙ']),
+    ('Ꮚ', &['ꮚ']),
+    ('Ꮛ', &['ꮛ']),
+    ('Ꮜ', &['ꮜ']),
+    ('Ꮝ', &['ꮝ']),
+    ('Ꮞ', &['ꮞ']),
+    ('Ꮟ', &['ꮟ']),
+    ('Ꮠ', &['ꮠ']),
+    ('Ꮡ', &['ꮡ']),
+    ('Ꮢ', &['ꮢ']),
+    ('Ꮣ', &['ꮣ']),
+    ('Ꮤ', &['ꮤ']),
+    ('Ꮥ', &['ꮥ']),
+    ('Ꮦ', &['ꮦ']),
+    ('Ꮧ', &['ꮧ']),
+    ('Ꮨ', &['ꮨ']),
+    ('Ꮩ', &['ꮩ']),
+    ('Ꮪ', &['ꮪ']),
+    ('Ꮫ', &['ꮫ']),
+    ('Ꮬ', &['ꮬ']),
+    ('Ꮭ', &['ꮭ']),
+    ('Ꮮ', &['ꮮ']),
+    ('Ꮯ', &['ꮯ']),
+    ('Ꮰ', &['ꮰ']),
+    ('Ꮱ', &['ꮱ']),
+    ('Ꮲ', &['ꮲ']),
+    ('Ꮳ', &['ꮳ']),
+    ('Ꮴ', &['ꮴ']),
+    ('Ꮵ', &['ꮵ']),
+    ('Ꮶ', &['ꮶ']),
+    ('Ꮷ', &['ꮷ']),
+    ('Ꮸ', &['ꮸ']),
+    ('Ꮹ', &['ꮹ']),
+    ('Ꮺ', &['ꮺ']),
+    ('Ꮻ', &['ꮻ']),
+    ('Ꮼ', &['ꮼ']),
+    ('Ꮽ', &['ꮽ']),
+    ('Ꮾ', &['ꮾ']),
+    ('Ꮿ', &['ꮿ']),
+    ('Ᏸ', &['ᏸ']),
+    ('Ᏹ', &['ᏹ']),
+    ('Ᏺ', &['ᏺ']),
+    ('Ᏻ', &['ᏻ']),
+    ('Ᏼ', &['ᏼ']),
+    ('Ᏽ', &['ᏽ']),
+    ('ᏸ', &['Ᏸ']),
+    ('ᏹ', &['Ᏹ']),
+    ('ᏺ', &['Ᏺ']),
+    ('ᏻ', &['Ᏻ']),
+    ('ᏼ', &['Ᏼ']),
+    ('ᏽ', &['Ᏽ']),
+    ('ᲀ', &['В', 'в']),
+    ('ᲁ', &['Д', 'д']),
+    ('ᲂ', &['О', 'о']),
+    ('ᲃ', &['С', 'с']),
+    ('ᲄ', &['Т', 'т', 'ᲅ']),
+    ('ᲅ', &['Т', 'т', 'ᲄ']),
+    ('ᲆ', &['Ъ', 'ъ']),
+    ('ᲇ', &['Ѣ', 'ѣ']),
+    ('ᲈ', &['Ꙋ', 'ꙋ']),
+    ('Ა', &['ა']),
+    ('Ბ', &['ბ']),
+    ('Გ', &['გ']),
+    ('Დ', &['დ']),
+    ('Ე', &['ე']),
+    ('Ვ', &['ვ']),
+    ('Ზ', &['ზ']),
+    ('Თ', &['თ']),
+    ('Ი', &['ი']),
+    ('Კ', &['კ']),
+    ('Ლ', &['ლ']),
+    ('Მ', &['მ']),
+    ('Ნ', &['ნ']),
+    ('Ო', &['ო']),
+    ('Პ', &['პ']),
+    ('Ჟ', &['ჟ']),
+    ('Რ', &['რ']),
+    ('Ს', &['ს']),
+    ('Ტ', &['ტ']),
+    ('Უ', &['უ']),
+    ('Ფ', &['ფ']),
+    ('Ქ', &['ქ']),
+    ('Ღ', &['ღ']),
+    ('Ყ', &['ყ']),
+    ('Შ', &['შ']),
+    ('Ჩ', &['ჩ']),
+    ('Ც', &['ც']),
+    ('Ძ', &['ძ']),
+    ('Წ', &['წ']),
+    ('Ჭ', &['ჭ']),
+    ('Ხ', &['ხ']),
+    ('Ჯ', &['ჯ']),
+    ('Ჰ', &['ჰ']),
+    ('Ჱ', &['ჱ']),
+    ('Ჲ', &['ჲ']),
+    ('Ჳ', &['ჳ']),
+    ('Ჴ', &['ჴ']),
+    ('Ჵ', &['ჵ']),
+    ('Ჶ', &['ჶ']),
+    ('Ჷ', &['ჷ']),
+    ('Ჸ', &['ჸ']),
+    ('Ჹ', &['ჹ']),
+    ('Ჺ', &['ჺ']),
+    ('Ჽ', &['ჽ']),
+    ('Ჾ', &['ჾ']),
+    ('Ჿ', &['ჿ']),
+    ('ᵹ', &['Ᵹ']),
+    ('ᵽ', &['Ᵽ']),
+    ('ᶎ', &['Ᶎ']),
+    ('Ḁ', &['ḁ']),
+    ('ḁ', &['Ḁ']),
+    ('Ḃ', &['ḃ']),
+    ('ḃ', &['Ḃ']),
+    ('Ḅ', &['ḅ']),
+    ('ḅ', &['Ḅ']),
+    ('Ḇ', &['ḇ']),
+    ('ḇ', &['Ḇ']),
+    ('Ḉ', &['ḉ']),
+    ('ḉ', &['Ḉ']),
+    ('Ḋ', &['ḋ']),
+    ('ḋ', &['Ḋ']),
+    ('Ḍ', &['ḍ']),
+    ('ḍ', &['Ḍ']),
+    ('Ḏ', &['ḏ']),
+    ('ḏ', &['Ḏ']),
+    ('Ḑ', &['ḑ']),
+    ('ḑ', &['Ḑ']),
+    ('Ḓ', &['ḓ']),
+    ('ḓ', &['Ḓ']),
+    ('Ḕ', &['ḕ']),
+    ('ḕ', &['Ḕ']),
+    ('Ḗ', &['ḗ']),
+    ('ḗ', &['Ḗ']),
+    ('Ḙ', &['ḙ']),
+    ('ḙ', &['Ḙ']),
+    ('Ḛ', &['ḛ']),
+    ('ḛ', &['Ḛ']),
+    ('Ḝ', &['ḝ']),
+    ('ḝ', &['Ḝ']),
+    ('Ḟ', &['ḟ']),
+    ('ḟ', &['Ḟ']),
+    ('Ḡ', &['ḡ']),
+    ('ḡ', &['Ḡ']),
+    ('Ḣ', &['ḣ']),
+    ('ḣ', &['Ḣ']),
+    ('Ḥ', &['ḥ']),
+    ('ḥ', &['Ḥ']),
+    ('Ḧ', &['ḧ']),
+    ('ḧ', &['Ḧ']),
+    ('Ḩ', &['ḩ']),
+    ('ḩ', &['Ḩ']),
+    ('Ḫ', &['ḫ']),
+    ('ḫ', &['Ḫ']),
+    ('Ḭ', &['ḭ']),
+    ('ḭ', &['Ḭ']),
+    ('Ḯ', &['ḯ']),
+    ('ḯ', &['Ḯ']),
+    ('Ḱ', &['ḱ']),
+    ('ḱ', &['Ḱ']),
+    ('Ḳ', &['ḳ']),
+    ('ḳ', &['Ḳ']),
+    ('Ḵ', &['ḵ']),
+    ('ḵ', &['Ḵ']),
+    ('Ḷ', &['ḷ']),
+    ('ḷ', &['Ḷ']),
+    ('Ḹ', &['ḹ']),
+    ('ḹ', &['Ḹ']),
+    ('Ḻ', &['ḻ']),
+    ('ḻ', &['Ḻ']),
+    ('Ḽ', &['ḽ']),
+    ('ḽ', &['Ḽ']),
+    ('Ḿ', &['ḿ']),
+    ('ḿ', &['Ḿ']),
+    ('Ṁ', &['ṁ']),
+    ('ṁ', &['Ṁ']),
+    ('Ṃ', &['ṃ']),
+    ('ṃ', &['Ṃ']),
+    ('Ṅ', &['ṅ']),
+    ('ṅ', &['Ṅ']),
+    ('Ṇ', &['ṇ']),
+    ('ṇ', &['Ṇ']),
+    ('Ṉ', &['ṉ']),
+    ('ṉ', &['Ṉ']),
+    ('Ṋ', &['ṋ']),
+    ('ṋ', &['Ṋ']),
+    ('Ṍ', &['ṍ']),
+    ('ṍ', &['Ṍ']),
+    ('Ṏ', &['ṏ']),
+    ('ṏ', &['Ṏ']),
+    ('Ṑ', &['ṑ']),
+    ('ṑ', &['Ṑ']),
+    ('Ṓ', &['ṓ']),
+    ('ṓ', &['Ṓ']),
+    ('Ṕ', &['ṕ']),
+    ('ṕ', &['Ṕ']),
+    ('Ṗ', &['ṗ']),
+    ('ṗ', &['Ṗ']),
+    ('Ṙ', &['ṙ']),
+    ('ṙ', &['Ṙ']),
+    ('Ṛ', &['ṛ']),
+    ('ṛ', &['Ṛ']),
+    ('Ṝ', &['ṝ']),
+    ('ṝ', &['Ṝ']),
+    ('Ṟ', &['ṟ']),
+    ('ṟ', &['Ṟ']),
+    ('Ṡ', &['ṡ', 'ẛ']),
+    ('ṡ', &['Ṡ', 'ẛ']),
+    ('Ṣ', &['ṣ']),
+    ('ṣ', &['Ṣ']),
+    ('Ṥ', &['ṥ']),
+    ('ṥ', &['Ṥ']),
+    ('Ṧ', &['ṧ']),
+    ('ṧ', &['Ṧ']),
+    ('Ṩ', &['ṩ']),
+    ('ṩ', &['Ṩ']),
+    ('Ṫ', &['ṫ']),
+    ('ṫ', &['Ṫ']),
+    ('Ṭ', &['ṭ']),
+    ('ṭ', &['Ṭ']),
+    ('Ṯ', &['ṯ']),
+    ('ṯ', &['Ṯ']),
+    ('Ṱ', &['ṱ']),
+    ('ṱ', &['Ṱ']),
+    ('Ṳ', &['ṳ']),
+    ('ṳ', &['Ṳ']),
+    ('Ṵ', &['ṵ']),
+    ('ṵ', &['Ṵ']),
+    ('Ṷ', &['ṷ']),
+    ('ṷ', &['Ṷ']),
+    ('Ṹ', &['ṹ']),
+    ('ṹ', &['Ṹ']),
+    ('Ṻ', &['ṻ']),
+    ('ṻ', &['Ṻ']),
+    ('Ṽ', &['ṽ']),
+    ('ṽ', &['Ṽ']),
+    ('Ṿ', &['ṿ']),
+    ('ṿ', &['Ṿ']),
+    ('Ẁ', &['ẁ']),
+    ('ẁ', &['Ẁ']),
+    ('Ẃ', &['ẃ']),
+    ('ẃ', &['Ẃ']),
+    ('Ẅ', &['ẅ']),
+    ('ẅ', &['Ẅ']),
+    ('Ẇ', &['ẇ']),
+    ('ẇ', &['Ẇ']),
+    ('Ẉ', &['ẉ']),
+    ('ẉ', &['Ẉ']),
+    ('Ẋ', &['ẋ']),
+    ('ẋ', &['Ẋ']),
+    ('Ẍ', &['ẍ']),
+    ('ẍ', &['Ẍ']),
+    ('Ẏ', &['ẏ']),
+    ('ẏ', &['Ẏ']),
+    ('Ẑ', &['ẑ']),
+    ('ẑ', &['Ẑ']),
+    ('Ẓ', &['ẓ']),
+    ('ẓ', &['Ẓ']),
+    ('Ẕ', &['ẕ']),
+    ('ẕ', &['Ẕ']),
+    ('ẛ', &['Ṡ', 'ṡ']),
+    ('ẞ', &['ß']),
+    ('Ạ', &['ạ']),
+    ('ạ', &['Ạ']),
+    ('Ả', &['ả']),
+    ('ả', &['Ả']),
+    ('Ấ', &['ấ']),
+    ('ấ', &['Ấ']),
+    ('Ầ', &['ầ']),
+    ('ầ', &['Ầ']),
+    ('Ẩ', &['ẩ']),
+    ('ẩ', &['Ẩ']),
+    ('Ẫ', &['ẫ']),
+    ('ẫ', &['Ẫ']),
+    ('Ậ', &['ậ']),
+    ('ậ', &['Ậ']),
+    ('Ắ', &['ắ']),
+    ('ắ', &['Ắ']),
+    ('Ằ', &['ằ']),
+    ('ằ', &['Ằ']),
+    ('Ẳ', &['ẳ']),
+    ('ẳ', &['Ẳ']),
+    ('Ẵ', &['ẵ']),
+    ('ẵ', &['Ẵ']),
+    ('Ặ', &['ặ']),
+    ('ặ', &['Ặ']),
+    ('Ẹ', &['ẹ']),
+    ('ẹ', &['Ẹ']),
+    ('Ẻ', &['ẻ']),
+    ('ẻ', &['Ẻ']),
+    ('Ẽ', &['ẽ']),
+    ('ẽ', &['Ẽ']),
+    ('Ế', &['ế']),
+    ('ế', &['Ế']),
+    ('Ề', &['ề']),
+    ('ề', &['Ề']),
+    ('Ể', &['ể']),
+    ('ể', &['Ể']),
+    ('Ễ', &['ễ']),
+    ('ễ', &['Ễ']),
+    ('Ệ', &['ệ']),
+    ('ệ', &['Ệ']),
+    ('Ỉ', &['ỉ']),
+    ('ỉ', &['Ỉ']),
+    ('Ị', &['ị']),
+    ('ị', &['Ị']),
+    ('Ọ', &['ọ']),
+    ('ọ', &['Ọ']),
+    ('Ỏ', &['ỏ']),
+    ('ỏ', &['Ỏ']),
+    ('Ố', &['ố']),
+    ('ố', &['Ố']),
+    ('Ồ', &['ồ']),
+    ('ồ', &['Ồ']),
+    ('Ổ', &['ổ']),
+    ('ổ', &['Ổ']),
+    ('Ỗ', &['ỗ']),
+    ('ỗ', &['Ỗ']),
+    ('Ộ', &['ộ']),
+    ('ộ', &['Ộ']),
+    ('Ớ', &['ớ']),
+    ('ớ', &['Ớ']),
+    ('Ờ', &['ờ']),
+    ('ờ', &['Ờ']),
+    ('Ở', &['ở']),
+    ('ở', &['Ở']),
+    ('Ỡ', &['ỡ']),
+    ('ỡ', &['Ỡ']),
+    ('Ợ', &['ợ']),
+    ('ợ', &['Ợ']),
+    ('Ụ', &['ụ']),
+    ('ụ', &['Ụ']),
+    ('Ủ', &['ủ']),
+    ('ủ', &['Ủ']),
+    ('Ứ', &['ứ']),
+    ('ứ', &['Ứ']),
+    ('Ừ', &['ừ']),
+    ('ừ', &['Ừ']),
+    ('Ử', &['ử']),
+    ('ử', &['Ử']),
+    ('Ữ', &['ữ']),
+    ('ữ', &['Ữ']),
+    ('Ự', &['ự']),
+    ('ự', &['Ự']),
+    ('Ỳ', &['ỳ']),
+    ('ỳ', &['Ỳ']),
+    ('Ỵ', &['ỵ']),
+    ('ỵ', &['Ỵ']),
+    ('Ỷ', &['ỷ']),
+    ('ỷ', &['Ỷ']),
+    ('Ỹ', &['ỹ']),
+    ('ỹ', &['Ỹ']),
+    ('Ỻ', &['ỻ']),
+    ('ỻ', &['Ỻ']),
+    ('Ỽ', &['ỽ']),
+    ('ỽ', &['Ỽ']),
+    ('Ỿ', &['ỿ']),
+    ('ỿ', &['Ỿ']),
+    ('ἀ', &['Ἀ']),
+    ('ἁ', &['Ἁ']),
+    ('ἂ', &['Ἂ']),
+    ('ἃ', &['Ἃ']),
+    ('ἄ', &['Ἄ']),
+    ('ἅ', &['Ἅ']),
+    ('ἆ', &['Ἆ']),
+    ('ἇ', &['Ἇ']),
+    ('Ἀ', &['ἀ']),
+    ('Ἁ', &['ἁ']),
+    ('Ἂ', &['ἂ']),
+    ('Ἃ', &['ἃ']),
+    ('Ἄ', &['ἄ']),
+    ('Ἅ', &['ἅ']),
+    ('Ἆ', &['ἆ']),
+    ('Ἇ', &['ἇ']),
+    ('ἐ', &['Ἐ']),
+    ('ἑ', &['Ἑ']),
+    ('ἒ', &['Ἒ']),
+    ('ἓ', &['Ἓ']),
+    ('ἔ', &['Ἔ']),
+    ('ἕ', &['Ἕ']),
+    ('Ἐ', &['ἐ']),
+    ('Ἑ', &['ἑ']),
+    ('Ἒ', &['ἒ']),
+    ('Ἓ', &['ἓ']),
+    ('Ἔ', &['ἔ']),
+    ('Ἕ', &['ἕ']),
+    ('ἠ', &['Ἠ']),
+    ('ἡ', &['Ἡ']),
+    ('ἢ', &['Ἢ']),
+    ('ἣ', &['Ἣ']),
+    ('ἤ', &['Ἤ']),
+    ('ἥ', &['Ἥ']),
+    ('ἦ', &['Ἦ']),
+    ('ἧ', &['Ἧ']),
+    ('Ἠ', &['ἠ']),
+    ('Ἡ', &['ἡ']),
+    ('Ἢ', &['ἢ']),
+    ('Ἣ', &['ἣ']),
+    ('Ἤ', &['ἤ']),
+    ('Ἥ', &['ἥ']),
+    ('Ἦ', &['ἦ']),
+    ('Ἧ', &['ἧ']),
+    ('ἰ', &['Ἰ']),
+    ('ἱ', &['Ἱ']),
+    ('ἲ', &['Ἲ']),
+    ('ἳ', &['Ἳ']),
+    ('ἴ', &['Ἴ']),
+    ('ἵ', &['Ἵ']),
+    ('ἶ', &['Ἶ']),
+    ('ἷ', &['Ἷ']),
+    ('Ἰ', &['ἰ']),
+    ('Ἱ', &['ἱ']),
+    ('Ἲ', &['ἲ']),
+    ('Ἳ', &['ἳ']),
+    ('Ἴ', &['ἴ']),
+    ('Ἵ', &['ἵ']),
+    ('Ἶ', &['ἶ']),
+    ('Ἷ', &['ἷ']),
+    ('ὀ', &['Ὀ']),
+    ('ὁ', &['Ὁ']),
+    ('ὂ', &['Ὂ']),
+    ('ὃ', &['Ὃ']),
+    ('ὄ', &['Ὄ']),
+    ('ὅ', &['Ὅ']),
+    ('Ὀ', &['ὀ']),
+    ('Ὁ', &['ὁ']),
+    ('Ὂ', &['ὂ']),
+    ('Ὃ', &['ὃ']),
+    ('Ὄ', &['ὄ']),
+    ('Ὅ', &['ὅ']),
+    ('ὑ', &['Ὑ']),
+    ('ὓ', &['Ὓ']),
+    ('ὕ', &['Ὕ']),
+    ('ὗ', &['Ὗ']),
+    ('Ὑ', &['ὑ']),
+    ('Ὓ', &['ὓ']),
+    ('Ὕ', &['ὕ']),
+    ('Ὗ', &['ὗ']),
+    ('ὠ', &['Ὠ']),
+    ('ὡ', &['Ὡ']),
+    ('ὢ', &['Ὢ']),
+    ('ὣ', &['Ὣ']),
+    ('ὤ', &['Ὤ']),
+    ('ὥ', &['Ὥ']),
+    ('ὦ', &['Ὦ']),
+    ('ὧ', &['Ὧ']),
+    ('Ὠ', &['ὠ']),
+    ('Ὡ', &['ὡ']),
+    ('Ὢ', &['ὢ']),
+    ('Ὣ', &['ὣ']),
+    ('Ὤ', &['ὤ']),
+    ('Ὥ', &['ὥ']),
+    ('Ὦ', &['ὦ']),
+    ('Ὧ', &['ὧ']),
+    ('ὰ', &['Ὰ']),
+    ('ά', &['Ά']),
+    ('ὲ', &['Ὲ']),
+    ('έ', &['Έ']),
+    ('ὴ', &['Ὴ']),
+    ('ή', &['Ή']),
+    ('ὶ', &['Ὶ']),
+    ('ί', &['Ί']),
+    ('ὸ', &['Ὸ']),
+    ('ό', &['Ό']),
+    ('ὺ', &['Ὺ']),
+    ('ύ', &['Ύ']),
+    ('ὼ', &['Ὼ']),
+    ('ώ', &['Ώ']),
+    ('ᾀ', &['ᾈ']),
+    ('ᾁ', &['ᾉ']),
+    ('ᾂ', &['ᾊ']),
+    ('ᾃ', &['ᾋ']),
+    ('ᾄ', &['ᾌ']),
+    ('ᾅ', &['ᾍ']),
+    ('ᾆ', &['ᾎ']),
+    ('ᾇ', &['ᾏ']),
+    ('ᾈ', &['ᾀ']),
+    ('ᾉ', &['ᾁ']),
+    ('ᾊ', &['ᾂ']),
+    ('ᾋ', &['ᾃ']),
+    ('ᾌ', &['ᾄ']),
+    ('ᾍ', &['ᾅ']),
+    ('ᾎ', &['ᾆ']),
+    ('ᾏ', &['ᾇ']),
+    ('ᾐ', &['ᾘ']),
+    ('ᾑ', &['ᾙ']),
+    ('ᾒ', &['ᾚ']),
+    ('ᾓ', &['ᾛ']),
+    ('ᾔ', &['ᾜ']),
+    ('ᾕ', &['ᾝ']),
+    ('ᾖ', &['ᾞ']),
+    ('ᾗ', &['ᾟ']),
+    ('ᾘ', &['ᾐ']),
+    ('ᾙ', &['ᾑ']),
+    ('ᾚ', &['ᾒ']),
+    ('ᾛ', &['ᾓ']),
+    ('ᾜ', &['ᾔ']),
+    ('ᾝ', &['ᾕ']),
+    ('ᾞ', &['ᾖ']),
+    ('ᾟ', &['ᾗ']),
+    ('ᾠ', &['ᾨ']),
+    ('ᾡ', &['ᾩ']),
+    ('ᾢ', &['ᾪ']),
+    ('ᾣ', &['ᾫ']),
+    ('ᾤ', &['ᾬ']),
+    ('ᾥ', &['ᾭ']),
+    ('ᾦ', &['ᾮ']),
+    ('ᾧ', &['ᾯ']),
+    ('ᾨ', &['ᾠ']),
+    ('ᾩ', &['ᾡ']),
+    ('ᾪ', &['ᾢ']),
+    ('ᾫ', &['ᾣ']),
+    ('ᾬ', &['ᾤ']),
+    ('ᾭ', &['ᾥ']),
+    ('ᾮ', &['ᾦ']),
+    ('ᾯ', &['ᾧ']),
+    ('ᾰ', &['Ᾰ']),
+    ('ᾱ', &['Ᾱ']),
+    ('ᾳ', &['ᾼ']),
+    ('Ᾰ', &['ᾰ']),
+    ('Ᾱ', &['ᾱ']),
+    ('Ὰ', &['ὰ']),
+    ('Ά', &['ά']),
+    ('ᾼ', &['ᾳ']),
+    ('ι', &['\u{345}', 'Ι', 'ι']),
+    ('ῃ', &['ῌ']),
+    ('Ὲ', &['ὲ']),
+    ('Έ', &['έ']),
+    ('Ὴ', &['ὴ']),
+    ('Ή', &['ή']),
+    ('ῌ', &['ῃ']),
+    ('ῐ', &['Ῐ']),
+    ('ῑ', &['Ῑ']),
+    ('Ῐ', &['ῐ']),
+    ('Ῑ', &['ῑ']),
+    ('Ὶ', &['ὶ']),
+    ('Ί', &['ί']),
+    ('ῠ', &['Ῠ']),
+    ('ῡ', &['Ῡ']),
+    ('ῥ', &['Ῥ']),
+    ('Ῠ', &['ῠ']),
+    ('Ῡ', &['ῡ']),
+    ('Ὺ', &['ὺ']),
+    ('Ύ', &['ύ']),
+    ('Ῥ', &['ῥ']),
+    ('ῳ', &['ῼ']),
+    ('Ὸ', &['ὸ']),
+    ('Ό', &['ό']),
+    ('Ὼ', &['ὼ']),
+    ('Ώ', &['ώ']),
+    ('ῼ', &['ῳ']),
+    ('Ω', &['Ω', 'ω']),
+    ('K', &['K', 'k']),
+    ('Å', &['Å', 'å']),
+    ('Ⅎ', &['ⅎ']),
+    ('ⅎ', &['Ⅎ']),
+    ('Ⅰ', &['ⅰ']),
+    ('Ⅱ', &['ⅱ']),
+    ('Ⅲ', &['ⅲ']),
+    ('Ⅳ', &['ⅳ']),
+    ('Ⅴ', &['ⅴ']),
+    ('Ⅵ', &['ⅵ']),
+    ('Ⅶ', &['ⅶ']),
+    ('Ⅷ', &['ⅷ']),
+    ('Ⅸ', &['ⅸ']),
+    ('Ⅹ', &['ⅹ']),
+    ('Ⅺ', &['ⅺ']),
+    ('Ⅻ', &['ⅻ']),
+    ('Ⅼ', &['ⅼ']),
+    ('Ⅽ', &['ⅽ']),
+    ('Ⅾ', &['ⅾ']),
+    ('Ⅿ', &['ⅿ']),
+    ('ⅰ', &['Ⅰ']),
+    ('ⅱ', &['Ⅱ']),
+    ('ⅲ', &['Ⅲ']),
+    ('ⅳ', &['Ⅳ']),
+    ('ⅴ', &['Ⅴ']),
+    ('ⅵ', &['Ⅵ']),
+    ('ⅶ', &['Ⅶ']),
+    ('ⅷ', &['Ⅷ']),
+    ('ⅸ', &['Ⅸ']),
+    ('ⅹ', &['Ⅹ']),
+    ('ⅺ', &['Ⅺ']),
+    ('ⅻ', &['Ⅻ']),
+    ('ⅼ', &['Ⅼ']),
+    ('ⅽ', &['Ⅽ']),
+    ('ⅾ', &['Ⅾ']),
+    ('ⅿ', &['Ⅿ']),
+    ('Ↄ', &['ↄ']),
+    ('ↄ', &['Ↄ']),
+    ('Ⓐ', &['ⓐ']),
+    ('Ⓑ', &['ⓑ']),
+    ('Ⓒ', &['ⓒ']),
+    ('Ⓓ', &['ⓓ']),
+    ('Ⓔ', &['ⓔ']),
+    ('Ⓕ', &['ⓕ']),
+    ('Ⓖ', &['ⓖ']),
+    ('Ⓗ', &['ⓗ']),
+    ('Ⓘ', &['ⓘ']),
+    ('Ⓙ', &['ⓙ']),
+    ('Ⓚ', &['ⓚ']),
+    ('Ⓛ', &['ⓛ']),
+    ('Ⓜ', &['ⓜ']),
+    ('Ⓝ', &['ⓝ']),
+    ('Ⓞ', &['ⓞ']),
+    ('Ⓟ', &['ⓟ']),
+    ('Ⓠ', &['ⓠ']),
+    ('Ⓡ', &['ⓡ']),
+    ('Ⓢ', &['ⓢ']),
+    ('Ⓣ', &['ⓣ']),
+    ('Ⓤ', &['ⓤ']),
+    ('Ⓥ', &['ⓥ']),
+    ('Ⓦ', &['ⓦ']),
+    ('Ⓧ', &['ⓧ']),
+    ('Ⓨ', &['ⓨ']),
+    ('Ⓩ', &['ⓩ']),
+    ('ⓐ', &['Ⓐ']),
+    ('ⓑ', &['Ⓑ']),
+    ('ⓒ', &['Ⓒ']),
+    ('ⓓ', &['Ⓓ']),
+    ('ⓔ', &['Ⓔ']),
+    ('ⓕ', &['Ⓕ']),
+    ('ⓖ', &['Ⓖ']),
+    ('ⓗ', &['Ⓗ']),
+    ('ⓘ', &['Ⓘ']),
+    ('ⓙ', &['Ⓙ']),
+    ('ⓚ', &['Ⓚ']),
+    ('ⓛ', &['Ⓛ']),
+    ('ⓜ', &['Ⓜ']),
+    ('ⓝ', &['Ⓝ']),
+    ('ⓞ', &['Ⓞ']),
+    ('ⓟ', &['Ⓟ']),
+    ('ⓠ', &['Ⓠ']),
+    ('ⓡ', &['Ⓡ']),
+    ('ⓢ', &['Ⓢ']),
+    ('ⓣ', &['Ⓣ']),
+    ('ⓤ', &['Ⓤ']),
+    ('ⓥ', &['Ⓥ']),
+    ('ⓦ', &['Ⓦ']),
+    ('ⓧ', &['Ⓧ']),
+    ('ⓨ', &['Ⓨ']),
+    ('ⓩ', &['Ⓩ']),
+    ('Ⰰ', &['ⰰ']),
+    ('Ⰱ', &['ⰱ']),
+    ('Ⰲ', &['ⰲ']),
+    ('Ⰳ', &['ⰳ']),
+    ('Ⰴ', &['ⰴ']),
+    ('Ⰵ', &['ⰵ']),
+    ('Ⰶ', &['ⰶ']),
+    ('Ⰷ', &['ⰷ']),
+    ('Ⰸ', &['ⰸ']),
+    ('Ⰹ', &['ⰹ']),
+    ('Ⰺ', &['ⰺ']),
+    ('Ⰻ', &['ⰻ']),
+    ('Ⰼ', &['ⰼ']),
+    ('Ⰽ', &['ⰽ']),
+    ('Ⰾ', &['ⰾ']),
+    ('Ⰿ', &['ⰿ']),
+    ('Ⱀ', &['ⱀ']),
+    ('Ⱁ', &['ⱁ']),
+    ('Ⱂ', &['ⱂ']),
+    ('Ⱃ', &['ⱃ']),
+    ('Ⱄ', &['ⱄ']),
+    ('Ⱅ', &['ⱅ']),
+    ('Ⱆ', &['ⱆ']),
+    ('Ⱇ', &['ⱇ']),
+    ('Ⱈ', &['ⱈ']),
+    ('Ⱉ', &['ⱉ']),
+    ('Ⱊ', &['ⱊ']),
+    ('Ⱋ', &['ⱋ']),
+    ('Ⱌ', &['ⱌ']),
+    ('Ⱍ', &['ⱍ']),
+    ('Ⱎ', &['ⱎ']),
+    ('Ⱏ', &['ⱏ']),
+    ('Ⱐ', &['ⱐ']),
+    ('Ⱑ', &['ⱑ']),
+    ('Ⱒ', &['ⱒ']),
+    ('Ⱓ', &['ⱓ']),
+    ('Ⱔ', &['ⱔ']),
+    ('Ⱕ', &['ⱕ']),
+    ('Ⱖ', &['ⱖ']),
+    ('Ⱗ', &['ⱗ']),
+    ('Ⱘ', &['ⱘ']),
+    ('Ⱙ', &['ⱙ']),
+    ('Ⱚ', &['ⱚ']),
+    ('Ⱛ', &['ⱛ']),
+    ('Ⱜ', &['ⱜ']),
+    ('Ⱝ', &['ⱝ']),
+    ('Ⱞ', &['ⱞ']),
+    ('Ⱟ', &['ⱟ']),
+    ('ⰰ', &['Ⰰ']),
+    ('ⰱ', &['Ⰱ']),
+    ('ⰲ', &['Ⰲ']),
+    ('ⰳ', &['Ⰳ']),
+    ('ⰴ', &['Ⰴ']),
+    ('ⰵ', &['Ⰵ']),
+    ('ⰶ', &['Ⰶ']),
+    ('ⰷ', &['Ⰷ']),
+    ('ⰸ', &['Ⰸ']),
+    ('ⰹ', &['Ⰹ']),
+    ('ⰺ', &['Ⰺ']),
+    ('ⰻ', &['Ⰻ']),
+    ('ⰼ', &['Ⰼ']),
+    ('ⰽ', &['Ⰽ']),
+    ('ⰾ', &['Ⰾ']),
+    ('ⰿ', &['Ⰿ']),
+    ('ⱀ', &['Ⱀ']),
+    ('ⱁ', &['Ⱁ']),
+    ('ⱂ', &['Ⱂ']),
+    ('ⱃ', &['Ⱃ']),
+    ('ⱄ', &['Ⱄ']),
+    ('ⱅ', &['Ⱅ']),
+    ('ⱆ', &['Ⱆ']),
+    ('ⱇ', &['Ⱇ']),
+    ('ⱈ', &['Ⱈ']),
+    ('ⱉ', &['Ⱉ']),
+    ('ⱊ', &['Ⱊ']),
+    ('ⱋ', &['Ⱋ']),
+    ('ⱌ', &['Ⱌ']),
+    ('ⱍ', &['Ⱍ']),
+    ('ⱎ', &['Ⱎ']),
+    ('ⱏ', &['Ⱏ']),
+    ('ⱐ', &['Ⱐ']),
+    ('ⱑ', &['Ⱑ']),
+    ('ⱒ', &['Ⱒ']),
+    ('ⱓ', &['Ⱓ']),
+    ('ⱔ', &['Ⱔ']),
+    ('ⱕ', &['Ⱕ']),
+    ('ⱖ', &['Ⱖ']),
+    ('ⱗ', &['Ⱗ']),
+    ('ⱘ', &['Ⱘ']),
+    ('ⱙ', &['Ⱙ']),
+    ('ⱚ', &['Ⱚ']),
+    ('ⱛ', &['Ⱛ']),
+    ('ⱜ', &['Ⱜ']),
+    ('ⱝ', &['Ⱝ']),
+    ('ⱞ', &['Ⱞ']),
+    ('ⱟ', &['Ⱟ']),
+    ('Ⱡ', &['ⱡ']),
+    ('ⱡ', &['Ⱡ']),
+    ('Ɫ', &['ɫ']),
+    ('Ᵽ', &['ᵽ']),
+    ('Ɽ', &['ɽ']),
+    ('ⱥ', &['Ⱥ']),
+    ('ⱦ', &['Ⱦ']),
+    ('Ⱨ', &['ⱨ']),
+    ('ⱨ', &['Ⱨ']),
+    ('Ⱪ', &['ⱪ']),
+    ('ⱪ', &['Ⱪ']),
+    ('Ⱬ', &['ⱬ']),
+    ('ⱬ', &['Ⱬ']),
+    ('Ɑ', &['ɑ']),
+    ('Ɱ', &['ɱ']),
+    ('Ɐ', &['ɐ']),
+    ('Ɒ', &['ɒ']),
+    ('Ⱳ', &['ⱳ']),
+    ('ⱳ', &['Ⱳ']),
+    ('Ⱶ', &['ⱶ']),
+    ('ⱶ', &['Ⱶ']),
+    ('Ȿ', &['ȿ']),
+    ('Ɀ', &['ɀ']),
+    ('Ⲁ', &['ⲁ']),
+    ('ⲁ', &['Ⲁ']),
+    ('Ⲃ', &['ⲃ']),
+    ('ⲃ', &['Ⲃ']),
+    ('Ⲅ', &['ⲅ']),
+    ('ⲅ', &['Ⲅ']),
+    ('Ⲇ', &['ⲇ']),
+    ('ⲇ', &['Ⲇ']),
+    ('Ⲉ', &['ⲉ']),
+    ('ⲉ', &['Ⲉ']),
+    ('Ⲋ', &['ⲋ']),
+    ('ⲋ', &['Ⲋ']),
+    ('Ⲍ', &['ⲍ']),
+    ('ⲍ', &['Ⲍ']),
+    ('Ⲏ', &['ⲏ']),
+    ('ⲏ', &['Ⲏ']),
+    ('Ⲑ', &['ⲑ']),
+    ('ⲑ', &['Ⲑ']),
+    ('Ⲓ', &['ⲓ']),
+    ('ⲓ', &['Ⲓ']),
+    ('Ⲕ', &['ⲕ']),
+    ('ⲕ', &['Ⲕ']),
+    ('Ⲗ', &['ⲗ']),
+    ('ⲗ', &['Ⲗ']),
+    ('Ⲙ', &['ⲙ']),
+    ('ⲙ', &['Ⲙ']),
+    ('Ⲛ', &['ⲛ']),
+    ('ⲛ', &['Ⲛ']),
+    ('Ⲝ', &['ⲝ']),
+    ('ⲝ', &['Ⲝ']),
+    ('Ⲟ', &['ⲟ']),
+    ('ⲟ', &['Ⲟ']),
+    ('Ⲡ', &['ⲡ']),
+    ('ⲡ', &['Ⲡ']),
+    ('Ⲣ', &['ⲣ']),
+    ('ⲣ', &['Ⲣ']),
+    ('Ⲥ', &['ⲥ']),
+    ('ⲥ', &['Ⲥ']),
+    ('Ⲧ', &['ⲧ']),
+    ('ⲧ', &['Ⲧ']),
+    ('Ⲩ', &['ⲩ']),
+    ('ⲩ', &['Ⲩ']),
+    ('Ⲫ', &['ⲫ']),
+    ('ⲫ', &['Ⲫ']),
+    ('Ⲭ', &['ⲭ']),
+    ('ⲭ', &['Ⲭ']),
+    ('Ⲯ', &['ⲯ']),
+    ('ⲯ', &['Ⲯ']),
+    ('Ⲱ', &['ⲱ']),
+    ('ⲱ', &['Ⲱ']),
+    ('Ⲳ', &['ⲳ']),
+    ('ⲳ', &['Ⲳ']),
+    ('Ⲵ', &['ⲵ']),
+    ('ⲵ', &['Ⲵ']),
+    ('Ⲷ', &['ⲷ']),
+    ('ⲷ', &['Ⲷ']),
+    ('Ⲹ', &['ⲹ']),
+    ('ⲹ', &['Ⲹ']),
+    ('Ⲻ', &['ⲻ']),
+    ('ⲻ', &['Ⲻ']),
+    ('Ⲽ', &['ⲽ']),
+    ('ⲽ', &['Ⲽ']),
+    ('Ⲿ', &['ⲿ']),
+    ('ⲿ', &['Ⲿ']),
+    ('Ⳁ', &['ⳁ']),
+    ('ⳁ', &['Ⳁ']),
+    ('Ⳃ', &['ⳃ']),
+    ('ⳃ', &['Ⳃ']),
+    ('Ⳅ', &['ⳅ']),
+    ('ⳅ', &['Ⳅ']),
+    ('Ⳇ', &['ⳇ']),
+    ('ⳇ', &['Ⳇ']),
+    ('Ⳉ', &['ⳉ']),
+    ('ⳉ', &['Ⳉ']),
+    ('Ⳋ', &['ⳋ']),
+    ('ⳋ', &['Ⳋ']),
+    ('Ⳍ', &['ⳍ']),
+    ('ⳍ', &['Ⳍ']),
+    ('Ⳏ', &['ⳏ']),
+    ('ⳏ', &['Ⳏ']),
+    ('Ⳑ', &['ⳑ']),
+    ('ⳑ', &['Ⳑ']),
+    ('Ⳓ', &['ⳓ']),
+    ('ⳓ', &['Ⳓ']),
+    ('Ⳕ', &['ⳕ']),
+    ('ⳕ', &['Ⳕ']),
+    ('Ⳗ', &['ⳗ']),
+    ('ⳗ', &['Ⳗ']),
+    ('Ⳙ', &['ⳙ']),
+    ('ⳙ', &['Ⳙ']),
+    ('Ⳛ', &['ⳛ']),
+    ('ⳛ', &['Ⳛ']),
+    ('Ⳝ', &['ⳝ']),
+    ('ⳝ', &['Ⳝ']),
+    ('Ⳟ', &['ⳟ']),
+    ('ⳟ', &['Ⳟ']),
+    ('Ⳡ', &['ⳡ']),
+    ('ⳡ', &['Ⳡ']),
+    ('Ⳣ', &['ⳣ']),
+    ('ⳣ', &['Ⳣ']),
+    ('Ⳬ', &['ⳬ']),
+    ('ⳬ', &['Ⳬ']),
+    ('Ⳮ', &['ⳮ']),
+    ('ⳮ', &['Ⳮ']),
+    ('Ⳳ', &['ⳳ']),
+    ('ⳳ', &['Ⳳ']),
+    ('ⴀ', &['Ⴀ']),
+    ('ⴁ', &['Ⴁ']),
+    ('ⴂ', &['Ⴂ']),
+    ('ⴃ', &['Ⴃ']),
+    ('ⴄ', &['Ⴄ']),
+    ('ⴅ', &['Ⴅ']),
+    ('ⴆ', &['Ⴆ']),
+    ('ⴇ', &['Ⴇ']),
+    ('ⴈ', &['Ⴈ']),
+    ('ⴉ', &['Ⴉ']),
+    ('ⴊ', &['Ⴊ']),
+    ('ⴋ', &['Ⴋ']),
+    ('ⴌ', &['Ⴌ']),
+    ('ⴍ', &['Ⴍ']),
+    ('ⴎ', &['Ⴎ']),
+    ('ⴏ', &['Ⴏ']),
+    ('ⴐ', &['Ⴐ']),
+    ('ⴑ', &['Ⴑ']),
+    ('ⴒ', &['Ⴒ']),
+    ('ⴓ', &['Ⴓ']),
+    ('ⴔ', &['Ⴔ']),
+    ('ⴕ', &['Ⴕ']),
+    ('ⴖ', &['Ⴖ']),
+    ('ⴗ', &['Ⴗ']),
+    ('ⴘ', &['Ⴘ']),
+    ('ⴙ', &['Ⴙ']),
+    ('ⴚ', &['Ⴚ']),
+    ('ⴛ', &['Ⴛ']),
+    ('ⴜ', &['Ⴜ']),
+    ('ⴝ', &['Ⴝ']),
+    ('ⴞ', &['Ⴞ']),
+    ('ⴟ', &['Ⴟ']),
+    ('ⴠ', &['Ⴠ']),
+    ('ⴡ', &['Ⴡ']),
+    ('ⴢ', &['Ⴢ']),
+    ('ⴣ', &['Ⴣ']),
+    ('ⴤ', &['Ⴤ']),
+    ('ⴥ', &['Ⴥ']),
+    ('ⴧ', &['Ⴧ']),
+    ('ⴭ', &['Ⴭ']),
+    ('Ꙁ', &['ꙁ']),
+    ('ꙁ', &['Ꙁ']),
+    ('Ꙃ', &['ꙃ']),
+    ('ꙃ', &['Ꙃ']),
+    ('Ꙅ', &['ꙅ']),
+    ('ꙅ', &['Ꙅ']),
+    ('Ꙇ', &['ꙇ']),
+    ('ꙇ', &['Ꙇ']),
+    ('Ꙉ', &['ꙉ']),
+    ('ꙉ', &['Ꙉ']),
+    ('Ꙋ', &['ᲈ', 'ꙋ']),
+    ('ꙋ', &['ᲈ', 'Ꙋ']),
+    ('Ꙍ', &['ꙍ']),
+    ('ꙍ', &['Ꙍ']),
+    ('Ꙏ', &['ꙏ']),
+    ('ꙏ', &['Ꙏ']),
+    ('Ꙑ', &['ꙑ']),
+    ('ꙑ', &['Ꙑ']),
+    ('Ꙓ', &['ꙓ']),
+    ('ꙓ', &['Ꙓ']),
+    ('Ꙕ', &['ꙕ']),
+    ('ꙕ', &['Ꙕ']),
+    ('Ꙗ', &['ꙗ']),
+    ('ꙗ', &['Ꙗ']),
+    ('Ꙙ', &['ꙙ']),
+    ('ꙙ', &['Ꙙ']),
+    ('Ꙛ', &['ꙛ']),
+    ('ꙛ', &['Ꙛ']),
+    ('Ꙝ', &['ꙝ']),
+    ('ꙝ', &['Ꙝ']),
+    ('Ꙟ', &['ꙟ']),
+    ('ꙟ', &['Ꙟ']),
+    ('Ꙡ', &['ꙡ']),
+    ('ꙡ', &['Ꙡ']),
+    ('Ꙣ', &['ꙣ']),
+    ('ꙣ', &['Ꙣ']),
+    ('Ꙥ', &['ꙥ']),
+    ('ꙥ', &['Ꙥ']),
+    ('Ꙧ', &['ꙧ']),
+    ('ꙧ', &['Ꙧ']),
+    ('Ꙩ', &['ꙩ']),
+    ('ꙩ', &['Ꙩ']),
+    ('Ꙫ', &['ꙫ']),
+    ('ꙫ', &['Ꙫ']),
+    ('Ꙭ', &['ꙭ']),
+    ('ꙭ', &['Ꙭ']),
+    ('Ꚁ', &['ꚁ']),
+    ('ꚁ', &['Ꚁ']),
+    ('Ꚃ', &['ꚃ']),
+    ('ꚃ', &['Ꚃ']),
+    ('Ꚅ', &['ꚅ']),
+    ('ꚅ', &['Ꚅ']),
+    ('Ꚇ', &['ꚇ']),
+    ('ꚇ', &['Ꚇ']),
+    ('Ꚉ', &['ꚉ']),
+    ('ꚉ', &['Ꚉ']),
+    ('Ꚋ', &['ꚋ']),
+    ('ꚋ', &['Ꚋ']),
+    ('Ꚍ', &['ꚍ']),
+    ('ꚍ', &['Ꚍ']),
+    ('Ꚏ', &['ꚏ']),
+    ('ꚏ', &['Ꚏ']),
+    ('Ꚑ', &['ꚑ']),
+    ('ꚑ', &['Ꚑ']),
+    ('Ꚓ', &['ꚓ']),
+    ('ꚓ', &['Ꚓ']),
+    ('Ꚕ', &['ꚕ']),
+    ('ꚕ', &['Ꚕ']),
+    ('Ꚗ', &['ꚗ']),
+    ('ꚗ', &['Ꚗ']),
+    ('Ꚙ', &['ꚙ']),
+    ('ꚙ', &['Ꚙ']),
+    ('Ꚛ', &['ꚛ']),
+    ('ꚛ', &['Ꚛ']),
+    ('Ꜣ', &['ꜣ']),
+    ('ꜣ', &['Ꜣ']),
+    ('Ꜥ', &['ꜥ']),
+    ('ꜥ', &['Ꜥ']),
+    ('Ꜧ', &['ꜧ']),
+    ('ꜧ', &['Ꜧ']),
+    ('Ꜩ', &['ꜩ']),
+    ('ꜩ', &['Ꜩ']),
+    ('Ꜫ', &['ꜫ']),
+    ('ꜫ', &['Ꜫ']),
+    ('Ꜭ', &['ꜭ']),
+    ('ꜭ', &['Ꜭ']),
+    ('Ꜯ', &['ꜯ']),
+    ('ꜯ', &['Ꜯ']),
+    ('Ꜳ', &['ꜳ']),
+    ('ꜳ', &['Ꜳ']),
+    ('Ꜵ', &['ꜵ']),
+    ('ꜵ', &['Ꜵ']),
+    ('Ꜷ', &['ꜷ']),
+    ('ꜷ', &['Ꜷ']),
+    ('Ꜹ', &['ꜹ']),
+    ('ꜹ', &['Ꜹ']),
+    ('Ꜻ', &['ꜻ']),
+    ('ꜻ', &['Ꜻ']),
+    ('Ꜽ', &['ꜽ']),
+    ('ꜽ', &['Ꜽ']),
+    ('Ꜿ', &['ꜿ']),
+    ('ꜿ', &['Ꜿ']),
+    ('Ꝁ', &['ꝁ']),
+    ('ꝁ', &['Ꝁ']),
+    ('Ꝃ', &['ꝃ']),
+    ('ꝃ', &['Ꝃ']),
+    ('Ꝅ', &['ꝅ']),
+    ('ꝅ', &['Ꝅ']),
+    ('Ꝇ', &['ꝇ']),
+    ('ꝇ', &['Ꝇ']),
+    ('Ꝉ', &['ꝉ']),
+    ('ꝉ', &['Ꝉ']),
+    ('Ꝋ', &['ꝋ']),
+    ('ꝋ', &['Ꝋ']),
+    ('Ꝍ', &['ꝍ']),
+    ('ꝍ', &['Ꝍ']),
+    ('Ꝏ', &['ꝏ']),
+    ('ꝏ', &['Ꝏ']),
+    ('Ꝑ', &['ꝑ']),
+    ('ꝑ', &['Ꝑ']),
+    ('Ꝓ', &['ꝓ']),
+    ('ꝓ', &['Ꝓ']),
+    ('Ꝕ', &['ꝕ']),
+    ('ꝕ', &['Ꝕ']),
+    ('Ꝗ', &['ꝗ']),
+    ('ꝗ', &['Ꝗ']),
+    ('Ꝙ', &['ꝙ']),
+    ('ꝙ', &['Ꝙ']),
+    ('Ꝛ', &['ꝛ']),
+    ('ꝛ', &['Ꝛ']),
+    ('Ꝝ', &['ꝝ']),
+    ('ꝝ', &['Ꝝ']),
+    ('Ꝟ', &['ꝟ']),
+    ('ꝟ', &['Ꝟ']),
+    ('Ꝡ', &['ꝡ']),
+    ('ꝡ', &['Ꝡ']),
+    ('Ꝣ', &['ꝣ']),
+    ('ꝣ', &['Ꝣ']),
+    ('Ꝥ', &['ꝥ']),
+    ('ꝥ', &['Ꝥ']),
+    ('Ꝧ', &['ꝧ']),
+    ('ꝧ', &['Ꝧ']),
+    ('Ꝩ', &['ꝩ']),
+    ('ꝩ', &['Ꝩ']),
+    ('Ꝫ', &['ꝫ']),
+    ('ꝫ', &['Ꝫ']),
+    ('Ꝭ', &['ꝭ']),
+    ('ꝭ', &['Ꝭ']),
+    ('Ꝯ', &['ꝯ']),
+    ('ꝯ', &['Ꝯ']),
+    ('Ꝺ', &['ꝺ']),
+    ('ꝺ', &['Ꝺ']),
+    ('Ꝼ', &['ꝼ']),
+    ('ꝼ', &['Ꝼ']),
+    ('Ᵹ', &['ᵹ']),
+    ('Ꝿ', &['ꝿ']),
+    ('ꝿ', &['Ꝿ']),
+    ('Ꞁ', &['ꞁ']),
+    ('ꞁ', &['Ꞁ']),
+    ('Ꞃ', &['ꞃ']),
+    ('ꞃ', &['Ꞃ']),
+    ('Ꞅ', &['ꞅ']),
+    ('ꞅ', &['Ꞅ']),
+    ('Ꞇ', &['ꞇ']),
+    ('ꞇ', &['Ꞇ']),
+    ('Ꞌ', &['ꞌ']),
+    ('ꞌ', &['Ꞌ']),
+    ('Ɥ', &['ɥ']),
+    ('Ꞑ', &['ꞑ']),
+    ('ꞑ', &['Ꞑ']),
+    ('Ꞓ', &['ꞓ']),
+    ('ꞓ', &['Ꞓ']),
+    ('ꞔ', &['Ꞔ']),
+    ('Ꞗ', &['ꞗ']),
+    ('ꞗ', &['Ꞗ']),
+    ('Ꞙ', &['ꞙ']),
+    ('ꞙ', &['Ꞙ']),
+    ('Ꞛ', &['ꞛ']),
+    ('ꞛ', &['Ꞛ']),
+    ('Ꞝ', &['ꞝ']),
+    ('ꞝ', &['Ꞝ']),
+    ('Ꞟ', &['ꞟ']),
+    ('ꞟ', &['Ꞟ']),
+    ('Ꞡ', &['ꞡ']),
+    ('ꞡ', &['Ꞡ']),
+    ('Ꞣ', &['ꞣ']),
+    ('ꞣ', &['Ꞣ']),
+    ('Ꞥ', &['ꞥ']),
+    ('ꞥ', &['Ꞥ']),
+    ('Ꞧ', &['ꞧ']),
+    ('ꞧ', &['Ꞧ']),
+    ('Ꞩ', &['ꞩ']),
+    ('ꞩ', &['Ꞩ']),
+    ('Ɦ', &['ɦ']),
+    ('Ɜ', &['ɜ']),
+    ('Ɡ', &['ɡ']),
+    ('Ɬ', &['ɬ']),
+    ('Ɪ', &['ɪ']),
+    ('Ʞ', &['ʞ']),
+    ('Ʇ', &['ʇ']),
+    ('Ʝ', &['ʝ']),
+    ('Ꭓ', &['ꭓ']),
+    ('Ꞵ', &['ꞵ']),
+    ('ꞵ', &['Ꞵ']),
+    ('Ꞷ', &['ꞷ']),
+    ('ꞷ', &['Ꞷ']),
+    ('Ꞹ', &['ꞹ']),
+    ('ꞹ', &['Ꞹ']),
+    ('Ꞻ', &['ꞻ']),
+    ('ꞻ', &['Ꞻ']),
+    ('Ꞽ', &['ꞽ']),
+    ('ꞽ', &['Ꞽ']),
+    ('Ꞿ', &['ꞿ']),
+    ('ꞿ', &['Ꞿ']),
+    ('Ꟁ', &['ꟁ']),
+    ('ꟁ', &['Ꟁ']),
+    ('Ꟃ', &['ꟃ']),
+    ('ꟃ', &['Ꟃ']),
+    ('Ꞔ', &['ꞔ']),
+    ('Ʂ', &['ʂ']),
+    ('Ᶎ', &['ᶎ']),
+    ('Ꟈ', &['ꟈ']),
+    ('ꟈ', &['Ꟈ']),
+    ('Ꟊ', &['ꟊ']),
+    ('ꟊ', &['Ꟊ']),
+    ('Ꟑ', &['ꟑ']),
+    ('ꟑ', &['Ꟑ']),
+    ('Ꟗ', &['ꟗ']),
+    ('ꟗ', &['Ꟗ']),
+    ('Ꟙ', &['ꟙ']),
+    ('ꟙ', &['Ꟙ']),
+    ('Ꟶ', &['ꟶ']),
+    ('ꟶ', &['Ꟶ']),
+    ('ꭓ', &['Ꭓ']),
+    ('ꭰ', &['Ꭰ']),
+    ('ꭱ', &['Ꭱ']),
+    ('ꭲ', &['Ꭲ']),
+    ('ꭳ', &['Ꭳ']),
+    ('ꭴ', &['Ꭴ']),
+    ('ꭵ', &['Ꭵ']),
+    ('ꭶ', &['Ꭶ']),
+    ('ꭷ', &['Ꭷ']),
+    ('ꭸ', &['Ꭸ']),
+    ('ꭹ', &['Ꭹ']),
+    ('ꭺ', &['Ꭺ']),
+    ('ꭻ', &['Ꭻ']),
+    ('ꭼ', &['Ꭼ']),
+    ('ꭽ', &['Ꭽ']),
+    ('ꭾ', &['Ꭾ']),
+    ('ꭿ', &['Ꭿ']),
+    ('ꮀ', &['Ꮀ']),
+    ('ꮁ', &['Ꮁ']),
+    ('ꮂ', &['Ꮂ']),
+    ('ꮃ', &['Ꮃ']),
+    ('ꮄ', &['Ꮄ']),
+    ('ꮅ', &['Ꮅ']),
+    ('ꮆ', &['Ꮆ']),
+    ('ꮇ', &['Ꮇ']),
+    ('ꮈ', &['Ꮈ']),
+    ('ꮉ', &['Ꮉ']),
+    ('ꮊ', &['Ꮊ']),
+    ('ꮋ', &['Ꮋ']),
+    ('ꮌ', &['Ꮌ']),
+    ('ꮍ', &['Ꮍ']),
+    ('ꮎ', &['Ꮎ']),
+    ('ꮏ', &['Ꮏ']),
+    ('ꮐ', &['Ꮐ']),
+    ('ꮑ', &['Ꮑ']),
+    ('ꮒ', &['Ꮒ']),
+    ('ꮓ', &['Ꮓ']),
+    ('ꮔ', &['Ꮔ']),
+    ('ꮕ', &['Ꮕ']),
+    ('ꮖ', &['Ꮖ']),
+    ('ꮗ', &['Ꮗ']),
+    ('ꮘ', &['Ꮘ']),
+    ('ꮙ', &['Ꮙ']),
+    ('ꮚ', &['Ꮚ']),
+    ('ꮛ', &['Ꮛ']),
+    ('ꮜ', &['Ꮜ']),
+    ('ꮝ', &['Ꮝ']),
+    ('ꮞ', &['Ꮞ']),
+    ('ꮟ', &['Ꮟ']),
+    ('ꮠ', &['Ꮠ']),
+    ('ꮡ', &['Ꮡ']),
+    ('ꮢ', &['Ꮢ']),
+    ('ꮣ', &['Ꮣ']),
+    ('ꮤ', &['Ꮤ']),
+    ('ꮥ', &['Ꮥ']),
+    ('ꮦ', &['Ꮦ']),
+    ('ꮧ', &['Ꮧ']),
+    ('ꮨ', &['Ꮨ']),
+    ('ꮩ', &['Ꮩ']),
+    ('ꮪ', &['Ꮪ']),
+    ('ꮫ', &['Ꮫ']),
+    ('ꮬ', &['Ꮬ']),
+    ('ꮭ', &['Ꮭ']),
+    ('ꮮ', &['Ꮮ']),
+    ('ꮯ', &['Ꮯ']),
+    ('ꮰ', &['Ꮰ']),
+    ('ꮱ', &['Ꮱ']),
+    ('ꮲ', &['Ꮲ']),
+    ('ꮳ', &['Ꮳ']),
+    ('ꮴ', &['Ꮴ']),
+    ('ꮵ', &['Ꮵ']),
+    ('ꮶ', &['Ꮶ']),
+    ('ꮷ', &['Ꮷ']),
+    ('ꮸ', &['Ꮸ']),
+    ('ꮹ', &['Ꮹ']),
+    ('ꮺ', &['Ꮺ']),
+    ('ꮻ', &['Ꮻ']),
+    ('ꮼ', &['Ꮼ']),
+    ('ꮽ', &['Ꮽ']),
+    ('ꮾ', &['Ꮾ']),
+    ('ꮿ', &['Ꮿ']),
+    ('Ａ', &['ａ']),
+    ('Ｂ', &['ｂ']),
+    ('Ｃ', &['ｃ']),
+    ('Ｄ', &['ｄ']),
+    ('Ｅ', &['ｅ']),
+    ('Ｆ', &['ｆ']),
+    ('Ｇ', &['ｇ']),
+    ('Ｈ', &['ｈ']),
+    ('Ｉ', &['ｉ']),
+    ('Ｊ', &['ｊ']),
+    ('Ｋ', &['ｋ']),
+    ('Ｌ', &['ｌ']),
+    ('Ｍ', &['ｍ']),
+    ('Ｎ', &['ｎ']),
+    ('Ｏ', &['ｏ']),
+    ('Ｐ', &['ｐ']),
+    ('Ｑ', &['ｑ']),
+    ('Ｒ', &['ｒ']),
+    ('Ｓ', &['ｓ']),
+    ('Ｔ', &['ｔ']),
+    ('Ｕ', &['ｕ']),
+    ('Ｖ', &['ｖ']),
+    ('Ｗ', &['ｗ']),
+    ('Ｘ', &['ｘ']),
+    ('Ｙ', &['ｙ']),
+    ('Ｚ', &['ｚ']),
+    ('ａ', &['Ａ']),
+    ('ｂ', &['Ｂ']),
+    ('ｃ', &['Ｃ']),
+    ('ｄ', &['Ｄ']),
+    ('ｅ', &['Ｅ']),
+    ('ｆ', &['Ｆ']),
+    ('ｇ', &['Ｇ']),
+    ('ｈ', &['Ｈ']),
+    ('ｉ', &['Ｉ']),
+    ('ｊ', &['Ｊ']),
+    ('ｋ', &['Ｋ']),
+    ('ｌ', &['Ｌ']),
+    ('ｍ', &['Ｍ']),
+    ('ｎ', &['Ｎ']),
+    ('ｏ', &['Ｏ']),
+    ('ｐ', &['Ｐ']),
+    ('ｑ', &['Ｑ']),
+    ('ｒ', &['Ｒ']),
+    ('ｓ', &['Ｓ']),
+    ('ｔ', &['Ｔ']),
+    ('ｕ', &['Ｕ']),
+    ('ｖ', &['Ｖ']),
+    ('ｗ', &['Ｗ']),
+    ('ｘ', &['Ｘ']),
+    ('ｙ', &['Ｙ']),
+    ('ｚ', &['Ｚ']),
+    ('𐐀', &['𐐨']),
+    ('𐐁', &['𐐩']),
+    ('𐐂', &['𐐪']),
+    ('𐐃', &['𐐫']),
+    ('𐐄', &['𐐬']),
+    ('𐐅', &['𐐭']),
+    ('𐐆', &['𐐮']),
+    ('𐐇', &['𐐯']),
+    ('𐐈', &['𐐰']),
+    ('𐐉', &['𐐱']),
+    ('𐐊', &['𐐲']),
+    ('𐐋', &['𐐳']),
+    ('𐐌', &['𐐴']),
+    ('𐐍', &['𐐵']),
+    ('𐐎', &['𐐶']),
+    ('𐐏', &['𐐷']),
+    ('𐐐', &['𐐸']),
+    ('𐐑', &['𐐹']),
+    ('𐐒', &['𐐺']),
+    ('𐐓', &['𐐻']),
+    ('𐐔', &['𐐼']),
+    ('𐐕', &['𐐽']),
+    ('𐐖', &['𐐾']),
+    ('𐐗', &['𐐿']),
+    ('𐐘', &['𐑀']),
+    ('𐐙', &['𐑁']),
+    ('𐐚', &['𐑂']),
+    ('𐐛', &['𐑃']),
+    ('𐐜', &['𐑄']),
+    ('𐐝', &['𐑅']),
+    ('𐐞', &['𐑆']),
+    ('𐐟', &['𐑇']),
+    ('𐐠', &['𐑈']),
+    ('𐐡', &['𐑉']),
+    ('𐐢', &['𐑊']),
+    ('𐐣', &['𐑋']),
+    ('𐐤', &['𐑌']),
+    ('𐐥', &['𐑍']),
+    ('𐐦', &['𐑎']),
+    ('𐐧', &['𐑏']),
+    ('𐐨', &['𐐀']),
+    ('𐐩', &['𐐁']),
+    ('𐐪', &['𐐂']),
+    ('𐐫', &['𐐃']),
+    ('𐐬', &['𐐄']),
+    ('𐐭', &['𐐅']),
+    ('𐐮', &['𐐆']),
+    ('𐐯', &['𐐇']),
+    ('𐐰', &['𐐈']),
+    ('𐐱', &['𐐉']),
+    ('𐐲', &['𐐊']),
+    ('𐐳', &['𐐋']),
+    ('𐐴', &['𐐌']),
+    ('𐐵', &['𐐍']),
+    ('𐐶', &['𐐎']),
+    ('𐐷', &['𐐏']),
+    ('𐐸', &['𐐐']),
+    ('𐐹', &['𐐑']),
+    ('𐐺', &['𐐒']),
+    ('𐐻', &['𐐓']),
+    ('𐐼', &['𐐔']),
+    ('𐐽', &['𐐕']),
+    ('𐐾', &['𐐖']),
+    ('𐐿', &['𐐗']),
+    ('𐑀', &['𐐘']),
+    ('𐑁', &['𐐙']),
+    ('𐑂', &['𐐚']),
+    ('𐑃', &['𐐛']),
+    ('𐑄', &['𐐜']),
+    ('𐑅', &['𐐝']),
+    ('𐑆', &['𐐞']),
+    ('𐑇', &['𐐟']),
+    ('𐑈', &['𐐠']),
+    ('𐑉', &['𐐡']),
+    ('𐑊', &['𐐢']),
+    ('𐑋', &['𐐣']),
+    ('𐑌', &['𐐤']),
+    ('𐑍', &['𐐥']),
+    ('𐑎', &['𐐦']),
+    ('𐑏', &['𐐧']),
+    ('𐒰', &['𐓘']),
+    ('𐒱', &['𐓙']),
+    ('𐒲', &['𐓚']),
+    ('𐒳', &['𐓛']),
+    ('𐒴', &['𐓜']),
+    ('𐒵', &['𐓝']),
+    ('𐒶', &['𐓞']),
+    ('𐒷', &['𐓟']),
+    ('𐒸', &['𐓠']),
+    ('𐒹', &['𐓡']),
+    ('𐒺', &['𐓢']),
+    ('𐒻', &['𐓣']),
+    ('𐒼', &['𐓤']),
+    ('𐒽', &['𐓥']),
+    ('𐒾', &['𐓦']),
+    ('𐒿', &['𐓧']),
+    ('𐓀', &['𐓨']),
+    ('𐓁', &['𐓩']),
+    ('𐓂', &['𐓪']),
+    ('𐓃', &['𐓫']),
+    ('𐓄', &['𐓬']),
+    ('𐓅', &['𐓭']),
+    ('𐓆', &['𐓮']),
+    ('𐓇', &['𐓯']),
+    ('𐓈', &['𐓰']),
+    ('𐓉', &['𐓱']),
+    ('𐓊', &['𐓲']),
+    ('𐓋', &['𐓳']),
+    ('𐓌', &['𐓴']),
+    ('𐓍', &['𐓵']),
+    ('𐓎', &['𐓶']),
+    ('𐓏', &['𐓷']),
+    ('𐓐', &['𐓸']),
+    ('𐓑', &['𐓹']),
+    ('𐓒', &['𐓺']),
+    ('𐓓', &['𐓻']),
+    ('𐓘', &['𐒰']),
+    ('𐓙', &['𐒱']),
+    ('𐓚', &['𐒲']),
+    ('𐓛', &['𐒳']),
+    ('𐓜', &['𐒴']),
+    ('𐓝', &['𐒵']),
+    ('𐓞', &['𐒶']),
+    ('𐓟', &['𐒷']),
+    ('𐓠', &['𐒸']),
+    ('𐓡', &['𐒹']),
+    ('𐓢', &['𐒺']),
+    ('𐓣', &['𐒻']),
+    ('𐓤', &['𐒼']),
+    ('𐓥', &['𐒽']),
+    ('𐓦', &['𐒾']),
+    ('𐓧', &['𐒿']),
+    ('𐓨', &['𐓀']),
+    ('𐓩', &['𐓁']),
+    ('𐓪', &['𐓂']),
+    ('𐓫', &['𐓃']),
+    ('𐓬', &['𐓄']),
+    ('𐓭', &['𐓅']),
+    ('𐓮', &['𐓆']),
+    ('𐓯', &['𐓇']),
+    ('𐓰', &['𐓈']),
+    ('𐓱', &['𐓉']),
+    ('𐓲', &['𐓊']),
+    ('𐓳', &['𐓋']),
+    ('𐓴', &['𐓌']),
+    ('𐓵', &['𐓍']),
+    ('𐓶', &['𐓎']),
+    ('𐓷', &['𐓏']),
+    ('𐓸', &['𐓐']),
+    ('𐓹', &['𐓑']),
+    ('𐓺', &['𐓒']),
+    ('𐓻', &['𐓓']),
+    ('𐕰', &['𐖗']),
+    ('𐕱', &['𐖘']),
+    ('𐕲', &['𐖙']),
+    ('𐕳', &['𐖚']),
+    ('𐕴', &['𐖛']),
+    ('𐕵', &['𐖜']),
+    ('𐕶', &['𐖝']),
+    ('𐕷', &['𐖞']),
+    ('𐕸', &['𐖟']),
+    ('𐕹', &['𐖠']),
+    ('𐕺', &['𐖡']),
+    ('𐕼', &['𐖣']),
+    ('𐕽', &['𐖤']),
+    ('𐕾', &['𐖥']),
+    ('𐕿', &['𐖦']),
+    ('𐖀', &['𐖧']),
+    ('𐖁', &['𐖨']),
+    ('𐖂', &['𐖩']),
+    ('𐖃', &['𐖪']),
+    ('𐖄', &['𐖫']),
+    ('𐖅', &['𐖬']),
+    ('𐖆', &['𐖭']),
+    ('𐖇', &['𐖮']),
+    ('𐖈', &['𐖯']),
+    ('𐖉', &['𐖰']),
+    ('𐖊', &['𐖱']),
+    ('𐖌', &['𐖳']),
+    ('𐖍', &['𐖴']),
+    ('𐖎', &['𐖵']),
+    ('𐖏', &['𐖶']),
+    ('𐖐', &['𐖷']),
+    ('𐖑', &['𐖸']),
+    ('𐖒', &['𐖹']),
+    ('𐖔', &['𐖻']),
+    ('𐖕', &['𐖼']),
+    ('𐖗', &['𐕰']),
+    ('𐖘', &['𐕱']),
+    ('𐖙', &['𐕲']),
+    ('𐖚', &['𐕳']),
+    ('𐖛', &['𐕴']),
+    ('𐖜', &['𐕵']),
+    ('𐖝', &['𐕶']),
+    ('𐖞', &['𐕷']),
+    ('𐖟', &['𐕸']),
+    ('𐖠', &['𐕹']),
+    ('𐖡', &['𐕺']),
+    ('𐖣', &['𐕼']),
+    ('𐖤', &['𐕽']),
+    ('𐖥', &['𐕾']),
+    ('𐖦', &['𐕿']),
+    ('𐖧', &['𐖀']),
+    ('𐖨', &['𐖁']),
+    ('𐖩', &['𐖂']),
+    ('𐖪', &['𐖃']),
+    ('𐖫', &['𐖄']),
+    ('𐖬', &['𐖅']),
+    ('𐖭', &['𐖆']),
+    ('𐖮', &['𐖇']),
+    ('𐖯', &['𐖈']),
+    ('𐖰', &['𐖉']),
+    ('𐖱', &['𐖊']),
+    ('𐖳', &['𐖌']),
+    ('𐖴', &['𐖍']),
+    ('𐖵', &['𐖎']),
+    ('𐖶', &['𐖏']),
+    ('𐖷', &['𐖐']),
+    ('𐖸', &['𐖑']),
+    ('𐖹', &['𐖒']),
+    ('𐖻', &['𐖔']),
+    ('𐖼', &['𐖕']),
+    ('𐲀', &['𐳀']),
+    ('𐲁', &['𐳁']),
+    ('𐲂', &['𐳂']),
+    ('𐲃', &['𐳃']),
+    ('𐲄', &['𐳄']),
+    ('𐲅', &['𐳅']),
+    ('𐲆', &['𐳆']),
+    ('𐲇', &['𐳇']),
+    ('𐲈', &['𐳈']),
+    ('𐲉', &['𐳉']),
+    ('𐲊', &['𐳊']),
+    ('𐲋', &['𐳋']),
+    ('𐲌', &['𐳌']),
+    ('𐲍', &['𐳍']),
+    ('𐲎', &['𐳎']),
+    ('𐲏', &['𐳏']),
+    ('𐲐', &['𐳐']),
+    ('𐲑', &['𐳑']),
+    ('𐲒', &['𐳒']),
+    ('𐲓', &['𐳓']),
+    ('𐲔', &['𐳔']),
+    ('𐲕', &['𐳕']),
+    ('𐲖', &['𐳖']),
+    ('𐲗', &['𐳗']),
+    ('𐲘', &['𐳘']),
+    ('𐲙', &['𐳙']),
+    ('𐲚', &['𐳚']),
+    ('𐲛', &['𐳛']),
+    ('𐲜', &['𐳜']),
+    ('𐲝', &['𐳝']),
+    ('𐲞', &['𐳞']),
+    ('𐲟', &['𐳟']),
+    ('𐲠', &['𐳠']),
+    ('𐲡', &['𐳡']),
+    ('𐲢', &['𐳢']),
+    ('𐲣', &['𐳣']),
+    ('𐲤', &['𐳤']),
+    ('𐲥', &['𐳥']),
+    ('𐲦', &['𐳦']),
+    ('𐲧', &['𐳧']),
+    ('𐲨', &['𐳨']),
+    ('𐲩', &['𐳩']),
+    ('𐲪', &['𐳪']),
+    ('𐲫', &['𐳫']),
+    ('𐲬', &['𐳬']),
+    ('𐲭', &['𐳭']),
+    ('𐲮', &['𐳮']),
+    ('𐲯', &['𐳯']),
+    ('𐲰', &['𐳰']),
+    ('𐲱', &['𐳱']),
+    ('𐲲', &['𐳲']),
+    ('𐳀', &['𐲀']),
+    ('𐳁', &['𐲁']),
+    ('𐳂', &['𐲂']),
+    ('𐳃', &['𐲃']),
+    ('𐳄', &['𐲄']),
+    ('𐳅', &['𐲅']),
+    ('𐳆', &['𐲆']),
+    ('𐳇', &['𐲇']),
+    ('𐳈', &['𐲈']),
+    ('𐳉', &['𐲉']),
+    ('𐳊', &['𐲊']),
+    ('𐳋', &['𐲋']),
+    ('𐳌', &['𐲌']),
+    ('𐳍', &['𐲍']),
+    ('𐳎', &['𐲎']),
+    ('𐳏', &['𐲏']),
+    ('𐳐', &['𐲐']),
+    ('𐳑', &['𐲑']),
+    ('𐳒', &['𐲒']),
+    ('𐳓', &['𐲓']),
+    ('𐳔', &['𐲔']),
+    ('𐳕', &['𐲕']),
+    ('𐳖', &['𐲖']),
+    ('𐳗', &['𐲗']),
+    ('𐳘', &['𐲘']),
+    ('𐳙', &['𐲙']),
+    ('𐳚', &['𐲚']),
+    ('𐳛', &['𐲛']),
+    ('𐳜', &['𐲜']),
+    ('𐳝', &['𐲝']),
+    ('𐳞', &['𐲞']),
+    ('𐳟', &['𐲟']),
+    ('𐳠', &['𐲠']),
+    ('𐳡', &['𐲡']),
+    ('𐳢', &['𐲢']),
+    ('𐳣', &['𐲣']),
+    ('𐳤', &['𐲤']),
+    ('𐳥', &['𐲥']),
+    ('𐳦', &['𐲦']),
+    ('𐳧', &['𐲧']),
+    ('𐳨', &['𐲨']),
+    ('𐳩', &['𐲩']),
+    ('𐳪', &['𐲪']),
+    ('𐳫', &['𐲫']),
+    ('𐳬', &['𐲬']),
+    ('𐳭', &['𐲭']),
+    ('𐳮', &['𐲮']),
+    ('𐳯', &['𐲯']),
+    ('𐳰', &['𐲰']),
+    ('𐳱', &['𐲱']),
+    ('𐳲', &['𐲲']),
+    ('𑢠', &['𑣀']),
+    ('𑢡', &['𑣁']),
+    ('𑢢', &['𑣂']),
+    ('𑢣', &['𑣃']),
+    ('𑢤', &['𑣄']),
+    ('𑢥', &['𑣅']),
+    ('𑢦', &['𑣆']),
+    ('𑢧', &['𑣇']),
+    ('𑢨', &['𑣈']),
+    ('𑢩', &['𑣉']),
+    ('𑢪', &['𑣊']),
+    ('𑢫', &['𑣋']),
+    ('𑢬', &['𑣌']),
+    ('𑢭', &['𑣍']),
+    ('𑢮', &['𑣎']),
+    ('𑢯', &['𑣏']),
+    ('𑢰', &['𑣐']),
+    ('𑢱', &['𑣑']),
+    ('𑢲', &['𑣒']),
+    ('𑢳', &['𑣓']),
+    ('𑢴', &['𑣔']),
+    ('𑢵', &['𑣕']),
+    ('𑢶', &['𑣖']),
+    ('𑢷', &['𑣗']),
+    ('𑢸', &['𑣘']),
+    ('𑢹', &['𑣙']),
+    ('𑢺', &['𑣚']),
+    ('𑢻', &['𑣛']),
+    ('𑢼', &['𑣜']),
+    ('𑢽', &['𑣝']),
+    ('𑢾', &['𑣞']),
+    ('𑢿', &['𑣟']),
+    ('𑣀', &['𑢠']),
+    ('𑣁', &['𑢡']),
+    ('𑣂', &['𑢢']),
+    ('𑣃', &['𑢣']),
+    ('𑣄', &['𑢤']),
+    ('𑣅', &['𑢥']),
+    ('𑣆', &['𑢦']),
+    ('𑣇', &['𑢧']),
+    ('𑣈', &['𑢨']),
+    ('𑣉', &['𑢩']),
+    ('𑣊', &['𑢪']),
+    ('𑣋', &['𑢫']),
+    ('𑣌', &['𑢬']),
+    ('𑣍', &['𑢭']),
+    ('𑣎', &['𑢮']),
+    ('𑣏', &['𑢯']),
+    ('𑣐', &['𑢰']),
+    ('𑣑', &['𑢱']),
+    ('𑣒', &['𑢲']),
+    ('𑣓', &['𑢳']),
+    ('𑣔', &['𑢴']),
+    ('𑣕', &['𑢵']),
+    ('𑣖', &['𑢶']),
+    ('𑣗', &['𑢷']),
+    ('𑣘', &['𑢸']),
+    ('𑣙', &['𑢹']),
+    ('𑣚', &['𑢺']),
+    ('𑣛', &['𑢻']),
+    ('𑣜', &['𑢼']),
+    ('𑣝', &['𑢽']),
+    ('𑣞', &['𑢾']),
+    ('𑣟', &['𑢿']),
+    ('𖹀', &['𖹠']),
+    ('𖹁', &['𖹡']),
+    ('𖹂', &['𖹢']),
+    ('𖹃', &['𖹣']),
+    ('𖹄', &['𖹤']),
+    ('𖹅', &['𖹥']),
+    ('𖹆', &['𖹦']),
+    ('𖹇', &['𖹧']),
+    ('𖹈', &['𖹨']),
+    ('𖹉', &['𖹩']),
+    ('𖹊', &['𖹪']),
+    ('𖹋', &['𖹫']),
+    ('𖹌', &['𖹬']),
+    ('𖹍', &['𖹭']),
+    ('𖹎', &['𖹮']),
+    ('𖹏', &['𖹯']),
+    ('𖹐', &['𖹰']),
+    ('𖹑', &['𖹱']),
+    ('𖹒', &['𖹲']),
+    ('𖹓', &['𖹳']),
+    ('𖹔', &['𖹴']),
+    ('𖹕', &['𖹵']),
+    ('𖹖', &['𖹶']),
+    ('𖹗', &['𖹷']),
+    ('𖹘', &['𖹸']),
+    ('𖹙', &['𖹹']),
+    ('𖹚', &['𖹺']),
+    ('𖹛', &['𖹻']),
+    ('𖹜', &['𖹼']),
+    ('𖹝', &['𖹽']),
+    ('𖹞', &['𖹾']),
+    ('𖹟', &['𖹿']),
+    ('𖹠', &['𖹀']),
+    ('𖹡', &['𖹁']),
+    ('𖹢', &['𖹂']),
+    ('𖹣', &['𖹃']),
+    ('𖹤', &['𖹄']),
+    ('𖹥', &['𖹅']),
+    ('𖹦', &['𖹆']),
+    ('𖹧', &['𖹇']),
+    ('𖹨', &['𖹈']),
+    ('𖹩', &['𖹉']),
+    ('𖹪', &['𖹊']),
+    ('𖹫', &['𖹋']),
+    ('𖹬', &['𖹌']),
+    ('𖹭', &['𖹍']),
+    ('𖹮', &['𖹎']),
+    ('𖹯', &['𖹏']),
+    ('𖹰', &['𖹐']),
+    ('𖹱', &['𖹑']),
+    ('𖹲', &['𖹒']),
+    ('𖹳', &['𖹓']),
+    ('𖹴', &['𖹔']),
+    ('𖹵', &['𖹕']),
+    ('𖹶', &['𖹖']),
+    ('𖹷', &['𖹗']),
+    ('𖹸', &['𖹘']),
+    ('𖹹', &['𖹙']),
+    ('𖹺', &['𖹚']),
+    ('𖹻', &['𖹛']),
+    ('𖹼', &['𖹜']),
+    ('𖹽', &['𖹝']),
+    ('𖹾', &['𖹞']),
+    ('𖹿', &['𖹟']),
+    ('𞤀', &['𞤢']),
+    ('𞤁', &['𞤣']),
+    ('𞤂', &['𞤤']),
+    ('𞤃', &['𞤥']),
+    ('𞤄', &['𞤦']),
+    ('𞤅', &['𞤧']),
+    ('𞤆', &['𞤨']),
+    ('𞤇', &['𞤩']),
+    ('𞤈', &['𞤪']),
+    ('𞤉', &['𞤫']),
+    ('𞤊', &['𞤬']),
+    ('𞤋', &['𞤭']),
+    ('𞤌', &['𞤮']),
+    ('𞤍', &['𞤯']),
+    ('𞤎', &['𞤰']),
+    ('𞤏', &['𞤱']),
+    ('𞤐', &['𞤲']),
+    ('𞤑', &['𞤳']),
+    ('𞤒', &['𞤴']),
+    ('𞤓', &['𞤵']),
+    ('𞤔', &['𞤶']),
+    ('𞤕', &['𞤷']),
+    ('𞤖', &['𞤸']),
+    ('𞤗', &['𞤹']),
+    ('𞤘', &['𞤺']),
+    ('𞤙', &['𞤻']),
+    ('𞤚', &['𞤼']),
+    ('𞤛', &['𞤽']),
+    ('𞤜', &['𞤾']),
+    ('𞤝', &['𞤿']),
+    ('𞤞', &['𞥀']),
+    ('𞤟', &['𞥁']),
+    ('𞤠', &['𞥂']),
+    ('𞤡', &['𞥃']),
+    ('𞤢', &['𞤀']),
+    ('𞤣', &['𞤁']),
+    ('𞤤', &['𞤂']),
+    ('𞤥', &['𞤃']),
+    ('𞤦', &['𞤄']),
+    ('𞤧', &['𞤅']),
+    ('𞤨', &['𞤆']),
+    ('𞤩', &['𞤇']),
+    ('𞤪', &['𞤈']),
+    ('𞤫', &['𞤉']),
+    ('𞤬', &['𞤊']),
+    ('𞤭', &['𞤋']),
+    ('𞤮', &['𞤌']),
+    ('𞤯', &['𞤍']),
+    ('𞤰', &['𞤎']),
+    ('𞤱', &['𞤏']),
+    ('𞤲', &['𞤐']),
+    ('𞤳', &['𞤑']),
+    ('𞤴', &['𞤒']),
+    ('𞤵', &['𞤓']),
+    ('𞤶', &['𞤔']),
+    ('𞤷', &['𞤕']),
+    ('𞤸', &['𞤖']),
+    ('𞤹', &['𞤗']),
+    ('𞤺', &['𞤘']),
+    ('𞤻', &['𞤙']),
+    ('𞤼', &['𞤚']),
+    ('𞤽', &['𞤛']),
+    ('𞤾', &['𞤜']),
+    ('𞤿', &['𞤝']),
+    ('𞥀', &['𞤞']),
+    ('𞥁', &['𞤟']),
+    ('𞥂', &['𞤠']),
+    ('𞥃', &['𞤡']),
+];
diff --git a/crates/regex-syntax/src/unicode_tables/general_category.rs b/crates/regex-syntax/src/unicode_tables/general_category.rs
new file mode 100644
index 0000000..8fc9289
--- /dev/null
+++ b/crates/regex-syntax/src/unicode_tables/general_category.rs
@@ -0,0 +1,6552 @@
+// DO NOT EDIT THIS FILE. IT WAS AUTOMATICALLY GENERATED BY:
+//
+//   ucd-generate general-category ucd-15.0.0 --chars --exclude surrogate
+//
+// Unicode version: 15.0.0.
+//
+// ucd-generate 0.2.14 is available on crates.io.
+
+pub const BY_NAME: &'static [(&'static str, &'static [(char, char)])] = &[
+    ("Cased_Letter", CASED_LETTER),
+    ("Close_Punctuation", CLOSE_PUNCTUATION),
+    ("Connector_Punctuation", CONNECTOR_PUNCTUATION),
+    ("Control", CONTROL),
+    ("Currency_Symbol", CURRENCY_SYMBOL),
+    ("Dash_Punctuation", DASH_PUNCTUATION),
+    ("Decimal_Number", DECIMAL_NUMBER),
+    ("Enclosing_Mark", ENCLOSING_MARK),
+    ("Final_Punctuation", FINAL_PUNCTUATION),
+    ("Format", FORMAT),
+    ("Initial_Punctuation", INITIAL_PUNCTUATION),
+    ("Letter", LETTER),
+    ("Letter_Number", LETTER_NUMBER),
+    ("Line_Separator", LINE_SEPARATOR),
+    ("Lowercase_Letter", LOWERCASE_LETTER),
+    ("Mark", MARK),
+    ("Math_Symbol", MATH_SYMBOL),
+    ("Modifier_Letter", MODIFIER_LETTER),
+    ("Modifier_Symbol", MODIFIER_SYMBOL),
+    ("Nonspacing_Mark", NONSPACING_MARK),
+    ("Number", NUMBER),
+    ("Open_Punctuation", OPEN_PUNCTUATION),
+    ("Other", OTHER),
+    ("Other_Letter", OTHER_LETTER),
+    ("Other_Number", OTHER_NUMBER),
+    ("Other_Punctuation", OTHER_PUNCTUATION),
+    ("Other_Symbol", OTHER_SYMBOL),
+    ("Paragraph_Separator", PARAGRAPH_SEPARATOR),
+    ("Private_Use", PRIVATE_USE),
+    ("Punctuation", PUNCTUATION),
+    ("Separator", SEPARATOR),
+    ("Space_Separator", SPACE_SEPARATOR),
+    ("Spacing_Mark", SPACING_MARK),
+    ("Symbol", SYMBOL),
+    ("Titlecase_Letter", TITLECASE_LETTER),
+    ("Unassigned", UNASSIGNED),
+    ("Uppercase_Letter", UPPERCASE_LETTER),
+];
+
+pub const CASED_LETTER: &'static [(char, char)] = &[
+    ('A', 'Z'),
+    ('a', 'z'),
+    ('µ', 'µ'),
+    ('À', 'Ö'),
+    ('Ø', 'ö'),
+    ('ø', 'ƺ'),
+    ('Ƽ', 'ƿ'),
+    ('Ǆ', 'ʓ'),
+    ('ʕ', 'ʯ'),
+    ('Ͱ', 'ͳ'),
+    ('Ͷ', 'ͷ'),
+    ('ͻ', 'ͽ'),
+    ('Ϳ', 'Ϳ'),
+    ('Ά', 'Ά'),
+    ('Έ', 'Ί'),
+    ('Ό', 'Ό'),
+    ('Ύ', 'Ρ'),
+    ('Σ', 'ϵ'),
+    ('Ϸ', 'ҁ'),
+    ('Ҋ', 'ԯ'),
+    ('Ա', 'Ֆ'),
+    ('ՠ', 'ֈ'),
+    ('Ⴀ', 'Ⴥ'),
+    ('Ⴧ', 'Ⴧ'),
+    ('Ⴭ', 'Ⴭ'),
+    ('ა', 'ჺ'),
+    ('ჽ', 'ჿ'),
+    ('Ꭰ', 'Ᏽ'),
+    ('ᏸ', 'ᏽ'),
+    ('ᲀ', 'ᲈ'),
+    ('Ა', 'Ჺ'),
+    ('Ჽ', 'Ჿ'),
+    ('ᴀ', 'ᴫ'),
+    ('ᵫ', 'ᵷ'),
+    ('ᵹ', 'ᶚ'),
+    ('Ḁ', 'ἕ'),
+    ('Ἐ', 'Ἕ'),
+    ('ἠ', 'ὅ'),
+    ('Ὀ', 'Ὅ'),
+    ('ὐ', 'ὗ'),
+    ('Ὑ', 'Ὑ'),
+    ('Ὓ', 'Ὓ'),
+    ('Ὕ', 'Ὕ'),
+    ('Ὗ', 'ώ'),
+    ('ᾀ', 'ᾴ'),
+    ('ᾶ', 'ᾼ'),
+    ('ι', 'ι'),
+    ('ῂ', 'ῄ'),
+    ('ῆ', 'ῌ'),
+    ('ῐ', 'ΐ'),
+    ('ῖ', 'Ί'),
+    ('ῠ', 'Ῥ'),
+    ('ῲ', 'ῴ'),
+    ('ῶ', 'ῼ'),
+    ('ℂ', 'ℂ'),
+    ('ℇ', 'ℇ'),
+    ('ℊ', 'ℓ'),
+    ('ℕ', 'ℕ'),
+    ('ℙ', 'ℝ'),
+    ('ℤ', 'ℤ'),
+    ('Ω', 'Ω'),
+    ('ℨ', 'ℨ'),
+    ('K', 'ℭ'),
+    ('ℯ', 'ℴ'),
+    ('ℹ', 'ℹ'),
+    ('ℼ', 'ℿ'),
+    ('ⅅ', 'ⅉ'),
+    ('ⅎ', 'ⅎ'),
+    ('Ↄ', 'ↄ'),
+    ('Ⰰ', 'ⱻ'),
+    ('Ȿ', 'ⳤ'),
+    ('Ⳬ', 'ⳮ'),
+    ('Ⳳ', 'ⳳ'),
+    ('ⴀ', 'ⴥ'),
+    ('ⴧ', 'ⴧ'),
+    ('ⴭ', 'ⴭ'),
+    ('Ꙁ', 'ꙭ'),
+    ('Ꚁ', 'ꚛ'),
+    ('Ꜣ', 'ꝯ'),
+    ('ꝱ', 'ꞇ'),
+    ('Ꞌ', 'ꞎ'),
+    ('Ꞑ', 'ꟊ'),
+    ('Ꟑ', 'ꟑ'),
+    ('ꟓ', 'ꟓ'),
+    ('ꟕ', 'ꟙ'),
+    ('Ꟶ', 'ꟶ'),
+    ('ꟺ', 'ꟺ'),
+    ('ꬰ', 'ꭚ'),
+    ('ꭠ', 'ꭨ'),
+    ('ꭰ', 'ꮿ'),
+    ('ﬀ', 'ﬆ'),
+    ('ﬓ', 'ﬗ'),
+    ('Ａ', 'Ｚ'),
+    ('ａ', 'ｚ'),
+    ('𐐀', '𐑏'),
+    ('𐒰', '𐓓'),
+    ('𐓘', '𐓻'),
+    ('𐕰', '𐕺'),
+    ('𐕼', '𐖊'),
+    ('𐖌', '𐖒'),
+    ('𐖔', '𐖕'),
+    ('𐖗', '𐖡'),
+    ('𐖣', '𐖱'),
+    ('𐖳', '𐖹'),
+    ('𐖻', '𐖼'),
+    ('𐲀', '𐲲'),
+    ('𐳀', '𐳲'),
+    ('𑢠', '𑣟'),
+    ('𖹀', '𖹿'),
+    ('𝐀', '𝑔'),
+    ('𝑖', '𝒜'),
+    ('𝒞', '𝒟'),
+    ('𝒢', '𝒢'),
+    ('𝒥', '𝒦'),
+    ('𝒩', '𝒬'),
+    ('𝒮', '𝒹'),
+    ('𝒻', '𝒻'),
+    ('𝒽', '𝓃'),
+    ('𝓅', '𝔅'),
+    ('𝔇', '𝔊'),
+    ('𝔍', '𝔔'),
+    ('𝔖', '𝔜'),
+    ('𝔞', '𝔹'),
+    ('𝔻', '𝔾'),
+    ('𝕀', '𝕄'),
+    ('𝕆', '𝕆'),
+    ('𝕊', '𝕐'),
+    ('𝕒', '𝚥'),
+    ('𝚨', '𝛀'),
+    ('𝛂', '𝛚'),
+    ('𝛜', '𝛺'),
+    ('𝛼', '𝜔'),
+    ('𝜖', '𝜴'),
+    ('𝜶', '𝝎'),
+    ('𝝐', '𝝮'),
+    ('𝝰', '𝞈'),
+    ('𝞊', '𝞨'),
+    ('𝞪', '𝟂'),
+    ('𝟄', '𝟋'),
+    ('𝼀', '𝼉'),
+    ('𝼋', '𝼞'),
+    ('𝼥', '𝼪'),
+    ('𞤀', '𞥃'),
+];
+
+pub const CLOSE_PUNCTUATION: &'static [(char, char)] = &[
+    (')', ')'),
+    (']', ']'),
+    ('}', '}'),
+    ('༻', '༻'),
+    ('༽', '༽'),
+    ('᚜', '᚜'),
+    ('⁆', '⁆'),
+    ('⁾', '⁾'),
+    ('₎', '₎'),
+    ('⌉', '⌉'),
+    ('⌋', '⌋'),
+    ('〉', '〉'),
+    ('❩', '❩'),
+    ('❫', '❫'),
+    ('❭', '❭'),
+    ('❯', '❯'),
+    ('❱', '❱'),
+    ('❳', '❳'),
+    ('❵', '❵'),
+    ('⟆', '⟆'),
+    ('⟧', '⟧'),
+    ('⟩', '⟩'),
+    ('⟫', '⟫'),
+    ('⟭', '⟭'),
+    ('⟯', '⟯'),
+    ('⦄', '⦄'),
+    ('⦆', '⦆'),
+    ('⦈', '⦈'),
+    ('⦊', '⦊'),
+    ('⦌', '⦌'),
+    ('⦎', '⦎'),
+    ('⦐', '⦐'),
+    ('⦒', '⦒'),
+    ('⦔', '⦔'),
+    ('⦖', '⦖'),
+    ('⦘', '⦘'),
+    ('⧙', '⧙'),
+    ('⧛', '⧛'),
+    ('⧽', '⧽'),
+    ('⸣', '⸣'),
+    ('⸥', '⸥'),
+    ('⸧', '⸧'),
+    ('⸩', '⸩'),
+    ('⹖', '⹖'),
+    ('⹘', '⹘'),
+    ('⹚', '⹚'),
+    ('⹜', '⹜'),
+    ('〉', '〉'),
+    ('》', '》'),
+    ('」', '」'),
+    ('』', '』'),
+    ('】', '】'),
+    ('〕', '〕'),
+    ('〗', '〗'),
+    ('〙', '〙'),
+    ('〛', '〛'),
+    ('〞', '〟'),
+    ('﴾', '﴾'),
+    ('︘', '︘'),
+    ('︶', '︶'),
+    ('︸', '︸'),
+    ('︺', '︺'),
+    ('︼', '︼'),
+    ('︾', '︾'),
+    ('﹀', '﹀'),
+    ('﹂', '﹂'),
+    ('﹄', '﹄'),
+    ('﹈', '﹈'),
+    ('﹚', '﹚'),
+    ('﹜', '﹜'),
+    ('﹞', '﹞'),
+    ('）', '）'),
+    ('］', '］'),
+    ('｝', '｝'),
+    ('｠', '｠'),
+    ('｣', '｣'),
+];
+
+pub const CONNECTOR_PUNCTUATION: &'static [(char, char)] = &[
+    ('_', '_'),
+    ('‿', '⁀'),
+    ('⁔', '⁔'),
+    ('︳', '︴'),
+    ('﹍', '﹏'),
+    ('＿', '＿'),
+];
+
+pub const CONTROL: &'static [(char, char)] =
+    &[('\0', '\u{1f}'), ('\u{7f}', '\u{9f}')];
+
+pub const CURRENCY_SYMBOL: &'static [(char, char)] = &[
+    ('$', '$'),
+    ('¢', '¥'),
+    ('֏', '֏'),
+    ('؋', '؋'),
+    ('߾', '߿'),
+    ('৲', '৳'),
+    ('৻', '৻'),
+    ('૱', '૱'),
+    ('௹', '௹'),
+    ('฿', '฿'),
+    ('៛', '៛'),
+    ('₠', '⃀'),
+    ('꠸', '꠸'),
+    ('﷼', '﷼'),
+    ('﹩', '﹩'),
+    ('＄', '＄'),
+    ('￠', '￡'),
+    ('￥', '￦'),
+    ('𑿝', '𑿠'),
+    ('𞋿', '𞋿'),
+    ('𞲰', '𞲰'),
+];
+
+pub const DASH_PUNCTUATION: &'static [(char, char)] = &[
+    ('-', '-'),
+    ('֊', '֊'),
+    ('־', '־'),
+    ('᐀', '᐀'),
+    ('᠆', '᠆'),
+    ('‐', '―'),
+    ('⸗', '⸗'),
+    ('⸚', '⸚'),
+    ('⸺', '⸻'),
+    ('⹀', '⹀'),
+    ('⹝', '⹝'),
+    ('〜', '〜'),
+    ('〰', '〰'),
+    ('゠', '゠'),
+    ('︱', '︲'),
+    ('﹘', '﹘'),
+    ('﹣', '﹣'),
+    ('－', '－'),
+    ('𐺭', '𐺭'),
+];
+
+pub const DECIMAL_NUMBER: &'static [(char, char)] = &[
+    ('0', '9'),
+    ('٠', '٩'),
+    ('۰', '۹'),
+    ('߀', '߉'),
+    ('०', '९'),
+    ('০', '৯'),
+    ('੦', '੯'),
+    ('૦', '૯'),
+    ('୦', '୯'),
+    ('௦', '௯'),
+    ('౦', '౯'),
+    ('೦', '೯'),
+    ('൦', '൯'),
+    ('෦', '෯'),
+    ('๐', '๙'),
+    ('໐', '໙'),
+    ('༠', '༩'),
+    ('၀', '၉'),
+    ('႐', '႙'),
+    ('០', '៩'),
+    ('᠐', '᠙'),
+    ('᥆', '᥏'),
+    ('᧐', '᧙'),
+    ('᪀', '᪉'),
+    ('᪐', '᪙'),
+    ('᭐', '᭙'),
+    ('᮰', '᮹'),
+    ('᱀', '᱉'),
+    ('᱐', '᱙'),
+    ('꘠', '꘩'),
+    ('꣐', '꣙'),
+    ('꤀', '꤉'),
+    ('꧐', '꧙'),
+    ('꧰', '꧹'),
+    ('꩐', '꩙'),
+    ('꯰', '꯹'),
+    ('０', '９'),
+    ('𐒠', '𐒩'),
+    ('𐴰', '𐴹'),
+    ('𑁦', '𑁯'),
+    ('𑃰', '𑃹'),
+    ('𑄶', '𑄿'),
+    ('𑇐', '𑇙'),
+    ('𑋰', '𑋹'),
+    ('𑑐', '𑑙'),
+    ('𑓐', '𑓙'),
+    ('𑙐', '𑙙'),
+    ('𑛀', '𑛉'),
+    ('𑜰', '𑜹'),
+    ('𑣠', '𑣩'),
+    ('𑥐', '𑥙'),
+    ('𑱐', '𑱙'),
+    ('𑵐', '𑵙'),
+    ('𑶠', '𑶩'),
+    ('𑽐', '𑽙'),
+    ('𖩠', '𖩩'),
+    ('𖫀', '𖫉'),
+    ('𖭐', '𖭙'),
+    ('𝟎', '𝟿'),
+    ('𞅀', '𞅉'),
+    ('𞋰', '𞋹'),
+    ('𞓰', '𞓹'),
+    ('𞥐', '𞥙'),
+    ('🯰', '🯹'),
+];
+
+pub const ENCLOSING_MARK: &'static [(char, char)] = &[
+    ('\u{488}', '\u{489}'),
+    ('\u{1abe}', '\u{1abe}'),
+    ('\u{20dd}', '\u{20e0}'),
+    ('\u{20e2}', '\u{20e4}'),
+    ('\u{a670}', '\u{a672}'),
+];
+
+pub const FINAL_PUNCTUATION: &'static [(char, char)] = &[
+    ('»', '»'),
+    ('’', '’'),
+    ('”', '”'),
+    ('›', '›'),
+    ('⸃', '⸃'),
+    ('⸅', '⸅'),
+    ('⸊', '⸊'),
+    ('⸍', '⸍'),
+    ('⸝', '⸝'),
+    ('⸡', '⸡'),
+];
+
+pub const FORMAT: &'static [(char, char)] = &[
+    ('\u{ad}', '\u{ad}'),
+    ('\u{600}', '\u{605}'),
+    ('\u{61c}', '\u{61c}'),
+    ('\u{6dd}', '\u{6dd}'),
+    ('\u{70f}', '\u{70f}'),
+    ('\u{890}', '\u{891}'),
+    ('\u{8e2}', '\u{8e2}'),
+    ('\u{180e}', '\u{180e}'),
+    ('\u{200b}', '\u{200f}'),
+    ('\u{202a}', '\u{202e}'),
+    ('\u{2060}', '\u{2064}'),
+    ('\u{2066}', '\u{206f}'),
+    ('\u{feff}', '\u{feff}'),
+    ('\u{fff9}', '\u{fffb}'),
+    ('\u{110bd}', '\u{110bd}'),
+    ('\u{110cd}', '\u{110cd}'),
+    ('\u{13430}', '\u{1343f}'),
+    ('\u{1bca0}', '\u{1bca3}'),
+    ('\u{1d173}', '\u{1d17a}'),
+    ('\u{e0001}', '\u{e0001}'),
+    ('\u{e0020}', '\u{e007f}'),
+];
+
+pub const INITIAL_PUNCTUATION: &'static [(char, char)] = &[
+    ('«', '«'),
+    ('‘', '‘'),
+    ('‛', '“'),
+    ('‟', '‟'),
+    ('‹', '‹'),
+    ('⸂', '⸂'),
+    ('⸄', '⸄'),
+    ('⸉', '⸉'),
+    ('⸌', '⸌'),
+    ('⸜', '⸜'),
+    ('⸠', '⸠'),
+];
+
+pub const LETTER: &'static [(char, char)] = &[
+    ('A', 'Z'),
+    ('a', 'z'),
+    ('ª', 'ª'),
+    ('µ', 'µ'),
+    ('º', 'º'),
+    ('À', 'Ö'),
+    ('Ø', 'ö'),
+    ('ø', 'ˁ'),
+    ('ˆ', 'ˑ'),
+    ('ˠ', 'ˤ'),
+    ('ˬ', 'ˬ'),
+    ('ˮ', 'ˮ'),
+    ('Ͱ', 'ʹ'),
+    ('Ͷ', 'ͷ'),
+    ('ͺ', 'ͽ'),
+    ('Ϳ', 'Ϳ'),
+    ('Ά', 'Ά'),
+    ('Έ', 'Ί'),
+    ('Ό', 'Ό'),
+    ('Ύ', 'Ρ'),
+    ('Σ', 'ϵ'),
+    ('Ϸ', 'ҁ'),
+    ('Ҋ', 'ԯ'),
+    ('Ա', 'Ֆ'),
+    ('ՙ', 'ՙ'),
+    ('ՠ', 'ֈ'),
+    ('א', 'ת'),
+    ('ׯ', 'ײ'),
+    ('ؠ', 'ي'),
+    ('ٮ', 'ٯ'),
+    ('ٱ', 'ۓ'),
+    ('ە', 'ە'),
+    ('ۥ', 'ۦ'),
+    ('ۮ', 'ۯ'),
+    ('ۺ', 'ۼ'),
+    ('ۿ', 'ۿ'),
+    ('ܐ', 'ܐ'),
+    ('ܒ', 'ܯ'),
+    ('ݍ', 'ޥ'),
+    ('ޱ', 'ޱ'),
+    ('ߊ', 'ߪ'),
+    ('ߴ', 'ߵ'),
+    ('ߺ', 'ߺ'),
+    ('ࠀ', 'ࠕ'),
+    ('ࠚ', 'ࠚ'),
+    ('ࠤ', 'ࠤ'),
+    ('ࠨ', 'ࠨ'),
+    ('ࡀ', 'ࡘ'),
+    ('ࡠ', 'ࡪ'),
+    ('ࡰ', 'ࢇ'),
+    ('ࢉ', 'ࢎ'),
+    ('ࢠ', 'ࣉ'),
+    ('ऄ', 'ह'),
+    ('ऽ', 'ऽ'),
+    ('ॐ', 'ॐ'),
+    ('क़', 'ॡ'),
+    ('ॱ', 'ঀ'),
+    ('অ', 'ঌ'),
+    ('এ', 'ঐ'),
+    ('ও', 'ন'),
+    ('প', 'র'),
+    ('ল', 'ল'),
+    ('শ', 'হ'),
+    ('ঽ', 'ঽ'),
+    ('ৎ', 'ৎ'),
+    ('ড়', 'ঢ়'),
+    ('য়', 'ৡ'),
+    ('ৰ', 'ৱ'),
+    ('ৼ', 'ৼ'),
+    ('ਅ', 'ਊ'),
+    ('ਏ', 'ਐ'),
+    ('ਓ', 'ਨ'),
+    ('ਪ', 'ਰ'),
+    ('ਲ', 'ਲ਼'),
+    ('ਵ', 'ਸ਼'),
+    ('ਸ', 'ਹ'),
+    ('ਖ਼', 'ੜ'),
+    ('ਫ਼', 'ਫ਼'),
+    ('ੲ', 'ੴ'),
+    ('અ', 'ઍ'),
+    ('એ', 'ઑ'),
+    ('ઓ', 'ન'),
+    ('પ', 'ર'),
+    ('લ', 'ળ'),
+    ('વ', 'હ'),
+    ('ઽ', 'ઽ'),
+    ('ૐ', 'ૐ'),
+    ('ૠ', 'ૡ'),
+    ('ૹ', 'ૹ'),
+    ('ଅ', 'ଌ'),
+    ('ଏ', 'ଐ'),
+    ('ଓ', 'ନ'),
+    ('ପ', 'ର'),
+    ('ଲ', 'ଳ'),
+    ('ଵ', 'ହ'),
+    ('ଽ', 'ଽ'),
+    ('ଡ଼', 'ଢ଼'),
+    ('ୟ', 'ୡ'),
+    ('ୱ', 'ୱ'),
+    ('ஃ', 'ஃ'),
+    ('அ', 'ஊ'),
+    ('எ', 'ஐ'),
+    ('ஒ', 'க'),
+    ('ங', 'ச'),
+    ('ஜ', 'ஜ'),
+    ('ஞ', 'ட'),
+    ('ண', 'த'),
+    ('ந', 'ப'),
+    ('ம', 'ஹ'),
+    ('ௐ', 'ௐ'),
+    ('అ', 'ఌ'),
+    ('ఎ', 'ఐ'),
+    ('ఒ', 'న'),
+    ('ప', 'హ'),
+    ('ఽ', 'ఽ'),
+    ('ౘ', 'ౚ'),
+    ('ౝ', 'ౝ'),
+    ('ౠ', 'ౡ'),
+    ('ಀ', 'ಀ'),
+    ('ಅ', 'ಌ'),
+    ('ಎ', 'ಐ'),
+    ('ಒ', 'ನ'),
+    ('ಪ', 'ಳ'),
+    ('ವ', 'ಹ'),
+    ('ಽ', 'ಽ'),
+    ('ೝ', 'ೞ'),
+    ('ೠ', 'ೡ'),
+    ('ೱ', 'ೲ'),
+    ('ഄ', 'ഌ'),
+    ('എ', 'ഐ'),
+    ('ഒ', 'ഺ'),
+    ('ഽ', 'ഽ'),
+    ('ൎ', 'ൎ'),
+    ('ൔ', 'ൖ'),
+    ('ൟ', 'ൡ'),
+    ('ൺ', 'ൿ'),
+    ('අ', 'ඖ'),
+    ('ක', 'න'),
+    ('ඳ', 'ර'),
+    ('ල', 'ල'),
+    ('ව', 'ෆ'),
+    ('ก', 'ะ'),
+    ('า', 'ำ'),
+    ('เ', 'ๆ'),
+    ('ກ', 'ຂ'),
+    ('ຄ', 'ຄ'),
+    ('ຆ', 'ຊ'),
+    ('ຌ', 'ຣ'),
+    ('ລ', 'ລ'),
+    ('ວ', 'ະ'),
+    ('າ', 'ຳ'),
+    ('ຽ', 'ຽ'),
+    ('ເ', 'ໄ'),
+    ('ໆ', 'ໆ'),
+    ('ໜ', 'ໟ'),
+    ('ༀ', 'ༀ'),
+    ('ཀ', 'ཇ'),
+    ('ཉ', 'ཬ'),
+    ('ྈ', 'ྌ'),
+    ('က', 'ဪ'),
+    ('ဿ', 'ဿ'),
+    ('ၐ', 'ၕ'),
+    ('ၚ', 'ၝ'),
+    ('ၡ', 'ၡ'),
+    ('ၥ', 'ၦ'),
+    ('ၮ', 'ၰ'),
+    ('ၵ', 'ႁ'),
+    ('ႎ', 'ႎ'),
+    ('Ⴀ', 'Ⴥ'),
+    ('Ⴧ', 'Ⴧ'),
+    ('Ⴭ', 'Ⴭ'),
+    ('ა', 'ჺ'),
+    ('ჼ', 'ቈ'),
+    ('ቊ', 'ቍ'),
+    ('ቐ', 'ቖ'),
+    ('ቘ', 'ቘ'),
+    ('ቚ', 'ቝ'),
+    ('በ', 'ኈ'),
+    ('ኊ', 'ኍ'),
+    ('ነ', 'ኰ'),
+    ('ኲ', 'ኵ'),
+    ('ኸ', 'ኾ'),
+    ('ዀ', 'ዀ'),
+    ('ዂ', 'ዅ'),
+    ('ወ', 'ዖ'),
+    ('ዘ', 'ጐ'),
+    ('ጒ', 'ጕ'),
+    ('ጘ', 'ፚ'),
+    ('ᎀ', 'ᎏ'),
+    ('Ꭰ', 'Ᏽ'),
+    ('ᏸ', 'ᏽ'),
+    ('ᐁ', 'ᙬ'),
+    ('ᙯ', 'ᙿ'),
+    ('ᚁ', 'ᚚ'),
+    ('ᚠ', 'ᛪ'),
+    ('ᛱ', 'ᛸ'),
+    ('ᜀ', 'ᜑ'),
+    ('ᜟ', 'ᜱ'),
+    ('ᝀ', 'ᝑ'),
+    ('ᝠ', 'ᝬ'),
+    ('ᝮ', 'ᝰ'),
+    ('ក', 'ឳ'),
+    ('ៗ', 'ៗ'),
+    ('ៜ', 'ៜ'),
+    ('ᠠ', 'ᡸ'),
+    ('ᢀ', 'ᢄ'),
+    ('ᢇ', 'ᢨ'),
+    ('ᢪ', 'ᢪ'),
+    ('ᢰ', 'ᣵ'),
+    ('ᤀ', 'ᤞ'),
+    ('ᥐ', 'ᥭ'),
+    ('ᥰ', 'ᥴ'),
+    ('ᦀ', 'ᦫ'),
+    ('ᦰ', 'ᧉ'),
+    ('ᨀ', 'ᨖ'),
+    ('ᨠ', 'ᩔ'),
+    ('ᪧ', 'ᪧ'),
+    ('ᬅ', 'ᬳ'),
+    ('ᭅ', 'ᭌ'),
+    ('ᮃ', 'ᮠ'),
+    ('ᮮ', 'ᮯ'),
+    ('ᮺ', 'ᯥ'),
+    ('ᰀ', 'ᰣ'),
+    ('ᱍ', 'ᱏ'),
+    ('ᱚ', 'ᱽ'),
+    ('ᲀ', 'ᲈ'),
+    ('Ა', 'Ჺ'),
+    ('Ჽ', 'Ჿ'),
+    ('ᳩ', 'ᳬ'),
+    ('ᳮ', 'ᳳ'),
+    ('ᳵ', 'ᳶ'),
+    ('ᳺ', 'ᳺ'),
+    ('ᴀ', 'ᶿ'),
+    ('Ḁ', 'ἕ'),
+    ('Ἐ', 'Ἕ'),
+    ('ἠ', 'ὅ'),
+    ('Ὀ', 'Ὅ'),
+    ('ὐ', 'ὗ'),
+    ('Ὑ', 'Ὑ'),
+    ('Ὓ', 'Ὓ'),
+    ('Ὕ', 'Ὕ'),
+    ('Ὗ', 'ώ'),
+    ('ᾀ', 'ᾴ'),
+    ('ᾶ', 'ᾼ'),
+    ('ι', 'ι'),
+    ('ῂ', 'ῄ'),
+    ('ῆ', 'ῌ'),
+    ('ῐ', 'ΐ'),
+    ('ῖ', 'Ί'),
+    ('ῠ', 'Ῥ'),
+    ('ῲ', 'ῴ'),
+    ('ῶ', 'ῼ'),
+    ('ⁱ', 'ⁱ'),
+    ('ⁿ', 'ⁿ'),
+    ('ₐ', 'ₜ'),
+    ('ℂ', 'ℂ'),
+    ('ℇ', 'ℇ'),
+    ('ℊ', 'ℓ'),
+    ('ℕ', 'ℕ'),
+    ('ℙ', 'ℝ'),
+    ('ℤ', 'ℤ'),
+    ('Ω', 'Ω'),
+    ('ℨ', 'ℨ'),
+    ('K', 'ℭ'),
+    ('ℯ', 'ℹ'),
+    ('ℼ', 'ℿ'),
+    ('ⅅ', 'ⅉ'),
+    ('ⅎ', 'ⅎ'),
+    ('Ↄ', 'ↄ'),
+    ('Ⰰ', 'ⳤ'),
+    ('Ⳬ', 'ⳮ'),
+    ('Ⳳ', 'ⳳ'),
+    ('ⴀ', 'ⴥ'),
+    ('ⴧ', 'ⴧ'),
+    ('ⴭ', 'ⴭ'),
+    ('ⴰ', 'ⵧ'),
+    ('ⵯ', 'ⵯ'),
+    ('ⶀ', 'ⶖ'),
+    ('ⶠ', 'ⶦ'),
+    ('ⶨ', 'ⶮ'),
+    ('ⶰ', 'ⶶ'),
+    ('ⶸ', 'ⶾ'),
+    ('ⷀ', 'ⷆ'),
+    ('ⷈ', 'ⷎ'),
+    ('ⷐ', 'ⷖ'),
+    ('ⷘ', 'ⷞ'),
+    ('ⸯ', 'ⸯ'),
+    ('々', '〆'),
+    ('〱', '〵'),
+    ('〻', '〼'),
+    ('ぁ', 'ゖ'),
+    ('ゝ', 'ゟ'),
+    ('ァ', 'ヺ'),
+    ('ー', 'ヿ'),
+    ('ㄅ', 'ㄯ'),
+    ('ㄱ', 'ㆎ'),
+    ('ㆠ', 'ㆿ'),
+    ('ㇰ', 'ㇿ'),
+    ('㐀', '䶿'),
+    ('一', 'ꒌ'),
+    ('ꓐ', 'ꓽ'),
+    ('ꔀ', 'ꘌ'),
+    ('ꘐ', 'ꘟ'),
+    ('ꘪ', 'ꘫ'),
+    ('Ꙁ', 'ꙮ'),
+    ('ꙿ', 'ꚝ'),
+    ('ꚠ', 'ꛥ'),
+    ('ꜗ', 'ꜟ'),
+    ('Ꜣ', 'ꞈ'),
+    ('Ꞌ', 'ꟊ'),
+    ('Ꟑ', 'ꟑ'),
+    ('ꟓ', 'ꟓ'),
+    ('ꟕ', 'ꟙ'),
+    ('ꟲ', 'ꠁ'),
+    ('ꠃ', 'ꠅ'),
+    ('ꠇ', 'ꠊ'),
+    ('ꠌ', 'ꠢ'),
+    ('ꡀ', 'ꡳ'),
+    ('ꢂ', 'ꢳ'),
+    ('ꣲ', 'ꣷ'),
+    ('ꣻ', 'ꣻ'),
+    ('ꣽ', 'ꣾ'),
+    ('ꤊ', 'ꤥ'),
+    ('ꤰ', 'ꥆ'),
+    ('ꥠ', 'ꥼ'),
+    ('ꦄ', 'ꦲ'),
+    ('ꧏ', 'ꧏ'),
+    ('ꧠ', 'ꧤ'),
+    ('ꧦ', 'ꧯ'),
+    ('ꧺ', 'ꧾ'),
+    ('ꨀ', 'ꨨ'),
+    ('ꩀ', 'ꩂ'),
+    ('ꩄ', 'ꩋ'),
+    ('ꩠ', 'ꩶ'),
+    ('ꩺ', 'ꩺ'),
+    ('ꩾ', 'ꪯ'),
+    ('ꪱ', 'ꪱ'),
+    ('ꪵ', 'ꪶ'),
+    ('ꪹ', 'ꪽ'),
+    ('ꫀ', 'ꫀ'),
+    ('ꫂ', 'ꫂ'),
+    ('ꫛ', 'ꫝ'),
+    ('ꫠ', 'ꫪ'),
+    ('ꫲ', 'ꫴ'),
+    ('ꬁ', 'ꬆ'),
+    ('ꬉ', 'ꬎ'),
+    ('ꬑ', 'ꬖ'),
+    ('ꬠ', 'ꬦ'),
+    ('ꬨ', 'ꬮ'),
+    ('ꬰ', 'ꭚ'),
+    ('ꭜ', 'ꭩ'),
+    ('ꭰ', 'ꯢ'),
+    ('가', '힣'),
+    ('ힰ', 'ퟆ'),
+    ('ퟋ', 'ퟻ'),
+    ('豈', '舘'),
+    ('並', '龎'),
+    ('ﬀ', 'ﬆ'),
+    ('ﬓ', 'ﬗ'),
+    ('יִ', 'יִ'),
+    ('ײַ', 'ﬨ'),
+    ('שׁ', 'זּ'),
+    ('טּ', 'לּ'),
+    ('מּ', 'מּ'),
+    ('נּ', 'סּ'),
+    ('ףּ', 'פּ'),
+    ('צּ', 'ﮱ'),
+    ('ﯓ', 'ﴽ'),
+    ('ﵐ', 'ﶏ'),
+    ('ﶒ', 'ﷇ'),
+    ('ﷰ', 'ﷻ'),
+    ('ﹰ', 'ﹴ'),
+    ('ﹶ', 'ﻼ'),
+    ('Ａ', 'Ｚ'),
+    ('ａ', 'ｚ'),
+    ('ｦ', 'ﾾ'),
+    ('ￂ', 'ￇ'),
+    ('ￊ', 'ￏ'),
+    ('ￒ', 'ￗ'),
+    ('ￚ', 'ￜ'),
+    ('𐀀', '𐀋'),
+    ('𐀍', '𐀦'),
+    ('𐀨', '𐀺'),
+    ('𐀼', '𐀽'),
+    ('𐀿', '𐁍'),
+    ('𐁐', '𐁝'),
+    ('𐂀', '𐃺'),
+    ('𐊀', '𐊜'),
+    ('𐊠', '𐋐'),
+    ('𐌀', '𐌟'),
+    ('𐌭', '𐍀'),
+    ('𐍂', '𐍉'),
+    ('𐍐', '𐍵'),
+    ('𐎀', '𐎝'),
+    ('𐎠', '𐏃'),
+    ('𐏈', '𐏏'),
+    ('𐐀', '𐒝'),
+    ('𐒰', '𐓓'),
+    ('𐓘', '𐓻'),
+    ('𐔀', '𐔧'),
+    ('𐔰', '𐕣'),
+    ('𐕰', '𐕺'),
+    ('𐕼', '𐖊'),
+    ('𐖌', '𐖒'),
+    ('𐖔', '𐖕'),
+    ('𐖗', '𐖡'),
+    ('𐖣', '𐖱'),
+    ('𐖳', '𐖹'),
+    ('𐖻', '𐖼'),
+    ('𐘀', '𐜶'),
+    ('𐝀', '𐝕'),
+    ('𐝠', '𐝧'),
+    ('𐞀', '𐞅'),
+    ('𐞇', '𐞰'),
+    ('𐞲', '𐞺'),
+    ('𐠀', '𐠅'),
+    ('𐠈', '𐠈'),
+    ('𐠊', '𐠵'),
+    ('𐠷', '𐠸'),
+    ('𐠼', '𐠼'),
+    ('𐠿', '𐡕'),
+    ('𐡠', '𐡶'),
+    ('𐢀', '𐢞'),
+    ('𐣠', '𐣲'),
+    ('𐣴', '𐣵'),
+    ('𐤀', '𐤕'),
+    ('𐤠', '𐤹'),
+    ('𐦀', '𐦷'),
+    ('𐦾', '𐦿'),
+    ('𐨀', '𐨀'),
+    ('𐨐', '𐨓'),
+    ('𐨕', '𐨗'),
+    ('𐨙', '𐨵'),
+    ('𐩠', '𐩼'),
+    ('𐪀', '𐪜'),
+    ('𐫀', '𐫇'),
+    ('𐫉', '𐫤'),
+    ('𐬀', '𐬵'),
+    ('𐭀', '𐭕'),
+    ('𐭠', '𐭲'),
+    ('𐮀', '𐮑'),
+    ('𐰀', '𐱈'),
+    ('𐲀', '𐲲'),
+    ('𐳀', '𐳲'),
+    ('𐴀', '𐴣'),
+    ('𐺀', '𐺩'),
+    ('𐺰', '𐺱'),
+    ('𐼀', '𐼜'),
+    ('𐼧', '𐼧'),
+    ('𐼰', '𐽅'),
+    ('𐽰', '𐾁'),
+    ('𐾰', '𐿄'),
+    ('𐿠', '𐿶'),
+    ('𑀃', '𑀷'),
+    ('𑁱', '𑁲'),
+    ('𑁵', '𑁵'),
+    ('𑂃', '𑂯'),
+    ('𑃐', '𑃨'),
+    ('𑄃', '𑄦'),
+    ('𑅄', '𑅄'),
+    ('𑅇', '𑅇'),
+    ('𑅐', '𑅲'),
+    ('𑅶', '𑅶'),
+    ('𑆃', '𑆲'),
+    ('𑇁', '𑇄'),
+    ('𑇚', '𑇚'),
+    ('𑇜', '𑇜'),
+    ('𑈀', '𑈑'),
+    ('𑈓', '𑈫'),
+    ('𑈿', '𑉀'),
+    ('𑊀', '𑊆'),
+    ('𑊈', '𑊈'),
+    ('𑊊', '𑊍'),
+    ('𑊏', '𑊝'),
+    ('𑊟', '𑊨'),
+    ('𑊰', '𑋞'),
+    ('𑌅', '𑌌'),
+    ('𑌏', '𑌐'),
+    ('𑌓', '𑌨'),
+    ('𑌪', '𑌰'),
+    ('𑌲', '𑌳'),
+    ('𑌵', '𑌹'),
+    ('𑌽', '𑌽'),
+    ('𑍐', '𑍐'),
+    ('𑍝', '𑍡'),
+    ('𑐀', '𑐴'),
+    ('𑑇', '𑑊'),
+    ('𑑟', '𑑡'),
+    ('𑒀', '𑒯'),
+    ('𑓄', '𑓅'),
+    ('𑓇', '𑓇'),
+    ('𑖀', '𑖮'),
+    ('𑗘', '𑗛'),
+    ('𑘀', '𑘯'),
+    ('𑙄', '𑙄'),
+    ('𑚀', '𑚪'),
+    ('𑚸', '𑚸'),
+    ('𑜀', '𑜚'),
+    ('𑝀', '𑝆'),
+    ('𑠀', '𑠫'),
+    ('𑢠', '𑣟'),
+    ('𑣿', '𑤆'),
+    ('𑤉', '𑤉'),
+    ('𑤌', '𑤓'),
+    ('𑤕', '𑤖'),
+    ('𑤘', '𑤯'),
+    ('𑤿', '𑤿'),
+    ('𑥁', '𑥁'),
+    ('𑦠', '𑦧'),
+    ('𑦪', '𑧐'),
+    ('𑧡', '𑧡'),
+    ('𑧣', '𑧣'),
+    ('𑨀', '𑨀'),
+    ('𑨋', '𑨲'),
+    ('𑨺', '𑨺'),
+    ('𑩐', '𑩐'),
+    ('𑩜', '𑪉'),
+    ('𑪝', '𑪝'),
+    ('𑪰', '𑫸'),
+    ('𑰀', '𑰈'),
+    ('𑰊', '𑰮'),
+    ('𑱀', '𑱀'),
+    ('𑱲', '𑲏'),
+    ('𑴀', '𑴆'),
+    ('𑴈', '𑴉'),
+    ('𑴋', '𑴰'),
+    ('𑵆', '𑵆'),
+    ('𑵠', '𑵥'),
+    ('𑵧', '𑵨'),
+    ('𑵪', '𑶉'),
+    ('𑶘', '𑶘'),
+    ('𑻠', '𑻲'),
+    ('𑼂', '𑼂'),
+    ('𑼄', '𑼐'),
+    ('𑼒', '𑼳'),
+    ('𑾰', '𑾰'),
+    ('𒀀', '𒎙'),
+    ('𒒀', '𒕃'),
+    ('𒾐', '𒿰'),
+    ('𓀀', '𓐯'),
+    ('𓑁', '𓑆'),
+    ('𔐀', '𔙆'),
+    ('𖠀', '𖨸'),
+    ('𖩀', '𖩞'),
+    ('𖩰', '𖪾'),
+    ('𖫐', '𖫭'),
+    ('𖬀', '𖬯'),
+    ('𖭀', '𖭃'),
+    ('𖭣', '𖭷'),
+    ('𖭽', '𖮏'),
+    ('𖹀', '𖹿'),
+    ('𖼀', '𖽊'),
+    ('𖽐', '𖽐'),
+    ('𖾓', '𖾟'),
+    ('𖿠', '𖿡'),
+    ('𖿣', '𖿣'),
+    ('𗀀', '𘟷'),
+    ('𘠀', '𘳕'),
+    ('𘴀', '𘴈'),
+    ('𚿰', '𚿳'),
+    ('𚿵', '𚿻'),
+    ('𚿽', '𚿾'),
+    ('𛀀', '𛄢'),
+    ('𛄲', '𛄲'),
+    ('𛅐', '𛅒'),
+    ('𛅕', '𛅕'),
+    ('𛅤', '𛅧'),
+    ('𛅰', '𛋻'),
+    ('𛰀', '𛱪'),
+    ('𛱰', '𛱼'),
+    ('𛲀', '𛲈'),
+    ('𛲐', '𛲙'),
+    ('𝐀', '𝑔'),
+    ('𝑖', '𝒜'),
+    ('𝒞', '𝒟'),
+    ('𝒢', '𝒢'),
+    ('𝒥', '𝒦'),
+    ('𝒩', '𝒬'),
+    ('𝒮', '𝒹'),
+    ('𝒻', '𝒻'),
+    ('𝒽', '𝓃'),
+    ('𝓅', '𝔅'),
+    ('𝔇', '𝔊'),
+    ('𝔍', '𝔔'),
+    ('𝔖', '𝔜'),
+    ('𝔞', '𝔹'),
+    ('𝔻', '𝔾'),
+    ('𝕀', '𝕄'),
+    ('𝕆', '𝕆'),
+    ('𝕊', '𝕐'),
+    ('𝕒', '𝚥'),
+    ('𝚨', '𝛀'),
+    ('𝛂', '𝛚'),
+    ('𝛜', '𝛺'),
+    ('𝛼', '𝜔'),
+    ('𝜖', '𝜴'),
+    ('𝜶', '𝝎'),
+    ('𝝐', '𝝮'),
+    ('𝝰', '𝞈'),
+    ('𝞊', '𝞨'),
+    ('𝞪', '𝟂'),
+    ('𝟄', '𝟋'),
+    ('𝼀', '𝼞'),
+    ('𝼥', '𝼪'),
+    ('𞀰', '𞁭'),
+    ('𞄀', '𞄬'),
+    ('𞄷', '𞄽'),
+    ('𞅎', '𞅎'),
+    ('𞊐', '𞊭'),
+    ('𞋀', '𞋫'),
+    ('𞓐', '𞓫'),
+    ('𞟠', '𞟦'),
+    ('𞟨', '𞟫'),
+    ('𞟭', '𞟮'),
+    ('𞟰', '𞟾'),
+    ('𞠀', '𞣄'),
+    ('𞤀', '𞥃'),
+    ('𞥋', '𞥋'),
+    ('𞸀', '𞸃'),
+    ('𞸅', '𞸟'),
+    ('𞸡', '𞸢'),
+    ('𞸤', '𞸤'),
+    ('𞸧', '𞸧'),
+    ('𞸩', '𞸲'),
+    ('𞸴', '𞸷'),
+    ('𞸹', '𞸹'),
+    ('𞸻', '𞸻'),
+    ('𞹂', '𞹂'),
+    ('𞹇', '𞹇'),
+    ('𞹉', '𞹉'),
+    ('𞹋', '𞹋'),
+    ('𞹍', '𞹏'),
+    ('𞹑', '𞹒'),
+    ('𞹔', '𞹔'),
+    ('𞹗', '𞹗'),
+    ('𞹙', '𞹙'),
+    ('𞹛', '𞹛'),
+    ('𞹝', '𞹝'),
+    ('𞹟', '𞹟'),
+    ('𞹡', '𞹢'),
+    ('𞹤', '𞹤'),
+    ('𞹧', '𞹪'),
+    ('𞹬', '𞹲'),
+    ('𞹴', '𞹷'),
+    ('𞹹', '𞹼'),
+    ('𞹾', '𞹾'),
+    ('𞺀', '𞺉'),
+    ('𞺋', '𞺛'),
+    ('𞺡', '𞺣'),
+    ('𞺥', '𞺩'),
+    ('𞺫', '𞺻'),
+    ('𠀀', '𪛟'),
+    ('𪜀', '𫜹'),
+    ('𫝀', '𫠝'),
+    ('𫠠', '𬺡'),
+    ('𬺰', '𮯠'),
+    ('丽', '𪘀'),
+    ('𰀀', '𱍊'),
+    ('𱍐', '𲎯'),
+];
+
+pub const LETTER_NUMBER: &'static [(char, char)] = &[
+    ('ᛮ', 'ᛰ'),
+    ('Ⅰ', 'ↂ'),
+    ('ↅ', 'ↈ'),
+    ('〇', '〇'),
+    ('〡', '〩'),
+    ('〸', '〺'),
+    ('ꛦ', 'ꛯ'),
+    ('𐅀', '𐅴'),
+    ('𐍁', '𐍁'),
+    ('𐍊', '𐍊'),
+    ('𐏑', '𐏕'),
+    ('𒐀', '𒑮'),
+];
+
+pub const LINE_SEPARATOR: &'static [(char, char)] =
+    &[('\u{2028}', '\u{2028}')];
+
+pub const LOWERCASE_LETTER: &'static [(char, char)] = &[
+    ('a', 'z'),
+    ('µ', 'µ'),
+    ('ß', 'ö'),
+    ('ø', 'ÿ'),
+    ('ā', 'ā'),
+    ('ă', 'ă'),
+    ('ą', 'ą'),
+    ('ć', 'ć'),
+    ('ĉ', 'ĉ'),
+    ('ċ', 'ċ'),
+    ('č', 'č'),
+    ('ď', 'ď'),
+    ('đ', 'đ'),
+    ('ē', 'ē'),
+    ('ĕ', 'ĕ'),
+    ('ė', 'ė'),
+    ('ę', 'ę'),
+    ('ě', 'ě'),
+    ('ĝ', 'ĝ'),
+    ('ğ', 'ğ'),
+    ('ġ', 'ġ'),
+    ('ģ', 'ģ'),
+    ('ĥ', 'ĥ'),
+    ('ħ', 'ħ'),
+    ('ĩ', 'ĩ'),
+    ('ī', 'ī'),
+    ('ĭ', 'ĭ'),
+    ('į', 'į'),
+    ('ı', 'ı'),
+    ('ĳ', 'ĳ'),
+    ('ĵ', 'ĵ'),
+    ('ķ', 'ĸ'),
+    ('ĺ', 'ĺ'),
+    ('ļ', 'ļ'),
+    ('ľ', 'ľ'),
+    ('ŀ', 'ŀ'),
+    ('ł', 'ł'),
+    ('ń', 'ń'),
+    ('ņ', 'ņ'),
+    ('ň', 'ŉ'),
+    ('ŋ', 'ŋ'),
+    ('ō', 'ō'),
+    ('ŏ', 'ŏ'),
+    ('ő', 'ő'),
+    ('œ', 'œ'),
+    ('ŕ', 'ŕ'),
+    ('ŗ', 'ŗ'),
+    ('ř', 'ř'),
+    ('ś', 'ś'),
+    ('ŝ', 'ŝ'),
+    ('ş', 'ş'),
+    ('š', 'š'),
+    ('ţ', 'ţ'),
+    ('ť', 'ť'),
+    ('ŧ', 'ŧ'),
+    ('ũ', 'ũ'),
+    ('ū', 'ū'),
+    ('ŭ', 'ŭ'),
+    ('ů', 'ů'),
+    ('ű', 'ű'),
+    ('ų', 'ų'),
+    ('ŵ', 'ŵ'),
+    ('ŷ', 'ŷ'),
+    ('ź', 'ź'),
+    ('ż', 'ż'),
+    ('ž', 'ƀ'),
+    ('ƃ', 'ƃ'),
+    ('ƅ', 'ƅ'),
+    ('ƈ', 'ƈ'),
+    ('ƌ', 'ƍ'),
+    ('ƒ', 'ƒ'),
+    ('ƕ', 'ƕ'),
+    ('ƙ', 'ƛ'),
+    ('ƞ', 'ƞ'),
+    ('ơ', 'ơ'),
+    ('ƣ', 'ƣ'),
+    ('ƥ', 'ƥ'),
+    ('ƨ', 'ƨ'),
+    ('ƪ', 'ƫ'),
+    ('ƭ', 'ƭ'),
+    ('ư', 'ư'),
+    ('ƴ', 'ƴ'),
+    ('ƶ', 'ƶ'),
+    ('ƹ', 'ƺ'),
+    ('ƽ', 'ƿ'),
+    ('ǆ', 'ǆ'),
+    ('ǉ', 'ǉ'),
+    ('ǌ', 'ǌ'),
+    ('ǎ', 'ǎ'),
+    ('ǐ', 'ǐ'),
+    ('ǒ', 'ǒ'),
+    ('ǔ', 'ǔ'),
+    ('ǖ', 'ǖ'),
+    ('ǘ', 'ǘ'),
+    ('ǚ', 'ǚ'),
+    ('ǜ', 'ǝ'),
+    ('ǟ', 'ǟ'),
+    ('ǡ', 'ǡ'),
+    ('ǣ', 'ǣ'),
+    ('ǥ', 'ǥ'),
+    ('ǧ', 'ǧ'),
+    ('ǩ', 'ǩ'),
+    ('ǫ', 'ǫ'),
+    ('ǭ', 'ǭ'),
+    ('ǯ', 'ǰ'),
+    ('ǳ', 'ǳ'),
+    ('ǵ', 'ǵ'),
+    ('ǹ', 'ǹ'),
+    ('ǻ', 'ǻ'),
+    ('ǽ', 'ǽ'),
+    ('ǿ', 'ǿ'),
+    ('ȁ', 'ȁ'),
+    ('ȃ', 'ȃ'),
+    ('ȅ', 'ȅ'),
+    ('ȇ', 'ȇ'),
+    ('ȉ', 'ȉ'),
+    ('ȋ', 'ȋ'),
+    ('ȍ', 'ȍ'),
+    ('ȏ', 'ȏ'),
+    ('ȑ', 'ȑ'),
+    ('ȓ', 'ȓ'),
+    ('ȕ', 'ȕ'),
+    ('ȗ', 'ȗ'),
+    ('ș', 'ș'),
+    ('ț', 'ț'),
+    ('ȝ', 'ȝ'),
+    ('ȟ', 'ȟ'),
+    ('ȡ', 'ȡ'),
+    ('ȣ', 'ȣ'),
+    ('ȥ', 'ȥ'),
+    ('ȧ', 'ȧ'),
+    ('ȩ', 'ȩ'),
+    ('ȫ', 'ȫ'),
+    ('ȭ', 'ȭ'),
+    ('ȯ', 'ȯ'),
+    ('ȱ', 'ȱ'),
+    ('ȳ', 'ȹ'),
+    ('ȼ', 'ȼ'),
+    ('ȿ', 'ɀ'),
+    ('ɂ', 'ɂ'),
+    ('ɇ', 'ɇ'),
+    ('ɉ', 'ɉ'),
+    ('ɋ', 'ɋ'),
+    ('ɍ', 'ɍ'),
+    ('ɏ', 'ʓ'),
+    ('ʕ', 'ʯ'),
+    ('ͱ', 'ͱ'),
+    ('ͳ', 'ͳ'),
+    ('ͷ', 'ͷ'),
+    ('ͻ', 'ͽ'),
+    ('ΐ', 'ΐ'),
+    ('ά', 'ώ'),
+    ('ϐ', 'ϑ'),
+    ('ϕ', 'ϗ'),
+    ('ϙ', 'ϙ'),
+    ('ϛ', 'ϛ'),
+    ('ϝ', 'ϝ'),
+    ('ϟ', 'ϟ'),
+    ('ϡ', 'ϡ'),
+    ('ϣ', 'ϣ'),
+    ('ϥ', 'ϥ'),
+    ('ϧ', 'ϧ'),
+    ('ϩ', 'ϩ'),
+    ('ϫ', 'ϫ'),
+    ('ϭ', 'ϭ'),
+    ('ϯ', 'ϳ'),
+    ('ϵ', 'ϵ'),
+    ('ϸ', 'ϸ'),
+    ('ϻ', 'ϼ'),
+    ('а', 'џ'),
+    ('ѡ', 'ѡ'),
+    ('ѣ', 'ѣ'),
+    ('ѥ', 'ѥ'),
+    ('ѧ', 'ѧ'),
+    ('ѩ', 'ѩ'),
+    ('ѫ', 'ѫ'),
+    ('ѭ', 'ѭ'),
+    ('ѯ', 'ѯ'),
+    ('ѱ', 'ѱ'),
+    ('ѳ', 'ѳ'),
+    ('ѵ', 'ѵ'),
+    ('ѷ', 'ѷ'),
+    ('ѹ', 'ѹ'),
+    ('ѻ', 'ѻ'),
+    ('ѽ', 'ѽ'),
+    ('ѿ', 'ѿ'),
+    ('ҁ', 'ҁ'),
+    ('ҋ', 'ҋ'),
+    ('ҍ', 'ҍ'),
+    ('ҏ', 'ҏ'),
+    ('ґ', 'ґ'),
+    ('ғ', 'ғ'),
+    ('ҕ', 'ҕ'),
+    ('җ', 'җ'),
+    ('ҙ', 'ҙ'),
+    ('қ', 'қ'),
+    ('ҝ', 'ҝ'),
+    ('ҟ', 'ҟ'),
+    ('ҡ', 'ҡ'),
+    ('ң', 'ң'),
+    ('ҥ', 'ҥ'),
+    ('ҧ', 'ҧ'),
+    ('ҩ', 'ҩ'),
+    ('ҫ', 'ҫ'),
+    ('ҭ', 'ҭ'),
+    ('ү', 'ү'),
+    ('ұ', 'ұ'),
+    ('ҳ', 'ҳ'),
+    ('ҵ', 'ҵ'),
+    ('ҷ', 'ҷ'),
+    ('ҹ', 'ҹ'),
+    ('һ', 'һ'),
+    ('ҽ', 'ҽ'),
+    ('ҿ', 'ҿ'),
+    ('ӂ', 'ӂ'),
+    ('ӄ', 'ӄ'),
+    ('ӆ', 'ӆ'),
+    ('ӈ', 'ӈ'),
+    ('ӊ', 'ӊ'),
+    ('ӌ', 'ӌ'),
+    ('ӎ', 'ӏ'),
+    ('ӑ', 'ӑ'),
+    ('ӓ', 'ӓ'),
+    ('ӕ', 'ӕ'),
+    ('ӗ', 'ӗ'),
+    ('ә', 'ә'),
+    ('ӛ', 'ӛ'),
+    ('ӝ', 'ӝ'),
+    ('ӟ', 'ӟ'),
+    ('ӡ', 'ӡ'),
+    ('ӣ', 'ӣ'),
+    ('ӥ', 'ӥ'),
+    ('ӧ', 'ӧ'),
+    ('ө', 'ө'),
+    ('ӫ', 'ӫ'),
+    ('ӭ', 'ӭ'),
+    ('ӯ', 'ӯ'),
+    ('ӱ', 'ӱ'),
+    ('ӳ', 'ӳ'),
+    ('ӵ', 'ӵ'),
+    ('ӷ', 'ӷ'),
+    ('ӹ', 'ӹ'),
+    ('ӻ', 'ӻ'),
+    ('ӽ', 'ӽ'),
+    ('ӿ', 'ӿ'),
+    ('ԁ', 'ԁ'),
+    ('ԃ', 'ԃ'),
+    ('ԅ', 'ԅ'),
+    ('ԇ', 'ԇ'),
+    ('ԉ', 'ԉ'),
+    ('ԋ', 'ԋ'),
+    ('ԍ', 'ԍ'),
+    ('ԏ', 'ԏ'),
+    ('ԑ', 'ԑ'),
+    ('ԓ', 'ԓ'),
+    ('ԕ', 'ԕ'),
+    ('ԗ', 'ԗ'),
+    ('ԙ', 'ԙ'),
+    ('ԛ', 'ԛ'),
+    ('ԝ', 'ԝ'),
+    ('ԟ', 'ԟ'),
+    ('ԡ', 'ԡ'),
+    ('ԣ', 'ԣ'),
+    ('ԥ', 'ԥ'),
+    ('ԧ', 'ԧ'),
+    ('ԩ', 'ԩ'),
+    ('ԫ', 'ԫ'),
+    ('ԭ', 'ԭ'),
+    ('ԯ', 'ԯ'),
+    ('ՠ', 'ֈ'),
+    ('ა', 'ჺ'),
+    ('ჽ', 'ჿ'),
+    ('ᏸ', 'ᏽ'),
+    ('ᲀ', 'ᲈ'),
+    ('ᴀ', 'ᴫ'),
+    ('ᵫ', 'ᵷ'),
+    ('ᵹ', 'ᶚ'),
+    ('ḁ', 'ḁ'),
+    ('ḃ', 'ḃ'),
+    ('ḅ', 'ḅ'),
+    ('ḇ', 'ḇ'),
+    ('ḉ', 'ḉ'),
+    ('ḋ', 'ḋ'),
+    ('ḍ', 'ḍ'),
+    ('ḏ', 'ḏ'),
+    ('ḑ', 'ḑ'),
+    ('ḓ', 'ḓ'),
+    ('ḕ', 'ḕ'),
+    ('ḗ', 'ḗ'),
+    ('ḙ', 'ḙ'),
+    ('ḛ', 'ḛ'),
+    ('ḝ', 'ḝ'),
+    ('ḟ', 'ḟ'),
+    ('ḡ', 'ḡ'),
+    ('ḣ', 'ḣ'),
+    ('ḥ', 'ḥ'),
+    ('ḧ', 'ḧ'),
+    ('ḩ', 'ḩ'),
+    ('ḫ', 'ḫ'),
+    ('ḭ', 'ḭ'),
+    ('ḯ', 'ḯ'),
+    ('ḱ', 'ḱ'),
+    ('ḳ', 'ḳ'),
+    ('ḵ', 'ḵ'),
+    ('ḷ', 'ḷ'),
+    ('ḹ', 'ḹ'),
+    ('ḻ', 'ḻ'),
+    ('ḽ', 'ḽ'),
+    ('ḿ', 'ḿ'),
+    ('ṁ', 'ṁ'),
+    ('ṃ', 'ṃ'),
+    ('ṅ', 'ṅ'),
+    ('ṇ', 'ṇ'),
+    ('ṉ', 'ṉ'),
+    ('ṋ', 'ṋ'),
+    ('ṍ', 'ṍ'),
+    ('ṏ', 'ṏ'),
+    ('ṑ', 'ṑ'),
+    ('ṓ', 'ṓ'),
+    ('ṕ', 'ṕ'),
+    ('ṗ', 'ṗ'),
+    ('ṙ', 'ṙ'),
+    ('ṛ', 'ṛ'),
+    ('ṝ', 'ṝ'),
+    ('ṟ', 'ṟ'),
+    ('ṡ', 'ṡ'),
+    ('ṣ', 'ṣ'),
+    ('ṥ', 'ṥ'),
+    ('ṧ', 'ṧ'),
+    ('ṩ', 'ṩ'),
+    ('ṫ', 'ṫ'),
+    ('ṭ', 'ṭ'),
+    ('ṯ', 'ṯ'),
+    ('ṱ', 'ṱ'),
+    ('ṳ', 'ṳ'),
+    ('ṵ', 'ṵ'),
+    ('ṷ', 'ṷ'),
+    ('ṹ', 'ṹ'),
+    ('ṻ', 'ṻ'),
+    ('ṽ', 'ṽ'),
+    ('ṿ', 'ṿ'),
+    ('ẁ', 'ẁ'),
+    ('ẃ', 'ẃ'),
+    ('ẅ', 'ẅ'),
+    ('ẇ', 'ẇ'),
+    ('ẉ', 'ẉ'),
+    ('ẋ', 'ẋ'),
+    ('ẍ', 'ẍ'),
+    ('ẏ', 'ẏ'),
+    ('ẑ', 'ẑ'),
+    ('ẓ', 'ẓ'),
+    ('ẕ', 'ẝ'),
+    ('ẟ', 'ẟ'),
+    ('ạ', 'ạ'),
+    ('ả', 'ả'),
+    ('ấ', 'ấ'),
+    ('ầ', 'ầ'),
+    ('ẩ', 'ẩ'),
+    ('ẫ', 'ẫ'),
+    ('ậ', 'ậ'),
+    ('ắ', 'ắ'),
+    ('ằ', 'ằ'),
+    ('ẳ', 'ẳ'),
+    ('ẵ', 'ẵ'),
+    ('ặ', 'ặ'),
+    ('ẹ', 'ẹ'),
+    ('ẻ', 'ẻ'),
+    ('ẽ', 'ẽ'),
+    ('ế', 'ế'),
+    ('ề', 'ề'),
+    ('ể', 'ể'),
+    ('ễ', 'ễ'),
+    ('ệ', 'ệ'),
+    ('ỉ', 'ỉ'),
+    ('ị', 'ị'),
+    ('ọ', 'ọ'),
+    ('ỏ', 'ỏ'),
+    ('ố', 'ố'),
+    ('ồ', 'ồ'),
+    ('ổ', 'ổ'),
+    ('ỗ', 'ỗ'),
+    ('ộ', 'ộ'),
+    ('ớ', 'ớ'),
+    ('ờ', 'ờ'),
+    ('ở', 'ở'),
+    ('ỡ', 'ỡ'),
+    ('ợ', 'ợ'),
+    ('ụ', 'ụ'),
+    ('ủ', 'ủ'),
+    ('ứ', 'ứ'),
+    ('ừ', 'ừ'),
+    ('ử', 'ử'),
+    ('ữ', 'ữ'),
+    ('ự', 'ự'),
+    ('ỳ', 'ỳ'),
+    ('ỵ', 'ỵ'),
+    ('ỷ', 'ỷ'),
+    ('ỹ', 'ỹ'),
+    ('ỻ', 'ỻ'),
+    ('ỽ', 'ỽ'),
+    ('ỿ', 'ἇ'),
+    ('ἐ', 'ἕ'),
+    ('ἠ', 'ἧ'),
+    ('ἰ', 'ἷ'),
+    ('ὀ', 'ὅ'),
+    ('ὐ', 'ὗ'),
+    ('ὠ', 'ὧ'),
+    ('ὰ', 'ώ'),
+    ('ᾀ', 'ᾇ'),
+    ('ᾐ', 'ᾗ'),
+    ('ᾠ', 'ᾧ'),
+    ('ᾰ', 'ᾴ'),
+    ('ᾶ', 'ᾷ'),
+    ('ι', 'ι'),
+    ('ῂ', 'ῄ'),
+    ('ῆ', 'ῇ'),
+    ('ῐ', 'ΐ'),
+    ('ῖ', 'ῗ'),
+    ('ῠ', 'ῧ'),
+    ('ῲ', 'ῴ'),
+    ('ῶ', 'ῷ'),
+    ('ℊ', 'ℊ'),
+    ('ℎ', 'ℏ'),
+    ('ℓ', 'ℓ'),
+    ('ℯ', 'ℯ'),
+    ('ℴ', 'ℴ'),
+    ('ℹ', 'ℹ'),
+    ('ℼ', 'ℽ'),
+    ('ⅆ', 'ⅉ'),
+    ('ⅎ', 'ⅎ'),
+    ('ↄ', 'ↄ'),
+    ('ⰰ', 'ⱟ'),
+    ('ⱡ', 'ⱡ'),
+    ('ⱥ', 'ⱦ'),
+    ('ⱨ', 'ⱨ'),
+    ('ⱪ', 'ⱪ'),
+    ('ⱬ', 'ⱬ'),
+    ('ⱱ', 'ⱱ'),
+    ('ⱳ', 'ⱴ'),
+    ('ⱶ', 'ⱻ'),
+    ('ⲁ', 'ⲁ'),
+    ('ⲃ', 'ⲃ'),
+    ('ⲅ', 'ⲅ'),
+    ('ⲇ', 'ⲇ'),
+    ('ⲉ', 'ⲉ'),
+    ('ⲋ', 'ⲋ'),
+    ('ⲍ', 'ⲍ'),
+    ('ⲏ', 'ⲏ'),
+    ('ⲑ', 'ⲑ'),
+    ('ⲓ', 'ⲓ'),
+    ('ⲕ', 'ⲕ'),
+    ('ⲗ', 'ⲗ'),
+    ('ⲙ', 'ⲙ'),
+    ('ⲛ', 'ⲛ'),
+    ('ⲝ', 'ⲝ'),
+    ('ⲟ', 'ⲟ'),
+    ('ⲡ', 'ⲡ'),
+    ('ⲣ', 'ⲣ'),
+    ('ⲥ', 'ⲥ'),
+    ('ⲧ', 'ⲧ'),
+    ('ⲩ', 'ⲩ'),
+    ('ⲫ', 'ⲫ'),
+    ('ⲭ', 'ⲭ'),
+    ('ⲯ', 'ⲯ'),
+    ('ⲱ', 'ⲱ'),
+    ('ⲳ', 'ⲳ'),
+    ('ⲵ', 'ⲵ'),
+    ('ⲷ', 'ⲷ'),
+    ('ⲹ', 'ⲹ'),
+    ('ⲻ', 'ⲻ'),
+    ('ⲽ', 'ⲽ'),
+    ('ⲿ', 'ⲿ'),
+    ('ⳁ', 'ⳁ'),
+    ('ⳃ', 'ⳃ'),
+    ('ⳅ', 'ⳅ'),
+    ('ⳇ', 'ⳇ'),
+    ('ⳉ', 'ⳉ'),
+    ('ⳋ', 'ⳋ'),
+    ('ⳍ', 'ⳍ'),
+    ('ⳏ', 'ⳏ'),
+    ('ⳑ', 'ⳑ'),
+    ('ⳓ', 'ⳓ'),
+    ('ⳕ', 'ⳕ'),
+    ('ⳗ', 'ⳗ'),
+    ('ⳙ', 'ⳙ'),
+    ('ⳛ', 'ⳛ'),
+    ('ⳝ', 'ⳝ'),
+    ('ⳟ', 'ⳟ'),
+    ('ⳡ', 'ⳡ'),
+    ('ⳣ', 'ⳤ'),
+    ('ⳬ', 'ⳬ'),
+    ('ⳮ', 'ⳮ'),
+    ('ⳳ', 'ⳳ'),
+    ('ⴀ', 'ⴥ'),
+    ('ⴧ', 'ⴧ'),
+    ('ⴭ', 'ⴭ'),
+    ('ꙁ', 'ꙁ'),
+    ('ꙃ', 'ꙃ'),
+    ('ꙅ', 'ꙅ'),
+    ('ꙇ', 'ꙇ'),
+    ('ꙉ', 'ꙉ'),
+    ('ꙋ', 'ꙋ'),
+    ('ꙍ', 'ꙍ'),
+    ('ꙏ', 'ꙏ'),
+    ('ꙑ', 'ꙑ'),
+    ('ꙓ', 'ꙓ'),
+    ('ꙕ', 'ꙕ'),
+    ('ꙗ', 'ꙗ'),
+    ('ꙙ', 'ꙙ'),
+    ('ꙛ', 'ꙛ'),
+    ('ꙝ', 'ꙝ'),
+    ('ꙟ', 'ꙟ'),
+    ('ꙡ', 'ꙡ'),
+    ('ꙣ', 'ꙣ'),
+    ('ꙥ', 'ꙥ'),
+    ('ꙧ', 'ꙧ'),
+    ('ꙩ', 'ꙩ'),
+    ('ꙫ', 'ꙫ'),
+    ('ꙭ', 'ꙭ'),
+    ('ꚁ', 'ꚁ'),
+    ('ꚃ', 'ꚃ'),
+    ('ꚅ', 'ꚅ'),
+    ('ꚇ', 'ꚇ'),
+    ('ꚉ', 'ꚉ'),
+    ('ꚋ', 'ꚋ'),
+    ('ꚍ', 'ꚍ'),
+    ('ꚏ', 'ꚏ'),
+    ('ꚑ', 'ꚑ'),
+    ('ꚓ', 'ꚓ'),
+    ('ꚕ', 'ꚕ'),
+    ('ꚗ', 'ꚗ'),
+    ('ꚙ', 'ꚙ'),
+    ('ꚛ', 'ꚛ'),
+    ('ꜣ', 'ꜣ'),
+    ('ꜥ', 'ꜥ'),
+    ('ꜧ', 'ꜧ'),
+    ('ꜩ', 'ꜩ'),
+    ('ꜫ', 'ꜫ'),
+    ('ꜭ', 'ꜭ'),
+    ('ꜯ', 'ꜱ'),
+    ('ꜳ', 'ꜳ'),
+    ('ꜵ', 'ꜵ'),
+    ('ꜷ', 'ꜷ'),
+    ('ꜹ', 'ꜹ'),
+    ('ꜻ', 'ꜻ'),
+    ('ꜽ', 'ꜽ'),
+    ('ꜿ', 'ꜿ'),
+    ('ꝁ', 'ꝁ'),
+    ('ꝃ', 'ꝃ'),
+    ('ꝅ', 'ꝅ'),
+    ('ꝇ', 'ꝇ'),
+    ('ꝉ', 'ꝉ'),
+    ('ꝋ', 'ꝋ'),
+    ('ꝍ', 'ꝍ'),
+    ('ꝏ', 'ꝏ'),
+    ('ꝑ', 'ꝑ'),
+    ('ꝓ', 'ꝓ'),
+    ('ꝕ', 'ꝕ'),
+    ('ꝗ', 'ꝗ'),
+    ('ꝙ', 'ꝙ'),
+    ('ꝛ', 'ꝛ'),
+    ('ꝝ', 'ꝝ'),
+    ('ꝟ', 'ꝟ'),
+    ('ꝡ', 'ꝡ'),
+    ('ꝣ', 'ꝣ'),
+    ('ꝥ', 'ꝥ'),
+    ('ꝧ', 'ꝧ'),
+    ('ꝩ', 'ꝩ'),
+    ('ꝫ', 'ꝫ'),
+    ('ꝭ', 'ꝭ'),
+    ('ꝯ', 'ꝯ'),
+    ('ꝱ', 'ꝸ'),
+    ('ꝺ', 'ꝺ'),
+    ('ꝼ', 'ꝼ'),
+    ('ꝿ', 'ꝿ'),
+    ('ꞁ', 'ꞁ'),
+    ('ꞃ', 'ꞃ'),
+    ('ꞅ', 'ꞅ'),
+    ('ꞇ', 'ꞇ'),
+    ('ꞌ', 'ꞌ'),
+    ('ꞎ', 'ꞎ'),
+    ('ꞑ', 'ꞑ'),
+    ('ꞓ', 'ꞕ'),
+    ('ꞗ', 'ꞗ'),
+    ('ꞙ', 'ꞙ'),
+    ('ꞛ', 'ꞛ'),
+    ('ꞝ', 'ꞝ'),
+    ('ꞟ', 'ꞟ'),
+    ('ꞡ', 'ꞡ'),
+    ('ꞣ', 'ꞣ'),
+    ('ꞥ', 'ꞥ'),
+    ('ꞧ', 'ꞧ'),
+    ('ꞩ', 'ꞩ'),
+    ('ꞯ', 'ꞯ'),
+    ('ꞵ', 'ꞵ'),
+    ('ꞷ', 'ꞷ'),
+    ('ꞹ', 'ꞹ'),
+    ('ꞻ', 'ꞻ'),
+    ('ꞽ', 'ꞽ'),
+    ('ꞿ', 'ꞿ'),
+    ('ꟁ', 'ꟁ'),
+    ('ꟃ', 'ꟃ'),
+    ('ꟈ', 'ꟈ'),
+    ('ꟊ', 'ꟊ'),
+    ('ꟑ', 'ꟑ'),
+    ('ꟓ', 'ꟓ'),
+    ('ꟕ', 'ꟕ'),
+    ('ꟗ', 'ꟗ'),
+    ('ꟙ', 'ꟙ'),
+    ('ꟶ', 'ꟶ'),
+    ('ꟺ', 'ꟺ'),
+    ('ꬰ', 'ꭚ'),
+    ('ꭠ', 'ꭨ'),
+    ('ꭰ', 'ꮿ'),
+    ('ﬀ', 'ﬆ'),
+    ('ﬓ', 'ﬗ'),
+    ('ａ', 'ｚ'),
+    ('𐐨', '𐑏'),
+    ('𐓘', '𐓻'),
+    ('𐖗', '𐖡'),
+    ('𐖣', '𐖱'),
+    ('𐖳', '𐖹'),
+    ('𐖻', '𐖼'),
+    ('𐳀', '𐳲'),
+    ('𑣀', '𑣟'),
+    ('𖹠', '𖹿'),
+    ('𝐚', '𝐳'),
+    ('𝑎', '𝑔'),
+    ('𝑖', '𝑧'),
+    ('𝒂', '𝒛'),
+    ('𝒶', '𝒹'),
+    ('𝒻', '𝒻'),
+    ('𝒽', '𝓃'),
+    ('𝓅', '𝓏'),
+    ('𝓪', '𝔃'),
+    ('𝔞', '𝔷'),
+    ('𝕒', '𝕫'),
+    ('𝖆', '𝖟'),
+    ('𝖺', '𝗓'),
+    ('𝗮', '𝘇'),
+    ('𝘢', '𝘻'),
+    ('𝙖', '𝙯'),
+    ('𝚊', '𝚥'),
+    ('𝛂', '𝛚'),
+    ('𝛜', '𝛡'),
+    ('𝛼', '𝜔'),
+    ('𝜖', '𝜛'),
+    ('𝜶', '𝝎'),
+    ('𝝐', '𝝕'),
+    ('𝝰', '𝞈'),
+    ('𝞊', '𝞏'),
+    ('𝞪', '𝟂'),
+    ('𝟄', '𝟉'),
+    ('𝟋', '𝟋'),
+    ('𝼀', '𝼉'),
+    ('𝼋', '𝼞'),
+    ('𝼥', '𝼪'),
+    ('𞤢', '𞥃'),
+];
+
+pub const MARK: &'static [(char, char)] = &[
+    ('\u{300}', '\u{36f}'),
+    ('\u{483}', '\u{489}'),
+    ('\u{591}', '\u{5bd}'),
+    ('\u{5bf}', '\u{5bf}'),
+    ('\u{5c1}', '\u{5c2}'),
+    ('\u{5c4}', '\u{5c5}'),
+    ('\u{5c7}', '\u{5c7}'),
+    ('\u{610}', '\u{61a}'),
+    ('\u{64b}', '\u{65f}'),
+    ('\u{670}', '\u{670}'),
+    ('\u{6d6}', '\u{6dc}'),
+    ('\u{6df}', '\u{6e4}'),
+    ('\u{6e7}', '\u{6e8}'),
+    ('\u{6ea}', '\u{6ed}'),
+    ('\u{711}', '\u{711}'),
+    ('\u{730}', '\u{74a}'),
+    ('\u{7a6}', '\u{7b0}'),
+    ('\u{7eb}', '\u{7f3}'),
+    ('\u{7fd}', '\u{7fd}'),
+    ('\u{816}', '\u{819}'),
+    ('\u{81b}', '\u{823}'),
+    ('\u{825}', '\u{827}'),
+    ('\u{829}', '\u{82d}'),
+    ('\u{859}', '\u{85b}'),
+    ('\u{898}', '\u{89f}'),
+    ('\u{8ca}', '\u{8e1}'),
+    ('\u{8e3}', 'ः'),
+    ('\u{93a}', '\u{93c}'),
+    ('ा', 'ॏ'),
+    ('\u{951}', '\u{957}'),
+    ('\u{962}', '\u{963}'),
+    ('\u{981}', 'ঃ'),
+    ('\u{9bc}', '\u{9bc}'),
+    ('\u{9be}', '\u{9c4}'),
+    ('ে', 'ৈ'),
+    ('ো', '\u{9cd}'),
+    ('\u{9d7}', '\u{9d7}'),
+    ('\u{9e2}', '\u{9e3}'),
+    ('\u{9fe}', '\u{9fe}'),
+    ('\u{a01}', 'ਃ'),
+    ('\u{a3c}', '\u{a3c}'),
+    ('ਾ', '\u{a42}'),
+    ('\u{a47}', '\u{a48}'),
+    ('\u{a4b}', '\u{a4d}'),
+    ('\u{a51}', '\u{a51}'),
+    ('\u{a70}', '\u{a71}'),
+    ('\u{a75}', '\u{a75}'),
+    ('\u{a81}', 'ઃ'),
+    ('\u{abc}', '\u{abc}'),
+    ('ા', '\u{ac5}'),
+    ('\u{ac7}', 'ૉ'),
+    ('ો', '\u{acd}'),
+    ('\u{ae2}', '\u{ae3}'),
+    ('\u{afa}', '\u{aff}'),
+    ('\u{b01}', 'ଃ'),
+    ('\u{b3c}', '\u{b3c}'),
+    ('\u{b3e}', '\u{b44}'),
+    ('େ', 'ୈ'),
+    ('ୋ', '\u{b4d}'),
+    ('\u{b55}', '\u{b57}'),
+    ('\u{b62}', '\u{b63}'),
+    ('\u{b82}', '\u{b82}'),
+    ('\u{bbe}', 'ூ'),
+    ('ெ', 'ை'),
+    ('ொ', '\u{bcd}'),
+    ('\u{bd7}', '\u{bd7}'),
+    ('\u{c00}', '\u{c04}'),
+    ('\u{c3c}', '\u{c3c}'),
+    ('\u{c3e}', 'ౄ'),
+    ('\u{c46}', '\u{c48}'),
+    ('\u{c4a}', '\u{c4d}'),
+    ('\u{c55}', '\u{c56}'),
+    ('\u{c62}', '\u{c63}'),
+    ('\u{c81}', 'ಃ'),
+    ('\u{cbc}', '\u{cbc}'),
+    ('ಾ', 'ೄ'),
+    ('\u{cc6}', 'ೈ'),
+    ('ೊ', '\u{ccd}'),
+    ('\u{cd5}', '\u{cd6}'),
+    ('\u{ce2}', '\u{ce3}'),
+    ('ೳ', 'ೳ'),
+    ('\u{d00}', 'ഃ'),
+    ('\u{d3b}', '\u{d3c}'),
+    ('\u{d3e}', '\u{d44}'),
+    ('െ', 'ൈ'),
+    ('ൊ', '\u{d4d}'),
+    ('\u{d57}', '\u{d57}'),
+    ('\u{d62}', '\u{d63}'),
+    ('\u{d81}', 'ඃ'),
+    ('\u{dca}', '\u{dca}'),
+    ('\u{dcf}', '\u{dd4}'),
+    ('\u{dd6}', '\u{dd6}'),
+    ('ෘ', '\u{ddf}'),
+    ('ෲ', 'ෳ'),
+    ('\u{e31}', '\u{e31}'),
+    ('\u{e34}', '\u{e3a}'),
+    ('\u{e47}', '\u{e4e}'),
+    ('\u{eb1}', '\u{eb1}'),
+    ('\u{eb4}', '\u{ebc}'),
+    ('\u{ec8}', '\u{ece}'),
+    ('\u{f18}', '\u{f19}'),
+    ('\u{f35}', '\u{f35}'),
+    ('\u{f37}', '\u{f37}'),
+    ('\u{f39}', '\u{f39}'),
+    ('༾', '༿'),
+    ('\u{f71}', '\u{f84}'),
+    ('\u{f86}', '\u{f87}'),
+    ('\u{f8d}', '\u{f97}'),
+    ('\u{f99}', '\u{fbc}'),
+    ('\u{fc6}', '\u{fc6}'),
+    ('ါ', '\u{103e}'),
+    ('ၖ', '\u{1059}'),
+    ('\u{105e}', '\u{1060}'),
+    ('ၢ', 'ၤ'),
+    ('ၧ', 'ၭ'),
+    ('\u{1071}', '\u{1074}'),
+    ('\u{1082}', '\u{108d}'),
+    ('ႏ', 'ႏ'),
+    ('ႚ', '\u{109d}'),
+    ('\u{135d}', '\u{135f}'),
+    ('\u{1712}', '᜕'),
+    ('\u{1732}', '᜴'),
+    ('\u{1752}', '\u{1753}'),
+    ('\u{1772}', '\u{1773}'),
+    ('\u{17b4}', '\u{17d3}'),
+    ('\u{17dd}', '\u{17dd}'),
+    ('\u{180b}', '\u{180d}'),
+    ('\u{180f}', '\u{180f}'),
+    ('\u{1885}', '\u{1886}'),
+    ('\u{18a9}', '\u{18a9}'),
+    ('\u{1920}', 'ᤫ'),
+    ('ᤰ', '\u{193b}'),
+    ('\u{1a17}', '\u{1a1b}'),
+    ('ᩕ', '\u{1a5e}'),
+    ('\u{1a60}', '\u{1a7c}'),
+    ('\u{1a7f}', '\u{1a7f}'),
+    ('\u{1ab0}', '\u{1ace}'),
+    ('\u{1b00}', 'ᬄ'),
+    ('\u{1b34}', '᭄'),
+    ('\u{1b6b}', '\u{1b73}'),
+    ('\u{1b80}', 'ᮂ'),
+    ('ᮡ', '\u{1bad}'),
+    ('\u{1be6}', '᯳'),
+    ('ᰤ', '\u{1c37}'),
+    ('\u{1cd0}', '\u{1cd2}'),
+    ('\u{1cd4}', '\u{1ce8}'),
+    ('\u{1ced}', '\u{1ced}'),
+    ('\u{1cf4}', '\u{1cf4}'),
+    ('᳷', '\u{1cf9}'),
+    ('\u{1dc0}', '\u{1dff}'),
+    ('\u{20d0}', '\u{20f0}'),
+    ('\u{2cef}', '\u{2cf1}'),
+    ('\u{2d7f}', '\u{2d7f}'),
+    ('\u{2de0}', '\u{2dff}'),
+    ('\u{302a}', '\u{302f}'),
+    ('\u{3099}', '\u{309a}'),
+    ('\u{a66f}', '\u{a672}'),
+    ('\u{a674}', '\u{a67d}'),
+    ('\u{a69e}', '\u{a69f}'),
+    ('\u{a6f0}', '\u{a6f1}'),
+    ('\u{a802}', '\u{a802}'),
+    ('\u{a806}', '\u{a806}'),
+    ('\u{a80b}', '\u{a80b}'),
+    ('ꠣ', 'ꠧ'),
+    ('\u{a82c}', '\u{a82c}'),
+    ('ꢀ', 'ꢁ'),
+    ('ꢴ', '\u{a8c5}'),
+    ('\u{a8e0}', '\u{a8f1}'),
+    ('\u{a8ff}', '\u{a8ff}'),
+    ('\u{a926}', '\u{a92d}'),
+    ('\u{a947}', '꥓'),
+    ('\u{a980}', 'ꦃ'),
+    ('\u{a9b3}', '꧀'),
+    ('\u{a9e5}', '\u{a9e5}'),
+    ('\u{aa29}', '\u{aa36}'),
+    ('\u{aa43}', '\u{aa43}'),
+    ('\u{aa4c}', 'ꩍ'),
+    ('ꩻ', 'ꩽ'),
+    ('\u{aab0}', '\u{aab0}'),
+    ('\u{aab2}', '\u{aab4}'),
+    ('\u{aab7}', '\u{aab8}'),
+    ('\u{aabe}', '\u{aabf}'),
+    ('\u{aac1}', '\u{aac1}'),
+    ('ꫫ', 'ꫯ'),
+    ('ꫵ', '\u{aaf6}'),
+    ('ꯣ', 'ꯪ'),
+    ('꯬', '\u{abed}'),
+    ('\u{fb1e}', '\u{fb1e}'),
+    ('\u{fe00}', '\u{fe0f}'),
+    ('\u{fe20}', '\u{fe2f}'),
+    ('\u{101fd}', '\u{101fd}'),
+    ('\u{102e0}', '\u{102e0}'),
+    ('\u{10376}', '\u{1037a}'),
+    ('\u{10a01}', '\u{10a03}'),
+    ('\u{10a05}', '\u{10a06}'),
+    ('\u{10a0c}', '\u{10a0f}'),
+    ('\u{10a38}', '\u{10a3a}'),
+    ('\u{10a3f}', '\u{10a3f}'),
+    ('\u{10ae5}', '\u{10ae6}'),
+    ('\u{10d24}', '\u{10d27}'),
+    ('\u{10eab}', '\u{10eac}'),
+    ('\u{10efd}', '\u{10eff}'),
+    ('\u{10f46}', '\u{10f50}'),
+    ('\u{10f82}', '\u{10f85}'),
+    ('𑀀', '𑀂'),
+    ('\u{11038}', '\u{11046}'),
+    ('\u{11070}', '\u{11070}'),
+    ('\u{11073}', '\u{11074}'),
+    ('\u{1107f}', '𑂂'),
+    ('𑂰', '\u{110ba}'),
+    ('\u{110c2}', '\u{110c2}'),
+    ('\u{11100}', '\u{11102}'),
+    ('\u{11127}', '\u{11134}'),
+    ('𑅅', '𑅆'),
+    ('\u{11173}', '\u{11173}'),
+    ('\u{11180}', '𑆂'),
+    ('𑆳', '𑇀'),
+    ('\u{111c9}', '\u{111cc}'),
+    ('𑇎', '\u{111cf}'),
+    ('𑈬', '\u{11237}'),
+    ('\u{1123e}', '\u{1123e}'),
+    ('\u{11241}', '\u{11241}'),
+    ('\u{112df}', '\u{112ea}'),
+    ('\u{11300}', '𑌃'),
+    ('\u{1133b}', '\u{1133c}'),
+    ('\u{1133e}', '𑍄'),
+    ('𑍇', '𑍈'),
+    ('𑍋', '𑍍'),
+    ('\u{11357}', '\u{11357}'),
+    ('𑍢', '𑍣'),
+    ('\u{11366}', '\u{1136c}'),
+    ('\u{11370}', '\u{11374}'),
+    ('𑐵', '\u{11446}'),
+    ('\u{1145e}', '\u{1145e}'),
+    ('\u{114b0}', '\u{114c3}'),
+    ('\u{115af}', '\u{115b5}'),
+    ('𑖸', '\u{115c0}'),
+    ('\u{115dc}', '\u{115dd}'),
+    ('𑘰', '\u{11640}'),
+    ('\u{116ab}', '\u{116b7}'),
+    ('\u{1171d}', '\u{1172b}'),
+    ('𑠬', '\u{1183a}'),
+    ('\u{11930}', '𑤵'),
+    ('𑤷', '𑤸'),
+    ('\u{1193b}', '\u{1193e}'),
+    ('𑥀', '𑥀'),
+    ('𑥂', '\u{11943}'),
+    ('𑧑', '\u{119d7}'),
+    ('\u{119da}', '\u{119e0}'),
+    ('𑧤', '𑧤'),
+    ('\u{11a01}', '\u{11a0a}'),
+    ('\u{11a33}', '𑨹'),
+    ('\u{11a3b}', '\u{11a3e}'),
+    ('\u{11a47}', '\u{11a47}'),
+    ('\u{11a51}', '\u{11a5b}'),
+    ('\u{11a8a}', '\u{11a99}'),
+    ('𑰯', '\u{11c36}'),
+    ('\u{11c38}', '\u{11c3f}'),
+    ('\u{11c92}', '\u{11ca7}'),
+    ('𑲩', '\u{11cb6}'),
+    ('\u{11d31}', '\u{11d36}'),
+    ('\u{11d3a}', '\u{11d3a}'),
+    ('\u{11d3c}', '\u{11d3d}'),
+    ('\u{11d3f}', '\u{11d45}'),
+    ('\u{11d47}', '\u{11d47}'),
+    ('𑶊', '𑶎'),
+    ('\u{11d90}', '\u{11d91}'),
+    ('𑶓', '\u{11d97}'),
+    ('\u{11ef3}', '𑻶'),
+    ('\u{11f00}', '\u{11f01}'),
+    ('𑼃', '𑼃'),
+    ('𑼴', '\u{11f3a}'),
+    ('𑼾', '\u{11f42}'),
+    ('\u{13440}', '\u{13440}'),
+    ('\u{13447}', '\u{13455}'),
+    ('\u{16af0}', '\u{16af4}'),
+    ('\u{16b30}', '\u{16b36}'),
+    ('\u{16f4f}', '\u{16f4f}'),
+    ('𖽑', '𖾇'),
+    ('\u{16f8f}', '\u{16f92}'),
+    ('\u{16fe4}', '\u{16fe4}'),
+    ('𖿰', '𖿱'),
+    ('\u{1bc9d}', '\u{1bc9e}'),
+    ('\u{1cf00}', '\u{1cf2d}'),
+    ('\u{1cf30}', '\u{1cf46}'),
+    ('\u{1d165}', '\u{1d169}'),
+    ('𝅭', '\u{1d172}'),
+    ('\u{1d17b}', '\u{1d182}'),
+    ('\u{1d185}', '\u{1d18b}'),
+    ('\u{1d1aa}', '\u{1d1ad}'),
+    ('\u{1d242}', '\u{1d244}'),
+    ('\u{1da00}', '\u{1da36}'),
+    ('\u{1da3b}', '\u{1da6c}'),
+    ('\u{1da75}', '\u{1da75}'),
+    ('\u{1da84}', '\u{1da84}'),
+    ('\u{1da9b}', '\u{1da9f}'),
+    ('\u{1daa1}', '\u{1daaf}'),
+    ('\u{1e000}', '\u{1e006}'),
+    ('\u{1e008}', '\u{1e018}'),
+    ('\u{1e01b}', '\u{1e021}'),
+    ('\u{1e023}', '\u{1e024}'),
+    ('\u{1e026}', '\u{1e02a}'),
+    ('\u{1e08f}', '\u{1e08f}'),
+    ('\u{1e130}', '\u{1e136}'),
+    ('\u{1e2ae}', '\u{1e2ae}'),
+    ('\u{1e2ec}', '\u{1e2ef}'),
+    ('\u{1e4ec}', '\u{1e4ef}'),
+    ('\u{1e8d0}', '\u{1e8d6}'),
+    ('\u{1e944}', '\u{1e94a}'),
+    ('\u{e0100}', '\u{e01ef}'),
+];
+
+pub const MATH_SYMBOL: &'static [(char, char)] = &[
+    ('+', '+'),
+    ('<', '>'),
+    ('|', '|'),
+    ('~', '~'),
+    ('¬', '¬'),
+    ('±', '±'),
+    ('×', '×'),
+    ('÷', '÷'),
+    ('϶', '϶'),
+    ('؆', '؈'),
+    ('⁄', '⁄'),
+    ('⁒', '⁒'),
+    ('⁺', '⁼'),
+    ('₊', '₌'),
+    ('℘', '℘'),
+    ('⅀', '⅄'),
+    ('⅋', '⅋'),
+    ('←', '↔'),
+    ('↚', '↛'),
+    ('↠', '↠'),
+    ('↣', '↣'),
+    ('↦', '↦'),
+    ('↮', '↮'),
+    ('⇎', '⇏'),
+    ('⇒', '⇒'),
+    ('⇔', '⇔'),
+    ('⇴', '⋿'),
+    ('⌠', '⌡'),
+    ('⍼', '⍼'),
+    ('⎛', '⎳'),
+    ('⏜', '⏡'),
+    ('▷', '▷'),
+    ('◁', '◁'),
+    ('◸', '◿'),
+    ('♯', '♯'),
+    ('⟀', '⟄'),
+    ('⟇', '⟥'),
+    ('⟰', '⟿'),
+    ('⤀', '⦂'),
+    ('⦙', '⧗'),
+    ('⧜', '⧻'),
+    ('⧾', '⫿'),
+    ('⬰', '⭄'),
+    ('⭇', '⭌'),
+    ('﬩', '﬩'),
+    ('﹢', '﹢'),
+    ('﹤', '﹦'),
+    ('＋', '＋'),
+    ('＜', '＞'),
+    ('｜', '｜'),
+    ('～', '～'),
+    ('￢', '￢'),
+    ('￩', '￬'),
+    ('𝛁', '𝛁'),
+    ('𝛛', '𝛛'),
+    ('𝛻', '𝛻'),
+    ('𝜕', '𝜕'),
+    ('𝜵', '𝜵'),
+    ('𝝏', '𝝏'),
+    ('𝝯', '𝝯'),
+    ('𝞉', '𝞉'),
+    ('𝞩', '𝞩'),
+    ('𝟃', '𝟃'),
+    ('𞻰', '𞻱'),
+];
+
+pub const MODIFIER_LETTER: &'static [(char, char)] = &[
+    ('ʰ', 'ˁ'),
+    ('ˆ', 'ˑ'),
+    ('ˠ', 'ˤ'),
+    ('ˬ', 'ˬ'),
+    ('ˮ', 'ˮ'),
+    ('ʹ', 'ʹ'),
+    ('ͺ', 'ͺ'),
+    ('ՙ', 'ՙ'),
+    ('ـ', 'ـ'),
+    ('ۥ', 'ۦ'),
+    ('ߴ', 'ߵ'),
+    ('ߺ', 'ߺ'),
+    ('ࠚ', 'ࠚ'),
+    ('ࠤ', 'ࠤ'),
+    ('ࠨ', 'ࠨ'),
+    ('ࣉ', 'ࣉ'),
+    ('ॱ', 'ॱ'),
+    ('ๆ', 'ๆ'),
+    ('ໆ', 'ໆ'),
+    ('ჼ', 'ჼ'),
+    ('ៗ', 'ៗ'),
+    ('ᡃ', 'ᡃ'),
+    ('ᪧ', 'ᪧ'),
+    ('ᱸ', 'ᱽ'),
+    ('ᴬ', 'ᵪ'),
+    ('ᵸ', 'ᵸ'),
+    ('ᶛ', 'ᶿ'),
+    ('ⁱ', 'ⁱ'),
+    ('ⁿ', 'ⁿ'),
+    ('ₐ', 'ₜ'),
+    ('ⱼ', 'ⱽ'),
+    ('ⵯ', 'ⵯ'),
+    ('ⸯ', 'ⸯ'),
+    ('々', '々'),
+    ('〱', '〵'),
+    ('〻', '〻'),
+    ('ゝ', 'ゞ'),
+    ('ー', 'ヾ'),
+    ('ꀕ', 'ꀕ'),
+    ('ꓸ', 'ꓽ'),
+    ('ꘌ', 'ꘌ'),
+    ('ꙿ', 'ꙿ'),
+    ('ꚜ', 'ꚝ'),
+    ('ꜗ', 'ꜟ'),
+    ('ꝰ', 'ꝰ'),
+    ('ꞈ', 'ꞈ'),
+    ('ꟲ', 'ꟴ'),
+    ('ꟸ', 'ꟹ'),
+    ('ꧏ', 'ꧏ'),
+    ('ꧦ', 'ꧦ'),
+    ('ꩰ', 'ꩰ'),
+    ('ꫝ', 'ꫝ'),
+    ('ꫳ', 'ꫴ'),
+    ('ꭜ', 'ꭟ'),
+    ('ꭩ', 'ꭩ'),
+    ('ｰ', 'ｰ'),
+    ('\u{ff9e}', '\u{ff9f}'),
+    ('𐞀', '𐞅'),
+    ('𐞇', '𐞰'),
+    ('𐞲', '𐞺'),
+    ('𖭀', '𖭃'),
+    ('𖾓', '𖾟'),
+    ('𖿠', '𖿡'),
+    ('𖿣', '𖿣'),
+    ('𚿰', '𚿳'),
+    ('𚿵', '𚿻'),
+    ('𚿽', '𚿾'),
+    ('𞀰', '𞁭'),
+    ('𞄷', '𞄽'),
+    ('𞓫', '𞓫'),
+    ('𞥋', '𞥋'),
+];
+
+pub const MODIFIER_SYMBOL: &'static [(char, char)] = &[
+    ('^', '^'),
+    ('`', '`'),
+    ('¨', '¨'),
+    ('¯', '¯'),
+    ('´', '´'),
+    ('¸', '¸'),
+    ('˂', '˅'),
+    ('˒', '˟'),
+    ('˥', '˫'),
+    ('˭', '˭'),
+    ('˯', '˿'),
+    ('͵', '͵'),
+    ('΄', '΅'),
+    ('࢈', '࢈'),
+    ('᾽', '᾽'),
+    ('᾿', '῁'),
+    ('῍', '῏'),
+    ('῝', '῟'),
+    ('῭', '`'),
+    ('´', '῾'),
+    ('゛', '゜'),
+    ('꜀', '꜖'),
+    ('꜠', '꜡'),
+    ('꞉', '꞊'),
+    ('꭛', '꭛'),
+    ('꭪', '꭫'),
+    ('﮲', '﯂'),
+    ('＾', '＾'),
+    ('｀', '｀'),
+    ('￣', '￣'),
+    ('🏻', '🏿'),
+];
+
+pub const NONSPACING_MARK: &'static [(char, char)] = &[
+    ('\u{300}', '\u{36f}'),
+    ('\u{483}', '\u{487}'),
+    ('\u{591}', '\u{5bd}'),
+    ('\u{5bf}', '\u{5bf}'),
+    ('\u{5c1}', '\u{5c2}'),
+    ('\u{5c4}', '\u{5c5}'),
+    ('\u{5c7}', '\u{5c7}'),
+    ('\u{610}', '\u{61a}'),
+    ('\u{64b}', '\u{65f}'),
+    ('\u{670}', '\u{670}'),
+    ('\u{6d6}', '\u{6dc}'),
+    ('\u{6df}', '\u{6e4}'),
+    ('\u{6e7}', '\u{6e8}'),
+    ('\u{6ea}', '\u{6ed}'),
+    ('\u{711}', '\u{711}'),
+    ('\u{730}', '\u{74a}'),
+    ('\u{7a6}', '\u{7b0}'),
+    ('\u{7eb}', '\u{7f3}'),
+    ('\u{7fd}', '\u{7fd}'),
+    ('\u{816}', '\u{819}'),
+    ('\u{81b}', '\u{823}'),
+    ('\u{825}', '\u{827}'),
+    ('\u{829}', '\u{82d}'),
+    ('\u{859}', '\u{85b}'),
+    ('\u{898}', '\u{89f}'),
+    ('\u{8ca}', '\u{8e1}'),
+    ('\u{8e3}', '\u{902}'),
+    ('\u{93a}', '\u{93a}'),
+    ('\u{93c}', '\u{93c}'),
+    ('\u{941}', '\u{948}'),
+    ('\u{94d}', '\u{94d}'),
+    ('\u{951}', '\u{957}'),
+    ('\u{962}', '\u{963}'),
+    ('\u{981}', '\u{981}'),
+    ('\u{9bc}', '\u{9bc}'),
+    ('\u{9c1}', '\u{9c4}'),
+    ('\u{9cd}', '\u{9cd}'),
+    ('\u{9e2}', '\u{9e3}'),
+    ('\u{9fe}', '\u{9fe}'),
+    ('\u{a01}', '\u{a02}'),
+    ('\u{a3c}', '\u{a3c}'),
+    ('\u{a41}', '\u{a42}'),
+    ('\u{a47}', '\u{a48}'),
+    ('\u{a4b}', '\u{a4d}'),
+    ('\u{a51}', '\u{a51}'),
+    ('\u{a70}', '\u{a71}'),
+    ('\u{a75}', '\u{a75}'),
+    ('\u{a81}', '\u{a82}'),
+    ('\u{abc}', '\u{abc}'),
+    ('\u{ac1}', '\u{ac5}'),
+    ('\u{ac7}', '\u{ac8}'),
+    ('\u{acd}', '\u{acd}'),
+    ('\u{ae2}', '\u{ae3}'),
+    ('\u{afa}', '\u{aff}'),
+    ('\u{b01}', '\u{b01}'),
+    ('\u{b3c}', '\u{b3c}'),
+    ('\u{b3f}', '\u{b3f}'),
+    ('\u{b41}', '\u{b44}'),
+    ('\u{b4d}', '\u{b4d}'),
+    ('\u{b55}', '\u{b56}'),
+    ('\u{b62}', '\u{b63}'),
+    ('\u{b82}', '\u{b82}'),
+    ('\u{bc0}', '\u{bc0}'),
+    ('\u{bcd}', '\u{bcd}'),
+    ('\u{c00}', '\u{c00}'),
+    ('\u{c04}', '\u{c04}'),
+    ('\u{c3c}', '\u{c3c}'),
+    ('\u{c3e}', '\u{c40}'),
+    ('\u{c46}', '\u{c48}'),
+    ('\u{c4a}', '\u{c4d}'),
+    ('\u{c55}', '\u{c56}'),
+    ('\u{c62}', '\u{c63}'),
+    ('\u{c81}', '\u{c81}'),
+    ('\u{cbc}', '\u{cbc}'),
+    ('\u{cbf}', '\u{cbf}'),
+    ('\u{cc6}', '\u{cc6}'),
+    ('\u{ccc}', '\u{ccd}'),
+    ('\u{ce2}', '\u{ce3}'),
+    ('\u{d00}', '\u{d01}'),
+    ('\u{d3b}', '\u{d3c}'),
+    ('\u{d41}', '\u{d44}'),
+    ('\u{d4d}', '\u{d4d}'),
+    ('\u{d62}', '\u{d63}'),
+    ('\u{d81}', '\u{d81}'),
+    ('\u{dca}', '\u{dca}'),
+    ('\u{dd2}', '\u{dd4}'),
+    ('\u{dd6}', '\u{dd6}'),
+    ('\u{e31}', '\u{e31}'),
+    ('\u{e34}', '\u{e3a}'),
+    ('\u{e47}', '\u{e4e}'),
+    ('\u{eb1}', '\u{eb1}'),
+    ('\u{eb4}', '\u{ebc}'),
+    ('\u{ec8}', '\u{ece}'),
+    ('\u{f18}', '\u{f19}'),
+    ('\u{f35}', '\u{f35}'),
+    ('\u{f37}', '\u{f37}'),
+    ('\u{f39}', '\u{f39}'),
+    ('\u{f71}', '\u{f7e}'),
+    ('\u{f80}', '\u{f84}'),
+    ('\u{f86}', '\u{f87}'),
+    ('\u{f8d}', '\u{f97}'),
+    ('\u{f99}', '\u{fbc}'),
+    ('\u{fc6}', '\u{fc6}'),
+    ('\u{102d}', '\u{1030}'),
+    ('\u{1032}', '\u{1037}'),
+    ('\u{1039}', '\u{103a}'),
+    ('\u{103d}', '\u{103e}'),
+    ('\u{1058}', '\u{1059}'),
+    ('\u{105e}', '\u{1060}'),
+    ('\u{1071}', '\u{1074}'),
+    ('\u{1082}', '\u{1082}'),
+    ('\u{1085}', '\u{1086}'),
+    ('\u{108d}', '\u{108d}'),
+    ('\u{109d}', '\u{109d}'),
+    ('\u{135d}', '\u{135f}'),
+    ('\u{1712}', '\u{1714}'),
+    ('\u{1732}', '\u{1733}'),
+    ('\u{1752}', '\u{1753}'),
+    ('\u{1772}', '\u{1773}'),
+    ('\u{17b4}', '\u{17b5}'),
+    ('\u{17b7}', '\u{17bd}'),
+    ('\u{17c6}', '\u{17c6}'),
+    ('\u{17c9}', '\u{17d3}'),
+    ('\u{17dd}', '\u{17dd}'),
+    ('\u{180b}', '\u{180d}'),
+    ('\u{180f}', '\u{180f}'),
+    ('\u{1885}', '\u{1886}'),
+    ('\u{18a9}', '\u{18a9}'),
+    ('\u{1920}', '\u{1922}'),
+    ('\u{1927}', '\u{1928}'),
+    ('\u{1932}', '\u{1932}'),
+    ('\u{1939}', '\u{193b}'),
+    ('\u{1a17}', '\u{1a18}'),
+    ('\u{1a1b}', '\u{1a1b}'),
+    ('\u{1a56}', '\u{1a56}'),
+    ('\u{1a58}', '\u{1a5e}'),
+    ('\u{1a60}', '\u{1a60}'),
+    ('\u{1a62}', '\u{1a62}'),
+    ('\u{1a65}', '\u{1a6c}'),
+    ('\u{1a73}', '\u{1a7c}'),
+    ('\u{1a7f}', '\u{1a7f}'),
+    ('\u{1ab0}', '\u{1abd}'),
+    ('\u{1abf}', '\u{1ace}'),
+    ('\u{1b00}', '\u{1b03}'),
+    ('\u{1b34}', '\u{1b34}'),
+    ('\u{1b36}', '\u{1b3a}'),
+    ('\u{1b3c}', '\u{1b3c}'),
+    ('\u{1b42}', '\u{1b42}'),
+    ('\u{1b6b}', '\u{1b73}'),
+    ('\u{1b80}', '\u{1b81}'),
+    ('\u{1ba2}', '\u{1ba5}'),
+    ('\u{1ba8}', '\u{1ba9}'),
+    ('\u{1bab}', '\u{1bad}'),
+    ('\u{1be6}', '\u{1be6}'),
+    ('\u{1be8}', '\u{1be9}'),
+    ('\u{1bed}', '\u{1bed}'),
+    ('\u{1bef}', '\u{1bf1}'),
+    ('\u{1c2c}', '\u{1c33}'),
+    ('\u{1c36}', '\u{1c37}'),
+    ('\u{1cd0}', '\u{1cd2}'),
+    ('\u{1cd4}', '\u{1ce0}'),
+    ('\u{1ce2}', '\u{1ce8}'),
+    ('\u{1ced}', '\u{1ced}'),
+    ('\u{1cf4}', '\u{1cf4}'),
+    ('\u{1cf8}', '\u{1cf9}'),
+    ('\u{1dc0}', '\u{1dff}'),
+    ('\u{20d0}', '\u{20dc}'),
+    ('\u{20e1}', '\u{20e1}'),
+    ('\u{20e5}', '\u{20f0}'),
+    ('\u{2cef}', '\u{2cf1}'),
+    ('\u{2d7f}', '\u{2d7f}'),
+    ('\u{2de0}', '\u{2dff}'),
+    ('\u{302a}', '\u{302d}'),
+    ('\u{3099}', '\u{309a}'),
+    ('\u{a66f}', '\u{a66f}'),
+    ('\u{a674}', '\u{a67d}'),
+    ('\u{a69e}', '\u{a69f}'),
+    ('\u{a6f0}', '\u{a6f1}'),
+    ('\u{a802}', '\u{a802}'),
+    ('\u{a806}', '\u{a806}'),
+    ('\u{a80b}', '\u{a80b}'),
+    ('\u{a825}', '\u{a826}'),
+    ('\u{a82c}', '\u{a82c}'),
+    ('\u{a8c4}', '\u{a8c5}'),
+    ('\u{a8e0}', '\u{a8f1}'),
+    ('\u{a8ff}', '\u{a8ff}'),
+    ('\u{a926}', '\u{a92d}'),
+    ('\u{a947}', '\u{a951}'),
+    ('\u{a980}', '\u{a982}'),
+    ('\u{a9b3}', '\u{a9b3}'),
+    ('\u{a9b6}', '\u{a9b9}'),
+    ('\u{a9bc}', '\u{a9bd}'),
+    ('\u{a9e5}', '\u{a9e5}'),
+    ('\u{aa29}', '\u{aa2e}'),
+    ('\u{aa31}', '\u{aa32}'),
+    ('\u{aa35}', '\u{aa36}'),
+    ('\u{aa43}', '\u{aa43}'),
+    ('\u{aa4c}', '\u{aa4c}'),
+    ('\u{aa7c}', '\u{aa7c}'),
+    ('\u{aab0}', '\u{aab0}'),
+    ('\u{aab2}', '\u{aab4}'),
+    ('\u{aab7}', '\u{aab8}'),
+    ('\u{aabe}', '\u{aabf}'),
+    ('\u{aac1}', '\u{aac1}'),
+    ('\u{aaec}', '\u{aaed}'),
+    ('\u{aaf6}', '\u{aaf6}'),
+    ('\u{abe5}', '\u{abe5}'),
+    ('\u{abe8}', '\u{abe8}'),
+    ('\u{abed}', '\u{abed}'),
+    ('\u{fb1e}', '\u{fb1e}'),
+    ('\u{fe00}', '\u{fe0f}'),
+    ('\u{fe20}', '\u{fe2f}'),
+    ('\u{101fd}', '\u{101fd}'),
+    ('\u{102e0}', '\u{102e0}'),
+    ('\u{10376}', '\u{1037a}'),
+    ('\u{10a01}', '\u{10a03}'),
+    ('\u{10a05}', '\u{10a06}'),
+    ('\u{10a0c}', '\u{10a0f}'),
+    ('\u{10a38}', '\u{10a3a}'),
+    ('\u{10a3f}', '\u{10a3f}'),
+    ('\u{10ae5}', '\u{10ae6}'),
+    ('\u{10d24}', '\u{10d27}'),
+    ('\u{10eab}', '\u{10eac}'),
+    ('\u{10efd}', '\u{10eff}'),
+    ('\u{10f46}', '\u{10f50}'),
+    ('\u{10f82}', '\u{10f85}'),
+    ('\u{11001}', '\u{11001}'),
+    ('\u{11038}', '\u{11046}'),
+    ('\u{11070}', '\u{11070}'),
+    ('\u{11073}', '\u{11074}'),
+    ('\u{1107f}', '\u{11081}'),
+    ('\u{110b3}', '\u{110b6}'),
+    ('\u{110b9}', '\u{110ba}'),
+    ('\u{110c2}', '\u{110c2}'),
+    ('\u{11100}', '\u{11102}'),
+    ('\u{11127}', '\u{1112b}'),
+    ('\u{1112d}', '\u{11134}'),
+    ('\u{11173}', '\u{11173}'),
+    ('\u{11180}', '\u{11181}'),
+    ('\u{111b6}', '\u{111be}'),
+    ('\u{111c9}', '\u{111cc}'),
+    ('\u{111cf}', '\u{111cf}'),
+    ('\u{1122f}', '\u{11231}'),
+    ('\u{11234}', '\u{11234}'),
+    ('\u{11236}', '\u{11237}'),
+    ('\u{1123e}', '\u{1123e}'),
+    ('\u{11241}', '\u{11241}'),
+    ('\u{112df}', '\u{112df}'),
+    ('\u{112e3}', '\u{112ea}'),
+    ('\u{11300}', '\u{11301}'),
+    ('\u{1133b}', '\u{1133c}'),
+    ('\u{11340}', '\u{11340}'),
+    ('\u{11366}', '\u{1136c}'),
+    ('\u{11370}', '\u{11374}'),
+    ('\u{11438}', '\u{1143f}'),
+    ('\u{11442}', '\u{11444}'),
+    ('\u{11446}', '\u{11446}'),
+    ('\u{1145e}', '\u{1145e}'),
+    ('\u{114b3}', '\u{114b8}'),
+    ('\u{114ba}', '\u{114ba}'),
+    ('\u{114bf}', '\u{114c0}'),
+    ('\u{114c2}', '\u{114c3}'),
+    ('\u{115b2}', '\u{115b5}'),
+    ('\u{115bc}', '\u{115bd}'),
+    ('\u{115bf}', '\u{115c0}'),
+    ('\u{115dc}', '\u{115dd}'),
+    ('\u{11633}', '\u{1163a}'),
+    ('\u{1163d}', '\u{1163d}'),
+    ('\u{1163f}', '\u{11640}'),
+    ('\u{116ab}', '\u{116ab}'),
+    ('\u{116ad}', '\u{116ad}'),
+    ('\u{116b0}', '\u{116b5}'),
+    ('\u{116b7}', '\u{116b7}'),
+    ('\u{1171d}', '\u{1171f}'),
+    ('\u{11722}', '\u{11725}'),
+    ('\u{11727}', '\u{1172b}'),
+    ('\u{1182f}', '\u{11837}'),
+    ('\u{11839}', '\u{1183a}'),
+    ('\u{1193b}', '\u{1193c}'),
+    ('\u{1193e}', '\u{1193e}'),
+    ('\u{11943}', '\u{11943}'),
+    ('\u{119d4}', '\u{119d7}'),
+    ('\u{119da}', '\u{119db}'),
+    ('\u{119e0}', '\u{119e0}'),
+    ('\u{11a01}', '\u{11a0a}'),
+    ('\u{11a33}', '\u{11a38}'),
+    ('\u{11a3b}', '\u{11a3e}'),
+    ('\u{11a47}', '\u{11a47}'),
+    ('\u{11a51}', '\u{11a56}'),
+    ('\u{11a59}', '\u{11a5b}'),
+    ('\u{11a8a}', '\u{11a96}'),
+    ('\u{11a98}', '\u{11a99}'),
+    ('\u{11c30}', '\u{11c36}'),
+    ('\u{11c38}', '\u{11c3d}'),
+    ('\u{11c3f}', '\u{11c3f}'),
+    ('\u{11c92}', '\u{11ca7}'),
+    ('\u{11caa}', '\u{11cb0}'),
+    ('\u{11cb2}', '\u{11cb3}'),
+    ('\u{11cb5}', '\u{11cb6}'),
+    ('\u{11d31}', '\u{11d36}'),
+    ('\u{11d3a}', '\u{11d3a}'),
+    ('\u{11d3c}', '\u{11d3d}'),
+    ('\u{11d3f}', '\u{11d45}'),
+    ('\u{11d47}', '\u{11d47}'),
+    ('\u{11d90}', '\u{11d91}'),
+    ('\u{11d95}', '\u{11d95}'),
+    ('\u{11d97}', '\u{11d97}'),
+    ('\u{11ef3}', '\u{11ef4}'),
+    ('\u{11f00}', '\u{11f01}'),
+    ('\u{11f36}', '\u{11f3a}'),
+    ('\u{11f40}', '\u{11f40}'),
+    ('\u{11f42}', '\u{11f42}'),
+    ('\u{13440}', '\u{13440}'),
+    ('\u{13447}', '\u{13455}'),
+    ('\u{16af0}', '\u{16af4}'),
+    ('\u{16b30}', '\u{16b36}'),
+    ('\u{16f4f}', '\u{16f4f}'),
+    ('\u{16f8f}', '\u{16f92}'),
+    ('\u{16fe4}', '\u{16fe4}'),
+    ('\u{1bc9d}', '\u{1bc9e}'),
+    ('\u{1cf00}', '\u{1cf2d}'),
+    ('\u{1cf30}', '\u{1cf46}'),
+    ('\u{1d167}', '\u{1d169}'),
+    ('\u{1d17b}', '\u{1d182}'),
+    ('\u{1d185}', '\u{1d18b}'),
+    ('\u{1d1aa}', '\u{1d1ad}'),
+    ('\u{1d242}', '\u{1d244}'),
+    ('\u{1da00}', '\u{1da36}'),
+    ('\u{1da3b}', '\u{1da6c}'),
+    ('\u{1da75}', '\u{1da75}'),
+    ('\u{1da84}', '\u{1da84}'),
+    ('\u{1da9b}', '\u{1da9f}'),
+    ('\u{1daa1}', '\u{1daaf}'),
+    ('\u{1e000}', '\u{1e006}'),
+    ('\u{1e008}', '\u{1e018}'),
+    ('\u{1e01b}', '\u{1e021}'),
+    ('\u{1e023}', '\u{1e024}'),
+    ('\u{1e026}', '\u{1e02a}'),
+    ('\u{1e08f}', '\u{1e08f}'),
+    ('\u{1e130}', '\u{1e136}'),
+    ('\u{1e2ae}', '\u{1e2ae}'),
+    ('\u{1e2ec}', '\u{1e2ef}'),
+    ('\u{1e4ec}', '\u{1e4ef}'),
+    ('\u{1e8d0}', '\u{1e8d6}'),
+    ('\u{1e944}', '\u{1e94a}'),
+    ('\u{e0100}', '\u{e01ef}'),
+];
+
+pub const NUMBER: &'static [(char, char)] = &[
+    ('0', '9'),
+    ('²', '³'),
+    ('¹', '¹'),
+    ('¼', '¾'),
+    ('٠', '٩'),
+    ('۰', '۹'),
+    ('߀', '߉'),
+    ('०', '९'),
+    ('০', '৯'),
+    ('৴', '৹'),
+    ('੦', '੯'),
+    ('૦', '૯'),
+    ('୦', '୯'),
+    ('୲', '୷'),
+    ('௦', '௲'),
+    ('౦', '౯'),
+    ('౸', '౾'),
+    ('೦', '೯'),
+    ('൘', '൞'),
+    ('൦', '൸'),
+    ('෦', '෯'),
+    ('๐', '๙'),
+    ('໐', '໙'),
+    ('༠', '༳'),
+    ('၀', '၉'),
+    ('႐', '႙'),
+    ('፩', '፼'),
+    ('ᛮ', 'ᛰ'),
+    ('០', '៩'),
+    ('៰', '៹'),
+    ('᠐', '᠙'),
+    ('᥆', '᥏'),
+    ('᧐', '᧚'),
+    ('᪀', '᪉'),
+    ('᪐', '᪙'),
+    ('᭐', '᭙'),
+    ('᮰', '᮹'),
+    ('᱀', '᱉'),
+    ('᱐', '᱙'),
+    ('⁰', '⁰'),
+    ('⁴', '⁹'),
+    ('₀', '₉'),
+    ('⅐', 'ↂ'),
+    ('ↅ', '↉'),
+    ('①', '⒛'),
+    ('⓪', '⓿'),
+    ('❶', '➓'),
+    ('⳽', '⳽'),
+    ('〇', '〇'),
+    ('〡', '〩'),
+    ('〸', '〺'),
+    ('㆒', '㆕'),
+    ('㈠', '㈩'),
+    ('㉈', '㉏'),
+    ('㉑', '㉟'),
+    ('㊀', '㊉'),
+    ('㊱', '㊿'),
+    ('꘠', '꘩'),
+    ('ꛦ', 'ꛯ'),
+    ('꠰', '꠵'),
+    ('꣐', '꣙'),
+    ('꤀', '꤉'),
+    ('꧐', '꧙'),
+    ('꧰', '꧹'),
+    ('꩐', '꩙'),
+    ('꯰', '꯹'),
+    ('０', '９'),
+    ('𐄇', '𐄳'),
+    ('𐅀', '𐅸'),
+    ('𐆊', '𐆋'),
+    ('𐋡', '𐋻'),
+    ('𐌠', '𐌣'),
+    ('𐍁', '𐍁'),
+    ('𐍊', '𐍊'),
+    ('𐏑', '𐏕'),
+    ('𐒠', '𐒩'),
+    ('𐡘', '𐡟'),
+    ('𐡹', '𐡿'),
+    ('𐢧', '𐢯'),
+    ('𐣻', '𐣿'),
+    ('𐤖', '𐤛'),
+    ('𐦼', '𐦽'),
+    ('𐧀', '𐧏'),
+    ('𐧒', '𐧿'),
+    ('𐩀', '𐩈'),
+    ('𐩽', '𐩾'),
+    ('𐪝', '𐪟'),
+    ('𐫫', '𐫯'),
+    ('𐭘', '𐭟'),
+    ('𐭸', '𐭿'),
+    ('𐮩', '𐮯'),
+    ('𐳺', '𐳿'),
+    ('𐴰', '𐴹'),
+    ('𐹠', '𐹾'),
+    ('𐼝', '𐼦'),
+    ('𐽑', '𐽔'),
+    ('𐿅', '𐿋'),
+    ('𑁒', '𑁯'),
+    ('𑃰', '𑃹'),
+    ('𑄶', '𑄿'),
+    ('𑇐', '𑇙'),
+    ('𑇡', '𑇴'),
+    ('𑋰', '𑋹'),
+    ('𑑐', '𑑙'),
+    ('𑓐', '𑓙'),
+    ('𑙐', '𑙙'),
+    ('𑛀', '𑛉'),
+    ('𑜰', '𑜻'),
+    ('𑣠', '𑣲'),
+    ('𑥐', '𑥙'),
+    ('𑱐', '𑱬'),
+    ('𑵐', '𑵙'),
+    ('𑶠', '𑶩'),
+    ('𑽐', '𑽙'),
+    ('𑿀', '𑿔'),
+    ('𒐀', '𒑮'),
+    ('𖩠', '𖩩'),
+    ('𖫀', '𖫉'),
+    ('𖭐', '𖭙'),
+    ('𖭛', '𖭡'),
+    ('𖺀', '𖺖'),
+    ('𝋀', '𝋓'),
+    ('𝋠', '𝋳'),
+    ('𝍠', '𝍸'),
+    ('𝟎', '𝟿'),
+    ('𞅀', '𞅉'),
+    ('𞋰', '𞋹'),
+    ('𞓰', '𞓹'),
+    ('𞣇', '𞣏'),
+    ('𞥐', '𞥙'),
+    ('𞱱', '𞲫'),
+    ('𞲭', '𞲯'),
+    ('𞲱', '𞲴'),
+    ('𞴁', '𞴭'),
+    ('𞴯', '𞴽'),
+    ('🄀', '🄌'),
+    ('🯰', '🯹'),
+];
+
+pub const OPEN_PUNCTUATION: &'static [(char, char)] = &[
+    ('(', '('),
+    ('[', '['),
+    ('{', '{'),
+    ('༺', '༺'),
+    ('༼', '༼'),
+    ('᚛', '᚛'),
+    ('‚', '‚'),
+    ('„', '„'),
+    ('⁅', '⁅'),
+    ('⁽', '⁽'),
+    ('₍', '₍'),
+    ('⌈', '⌈'),
+    ('⌊', '⌊'),
+    ('〈', '〈'),
+    ('❨', '❨'),
+    ('❪', '❪'),
+    ('❬', '❬'),
+    ('❮', '❮'),
+    ('❰', '❰'),
+    ('❲', '❲'),
+    ('❴', '❴'),
+    ('⟅', '⟅'),
+    ('⟦', '⟦'),
+    ('⟨', '⟨'),
+    ('⟪', '⟪'),
+    ('⟬', '⟬'),
+    ('⟮', '⟮'),
+    ('⦃', '⦃'),
+    ('⦅', '⦅'),
+    ('⦇', '⦇'),
+    ('⦉', '⦉'),
+    ('⦋', '⦋'),
+    ('⦍', '⦍'),
+    ('⦏', '⦏'),
+    ('⦑', '⦑'),
+    ('⦓', '⦓'),
+    ('⦕', '⦕'),
+    ('⦗', '⦗'),
+    ('⧘', '⧘'),
+    ('⧚', '⧚'),
+    ('⧼', '⧼'),
+    ('⸢', '⸢'),
+    ('⸤', '⸤'),
+    ('⸦', '⸦'),
+    ('⸨', '⸨'),
+    ('⹂', '⹂'),
+    ('⹕', '⹕'),
+    ('⹗', '⹗'),
+    ('⹙', '⹙'),
+    ('⹛', '⹛'),
+    ('〈', '〈'),
+    ('《', '《'),
+    ('「', '「'),
+    ('『', '『'),
+    ('【', '【'),
+    ('〔', '〔'),
+    ('〖', '〖'),
+    ('〘', '〘'),
+    ('〚', '〚'),
+    ('〝', '〝'),
+    ('﴿', '﴿'),
+    ('︗', '︗'),
+    ('︵', '︵'),
+    ('︷', '︷'),
+    ('︹', '︹'),
+    ('︻', '︻'),
+    ('︽', '︽'),
+    ('︿', '︿'),
+    ('﹁', '﹁'),
+    ('﹃', '﹃'),
+    ('﹇', '﹇'),
+    ('﹙', '﹙'),
+    ('﹛', '﹛'),
+    ('﹝', '﹝'),
+    ('（', '（'),
+    ('［', '［'),
+    ('｛', '｛'),
+    ('｟', '｟'),
+    ('｢', '｢'),
+];
+
+pub const OTHER: &'static [(char, char)] = &[
+    ('\0', '\u{1f}'),
+    ('\u{7f}', '\u{9f}'),
+    ('\u{ad}', '\u{ad}'),
+    ('\u{378}', '\u{379}'),
+    ('\u{380}', '\u{383}'),
+    ('\u{38b}', '\u{38b}'),
+    ('\u{38d}', '\u{38d}'),
+    ('\u{3a2}', '\u{3a2}'),
+    ('\u{530}', '\u{530}'),
+    ('\u{557}', '\u{558}'),
+    ('\u{58b}', '\u{58c}'),
+    ('\u{590}', '\u{590}'),
+    ('\u{5c8}', '\u{5cf}'),
+    ('\u{5eb}', '\u{5ee}'),
+    ('\u{5f5}', '\u{605}'),
+    ('\u{61c}', '\u{61c}'),
+    ('\u{6dd}', '\u{6dd}'),
+    ('\u{70e}', '\u{70f}'),
+    ('\u{74b}', '\u{74c}'),
+    ('\u{7b2}', '\u{7bf}'),
+    ('\u{7fb}', '\u{7fc}'),
+    ('\u{82e}', '\u{82f}'),
+    ('\u{83f}', '\u{83f}'),
+    ('\u{85c}', '\u{85d}'),
+    ('\u{85f}', '\u{85f}'),
+    ('\u{86b}', '\u{86f}'),
+    ('\u{88f}', '\u{897}'),
+    ('\u{8e2}', '\u{8e2}'),
+    ('\u{984}', '\u{984}'),
+    ('\u{98d}', '\u{98e}'),
+    ('\u{991}', '\u{992}'),
+    ('\u{9a9}', '\u{9a9}'),
+    ('\u{9b1}', '\u{9b1}'),
+    ('\u{9b3}', '\u{9b5}'),
+    ('\u{9ba}', '\u{9bb}'),
+    ('\u{9c5}', '\u{9c6}'),
+    ('\u{9c9}', '\u{9ca}'),
+    ('\u{9cf}', '\u{9d6}'),
+    ('\u{9d8}', '\u{9db}'),
+    ('\u{9de}', '\u{9de}'),
+    ('\u{9e4}', '\u{9e5}'),
+    ('\u{9ff}', '\u{a00}'),
+    ('\u{a04}', '\u{a04}'),
+    ('\u{a0b}', '\u{a0e}'),
+    ('\u{a11}', '\u{a12}'),
+    ('\u{a29}', '\u{a29}'),
+    ('\u{a31}', '\u{a31}'),
+    ('\u{a34}', '\u{a34}'),
+    ('\u{a37}', '\u{a37}'),
+    ('\u{a3a}', '\u{a3b}'),
+    ('\u{a3d}', '\u{a3d}'),
+    ('\u{a43}', '\u{a46}'),
+    ('\u{a49}', '\u{a4a}'),
+    ('\u{a4e}', '\u{a50}'),
+    ('\u{a52}', '\u{a58}'),
+    ('\u{a5d}', '\u{a5d}'),
+    ('\u{a5f}', '\u{a65}'),
+    ('\u{a77}', '\u{a80}'),
+    ('\u{a84}', '\u{a84}'),
+    ('\u{a8e}', '\u{a8e}'),
+    ('\u{a92}', '\u{a92}'),
+    ('\u{aa9}', '\u{aa9}'),
+    ('\u{ab1}', '\u{ab1}'),
+    ('\u{ab4}', '\u{ab4}'),
+    ('\u{aba}', '\u{abb}'),
+    ('\u{ac6}', '\u{ac6}'),
+    ('\u{aca}', '\u{aca}'),
+    ('\u{ace}', '\u{acf}'),
+    ('\u{ad1}', '\u{adf}'),
+    ('\u{ae4}', '\u{ae5}'),
+    ('\u{af2}', '\u{af8}'),
+    ('\u{b00}', '\u{b00}'),
+    ('\u{b04}', '\u{b04}'),
+    ('\u{b0d}', '\u{b0e}'),
+    ('\u{b11}', '\u{b12}'),
+    ('\u{b29}', '\u{b29}'),
+    ('\u{b31}', '\u{b31}'),
+    ('\u{b34}', '\u{b34}'),
+    ('\u{b3a}', '\u{b3b}'),
+    ('\u{b45}', '\u{b46}'),
+    ('\u{b49}', '\u{b4a}'),
+    ('\u{b4e}', '\u{b54}'),
+    ('\u{b58}', '\u{b5b}'),
+    ('\u{b5e}', '\u{b5e}'),
+    ('\u{b64}', '\u{b65}'),
+    ('\u{b78}', '\u{b81}'),
+    ('\u{b84}', '\u{b84}'),
+    ('\u{b8b}', '\u{b8d}'),
+    ('\u{b91}', '\u{b91}'),
+    ('\u{b96}', '\u{b98}'),
+    ('\u{b9b}', '\u{b9b}'),
+    ('\u{b9d}', '\u{b9d}'),
+    ('\u{ba0}', '\u{ba2}'),
+    ('\u{ba5}', '\u{ba7}'),
+    ('\u{bab}', '\u{bad}'),
+    ('\u{bba}', '\u{bbd}'),
+    ('\u{bc3}', '\u{bc5}'),
+    ('\u{bc9}', '\u{bc9}'),
+    ('\u{bce}', '\u{bcf}'),
+    ('\u{bd1}', '\u{bd6}'),
+    ('\u{bd8}', '\u{be5}'),
+    ('\u{bfb}', '\u{bff}'),
+    ('\u{c0d}', '\u{c0d}'),
+    ('\u{c11}', '\u{c11}'),
+    ('\u{c29}', '\u{c29}'),
+    ('\u{c3a}', '\u{c3b}'),
+    ('\u{c45}', '\u{c45}'),
+    ('\u{c49}', '\u{c49}'),
+    ('\u{c4e}', '\u{c54}'),
+    ('\u{c57}', '\u{c57}'),
+    ('\u{c5b}', '\u{c5c}'),
+    ('\u{c5e}', '\u{c5f}'),
+    ('\u{c64}', '\u{c65}'),
+    ('\u{c70}', '\u{c76}'),
+    ('\u{c8d}', '\u{c8d}'),
+    ('\u{c91}', '\u{c91}'),
+    ('\u{ca9}', '\u{ca9}'),
+    ('\u{cb4}', '\u{cb4}'),
+    ('\u{cba}', '\u{cbb}'),
+    ('\u{cc5}', '\u{cc5}'),
+    ('\u{cc9}', '\u{cc9}'),
+    ('\u{cce}', '\u{cd4}'),
+    ('\u{cd7}', '\u{cdc}'),
+    ('\u{cdf}', '\u{cdf}'),
+    ('\u{ce4}', '\u{ce5}'),
+    ('\u{cf0}', '\u{cf0}'),
+    ('\u{cf4}', '\u{cff}'),
+    ('\u{d0d}', '\u{d0d}'),
+    ('\u{d11}', '\u{d11}'),
+    ('\u{d45}', '\u{d45}'),
+    ('\u{d49}', '\u{d49}'),
+    ('\u{d50}', '\u{d53}'),
+    ('\u{d64}', '\u{d65}'),
+    ('\u{d80}', '\u{d80}'),
+    ('\u{d84}', '\u{d84}'),
+    ('\u{d97}', '\u{d99}'),
+    ('\u{db2}', '\u{db2}'),
+    ('\u{dbc}', '\u{dbc}'),
+    ('\u{dbe}', '\u{dbf}'),
+    ('\u{dc7}', '\u{dc9}'),
+    ('\u{dcb}', '\u{dce}'),
+    ('\u{dd5}', '\u{dd5}'),
+    ('\u{dd7}', '\u{dd7}'),
+    ('\u{de0}', '\u{de5}'),
+    ('\u{df0}', '\u{df1}'),
+    ('\u{df5}', '\u{e00}'),
+    ('\u{e3b}', '\u{e3e}'),
+    ('\u{e5c}', '\u{e80}'),
+    ('\u{e83}', '\u{e83}'),
+    ('\u{e85}', '\u{e85}'),
+    ('\u{e8b}', '\u{e8b}'),
+    ('\u{ea4}', '\u{ea4}'),
+    ('\u{ea6}', '\u{ea6}'),
+    ('\u{ebe}', '\u{ebf}'),
+    ('\u{ec5}', '\u{ec5}'),
+    ('\u{ec7}', '\u{ec7}'),
+    ('\u{ecf}', '\u{ecf}'),
+    ('\u{eda}', '\u{edb}'),
+    ('\u{ee0}', '\u{eff}'),
+    ('\u{f48}', '\u{f48}'),
+    ('\u{f6d}', '\u{f70}'),
+    ('\u{f98}', '\u{f98}'),
+    ('\u{fbd}', '\u{fbd}'),
+    ('\u{fcd}', '\u{fcd}'),
+    ('\u{fdb}', '\u{fff}'),
+    ('\u{10c6}', '\u{10c6}'),
+    ('\u{10c8}', '\u{10cc}'),
+    ('\u{10ce}', '\u{10cf}'),
+    ('\u{1249}', '\u{1249}'),
+    ('\u{124e}', '\u{124f}'),
+    ('\u{1257}', '\u{1257}'),
+    ('\u{1259}', '\u{1259}'),
+    ('\u{125e}', '\u{125f}'),
+    ('\u{1289}', '\u{1289}'),
+    ('\u{128e}', '\u{128f}'),
+    ('\u{12b1}', '\u{12b1}'),
+    ('\u{12b6}', '\u{12b7}'),
+    ('\u{12bf}', '\u{12bf}'),
+    ('\u{12c1}', '\u{12c1}'),
+    ('\u{12c6}', '\u{12c7}'),
+    ('\u{12d7}', '\u{12d7}'),
+    ('\u{1311}', '\u{1311}'),
+    ('\u{1316}', '\u{1317}'),
+    ('\u{135b}', '\u{135c}'),
+    ('\u{137d}', '\u{137f}'),
+    ('\u{139a}', '\u{139f}'),
+    ('\u{13f6}', '\u{13f7}'),
+    ('\u{13fe}', '\u{13ff}'),
+    ('\u{169d}', '\u{169f}'),
+    ('\u{16f9}', '\u{16ff}'),
+    ('\u{1716}', '\u{171e}'),
+    ('\u{1737}', '\u{173f}'),
+    ('\u{1754}', '\u{175f}'),
+    ('\u{176d}', '\u{176d}'),
+    ('\u{1771}', '\u{1771}'),
+    ('\u{1774}', '\u{177f}'),
+    ('\u{17de}', '\u{17df}'),
+    ('\u{17ea}', '\u{17ef}'),
+    ('\u{17fa}', '\u{17ff}'),
+    ('\u{180e}', '\u{180e}'),
+    ('\u{181a}', '\u{181f}'),
+    ('\u{1879}', '\u{187f}'),
+    ('\u{18ab}', '\u{18af}'),
+    ('\u{18f6}', '\u{18ff}'),
+    ('\u{191f}', '\u{191f}'),
+    ('\u{192c}', '\u{192f}'),
+    ('\u{193c}', '\u{193f}'),
+    ('\u{1941}', '\u{1943}'),
+    ('\u{196e}', '\u{196f}'),
+    ('\u{1975}', '\u{197f}'),
+    ('\u{19ac}', '\u{19af}'),
+    ('\u{19ca}', '\u{19cf}'),
+    ('\u{19db}', '\u{19dd}'),
+    ('\u{1a1c}', '\u{1a1d}'),
+    ('\u{1a5f}', '\u{1a5f}'),
+    ('\u{1a7d}', '\u{1a7e}'),
+    ('\u{1a8a}', '\u{1a8f}'),
+    ('\u{1a9a}', '\u{1a9f}'),
+    ('\u{1aae}', '\u{1aaf}'),
+    ('\u{1acf}', '\u{1aff}'),
+    ('\u{1b4d}', '\u{1b4f}'),
+    ('\u{1b7f}', '\u{1b7f}'),
+    ('\u{1bf4}', '\u{1bfb}'),
+    ('\u{1c38}', '\u{1c3a}'),
+    ('\u{1c4a}', '\u{1c4c}'),
+    ('\u{1c89}', '\u{1c8f}'),
+    ('\u{1cbb}', '\u{1cbc}'),
+    ('\u{1cc8}', '\u{1ccf}'),
+    ('\u{1cfb}', '\u{1cff}'),
+    ('\u{1f16}', '\u{1f17}'),
+    ('\u{1f1e}', '\u{1f1f}'),
+    ('\u{1f46}', '\u{1f47}'),
+    ('\u{1f4e}', '\u{1f4f}'),
+    ('\u{1f58}', '\u{1f58}'),
+    ('\u{1f5a}', '\u{1f5a}'),
+    ('\u{1f5c}', '\u{1f5c}'),
+    ('\u{1f5e}', '\u{1f5e}'),
+    ('\u{1f7e}', '\u{1f7f}'),
+    ('\u{1fb5}', '\u{1fb5}'),
+    ('\u{1fc5}', '\u{1fc5}'),
+    ('\u{1fd4}', '\u{1fd5}'),
+    ('\u{1fdc}', '\u{1fdc}'),
+    ('\u{1ff0}', '\u{1ff1}'),
+    ('\u{1ff5}', '\u{1ff5}'),
+    ('\u{1fff}', '\u{1fff}'),
+    ('\u{200b}', '\u{200f}'),
+    ('\u{202a}', '\u{202e}'),
+    ('\u{2060}', '\u{206f}'),
+    ('\u{2072}', '\u{2073}'),
+    ('\u{208f}', '\u{208f}'),
+    ('\u{209d}', '\u{209f}'),
+    ('\u{20c1}', '\u{20cf}'),
+    ('\u{20f1}', '\u{20ff}'),
+    ('\u{218c}', '\u{218f}'),
+    ('\u{2427}', '\u{243f}'),
+    ('\u{244b}', '\u{245f}'),
+    ('\u{2b74}', '\u{2b75}'),
+    ('\u{2b96}', '\u{2b96}'),
+    ('\u{2cf4}', '\u{2cf8}'),
+    ('\u{2d26}', '\u{2d26}'),
+    ('\u{2d28}', '\u{2d2c}'),
+    ('\u{2d2e}', '\u{2d2f}'),
+    ('\u{2d68}', '\u{2d6e}'),
+    ('\u{2d71}', '\u{2d7e}'),
+    ('\u{2d97}', '\u{2d9f}'),
+    ('\u{2da7}', '\u{2da7}'),
+    ('\u{2daf}', '\u{2daf}'),
+    ('\u{2db7}', '\u{2db7}'),
+    ('\u{2dbf}', '\u{2dbf}'),
+    ('\u{2dc7}', '\u{2dc7}'),
+    ('\u{2dcf}', '\u{2dcf}'),
+    ('\u{2dd7}', '\u{2dd7}'),
+    ('\u{2ddf}', '\u{2ddf}'),
+    ('\u{2e5e}', '\u{2e7f}'),
+    ('\u{2e9a}', '\u{2e9a}'),
+    ('\u{2ef4}', '\u{2eff}'),
+    ('\u{2fd6}', '\u{2fef}'),
+    ('\u{2ffc}', '\u{2fff}'),
+    ('\u{3040}', '\u{3040}'),
+    ('\u{3097}', '\u{3098}'),
+    ('\u{3100}', '\u{3104}'),
+    ('\u{3130}', '\u{3130}'),
+    ('\u{318f}', '\u{318f}'),
+    ('\u{31e4}', '\u{31ef}'),
+    ('\u{321f}', '\u{321f}'),
+    ('\u{a48d}', '\u{a48f}'),
+    ('\u{a4c7}', '\u{a4cf}'),
+    ('\u{a62c}', '\u{a63f}'),
+    ('\u{a6f8}', '\u{a6ff}'),
+    ('\u{a7cb}', '\u{a7cf}'),
+    ('\u{a7d2}', '\u{a7d2}'),
+    ('\u{a7d4}', '\u{a7d4}'),
+    ('\u{a7da}', '\u{a7f1}'),
+    ('\u{a82d}', '\u{a82f}'),
+    ('\u{a83a}', '\u{a83f}'),
+    ('\u{a878}', '\u{a87f}'),
+    ('\u{a8c6}', '\u{a8cd}'),
+    ('\u{a8da}', '\u{a8df}'),
+    ('\u{a954}', '\u{a95e}'),
+    ('\u{a97d}', '\u{a97f}'),
+    ('\u{a9ce}', '\u{a9ce}'),
+    ('\u{a9da}', '\u{a9dd}'),
+    ('\u{a9ff}', '\u{a9ff}'),
+    ('\u{aa37}', '\u{aa3f}'),
+    ('\u{aa4e}', '\u{aa4f}'),
+    ('\u{aa5a}', '\u{aa5b}'),
+    ('\u{aac3}', '\u{aada}'),
+    ('\u{aaf7}', '\u{ab00}'),
+    ('\u{ab07}', '\u{ab08}'),
+    ('\u{ab0f}', '\u{ab10}'),
+    ('\u{ab17}', '\u{ab1f}'),
+    ('\u{ab27}', '\u{ab27}'),
+    ('\u{ab2f}', '\u{ab2f}'),
+    ('\u{ab6c}', '\u{ab6f}'),
+    ('\u{abee}', '\u{abef}'),
+    ('\u{abfa}', '\u{abff}'),
+    ('\u{d7a4}', '\u{d7af}'),
+    ('\u{d7c7}', '\u{d7ca}'),
+    ('\u{d7fc}', '\u{f8ff}'),
+    ('\u{fa6e}', '\u{fa6f}'),
+    ('\u{fada}', '\u{faff}'),
+    ('\u{fb07}', '\u{fb12}'),
+    ('\u{fb18}', '\u{fb1c}'),
+    ('\u{fb37}', '\u{fb37}'),
+    ('\u{fb3d}', '\u{fb3d}'),
+    ('\u{fb3f}', '\u{fb3f}'),
+    ('\u{fb42}', '\u{fb42}'),
+    ('\u{fb45}', '\u{fb45}'),
+    ('\u{fbc3}', '\u{fbd2}'),
+    ('\u{fd90}', '\u{fd91}'),
+    ('\u{fdc8}', '\u{fdce}'),
+    ('\u{fdd0}', '\u{fdef}'),
+    ('\u{fe1a}', '\u{fe1f}'),
+    ('\u{fe53}', '\u{fe53}'),
+    ('\u{fe67}', '\u{fe67}'),
+    ('\u{fe6c}', '\u{fe6f}'),
+    ('\u{fe75}', '\u{fe75}'),
+    ('\u{fefd}', '\u{ff00}'),
+    ('\u{ffbf}', '\u{ffc1}'),
+    ('\u{ffc8}', '\u{ffc9}'),
+    ('\u{ffd0}', '\u{ffd1}'),
+    ('\u{ffd8}', '\u{ffd9}'),
+    ('\u{ffdd}', '\u{ffdf}'),
+    ('\u{ffe7}', '\u{ffe7}'),
+    ('\u{ffef}', '\u{fffb}'),
+    ('\u{fffe}', '\u{ffff}'),
+    ('\u{1000c}', '\u{1000c}'),
+    ('\u{10027}', '\u{10027}'),
+    ('\u{1003b}', '\u{1003b}'),
+    ('\u{1003e}', '\u{1003e}'),
+    ('\u{1004e}', '\u{1004f}'),
+    ('\u{1005e}', '\u{1007f}'),
+    ('\u{100fb}', '\u{100ff}'),
+    ('\u{10103}', '\u{10106}'),
+    ('\u{10134}', '\u{10136}'),
+    ('\u{1018f}', '\u{1018f}'),
+    ('\u{1019d}', '\u{1019f}'),
+    ('\u{101a1}', '\u{101cf}'),
+    ('\u{101fe}', '\u{1027f}'),
+    ('\u{1029d}', '\u{1029f}'),
+    ('\u{102d1}', '\u{102df}'),
+    ('\u{102fc}', '\u{102ff}'),
+    ('\u{10324}', '\u{1032c}'),
+    ('\u{1034b}', '\u{1034f}'),
+    ('\u{1037b}', '\u{1037f}'),
+    ('\u{1039e}', '\u{1039e}'),
+    ('\u{103c4}', '\u{103c7}'),
+    ('\u{103d6}', '\u{103ff}'),
+    ('\u{1049e}', '\u{1049f}'),
+    ('\u{104aa}', '\u{104af}'),
+    ('\u{104d4}', '\u{104d7}'),
+    ('\u{104fc}', '\u{104ff}'),
+    ('\u{10528}', '\u{1052f}'),
+    ('\u{10564}', '\u{1056e}'),
+    ('\u{1057b}', '\u{1057b}'),
+    ('\u{1058b}', '\u{1058b}'),
+    ('\u{10593}', '\u{10593}'),
+    ('\u{10596}', '\u{10596}'),
+    ('\u{105a2}', '\u{105a2}'),
+    ('\u{105b2}', '\u{105b2}'),
+    ('\u{105ba}', '\u{105ba}'),
+    ('\u{105bd}', '\u{105ff}'),
+    ('\u{10737}', '\u{1073f}'),
+    ('\u{10756}', '\u{1075f}'),
+    ('\u{10768}', '\u{1077f}'),
+    ('\u{10786}', '\u{10786}'),
+    ('\u{107b1}', '\u{107b1}'),
+    ('\u{107bb}', '\u{107ff}'),
+    ('\u{10806}', '\u{10807}'),
+    ('\u{10809}', '\u{10809}'),
+    ('\u{10836}', '\u{10836}'),
+    ('\u{10839}', '\u{1083b}'),
+    ('\u{1083d}', '\u{1083e}'),
+    ('\u{10856}', '\u{10856}'),
+    ('\u{1089f}', '\u{108a6}'),
+    ('\u{108b0}', '\u{108df}'),
+    ('\u{108f3}', '\u{108f3}'),
+    ('\u{108f6}', '\u{108fa}'),
+    ('\u{1091c}', '\u{1091e}'),
+    ('\u{1093a}', '\u{1093e}'),
+    ('\u{10940}', '\u{1097f}'),
+    ('\u{109b8}', '\u{109bb}'),
+    ('\u{109d0}', '\u{109d1}'),
+    ('\u{10a04}', '\u{10a04}'),
+    ('\u{10a07}', '\u{10a0b}'),
+    ('\u{10a14}', '\u{10a14}'),
+    ('\u{10a18}', '\u{10a18}'),
+    ('\u{10a36}', '\u{10a37}'),
+    ('\u{10a3b}', '\u{10a3e}'),
+    ('\u{10a49}', '\u{10a4f}'),
+    ('\u{10a59}', '\u{10a5f}'),
+    ('\u{10aa0}', '\u{10abf}'),
+    ('\u{10ae7}', '\u{10aea}'),
+    ('\u{10af7}', '\u{10aff}'),
+    ('\u{10b36}', '\u{10b38}'),
+    ('\u{10b56}', '\u{10b57}'),
+    ('\u{10b73}', '\u{10b77}'),
+    ('\u{10b92}', '\u{10b98}'),
+    ('\u{10b9d}', '\u{10ba8}'),
+    ('\u{10bb0}', '\u{10bff}'),
+    ('\u{10c49}', '\u{10c7f}'),
+    ('\u{10cb3}', '\u{10cbf}'),
+    ('\u{10cf3}', '\u{10cf9}'),
+    ('\u{10d28}', '\u{10d2f}'),
+    ('\u{10d3a}', '\u{10e5f}'),
+    ('\u{10e7f}', '\u{10e7f}'),
+    ('\u{10eaa}', '\u{10eaa}'),
+    ('\u{10eae}', '\u{10eaf}'),
+    ('\u{10eb2}', '\u{10efc}'),
+    ('\u{10f28}', '\u{10f2f}'),
+    ('\u{10f5a}', '\u{10f6f}'),
+    ('\u{10f8a}', '\u{10faf}'),
+    ('\u{10fcc}', '\u{10fdf}'),
+    ('\u{10ff7}', '\u{10fff}'),
+    ('\u{1104e}', '\u{11051}'),
+    ('\u{11076}', '\u{1107e}'),
+    ('\u{110bd}', '\u{110bd}'),
+    ('\u{110c3}', '\u{110cf}'),
+    ('\u{110e9}', '\u{110ef}'),
+    ('\u{110fa}', '\u{110ff}'),
+    ('\u{11135}', '\u{11135}'),
+    ('\u{11148}', '\u{1114f}'),
+    ('\u{11177}', '\u{1117f}'),
+    ('\u{111e0}', '\u{111e0}'),
+    ('\u{111f5}', '\u{111ff}'),
+    ('\u{11212}', '\u{11212}'),
+    ('\u{11242}', '\u{1127f}'),
+    ('\u{11287}', '\u{11287}'),
+    ('\u{11289}', '\u{11289}'),
+    ('\u{1128e}', '\u{1128e}'),
+    ('\u{1129e}', '\u{1129e}'),
+    ('\u{112aa}', '\u{112af}'),
+    ('\u{112eb}', '\u{112ef}'),
+    ('\u{112fa}', '\u{112ff}'),
+    ('\u{11304}', '\u{11304}'),
+    ('\u{1130d}', '\u{1130e}'),
+    ('\u{11311}', '\u{11312}'),
+    ('\u{11329}', '\u{11329}'),
+    ('\u{11331}', '\u{11331}'),
+    ('\u{11334}', '\u{11334}'),
+    ('\u{1133a}', '\u{1133a}'),
+    ('\u{11345}', '\u{11346}'),
+    ('\u{11349}', '\u{1134a}'),
+    ('\u{1134e}', '\u{1134f}'),
+    ('\u{11351}', '\u{11356}'),
+    ('\u{11358}', '\u{1135c}'),
+    ('\u{11364}', '\u{11365}'),
+    ('\u{1136d}', '\u{1136f}'),
+    ('\u{11375}', '\u{113ff}'),
+    ('\u{1145c}', '\u{1145c}'),
+    ('\u{11462}', '\u{1147f}'),
+    ('\u{114c8}', '\u{114cf}'),
+    ('\u{114da}', '\u{1157f}'),
+    ('\u{115b6}', '\u{115b7}'),
+    ('\u{115de}', '\u{115ff}'),
+    ('\u{11645}', '\u{1164f}'),
+    ('\u{1165a}', '\u{1165f}'),
+    ('\u{1166d}', '\u{1167f}'),
+    ('\u{116ba}', '\u{116bf}'),
+    ('\u{116ca}', '\u{116ff}'),
+    ('\u{1171b}', '\u{1171c}'),
+    ('\u{1172c}', '\u{1172f}'),
+    ('\u{11747}', '\u{117ff}'),
+    ('\u{1183c}', '\u{1189f}'),
+    ('\u{118f3}', '\u{118fe}'),
+    ('\u{11907}', '\u{11908}'),
+    ('\u{1190a}', '\u{1190b}'),
+    ('\u{11914}', '\u{11914}'),
+    ('\u{11917}', '\u{11917}'),
+    ('\u{11936}', '\u{11936}'),
+    ('\u{11939}', '\u{1193a}'),
+    ('\u{11947}', '\u{1194f}'),
+    ('\u{1195a}', '\u{1199f}'),
+    ('\u{119a8}', '\u{119a9}'),
+    ('\u{119d8}', '\u{119d9}'),
+    ('\u{119e5}', '\u{119ff}'),
+    ('\u{11a48}', '\u{11a4f}'),
+    ('\u{11aa3}', '\u{11aaf}'),
+    ('\u{11af9}', '\u{11aff}'),
+    ('\u{11b0a}', '\u{11bff}'),
+    ('\u{11c09}', '\u{11c09}'),
+    ('\u{11c37}', '\u{11c37}'),
+    ('\u{11c46}', '\u{11c4f}'),
+    ('\u{11c6d}', '\u{11c6f}'),
+    ('\u{11c90}', '\u{11c91}'),
+    ('\u{11ca8}', '\u{11ca8}'),
+    ('\u{11cb7}', '\u{11cff}'),
+    ('\u{11d07}', '\u{11d07}'),
+    ('\u{11d0a}', '\u{11d0a}'),
+    ('\u{11d37}', '\u{11d39}'),
+    ('\u{11d3b}', '\u{11d3b}'),
+    ('\u{11d3e}', '\u{11d3e}'),
+    ('\u{11d48}', '\u{11d4f}'),
+    ('\u{11d5a}', '\u{11d5f}'),
+    ('\u{11d66}', '\u{11d66}'),
+    ('\u{11d69}', '\u{11d69}'),
+    ('\u{11d8f}', '\u{11d8f}'),
+    ('\u{11d92}', '\u{11d92}'),
+    ('\u{11d99}', '\u{11d9f}'),
+    ('\u{11daa}', '\u{11edf}'),
+    ('\u{11ef9}', '\u{11eff}'),
+    ('\u{11f11}', '\u{11f11}'),
+    ('\u{11f3b}', '\u{11f3d}'),
+    ('\u{11f5a}', '\u{11faf}'),
+    ('\u{11fb1}', '\u{11fbf}'),
+    ('\u{11ff2}', '\u{11ffe}'),
+    ('\u{1239a}', '\u{123ff}'),
+    ('\u{1246f}', '\u{1246f}'),
+    ('\u{12475}', '\u{1247f}'),
+    ('\u{12544}', '\u{12f8f}'),
+    ('\u{12ff3}', '\u{12fff}'),
+    ('\u{13430}', '\u{1343f}'),
+    ('\u{13456}', '\u{143ff}'),
+    ('\u{14647}', '\u{167ff}'),
+    ('\u{16a39}', '\u{16a3f}'),
+    ('\u{16a5f}', '\u{16a5f}'),
+    ('\u{16a6a}', '\u{16a6d}'),
+    ('\u{16abf}', '\u{16abf}'),
+    ('\u{16aca}', '\u{16acf}'),
+    ('\u{16aee}', '\u{16aef}'),
+    ('\u{16af6}', '\u{16aff}'),
+    ('\u{16b46}', '\u{16b4f}'),
+    ('\u{16b5a}', '\u{16b5a}'),
+    ('\u{16b62}', '\u{16b62}'),
+    ('\u{16b78}', '\u{16b7c}'),
+    ('\u{16b90}', '\u{16e3f}'),
+    ('\u{16e9b}', '\u{16eff}'),
+    ('\u{16f4b}', '\u{16f4e}'),
+    ('\u{16f88}', '\u{16f8e}'),
+    ('\u{16fa0}', '\u{16fdf}'),
+    ('\u{16fe5}', '\u{16fef}'),
+    ('\u{16ff2}', '\u{16fff}'),
+    ('\u{187f8}', '\u{187ff}'),
+    ('\u{18cd6}', '\u{18cff}'),
+    ('\u{18d09}', '\u{1afef}'),
+    ('\u{1aff4}', '\u{1aff4}'),
+    ('\u{1affc}', '\u{1affc}'),
+    ('\u{1afff}', '\u{1afff}'),
+    ('\u{1b123}', '\u{1b131}'),
+    ('\u{1b133}', '\u{1b14f}'),
+    ('\u{1b153}', '\u{1b154}'),
+    ('\u{1b156}', '\u{1b163}'),
+    ('\u{1b168}', '\u{1b16f}'),
+    ('\u{1b2fc}', '\u{1bbff}'),
+    ('\u{1bc6b}', '\u{1bc6f}'),
+    ('\u{1bc7d}', '\u{1bc7f}'),
+    ('\u{1bc89}', '\u{1bc8f}'),
+    ('\u{1bc9a}', '\u{1bc9b}'),
+    ('\u{1bca0}', '\u{1ceff}'),
+    ('\u{1cf2e}', '\u{1cf2f}'),
+    ('\u{1cf47}', '\u{1cf4f}'),
+    ('\u{1cfc4}', '\u{1cfff}'),
+    ('\u{1d0f6}', '\u{1d0ff}'),
+    ('\u{1d127}', '\u{1d128}'),
+    ('\u{1d173}', '\u{1d17a}'),
+    ('\u{1d1eb}', '\u{1d1ff}'),
+    ('\u{1d246}', '\u{1d2bf}'),
+    ('\u{1d2d4}', '\u{1d2df}'),
+    ('\u{1d2f4}', '\u{1d2ff}'),
+    ('\u{1d357}', '\u{1d35f}'),
+    ('\u{1d379}', '\u{1d3ff}'),
+    ('\u{1d455}', '\u{1d455}'),
+    ('\u{1d49d}', '\u{1d49d}'),
+    ('\u{1d4a0}', '\u{1d4a1}'),
+    ('\u{1d4a3}', '\u{1d4a4}'),
+    ('\u{1d4a7}', '\u{1d4a8}'),
+    ('\u{1d4ad}', '\u{1d4ad}'),
+    ('\u{1d4ba}', '\u{1d4ba}'),
+    ('\u{1d4bc}', '\u{1d4bc}'),
+    ('\u{1d4c4}', '\u{1d4c4}'),
+    ('\u{1d506}', '\u{1d506}'),
+    ('\u{1d50b}', '\u{1d50c}'),
+    ('\u{1d515}', '\u{1d515}'),
+    ('\u{1d51d}', '\u{1d51d}'),
+    ('\u{1d53a}', '\u{1d53a}'),
+    ('\u{1d53f}', '\u{1d53f}'),
+    ('\u{1d545}', '\u{1d545}'),
+    ('\u{1d547}', '\u{1d549}'),
+    ('\u{1d551}', '\u{1d551}'),
+    ('\u{1d6a6}', '\u{1d6a7}'),
+    ('\u{1d7cc}', '\u{1d7cd}'),
+    ('\u{1da8c}', '\u{1da9a}'),
+    ('\u{1daa0}', '\u{1daa0}'),
+    ('\u{1dab0}', '\u{1deff}'),
+    ('\u{1df1f}', '\u{1df24}'),
+    ('\u{1df2b}', '\u{1dfff}'),
+    ('\u{1e007}', '\u{1e007}'),
+    ('\u{1e019}', '\u{1e01a}'),
+    ('\u{1e022}', '\u{1e022}'),
+    ('\u{1e025}', '\u{1e025}'),
+    ('\u{1e02b}', '\u{1e02f}'),
+    ('\u{1e06e}', '\u{1e08e}'),
+    ('\u{1e090}', '\u{1e0ff}'),
+    ('\u{1e12d}', '\u{1e12f}'),
+    ('\u{1e13e}', '\u{1e13f}'),
+    ('\u{1e14a}', '\u{1e14d}'),
+    ('\u{1e150}', '\u{1e28f}'),
+    ('\u{1e2af}', '\u{1e2bf}'),
+    ('\u{1e2fa}', '\u{1e2fe}'),
+    ('\u{1e300}', '\u{1e4cf}'),
+    ('\u{1e4fa}', '\u{1e7df}'),
+    ('\u{1e7e7}', '\u{1e7e7}'),
+    ('\u{1e7ec}', '\u{1e7ec}'),
+    ('\u{1e7ef}', '\u{1e7ef}'),
+    ('\u{1e7ff}', '\u{1e7ff}'),
+    ('\u{1e8c5}', '\u{1e8c6}'),
+    ('\u{1e8d7}', '\u{1e8ff}'),
+    ('\u{1e94c}', '\u{1e94f}'),
+    ('\u{1e95a}', '\u{1e95d}'),
+    ('\u{1e960}', '\u{1ec70}'),
+    ('\u{1ecb5}', '\u{1ed00}'),
+    ('\u{1ed3e}', '\u{1edff}'),
+    ('\u{1ee04}', '\u{1ee04}'),
+    ('\u{1ee20}', '\u{1ee20}'),
+    ('\u{1ee23}', '\u{1ee23}'),
+    ('\u{1ee25}', '\u{1ee26}'),
+    ('\u{1ee28}', '\u{1ee28}'),
+    ('\u{1ee33}', '\u{1ee33}'),
+    ('\u{1ee38}', '\u{1ee38}'),
+    ('\u{1ee3a}', '\u{1ee3a}'),
+    ('\u{1ee3c}', '\u{1ee41}'),
+    ('\u{1ee43}', '\u{1ee46}'),
+    ('\u{1ee48}', '\u{1ee48}'),
+    ('\u{1ee4a}', '\u{1ee4a}'),
+    ('\u{1ee4c}', '\u{1ee4c}'),
+    ('\u{1ee50}', '\u{1ee50}'),
+    ('\u{1ee53}', '\u{1ee53}'),
+    ('\u{1ee55}', '\u{1ee56}'),
+    ('\u{1ee58}', '\u{1ee58}'),
+    ('\u{1ee5a}', '\u{1ee5a}'),
+    ('\u{1ee5c}', '\u{1ee5c}'),
+    ('\u{1ee5e}', '\u{1ee5e}'),
+    ('\u{1ee60}', '\u{1ee60}'),
+    ('\u{1ee63}', '\u{1ee63}'),
+    ('\u{1ee65}', '\u{1ee66}'),
+    ('\u{1ee6b}', '\u{1ee6b}'),
+    ('\u{1ee73}', '\u{1ee73}'),
+    ('\u{1ee78}', '\u{1ee78}'),
+    ('\u{1ee7d}', '\u{1ee7d}'),
+    ('\u{1ee7f}', '\u{1ee7f}'),
+    ('\u{1ee8a}', '\u{1ee8a}'),
+    ('\u{1ee9c}', '\u{1eea0}'),
+    ('\u{1eea4}', '\u{1eea4}'),
+    ('\u{1eeaa}', '\u{1eeaa}'),
+    ('\u{1eebc}', '\u{1eeef}'),
+    ('\u{1eef2}', '\u{1efff}'),
+    ('\u{1f02c}', '\u{1f02f}'),
+    ('\u{1f094}', '\u{1f09f}'),
+    ('\u{1f0af}', '\u{1f0b0}'),
+    ('\u{1f0c0}', '\u{1f0c0}'),
+    ('\u{1f0d0}', '\u{1f0d0}'),
+    ('\u{1f0f6}', '\u{1f0ff}'),
+    ('\u{1f1ae}', '\u{1f1e5}'),
+    ('\u{1f203}', '\u{1f20f}'),
+    ('\u{1f23c}', '\u{1f23f}'),
+    ('\u{1f249}', '\u{1f24f}'),
+    ('\u{1f252}', '\u{1f25f}'),
+    ('\u{1f266}', '\u{1f2ff}'),
+    ('\u{1f6d8}', '\u{1f6db}'),
+    ('\u{1f6ed}', '\u{1f6ef}'),
+    ('\u{1f6fd}', '\u{1f6ff}'),
+    ('\u{1f777}', '\u{1f77a}'),
+    ('\u{1f7da}', '\u{1f7df}'),
+    ('\u{1f7ec}', '\u{1f7ef}'),
+    ('\u{1f7f1}', '\u{1f7ff}'),
+    ('\u{1f80c}', '\u{1f80f}'),
+    ('\u{1f848}', '\u{1f84f}'),
+    ('\u{1f85a}', '\u{1f85f}'),
+    ('\u{1f888}', '\u{1f88f}'),
+    ('\u{1f8ae}', '\u{1f8af}'),
+    ('\u{1f8b2}', '\u{1f8ff}'),
+    ('\u{1fa54}', '\u{1fa5f}'),
+    ('\u{1fa6e}', '\u{1fa6f}'),
+    ('\u{1fa7d}', '\u{1fa7f}'),
+    ('\u{1fa89}', '\u{1fa8f}'),
+    ('\u{1fabe}', '\u{1fabe}'),
+    ('\u{1fac6}', '\u{1facd}'),
+    ('\u{1fadc}', '\u{1fadf}'),
+    ('\u{1fae9}', '\u{1faef}'),
+    ('\u{1faf9}', '\u{1faff}'),
+    ('\u{1fb93}', '\u{1fb93}'),
+    ('\u{1fbcb}', '\u{1fbef}'),
+    ('\u{1fbfa}', '\u{1ffff}'),
+    ('\u{2a6e0}', '\u{2a6ff}'),
+    ('\u{2b73a}', '\u{2b73f}'),
+    ('\u{2b81e}', '\u{2b81f}'),
+    ('\u{2cea2}', '\u{2ceaf}'),
+    ('\u{2ebe1}', '\u{2f7ff}'),
+    ('\u{2fa1e}', '\u{2ffff}'),
+    ('\u{3134b}', '\u{3134f}'),
+    ('\u{323b0}', '\u{e00ff}'),
+    ('\u{e01f0}', '\u{10ffff}'),
+];
+
+pub const OTHER_LETTER: &'static [(char, char)] = &[
+    ('ª', 'ª'),
+    ('º', 'º'),
+    ('ƻ', 'ƻ'),
+    ('ǀ', 'ǃ'),
+    ('ʔ', 'ʔ'),
+    ('א', 'ת'),
+    ('ׯ', 'ײ'),
+    ('ؠ', 'ؿ'),
+    ('ف', 'ي'),
+    ('ٮ', 'ٯ'),
+    ('ٱ', 'ۓ'),
+    ('ە', 'ە'),
+    ('ۮ', 'ۯ'),
+    ('ۺ', 'ۼ'),
+    ('ۿ', 'ۿ'),
+    ('ܐ', 'ܐ'),
+    ('ܒ', 'ܯ'),
+    ('ݍ', 'ޥ'),
+    ('ޱ', 'ޱ'),
+    ('ߊ', 'ߪ'),
+    ('ࠀ', 'ࠕ'),
+    ('ࡀ', 'ࡘ'),
+    ('ࡠ', 'ࡪ'),
+    ('ࡰ', 'ࢇ'),
+    ('ࢉ', 'ࢎ'),
+    ('ࢠ', 'ࣈ'),
+    ('ऄ', 'ह'),
+    ('ऽ', 'ऽ'),
+    ('ॐ', 'ॐ'),
+    ('क़', 'ॡ'),
+    ('ॲ', 'ঀ'),
+    ('অ', 'ঌ'),
+    ('এ', 'ঐ'),
+    ('ও', 'ন'),
+    ('প', 'র'),
+    ('ল', 'ল'),
+    ('শ', 'হ'),
+    ('ঽ', 'ঽ'),
+    ('ৎ', 'ৎ'),
+    ('ড়', 'ঢ়'),
+    ('য়', 'ৡ'),
+    ('ৰ', 'ৱ'),
+    ('ৼ', 'ৼ'),
+    ('ਅ', 'ਊ'),
+    ('ਏ', 'ਐ'),
+    ('ਓ', 'ਨ'),
+    ('ਪ', 'ਰ'),
+    ('ਲ', 'ਲ਼'),
+    ('ਵ', 'ਸ਼'),
+    ('ਸ', 'ਹ'),
+    ('ਖ਼', 'ੜ'),
+    ('ਫ਼', 'ਫ਼'),
+    ('ੲ', 'ੴ'),
+    ('અ', 'ઍ'),
+    ('એ', 'ઑ'),
+    ('ઓ', 'ન'),
+    ('પ', 'ર'),
+    ('લ', 'ળ'),
+    ('વ', 'હ'),
+    ('ઽ', 'ઽ'),
+    ('ૐ', 'ૐ'),
+    ('ૠ', 'ૡ'),
+    ('ૹ', 'ૹ'),
+    ('ଅ', 'ଌ'),
+    ('ଏ', 'ଐ'),
+    ('ଓ', 'ନ'),
+    ('ପ', 'ର'),
+    ('ଲ', 'ଳ'),
+    ('ଵ', 'ହ'),
+    ('ଽ', 'ଽ'),
+    ('ଡ଼', 'ଢ଼'),
+    ('ୟ', 'ୡ'),
+    ('ୱ', 'ୱ'),
+    ('ஃ', 'ஃ'),
+    ('அ', 'ஊ'),
+    ('எ', 'ஐ'),
+    ('ஒ', 'க'),
+    ('ங', 'ச'),
+    ('ஜ', 'ஜ'),
+    ('ஞ', 'ட'),
+    ('ண', 'த'),
+    ('ந', 'ப'),
+    ('ம', 'ஹ'),
+    ('ௐ', 'ௐ'),
+    ('అ', 'ఌ'),
+    ('ఎ', 'ఐ'),
+    ('ఒ', 'న'),
+    ('ప', 'హ'),
+    ('ఽ', 'ఽ'),
+    ('ౘ', 'ౚ'),
+    ('ౝ', 'ౝ'),
+    ('ౠ', 'ౡ'),
+    ('ಀ', 'ಀ'),
+    ('ಅ', 'ಌ'),
+    ('ಎ', 'ಐ'),
+    ('ಒ', 'ನ'),
+    ('ಪ', 'ಳ'),
+    ('ವ', 'ಹ'),
+    ('ಽ', 'ಽ'),
+    ('ೝ', 'ೞ'),
+    ('ೠ', 'ೡ'),
+    ('ೱ', 'ೲ'),
+    ('ഄ', 'ഌ'),
+    ('എ', 'ഐ'),
+    ('ഒ', 'ഺ'),
+    ('ഽ', 'ഽ'),
+    ('ൎ', 'ൎ'),
+    ('ൔ', 'ൖ'),
+    ('ൟ', 'ൡ'),
+    ('ൺ', 'ൿ'),
+    ('අ', 'ඖ'),
+    ('ක', 'න'),
+    ('ඳ', 'ර'),
+    ('ල', 'ල'),
+    ('ව', 'ෆ'),
+    ('ก', 'ะ'),
+    ('า', 'ำ'),
+    ('เ', 'ๅ'),
+    ('ກ', 'ຂ'),
+    ('ຄ', 'ຄ'),
+    ('ຆ', 'ຊ'),
+    ('ຌ', 'ຣ'),
+    ('ລ', 'ລ'),
+    ('ວ', 'ະ'),
+    ('າ', 'ຳ'),
+    ('ຽ', 'ຽ'),
+    ('ເ', 'ໄ'),
+    ('ໜ', 'ໟ'),
+    ('ༀ', 'ༀ'),
+    ('ཀ', 'ཇ'),
+    ('ཉ', 'ཬ'),
+    ('ྈ', 'ྌ'),
+    ('က', 'ဪ'),
+    ('ဿ', 'ဿ'),
+    ('ၐ', 'ၕ'),
+    ('ၚ', 'ၝ'),
+    ('ၡ', 'ၡ'),
+    ('ၥ', 'ၦ'),
+    ('ၮ', 'ၰ'),
+    ('ၵ', 'ႁ'),
+    ('ႎ', 'ႎ'),
+    ('ᄀ', 'ቈ'),
+    ('ቊ', 'ቍ'),
+    ('ቐ', 'ቖ'),
+    ('ቘ', 'ቘ'),
+    ('ቚ', 'ቝ'),
+    ('በ', 'ኈ'),
+    ('ኊ', 'ኍ'),
+    ('ነ', 'ኰ'),
+    ('ኲ', 'ኵ'),
+    ('ኸ', 'ኾ'),
+    ('ዀ', 'ዀ'),
+    ('ዂ', 'ዅ'),
+    ('ወ', 'ዖ'),
+    ('ዘ', 'ጐ'),
+    ('ጒ', 'ጕ'),
+    ('ጘ', 'ፚ'),
+    ('ᎀ', 'ᎏ'),
+    ('ᐁ', 'ᙬ'),
+    ('ᙯ', 'ᙿ'),
+    ('ᚁ', 'ᚚ'),
+    ('ᚠ', 'ᛪ'),
+    ('ᛱ', 'ᛸ'),
+    ('ᜀ', 'ᜑ'),
+    ('ᜟ', 'ᜱ'),
+    ('ᝀ', 'ᝑ'),
+    ('ᝠ', 'ᝬ'),
+    ('ᝮ', 'ᝰ'),
+    ('ក', 'ឳ'),
+    ('ៜ', 'ៜ'),
+    ('ᠠ', 'ᡂ'),
+    ('ᡄ', 'ᡸ'),
+    ('ᢀ', 'ᢄ'),
+    ('ᢇ', 'ᢨ'),
+    ('ᢪ', 'ᢪ'),
+    ('ᢰ', 'ᣵ'),
+    ('ᤀ', 'ᤞ'),
+    ('ᥐ', 'ᥭ'),
+    ('ᥰ', 'ᥴ'),
+    ('ᦀ', 'ᦫ'),
+    ('ᦰ', 'ᧉ'),
+    ('ᨀ', 'ᨖ'),
+    ('ᨠ', 'ᩔ'),
+    ('ᬅ', 'ᬳ'),
+    ('ᭅ', 'ᭌ'),
+    ('ᮃ', 'ᮠ'),
+    ('ᮮ', 'ᮯ'),
+    ('ᮺ', 'ᯥ'),
+    ('ᰀ', 'ᰣ'),
+    ('ᱍ', 'ᱏ'),
+    ('ᱚ', 'ᱷ'),
+    ('ᳩ', 'ᳬ'),
+    ('ᳮ', 'ᳳ'),
+    ('ᳵ', 'ᳶ'),
+    ('ᳺ', 'ᳺ'),
+    ('ℵ', 'ℸ'),
+    ('ⴰ', 'ⵧ'),
+    ('ⶀ', 'ⶖ'),
+    ('ⶠ', 'ⶦ'),
+    ('ⶨ', 'ⶮ'),
+    ('ⶰ', 'ⶶ'),
+    ('ⶸ', 'ⶾ'),
+    ('ⷀ', 'ⷆ'),
+    ('ⷈ', 'ⷎ'),
+    ('ⷐ', 'ⷖ'),
+    ('ⷘ', 'ⷞ'),
+    ('〆', '〆'),
+    ('〼', '〼'),
+    ('ぁ', 'ゖ'),
+    ('ゟ', 'ゟ'),
+    ('ァ', 'ヺ'),
+    ('ヿ', 'ヿ'),
+    ('ㄅ', 'ㄯ'),
+    ('ㄱ', 'ㆎ'),
+    ('ㆠ', 'ㆿ'),
+    ('ㇰ', 'ㇿ'),
+    ('㐀', '䶿'),
+    ('一', 'ꀔ'),
+    ('ꀖ', 'ꒌ'),
+    ('ꓐ', 'ꓷ'),
+    ('ꔀ', 'ꘋ'),
+    ('ꘐ', 'ꘟ'),
+    ('ꘪ', 'ꘫ'),
+    ('ꙮ', 'ꙮ'),
+    ('ꚠ', 'ꛥ'),
+    ('ꞏ', 'ꞏ'),
+    ('ꟷ', 'ꟷ'),
+    ('ꟻ', 'ꠁ'),
+    ('ꠃ', 'ꠅ'),
+    ('ꠇ', 'ꠊ'),
+    ('ꠌ', 'ꠢ'),
+    ('ꡀ', 'ꡳ'),
+    ('ꢂ', 'ꢳ'),
+    ('ꣲ', 'ꣷ'),
+    ('ꣻ', 'ꣻ'),
+    ('ꣽ', 'ꣾ'),
+    ('ꤊ', 'ꤥ'),
+    ('ꤰ', 'ꥆ'),
+    ('ꥠ', 'ꥼ'),
+    ('ꦄ', 'ꦲ'),
+    ('ꧠ', 'ꧤ'),
+    ('ꧧ', 'ꧯ'),
+    ('ꧺ', 'ꧾ'),
+    ('ꨀ', 'ꨨ'),
+    ('ꩀ', 'ꩂ'),
+    ('ꩄ', 'ꩋ'),
+    ('ꩠ', 'ꩯ'),
+    ('ꩱ', 'ꩶ'),
+    ('ꩺ', 'ꩺ'),
+    ('ꩾ', 'ꪯ'),
+    ('ꪱ', 'ꪱ'),
+    ('ꪵ', 'ꪶ'),
+    ('ꪹ', 'ꪽ'),
+    ('ꫀ', 'ꫀ'),
+    ('ꫂ', 'ꫂ'),
+    ('ꫛ', 'ꫜ'),
+    ('ꫠ', 'ꫪ'),
+    ('ꫲ', 'ꫲ'),
+    ('ꬁ', 'ꬆ'),
+    ('ꬉ', 'ꬎ'),
+    ('ꬑ', 'ꬖ'),
+    ('ꬠ', 'ꬦ'),
+    ('ꬨ', 'ꬮ'),
+    ('ꯀ', 'ꯢ'),
+    ('가', '힣'),
+    ('ힰ', 'ퟆ'),
+    ('ퟋ', 'ퟻ'),
+    ('豈', '舘'),
+    ('並', '龎'),
+    ('יִ', 'יִ'),
+    ('ײַ', 'ﬨ'),
+    ('שׁ', 'זּ'),
+    ('טּ', 'לּ'),
+    ('מּ', 'מּ'),
+    ('נּ', 'סּ'),
+    ('ףּ', 'פּ'),
+    ('צּ', 'ﮱ'),
+    ('ﯓ', 'ﴽ'),
+    ('ﵐ', 'ﶏ'),
+    ('ﶒ', 'ﷇ'),
+    ('ﷰ', 'ﷻ'),
+    ('ﹰ', 'ﹴ'),
+    ('ﹶ', 'ﻼ'),
+    ('ｦ', 'ｯ'),
+    ('ｱ', 'ﾝ'),
+    ('ﾠ', 'ﾾ'),
+    ('ￂ', 'ￇ'),
+    ('ￊ', 'ￏ'),
+    ('ￒ', 'ￗ'),
+    ('ￚ', 'ￜ'),
+    ('𐀀', '𐀋'),
+    ('𐀍', '𐀦'),
+    ('𐀨', '𐀺'),
+    ('𐀼', '𐀽'),
+    ('𐀿', '𐁍'),
+    ('𐁐', '𐁝'),
+    ('𐂀', '𐃺'),
+    ('𐊀', '𐊜'),
+    ('𐊠', '𐋐'),
+    ('𐌀', '𐌟'),
+    ('𐌭', '𐍀'),
+    ('𐍂', '𐍉'),
+    ('𐍐', '𐍵'),
+    ('𐎀', '𐎝'),
+    ('𐎠', '𐏃'),
+    ('𐏈', '𐏏'),
+    ('𐑐', '𐒝'),
+    ('𐔀', '𐔧'),
+    ('𐔰', '𐕣'),
+    ('𐘀', '𐜶'),
+    ('𐝀', '𐝕'),
+    ('𐝠', '𐝧'),
+    ('𐠀', '𐠅'),
+    ('𐠈', '𐠈'),
+    ('𐠊', '𐠵'),
+    ('𐠷', '𐠸'),
+    ('𐠼', '𐠼'),
+    ('𐠿', '𐡕'),
+    ('𐡠', '𐡶'),
+    ('𐢀', '𐢞'),
+    ('𐣠', '𐣲'),
+    ('𐣴', '𐣵'),
+    ('𐤀', '𐤕'),
+    ('𐤠', '𐤹'),
+    ('𐦀', '𐦷'),
+    ('𐦾', '𐦿'),
+    ('𐨀', '𐨀'),
+    ('𐨐', '𐨓'),
+    ('𐨕', '𐨗'),
+    ('𐨙', '𐨵'),
+    ('𐩠', '𐩼'),
+    ('𐪀', '𐪜'),
+    ('𐫀', '𐫇'),
+    ('𐫉', '𐫤'),
+    ('𐬀', '𐬵'),
+    ('𐭀', '𐭕'),
+    ('𐭠', '𐭲'),
+    ('𐮀', '𐮑'),
+    ('𐰀', '𐱈'),
+    ('𐴀', '𐴣'),
+    ('𐺀', '𐺩'),
+    ('𐺰', '𐺱'),
+    ('𐼀', '𐼜'),
+    ('𐼧', '𐼧'),
+    ('𐼰', '𐽅'),
+    ('𐽰', '𐾁'),
+    ('𐾰', '𐿄'),
+    ('𐿠', '𐿶'),
+    ('𑀃', '𑀷'),
+    ('𑁱', '𑁲'),
+    ('𑁵', '𑁵'),
+    ('𑂃', '𑂯'),
+    ('𑃐', '𑃨'),
+    ('𑄃', '𑄦'),
+    ('𑅄', '𑅄'),
+    ('𑅇', '𑅇'),
+    ('𑅐', '𑅲'),
+    ('𑅶', '𑅶'),
+    ('𑆃', '𑆲'),
+    ('𑇁', '𑇄'),
+    ('𑇚', '𑇚'),
+    ('𑇜', '𑇜'),
+    ('𑈀', '𑈑'),
+    ('𑈓', '𑈫'),
+    ('𑈿', '𑉀'),
+    ('𑊀', '𑊆'),
+    ('𑊈', '𑊈'),
+    ('𑊊', '𑊍'),
+    ('𑊏', '𑊝'),
+    ('𑊟', '𑊨'),
+    ('𑊰', '𑋞'),
+    ('𑌅', '𑌌'),
+    ('𑌏', '𑌐'),
+    ('𑌓', '𑌨'),
+    ('𑌪', '𑌰'),
+    ('𑌲', '𑌳'),
+    ('𑌵', '𑌹'),
+    ('𑌽', '𑌽'),
+    ('𑍐', '𑍐'),
+    ('𑍝', '𑍡'),
+    ('𑐀', '𑐴'),
+    ('𑑇', '𑑊'),
+    ('𑑟', '𑑡'),
+    ('𑒀', '𑒯'),
+    ('𑓄', '𑓅'),
+    ('𑓇', '𑓇'),
+    ('𑖀', '𑖮'),
+    ('𑗘', '𑗛'),
+    ('𑘀', '𑘯'),
+    ('𑙄', '𑙄'),
+    ('𑚀', '𑚪'),
+    ('𑚸', '𑚸'),
+    ('𑜀', '𑜚'),
+    ('𑝀', '𑝆'),
+    ('𑠀', '𑠫'),
+    ('𑣿', '𑤆'),
+    ('𑤉', '𑤉'),
+    ('𑤌', '𑤓'),
+    ('𑤕', '𑤖'),
+    ('𑤘', '𑤯'),
+    ('𑤿', '𑤿'),
+    ('𑥁', '𑥁'),
+    ('𑦠', '𑦧'),
+    ('𑦪', '𑧐'),
+    ('𑧡', '𑧡'),
+    ('𑧣', '𑧣'),
+    ('𑨀', '𑨀'),
+    ('𑨋', '𑨲'),
+    ('𑨺', '𑨺'),
+    ('𑩐', '𑩐'),
+    ('𑩜', '𑪉'),
+    ('𑪝', '𑪝'),
+    ('𑪰', '𑫸'),
+    ('𑰀', '𑰈'),
+    ('𑰊', '𑰮'),
+    ('𑱀', '𑱀'),
+    ('𑱲', '𑲏'),
+    ('𑴀', '𑴆'),
+    ('𑴈', '𑴉'),
+    ('𑴋', '𑴰'),
+    ('𑵆', '𑵆'),
+    ('𑵠', '𑵥'),
+    ('𑵧', '𑵨'),
+    ('𑵪', '𑶉'),
+    ('𑶘', '𑶘'),
+    ('𑻠', '𑻲'),
+    ('𑼂', '𑼂'),
+    ('𑼄', '𑼐'),
+    ('𑼒', '𑼳'),
+    ('𑾰', '𑾰'),
+    ('𒀀', '𒎙'),
+    ('𒒀', '𒕃'),
+    ('𒾐', '𒿰'),
+    ('𓀀', '𓐯'),
+    ('𓑁', '𓑆'),
+    ('𔐀', '𔙆'),
+    ('𖠀', '𖨸'),
+    ('𖩀', '𖩞'),
+    ('𖩰', '𖪾'),
+    ('𖫐', '𖫭'),
+    ('𖬀', '𖬯'),
+    ('𖭣', '𖭷'),
+    ('𖭽', '𖮏'),
+    ('𖼀', '𖽊'),
+    ('𖽐', '𖽐'),
+    ('𗀀', '𘟷'),
+    ('𘠀', '𘳕'),
+    ('𘴀', '𘴈'),
+    ('𛀀', '𛄢'),
+    ('𛄲', '𛄲'),
+    ('𛅐', '𛅒'),
+    ('𛅕', '𛅕'),
+    ('𛅤', '𛅧'),
+    ('𛅰', '𛋻'),
+    ('𛰀', '𛱪'),
+    ('𛱰', '𛱼'),
+    ('𛲀', '𛲈'),
+    ('𛲐', '𛲙'),
+    ('𝼊', '𝼊'),
+    ('𞄀', '𞄬'),
+    ('𞅎', '𞅎'),
+    ('𞊐', '𞊭'),
+    ('𞋀', '𞋫'),
+    ('𞓐', '𞓪'),
+    ('𞟠', '𞟦'),
+    ('𞟨', '𞟫'),
+    ('𞟭', '𞟮'),
+    ('𞟰', '𞟾'),
+    ('𞠀', '𞣄'),
+    ('𞸀', '𞸃'),
+    ('𞸅', '𞸟'),
+    ('𞸡', '𞸢'),
+    ('𞸤', '𞸤'),
+    ('𞸧', '𞸧'),
+    ('𞸩', '𞸲'),
+    ('𞸴', '𞸷'),
+    ('𞸹', '𞸹'),
+    ('𞸻', '𞸻'),
+    ('𞹂', '𞹂'),
+    ('𞹇', '𞹇'),
+    ('𞹉', '𞹉'),
+    ('𞹋', '𞹋'),
+    ('𞹍', '𞹏'),
+    ('𞹑', '𞹒'),
+    ('𞹔', '𞹔'),
+    ('𞹗', '𞹗'),
+    ('𞹙', '𞹙'),
+    ('𞹛', '𞹛'),
+    ('𞹝', '𞹝'),
+    ('𞹟', '𞹟'),
+    ('𞹡', '𞹢'),
+    ('𞹤', '𞹤'),
+    ('𞹧', '𞹪'),
+    ('𞹬', '𞹲'),
+    ('𞹴', '𞹷'),
+    ('𞹹', '𞹼'),
+    ('𞹾', '𞹾'),
+    ('𞺀', '𞺉'),
+    ('𞺋', '𞺛'),
+    ('𞺡', '𞺣'),
+    ('𞺥', '𞺩'),
+    ('𞺫', '𞺻'),
+    ('𠀀', '𪛟'),
+    ('𪜀', '𫜹'),
+    ('𫝀', '𫠝'),
+    ('𫠠', '𬺡'),
+    ('𬺰', '𮯠'),
+    ('丽', '𪘀'),
+    ('𰀀', '𱍊'),
+    ('𱍐', '𲎯'),
+];
+
+pub const OTHER_NUMBER: &'static [(char, char)] = &[
+    ('²', '³'),
+    ('¹', '¹'),
+    ('¼', '¾'),
+    ('৴', '৹'),
+    ('୲', '୷'),
+    ('௰', '௲'),
+    ('౸', '౾'),
+    ('൘', '൞'),
+    ('൰', '൸'),
+    ('༪', '༳'),
+    ('፩', '፼'),
+    ('៰', '៹'),
+    ('᧚', '᧚'),
+    ('⁰', '⁰'),
+    ('⁴', '⁹'),
+    ('₀', '₉'),
+    ('⅐', '⅟'),
+    ('↉', '↉'),
+    ('①', '⒛'),
+    ('⓪', '⓿'),
+    ('❶', '➓'),
+    ('⳽', '⳽'),
+    ('㆒', '㆕'),
+    ('㈠', '㈩'),
+    ('㉈', '㉏'),
+    ('㉑', '㉟'),
+    ('㊀', '㊉'),
+    ('㊱', '㊿'),
+    ('꠰', '꠵'),
+    ('𐄇', '𐄳'),
+    ('𐅵', '𐅸'),
+    ('𐆊', '𐆋'),
+    ('𐋡', '𐋻'),
+    ('𐌠', '𐌣'),
+    ('𐡘', '𐡟'),
+    ('𐡹', '𐡿'),
+    ('𐢧', '𐢯'),
+    ('𐣻', '𐣿'),
+    ('𐤖', '𐤛'),
+    ('𐦼', '𐦽'),
+    ('𐧀', '𐧏'),
+    ('𐧒', '𐧿'),
+    ('𐩀', '𐩈'),
+    ('𐩽', '𐩾'),
+    ('𐪝', '𐪟'),
+    ('𐫫', '𐫯'),
+    ('𐭘', '𐭟'),
+    ('𐭸', '𐭿'),
+    ('𐮩', '𐮯'),
+    ('𐳺', '𐳿'),
+    ('𐹠', '𐹾'),
+    ('𐼝', '𐼦'),
+    ('𐽑', '𐽔'),
+    ('𐿅', '𐿋'),
+    ('𑁒', '𑁥'),
+    ('𑇡', '𑇴'),
+    ('𑜺', '𑜻'),
+    ('𑣪', '𑣲'),
+    ('𑱚', '𑱬'),
+    ('𑿀', '𑿔'),
+    ('𖭛', '𖭡'),
+    ('𖺀', '𖺖'),
+    ('𝋀', '𝋓'),
+    ('𝋠', '𝋳'),
+    ('𝍠', '𝍸'),
+    ('𞣇', '𞣏'),
+    ('𞱱', '𞲫'),
+    ('𞲭', '𞲯'),
+    ('𞲱', '𞲴'),
+    ('𞴁', '𞴭'),
+    ('𞴯', '𞴽'),
+    ('🄀', '🄌'),
+];
+
+pub const OTHER_PUNCTUATION: &'static [(char, char)] = &[
+    ('!', '#'),
+    ('%', '\''),
+    ('*', '*'),
+    (',', ','),
+    ('.', '/'),
+    (':', ';'),
+    ('?', '@'),
+    ('\\', '\\'),
+    ('¡', '¡'),
+    ('§', '§'),
+    ('¶', '·'),
+    ('¿', '¿'),
+    (';', ';'),
+    ('·', '·'),
+    ('՚', '՟'),
+    ('։', '։'),
+    ('׀', '׀'),
+    ('׃', '׃'),
+    ('׆', '׆'),
+    ('׳', '״'),
+    ('؉', '؊'),
+    ('،', '؍'),
+    ('؛', '؛'),
+    ('؝', '؟'),
+    ('٪', '٭'),
+    ('۔', '۔'),
+    ('܀', '܍'),
+    ('߷', '߹'),
+    ('࠰', '࠾'),
+    ('࡞', '࡞'),
+    ('।', '॥'),
+    ('॰', '॰'),
+    ('৽', '৽'),
+    ('੶', '੶'),
+    ('૰', '૰'),
+    ('౷', '౷'),
+    ('಄', '಄'),
+    ('෴', '෴'),
+    ('๏', '๏'),
+    ('๚', '๛'),
+    ('༄', '༒'),
+    ('༔', '༔'),
+    ('྅', '྅'),
+    ('࿐', '࿔'),
+    ('࿙', '࿚'),
+    ('၊', '၏'),
+    ('჻', '჻'),
+    ('፠', '፨'),
+    ('᙮', '᙮'),
+    ('᛫', '᛭'),
+    ('᜵', '᜶'),
+    ('។', '៖'),
+    ('៘', '៚'),
+    ('᠀', '᠅'),
+    ('᠇', '᠊'),
+    ('᥄', '᥅'),
+    ('᨞', '᨟'),
+    ('᪠', '᪦'),
+    ('᪨', '᪭'),
+    ('᭚', '᭠'),
+    ('᭽', '᭾'),
+    ('᯼', '᯿'),
+    ('᰻', '᰿'),
+    ('᱾', '᱿'),
+    ('᳀', '᳇'),
+    ('᳓', '᳓'),
+    ('‖', '‗'),
+    ('†', '‧'),
+    ('‰', '‸'),
+    ('※', '‾'),
+    ('⁁', '⁃'),
+    ('⁇', '⁑'),
+    ('⁓', '⁓'),
+    ('⁕', '⁞'),
+    ('⳹', '⳼'),
+    ('⳾', '⳿'),
+    ('⵰', '⵰'),
+    ('⸀', '⸁'),
+    ('⸆', '⸈'),
+    ('⸋', '⸋'),
+    ('⸎', '⸖'),
+    ('⸘', '⸙'),
+    ('⸛', '⸛'),
+    ('⸞', '⸟'),
+    ('⸪', '⸮'),
+    ('⸰', '⸹'),
+    ('⸼', '⸿'),
+    ('⹁', '⹁'),
+    ('⹃', '⹏'),
+    ('⹒', '⹔'),
+    ('、', '〃'),
+    ('〽', '〽'),
+    ('・', '・'),
+    ('꓾', '꓿'),
+    ('꘍', '꘏'),
+    ('꙳', '꙳'),
+    ('꙾', '꙾'),
+    ('꛲', '꛷'),
+    ('꡴', '꡷'),
+    ('꣎', '꣏'),
+    ('꣸', '꣺'),
+    ('꣼', '꣼'),
+    ('꤮', '꤯'),
+    ('꥟', '꥟'),
+    ('꧁', '꧍'),
+    ('꧞', '꧟'),
+    ('꩜', '꩟'),
+    ('꫞', '꫟'),
+    ('꫰', '꫱'),
+    ('꯫', '꯫'),
+    ('︐', '︖'),
+    ('︙', '︙'),
+    ('︰', '︰'),
+    ('﹅', '﹆'),
+    ('﹉', '﹌'),
+    ('﹐', '﹒'),
+    ('﹔', '﹗'),
+    ('﹟', '﹡'),
+    ('﹨', '﹨'),
+    ('﹪', '﹫'),
+    ('！', '＃'),
+    ('％', '＇'),
+    ('＊', '＊'),
+    ('，', '，'),
+    ('．', '／'),
+    ('：', '；'),
+    ('？', '＠'),
+    ('＼', '＼'),
+    ('｡', '｡'),
+    ('､', '･'),
+    ('𐄀', '𐄂'),
+    ('𐎟', '𐎟'),
+    ('𐏐', '𐏐'),
+    ('𐕯', '𐕯'),
+    ('𐡗', '𐡗'),
+    ('𐤟', '𐤟'),
+    ('𐤿', '𐤿'),
+    ('𐩐', '𐩘'),
+    ('𐩿', '𐩿'),
+    ('𐫰', '𐫶'),
+    ('𐬹', '𐬿'),
+    ('𐮙', '𐮜'),
+    ('𐽕', '𐽙'),
+    ('𐾆', '𐾉'),
+    ('𑁇', '𑁍'),
+    ('𑂻', '𑂼'),
+    ('𑂾', '𑃁'),
+    ('𑅀', '𑅃'),
+    ('𑅴', '𑅵'),
+    ('𑇅', '𑇈'),
+    ('𑇍', '𑇍'),
+    ('𑇛', '𑇛'),
+    ('𑇝', '𑇟'),
+    ('𑈸', '𑈽'),
+    ('𑊩', '𑊩'),
+    ('𑑋', '𑑏'),
+    ('𑑚', '𑑛'),
+    ('𑑝', '𑑝'),
+    ('𑓆', '𑓆'),
+    ('𑗁', '𑗗'),
+    ('𑙁', '𑙃'),
+    ('𑙠', '𑙬'),
+    ('𑚹', '𑚹'),
+    ('𑜼', '𑜾'),
+    ('𑠻', '𑠻'),
+    ('𑥄', '𑥆'),
+    ('𑧢', '𑧢'),
+    ('𑨿', '𑩆'),
+    ('𑪚', '𑪜'),
+    ('𑪞', '𑪢'),
+    ('𑬀', '𑬉'),
+    ('𑱁', '𑱅'),
+    ('𑱰', '𑱱'),
+    ('𑻷', '𑻸'),
+    ('𑽃', '𑽏'),
+    ('𑿿', '𑿿'),
+    ('𒑰', '𒑴'),
+    ('𒿱', '𒿲'),
+    ('𖩮', '𖩯'),
+    ('𖫵', '𖫵'),
+    ('𖬷', '𖬻'),
+    ('𖭄', '𖭄'),
+    ('𖺗', '𖺚'),
+    ('𖿢', '𖿢'),
+    ('𛲟', '𛲟'),
+    ('𝪇', '𝪋'),
+    ('𞥞', '𞥟'),
+];
+
+pub const OTHER_SYMBOL: &'static [(char, char)] = &[
+    ('¦', '¦'),
+    ('©', '©'),
+    ('®', '®'),
+    ('°', '°'),
+    ('҂', '҂'),
+    ('֍', '֎'),
+    ('؎', '؏'),
+    ('۞', '۞'),
+    ('۩', '۩'),
+    ('۽', '۾'),
+    ('߶', '߶'),
+    ('৺', '৺'),
+    ('୰', '୰'),
+    ('௳', '௸'),
+    ('௺', '௺'),
+    ('౿', '౿'),
+    ('൏', '൏'),
+    ('൹', '൹'),
+    ('༁', '༃'),
+    ('༓', '༓'),
+    ('༕', '༗'),
+    ('༚', '༟'),
+    ('༴', '༴'),
+    ('༶', '༶'),
+    ('༸', '༸'),
+    ('྾', '࿅'),
+    ('࿇', '࿌'),
+    ('࿎', '࿏'),
+    ('࿕', '࿘'),
+    ('႞', '႟'),
+    ('᎐', '᎙'),
+    ('᙭', '᙭'),
+    ('᥀', '᥀'),
+    ('᧞', '᧿'),
+    ('᭡', '᭪'),
+    ('᭴', '᭼'),
+    ('℀', '℁'),
+    ('℃', '℆'),
+    ('℈', '℉'),
+    ('℔', '℔'),
+    ('№', '℗'),
+    ('℞', '℣'),
+    ('℥', '℥'),
+    ('℧', '℧'),
+    ('℩', '℩'),
+    ('℮', '℮'),
+    ('℺', '℻'),
+    ('⅊', '⅊'),
+    ('⅌', '⅍'),
+    ('⅏', '⅏'),
+    ('↊', '↋'),
+    ('↕', '↙'),
+    ('↜', '↟'),
+    ('↡', '↢'),
+    ('↤', '↥'),
+    ('↧', '↭'),
+    ('↯', '⇍'),
+    ('⇐', '⇑'),
+    ('⇓', '⇓'),
+    ('⇕', '⇳'),
+    ('⌀', '⌇'),
+    ('⌌', '⌟'),
+    ('⌢', '⌨'),
+    ('⌫', '⍻'),
+    ('⍽', '⎚'),
+    ('⎴', '⏛'),
+    ('⏢', '␦'),
+    ('⑀', '⑊'),
+    ('⒜', 'ⓩ'),
+    ('─', '▶'),
+    ('▸', '◀'),
+    ('◂', '◷'),
+    ('☀', '♮'),
+    ('♰', '❧'),
+    ('➔', '➿'),
+    ('⠀', '⣿'),
+    ('⬀', '⬯'),
+    ('⭅', '⭆'),
+    ('⭍', '⭳'),
+    ('⭶', '⮕'),
+    ('⮗', '⯿'),
+    ('⳥', '⳪'),
+    ('⹐', '⹑'),
+    ('⺀', '⺙'),
+    ('⺛', '⻳'),
+    ('⼀', '⿕'),
+    ('⿰', '⿻'),
+    ('〄', '〄'),
+    ('〒', '〓'),
+    ('〠', '〠'),
+    ('〶', '〷'),
+    ('〾', '〿'),
+    ('㆐', '㆑'),
+    ('㆖', '㆟'),
+    ('㇀', '㇣'),
+    ('㈀', '㈞'),
+    ('㈪', '㉇'),
+    ('㉐', '㉐'),
+    ('㉠', '㉿'),
+    ('㊊', '㊰'),
+    ('㋀', '㏿'),
+    ('䷀', '䷿'),
+    ('꒐', '꓆'),
+    ('꠨', '꠫'),
+    ('꠶', '꠷'),
+    ('꠹', '꠹'),
+    ('꩷', '꩹'),
+    ('﵀', '﵏'),
+    ('﷏', '﷏'),
+    ('﷽', '﷿'),
+    ('￤', '￤'),
+    ('￨', '￨'),
+    ('￭', '￮'),
+    ('￼', '�'),
+    ('𐄷', '𐄿'),
+    ('𐅹', '𐆉'),
+    ('𐆌', '𐆎'),
+    ('𐆐', '𐆜'),
+    ('𐆠', '𐆠'),
+    ('𐇐', '𐇼'),
+    ('𐡷', '𐡸'),
+    ('𐫈', '𐫈'),
+    ('𑜿', '𑜿'),
+    ('𑿕', '𑿜'),
+    ('𑿡', '𑿱'),
+    ('𖬼', '𖬿'),
+    ('𖭅', '𖭅'),
+    ('𛲜', '𛲜'),
+    ('𜽐', '𜿃'),
+    ('𝀀', '𝃵'),
+    ('𝄀', '𝄦'),
+    ('𝄩', '𝅘𝅥𝅲'),
+    ('𝅪', '𝅬'),
+    ('𝆃', '𝆄'),
+    ('𝆌', '𝆩'),
+    ('𝆮', '𝇪'),
+    ('𝈀', '𝉁'),
+    ('𝉅', '𝉅'),
+    ('𝌀', '𝍖'),
+    ('𝠀', '𝧿'),
+    ('𝨷', '𝨺'),
+    ('𝩭', '𝩴'),
+    ('𝩶', '𝪃'),
+    ('𝪅', '𝪆'),
+    ('𞅏', '𞅏'),
+    ('𞲬', '𞲬'),
+    ('𞴮', '𞴮'),
+    ('🀀', '🀫'),
+    ('🀰', '🂓'),
+    ('🂠', '🂮'),
+    ('🂱', '🂿'),
+    ('🃁', '🃏'),
+    ('🃑', '🃵'),
+    ('🄍', '🆭'),
+    ('🇦', '🈂'),
+    ('🈐', '🈻'),
+    ('🉀', '🉈'),
+    ('🉐', '🉑'),
+    ('🉠', '🉥'),
+    ('🌀', '🏺'),
+    ('🐀', '🛗'),
+    ('🛜', '🛬'),
+    ('🛰', '🛼'),
+    ('🜀', '🝶'),
+    ('🝻', '🟙'),
+    ('🟠', '🟫'),
+    ('🟰', '🟰'),
+    ('🠀', '🠋'),
+    ('🠐', '🡇'),
+    ('🡐', '🡙'),
+    ('🡠', '🢇'),
+    ('🢐', '🢭'),
+    ('🢰', '🢱'),
+    ('🤀', '🩓'),
+    ('🩠', '🩭'),
+    ('🩰', '🩼'),
+    ('🪀', '🪈'),
+    ('🪐', '🪽'),
+    ('🪿', '🫅'),
+    ('🫎', '🫛'),
+    ('🫠', '🫨'),
+    ('🫰', '🫸'),
+    ('🬀', '🮒'),
+    ('🮔', '🯊'),
+];
+
+pub const PARAGRAPH_SEPARATOR: &'static [(char, char)] =
+    &[('\u{2029}', '\u{2029}')];
+
+pub const PRIVATE_USE: &'static [(char, char)] = &[
+    ('\u{e000}', '\u{f8ff}'),
+    ('\u{f0000}', '\u{ffffd}'),
+    ('\u{100000}', '\u{10fffd}'),
+];
+
+pub const PUNCTUATION: &'static [(char, char)] = &[
+    ('!', '#'),
+    ('%', '*'),
+    (',', '/'),
+    (':', ';'),
+    ('?', '@'),
+    ('[', ']'),
+    ('_', '_'),
+    ('{', '{'),
+    ('}', '}'),
+    ('¡', '¡'),
+    ('§', '§'),
+    ('«', '«'),
+    ('¶', '·'),
+    ('»', '»'),
+    ('¿', '¿'),
+    (';', ';'),
+    ('·', '·'),
+    ('՚', '՟'),
+    ('։', '֊'),
+    ('־', '־'),
+    ('׀', '׀'),
+    ('׃', '׃'),
+    ('׆', '׆'),
+    ('׳', '״'),
+    ('؉', '؊'),
+    ('،', '؍'),
+    ('؛', '؛'),
+    ('؝', '؟'),
+    ('٪', '٭'),
+    ('۔', '۔'),
+    ('܀', '܍'),
+    ('߷', '߹'),
+    ('࠰', '࠾'),
+    ('࡞', '࡞'),
+    ('।', '॥'),
+    ('॰', '॰'),
+    ('৽', '৽'),
+    ('੶', '੶'),
+    ('૰', '૰'),
+    ('౷', '౷'),
+    ('಄', '಄'),
+    ('෴', '෴'),
+    ('๏', '๏'),
+    ('๚', '๛'),
+    ('༄', '༒'),
+    ('༔', '༔'),
+    ('༺', '༽'),
+    ('྅', '྅'),
+    ('࿐', '࿔'),
+    ('࿙', '࿚'),
+    ('၊', '၏'),
+    ('჻', '჻'),
+    ('፠', '፨'),
+    ('᐀', '᐀'),
+    ('᙮', '᙮'),
+    ('᚛', '᚜'),
+    ('᛫', '᛭'),
+    ('᜵', '᜶'),
+    ('។', '៖'),
+    ('៘', '៚'),
+    ('᠀', '᠊'),
+    ('᥄', '᥅'),
+    ('᨞', '᨟'),
+    ('᪠', '᪦'),
+    ('᪨', '᪭'),
+    ('᭚', '᭠'),
+    ('᭽', '᭾'),
+    ('᯼', '᯿'),
+    ('᰻', '᰿'),
+    ('᱾', '᱿'),
+    ('᳀', '᳇'),
+    ('᳓', '᳓'),
+    ('‐', '‧'),
+    ('‰', '⁃'),
+    ('⁅', '⁑'),
+    ('⁓', '⁞'),
+    ('⁽', '⁾'),
+    ('₍', '₎'),
+    ('⌈', '⌋'),
+    ('〈', '〉'),
+    ('❨', '❵'),
+    ('⟅', '⟆'),
+    ('⟦', '⟯'),
+    ('⦃', '⦘'),
+    ('⧘', '⧛'),
+    ('⧼', '⧽'),
+    ('⳹', '⳼'),
+    ('⳾', '⳿'),
+    ('⵰', '⵰'),
+    ('⸀', '⸮'),
+    ('⸰', '⹏'),
+    ('⹒', '⹝'),
+    ('、', '〃'),
+    ('〈', '】'),
+    ('〔', '〟'),
+    ('〰', '〰'),
+    ('〽', '〽'),
+    ('゠', '゠'),
+    ('・', '・'),
+    ('꓾', '꓿'),
+    ('꘍', '꘏'),
+    ('꙳', '꙳'),
+    ('꙾', '꙾'),
+    ('꛲', '꛷'),
+    ('꡴', '꡷'),
+    ('꣎', '꣏'),
+    ('꣸', '꣺'),
+    ('꣼', '꣼'),
+    ('꤮', '꤯'),
+    ('꥟', '꥟'),
+    ('꧁', '꧍'),
+    ('꧞', '꧟'),
+    ('꩜', '꩟'),
+    ('꫞', '꫟'),
+    ('꫰', '꫱'),
+    ('꯫', '꯫'),
+    ('﴾', '﴿'),
+    ('︐', '︙'),
+    ('︰', '﹒'),
+    ('﹔', '﹡'),
+    ('﹣', '﹣'),
+    ('﹨', '﹨'),
+    ('﹪', '﹫'),
+    ('！', '＃'),
+    ('％', '＊'),
+    ('，', '／'),
+    ('：', '；'),
+    ('？', '＠'),
+    ('［', '］'),
+    ('＿', '＿'),
+    ('｛', '｛'),
+    ('｝', '｝'),
+    ('｟', '･'),
+    ('𐄀', '𐄂'),
+    ('𐎟', '𐎟'),
+    ('𐏐', '𐏐'),
+    ('𐕯', '𐕯'),
+    ('𐡗', '𐡗'),
+    ('𐤟', '𐤟'),
+    ('𐤿', '𐤿'),
+    ('𐩐', '𐩘'),
+    ('𐩿', '𐩿'),
+    ('𐫰', '𐫶'),
+    ('𐬹', '𐬿'),
+    ('𐮙', '𐮜'),
+    ('𐺭', '𐺭'),
+    ('𐽕', '𐽙'),
+    ('𐾆', '𐾉'),
+    ('𑁇', '𑁍'),
+    ('𑂻', '𑂼'),
+    ('𑂾', '𑃁'),
+    ('𑅀', '𑅃'),
+    ('𑅴', '𑅵'),
+    ('𑇅', '𑇈'),
+    ('𑇍', '𑇍'),
+    ('𑇛', '𑇛'),
+    ('𑇝', '𑇟'),
+    ('𑈸', '𑈽'),
+    ('𑊩', '𑊩'),
+    ('𑑋', '𑑏'),
+    ('𑑚', '𑑛'),
+    ('𑑝', '𑑝'),
+    ('𑓆', '𑓆'),
+    ('𑗁', '𑗗'),
+    ('𑙁', '𑙃'),
+    ('𑙠', '𑙬'),
+    ('𑚹', '𑚹'),
+    ('𑜼', '𑜾'),
+    ('𑠻', '𑠻'),
+    ('𑥄', '𑥆'),
+    ('𑧢', '𑧢'),
+    ('𑨿', '𑩆'),
+    ('𑪚', '𑪜'),
+    ('𑪞', '𑪢'),
+    ('𑬀', '𑬉'),
+    ('𑱁', '𑱅'),
+    ('𑱰', '𑱱'),
+    ('𑻷', '𑻸'),
+    ('𑽃', '𑽏'),
+    ('𑿿', '𑿿'),
+    ('𒑰', '𒑴'),
+    ('𒿱', '𒿲'),
+    ('𖩮', '𖩯'),
+    ('𖫵', '𖫵'),
+    ('𖬷', '𖬻'),
+    ('𖭄', '𖭄'),
+    ('𖺗', '𖺚'),
+    ('𖿢', '𖿢'),
+    ('𛲟', '𛲟'),
+    ('𝪇', '𝪋'),
+    ('𞥞', '𞥟'),
+];
+
+pub const SEPARATOR: &'static [(char, char)] = &[
+    (' ', ' '),
+    ('\u{a0}', '\u{a0}'),
+    ('\u{1680}', '\u{1680}'),
+    ('\u{2000}', '\u{200a}'),
+    ('\u{2028}', '\u{2029}'),
+    ('\u{202f}', '\u{202f}'),
+    ('\u{205f}', '\u{205f}'),
+    ('\u{3000}', '\u{3000}'),
+];
+
+pub const SPACE_SEPARATOR: &'static [(char, char)] = &[
+    (' ', ' '),
+    ('\u{a0}', '\u{a0}'),
+    ('\u{1680}', '\u{1680}'),
+    ('\u{2000}', '\u{200a}'),
+    ('\u{202f}', '\u{202f}'),
+    ('\u{205f}', '\u{205f}'),
+    ('\u{3000}', '\u{3000}'),
+];
+
+pub const SPACING_MARK: &'static [(char, char)] = &[
+    ('ः', 'ः'),
+    ('ऻ', 'ऻ'),
+    ('ा', 'ी'),
+    ('ॉ', 'ौ'),
+    ('ॎ', 'ॏ'),
+    ('ং', 'ঃ'),
+    ('\u{9be}', 'ী'),
+    ('ে', 'ৈ'),
+    ('ো', 'ৌ'),
+    ('\u{9d7}', '\u{9d7}'),
+    ('ਃ', 'ਃ'),
+    ('ਾ', 'ੀ'),
+    ('ઃ', 'ઃ'),
+    ('ા', 'ી'),
+    ('ૉ', 'ૉ'),
+    ('ો', 'ૌ'),
+    ('ଂ', 'ଃ'),
+    ('\u{b3e}', '\u{b3e}'),
+    ('ୀ', 'ୀ'),
+    ('େ', 'ୈ'),
+    ('ୋ', 'ୌ'),
+    ('\u{b57}', '\u{b57}'),
+    ('\u{bbe}', 'ி'),
+    ('ு', 'ூ'),
+    ('ெ', 'ை'),
+    ('ொ', 'ௌ'),
+    ('\u{bd7}', '\u{bd7}'),
+    ('ఁ', 'ః'),
+    ('ు', 'ౄ'),
+    ('ಂ', 'ಃ'),
+    ('ಾ', 'ಾ'),
+    ('ೀ', 'ೄ'),
+    ('ೇ', 'ೈ'),
+    ('ೊ', 'ೋ'),
+    ('\u{cd5}', '\u{cd6}'),
+    ('ೳ', 'ೳ'),
+    ('ം', 'ഃ'),
+    ('\u{d3e}', 'ീ'),
+    ('െ', 'ൈ'),
+    ('ൊ', 'ൌ'),
+    ('\u{d57}', '\u{d57}'),
+    ('ං', 'ඃ'),
+    ('\u{dcf}', 'ෑ'),
+    ('ෘ', '\u{ddf}'),
+    ('ෲ', 'ෳ'),
+    ('༾', '༿'),
+    ('ཿ', 'ཿ'),
+    ('ါ', 'ာ'),
+    ('ေ', 'ေ'),
+    ('း', 'း'),
+    ('ျ', 'ြ'),
+    ('ၖ', 'ၗ'),
+    ('ၢ', 'ၤ'),
+    ('ၧ', 'ၭ'),
+    ('ႃ', 'ႄ'),
+    ('ႇ', 'ႌ'),
+    ('ႏ', 'ႏ'),
+    ('ႚ', 'ႜ'),
+    ('᜕', '᜕'),
+    ('᜴', '᜴'),
+    ('ា', 'ា'),
+    ('ើ', 'ៅ'),
+    ('ះ', 'ៈ'),
+    ('ᤣ', 'ᤦ'),
+    ('ᤩ', 'ᤫ'),
+    ('ᤰ', 'ᤱ'),
+    ('ᤳ', 'ᤸ'),
+    ('ᨙ', 'ᨚ'),
+    ('ᩕ', 'ᩕ'),
+    ('ᩗ', 'ᩗ'),
+    ('ᩡ', 'ᩡ'),
+    ('ᩣ', 'ᩤ'),
+    ('ᩭ', 'ᩲ'),
+    ('ᬄ', 'ᬄ'),
+    ('\u{1b35}', '\u{1b35}'),
+    ('ᬻ', 'ᬻ'),
+    ('ᬽ', 'ᭁ'),
+    ('ᭃ', '᭄'),
+    ('ᮂ', 'ᮂ'),
+    ('ᮡ', 'ᮡ'),
+    ('ᮦ', 'ᮧ'),
+    ('᮪', '᮪'),
+    ('ᯧ', 'ᯧ'),
+    ('ᯪ', 'ᯬ'),
+    ('ᯮ', 'ᯮ'),
+    ('᯲', '᯳'),
+    ('ᰤ', 'ᰫ'),
+    ('ᰴ', 'ᰵ'),
+    ('᳡', '᳡'),
+    ('᳷', '᳷'),
+    ('\u{302e}', '\u{302f}'),
+    ('ꠣ', 'ꠤ'),
+    ('ꠧ', 'ꠧ'),
+    ('ꢀ', 'ꢁ'),
+    ('ꢴ', 'ꣃ'),
+    ('ꥒ', '꥓'),
+    ('ꦃ', 'ꦃ'),
+    ('ꦴ', 'ꦵ'),
+    ('ꦺ', 'ꦻ'),
+    ('ꦾ', '꧀'),
+    ('ꨯ', 'ꨰ'),
+    ('ꨳ', 'ꨴ'),
+    ('ꩍ', 'ꩍ'),
+    ('ꩻ', 'ꩻ'),
+    ('ꩽ', 'ꩽ'),
+    ('ꫫ', 'ꫫ'),
+    ('ꫮ', 'ꫯ'),
+    ('ꫵ', 'ꫵ'),
+    ('ꯣ', 'ꯤ'),
+    ('ꯦ', 'ꯧ'),
+    ('ꯩ', 'ꯪ'),
+    ('꯬', '꯬'),
+    ('𑀀', '𑀀'),
+    ('𑀂', '𑀂'),
+    ('𑂂', '𑂂'),
+    ('𑂰', '𑂲'),
+    ('𑂷', '𑂸'),
+    ('𑄬', '𑄬'),
+    ('𑅅', '𑅆'),
+    ('𑆂', '𑆂'),
+    ('𑆳', '𑆵'),
+    ('𑆿', '𑇀'),
+    ('𑇎', '𑇎'),
+    ('𑈬', '𑈮'),
+    ('𑈲', '𑈳'),
+    ('𑈵', '𑈵'),
+    ('𑋠', '𑋢'),
+    ('𑌂', '𑌃'),
+    ('\u{1133e}', '𑌿'),
+    ('𑍁', '𑍄'),
+    ('𑍇', '𑍈'),
+    ('𑍋', '𑍍'),
+    ('\u{11357}', '\u{11357}'),
+    ('𑍢', '𑍣'),
+    ('𑐵', '𑐷'),
+    ('𑑀', '𑑁'),
+    ('𑑅', '𑑅'),
+    ('\u{114b0}', '𑒲'),
+    ('𑒹', '𑒹'),
+    ('𑒻', '𑒾'),
+    ('𑓁', '𑓁'),
+    ('\u{115af}', '𑖱'),
+    ('𑖸', '𑖻'),
+    ('𑖾', '𑖾'),
+    ('𑘰', '𑘲'),
+    ('𑘻', '𑘼'),
+    ('𑘾', '𑘾'),
+    ('𑚬', '𑚬'),
+    ('𑚮', '𑚯'),
+    ('𑚶', '𑚶'),
+    ('𑜠', '𑜡'),
+    ('𑜦', '𑜦'),
+    ('𑠬', '𑠮'),
+    ('𑠸', '𑠸'),
+    ('\u{11930}', '𑤵'),
+    ('𑤷', '𑤸'),
+    ('𑤽', '𑤽'),
+    ('𑥀', '𑥀'),
+    ('𑥂', '𑥂'),
+    ('𑧑', '𑧓'),
+    ('𑧜', '𑧟'),
+    ('𑧤', '𑧤'),
+    ('𑨹', '𑨹'),
+    ('𑩗', '𑩘'),
+    ('𑪗', '𑪗'),
+    ('𑰯', '𑰯'),
+    ('𑰾', '𑰾'),
+    ('𑲩', '𑲩'),
+    ('𑲱', '𑲱'),
+    ('𑲴', '𑲴'),
+    ('𑶊', '𑶎'),
+    ('𑶓', '𑶔'),
+    ('𑶖', '𑶖'),
+    ('𑻵', '𑻶'),
+    ('𑼃', '𑼃'),
+    ('𑼴', '𑼵'),
+    ('𑼾', '𑼿'),
+    ('𑽁', '𑽁'),
+    ('𖽑', '𖾇'),
+    ('𖿰', '𖿱'),
+    ('\u{1d165}', '𝅦'),
+    ('𝅭', '\u{1d172}'),
+];
+
+pub const SYMBOL: &'static [(char, char)] = &[
+    ('$', '$'),
+    ('+', '+'),
+    ('<', '>'),
+    ('^', '^'),
+    ('`', '`'),
+    ('|', '|'),
+    ('~', '~'),
+    ('¢', '¦'),
+    ('¨', '©'),
+    ('¬', '¬'),
+    ('®', '±'),
+    ('´', '´'),
+    ('¸', '¸'),
+    ('×', '×'),
+    ('÷', '÷'),
+    ('˂', '˅'),
+    ('˒', '˟'),
+    ('˥', '˫'),
+    ('˭', '˭'),
+    ('˯', '˿'),
+    ('͵', '͵'),
+    ('΄', '΅'),
+    ('϶', '϶'),
+    ('҂', '҂'),
+    ('֍', '֏'),
+    ('؆', '؈'),
+    ('؋', '؋'),
+    ('؎', '؏'),
+    ('۞', '۞'),
+    ('۩', '۩'),
+    ('۽', '۾'),
+    ('߶', '߶'),
+    ('߾', '߿'),
+    ('࢈', '࢈'),
+    ('৲', '৳'),
+    ('৺', '৻'),
+    ('૱', '૱'),
+    ('୰', '୰'),
+    ('௳', '௺'),
+    ('౿', '౿'),
+    ('൏', '൏'),
+    ('൹', '൹'),
+    ('฿', '฿'),
+    ('༁', '༃'),
+    ('༓', '༓'),
+    ('༕', '༗'),
+    ('༚', '༟'),
+    ('༴', '༴'),
+    ('༶', '༶'),
+    ('༸', '༸'),
+    ('྾', '࿅'),
+    ('࿇', '࿌'),
+    ('࿎', '࿏'),
+    ('࿕', '࿘'),
+    ('႞', '႟'),
+    ('᎐', '᎙'),
+    ('᙭', '᙭'),
+    ('៛', '៛'),
+    ('᥀', '᥀'),
+    ('᧞', '᧿'),
+    ('᭡', '᭪'),
+    ('᭴', '᭼'),
+    ('᾽', '᾽'),
+    ('᾿', '῁'),
+    ('῍', '῏'),
+    ('῝', '῟'),
+    ('῭', '`'),
+    ('´', '῾'),
+    ('⁄', '⁄'),
+    ('⁒', '⁒'),
+    ('⁺', '⁼'),
+    ('₊', '₌'),
+    ('₠', '⃀'),
+    ('℀', '℁'),
+    ('℃', '℆'),
+    ('℈', '℉'),
+    ('℔', '℔'),
+    ('№', '℘'),
+    ('℞', '℣'),
+    ('℥', '℥'),
+    ('℧', '℧'),
+    ('℩', '℩'),
+    ('℮', '℮'),
+    ('℺', '℻'),
+    ('⅀', '⅄'),
+    ('⅊', '⅍'),
+    ('⅏', '⅏'),
+    ('↊', '↋'),
+    ('←', '⌇'),
+    ('⌌', '⌨'),
+    ('⌫', '␦'),
+    ('⑀', '⑊'),
+    ('⒜', 'ⓩ'),
+    ('─', '❧'),
+    ('➔', '⟄'),
+    ('⟇', '⟥'),
+    ('⟰', '⦂'),
+    ('⦙', '⧗'),
+    ('⧜', '⧻'),
+    ('⧾', '⭳'),
+    ('⭶', '⮕'),
+    ('⮗', '⯿'),
+    ('⳥', '⳪'),
+    ('⹐', '⹑'),
+    ('⺀', '⺙'),
+    ('⺛', '⻳'),
+    ('⼀', '⿕'),
+    ('⿰', '⿻'),
+    ('〄', '〄'),
+    ('〒', '〓'),
+    ('〠', '〠'),
+    ('〶', '〷'),
+    ('〾', '〿'),
+    ('゛', '゜'),
+    ('㆐', '㆑'),
+    ('㆖', '㆟'),
+    ('㇀', '㇣'),
+    ('㈀', '㈞'),
+    ('㈪', '㉇'),
+    ('㉐', '㉐'),
+    ('㉠', '㉿'),
+    ('㊊', '㊰'),
+    ('㋀', '㏿'),
+    ('䷀', '䷿'),
+    ('꒐', '꓆'),
+    ('꜀', '꜖'),
+    ('꜠', '꜡'),
+    ('꞉', '꞊'),
+    ('꠨', '꠫'),
+    ('꠶', '꠹'),
+    ('꩷', '꩹'),
+    ('꭛', '꭛'),
+    ('꭪', '꭫'),
+    ('﬩', '﬩'),
+    ('﮲', '﯂'),
+    ('﵀', '﵏'),
+    ('﷏', '﷏'),
+    ('﷼', '﷿'),
+    ('﹢', '﹢'),
+    ('﹤', '﹦'),
+    ('﹩', '﹩'),
+    ('＄', '＄'),
+    ('＋', '＋'),
+    ('＜', '＞'),
+    ('＾', '＾'),
+    ('｀', '｀'),
+    ('｜', '｜'),
+    ('～', '～'),
+    ('￠', '￦'),
+    ('￨', '￮'),
+    ('￼', '�'),
+    ('𐄷', '𐄿'),
+    ('𐅹', '𐆉'),
+    ('𐆌', '𐆎'),
+    ('𐆐', '𐆜'),
+    ('𐆠', '𐆠'),
+    ('𐇐', '𐇼'),
+    ('𐡷', '𐡸'),
+    ('𐫈', '𐫈'),
+    ('𑜿', '𑜿'),
+    ('𑿕', '𑿱'),
+    ('𖬼', '𖬿'),
+    ('𖭅', '𖭅'),
+    ('𛲜', '𛲜'),
+    ('𜽐', '𜿃'),
+    ('𝀀', '𝃵'),
+    ('𝄀', '𝄦'),
+    ('𝄩', '𝅘𝅥𝅲'),
+    ('𝅪', '𝅬'),
+    ('𝆃', '𝆄'),
+    ('𝆌', '𝆩'),
+    ('𝆮', '𝇪'),
+    ('𝈀', '𝉁'),
+    ('𝉅', '𝉅'),
+    ('𝌀', '𝍖'),
+    ('𝛁', '𝛁'),
+    ('𝛛', '𝛛'),
+    ('𝛻', '𝛻'),
+    ('𝜕', '𝜕'),
+    ('𝜵', '𝜵'),
+    ('𝝏', '𝝏'),
+    ('𝝯', '𝝯'),
+    ('𝞉', '𝞉'),
+    ('𝞩', '𝞩'),
+    ('𝟃', '𝟃'),
+    ('𝠀', '𝧿'),
+    ('𝨷', '𝨺'),
+    ('𝩭', '𝩴'),
+    ('𝩶', '𝪃'),
+    ('𝪅', '𝪆'),
+    ('𞅏', '𞅏'),
+    ('𞋿', '𞋿'),
+    ('𞲬', '𞲬'),
+    ('𞲰', '𞲰'),
+    ('𞴮', '𞴮'),
+    ('𞻰', '𞻱'),
+    ('🀀', '🀫'),
+    ('🀰', '🂓'),
+    ('🂠', '🂮'),
+    ('🂱', '🂿'),
+    ('🃁', '🃏'),
+    ('🃑', '🃵'),
+    ('🄍', '🆭'),
+    ('🇦', '🈂'),
+    ('🈐', '🈻'),
+    ('🉀', '🉈'),
+    ('🉐', '🉑'),
+    ('🉠', '🉥'),
+    ('🌀', '🛗'),
+    ('🛜', '🛬'),
+    ('🛰', '🛼'),
+    ('🜀', '🝶'),
+    ('🝻', '🟙'),
+    ('🟠', '🟫'),
+    ('🟰', '🟰'),
+    ('🠀', '🠋'),
+    ('🠐', '🡇'),
+    ('🡐', '🡙'),
+    ('🡠', '🢇'),
+    ('🢐', '🢭'),
+    ('🢰', '🢱'),
+    ('🤀', '🩓'),
+    ('🩠', '🩭'),
+    ('🩰', '🩼'),
+    ('🪀', '🪈'),
+    ('🪐', '🪽'),
+    ('🪿', '🫅'),
+    ('🫎', '🫛'),
+    ('🫠', '🫨'),
+    ('🫰', '🫸'),
+    ('🬀', '🮒'),
+    ('🮔', '🯊'),
+];
+
+pub const TITLECASE_LETTER: &'static [(char, char)] = &[
+    ('ǅ', 'ǅ'),
+    ('ǈ', 'ǈ'),
+    ('ǋ', 'ǋ'),
+    ('ǲ', 'ǲ'),
+    ('ᾈ', 'ᾏ'),
+    ('ᾘ', 'ᾟ'),
+    ('ᾨ', 'ᾯ'),
+    ('ᾼ', 'ᾼ'),
+    ('ῌ', 'ῌ'),
+    ('ῼ', 'ῼ'),
+];
+
+pub const UNASSIGNED: &'static [(char, char)] = &[
+    ('\u{378}', '\u{379}'),
+    ('\u{380}', '\u{383}'),
+    ('\u{38b}', '\u{38b}'),
+    ('\u{38d}', '\u{38d}'),
+    ('\u{3a2}', '\u{3a2}'),
+    ('\u{530}', '\u{530}'),
+    ('\u{557}', '\u{558}'),
+    ('\u{58b}', '\u{58c}'),
+    ('\u{590}', '\u{590}'),
+    ('\u{5c8}', '\u{5cf}'),
+    ('\u{5eb}', '\u{5ee}'),
+    ('\u{5f5}', '\u{5ff}'),
+    ('\u{70e}', '\u{70e}'),
+    ('\u{74b}', '\u{74c}'),
+    ('\u{7b2}', '\u{7bf}'),
+    ('\u{7fb}', '\u{7fc}'),
+    ('\u{82e}', '\u{82f}'),
+    ('\u{83f}', '\u{83f}'),
+    ('\u{85c}', '\u{85d}'),
+    ('\u{85f}', '\u{85f}'),
+    ('\u{86b}', '\u{86f}'),
+    ('\u{88f}', '\u{88f}'),
+    ('\u{892}', '\u{897}'),
+    ('\u{984}', '\u{984}'),
+    ('\u{98d}', '\u{98e}'),
+    ('\u{991}', '\u{992}'),
+    ('\u{9a9}', '\u{9a9}'),
+    ('\u{9b1}', '\u{9b1}'),
+    ('\u{9b3}', '\u{9b5}'),
+    ('\u{9ba}', '\u{9bb}'),
+    ('\u{9c5}', '\u{9c6}'),
+    ('\u{9c9}', '\u{9ca}'),
+    ('\u{9cf}', '\u{9d6}'),
+    ('\u{9d8}', '\u{9db}'),
+    ('\u{9de}', '\u{9de}'),
+    ('\u{9e4}', '\u{9e5}'),
+    ('\u{9ff}', '\u{a00}'),
+    ('\u{a04}', '\u{a04}'),
+    ('\u{a0b}', '\u{a0e}'),
+    ('\u{a11}', '\u{a12}'),
+    ('\u{a29}', '\u{a29}'),
+    ('\u{a31}', '\u{a31}'),
+    ('\u{a34}', '\u{a34}'),
+    ('\u{a37}', '\u{a37}'),
+    ('\u{a3a}', '\u{a3b}'),
+    ('\u{a3d}', '\u{a3d}'),
+    ('\u{a43}', '\u{a46}'),
+    ('\u{a49}', '\u{a4a}'),
+    ('\u{a4e}', '\u{a50}'),
+    ('\u{a52}', '\u{a58}'),
+    ('\u{a5d}', '\u{a5d}'),
+    ('\u{a5f}', '\u{a65}'),
+    ('\u{a77}', '\u{a80}'),
+    ('\u{a84}', '\u{a84}'),
+    ('\u{a8e}', '\u{a8e}'),
+    ('\u{a92}', '\u{a92}'),
+    ('\u{aa9}', '\u{aa9}'),
+    ('\u{ab1}', '\u{ab1}'),
+    ('\u{ab4}', '\u{ab4}'),
+    ('\u{aba}', '\u{abb}'),
+    ('\u{ac6}', '\u{ac6}'),
+    ('\u{aca}', '\u{aca}'),
+    ('\u{ace}', '\u{acf}'),
+    ('\u{ad1}', '\u{adf}'),
+    ('\u{ae4}', '\u{ae5}'),
+    ('\u{af2}', '\u{af8}'),
+    ('\u{b00}', '\u{b00}'),
+    ('\u{b04}', '\u{b04}'),
+    ('\u{b0d}', '\u{b0e}'),
+    ('\u{b11}', '\u{b12}'),
+    ('\u{b29}', '\u{b29}'),
+    ('\u{b31}', '\u{b31}'),
+    ('\u{b34}', '\u{b34}'),
+    ('\u{b3a}', '\u{b3b}'),
+    ('\u{b45}', '\u{b46}'),
+    ('\u{b49}', '\u{b4a}'),
+    ('\u{b4e}', '\u{b54}'),
+    ('\u{b58}', '\u{b5b}'),
+    ('\u{b5e}', '\u{b5e}'),
+    ('\u{b64}', '\u{b65}'),
+    ('\u{b78}', '\u{b81}'),
+    ('\u{b84}', '\u{b84}'),
+    ('\u{b8b}', '\u{b8d}'),
+    ('\u{b91}', '\u{b91}'),
+    ('\u{b96}', '\u{b98}'),
+    ('\u{b9b}', '\u{b9b}'),
+    ('\u{b9d}', '\u{b9d}'),
+    ('\u{ba0}', '\u{ba2}'),
+    ('\u{ba5}', '\u{ba7}'),
+    ('\u{bab}', '\u{bad}'),
+    ('\u{bba}', '\u{bbd}'),
+    ('\u{bc3}', '\u{bc5}'),
+    ('\u{bc9}', '\u{bc9}'),
+    ('\u{bce}', '\u{bcf}'),
+    ('\u{bd1}', '\u{bd6}'),
+    ('\u{bd8}', '\u{be5}'),
+    ('\u{bfb}', '\u{bff}'),
+    ('\u{c0d}', '\u{c0d}'),
+    ('\u{c11}', '\u{c11}'),
+    ('\u{c29}', '\u{c29}'),
+    ('\u{c3a}', '\u{c3b}'),
+    ('\u{c45}', '\u{c45}'),
+    ('\u{c49}', '\u{c49}'),
+    ('\u{c4e}', '\u{c54}'),
+    ('\u{c57}', '\u{c57}'),
+    ('\u{c5b}', '\u{c5c}'),
+    ('\u{c5e}', '\u{c5f}'),
+    ('\u{c64}', '\u{c65}'),
+    ('\u{c70}', '\u{c76}'),
+    ('\u{c8d}', '\u{c8d}'),
+    ('\u{c91}', '\u{c91}'),
+    ('\u{ca9}', '\u{ca9}'),
+    ('\u{cb4}', '\u{cb4}'),
+    ('\u{cba}', '\u{cbb}'),
+    ('\u{cc5}', '\u{cc5}'),
+    ('\u{cc9}', '\u{cc9}'),
+    ('\u{cce}', '\u{cd4}'),
+    ('\u{cd7}', '\u{cdc}'),
+    ('\u{cdf}', '\u{cdf}'),
+    ('\u{ce4}', '\u{ce5}'),
+    ('\u{cf0}', '\u{cf0}'),
+    ('\u{cf4}', '\u{cff}'),
+    ('\u{d0d}', '\u{d0d}'),
+    ('\u{d11}', '\u{d11}'),
+    ('\u{d45}', '\u{d45}'),
+    ('\u{d49}', '\u{d49}'),
+    ('\u{d50}', '\u{d53}'),
+    ('\u{d64}', '\u{d65}'),
+    ('\u{d80}', '\u{d80}'),
+    ('\u{d84}', '\u{d84}'),
+    ('\u{d97}', '\u{d99}'),
+    ('\u{db2}', '\u{db2}'),
+    ('\u{dbc}', '\u{dbc}'),
+    ('\u{dbe}', '\u{dbf}'),
+    ('\u{dc7}', '\u{dc9}'),
+    ('\u{dcb}', '\u{dce}'),
+    ('\u{dd5}', '\u{dd5}'),
+    ('\u{dd7}', '\u{dd7}'),
+    ('\u{de0}', '\u{de5}'),
+    ('\u{df0}', '\u{df1}'),
+    ('\u{df5}', '\u{e00}'),
+    ('\u{e3b}', '\u{e3e}'),
+    ('\u{e5c}', '\u{e80}'),
+    ('\u{e83}', '\u{e83}'),
+    ('\u{e85}', '\u{e85}'),
+    ('\u{e8b}', '\u{e8b}'),
+    ('\u{ea4}', '\u{ea4}'),
+    ('\u{ea6}', '\u{ea6}'),
+    ('\u{ebe}', '\u{ebf}'),
+    ('\u{ec5}', '\u{ec5}'),
+    ('\u{ec7}', '\u{ec7}'),
+    ('\u{ecf}', '\u{ecf}'),
+    ('\u{eda}', '\u{edb}'),
+    ('\u{ee0}', '\u{eff}'),
+    ('\u{f48}', '\u{f48}'),
+    ('\u{f6d}', '\u{f70}'),
+    ('\u{f98}', '\u{f98}'),
+    ('\u{fbd}', '\u{fbd}'),
+    ('\u{fcd}', '\u{fcd}'),
+    ('\u{fdb}', '\u{fff}'),
+    ('\u{10c6}', '\u{10c6}'),
+    ('\u{10c8}', '\u{10cc}'),
+    ('\u{10ce}', '\u{10cf}'),
+    ('\u{1249}', '\u{1249}'),
+    ('\u{124e}', '\u{124f}'),
+    ('\u{1257}', '\u{1257}'),
+    ('\u{1259}', '\u{1259}'),
+    ('\u{125e}', '\u{125f}'),
+    ('\u{1289}', '\u{1289}'),
+    ('\u{128e}', '\u{128f}'),
+    ('\u{12b1}', '\u{12b1}'),
+    ('\u{12b6}', '\u{12b7}'),
+    ('\u{12bf}', '\u{12bf}'),
+    ('\u{12c1}', '\u{12c1}'),
+    ('\u{12c6}', '\u{12c7}'),
+    ('\u{12d7}', '\u{12d7}'),
+    ('\u{1311}', '\u{1311}'),
+    ('\u{1316}', '\u{1317}'),
+    ('\u{135b}', '\u{135c}'),
+    ('\u{137d}', '\u{137f}'),
+    ('\u{139a}', '\u{139f}'),
+    ('\u{13f6}', '\u{13f7}'),
+    ('\u{13fe}', '\u{13ff}'),
+    ('\u{169d}', '\u{169f}'),
+    ('\u{16f9}', '\u{16ff}'),
+    ('\u{1716}', '\u{171e}'),
+    ('\u{1737}', '\u{173f}'),
+    ('\u{1754}', '\u{175f}'),
+    ('\u{176d}', '\u{176d}'),
+    ('\u{1771}', '\u{1771}'),
+    ('\u{1774}', '\u{177f}'),
+    ('\u{17de}', '\u{17df}'),
+    ('\u{17ea}', '\u{17ef}'),
+    ('\u{17fa}', '\u{17ff}'),
+    ('\u{181a}', '\u{181f}'),
+    ('\u{1879}', '\u{187f}'),
+    ('\u{18ab}', '\u{18af}'),
+    ('\u{18f6}', '\u{18ff}'),
+    ('\u{191f}', '\u{191f}'),
+    ('\u{192c}', '\u{192f}'),
+    ('\u{193c}', '\u{193f}'),
+    ('\u{1941}', '\u{1943}'),
+    ('\u{196e}', '\u{196f}'),
+    ('\u{1975}', '\u{197f}'),
+    ('\u{19ac}', '\u{19af}'),
+    ('\u{19ca}', '\u{19cf}'),
+    ('\u{19db}', '\u{19dd}'),
+    ('\u{1a1c}', '\u{1a1d}'),
+    ('\u{1a5f}', '\u{1a5f}'),
+    ('\u{1a7d}', '\u{1a7e}'),
+    ('\u{1a8a}', '\u{1a8f}'),
+    ('\u{1a9a}', '\u{1a9f}'),
+    ('\u{1aae}', '\u{1aaf}'),
+    ('\u{1acf}', '\u{1aff}'),
+    ('\u{1b4d}', '\u{1b4f}'),
+    ('\u{1b7f}', '\u{1b7f}'),
+    ('\u{1bf4}', '\u{1bfb}'),
+    ('\u{1c38}', '\u{1c3a}'),
+    ('\u{1c4a}', '\u{1c4c}'),
+    ('\u{1c89}', '\u{1c8f}'),
+    ('\u{1cbb}', '\u{1cbc}'),
+    ('\u{1cc8}', '\u{1ccf}'),
+    ('\u{1cfb}', '\u{1cff}'),
+    ('\u{1f16}', '\u{1f17}'),
+    ('\u{1f1e}', '\u{1f1f}'),
+    ('\u{1f46}', '\u{1f47}'),
+    ('\u{1f4e}', '\u{1f4f}'),
+    ('\u{1f58}', '\u{1f58}'),
+    ('\u{1f5a}', '\u{1f5a}'),
+    ('\u{1f5c}', '\u{1f5c}'),
+    ('\u{1f5e}', '\u{1f5e}'),
+    ('\u{1f7e}', '\u{1f7f}'),
+    ('\u{1fb5}', '\u{1fb5}'),
+    ('\u{1fc5}', '\u{1fc5}'),
+    ('\u{1fd4}', '\u{1fd5}'),
+    ('\u{1fdc}', '\u{1fdc}'),
+    ('\u{1ff0}', '\u{1ff1}'),
+    ('\u{1ff5}', '\u{1ff5}'),
+    ('\u{1fff}', '\u{1fff}'),
+    ('\u{2065}', '\u{2065}'),
+    ('\u{2072}', '\u{2073}'),
+    ('\u{208f}', '\u{208f}'),
+    ('\u{209d}', '\u{209f}'),
+    ('\u{20c1}', '\u{20cf}'),
+    ('\u{20f1}', '\u{20ff}'),
+    ('\u{218c}', '\u{218f}'),
+    ('\u{2427}', '\u{243f}'),
+    ('\u{244b}', '\u{245f}'),
+    ('\u{2b74}', '\u{2b75}'),
+    ('\u{2b96}', '\u{2b96}'),
+    ('\u{2cf4}', '\u{2cf8}'),
+    ('\u{2d26}', '\u{2d26}'),
+    ('\u{2d28}', '\u{2d2c}'),
+    ('\u{2d2e}', '\u{2d2f}'),
+    ('\u{2d68}', '\u{2d6e}'),
+    ('\u{2d71}', '\u{2d7e}'),
+    ('\u{2d97}', '\u{2d9f}'),
+    ('\u{2da7}', '\u{2da7}'),
+    ('\u{2daf}', '\u{2daf}'),
+    ('\u{2db7}', '\u{2db7}'),
+    ('\u{2dbf}', '\u{2dbf}'),
+    ('\u{2dc7}', '\u{2dc7}'),
+    ('\u{2dcf}', '\u{2dcf}'),
+    ('\u{2dd7}', '\u{2dd7}'),
+    ('\u{2ddf}', '\u{2ddf}'),
+    ('\u{2e5e}', '\u{2e7f}'),
+    ('\u{2e9a}', '\u{2e9a}'),
+    ('\u{2ef4}', '\u{2eff}'),
+    ('\u{2fd6}', '\u{2fef}'),
+    ('\u{2ffc}', '\u{2fff}'),
+    ('\u{3040}', '\u{3040}'),
+    ('\u{3097}', '\u{3098}'),
+    ('\u{3100}', '\u{3104}'),
+    ('\u{3130}', '\u{3130}'),
+    ('\u{318f}', '\u{318f}'),
+    ('\u{31e4}', '\u{31ef}'),
+    ('\u{321f}', '\u{321f}'),
+    ('\u{a48d}', '\u{a48f}'),
+    ('\u{a4c7}', '\u{a4cf}'),
+    ('\u{a62c}', '\u{a63f}'),
+    ('\u{a6f8}', '\u{a6ff}'),
+    ('\u{a7cb}', '\u{a7cf}'),
+    ('\u{a7d2}', '\u{a7d2}'),
+    ('\u{a7d4}', '\u{a7d4}'),
+    ('\u{a7da}', '\u{a7f1}'),
+    ('\u{a82d}', '\u{a82f}'),
+    ('\u{a83a}', '\u{a83f}'),
+    ('\u{a878}', '\u{a87f}'),
+    ('\u{a8c6}', '\u{a8cd}'),
+    ('\u{a8da}', '\u{a8df}'),
+    ('\u{a954}', '\u{a95e}'),
+    ('\u{a97d}', '\u{a97f}'),
+    ('\u{a9ce}', '\u{a9ce}'),
+    ('\u{a9da}', '\u{a9dd}'),
+    ('\u{a9ff}', '\u{a9ff}'),
+    ('\u{aa37}', '\u{aa3f}'),
+    ('\u{aa4e}', '\u{aa4f}'),
+    ('\u{aa5a}', '\u{aa5b}'),
+    ('\u{aac3}', '\u{aada}'),
+    ('\u{aaf7}', '\u{ab00}'),
+    ('\u{ab07}', '\u{ab08}'),
+    ('\u{ab0f}', '\u{ab10}'),
+    ('\u{ab17}', '\u{ab1f}'),
+    ('\u{ab27}', '\u{ab27}'),
+    ('\u{ab2f}', '\u{ab2f}'),
+    ('\u{ab6c}', '\u{ab6f}'),
+    ('\u{abee}', '\u{abef}'),
+    ('\u{abfa}', '\u{abff}'),
+    ('\u{d7a4}', '\u{d7af}'),
+    ('\u{d7c7}', '\u{d7ca}'),
+    ('\u{d7fc}', '\u{d7ff}'),
+    ('\u{fa6e}', '\u{fa6f}'),
+    ('\u{fada}', '\u{faff}'),
+    ('\u{fb07}', '\u{fb12}'),
+    ('\u{fb18}', '\u{fb1c}'),
+    ('\u{fb37}', '\u{fb37}'),
+    ('\u{fb3d}', '\u{fb3d}'),
+    ('\u{fb3f}', '\u{fb3f}'),
+    ('\u{fb42}', '\u{fb42}'),
+    ('\u{fb45}', '\u{fb45}'),
+    ('\u{fbc3}', '\u{fbd2}'),
+    ('\u{fd90}', '\u{fd91}'),
+    ('\u{fdc8}', '\u{fdce}'),
+    ('\u{fdd0}', '\u{fdef}'),
+    ('\u{fe1a}', '\u{fe1f}'),
+    ('\u{fe53}', '\u{fe53}'),
+    ('\u{fe67}', '\u{fe67}'),
+    ('\u{fe6c}', '\u{fe6f}'),
+    ('\u{fe75}', '\u{fe75}'),
+    ('\u{fefd}', '\u{fefe}'),
+    ('\u{ff00}', '\u{ff00}'),
+    ('\u{ffbf}', '\u{ffc1}'),
+    ('\u{ffc8}', '\u{ffc9}'),
+    ('\u{ffd0}', '\u{ffd1}'),
+    ('\u{ffd8}', '\u{ffd9}'),
+    ('\u{ffdd}', '\u{ffdf}'),
+    ('\u{ffe7}', '\u{ffe7}'),
+    ('\u{ffef}', '\u{fff8}'),
+    ('\u{fffe}', '\u{ffff}'),
+    ('\u{1000c}', '\u{1000c}'),
+    ('\u{10027}', '\u{10027}'),
+    ('\u{1003b}', '\u{1003b}'),
+    ('\u{1003e}', '\u{1003e}'),
+    ('\u{1004e}', '\u{1004f}'),
+    ('\u{1005e}', '\u{1007f}'),
+    ('\u{100fb}', '\u{100ff}'),
+    ('\u{10103}', '\u{10106}'),
+    ('\u{10134}', '\u{10136}'),
+    ('\u{1018f}', '\u{1018f}'),
+    ('\u{1019d}', '\u{1019f}'),
+    ('\u{101a1}', '\u{101cf}'),
+    ('\u{101fe}', '\u{1027f}'),
+    ('\u{1029d}', '\u{1029f}'),
+    ('\u{102d1}', '\u{102df}'),
+    ('\u{102fc}', '\u{102ff}'),
+    ('\u{10324}', '\u{1032c}'),
+    ('\u{1034b}', '\u{1034f}'),
+    ('\u{1037b}', '\u{1037f}'),
+    ('\u{1039e}', '\u{1039e}'),
+    ('\u{103c4}', '\u{103c7}'),
+    ('\u{103d6}', '\u{103ff}'),
+    ('\u{1049e}', '\u{1049f}'),
+    ('\u{104aa}', '\u{104af}'),
+    ('\u{104d4}', '\u{104d7}'),
+    ('\u{104fc}', '\u{104ff}'),
+    ('\u{10528}', '\u{1052f}'),
+    ('\u{10564}', '\u{1056e}'),
+    ('\u{1057b}', '\u{1057b}'),
+    ('\u{1058b}', '\u{1058b}'),
+    ('\u{10593}', '\u{10593}'),
+    ('\u{10596}', '\u{10596}'),
+    ('\u{105a2}', '\u{105a2}'),
+    ('\u{105b2}', '\u{105b2}'),
+    ('\u{105ba}', '\u{105ba}'),
+    ('\u{105bd}', '\u{105ff}'),
+    ('\u{10737}', '\u{1073f}'),
+    ('\u{10756}', '\u{1075f}'),
+    ('\u{10768}', '\u{1077f}'),
+    ('\u{10786}', '\u{10786}'),
+    ('\u{107b1}', '\u{107b1}'),
+    ('\u{107bb}', '\u{107ff}'),
+    ('\u{10806}', '\u{10807}'),
+    ('\u{10809}', '\u{10809}'),
+    ('\u{10836}', '\u{10836}'),
+    ('\u{10839}', '\u{1083b}'),
+    ('\u{1083d}', '\u{1083e}'),
+    ('\u{10856}', '\u{10856}'),
+    ('\u{1089f}', '\u{108a6}'),
+    ('\u{108b0}', '\u{108df}'),
+    ('\u{108f3}', '\u{108f3}'),
+    ('\u{108f6}', '\u{108fa}'),
+    ('\u{1091c}', '\u{1091e}'),
+    ('\u{1093a}', '\u{1093e}'),
+    ('\u{10940}', '\u{1097f}'),
+    ('\u{109b8}', '\u{109bb}'),
+    ('\u{109d0}', '\u{109d1}'),
+    ('\u{10a04}', '\u{10a04}'),
+    ('\u{10a07}', '\u{10a0b}'),
+    ('\u{10a14}', '\u{10a14}'),
+    ('\u{10a18}', '\u{10a18}'),
+    ('\u{10a36}', '\u{10a37}'),
+    ('\u{10a3b}', '\u{10a3e}'),
+    ('\u{10a49}', '\u{10a4f}'),
+    ('\u{10a59}', '\u{10a5f}'),
+    ('\u{10aa0}', '\u{10abf}'),
+    ('\u{10ae7}', '\u{10aea}'),
+    ('\u{10af7}', '\u{10aff}'),
+    ('\u{10b36}', '\u{10b38}'),
+    ('\u{10b56}', '\u{10b57}'),
+    ('\u{10b73}', '\u{10b77}'),
+    ('\u{10b92}', '\u{10b98}'),
+    ('\u{10b9d}', '\u{10ba8}'),
+    ('\u{10bb0}', '\u{10bff}'),
+    ('\u{10c49}', '\u{10c7f}'),
+    ('\u{10cb3}', '\u{10cbf}'),
+    ('\u{10cf3}', '\u{10cf9}'),
+    ('\u{10d28}', '\u{10d2f}'),
+    ('\u{10d3a}', '\u{10e5f}'),
+    ('\u{10e7f}', '\u{10e7f}'),
+    ('\u{10eaa}', '\u{10eaa}'),
+    ('\u{10eae}', '\u{10eaf}'),
+    ('\u{10eb2}', '\u{10efc}'),
+    ('\u{10f28}', '\u{10f2f}'),
+    ('\u{10f5a}', '\u{10f6f}'),
+    ('\u{10f8a}', '\u{10faf}'),
+    ('\u{10fcc}', '\u{10fdf}'),
+    ('\u{10ff7}', '\u{10fff}'),
+    ('\u{1104e}', '\u{11051}'),
+    ('\u{11076}', '\u{1107e}'),
+    ('\u{110c3}', '\u{110cc}'),
+    ('\u{110ce}', '\u{110cf}'),
+    ('\u{110e9}', '\u{110ef}'),
+    ('\u{110fa}', '\u{110ff}'),
+    ('\u{11135}', '\u{11135}'),
+    ('\u{11148}', '\u{1114f}'),
+    ('\u{11177}', '\u{1117f}'),
+    ('\u{111e0}', '\u{111e0}'),
+    ('\u{111f5}', '\u{111ff}'),
+    ('\u{11212}', '\u{11212}'),
+    ('\u{11242}', '\u{1127f}'),
+    ('\u{11287}', '\u{11287}'),
+    ('\u{11289}', '\u{11289}'),
+    ('\u{1128e}', '\u{1128e}'),
+    ('\u{1129e}', '\u{1129e}'),
+    ('\u{112aa}', '\u{112af}'),
+    ('\u{112eb}', '\u{112ef}'),
+    ('\u{112fa}', '\u{112ff}'),
+    ('\u{11304}', '\u{11304}'),
+    ('\u{1130d}', '\u{1130e}'),
+    ('\u{11311}', '\u{11312}'),
+    ('\u{11329}', '\u{11329}'),
+    ('\u{11331}', '\u{11331}'),
+    ('\u{11334}', '\u{11334}'),
+    ('\u{1133a}', '\u{1133a}'),
+    ('\u{11345}', '\u{11346}'),
+    ('\u{11349}', '\u{1134a}'),
+    ('\u{1134e}', '\u{1134f}'),
+    ('\u{11351}', '\u{11356}'),
+    ('\u{11358}', '\u{1135c}'),
+    ('\u{11364}', '\u{11365}'),
+    ('\u{1136d}', '\u{1136f}'),
+    ('\u{11375}', '\u{113ff}'),
+    ('\u{1145c}', '\u{1145c}'),
+    ('\u{11462}', '\u{1147f}'),
+    ('\u{114c8}', '\u{114cf}'),
+    ('\u{114da}', '\u{1157f}'),
+    ('\u{115b6}', '\u{115b7}'),
+    ('\u{115de}', '\u{115ff}'),
+    ('\u{11645}', '\u{1164f}'),
+    ('\u{1165a}', '\u{1165f}'),
+    ('\u{1166d}', '\u{1167f}'),
+    ('\u{116ba}', '\u{116bf}'),
+    ('\u{116ca}', '\u{116ff}'),
+    ('\u{1171b}', '\u{1171c}'),
+    ('\u{1172c}', '\u{1172f}'),
+    ('\u{11747}', '\u{117ff}'),
+    ('\u{1183c}', '\u{1189f}'),
+    ('\u{118f3}', '\u{118fe}'),
+    ('\u{11907}', '\u{11908}'),
+    ('\u{1190a}', '\u{1190b}'),
+    ('\u{11914}', '\u{11914}'),
+    ('\u{11917}', '\u{11917}'),
+    ('\u{11936}', '\u{11936}'),
+    ('\u{11939}', '\u{1193a}'),
+    ('\u{11947}', '\u{1194f}'),
+    ('\u{1195a}', '\u{1199f}'),
+    ('\u{119a8}', '\u{119a9}'),
+    ('\u{119d8}', '\u{119d9}'),
+    ('\u{119e5}', '\u{119ff}'),
+    ('\u{11a48}', '\u{11a4f}'),
+    ('\u{11aa3}', '\u{11aaf}'),
+    ('\u{11af9}', '\u{11aff}'),
+    ('\u{11b0a}', '\u{11bff}'),
+    ('\u{11c09}', '\u{11c09}'),
+    ('\u{11c37}', '\u{11c37}'),
+    ('\u{11c46}', '\u{11c4f}'),
+    ('\u{11c6d}', '\u{11c6f}'),
+    ('\u{11c90}', '\u{11c91}'),
+    ('\u{11ca8}', '\u{11ca8}'),
+    ('\u{11cb7}', '\u{11cff}'),
+    ('\u{11d07}', '\u{11d07}'),
+    ('\u{11d0a}', '\u{11d0a}'),
+    ('\u{11d37}', '\u{11d39}'),
+    ('\u{11d3b}', '\u{11d3b}'),
+    ('\u{11d3e}', '\u{11d3e}'),
+    ('\u{11d48}', '\u{11d4f}'),
+    ('\u{11d5a}', '\u{11d5f}'),
+    ('\u{11d66}', '\u{11d66}'),
+    ('\u{11d69}', '\u{11d69}'),
+    ('\u{11d8f}', '\u{11d8f}'),
+    ('\u{11d92}', '\u{11d92}'),
+    ('\u{11d99}', '\u{11d9f}'),
+    ('\u{11daa}', '\u{11edf}'),
+    ('\u{11ef9}', '\u{11eff}'),
+    ('\u{11f11}', '\u{11f11}'),
+    ('\u{11f3b}', '\u{11f3d}'),
+    ('\u{11f5a}', '\u{11faf}'),
+    ('\u{11fb1}', '\u{11fbf}'),
+    ('\u{11ff2}', '\u{11ffe}'),
+    ('\u{1239a}', '\u{123ff}'),
+    ('\u{1246f}', '\u{1246f}'),
+    ('\u{12475}', '\u{1247f}'),
+    ('\u{12544}', '\u{12f8f}'),
+    ('\u{12ff3}', '\u{12fff}'),
+    ('\u{13456}', '\u{143ff}'),
+    ('\u{14647}', '\u{167ff}'),
+    ('\u{16a39}', '\u{16a3f}'),
+    ('\u{16a5f}', '\u{16a5f}'),
+    ('\u{16a6a}', '\u{16a6d}'),
+    ('\u{16abf}', '\u{16abf}'),
+    ('\u{16aca}', '\u{16acf}'),
+    ('\u{16aee}', '\u{16aef}'),
+    ('\u{16af6}', '\u{16aff}'),
+    ('\u{16b46}', '\u{16b4f}'),
+    ('\u{16b5a}', '\u{16b5a}'),
+    ('\u{16b62}', '\u{16b62}'),
+    ('\u{16b78}', '\u{16b7c}'),
+    ('\u{16b90}', '\u{16e3f}'),
+    ('\u{16e9b}', '\u{16eff}'),
+    ('\u{16f4b}', '\u{16f4e}'),
+    ('\u{16f88}', '\u{16f8e}'),
+    ('\u{16fa0}', '\u{16fdf}'),
+    ('\u{16fe5}', '\u{16fef}'),
+    ('\u{16ff2}', '\u{16fff}'),
+    ('\u{187f8}', '\u{187ff}'),
+    ('\u{18cd6}', '\u{18cff}'),
+    ('\u{18d09}', '\u{1afef}'),
+    ('\u{1aff4}', '\u{1aff4}'),
+    ('\u{1affc}', '\u{1affc}'),
+    ('\u{1afff}', '\u{1afff}'),
+    ('\u{1b123}', '\u{1b131}'),
+    ('\u{1b133}', '\u{1b14f}'),
+    ('\u{1b153}', '\u{1b154}'),
+    ('\u{1b156}', '\u{1b163}'),
+    ('\u{1b168}', '\u{1b16f}'),
+    ('\u{1b2fc}', '\u{1bbff}'),
+    ('\u{1bc6b}', '\u{1bc6f}'),
+    ('\u{1bc7d}', '\u{1bc7f}'),
+    ('\u{1bc89}', '\u{1bc8f}'),
+    ('\u{1bc9a}', '\u{1bc9b}'),
+    ('\u{1bca4}', '\u{1ceff}'),
+    ('\u{1cf2e}', '\u{1cf2f}'),
+    ('\u{1cf47}', '\u{1cf4f}'),
+    ('\u{1cfc4}', '\u{1cfff}'),
+    ('\u{1d0f6}', '\u{1d0ff}'),
+    ('\u{1d127}', '\u{1d128}'),
+    ('\u{1d1eb}', '\u{1d1ff}'),
+    ('\u{1d246}', '\u{1d2bf}'),
+    ('\u{1d2d4}', '\u{1d2df}'),
+    ('\u{1d2f4}', '\u{1d2ff}'),
+    ('\u{1d357}', '\u{1d35f}'),
+    ('\u{1d379}', '\u{1d3ff}'),
+    ('\u{1d455}', '\u{1d455}'),
+    ('\u{1d49d}', '\u{1d49d}'),
+    ('\u{1d4a0}', '\u{1d4a1}'),
+    ('\u{1d4a3}', '\u{1d4a4}'),
+    ('\u{1d4a7}', '\u{1d4a8}'),
+    ('\u{1d4ad}', '\u{1d4ad}'),
+    ('\u{1d4ba}', '\u{1d4ba}'),
+    ('\u{1d4bc}', '\u{1d4bc}'),
+    ('\u{1d4c4}', '\u{1d4c4}'),
+    ('\u{1d506}', '\u{1d506}'),
+    ('\u{1d50b}', '\u{1d50c}'),
+    ('\u{1d515}', '\u{1d515}'),
+    ('\u{1d51d}', '\u{1d51d}'),
+    ('\u{1d53a}', '\u{1d53a}'),
+    ('\u{1d53f}', '\u{1d53f}'),
+    ('\u{1d545}', '\u{1d545}'),
+    ('\u{1d547}', '\u{1d549}'),
+    ('\u{1d551}', '\u{1d551}'),
+    ('\u{1d6a6}', '\u{1d6a7}'),
+    ('\u{1d7cc}', '\u{1d7cd}'),
+    ('\u{1da8c}', '\u{1da9a}'),
+    ('\u{1daa0}', '\u{1daa0}'),
+    ('\u{1dab0}', '\u{1deff}'),
+    ('\u{1df1f}', '\u{1df24}'),
+    ('\u{1df2b}', '\u{1dfff}'),
+    ('\u{1e007}', '\u{1e007}'),
+    ('\u{1e019}', '\u{1e01a}'),
+    ('\u{1e022}', '\u{1e022}'),
+    ('\u{1e025}', '\u{1e025}'),
+    ('\u{1e02b}', '\u{1e02f}'),
+    ('\u{1e06e}', '\u{1e08e}'),
+    ('\u{1e090}', '\u{1e0ff}'),
+    ('\u{1e12d}', '\u{1e12f}'),
+    ('\u{1e13e}', '\u{1e13f}'),
+    ('\u{1e14a}', '\u{1e14d}'),
+    ('\u{1e150}', '\u{1e28f}'),
+    ('\u{1e2af}', '\u{1e2bf}'),
+    ('\u{1e2fa}', '\u{1e2fe}'),
+    ('\u{1e300}', '\u{1e4cf}'),
+    ('\u{1e4fa}', '\u{1e7df}'),
+    ('\u{1e7e7}', '\u{1e7e7}'),
+    ('\u{1e7ec}', '\u{1e7ec}'),
+    ('\u{1e7ef}', '\u{1e7ef}'),
+    ('\u{1e7ff}', '\u{1e7ff}'),
+    ('\u{1e8c5}', '\u{1e8c6}'),
+    ('\u{1e8d7}', '\u{1e8ff}'),
+    ('\u{1e94c}', '\u{1e94f}'),
+    ('\u{1e95a}', '\u{1e95d}'),
+    ('\u{1e960}', '\u{1ec70}'),
+    ('\u{1ecb5}', '\u{1ed00}'),
+    ('\u{1ed3e}', '\u{1edff}'),
+    ('\u{1ee04}', '\u{1ee04}'),
+    ('\u{1ee20}', '\u{1ee20}'),
+    ('\u{1ee23}', '\u{1ee23}'),
+    ('\u{1ee25}', '\u{1ee26}'),
+    ('\u{1ee28}', '\u{1ee28}'),
+    ('\u{1ee33}', '\u{1ee33}'),
+    ('\u{1ee38}', '\u{1ee38}'),
+    ('\u{1ee3a}', '\u{1ee3a}'),
+    ('\u{1ee3c}', '\u{1ee41}'),
+    ('\u{1ee43}', '\u{1ee46}'),
+    ('\u{1ee48}', '\u{1ee48}'),
+    ('\u{1ee4a}', '\u{1ee4a}'),
+    ('\u{1ee4c}', '\u{1ee4c}'),
+    ('\u{1ee50}', '\u{1ee50}'),
+    ('\u{1ee53}', '\u{1ee53}'),
+    ('\u{1ee55}', '\u{1ee56}'),
+    ('\u{1ee58}', '\u{1ee58}'),
+    ('\u{1ee5a}', '\u{1ee5a}'),
+    ('\u{1ee5c}', '\u{1ee5c}'),
+    ('\u{1ee5e}', '\u{1ee5e}'),
+    ('\u{1ee60}', '\u{1ee60}'),
+    ('\u{1ee63}', '\u{1ee63}'),
+    ('\u{1ee65}', '\u{1ee66}'),
+    ('\u{1ee6b}', '\u{1ee6b}'),
+    ('\u{1ee73}', '\u{1ee73}'),
+    ('\u{1ee78}', '\u{1ee78}'),
+    ('\u{1ee7d}', '\u{1ee7d}'),
+    ('\u{1ee7f}', '\u{1ee7f}'),
+    ('\u{1ee8a}', '\u{1ee8a}'),
+    ('\u{1ee9c}', '\u{1eea0}'),
+    ('\u{1eea4}', '\u{1eea4}'),
+    ('\u{1eeaa}', '\u{1eeaa}'),
+    ('\u{1eebc}', '\u{1eeef}'),
+    ('\u{1eef2}', '\u{1efff}'),
+    ('\u{1f02c}', '\u{1f02f}'),
+    ('\u{1f094}', '\u{1f09f}'),
+    ('\u{1f0af}', '\u{1f0b0}'),
+    ('\u{1f0c0}', '\u{1f0c0}'),
+    ('\u{1f0d0}', '\u{1f0d0}'),
+    ('\u{1f0f6}', '\u{1f0ff}'),
+    ('\u{1f1ae}', '\u{1f1e5}'),
+    ('\u{1f203}', '\u{1f20f}'),
+    ('\u{1f23c}', '\u{1f23f}'),
+    ('\u{1f249}', '\u{1f24f}'),
+    ('\u{1f252}', '\u{1f25f}'),
+    ('\u{1f266}', '\u{1f2ff}'),
+    ('\u{1f6d8}', '\u{1f6db}'),
+    ('\u{1f6ed}', '\u{1f6ef}'),
+    ('\u{1f6fd}', '\u{1f6ff}'),
+    ('\u{1f777}', '\u{1f77a}'),
+    ('\u{1f7da}', '\u{1f7df}'),
+    ('\u{1f7ec}', '\u{1f7ef}'),
+    ('\u{1f7f1}', '\u{1f7ff}'),
+    ('\u{1f80c}', '\u{1f80f}'),
+    ('\u{1f848}', '\u{1f84f}'),
+    ('\u{1f85a}', '\u{1f85f}'),
+    ('\u{1f888}', '\u{1f88f}'),
+    ('\u{1f8ae}', '\u{1f8af}'),
+    ('\u{1f8b2}', '\u{1f8ff}'),
+    ('\u{1fa54}', '\u{1fa5f}'),
+    ('\u{1fa6e}', '\u{1fa6f}'),
+    ('\u{1fa7d}', '\u{1fa7f}'),
+    ('\u{1fa89}', '\u{1fa8f}'),
+    ('\u{1fabe}', '\u{1fabe}'),
+    ('\u{1fac6}', '\u{1facd}'),
+    ('\u{1fadc}', '\u{1fadf}'),
+    ('\u{1fae9}', '\u{1faef}'),
+    ('\u{1faf9}', '\u{1faff}'),
+    ('\u{1fb93}', '\u{1fb93}'),
+    ('\u{1fbcb}', '\u{1fbef}'),
+    ('\u{1fbfa}', '\u{1ffff}'),
+    ('\u{2a6e0}', '\u{2a6ff}'),
+    ('\u{2b73a}', '\u{2b73f}'),
+    ('\u{2b81e}', '\u{2b81f}'),
+    ('\u{2cea2}', '\u{2ceaf}'),
+    ('\u{2ebe1}', '\u{2f7ff}'),
+    ('\u{2fa1e}', '\u{2ffff}'),
+    ('\u{3134b}', '\u{3134f}'),
+    ('\u{323b0}', '\u{e0000}'),
+    ('\u{e0002}', '\u{e001f}'),
+    ('\u{e0080}', '\u{e00ff}'),
+    ('\u{e01f0}', '\u{effff}'),
+    ('\u{ffffe}', '\u{fffff}'),
+    ('\u{10fffe}', '\u{10ffff}'),
+];
+
+pub const UPPERCASE_LETTER: &'static [(char, char)] = &[
+    ('A', 'Z'),
+    ('À', 'Ö'),
+    ('Ø', 'Þ'),
+    ('Ā', 'Ā'),
+    ('Ă', 'Ă'),
+    ('Ą', 'Ą'),
+    ('Ć', 'Ć'),
+    ('Ĉ', 'Ĉ'),
+    ('Ċ', 'Ċ'),
+    ('Č', 'Č'),
+    ('Ď', 'Ď'),
+    ('Đ', 'Đ'),
+    ('Ē', 'Ē'),
+    ('Ĕ', 'Ĕ'),
+    ('Ė', 'Ė'),
+    ('Ę', 'Ę'),
+    ('Ě', 'Ě'),
+    ('Ĝ', 'Ĝ'),
+    ('Ğ', 'Ğ'),
+    ('Ġ', 'Ġ'),
+    ('Ģ', 'Ģ'),
+    ('Ĥ', 'Ĥ'),
+    ('Ħ', 'Ħ'),
+    ('Ĩ', 'Ĩ'),
+    ('Ī', 'Ī'),
+    ('Ĭ', 'Ĭ'),
+    ('Į', 'Į'),
+    ('İ', 'İ'),
+    ('Ĳ', 'Ĳ'),
+    ('Ĵ', 'Ĵ'),
+    ('Ķ', 'Ķ'),
+    ('Ĺ', 'Ĺ'),
+    ('Ļ', 'Ļ'),
+    ('Ľ', 'Ľ'),
+    ('Ŀ', 'Ŀ'),
+    ('Ł', 'Ł'),
+    ('Ń', 'Ń'),
+    ('Ņ', 'Ņ'),
+    ('Ň', 'Ň'),
+    ('Ŋ', 'Ŋ'),
+    ('Ō', 'Ō'),
+    ('Ŏ', 'Ŏ'),
+    ('Ő', 'Ő'),
+    ('Œ', 'Œ'),
+    ('Ŕ', 'Ŕ'),
+    ('Ŗ', 'Ŗ'),
+    ('Ř', 'Ř'),
+    ('Ś', 'Ś'),
+    ('Ŝ', 'Ŝ'),
+    ('Ş', 'Ş'),
+    ('Š', 'Š'),
+    ('Ţ', 'Ţ'),
+    ('Ť', 'Ť'),
+    ('Ŧ', 'Ŧ'),
+    ('Ũ', 'Ũ'),
+    ('Ū', 'Ū'),
+    ('Ŭ', 'Ŭ'),
+    ('Ů', 'Ů'),
+    ('Ű', 'Ű'),
+    ('Ų', 'Ų'),
+    ('Ŵ', 'Ŵ'),
+    ('Ŷ', 'Ŷ'),
+    ('Ÿ', 'Ź'),
+    ('Ż', 'Ż'),
+    ('Ž', 'Ž'),
+    ('Ɓ', 'Ƃ'),
+    ('Ƅ', 'Ƅ'),
+    ('Ɔ', 'Ƈ'),
+    ('Ɖ', 'Ƌ'),
+    ('Ǝ', 'Ƒ'),
+    ('Ɠ', 'Ɣ'),
+    ('Ɩ', 'Ƙ'),
+    ('Ɯ', 'Ɲ'),
+    ('Ɵ', 'Ơ'),
+    ('Ƣ', 'Ƣ'),
+    ('Ƥ', 'Ƥ'),
+    ('Ʀ', 'Ƨ'),
+    ('Ʃ', 'Ʃ'),
+    ('Ƭ', 'Ƭ'),
+    ('Ʈ', 'Ư'),
+    ('Ʊ', 'Ƴ'),
+    ('Ƶ', 'Ƶ'),
+    ('Ʒ', 'Ƹ'),
+    ('Ƽ', 'Ƽ'),
+    ('Ǆ', 'Ǆ'),
+    ('Ǉ', 'Ǉ'),
+    ('Ǌ', 'Ǌ'),
+    ('Ǎ', 'Ǎ'),
+    ('Ǐ', 'Ǐ'),
+    ('Ǒ', 'Ǒ'),
+    ('Ǔ', 'Ǔ'),
+    ('Ǖ', 'Ǖ'),
+    ('Ǘ', 'Ǘ'),
+    ('Ǚ', 'Ǚ'),
+    ('Ǜ', 'Ǜ'),
+    ('Ǟ', 'Ǟ'),
+    ('Ǡ', 'Ǡ'),
+    ('Ǣ', 'Ǣ'),
+    ('Ǥ', 'Ǥ'),
+    ('Ǧ', 'Ǧ'),
+    ('Ǩ', 'Ǩ'),
+    ('Ǫ', 'Ǫ'),
+    ('Ǭ', 'Ǭ'),
+    ('Ǯ', 'Ǯ'),
+    ('Ǳ', 'Ǳ'),
+    ('Ǵ', 'Ǵ'),
+    ('Ƕ', 'Ǹ'),
+    ('Ǻ', 'Ǻ'),
+    ('Ǽ', 'Ǽ'),
+    ('Ǿ', 'Ǿ'),
+    ('Ȁ', 'Ȁ'),
+    ('Ȃ', 'Ȃ'),
+    ('Ȅ', 'Ȅ'),
+    ('Ȇ', 'Ȇ'),
+    ('Ȉ', 'Ȉ'),
+    ('Ȋ', 'Ȋ'),
+    ('Ȍ', 'Ȍ'),
+    ('Ȏ', 'Ȏ'),
+    ('Ȑ', 'Ȑ'),
+    ('Ȓ', 'Ȓ'),
+    ('Ȕ', 'Ȕ'),
+    ('Ȗ', 'Ȗ'),
+    ('Ș', 'Ș'),
+    ('Ț', 'Ț'),
+    ('Ȝ', 'Ȝ'),
+    ('Ȟ', 'Ȟ'),
+    ('Ƞ', 'Ƞ'),
+    ('Ȣ', 'Ȣ'),
+    ('Ȥ', 'Ȥ'),
+    ('Ȧ', 'Ȧ'),
+    ('Ȩ', 'Ȩ'),
+    ('Ȫ', 'Ȫ'),
+    ('Ȭ', 'Ȭ'),
+    ('Ȯ', 'Ȯ'),
+    ('Ȱ', 'Ȱ'),
+    ('Ȳ', 'Ȳ'),
+    ('Ⱥ', 'Ȼ'),
+    ('Ƚ', 'Ⱦ'),
+    ('Ɂ', 'Ɂ'),
+    ('Ƀ', 'Ɇ'),
+    ('Ɉ', 'Ɉ'),
+    ('Ɋ', 'Ɋ'),
+    ('Ɍ', 'Ɍ'),
+    ('Ɏ', 'Ɏ'),
+    ('Ͱ', 'Ͱ'),
+    ('Ͳ', 'Ͳ'),
+    ('Ͷ', 'Ͷ'),
+    ('Ϳ', 'Ϳ'),
+    ('Ά', 'Ά'),
+    ('Έ', 'Ί'),
+    ('Ό', 'Ό'),
+    ('Ύ', 'Ώ'),
+    ('Α', 'Ρ'),
+    ('Σ', 'Ϋ'),
+    ('Ϗ', 'Ϗ'),
+    ('ϒ', 'ϔ'),
+    ('Ϙ', 'Ϙ'),
+    ('Ϛ', 'Ϛ'),
+    ('Ϝ', 'Ϝ'),
+    ('Ϟ', 'Ϟ'),
+    ('Ϡ', 'Ϡ'),
+    ('Ϣ', 'Ϣ'),
+    ('Ϥ', 'Ϥ'),
+    ('Ϧ', 'Ϧ'),
+    ('Ϩ', 'Ϩ'),
+    ('Ϫ', 'Ϫ'),
+    ('Ϭ', 'Ϭ'),
+    ('Ϯ', 'Ϯ'),
+    ('ϴ', 'ϴ'),
+    ('Ϸ', 'Ϸ'),
+    ('Ϲ', 'Ϻ'),
+    ('Ͻ', 'Я'),
+    ('Ѡ', 'Ѡ'),
+    ('Ѣ', 'Ѣ'),
+    ('Ѥ', 'Ѥ'),
+    ('Ѧ', 'Ѧ'),
+    ('Ѩ', 'Ѩ'),
+    ('Ѫ', 'Ѫ'),
+    ('Ѭ', 'Ѭ'),
+    ('Ѯ', 'Ѯ'),
+    ('Ѱ', 'Ѱ'),
+    ('Ѳ', 'Ѳ'),
+    ('Ѵ', 'Ѵ'),
+    ('Ѷ', 'Ѷ'),
+    ('Ѹ', 'Ѹ'),
+    ('Ѻ', 'Ѻ'),
+    ('Ѽ', 'Ѽ'),
+    ('Ѿ', 'Ѿ'),
+    ('Ҁ', 'Ҁ'),
+    ('Ҋ', 'Ҋ'),
+    ('Ҍ', 'Ҍ'),
+    ('Ҏ', 'Ҏ'),
+    ('Ґ', 'Ґ'),
+    ('Ғ', 'Ғ'),
+    ('Ҕ', 'Ҕ'),
+    ('Җ', 'Җ'),
+    ('Ҙ', 'Ҙ'),
+    ('Қ', 'Қ'),
+    ('Ҝ', 'Ҝ'),
+    ('Ҟ', 'Ҟ'),
+    ('Ҡ', 'Ҡ'),
+    ('Ң', 'Ң'),
+    ('Ҥ', 'Ҥ'),
+    ('Ҧ', 'Ҧ'),
+    ('Ҩ', 'Ҩ'),
+    ('Ҫ', 'Ҫ'),
+    ('Ҭ', 'Ҭ'),
+    ('Ү', 'Ү'),
+    ('Ұ', 'Ұ'),
+    ('Ҳ', 'Ҳ'),
+    ('Ҵ', 'Ҵ'),
+    ('Ҷ', 'Ҷ'),
+    ('Ҹ', 'Ҹ'),
+    ('Һ', 'Һ'),
+    ('Ҽ', 'Ҽ'),
+    ('Ҿ', 'Ҿ'),
+    ('Ӏ', 'Ӂ'),
+    ('Ӄ', 'Ӄ'),
+    ('Ӆ', 'Ӆ'),
+    ('Ӈ', 'Ӈ'),
+    ('Ӊ', 'Ӊ'),
+    ('Ӌ', 'Ӌ'),
+    ('Ӎ', 'Ӎ'),
+    ('Ӑ', 'Ӑ'),
+    ('Ӓ', 'Ӓ'),
+    ('Ӕ', 'Ӕ'),
+    ('Ӗ', 'Ӗ'),
+    ('Ә', 'Ә'),
+    ('Ӛ', 'Ӛ'),
+    ('Ӝ', 'Ӝ'),
+    ('Ӟ', 'Ӟ'),
+    ('Ӡ', 'Ӡ'),
+    ('Ӣ', 'Ӣ'),
+    ('Ӥ', 'Ӥ'),
+    ('Ӧ', 'Ӧ'),
+    ('Ө', 'Ө'),
+    ('Ӫ', 'Ӫ'),
+    ('Ӭ', 'Ӭ'),
+    ('Ӯ', 'Ӯ'),
+    ('Ӱ', 'Ӱ'),
+    ('Ӳ', 'Ӳ'),
+    ('Ӵ', 'Ӵ'),
+    ('Ӷ', 'Ӷ'),
+    ('Ӹ', 'Ӹ'),
+    ('Ӻ', 'Ӻ'),
+    ('Ӽ', 'Ӽ'),
+    ('Ӿ', 'Ӿ'),
+    ('Ԁ', 'Ԁ'),
+    ('Ԃ', 'Ԃ'),
+    ('Ԅ', 'Ԅ'),
+    ('Ԇ', 'Ԇ'),
+    ('Ԉ', 'Ԉ'),
+    ('Ԋ', 'Ԋ'),
+    ('Ԍ', 'Ԍ'),
+    ('Ԏ', 'Ԏ'),
+    ('Ԑ', 'Ԑ'),
+    ('Ԓ', 'Ԓ'),
+    ('Ԕ', 'Ԕ'),
+    ('Ԗ', 'Ԗ'),
+    ('Ԙ', 'Ԙ'),
+    ('Ԛ', 'Ԛ'),
+    ('Ԝ', 'Ԝ'),
+    ('Ԟ', 'Ԟ'),
+    ('Ԡ', 'Ԡ'),
+    ('Ԣ', 'Ԣ'),
+    ('Ԥ', 'Ԥ'),
+    ('Ԧ', 'Ԧ'),
+    ('Ԩ', 'Ԩ'),
+    ('Ԫ', 'Ԫ'),
+    ('Ԭ', 'Ԭ'),
+    ('Ԯ', 'Ԯ'),
+    ('Ա', 'Ֆ'),
+    ('Ⴀ', 'Ⴥ'),
+    ('Ⴧ', 'Ⴧ'),
+    ('Ⴭ', 'Ⴭ'),
+    ('Ꭰ', 'Ᏽ'),
+    ('Ა', 'Ჺ'),
+    ('Ჽ', 'Ჿ'),
+    ('Ḁ', 'Ḁ'),
+    ('Ḃ', 'Ḃ'),
+    ('Ḅ', 'Ḅ'),
+    ('Ḇ', 'Ḇ'),
+    ('Ḉ', 'Ḉ'),
+    ('Ḋ', 'Ḋ'),
+    ('Ḍ', 'Ḍ'),
+    ('Ḏ', 'Ḏ'),
+    ('Ḑ', 'Ḑ'),
+    ('Ḓ', 'Ḓ'),
+    ('Ḕ', 'Ḕ'),
+    ('Ḗ', 'Ḗ'),
+    ('Ḙ', 'Ḙ'),
+    ('Ḛ', 'Ḛ'),
+    ('Ḝ', 'Ḝ'),
+    ('Ḟ', 'Ḟ'),
+    ('Ḡ', 'Ḡ'),
+    ('Ḣ', 'Ḣ'),
+    ('Ḥ', 'Ḥ'),
+    ('Ḧ', 'Ḧ'),
+    ('Ḩ', 'Ḩ'),
+    ('Ḫ', 'Ḫ'),
+    ('Ḭ', 'Ḭ'),
+    ('Ḯ', 'Ḯ'),
+    ('Ḱ', 'Ḱ'),
+    ('Ḳ', 'Ḳ'),
+    ('Ḵ', 'Ḵ'),
+    ('Ḷ', 'Ḷ'),
+    ('Ḹ', 'Ḹ'),
+    ('Ḻ', 'Ḻ'),
+    ('Ḽ', 'Ḽ'),
+    ('Ḿ', 'Ḿ'),
+    ('Ṁ', 'Ṁ'),
+    ('Ṃ', 'Ṃ'),
+    ('Ṅ', 'Ṅ'),
+    ('Ṇ', 'Ṇ'),
+    ('Ṉ', 'Ṉ'),
+    ('Ṋ', 'Ṋ'),
+    ('Ṍ', 'Ṍ'),
+    ('Ṏ', 'Ṏ'),
+    ('Ṑ', 'Ṑ'),
+    ('Ṓ', 'Ṓ'),
+    ('Ṕ', 'Ṕ'),
+    ('Ṗ', 'Ṗ'),
+    ('Ṙ', 'Ṙ'),
+    ('Ṛ', 'Ṛ'),
+    ('Ṝ', 'Ṝ'),
+    ('Ṟ', 'Ṟ'),
+    ('Ṡ', 'Ṡ'),
+    ('Ṣ', 'Ṣ'),
+    ('Ṥ', 'Ṥ'),
+    ('Ṧ', 'Ṧ'),
+    ('Ṩ', 'Ṩ'),
+    ('Ṫ', 'Ṫ'),
+    ('Ṭ', 'Ṭ'),
+    ('Ṯ', 'Ṯ'),
+    ('Ṱ', 'Ṱ'),
+    ('Ṳ', 'Ṳ'),
+    ('Ṵ', 'Ṵ'),
+    ('Ṷ', 'Ṷ'),
+    ('Ṹ', 'Ṹ'),
+    ('Ṻ', 'Ṻ'),
+    ('Ṽ', 'Ṽ'),
+    ('Ṿ', 'Ṿ'),
+    ('Ẁ', 'Ẁ'),
+    ('Ẃ', 'Ẃ'),
+    ('Ẅ', 'Ẅ'),
+    ('Ẇ', 'Ẇ'),
+    ('Ẉ', 'Ẉ'),
+    ('Ẋ', 'Ẋ'),
+    ('Ẍ', 'Ẍ'),
+    ('Ẏ', 'Ẏ'),
+    ('Ẑ', 'Ẑ'),
+    ('Ẓ', 'Ẓ'),
+    ('Ẕ', 'Ẕ'),
+    ('ẞ', 'ẞ'),
+    ('Ạ', 'Ạ'),
+    ('Ả', 'Ả'),
+    ('Ấ', 'Ấ'),
+    ('Ầ', 'Ầ'),
+    ('Ẩ', 'Ẩ'),
+    ('Ẫ', 'Ẫ'),
+    ('Ậ', 'Ậ'),
+    ('Ắ', 'Ắ'),
+    ('Ằ', 'Ằ'),
+    ('Ẳ', 'Ẳ'),
+    ('Ẵ', 'Ẵ'),
+    ('Ặ', 'Ặ'),
+    ('Ẹ', 'Ẹ'),
+    ('Ẻ', 'Ẻ'),
+    ('Ẽ', 'Ẽ'),
+    ('Ế', 'Ế'),
+    ('Ề', 'Ề'),
+    ('Ể', 'Ể'),
+    ('Ễ', 'Ễ'),
+    ('Ệ', 'Ệ'),
+    ('Ỉ', 'Ỉ'),
+    ('Ị', 'Ị'),
+    ('Ọ', 'Ọ'),
+    ('Ỏ', 'Ỏ'),
+    ('Ố', 'Ố'),
+    ('Ồ', 'Ồ'),
+    ('Ổ', 'Ổ'),
+    ('Ỗ', 'Ỗ'),
+    ('Ộ', 'Ộ'),
+    ('Ớ', 'Ớ'),
+    ('Ờ', 'Ờ'),
+    ('Ở', 'Ở'),
+    ('Ỡ', 'Ỡ'),
+    ('Ợ', 'Ợ'),
+    ('Ụ', 'Ụ'),
+    ('Ủ', 'Ủ'),
+    ('Ứ', 'Ứ'),
+    ('Ừ', 'Ừ'),
+    ('Ử', 'Ử'),
+    ('Ữ', 'Ữ'),
+    ('Ự', 'Ự'),
+    ('Ỳ', 'Ỳ'),
+    ('Ỵ', 'Ỵ'),
+    ('Ỷ', 'Ỷ'),
+    ('Ỹ', 'Ỹ'),
+    ('Ỻ', 'Ỻ'),
+    ('Ỽ', 'Ỽ'),
+    ('Ỿ', 'Ỿ'),
+    ('Ἀ', 'Ἇ'),
+    ('Ἐ', 'Ἕ'),
+    ('Ἠ', 'Ἧ'),
+    ('Ἰ', 'Ἷ'),
+    ('Ὀ', 'Ὅ'),
+    ('Ὑ', 'Ὑ'),
+    ('Ὓ', 'Ὓ'),
+    ('Ὕ', 'Ὕ'),
+    ('Ὗ', 'Ὗ'),
+    ('Ὠ', 'Ὧ'),
+    ('Ᾰ', 'Ά'),
+    ('Ὲ', 'Ή'),
+    ('Ῐ', 'Ί'),
+    ('Ῠ', 'Ῥ'),
+    ('Ὸ', 'Ώ'),
+    ('ℂ', 'ℂ'),
+    ('ℇ', 'ℇ'),
+    ('ℋ', 'ℍ'),
+    ('ℐ', 'ℒ'),
+    ('ℕ', 'ℕ'),
+    ('ℙ', 'ℝ'),
+    ('ℤ', 'ℤ'),
+    ('Ω', 'Ω'),
+    ('ℨ', 'ℨ'),
+    ('K', 'ℭ'),
+    ('ℰ', 'ℳ'),
+    ('ℾ', 'ℿ'),
+    ('ⅅ', 'ⅅ'),
+    ('Ↄ', 'Ↄ'),
+    ('Ⰰ', 'Ⱟ'),
+    ('Ⱡ', 'Ⱡ'),
+    ('Ɫ', 'Ɽ'),
+    ('Ⱨ', 'Ⱨ'),
+    ('Ⱪ', 'Ⱪ'),
+    ('Ⱬ', 'Ⱬ'),
+    ('Ɑ', 'Ɒ'),
+    ('Ⱳ', 'Ⱳ'),
+    ('Ⱶ', 'Ⱶ'),
+    ('Ȿ', 'Ⲁ'),
+    ('Ⲃ', 'Ⲃ'),
+    ('Ⲅ', 'Ⲅ'),
+    ('Ⲇ', 'Ⲇ'),
+    ('Ⲉ', 'Ⲉ'),
+    ('Ⲋ', 'Ⲋ'),
+    ('Ⲍ', 'Ⲍ'),
+    ('Ⲏ', 'Ⲏ'),
+    ('Ⲑ', 'Ⲑ'),
+    ('Ⲓ', 'Ⲓ'),
+    ('Ⲕ', 'Ⲕ'),
+    ('Ⲗ', 'Ⲗ'),
+    ('Ⲙ', 'Ⲙ'),
+    ('Ⲛ', 'Ⲛ'),
+    ('Ⲝ', 'Ⲝ'),
+    ('Ⲟ', 'Ⲟ'),
+    ('Ⲡ', 'Ⲡ'),
+    ('Ⲣ', 'Ⲣ'),
+    ('Ⲥ', 'Ⲥ'),
+    ('Ⲧ', 'Ⲧ'),
+    ('Ⲩ', 'Ⲩ'),
+    ('Ⲫ', 'Ⲫ'),
+    ('Ⲭ', 'Ⲭ'),
+    ('Ⲯ', 'Ⲯ'),
+    ('Ⲱ', 'Ⲱ'),
+    ('Ⲳ', 'Ⲳ'),
+    ('Ⲵ', 'Ⲵ'),
+    ('Ⲷ', 'Ⲷ'),
+    ('Ⲹ', 'Ⲹ'),
+    ('Ⲻ', 'Ⲻ'),
+    ('Ⲽ', 'Ⲽ'),
+    ('Ⲿ', 'Ⲿ'),
+    ('Ⳁ', 'Ⳁ'),
+    ('Ⳃ', 'Ⳃ'),
+    ('Ⳅ', 'Ⳅ'),
+    ('Ⳇ', 'Ⳇ'),
+    ('Ⳉ', 'Ⳉ'),
+    ('Ⳋ', 'Ⳋ'),
+    ('Ⳍ', 'Ⳍ'),
+    ('Ⳏ', 'Ⳏ'),
+    ('Ⳑ', 'Ⳑ'),
+    ('Ⳓ', 'Ⳓ'),
+    ('Ⳕ', 'Ⳕ'),
+    ('Ⳗ', 'Ⳗ'),
+    ('Ⳙ', 'Ⳙ'),
+    ('Ⳛ', 'Ⳛ'),
+    ('Ⳝ', 'Ⳝ'),
+    ('Ⳟ', 'Ⳟ'),
+    ('Ⳡ', 'Ⳡ'),
+    ('Ⳣ', 'Ⳣ'),
+    ('Ⳬ', 'Ⳬ'),
+    ('Ⳮ', 'Ⳮ'),
+    ('Ⳳ', 'Ⳳ'),
+    ('Ꙁ', 'Ꙁ'),
+    ('Ꙃ', 'Ꙃ'),
+    ('Ꙅ', 'Ꙅ'),
+    ('Ꙇ', 'Ꙇ'),
+    ('Ꙉ', 'Ꙉ'),
+    ('Ꙋ', 'Ꙋ'),
+    ('Ꙍ', 'Ꙍ'),
+    ('Ꙏ', 'Ꙏ'),
+    ('Ꙑ', 'Ꙑ'),
+    ('Ꙓ', 'Ꙓ'),
+    ('Ꙕ', 'Ꙕ'),
+    ('Ꙗ', 'Ꙗ'),
+    ('Ꙙ', 'Ꙙ'),
+    ('Ꙛ', 'Ꙛ'),
+    ('Ꙝ', 'Ꙝ'),
+    ('Ꙟ', 'Ꙟ'),
+    ('Ꙡ', 'Ꙡ'),
+    ('Ꙣ', 'Ꙣ'),
+    ('Ꙥ', 'Ꙥ'),
+    ('Ꙧ', 'Ꙧ'),
+    ('Ꙩ', 'Ꙩ'),
+    ('Ꙫ', 'Ꙫ'),
+    ('Ꙭ', 'Ꙭ'),
+    ('Ꚁ', 'Ꚁ'),
+    ('Ꚃ', 'Ꚃ'),
+    ('Ꚅ', 'Ꚅ'),
+    ('Ꚇ', 'Ꚇ'),
+    ('Ꚉ', 'Ꚉ'),
+    ('Ꚋ', 'Ꚋ'),
+    ('Ꚍ', 'Ꚍ'),
+    ('Ꚏ', 'Ꚏ'),
+    ('Ꚑ', 'Ꚑ'),
+    ('Ꚓ', 'Ꚓ'),
+    ('Ꚕ', 'Ꚕ'),
+    ('Ꚗ', 'Ꚗ'),
+    ('Ꚙ', 'Ꚙ'),
+    ('Ꚛ', 'Ꚛ'),
+    ('Ꜣ', 'Ꜣ'),
+    ('Ꜥ', 'Ꜥ'),
+    ('Ꜧ', 'Ꜧ'),
+    ('Ꜩ', 'Ꜩ'),
+    ('Ꜫ', 'Ꜫ'),
+    ('Ꜭ', 'Ꜭ'),
+    ('Ꜯ', 'Ꜯ'),
+    ('Ꜳ', 'Ꜳ'),
+    ('Ꜵ', 'Ꜵ'),
+    ('Ꜷ', 'Ꜷ'),
+    ('Ꜹ', 'Ꜹ'),
+    ('Ꜻ', 'Ꜻ'),
+    ('Ꜽ', 'Ꜽ'),
+    ('Ꜿ', 'Ꜿ'),
+    ('Ꝁ', 'Ꝁ'),
+    ('Ꝃ', 'Ꝃ'),
+    ('Ꝅ', 'Ꝅ'),
+    ('Ꝇ', 'Ꝇ'),
+    ('Ꝉ', 'Ꝉ'),
+    ('Ꝋ', 'Ꝋ'),
+    ('Ꝍ', 'Ꝍ'),
+    ('Ꝏ', 'Ꝏ'),
+    ('Ꝑ', 'Ꝑ'),
+    ('Ꝓ', 'Ꝓ'),
+    ('Ꝕ', 'Ꝕ'),
+    ('Ꝗ', 'Ꝗ'),
+    ('Ꝙ', 'Ꝙ'),
+    ('Ꝛ', 'Ꝛ'),
+    ('Ꝝ', 'Ꝝ'),
+    ('Ꝟ', 'Ꝟ'),
+    ('Ꝡ', 'Ꝡ'),
+    ('Ꝣ', 'Ꝣ'),
+    ('Ꝥ', 'Ꝥ'),
+    ('Ꝧ', 'Ꝧ'),
+    ('Ꝩ', 'Ꝩ'),
+    ('Ꝫ', 'Ꝫ'),
+    ('Ꝭ', 'Ꝭ'),
+    ('Ꝯ', 'Ꝯ'),
+    ('Ꝺ', 'Ꝺ'),
+    ('Ꝼ', 'Ꝼ'),
+    ('Ᵹ', 'Ꝿ'),
+    ('Ꞁ', 'Ꞁ'),
+    ('Ꞃ', 'Ꞃ'),
+    ('Ꞅ', 'Ꞅ'),
+    ('Ꞇ', 'Ꞇ'),
+    ('Ꞌ', 'Ꞌ'),
+    ('Ɥ', 'Ɥ'),
+    ('Ꞑ', 'Ꞑ'),
+    ('Ꞓ', 'Ꞓ'),
+    ('Ꞗ', 'Ꞗ'),
+    ('Ꞙ', 'Ꞙ'),
+    ('Ꞛ', 'Ꞛ'),
+    ('Ꞝ', 'Ꞝ'),
+    ('Ꞟ', 'Ꞟ'),
+    ('Ꞡ', 'Ꞡ'),
+    ('Ꞣ', 'Ꞣ'),
+    ('Ꞥ', 'Ꞥ'),
+    ('Ꞧ', 'Ꞧ'),
+    ('Ꞩ', 'Ꞩ'),
+    ('Ɦ', 'Ɪ'),
+    ('Ʞ', 'Ꞵ'),
+    ('Ꞷ', 'Ꞷ'),
+    ('Ꞹ', 'Ꞹ'),
+    ('Ꞻ', 'Ꞻ'),
+    ('Ꞽ', 'Ꞽ'),
+    ('Ꞿ', 'Ꞿ'),
+    ('Ꟁ', 'Ꟁ'),
+    ('Ꟃ', 'Ꟃ'),
+    ('Ꞔ', 'Ꟈ'),
+    ('Ꟊ', 'Ꟊ'),
+    ('Ꟑ', 'Ꟑ'),
+    ('Ꟗ', 'Ꟗ'),
+    ('Ꟙ', 'Ꟙ'),
+    ('Ꟶ', 'Ꟶ'),
+    ('Ａ', 'Ｚ'),
+    ('𐐀', '𐐧'),
+    ('𐒰', '𐓓'),
+    ('𐕰', '𐕺'),
+    ('𐕼', '𐖊'),
+    ('𐖌', '𐖒'),
+    ('𐖔', '𐖕'),
+    ('𐲀', '𐲲'),
+    ('𑢠', '𑢿'),
+    ('𖹀', '𖹟'),
+    ('𝐀', '𝐙'),
+    ('𝐴', '𝑍'),
+    ('𝑨', '𝒁'),
+    ('𝒜', '𝒜'),
+    ('𝒞', '𝒟'),
+    ('𝒢', '𝒢'),
+    ('𝒥', '𝒦'),
+    ('𝒩', '𝒬'),
+    ('𝒮', '𝒵'),
+    ('𝓐', '𝓩'),
+    ('𝔄', '𝔅'),
+    ('𝔇', '𝔊'),
+    ('𝔍', '𝔔'),
+    ('𝔖', '𝔜'),
+    ('𝔸', '𝔹'),
+    ('𝔻', '𝔾'),
+    ('𝕀', '𝕄'),
+    ('𝕆', '𝕆'),
+    ('𝕊', '𝕐'),
+    ('𝕬', '𝖅'),
+    ('𝖠', '𝖹'),
+    ('𝗔', '𝗭'),
+    ('𝘈', '𝘡'),
+    ('𝘼', '𝙕'),
+    ('𝙰', '𝚉'),
+    ('𝚨', '𝛀'),
+    ('𝛢', '𝛺'),
+    ('𝜜', '𝜴'),
+    ('𝝖', '𝝮'),
+    ('𝞐', '𝞨'),
+    ('𝟊', '𝟊'),
+    ('𞤀', '𞤡'),
+];
diff --git a/crates/regex-syntax/src/unicode_tables/grapheme_cluster_break.rs b/crates/regex-syntax/src/unicode_tables/grapheme_cluster_break.rs
new file mode 100644
index 0000000..294dfbd
--- /dev/null
+++ b/crates/regex-syntax/src/unicode_tables/grapheme_cluster_break.rs
@@ -0,0 +1,1416 @@
+// DO NOT EDIT THIS FILE. IT WAS AUTOMATICALLY GENERATED BY:
+//
+//   ucd-generate grapheme-cluster-break ucd-15.0.0 --chars
+//
+// Unicode version: 15.0.0.
+//
+// ucd-generate 0.2.14 is available on crates.io.
+
+pub const BY_NAME: &'static [(&'static str, &'static [(char, char)])] = &[
+    ("CR", CR),
+    ("Control", CONTROL),
+    ("Extend", EXTEND),
+    ("L", L),
+    ("LF", LF),
+    ("LV", LV),
+    ("LVT", LVT),
+    ("Prepend", PREPEND),
+    ("Regional_Indicator", REGIONAL_INDICATOR),
+    ("SpacingMark", SPACINGMARK),
+    ("T", T),
+    ("V", V),
+    ("ZWJ", ZWJ),
+];
+
+pub const CR: &'static [(char, char)] = &[('\r', '\r')];
+
+pub const CONTROL: &'static [(char, char)] = &[
+    ('\0', '\t'),
+    ('\u{b}', '\u{c}'),
+    ('\u{e}', '\u{1f}'),
+    ('\u{7f}', '\u{9f}'),
+    ('\u{ad}', '\u{ad}'),
+    ('\u{61c}', '\u{61c}'),
+    ('\u{180e}', '\u{180e}'),
+    ('\u{200b}', '\u{200b}'),
+    ('\u{200e}', '\u{200f}'),
+    ('\u{2028}', '\u{202e}'),
+    ('\u{2060}', '\u{206f}'),
+    ('\u{feff}', '\u{feff}'),
+    ('\u{fff0}', '\u{fffb}'),
+    ('\u{13430}', '\u{1343f}'),
+    ('\u{1bca0}', '\u{1bca3}'),
+    ('\u{1d173}', '\u{1d17a}'),
+    ('\u{e0000}', '\u{e001f}'),
+    ('\u{e0080}', '\u{e00ff}'),
+    ('\u{e01f0}', '\u{e0fff}'),
+];
+
+pub const EXTEND: &'static [(char, char)] = &[
+    ('\u{300}', '\u{36f}'),
+    ('\u{483}', '\u{489}'),
+    ('\u{591}', '\u{5bd}'),
+    ('\u{5bf}', '\u{5bf}'),
+    ('\u{5c1}', '\u{5c2}'),
+    ('\u{5c4}', '\u{5c5}'),
+    ('\u{5c7}', '\u{5c7}'),
+    ('\u{610}', '\u{61a}'),
+    ('\u{64b}', '\u{65f}'),
+    ('\u{670}', '\u{670}'),
+    ('\u{6d6}', '\u{6dc}'),
+    ('\u{6df}', '\u{6e4}'),
+    ('\u{6e7}', '\u{6e8}'),
+    ('\u{6ea}', '\u{6ed}'),
+    ('\u{711}', '\u{711}'),
+    ('\u{730}', '\u{74a}'),
+    ('\u{7a6}', '\u{7b0}'),
+    ('\u{7eb}', '\u{7f3}'),
+    ('\u{7fd}', '\u{7fd}'),
+    ('\u{816}', '\u{819}'),
+    ('\u{81b}', '\u{823}'),
+    ('\u{825}', '\u{827}'),
+    ('\u{829}', '\u{82d}'),
+    ('\u{859}', '\u{85b}'),
+    ('\u{898}', '\u{89f}'),
+    ('\u{8ca}', '\u{8e1}'),
+    ('\u{8e3}', '\u{902}'),
+    ('\u{93a}', '\u{93a}'),
+    ('\u{93c}', '\u{93c}'),
+    ('\u{941}', '\u{948}'),
+    ('\u{94d}', '\u{94d}'),
+    ('\u{951}', '\u{957}'),
+    ('\u{962}', '\u{963}'),
+    ('\u{981}', '\u{981}'),
+    ('\u{9bc}', '\u{9bc}'),
+    ('\u{9be}', '\u{9be}'),
+    ('\u{9c1}', '\u{9c4}'),
+    ('\u{9cd}', '\u{9cd}'),
+    ('\u{9d7}', '\u{9d7}'),
+    ('\u{9e2}', '\u{9e3}'),
+    ('\u{9fe}', '\u{9fe}'),
+    ('\u{a01}', '\u{a02}'),
+    ('\u{a3c}', '\u{a3c}'),
+    ('\u{a41}', '\u{a42}'),
+    ('\u{a47}', '\u{a48}'),
+    ('\u{a4b}', '\u{a4d}'),
+    ('\u{a51}', '\u{a51}'),
+    ('\u{a70}', '\u{a71}'),
+    ('\u{a75}', '\u{a75}'),
+    ('\u{a81}', '\u{a82}'),
+    ('\u{abc}', '\u{abc}'),
+    ('\u{ac1}', '\u{ac5}'),
+    ('\u{ac7}', '\u{ac8}'),
+    ('\u{acd}', '\u{acd}'),
+    ('\u{ae2}', '\u{ae3}'),
+    ('\u{afa}', '\u{aff}'),
+    ('\u{b01}', '\u{b01}'),
+    ('\u{b3c}', '\u{b3c}'),
+    ('\u{b3e}', '\u{b3f}'),
+    ('\u{b41}', '\u{b44}'),
+    ('\u{b4d}', '\u{b4d}'),
+    ('\u{b55}', '\u{b57}'),
+    ('\u{b62}', '\u{b63}'),
+    ('\u{b82}', '\u{b82}'),
+    ('\u{bbe}', '\u{bbe}'),
+    ('\u{bc0}', '\u{bc0}'),
+    ('\u{bcd}', '\u{bcd}'),
+    ('\u{bd7}', '\u{bd7}'),
+    ('\u{c00}', '\u{c00}'),
+    ('\u{c04}', '\u{c04}'),
+    ('\u{c3c}', '\u{c3c}'),
+    ('\u{c3e}', '\u{c40}'),
+    ('\u{c46}', '\u{c48}'),
+    ('\u{c4a}', '\u{c4d}'),
+    ('\u{c55}', '\u{c56}'),
+    ('\u{c62}', '\u{c63}'),
+    ('\u{c81}', '\u{c81}'),
+    ('\u{cbc}', '\u{cbc}'),
+    ('\u{cbf}', '\u{cbf}'),
+    ('\u{cc2}', '\u{cc2}'),
+    ('\u{cc6}', '\u{cc6}'),
+    ('\u{ccc}', '\u{ccd}'),
+    ('\u{cd5}', '\u{cd6}'),
+    ('\u{ce2}', '\u{ce3}'),
+    ('\u{d00}', '\u{d01}'),
+    ('\u{d3b}', '\u{d3c}'),
+    ('\u{d3e}', '\u{d3e}'),
+    ('\u{d41}', '\u{d44}'),
+    ('\u{d4d}', '\u{d4d}'),
+    ('\u{d57}', '\u{d57}'),
+    ('\u{d62}', '\u{d63}'),
+    ('\u{d81}', '\u{d81}'),
+    ('\u{dca}', '\u{dca}'),
+    ('\u{dcf}', '\u{dcf}'),
+    ('\u{dd2}', '\u{dd4}'),
+    ('\u{dd6}', '\u{dd6}'),
+    ('\u{ddf}', '\u{ddf}'),
+    ('\u{e31}', '\u{e31}'),
+    ('\u{e34}', '\u{e3a}'),
+    ('\u{e47}', '\u{e4e}'),
+    ('\u{eb1}', '\u{eb1}'),
+    ('\u{eb4}', '\u{ebc}'),
+    ('\u{ec8}', '\u{ece}'),
+    ('\u{f18}', '\u{f19}'),
+    ('\u{f35}', '\u{f35}'),
+    ('\u{f37}', '\u{f37}'),
+    ('\u{f39}', '\u{f39}'),
+    ('\u{f71}', '\u{f7e}'),
+    ('\u{f80}', '\u{f84}'),
+    ('\u{f86}', '\u{f87}'),
+    ('\u{f8d}', '\u{f97}'),
+    ('\u{f99}', '\u{fbc}'),
+    ('\u{fc6}', '\u{fc6}'),
+    ('\u{102d}', '\u{1030}'),
+    ('\u{1032}', '\u{1037}'),
+    ('\u{1039}', '\u{103a}'),
+    ('\u{103d}', '\u{103e}'),
+    ('\u{1058}', '\u{1059}'),
+    ('\u{105e}', '\u{1060}'),
+    ('\u{1071}', '\u{1074}'),
+    ('\u{1082}', '\u{1082}'),
+    ('\u{1085}', '\u{1086}'),
+    ('\u{108d}', '\u{108d}'),
+    ('\u{109d}', '\u{109d}'),
+    ('\u{135d}', '\u{135f}'),
+    ('\u{1712}', '\u{1714}'),
+    ('\u{1732}', '\u{1733}'),
+    ('\u{1752}', '\u{1753}'),
+    ('\u{1772}', '\u{1773}'),
+    ('\u{17b4}', '\u{17b5}'),
+    ('\u{17b7}', '\u{17bd}'),
+    ('\u{17c6}', '\u{17c6}'),
+    ('\u{17c9}', '\u{17d3}'),
+    ('\u{17dd}', '\u{17dd}'),
+    ('\u{180b}', '\u{180d}'),
+    ('\u{180f}', '\u{180f}'),
+    ('\u{1885}', '\u{1886}'),
+    ('\u{18a9}', '\u{18a9}'),
+    ('\u{1920}', '\u{1922}'),
+    ('\u{1927}', '\u{1928}'),
+    ('\u{1932}', '\u{1932}'),
+    ('\u{1939}', '\u{193b}'),
+    ('\u{1a17}', '\u{1a18}'),
+    ('\u{1a1b}', '\u{1a1b}'),
+    ('\u{1a56}', '\u{1a56}'),
+    ('\u{1a58}', '\u{1a5e}'),
+    ('\u{1a60}', '\u{1a60}'),
+    ('\u{1a62}', '\u{1a62}'),
+    ('\u{1a65}', '\u{1a6c}'),
+    ('\u{1a73}', '\u{1a7c}'),
+    ('\u{1a7f}', '\u{1a7f}'),
+    ('\u{1ab0}', '\u{1ace}'),
+    ('\u{1b00}', '\u{1b03}'),
+    ('\u{1b34}', '\u{1b3a}'),
+    ('\u{1b3c}', '\u{1b3c}'),
+    ('\u{1b42}', '\u{1b42}'),
+    ('\u{1b6b}', '\u{1b73}'),
+    ('\u{1b80}', '\u{1b81}'),
+    ('\u{1ba2}', '\u{1ba5}'),
+    ('\u{1ba8}', '\u{1ba9}'),
+    ('\u{1bab}', '\u{1bad}'),
+    ('\u{1be6}', '\u{1be6}'),
+    ('\u{1be8}', '\u{1be9}'),
+    ('\u{1bed}', '\u{1bed}'),
+    ('\u{1bef}', '\u{1bf1}'),
+    ('\u{1c2c}', '\u{1c33}'),
+    ('\u{1c36}', '\u{1c37}'),
+    ('\u{1cd0}', '\u{1cd2}'),
+    ('\u{1cd4}', '\u{1ce0}'),
+    ('\u{1ce2}', '\u{1ce8}'),
+    ('\u{1ced}', '\u{1ced}'),
+    ('\u{1cf4}', '\u{1cf4}'),
+    ('\u{1cf8}', '\u{1cf9}'),
+    ('\u{1dc0}', '\u{1dff}'),
+    ('\u{200c}', '\u{200c}'),
+    ('\u{20d0}', '\u{20f0}'),
+    ('\u{2cef}', '\u{2cf1}'),
+    ('\u{2d7f}', '\u{2d7f}'),
+    ('\u{2de0}', '\u{2dff}'),
+    ('\u{302a}', '\u{302f}'),
+    ('\u{3099}', '\u{309a}'),
+    ('\u{a66f}', '\u{a672}'),
+    ('\u{a674}', '\u{a67d}'),
+    ('\u{a69e}', '\u{a69f}'),
+    ('\u{a6f0}', '\u{a6f1}'),
+    ('\u{a802}', '\u{a802}'),
+    ('\u{a806}', '\u{a806}'),
+    ('\u{a80b}', '\u{a80b}'),
+    ('\u{a825}', '\u{a826}'),
+    ('\u{a82c}', '\u{a82c}'),
+    ('\u{a8c4}', '\u{a8c5}'),
+    ('\u{a8e0}', '\u{a8f1}'),
+    ('\u{a8ff}', '\u{a8ff}'),
+    ('\u{a926}', '\u{a92d}'),
+    ('\u{a947}', '\u{a951}'),
+    ('\u{a980}', '\u{a982}'),
+    ('\u{a9b3}', '\u{a9b3}'),
+    ('\u{a9b6}', '\u{a9b9}'),
+    ('\u{a9bc}', '\u{a9bd}'),
+    ('\u{a9e5}', '\u{a9e5}'),
+    ('\u{aa29}', '\u{aa2e}'),
+    ('\u{aa31}', '\u{aa32}'),
+    ('\u{aa35}', '\u{aa36}'),
+    ('\u{aa43}', '\u{aa43}'),
+    ('\u{aa4c}', '\u{aa4c}'),
+    ('\u{aa7c}', '\u{aa7c}'),
+    ('\u{aab0}', '\u{aab0}'),
+    ('\u{aab2}', '\u{aab4}'),
+    ('\u{aab7}', '\u{aab8}'),
+    ('\u{aabe}', '\u{aabf}'),
+    ('\u{aac1}', '\u{aac1}'),
+    ('\u{aaec}', '\u{aaed}'),
+    ('\u{aaf6}', '\u{aaf6}'),
+    ('\u{abe5}', '\u{abe5}'),
+    ('\u{abe8}', '\u{abe8}'),
+    ('\u{abed}', '\u{abed}'),
+    ('\u{fb1e}', '\u{fb1e}'),
+    ('\u{fe00}', '\u{fe0f}'),
+    ('\u{fe20}', '\u{fe2f}'),
+    ('\u{ff9e}', '\u{ff9f}'),
+    ('\u{101fd}', '\u{101fd}'),
+    ('\u{102e0}', '\u{102e0}'),
+    ('\u{10376}', '\u{1037a}'),
+    ('\u{10a01}', '\u{10a03}'),
+    ('\u{10a05}', '\u{10a06}'),
+    ('\u{10a0c}', '\u{10a0f}'),
+    ('\u{10a38}', '\u{10a3a}'),
+    ('\u{10a3f}', '\u{10a3f}'),
+    ('\u{10ae5}', '\u{10ae6}'),
+    ('\u{10d24}', '\u{10d27}'),
+    ('\u{10eab}', '\u{10eac}'),
+    ('\u{10efd}', '\u{10eff}'),
+    ('\u{10f46}', '\u{10f50}'),
+    ('\u{10f82}', '\u{10f85}'),
+    ('\u{11001}', '\u{11001}'),
+    ('\u{11038}', '\u{11046}'),
+    ('\u{11070}', '\u{11070}'),
+    ('\u{11073}', '\u{11074}'),
+    ('\u{1107f}', '\u{11081}'),
+    ('\u{110b3}', '\u{110b6}'),
+    ('\u{110b9}', '\u{110ba}'),
+    ('\u{110c2}', '\u{110c2}'),
+    ('\u{11100}', '\u{11102}'),
+    ('\u{11127}', '\u{1112b}'),
+    ('\u{1112d}', '\u{11134}'),
+    ('\u{11173}', '\u{11173}'),
+    ('\u{11180}', '\u{11181}'),
+    ('\u{111b6}', '\u{111be}'),
+    ('\u{111c9}', '\u{111cc}'),
+    ('\u{111cf}', '\u{111cf}'),
+    ('\u{1122f}', '\u{11231}'),
+    ('\u{11234}', '\u{11234}'),
+    ('\u{11236}', '\u{11237}'),
+    ('\u{1123e}', '\u{1123e}'),
+    ('\u{11241}', '\u{11241}'),
+    ('\u{112df}', '\u{112df}'),
+    ('\u{112e3}', '\u{112ea}'),
+    ('\u{11300}', '\u{11301}'),
+    ('\u{1133b}', '\u{1133c}'),
+    ('\u{1133e}', '\u{1133e}'),
+    ('\u{11340}', '\u{11340}'),
+    ('\u{11357}', '\u{11357}'),
+    ('\u{11366}', '\u{1136c}'),
+    ('\u{11370}', '\u{11374}'),
+    ('\u{11438}', '\u{1143f}'),
+    ('\u{11442}', '\u{11444}'),
+    ('\u{11446}', '\u{11446}'),
+    ('\u{1145e}', '\u{1145e}'),
+    ('\u{114b0}', '\u{114b0}'),
+    ('\u{114b3}', '\u{114b8}'),
+    ('\u{114ba}', '\u{114ba}'),
+    ('\u{114bd}', '\u{114bd}'),
+    ('\u{114bf}', '\u{114c0}'),
+    ('\u{114c2}', '\u{114c3}'),
+    ('\u{115af}', '\u{115af}'),
+    ('\u{115b2}', '\u{115b5}'),
+    ('\u{115bc}', '\u{115bd}'),
+    ('\u{115bf}', '\u{115c0}'),
+    ('\u{115dc}', '\u{115dd}'),
+    ('\u{11633}', '\u{1163a}'),
+    ('\u{1163d}', '\u{1163d}'),
+    ('\u{1163f}', '\u{11640}'),
+    ('\u{116ab}', '\u{116ab}'),
+    ('\u{116ad}', '\u{116ad}'),
+    ('\u{116b0}', '\u{116b5}'),
+    ('\u{116b7}', '\u{116b7}'),
+    ('\u{1171d}', '\u{1171f}'),
+    ('\u{11722}', '\u{11725}'),
+    ('\u{11727}', '\u{1172b}'),
+    ('\u{1182f}', '\u{11837}'),
+    ('\u{11839}', '\u{1183a}'),
+    ('\u{11930}', '\u{11930}'),
+    ('\u{1193b}', '\u{1193c}'),
+    ('\u{1193e}', '\u{1193e}'),
+    ('\u{11943}', '\u{11943}'),
+    ('\u{119d4}', '\u{119d7}'),
+    ('\u{119da}', '\u{119db}'),
+    ('\u{119e0}', '\u{119e0}'),
+    ('\u{11a01}', '\u{11a0a}'),
+    ('\u{11a33}', '\u{11a38}'),
+    ('\u{11a3b}', '\u{11a3e}'),
+    ('\u{11a47}', '\u{11a47}'),
+    ('\u{11a51}', '\u{11a56}'),
+    ('\u{11a59}', '\u{11a5b}'),
+    ('\u{11a8a}', '\u{11a96}'),
+    ('\u{11a98}', '\u{11a99}'),
+    ('\u{11c30}', '\u{11c36}'),
+    ('\u{11c38}', '\u{11c3d}'),
+    ('\u{11c3f}', '\u{11c3f}'),
+    ('\u{11c92}', '\u{11ca7}'),
+    ('\u{11caa}', '\u{11cb0}'),
+    ('\u{11cb2}', '\u{11cb3}'),
+    ('\u{11cb5}', '\u{11cb6}'),
+    ('\u{11d31}', '\u{11d36}'),
+    ('\u{11d3a}', '\u{11d3a}'),
+    ('\u{11d3c}', '\u{11d3d}'),
+    ('\u{11d3f}', '\u{11d45}'),
+    ('\u{11d47}', '\u{11d47}'),
+    ('\u{11d90}', '\u{11d91}'),
+    ('\u{11d95}', '\u{11d95}'),
+    ('\u{11d97}', '\u{11d97}'),
+    ('\u{11ef3}', '\u{11ef4}'),
+    ('\u{11f00}', '\u{11f01}'),
+    ('\u{11f36}', '\u{11f3a}'),
+    ('\u{11f40}', '\u{11f40}'),
+    ('\u{11f42}', '\u{11f42}'),
+    ('\u{13440}', '\u{13440}'),
+    ('\u{13447}', '\u{13455}'),
+    ('\u{16af0}', '\u{16af4}'),
+    ('\u{16b30}', '\u{16b36}'),
+    ('\u{16f4f}', '\u{16f4f}'),
+    ('\u{16f8f}', '\u{16f92}'),
+    ('\u{16fe4}', '\u{16fe4}'),
+    ('\u{1bc9d}', '\u{1bc9e}'),
+    ('\u{1cf00}', '\u{1cf2d}'),
+    ('\u{1cf30}', '\u{1cf46}'),
+    ('\u{1d165}', '\u{1d165}'),
+    ('\u{1d167}', '\u{1d169}'),
+    ('\u{1d16e}', '\u{1d172}'),
+    ('\u{1d17b}', '\u{1d182}'),
+    ('\u{1d185}', '\u{1d18b}'),
+    ('\u{1d1aa}', '\u{1d1ad}'),
+    ('\u{1d242}', '\u{1d244}'),
+    ('\u{1da00}', '\u{1da36}'),
+    ('\u{1da3b}', '\u{1da6c}'),
+    ('\u{1da75}', '\u{1da75}'),
+    ('\u{1da84}', '\u{1da84}'),
+    ('\u{1da9b}', '\u{1da9f}'),
+    ('\u{1daa1}', '\u{1daaf}'),
+    ('\u{1e000}', '\u{1e006}'),
+    ('\u{1e008}', '\u{1e018}'),
+    ('\u{1e01b}', '\u{1e021}'),
+    ('\u{1e023}', '\u{1e024}'),
+    ('\u{1e026}', '\u{1e02a}'),
+    ('\u{1e08f}', '\u{1e08f}'),
+    ('\u{1e130}', '\u{1e136}'),
+    ('\u{1e2ae}', '\u{1e2ae}'),
+    ('\u{1e2ec}', '\u{1e2ef}'),
+    ('\u{1e4ec}', '\u{1e4ef}'),
+    ('\u{1e8d0}', '\u{1e8d6}'),
+    ('\u{1e944}', '\u{1e94a}'),
+    ('🏻', '🏿'),
+    ('\u{e0020}', '\u{e007f}'),
+    ('\u{e0100}', '\u{e01ef}'),
+];
+
+pub const L: &'static [(char, char)] = &[('ᄀ', 'ᅟ'), ('ꥠ', 'ꥼ')];
+
+pub const LF: &'static [(char, char)] = &[('\n', '\n')];
+
+pub const LV: &'static [(char, char)] = &[
+    ('가', '가'),
+    ('개', '개'),
+    ('갸', '갸'),
+    ('걔', '걔'),
+    ('거', '거'),
+    ('게', '게'),
+    ('겨', '겨'),
+    ('계', '계'),
+    ('고', '고'),
+    ('과', '과'),
+    ('괘', '괘'),
+    ('괴', '괴'),
+    ('교', '교'),
+    ('구', '구'),
+    ('궈', '궈'),
+    ('궤', '궤'),
+    ('귀', '귀'),
+    ('규', '규'),
+    ('그', '그'),
+    ('긔', '긔'),
+    ('기', '기'),
+    ('까', '까'),
+    ('깨', '깨'),
+    ('꺄', '꺄'),
+    ('꺠', '꺠'),
+    ('꺼', '꺼'),
+    ('께', '께'),
+    ('껴', '껴'),
+    ('꼐', '꼐'),
+    ('꼬', '꼬'),
+    ('꽈', '꽈'),
+    ('꽤', '꽤'),
+    ('꾀', '꾀'),
+    ('꾜', '꾜'),
+    ('꾸', '꾸'),
+    ('꿔', '꿔'),
+    ('꿰', '꿰'),
+    ('뀌', '뀌'),
+    ('뀨', '뀨'),
+    ('끄', '끄'),
+    ('끠', '끠'),
+    ('끼', '끼'),
+    ('나', '나'),
+    ('내', '내'),
+    ('냐', '냐'),
+    ('냬', '냬'),
+    ('너', '너'),
+    ('네', '네'),
+    ('녀', '녀'),
+    ('녜', '녜'),
+    ('노', '노'),
+    ('놔', '놔'),
+    ('놰', '놰'),
+    ('뇌', '뇌'),
+    ('뇨', '뇨'),
+    ('누', '누'),
+    ('눠', '눠'),
+    ('눼', '눼'),
+    ('뉘', '뉘'),
+    ('뉴', '뉴'),
+    ('느', '느'),
+    ('늬', '늬'),
+    ('니', '니'),
+    ('다', '다'),
+    ('대', '대'),
+    ('댜', '댜'),
+    ('댸', '댸'),
+    ('더', '더'),
+    ('데', '데'),
+    ('뎌', '뎌'),
+    ('뎨', '뎨'),
+    ('도', '도'),
+    ('돠', '돠'),
+    ('돼', '돼'),
+    ('되', '되'),
+    ('됴', '됴'),
+    ('두', '두'),
+    ('둬', '둬'),
+    ('뒈', '뒈'),
+    ('뒤', '뒤'),
+    ('듀', '듀'),
+    ('드', '드'),
+    ('듸', '듸'),
+    ('디', '디'),
+    ('따', '따'),
+    ('때', '때'),
+    ('땨', '땨'),
+    ('떄', '떄'),
+    ('떠', '떠'),
+    ('떼', '떼'),
+    ('뗘', '뗘'),
+    ('뗴', '뗴'),
+    ('또', '또'),
+    ('똬', '똬'),
+    ('뙈', '뙈'),
+    ('뙤', '뙤'),
+    ('뚀', '뚀'),
+    ('뚜', '뚜'),
+    ('뚸', '뚸'),
+    ('뛔', '뛔'),
+    ('뛰', '뛰'),
+    ('뜌', '뜌'),
+    ('뜨', '뜨'),
+    ('띄', '띄'),
+    ('띠', '띠'),
+    ('라', '라'),
+    ('래', '래'),
+    ('랴', '랴'),
+    ('럐', '럐'),
+    ('러', '러'),
+    ('레', '레'),
+    ('려', '려'),
+    ('례', '례'),
+    ('로', '로'),
+    ('롸', '롸'),
+    ('뢔', '뢔'),
+    ('뢰', '뢰'),
+    ('료', '료'),
+    ('루', '루'),
+    ('뤄', '뤄'),
+    ('뤠', '뤠'),
+    ('뤼', '뤼'),
+    ('류', '류'),
+    ('르', '르'),
+    ('릐', '릐'),
+    ('리', '리'),
+    ('마', '마'),
+    ('매', '매'),
+    ('먀', '먀'),
+    ('먜', '먜'),
+    ('머', '머'),
+    ('메', '메'),
+    ('며', '며'),
+    ('몌', '몌'),
+    ('모', '모'),
+    ('뫄', '뫄'),
+    ('뫠', '뫠'),
+    ('뫼', '뫼'),
+    ('묘', '묘'),
+    ('무', '무'),
+    ('뭐', '뭐'),
+    ('뭬', '뭬'),
+    ('뮈', '뮈'),
+    ('뮤', '뮤'),
+    ('므', '므'),
+    ('믜', '믜'),
+    ('미', '미'),
+    ('바', '바'),
+    ('배', '배'),
+    ('뱌', '뱌'),
+    ('뱨', '뱨'),
+    ('버', '버'),
+    ('베', '베'),
+    ('벼', '벼'),
+    ('볘', '볘'),
+    ('보', '보'),
+    ('봐', '봐'),
+    ('봬', '봬'),
+    ('뵈', '뵈'),
+    ('뵤', '뵤'),
+    ('부', '부'),
+    ('붜', '붜'),
+    ('붸', '붸'),
+    ('뷔', '뷔'),
+    ('뷰', '뷰'),
+    ('브', '브'),
+    ('븨', '븨'),
+    ('비', '비'),
+    ('빠', '빠'),
+    ('빼', '빼'),
+    ('뺘', '뺘'),
+    ('뺴', '뺴'),
+    ('뻐', '뻐'),
+    ('뻬', '뻬'),
+    ('뼈', '뼈'),
+    ('뼤', '뼤'),
+    ('뽀', '뽀'),
+    ('뽜', '뽜'),
+    ('뽸', '뽸'),
+    ('뾔', '뾔'),
+    ('뾰', '뾰'),
+    ('뿌', '뿌'),
+    ('뿨', '뿨'),
+    ('쀄', '쀄'),
+    ('쀠', '쀠'),
+    ('쀼', '쀼'),
+    ('쁘', '쁘'),
+    ('쁴', '쁴'),
+    ('삐', '삐'),
+    ('사', '사'),
+    ('새', '새'),
+    ('샤', '샤'),
+    ('섀', '섀'),
+    ('서', '서'),
+    ('세', '세'),
+    ('셔', '셔'),
+    ('셰', '셰'),
+    ('소', '소'),
+    ('솨', '솨'),
+    ('쇄', '쇄'),
+    ('쇠', '쇠'),
+    ('쇼', '쇼'),
+    ('수', '수'),
+    ('숴', '숴'),
+    ('쉐', '쉐'),
+    ('쉬', '쉬'),
+    ('슈', '슈'),
+    ('스', '스'),
+    ('싀', '싀'),
+    ('시', '시'),
+    ('싸', '싸'),
+    ('쌔', '쌔'),
+    ('쌰', '쌰'),
+    ('썌', '썌'),
+    ('써', '써'),
+    ('쎄', '쎄'),
+    ('쎠', '쎠'),
+    ('쎼', '쎼'),
+    ('쏘', '쏘'),
+    ('쏴', '쏴'),
+    ('쐐', '쐐'),
+    ('쐬', '쐬'),
+    ('쑈', '쑈'),
+    ('쑤', '쑤'),
+    ('쒀', '쒀'),
+    ('쒜', '쒜'),
+    ('쒸', '쒸'),
+    ('쓔', '쓔'),
+    ('쓰', '쓰'),
+    ('씌', '씌'),
+    ('씨', '씨'),
+    ('아', '아'),
+    ('애', '애'),
+    ('야', '야'),
+    ('얘', '얘'),
+    ('어', '어'),
+    ('에', '에'),
+    ('여', '여'),
+    ('예', '예'),
+    ('오', '오'),
+    ('와', '와'),
+    ('왜', '왜'),
+    ('외', '외'),
+    ('요', '요'),
+    ('우', '우'),
+    ('워', '워'),
+    ('웨', '웨'),
+    ('위', '위'),
+    ('유', '유'),
+    ('으', '으'),
+    ('의', '의'),
+    ('이', '이'),
+    ('자', '자'),
+    ('재', '재'),
+    ('쟈', '쟈'),
+    ('쟤', '쟤'),
+    ('저', '저'),
+    ('제', '제'),
+    ('져', '져'),
+    ('졔', '졔'),
+    ('조', '조'),
+    ('좌', '좌'),
+    ('좨', '좨'),
+    ('죄', '죄'),
+    ('죠', '죠'),
+    ('주', '주'),
+    ('줘', '줘'),
+    ('줴', '줴'),
+    ('쥐', '쥐'),
+    ('쥬', '쥬'),
+    ('즈', '즈'),
+    ('즤', '즤'),
+    ('지', '지'),
+    ('짜', '짜'),
+    ('째', '째'),
+    ('쨔', '쨔'),
+    ('쨰', '쨰'),
+    ('쩌', '쩌'),
+    ('쩨', '쩨'),
+    ('쪄', '쪄'),
+    ('쪠', '쪠'),
+    ('쪼', '쪼'),
+    ('쫘', '쫘'),
+    ('쫴', '쫴'),
+    ('쬐', '쬐'),
+    ('쬬', '쬬'),
+    ('쭈', '쭈'),
+    ('쭤', '쭤'),
+    ('쮀', '쮀'),
+    ('쮜', '쮜'),
+    ('쮸', '쮸'),
+    ('쯔', '쯔'),
+    ('쯰', '쯰'),
+    ('찌', '찌'),
+    ('차', '차'),
+    ('채', '채'),
+    ('챠', '챠'),
+    ('챼', '챼'),
+    ('처', '처'),
+    ('체', '체'),
+    ('쳐', '쳐'),
+    ('쳬', '쳬'),
+    ('초', '초'),
+    ('촤', '촤'),
+    ('쵀', '쵀'),
+    ('최', '최'),
+    ('쵸', '쵸'),
+    ('추', '추'),
+    ('춰', '춰'),
+    ('췌', '췌'),
+    ('취', '취'),
+    ('츄', '츄'),
+    ('츠', '츠'),
+    ('츼', '츼'),
+    ('치', '치'),
+    ('카', '카'),
+    ('캐', '캐'),
+    ('캬', '캬'),
+    ('컈', '컈'),
+    ('커', '커'),
+    ('케', '케'),
+    ('켜', '켜'),
+    ('켸', '켸'),
+    ('코', '코'),
+    ('콰', '콰'),
+    ('쾌', '쾌'),
+    ('쾨', '쾨'),
+    ('쿄', '쿄'),
+    ('쿠', '쿠'),
+    ('쿼', '쿼'),
+    ('퀘', '퀘'),
+    ('퀴', '퀴'),
+    ('큐', '큐'),
+    ('크', '크'),
+    ('킈', '킈'),
+    ('키', '키'),
+    ('타', '타'),
+    ('태', '태'),
+    ('탸', '탸'),
+    ('턔', '턔'),
+    ('터', '터'),
+    ('테', '테'),
+    ('텨', '텨'),
+    ('톄', '톄'),
+    ('토', '토'),
+    ('톼', '톼'),
+    ('퇘', '퇘'),
+    ('퇴', '퇴'),
+    ('툐', '툐'),
+    ('투', '투'),
+    ('퉈', '퉈'),
+    ('퉤', '퉤'),
+    ('튀', '튀'),
+    ('튜', '튜'),
+    ('트', '트'),
+    ('틔', '틔'),
+    ('티', '티'),
+    ('파', '파'),
+    ('패', '패'),
+    ('퍄', '퍄'),
+    ('퍠', '퍠'),
+    ('퍼', '퍼'),
+    ('페', '페'),
+    ('펴', '펴'),
+    ('폐', '폐'),
+    ('포', '포'),
+    ('퐈', '퐈'),
+    ('퐤', '퐤'),
+    ('푀', '푀'),
+    ('표', '표'),
+    ('푸', '푸'),
+    ('풔', '풔'),
+    ('풰', '풰'),
+    ('퓌', '퓌'),
+    ('퓨', '퓨'),
+    ('프', '프'),
+    ('픠', '픠'),
+    ('피', '피'),
+    ('하', '하'),
+    ('해', '해'),
+    ('햐', '햐'),
+    ('햬', '햬'),
+    ('허', '허'),
+    ('헤', '헤'),
+    ('혀', '혀'),
+    ('혜', '혜'),
+    ('호', '호'),
+    ('화', '화'),
+    ('홰', '홰'),
+    ('회', '회'),
+    ('효', '효'),
+    ('후', '후'),
+    ('훠', '훠'),
+    ('훼', '훼'),
+    ('휘', '휘'),
+    ('휴', '휴'),
+    ('흐', '흐'),
+    ('희', '희'),
+    ('히', '히'),
+];
+
+pub const LVT: &'static [(char, char)] = &[
+    ('각', '갛'),
+    ('객', '갷'),
+    ('갹', '걓'),
+    ('걕', '걯'),
+    ('걱', '겋'),
+    ('겍', '겧'),
+    ('격', '곃'),
+    ('곅', '곟'),
+    ('곡', '곻'),
+    ('곽', '괗'),
+    ('괙', '괳'),
+    ('괵', '굏'),
+    ('굑', '굫'),
+    ('국', '궇'),
+    ('궉', '궣'),
+    ('궥', '궿'),
+    ('귁', '귛'),
+    ('귝', '귷'),
+    ('극', '긓'),
+    ('긕', '긯'),
+    ('긱', '깋'),
+    ('깍', '깧'),
+    ('깩', '꺃'),
+    ('꺅', '꺟'),
+    ('꺡', '꺻'),
+    ('꺽', '껗'),
+    ('껙', '껳'),
+    ('껵', '꼏'),
+    ('꼑', '꼫'),
+    ('꼭', '꽇'),
+    ('꽉', '꽣'),
+    ('꽥', '꽿'),
+    ('꾁', '꾛'),
+    ('꾝', '꾷'),
+    ('꾹', '꿓'),
+    ('꿕', '꿯'),
+    ('꿱', '뀋'),
+    ('뀍', '뀧'),
+    ('뀩', '끃'),
+    ('끅', '끟'),
+    ('끡', '끻'),
+    ('끽', '낗'),
+    ('낙', '낳'),
+    ('낵', '냏'),
+    ('냑', '냫'),
+    ('냭', '넇'),
+    ('넉', '넣'),
+    ('넥', '넿'),
+    ('녁', '녛'),
+    ('녝', '녷'),
+    ('녹', '놓'),
+    ('놕', '놯'),
+    ('놱', '뇋'),
+    ('뇍', '뇧'),
+    ('뇩', '눃'),
+    ('눅', '눟'),
+    ('눡', '눻'),
+    ('눽', '뉗'),
+    ('뉙', '뉳'),
+    ('뉵', '늏'),
+    ('늑', '늫'),
+    ('늭', '닇'),
+    ('닉', '닣'),
+    ('닥', '닿'),
+    ('댁', '댛'),
+    ('댝', '댷'),
+    ('댹', '덓'),
+    ('덕', '덯'),
+    ('덱', '뎋'),
+    ('뎍', '뎧'),
+    ('뎩', '돃'),
+    ('독', '돟'),
+    ('돡', '돻'),
+    ('돽', '됗'),
+    ('됙', '됳'),
+    ('됵', '둏'),
+    ('둑', '둫'),
+    ('둭', '뒇'),
+    ('뒉', '뒣'),
+    ('뒥', '뒿'),
+    ('듁', '듛'),
+    ('득', '듷'),
+    ('듹', '딓'),
+    ('딕', '딯'),
+    ('딱', '땋'),
+    ('땍', '땧'),
+    ('땩', '떃'),
+    ('떅', '떟'),
+    ('떡', '떻'),
+    ('떽', '뗗'),
+    ('뗙', '뗳'),
+    ('뗵', '똏'),
+    ('똑', '똫'),
+    ('똭', '뙇'),
+    ('뙉', '뙣'),
+    ('뙥', '뙿'),
+    ('뚁', '뚛'),
+    ('뚝', '뚷'),
+    ('뚹', '뛓'),
+    ('뛕', '뛯'),
+    ('뛱', '뜋'),
+    ('뜍', '뜧'),
+    ('뜩', '띃'),
+    ('띅', '띟'),
+    ('띡', '띻'),
+    ('락', '랗'),
+    ('랙', '랳'),
+    ('략', '럏'),
+    ('럑', '럫'),
+    ('럭', '렇'),
+    ('렉', '렣'),
+    ('력', '렿'),
+    ('롁', '롛'),
+    ('록', '롷'),
+    ('롹', '뢓'),
+    ('뢕', '뢯'),
+    ('뢱', '룋'),
+    ('룍', '룧'),
+    ('룩', '뤃'),
+    ('뤅', '뤟'),
+    ('뤡', '뤻'),
+    ('뤽', '륗'),
+    ('륙', '륳'),
+    ('륵', '릏'),
+    ('릑', '릫'),
+    ('릭', '맇'),
+    ('막', '맣'),
+    ('맥', '맿'),
+    ('먁', '먛'),
+    ('먝', '먷'),
+    ('먹', '멓'),
+    ('멕', '멯'),
+    ('멱', '몋'),
+    ('몍', '몧'),
+    ('목', '뫃'),
+    ('뫅', '뫟'),
+    ('뫡', '뫻'),
+    ('뫽', '묗'),
+    ('묙', '묳'),
+    ('묵', '뭏'),
+    ('뭑', '뭫'),
+    ('뭭', '뮇'),
+    ('뮉', '뮣'),
+    ('뮥', '뮿'),
+    ('믁', '믛'),
+    ('믝', '믷'),
+    ('믹', '밓'),
+    ('박', '밯'),
+    ('백', '뱋'),
+    ('뱍', '뱧'),
+    ('뱩', '벃'),
+    ('벅', '벟'),
+    ('벡', '벻'),
+    ('벽', '볗'),
+    ('볙', '볳'),
+    ('복', '봏'),
+    ('봑', '봫'),
+    ('봭', '뵇'),
+    ('뵉', '뵣'),
+    ('뵥', '뵿'),
+    ('북', '붛'),
+    ('붝', '붷'),
+    ('붹', '뷓'),
+    ('뷕', '뷯'),
+    ('뷱', '븋'),
+    ('븍', '븧'),
+    ('븩', '빃'),
+    ('빅', '빟'),
+    ('빡', '빻'),
+    ('빽', '뺗'),
+    ('뺙', '뺳'),
+    ('뺵', '뻏'),
+    ('뻑', '뻫'),
+    ('뻭', '뼇'),
+    ('뼉', '뼣'),
+    ('뼥', '뼿'),
+    ('뽁', '뽛'),
+    ('뽝', '뽷'),
+    ('뽹', '뾓'),
+    ('뾕', '뾯'),
+    ('뾱', '뿋'),
+    ('뿍', '뿧'),
+    ('뿩', '쀃'),
+    ('쀅', '쀟'),
+    ('쀡', '쀻'),
+    ('쀽', '쁗'),
+    ('쁙', '쁳'),
+    ('쁵', '삏'),
+    ('삑', '삫'),
+    ('삭', '샇'),
+    ('색', '샣'),
+    ('샥', '샿'),
+    ('섁', '섛'),
+    ('석', '섷'),
+    ('섹', '셓'),
+    ('셕', '셯'),
+    ('셱', '솋'),
+    ('속', '솧'),
+    ('솩', '쇃'),
+    ('쇅', '쇟'),
+    ('쇡', '쇻'),
+    ('쇽', '숗'),
+    ('숙', '숳'),
+    ('숵', '쉏'),
+    ('쉑', '쉫'),
+    ('쉭', '슇'),
+    ('슉', '슣'),
+    ('슥', '슿'),
+    ('싁', '싛'),
+    ('식', '싷'),
+    ('싹', '쌓'),
+    ('쌕', '쌯'),
+    ('쌱', '썋'),
+    ('썍', '썧'),
+    ('썩', '쎃'),
+    ('쎅', '쎟'),
+    ('쎡', '쎻'),
+    ('쎽', '쏗'),
+    ('쏙', '쏳'),
+    ('쏵', '쐏'),
+    ('쐑', '쐫'),
+    ('쐭', '쑇'),
+    ('쑉', '쑣'),
+    ('쑥', '쑿'),
+    ('쒁', '쒛'),
+    ('쒝', '쒷'),
+    ('쒹', '쓓'),
+    ('쓕', '쓯'),
+    ('쓱', '씋'),
+    ('씍', '씧'),
+    ('씩', '앃'),
+    ('악', '앟'),
+    ('액', '앻'),
+    ('약', '얗'),
+    ('얙', '얳'),
+    ('억', '엏'),
+    ('엑', '엫'),
+    ('역', '옇'),
+    ('옉', '옣'),
+    ('옥', '옿'),
+    ('왁', '왛'),
+    ('왝', '왷'),
+    ('왹', '욓'),
+    ('욕', '욯'),
+    ('욱', '웋'),
+    ('웍', '웧'),
+    ('웩', '윃'),
+    ('윅', '윟'),
+    ('육', '윻'),
+    ('윽', '읗'),
+    ('읙', '읳'),
+    ('익', '잏'),
+    ('작', '잫'),
+    ('잭', '쟇'),
+    ('쟉', '쟣'),
+    ('쟥', '쟿'),
+    ('적', '젛'),
+    ('젝', '젷'),
+    ('젹', '졓'),
+    ('졕', '졯'),
+    ('족', '좋'),
+    ('좍', '좧'),
+    ('좩', '죃'),
+    ('죅', '죟'),
+    ('죡', '죻'),
+    ('죽', '줗'),
+    ('줙', '줳'),
+    ('줵', '쥏'),
+    ('쥑', '쥫'),
+    ('쥭', '즇'),
+    ('즉', '즣'),
+    ('즥', '즿'),
+    ('직', '짛'),
+    ('짝', '짷'),
+    ('짹', '쨓'),
+    ('쨕', '쨯'),
+    ('쨱', '쩋'),
+    ('쩍', '쩧'),
+    ('쩩', '쪃'),
+    ('쪅', '쪟'),
+    ('쪡', '쪻'),
+    ('쪽', '쫗'),
+    ('쫙', '쫳'),
+    ('쫵', '쬏'),
+    ('쬑', '쬫'),
+    ('쬭', '쭇'),
+    ('쭉', '쭣'),
+    ('쭥', '쭿'),
+    ('쮁', '쮛'),
+    ('쮝', '쮷'),
+    ('쮹', '쯓'),
+    ('쯕', '쯯'),
+    ('쯱', '찋'),
+    ('찍', '찧'),
+    ('착', '챃'),
+    ('책', '챟'),
+    ('챡', '챻'),
+    ('챽', '첗'),
+    ('척', '첳'),
+    ('첵', '쳏'),
+    ('쳑', '쳫'),
+    ('쳭', '촇'),
+    ('촉', '촣'),
+    ('촥', '촿'),
+    ('쵁', '쵛'),
+    ('쵝', '쵷'),
+    ('쵹', '춓'),
+    ('축', '춯'),
+    ('춱', '췋'),
+    ('췍', '췧'),
+    ('췩', '츃'),
+    ('츅', '츟'),
+    ('측', '츻'),
+    ('츽', '칗'),
+    ('칙', '칳'),
+    ('칵', '캏'),
+    ('캑', '캫'),
+    ('캭', '컇'),
+    ('컉', '컣'),
+    ('컥', '컿'),
+    ('켁', '켛'),
+    ('켝', '켷'),
+    ('켹', '콓'),
+    ('콕', '콯'),
+    ('콱', '쾋'),
+    ('쾍', '쾧'),
+    ('쾩', '쿃'),
+    ('쿅', '쿟'),
+    ('쿡', '쿻'),
+    ('쿽', '퀗'),
+    ('퀙', '퀳'),
+    ('퀵', '큏'),
+    ('큑', '큫'),
+    ('큭', '킇'),
+    ('킉', '킣'),
+    ('킥', '킿'),
+    ('탁', '탛'),
+    ('택', '탷'),
+    ('탹', '턓'),
+    ('턕', '턯'),
+    ('턱', '텋'),
+    ('텍', '텧'),
+    ('텩', '톃'),
+    ('톅', '톟'),
+    ('톡', '톻'),
+    ('톽', '퇗'),
+    ('퇙', '퇳'),
+    ('퇵', '툏'),
+    ('툑', '툫'),
+    ('툭', '퉇'),
+    ('퉉', '퉣'),
+    ('퉥', '퉿'),
+    ('튁', '튛'),
+    ('튝', '튷'),
+    ('특', '틓'),
+    ('틕', '틯'),
+    ('틱', '팋'),
+    ('팍', '팧'),
+    ('팩', '퍃'),
+    ('퍅', '퍟'),
+    ('퍡', '퍻'),
+    ('퍽', '펗'),
+    ('펙', '펳'),
+    ('펵', '폏'),
+    ('폑', '폫'),
+    ('폭', '퐇'),
+    ('퐉', '퐣'),
+    ('퐥', '퐿'),
+    ('푁', '푛'),
+    ('푝', '푷'),
+    ('푹', '풓'),
+    ('풕', '풯'),
+    ('풱', '퓋'),
+    ('퓍', '퓧'),
+    ('퓩', '픃'),
+    ('픅', '픟'),
+    ('픡', '픻'),
+    ('픽', '핗'),
+    ('학', '핳'),
+    ('핵', '햏'),
+    ('햑', '햫'),
+    ('햭', '헇'),
+    ('헉', '헣'),
+    ('헥', '헿'),
+    ('혁', '혛'),
+    ('혝', '혷'),
+    ('혹', '홓'),
+    ('확', '홯'),
+    ('홱', '횋'),
+    ('획', '횧'),
+    ('횩', '훃'),
+    ('훅', '훟'),
+    ('훡', '훻'),
+    ('훽', '휗'),
+    ('휙', '휳'),
+    ('휵', '흏'),
+    ('흑', '흫'),
+    ('흭', '힇'),
+    ('힉', '힣'),
+];
+
+pub const PREPEND: &'static [(char, char)] = &[
+    ('\u{600}', '\u{605}'),
+    ('\u{6dd}', '\u{6dd}'),
+    ('\u{70f}', '\u{70f}'),
+    ('\u{890}', '\u{891}'),
+    ('\u{8e2}', '\u{8e2}'),
+    ('ൎ', 'ൎ'),
+    ('\u{110bd}', '\u{110bd}'),
+    ('\u{110cd}', '\u{110cd}'),
+    ('𑇂', '𑇃'),
+    ('𑤿', '𑤿'),
+    ('𑥁', '𑥁'),
+    ('𑨺', '𑨺'),
+    ('𑪄', '𑪉'),
+    ('𑵆', '𑵆'),
+    ('𑼂', '𑼂'),
+];
+
+pub const REGIONAL_INDICATOR: &'static [(char, char)] = &[('🇦', '🇿')];
+
+pub const SPACINGMARK: &'static [(char, char)] = &[
+    ('ः', 'ः'),
+    ('ऻ', 'ऻ'),
+    ('ा', 'ी'),
+    ('ॉ', 'ौ'),
+    ('ॎ', 'ॏ'),
+    ('ং', 'ঃ'),
+    ('ি', 'ী'),
+    ('ে', 'ৈ'),
+    ('ো', 'ৌ'),
+    ('ਃ', 'ਃ'),
+    ('ਾ', 'ੀ'),
+    ('ઃ', 'ઃ'),
+    ('ા', 'ી'),
+    ('ૉ', 'ૉ'),
+    ('ો', 'ૌ'),
+    ('ଂ', 'ଃ'),
+    ('ୀ', 'ୀ'),
+    ('େ', 'ୈ'),
+    ('ୋ', 'ୌ'),
+    ('ி', 'ி'),
+    ('ு', 'ூ'),
+    ('ெ', 'ை'),
+    ('ொ', 'ௌ'),
+    ('ఁ', 'ః'),
+    ('ు', 'ౄ'),
+    ('ಂ', 'ಃ'),
+    ('ಾ', 'ಾ'),
+    ('ೀ', 'ು'),
+    ('ೃ', 'ೄ'),
+    ('ೇ', 'ೈ'),
+    ('ೊ', 'ೋ'),
+    ('ೳ', 'ೳ'),
+    ('ം', 'ഃ'),
+    ('ി', 'ീ'),
+    ('െ', 'ൈ'),
+    ('ൊ', 'ൌ'),
+    ('ං', 'ඃ'),
+    ('ැ', 'ෑ'),
+    ('ෘ', 'ෞ'),
+    ('ෲ', 'ෳ'),
+    ('ำ', 'ำ'),
+    ('ຳ', 'ຳ'),
+    ('༾', '༿'),
+    ('ཿ', 'ཿ'),
+    ('ေ', 'ေ'),
+    ('ျ', 'ြ'),
+    ('ၖ', 'ၗ'),
+    ('ႄ', 'ႄ'),
+    ('᜕', '᜕'),
+    ('᜴', '᜴'),
+    ('ា', 'ា'),
+    ('ើ', 'ៅ'),
+    ('ះ', 'ៈ'),
+    ('ᤣ', 'ᤦ'),
+    ('ᤩ', 'ᤫ'),
+    ('ᤰ', 'ᤱ'),
+    ('ᤳ', 'ᤸ'),
+    ('ᨙ', 'ᨚ'),
+    ('ᩕ', 'ᩕ'),
+    ('ᩗ', 'ᩗ'),
+    ('ᩭ', 'ᩲ'),
+    ('ᬄ', 'ᬄ'),
+    ('ᬻ', 'ᬻ'),
+    ('ᬽ', 'ᭁ'),
+    ('ᭃ', '᭄'),
+    ('ᮂ', 'ᮂ'),
+    ('ᮡ', 'ᮡ'),
+    ('ᮦ', 'ᮧ'),
+    ('᮪', '᮪'),
+    ('ᯧ', 'ᯧ'),
+    ('ᯪ', 'ᯬ'),
+    ('ᯮ', 'ᯮ'),
+    ('᯲', '᯳'),
+    ('ᰤ', 'ᰫ'),
+    ('ᰴ', 'ᰵ'),
+    ('᳡', '᳡'),
+    ('᳷', '᳷'),
+    ('ꠣ', 'ꠤ'),
+    ('ꠧ', 'ꠧ'),
+    ('ꢀ', 'ꢁ'),
+    ('ꢴ', 'ꣃ'),
+    ('ꥒ', '꥓'),
+    ('ꦃ', 'ꦃ'),
+    ('ꦴ', 'ꦵ'),
+    ('ꦺ', 'ꦻ'),
+    ('ꦾ', '꧀'),
+    ('ꨯ', 'ꨰ'),
+    ('ꨳ', 'ꨴ'),
+    ('ꩍ', 'ꩍ'),
+    ('ꫫ', 'ꫫ'),
+    ('ꫮ', 'ꫯ'),
+    ('ꫵ', 'ꫵ'),
+    ('ꯣ', 'ꯤ'),
+    ('ꯦ', 'ꯧ'),
+    ('ꯩ', 'ꯪ'),
+    ('꯬', '꯬'),
+    ('𑀀', '𑀀'),
+    ('𑀂', '𑀂'),
+    ('𑂂', '𑂂'),
+    ('𑂰', '𑂲'),
+    ('𑂷', '𑂸'),
+    ('𑄬', '𑄬'),
+    ('𑅅', '𑅆'),
+    ('𑆂', '𑆂'),
+    ('𑆳', '𑆵'),
+    ('𑆿', '𑇀'),
+    ('𑇎', '𑇎'),
+    ('𑈬', '𑈮'),
+    ('𑈲', '𑈳'),
+    ('𑈵', '𑈵'),
+    ('𑋠', '𑋢'),
+    ('𑌂', '𑌃'),
+    ('𑌿', '𑌿'),
+    ('𑍁', '𑍄'),
+    ('𑍇', '𑍈'),
+    ('𑍋', '𑍍'),
+    ('𑍢', '𑍣'),
+    ('𑐵', '𑐷'),
+    ('𑑀', '𑑁'),
+    ('𑑅', '𑑅'),
+    ('𑒱', '𑒲'),
+    ('𑒹', '𑒹'),
+    ('𑒻', '𑒼'),
+    ('𑒾', '𑒾'),
+    ('𑓁', '𑓁'),
+    ('𑖰', '𑖱'),
+    ('𑖸', '𑖻'),
+    ('𑖾', '𑖾'),
+    ('𑘰', '𑘲'),
+    ('𑘻', '𑘼'),
+    ('𑘾', '𑘾'),
+    ('𑚬', '𑚬'),
+    ('𑚮', '𑚯'),
+    ('𑚶', '𑚶'),
+    ('𑜦', '𑜦'),
+    ('𑠬', '𑠮'),
+    ('𑠸', '𑠸'),
+    ('𑤱', '𑤵'),
+    ('𑤷', '𑤸'),
+    ('𑤽', '𑤽'),
+    ('𑥀', '𑥀'),
+    ('𑥂', '𑥂'),
+    ('𑧑', '𑧓'),
+    ('𑧜', '𑧟'),
+    ('𑧤', '𑧤'),
+    ('𑨹', '𑨹'),
+    ('𑩗', '𑩘'),
+    ('𑪗', '𑪗'),
+    ('𑰯', '𑰯'),
+    ('𑰾', '𑰾'),
+    ('𑲩', '𑲩'),
+    ('𑲱', '𑲱'),
+    ('𑲴', '𑲴'),
+    ('𑶊', '𑶎'),
+    ('𑶓', '𑶔'),
+    ('𑶖', '𑶖'),
+    ('𑻵', '𑻶'),
+    ('𑼃', '𑼃'),
+    ('𑼴', '𑼵'),
+    ('𑼾', '𑼿'),
+    ('𑽁', '𑽁'),
+    ('𖽑', '𖾇'),
+    ('𖿰', '𖿱'),
+    ('𝅦', '𝅦'),
+    ('𝅭', '𝅭'),
+];
+
+pub const T: &'static [(char, char)] = &[('ᆨ', 'ᇿ'), ('ퟋ', 'ퟻ')];
+
+pub const V: &'static [(char, char)] = &[('ᅠ', 'ᆧ'), ('ힰ', 'ퟆ')];
+
+pub const ZWJ: &'static [(char, char)] = &[('\u{200d}', '\u{200d}')];
diff --git a/crates/regex-syntax/src/unicode_tables/mod.rs b/crates/regex-syntax/src/unicode_tables/mod.rs
new file mode 100644
index 0000000..20736c7
--- /dev/null
+++ b/crates/regex-syntax/src/unicode_tables/mod.rs
@@ -0,0 +1,57 @@
+#[cfg(feature = "unicode-age")]
+pub mod age;
+
+#[cfg(feature = "unicode-case")]
+pub mod case_folding_simple;
+
+#[cfg(feature = "unicode-gencat")]
+pub mod general_category;
+
+#[cfg(feature = "unicode-segment")]
+pub mod grapheme_cluster_break;
+
+#[cfg(all(feature = "unicode-perl", not(feature = "unicode-gencat")))]
+#[allow(dead_code)]
+pub mod perl_decimal;
+
+#[cfg(all(feature = "unicode-perl", not(feature = "unicode-bool")))]
+#[allow(dead_code)]
+pub mod perl_space;
+
+#[cfg(feature = "unicode-perl")]
+pub mod perl_word;
+
+#[cfg(feature = "unicode-bool")]
+pub mod property_bool;
+
+#[cfg(any(
+    feature = "unicode-age",
+    feature = "unicode-bool",
+    feature = "unicode-gencat",
+    feature = "unicode-perl",
+    feature = "unicode-script",
+    feature = "unicode-segment",
+))]
+pub mod property_names;
+
+#[cfg(any(
+    feature = "unicode-age",
+    feature = "unicode-bool",
+    feature = "unicode-gencat",
+    feature = "unicode-perl",
+    feature = "unicode-script",
+    feature = "unicode-segment",
+))]
+pub mod property_values;
+
+#[cfg(feature = "unicode-script")]
+pub mod script;
+
+#[cfg(feature = "unicode-script")]
+pub mod script_extension;
+
+#[cfg(feature = "unicode-segment")]
+pub mod sentence_break;
+
+#[cfg(feature = "unicode-segment")]
+pub mod word_break;
diff --git a/crates/regex-syntax/src/unicode_tables/perl_decimal.rs b/crates/regex-syntax/src/unicode_tables/perl_decimal.rs
new file mode 100644
index 0000000..4f4c08a
--- /dev/null
+++ b/crates/regex-syntax/src/unicode_tables/perl_decimal.rs
@@ -0,0 +1,77 @@
+// DO NOT EDIT THIS FILE. IT WAS AUTOMATICALLY GENERATED BY:
+//
+//   ucd-generate general-category ucd-15.0.0 --chars --include decimalnumber
+//
+// Unicode version: 15.0.0.
+//
+// ucd-generate 0.2.14 is available on crates.io.
+
+pub const BY_NAME: &'static [(&'static str, &'static [(char, char)])] =
+    &[("Decimal_Number", DECIMAL_NUMBER)];
+
+pub const DECIMAL_NUMBER: &'static [(char, char)] = &[
+    ('0', '9'),
+    ('٠', '٩'),
+    ('۰', '۹'),
+    ('߀', '߉'),
+    ('०', '९'),
+    ('০', '৯'),
+    ('੦', '੯'),
+    ('૦', '૯'),
+    ('୦', '୯'),
+    ('௦', '௯'),
+    ('౦', '౯'),
+    ('೦', '೯'),
+    ('൦', '൯'),
+    ('෦', '෯'),
+    ('๐', '๙'),
+    ('໐', '໙'),
+    ('༠', '༩'),
+    ('၀', '၉'),
+    ('႐', '႙'),
+    ('០', '៩'),
+    ('᠐', '᠙'),
+    ('᥆', '᥏'),
+    ('᧐', '᧙'),
+    ('᪀', '᪉'),
+    ('᪐', '᪙'),
+    ('᭐', '᭙'),
+    ('᮰', '᮹'),
+    ('᱀', '᱉'),
+    ('᱐', '᱙'),
+    ('꘠', '꘩'),
+    ('꣐', '꣙'),
+    ('꤀', '꤉'),
+    ('꧐', '꧙'),
+    ('꧰', '꧹'),
+    ('꩐', '꩙'),
+    ('꯰', '꯹'),
+    ('０', '９'),
+    ('𐒠', '𐒩'),
+    ('𐴰', '𐴹'),
+    ('𑁦', '𑁯'),
+    ('𑃰', '𑃹'),
+    ('𑄶', '𑄿'),
+    ('𑇐', '𑇙'),
+    ('𑋰', '𑋹'),
+    ('𑑐', '𑑙'),
+    ('𑓐', '𑓙'),
+    ('𑙐', '𑙙'),
+    ('𑛀', '𑛉'),
+    ('𑜰', '𑜹'),
+    ('𑣠', '𑣩'),
+    ('𑥐', '𑥙'),
+    ('𑱐', '𑱙'),
+    ('𑵐', '𑵙'),
+    ('𑶠', '𑶩'),
+    ('𑽐', '𑽙'),
+    ('𖩠', '𖩩'),
+    ('𖫀', '𖫉'),
+    ('𖭐', '𖭙'),
+    ('𝟎', '𝟿'),
+    ('𞅀', '𞅉'),
+    ('𞋰', '𞋹'),
+    ('𞓰', '𞓹'),
+    ('𞥐', '𞥙'),
+    ('🯰', '🯹'),
+];
diff --git a/crates/regex-syntax/src/unicode_tables/perl_space.rs b/crates/regex-syntax/src/unicode_tables/perl_space.rs
new file mode 100644
index 0000000..1741695
--- /dev/null
+++ b/crates/regex-syntax/src/unicode_tables/perl_space.rs
@@ -0,0 +1,23 @@
+// DO NOT EDIT THIS FILE. IT WAS AUTOMATICALLY GENERATED BY:
+//
+//   ucd-generate property-bool ucd-15.0.0 --chars --include whitespace
+//
+// Unicode version: 15.0.0.
+//
+// ucd-generate 0.2.14 is available on crates.io.
+
+pub const BY_NAME: &'static [(&'static str, &'static [(char, char)])] =
+    &[("White_Space", WHITE_SPACE)];
+
+pub const WHITE_SPACE: &'static [(char, char)] = &[
+    ('\t', '\r'),
+    (' ', ' '),
+    ('\u{85}', '\u{85}'),
+    ('\u{a0}', '\u{a0}'),
+    ('\u{1680}', '\u{1680}'),
+    ('\u{2000}', '\u{200a}'),
+    ('\u{2028}', '\u{2029}'),
+    ('\u{202f}', '\u{202f}'),
+    ('\u{205f}', '\u{205f}'),
+    ('\u{3000}', '\u{3000}'),
+];
diff --git a/crates/regex-syntax/src/unicode_tables/perl_word.rs b/crates/regex-syntax/src/unicode_tables/perl_word.rs
new file mode 100644
index 0000000..c1b66bd
--- /dev/null
+++ b/crates/regex-syntax/src/unicode_tables/perl_word.rs
@@ -0,0 +1,781 @@
+// DO NOT EDIT THIS FILE. IT WAS AUTOMATICALLY GENERATED BY:
+//
+//   ucd-generate perl-word ucd-15.0.0 --chars
+//
+// Unicode version: 15.0.0.
+//
+// ucd-generate 0.2.14 is available on crates.io.
+
+pub const PERL_WORD: &'static [(char, char)] = &[
+    ('0', '9'),
+    ('A', 'Z'),
+    ('_', '_'),
+    ('a', 'z'),
+    ('ª', 'ª'),
+    ('µ', 'µ'),
+    ('º', 'º'),
+    ('À', 'Ö'),
+    ('Ø', 'ö'),
+    ('ø', 'ˁ'),
+    ('ˆ', 'ˑ'),
+    ('ˠ', 'ˤ'),
+    ('ˬ', 'ˬ'),
+    ('ˮ', 'ˮ'),
+    ('\u{300}', 'ʹ'),
+    ('Ͷ', 'ͷ'),
+    ('ͺ', 'ͽ'),
+    ('Ϳ', 'Ϳ'),
+    ('Ά', 'Ά'),
+    ('Έ', 'Ί'),
+    ('Ό', 'Ό'),
+    ('Ύ', 'Ρ'),
+    ('Σ', 'ϵ'),
+    ('Ϸ', 'ҁ'),
+    ('\u{483}', 'ԯ'),
+    ('Ա', 'Ֆ'),
+    ('ՙ', 'ՙ'),
+    ('ՠ', 'ֈ'),
+    ('\u{591}', '\u{5bd}'),
+    ('\u{5bf}', '\u{5bf}'),
+    ('\u{5c1}', '\u{5c2}'),
+    ('\u{5c4}', '\u{5c5}'),
+    ('\u{5c7}', '\u{5c7}'),
+    ('א', 'ת'),
+    ('ׯ', 'ײ'),
+    ('\u{610}', '\u{61a}'),
+    ('ؠ', '٩'),
+    ('ٮ', 'ۓ'),
+    ('ە', '\u{6dc}'),
+    ('\u{6df}', '\u{6e8}'),
+    ('\u{6ea}', 'ۼ'),
+    ('ۿ', 'ۿ'),
+    ('ܐ', '\u{74a}'),
+    ('ݍ', 'ޱ'),
+    ('߀', 'ߵ'),
+    ('ߺ', 'ߺ'),
+    ('\u{7fd}', '\u{7fd}'),
+    ('ࠀ', '\u{82d}'),
+    ('ࡀ', '\u{85b}'),
+    ('ࡠ', 'ࡪ'),
+    ('ࡰ', 'ࢇ'),
+    ('ࢉ', 'ࢎ'),
+    ('\u{898}', '\u{8e1}'),
+    ('\u{8e3}', '\u{963}'),
+    ('०', '९'),
+    ('ॱ', 'ঃ'),
+    ('অ', 'ঌ'),
+    ('এ', 'ঐ'),
+    ('ও', 'ন'),
+    ('প', 'র'),
+    ('ল', 'ল'),
+    ('শ', 'হ'),
+    ('\u{9bc}', '\u{9c4}'),
+    ('ে', 'ৈ'),
+    ('ো', 'ৎ'),
+    ('\u{9d7}', '\u{9d7}'),
+    ('ড়', 'ঢ়'),
+    ('য়', '\u{9e3}'),
+    ('০', 'ৱ'),
+    ('ৼ', 'ৼ'),
+    ('\u{9fe}', '\u{9fe}'),
+    ('\u{a01}', 'ਃ'),
+    ('ਅ', 'ਊ'),
+    ('ਏ', 'ਐ'),
+    ('ਓ', 'ਨ'),
+    ('ਪ', 'ਰ'),
+    ('ਲ', 'ਲ਼'),
+    ('ਵ', 'ਸ਼'),
+    ('ਸ', 'ਹ'),
+    ('\u{a3c}', '\u{a3c}'),
+    ('ਾ', '\u{a42}'),
+    ('\u{a47}', '\u{a48}'),
+    ('\u{a4b}', '\u{a4d}'),
+    ('\u{a51}', '\u{a51}'),
+    ('ਖ਼', 'ੜ'),
+    ('ਫ਼', 'ਫ਼'),
+    ('੦', '\u{a75}'),
+    ('\u{a81}', 'ઃ'),
+    ('અ', 'ઍ'),
+    ('એ', 'ઑ'),
+    ('ઓ', 'ન'),
+    ('પ', 'ર'),
+    ('લ', 'ળ'),
+    ('વ', 'હ'),
+    ('\u{abc}', '\u{ac5}'),
+    ('\u{ac7}', 'ૉ'),
+    ('ો', '\u{acd}'),
+    ('ૐ', 'ૐ'),
+    ('ૠ', '\u{ae3}'),
+    ('૦', '૯'),
+    ('ૹ', '\u{aff}'),
+    ('\u{b01}', 'ଃ'),
+    ('ଅ', 'ଌ'),
+    ('ଏ', 'ଐ'),
+    ('ଓ', 'ନ'),
+    ('ପ', 'ର'),
+    ('ଲ', 'ଳ'),
+    ('ଵ', 'ହ'),
+    ('\u{b3c}', '\u{b44}'),
+    ('େ', 'ୈ'),
+    ('ୋ', '\u{b4d}'),
+    ('\u{b55}', '\u{b57}'),
+    ('ଡ଼', 'ଢ଼'),
+    ('ୟ', '\u{b63}'),
+    ('୦', '୯'),
+    ('ୱ', 'ୱ'),
+    ('\u{b82}', 'ஃ'),
+    ('அ', 'ஊ'),
+    ('எ', 'ஐ'),
+    ('ஒ', 'க'),
+    ('ங', 'ச'),
+    ('ஜ', 'ஜ'),
+    ('ஞ', 'ட'),
+    ('ண', 'த'),
+    ('ந', 'ப'),
+    ('ம', 'ஹ'),
+    ('\u{bbe}', 'ூ'),
+    ('ெ', 'ை'),
+    ('ொ', '\u{bcd}'),
+    ('ௐ', 'ௐ'),
+    ('\u{bd7}', '\u{bd7}'),
+    ('௦', '௯'),
+    ('\u{c00}', 'ఌ'),
+    ('ఎ', 'ఐ'),
+    ('ఒ', 'న'),
+    ('ప', 'హ'),
+    ('\u{c3c}', 'ౄ'),
+    ('\u{c46}', '\u{c48}'),
+    ('\u{c4a}', '\u{c4d}'),
+    ('\u{c55}', '\u{c56}'),
+    ('ౘ', 'ౚ'),
+    ('ౝ', 'ౝ'),
+    ('ౠ', '\u{c63}'),
+    ('౦', '౯'),
+    ('ಀ', 'ಃ'),
+    ('ಅ', 'ಌ'),
+    ('ಎ', 'ಐ'),
+    ('ಒ', 'ನ'),
+    ('ಪ', 'ಳ'),
+    ('ವ', 'ಹ'),
+    ('\u{cbc}', 'ೄ'),
+    ('\u{cc6}', 'ೈ'),
+    ('ೊ', '\u{ccd}'),
+    ('\u{cd5}', '\u{cd6}'),
+    ('ೝ', 'ೞ'),
+    ('ೠ', '\u{ce3}'),
+    ('೦', '೯'),
+    ('ೱ', 'ೳ'),
+    ('\u{d00}', 'ഌ'),
+    ('എ', 'ഐ'),
+    ('ഒ', '\u{d44}'),
+    ('െ', 'ൈ'),
+    ('ൊ', 'ൎ'),
+    ('ൔ', '\u{d57}'),
+    ('ൟ', '\u{d63}'),
+    ('൦', '൯'),
+    ('ൺ', 'ൿ'),
+    ('\u{d81}', 'ඃ'),
+    ('අ', 'ඖ'),
+    ('ක', 'න'),
+    ('ඳ', 'ර'),
+    ('ල', 'ල'),
+    ('ව', 'ෆ'),
+    ('\u{dca}', '\u{dca}'),
+    ('\u{dcf}', '\u{dd4}'),
+    ('\u{dd6}', '\u{dd6}'),
+    ('ෘ', '\u{ddf}'),
+    ('෦', '෯'),
+    ('ෲ', 'ෳ'),
+    ('ก', '\u{e3a}'),
+    ('เ', '\u{e4e}'),
+    ('๐', '๙'),
+    ('ກ', 'ຂ'),
+    ('ຄ', 'ຄ'),
+    ('ຆ', 'ຊ'),
+    ('ຌ', 'ຣ'),
+    ('ລ', 'ລ'),
+    ('ວ', 'ຽ'),
+    ('ເ', 'ໄ'),
+    ('ໆ', 'ໆ'),
+    ('\u{ec8}', '\u{ece}'),
+    ('໐', '໙'),
+    ('ໜ', 'ໟ'),
+    ('ༀ', 'ༀ'),
+    ('\u{f18}', '\u{f19}'),
+    ('༠', '༩'),
+    ('\u{f35}', '\u{f35}'),
+    ('\u{f37}', '\u{f37}'),
+    ('\u{f39}', '\u{f39}'),
+    ('༾', 'ཇ'),
+    ('ཉ', 'ཬ'),
+    ('\u{f71}', '\u{f84}'),
+    ('\u{f86}', '\u{f97}'),
+    ('\u{f99}', '\u{fbc}'),
+    ('\u{fc6}', '\u{fc6}'),
+    ('က', '၉'),
+    ('ၐ', '\u{109d}'),
+    ('Ⴀ', 'Ⴥ'),
+    ('Ⴧ', 'Ⴧ'),
+    ('Ⴭ', 'Ⴭ'),
+    ('ა', 'ჺ'),
+    ('ჼ', 'ቈ'),
+    ('ቊ', 'ቍ'),
+    ('ቐ', 'ቖ'),
+    ('ቘ', 'ቘ'),
+    ('ቚ', 'ቝ'),
+    ('በ', 'ኈ'),
+    ('ኊ', 'ኍ'),
+    ('ነ', 'ኰ'),
+    ('ኲ', 'ኵ'),
+    ('ኸ', 'ኾ'),
+    ('ዀ', 'ዀ'),
+    ('ዂ', 'ዅ'),
+    ('ወ', 'ዖ'),
+    ('ዘ', 'ጐ'),
+    ('ጒ', 'ጕ'),
+    ('ጘ', 'ፚ'),
+    ('\u{135d}', '\u{135f}'),
+    ('ᎀ', 'ᎏ'),
+    ('Ꭰ', 'Ᏽ'),
+    ('ᏸ', 'ᏽ'),
+    ('ᐁ', 'ᙬ'),
+    ('ᙯ', 'ᙿ'),
+    ('ᚁ', 'ᚚ'),
+    ('ᚠ', 'ᛪ'),
+    ('ᛮ', 'ᛸ'),
+    ('ᜀ', '᜕'),
+    ('ᜟ', '᜴'),
+    ('ᝀ', '\u{1753}'),
+    ('ᝠ', 'ᝬ'),
+    ('ᝮ', 'ᝰ'),
+    ('\u{1772}', '\u{1773}'),
+    ('ក', '\u{17d3}'),
+    ('ៗ', 'ៗ'),
+    ('ៜ', '\u{17dd}'),
+    ('០', '៩'),
+    ('\u{180b}', '\u{180d}'),
+    ('\u{180f}', '᠙'),
+    ('ᠠ', 'ᡸ'),
+    ('ᢀ', 'ᢪ'),
+    ('ᢰ', 'ᣵ'),
+    ('ᤀ', 'ᤞ'),
+    ('\u{1920}', 'ᤫ'),
+    ('ᤰ', '\u{193b}'),
+    ('᥆', 'ᥭ'),
+    ('ᥰ', 'ᥴ'),
+    ('ᦀ', 'ᦫ'),
+    ('ᦰ', 'ᧉ'),
+    ('᧐', '᧙'),
+    ('ᨀ', '\u{1a1b}'),
+    ('ᨠ', '\u{1a5e}'),
+    ('\u{1a60}', '\u{1a7c}'),
+    ('\u{1a7f}', '᪉'),
+    ('᪐', '᪙'),
+    ('ᪧ', 'ᪧ'),
+    ('\u{1ab0}', '\u{1ace}'),
+    ('\u{1b00}', 'ᭌ'),
+    ('᭐', '᭙'),
+    ('\u{1b6b}', '\u{1b73}'),
+    ('\u{1b80}', '᯳'),
+    ('ᰀ', '\u{1c37}'),
+    ('᱀', '᱉'),
+    ('ᱍ', 'ᱽ'),
+    ('ᲀ', 'ᲈ'),
+    ('Ა', 'Ჺ'),
+    ('Ჽ', 'Ჿ'),
+    ('\u{1cd0}', '\u{1cd2}'),
+    ('\u{1cd4}', 'ᳺ'),
+    ('ᴀ', 'ἕ'),
+    ('Ἐ', 'Ἕ'),
+    ('ἠ', 'ὅ'),
+    ('Ὀ', 'Ὅ'),
+    ('ὐ', 'ὗ'),
+    ('Ὑ', 'Ὑ'),
+    ('Ὓ', 'Ὓ'),
+    ('Ὕ', 'Ὕ'),
+    ('Ὗ', 'ώ'),
+    ('ᾀ', 'ᾴ'),
+    ('ᾶ', 'ᾼ'),
+    ('ι', 'ι'),
+    ('ῂ', 'ῄ'),
+    ('ῆ', 'ῌ'),
+    ('ῐ', 'ΐ'),
+    ('ῖ', 'Ί'),
+    ('ῠ', 'Ῥ'),
+    ('ῲ', 'ῴ'),
+    ('ῶ', 'ῼ'),
+    ('\u{200c}', '\u{200d}'),
+    ('‿', '⁀'),
+    ('⁔', '⁔'),
+    ('ⁱ', 'ⁱ'),
+    ('ⁿ', 'ⁿ'),
+    ('ₐ', 'ₜ'),
+    ('\u{20d0}', '\u{20f0}'),
+    ('ℂ', 'ℂ'),
+    ('ℇ', 'ℇ'),
+    ('ℊ', 'ℓ'),
+    ('ℕ', 'ℕ'),
+    ('ℙ', 'ℝ'),
+    ('ℤ', 'ℤ'),
+    ('Ω', 'Ω'),
+    ('ℨ', 'ℨ'),
+    ('K', 'ℭ'),
+    ('ℯ', 'ℹ'),
+    ('ℼ', 'ℿ'),
+    ('ⅅ', 'ⅉ'),
+    ('ⅎ', 'ⅎ'),
+    ('Ⅰ', 'ↈ'),
+    ('Ⓐ', 'ⓩ'),
+    ('Ⰰ', 'ⳤ'),
+    ('Ⳬ', 'ⳳ'),
+    ('ⴀ', 'ⴥ'),
+    ('ⴧ', 'ⴧ'),
+    ('ⴭ', 'ⴭ'),
+    ('ⴰ', 'ⵧ'),
+    ('ⵯ', 'ⵯ'),
+    ('\u{2d7f}', 'ⶖ'),
+    ('ⶠ', 'ⶦ'),
+    ('ⶨ', 'ⶮ'),
+    ('ⶰ', 'ⶶ'),
+    ('ⶸ', 'ⶾ'),
+    ('ⷀ', 'ⷆ'),
+    ('ⷈ', 'ⷎ'),
+    ('ⷐ', 'ⷖ'),
+    ('ⷘ', 'ⷞ'),
+    ('\u{2de0}', '\u{2dff}'),
+    ('ⸯ', 'ⸯ'),
+    ('々', '〇'),
+    ('〡', '\u{302f}'),
+    ('〱', '〵'),
+    ('〸', '〼'),
+    ('ぁ', 'ゖ'),
+    ('\u{3099}', '\u{309a}'),
+    ('ゝ', 'ゟ'),
+    ('ァ', 'ヺ'),
+    ('ー', 'ヿ'),
+    ('ㄅ', 'ㄯ'),
+    ('ㄱ', 'ㆎ'),
+    ('ㆠ', 'ㆿ'),
+    ('ㇰ', 'ㇿ'),
+    ('㐀', '䶿'),
+    ('一', 'ꒌ'),
+    ('ꓐ', 'ꓽ'),
+    ('ꔀ', 'ꘌ'),
+    ('ꘐ', 'ꘫ'),
+    ('Ꙁ', '\u{a672}'),
+    ('\u{a674}', '\u{a67d}'),
+    ('ꙿ', '\u{a6f1}'),
+    ('ꜗ', 'ꜟ'),
+    ('Ꜣ', 'ꞈ'),
+    ('Ꞌ', 'ꟊ'),
+    ('Ꟑ', 'ꟑ'),
+    ('ꟓ', 'ꟓ'),
+    ('ꟕ', 'ꟙ'),
+    ('ꟲ', 'ꠧ'),
+    ('\u{a82c}', '\u{a82c}'),
+    ('ꡀ', 'ꡳ'),
+    ('ꢀ', '\u{a8c5}'),
+    ('꣐', '꣙'),
+    ('\u{a8e0}', 'ꣷ'),
+    ('ꣻ', 'ꣻ'),
+    ('ꣽ', '\u{a92d}'),
+    ('ꤰ', '꥓'),
+    ('ꥠ', 'ꥼ'),
+    ('\u{a980}', '꧀'),
+    ('ꧏ', '꧙'),
+    ('ꧠ', 'ꧾ'),
+    ('ꨀ', '\u{aa36}'),
+    ('ꩀ', 'ꩍ'),
+    ('꩐', '꩙'),
+    ('ꩠ', 'ꩶ'),
+    ('ꩺ', 'ꫂ'),
+    ('ꫛ', 'ꫝ'),
+    ('ꫠ', 'ꫯ'),
+    ('ꫲ', '\u{aaf6}'),
+    ('ꬁ', 'ꬆ'),
+    ('ꬉ', 'ꬎ'),
+    ('ꬑ', 'ꬖ'),
+    ('ꬠ', 'ꬦ'),
+    ('ꬨ', 'ꬮ'),
+    ('ꬰ', 'ꭚ'),
+    ('ꭜ', 'ꭩ'),
+    ('ꭰ', 'ꯪ'),
+    ('꯬', '\u{abed}'),
+    ('꯰', '꯹'),
+    ('가', '힣'),
+    ('ힰ', 'ퟆ'),
+    ('ퟋ', 'ퟻ'),
+    ('豈', '舘'),
+    ('並', '龎'),
+    ('ﬀ', 'ﬆ'),
+    ('ﬓ', 'ﬗ'),
+    ('יִ', 'ﬨ'),
+    ('שׁ', 'זּ'),
+    ('טּ', 'לּ'),
+    ('מּ', 'מּ'),
+    ('נּ', 'סּ'),
+    ('ףּ', 'פּ'),
+    ('צּ', 'ﮱ'),
+    ('ﯓ', 'ﴽ'),
+    ('ﵐ', 'ﶏ'),
+    ('ﶒ', 'ﷇ'),
+    ('ﷰ', 'ﷻ'),
+    ('\u{fe00}', '\u{fe0f}'),
+    ('\u{fe20}', '\u{fe2f}'),
+    ('︳', '︴'),
+    ('﹍', '﹏'),
+    ('ﹰ', 'ﹴ'),
+    ('ﹶ', 'ﻼ'),
+    ('０', '９'),
+    ('Ａ', 'Ｚ'),
+    ('＿', '＿'),
+    ('ａ', 'ｚ'),
+    ('ｦ', 'ﾾ'),
+    ('ￂ', 'ￇ'),
+    ('ￊ', 'ￏ'),
+    ('ￒ', 'ￗ'),
+    ('ￚ', 'ￜ'),
+    ('𐀀', '𐀋'),
+    ('𐀍', '𐀦'),
+    ('𐀨', '𐀺'),
+    ('𐀼', '𐀽'),
+    ('𐀿', '𐁍'),
+    ('𐁐', '𐁝'),
+    ('𐂀', '𐃺'),
+    ('𐅀', '𐅴'),
+    ('\u{101fd}', '\u{101fd}'),
+    ('𐊀', '𐊜'),
+    ('𐊠', '𐋐'),
+    ('\u{102e0}', '\u{102e0}'),
+    ('𐌀', '𐌟'),
+    ('𐌭', '𐍊'),
+    ('𐍐', '\u{1037a}'),
+    ('𐎀', '𐎝'),
+    ('𐎠', '𐏃'),
+    ('𐏈', '𐏏'),
+    ('𐏑', '𐏕'),
+    ('𐐀', '𐒝'),
+    ('𐒠', '𐒩'),
+    ('𐒰', '𐓓'),
+    ('𐓘', '𐓻'),
+    ('𐔀', '𐔧'),
+    ('𐔰', '𐕣'),
+    ('𐕰', '𐕺'),
+    ('𐕼', '𐖊'),
+    ('𐖌', '𐖒'),
+    ('𐖔', '𐖕'),
+    ('𐖗', '𐖡'),
+    ('𐖣', '𐖱'),
+    ('𐖳', '𐖹'),
+    ('𐖻', '𐖼'),
+    ('𐘀', '𐜶'),
+    ('𐝀', '𐝕'),
+    ('𐝠', '𐝧'),
+    ('𐞀', '𐞅'),
+    ('𐞇', '𐞰'),
+    ('𐞲', '𐞺'),
+    ('𐠀', '𐠅'),
+    ('𐠈', '𐠈'),
+    ('𐠊', '𐠵'),
+    ('𐠷', '𐠸'),
+    ('𐠼', '𐠼'),
+    ('𐠿', '𐡕'),
+    ('𐡠', '𐡶'),
+    ('𐢀', '𐢞'),
+    ('𐣠', '𐣲'),
+    ('𐣴', '𐣵'),
+    ('𐤀', '𐤕'),
+    ('𐤠', '𐤹'),
+    ('𐦀', '𐦷'),
+    ('𐦾', '𐦿'),
+    ('𐨀', '\u{10a03}'),
+    ('\u{10a05}', '\u{10a06}'),
+    ('\u{10a0c}', '𐨓'),
+    ('𐨕', '𐨗'),
+    ('𐨙', '𐨵'),
+    ('\u{10a38}', '\u{10a3a}'),
+    ('\u{10a3f}', '\u{10a3f}'),
+    ('𐩠', '𐩼'),
+    ('𐪀', '𐪜'),
+    ('𐫀', '𐫇'),
+    ('𐫉', '\u{10ae6}'),
+    ('𐬀', '𐬵'),
+    ('𐭀', '𐭕'),
+    ('𐭠', '𐭲'),
+    ('𐮀', '𐮑'),
+    ('𐰀', '𐱈'),
+    ('𐲀', '𐲲'),
+    ('𐳀', '𐳲'),
+    ('𐴀', '\u{10d27}'),
+    ('𐴰', '𐴹'),
+    ('𐺀', '𐺩'),
+    ('\u{10eab}', '\u{10eac}'),
+    ('𐺰', '𐺱'),
+    ('\u{10efd}', '𐼜'),
+    ('𐼧', '𐼧'),
+    ('𐼰', '\u{10f50}'),
+    ('𐽰', '\u{10f85}'),
+    ('𐾰', '𐿄'),
+    ('𐿠', '𐿶'),
+    ('𑀀', '\u{11046}'),
+    ('𑁦', '𑁵'),
+    ('\u{1107f}', '\u{110ba}'),
+    ('\u{110c2}', '\u{110c2}'),
+    ('𑃐', '𑃨'),
+    ('𑃰', '𑃹'),
+    ('\u{11100}', '\u{11134}'),
+    ('𑄶', '𑄿'),
+    ('𑅄', '𑅇'),
+    ('𑅐', '\u{11173}'),
+    ('𑅶', '𑅶'),
+    ('\u{11180}', '𑇄'),
+    ('\u{111c9}', '\u{111cc}'),
+    ('𑇎', '𑇚'),
+    ('𑇜', '𑇜'),
+    ('𑈀', '𑈑'),
+    ('𑈓', '\u{11237}'),
+    ('\u{1123e}', '\u{11241}'),
+    ('𑊀', '𑊆'),
+    ('𑊈', '𑊈'),
+    ('𑊊', '𑊍'),
+    ('𑊏', '𑊝'),
+    ('𑊟', '𑊨'),
+    ('𑊰', '\u{112ea}'),
+    ('𑋰', '𑋹'),
+    ('\u{11300}', '𑌃'),
+    ('𑌅', '𑌌'),
+    ('𑌏', '𑌐'),
+    ('𑌓', '𑌨'),
+    ('𑌪', '𑌰'),
+    ('𑌲', '𑌳'),
+    ('𑌵', '𑌹'),
+    ('\u{1133b}', '𑍄'),
+    ('𑍇', '𑍈'),
+    ('𑍋', '𑍍'),
+    ('𑍐', '𑍐'),
+    ('\u{11357}', '\u{11357}'),
+    ('𑍝', '𑍣'),
+    ('\u{11366}', '\u{1136c}'),
+    ('\u{11370}', '\u{11374}'),
+    ('𑐀', '𑑊'),
+    ('𑑐', '𑑙'),
+    ('\u{1145e}', '𑑡'),
+    ('𑒀', '𑓅'),
+    ('𑓇', '𑓇'),
+    ('𑓐', '𑓙'),
+    ('𑖀', '\u{115b5}'),
+    ('𑖸', '\u{115c0}'),
+    ('𑗘', '\u{115dd}'),
+    ('𑘀', '\u{11640}'),
+    ('𑙄', '𑙄'),
+    ('𑙐', '𑙙'),
+    ('𑚀', '𑚸'),
+    ('𑛀', '𑛉'),
+    ('𑜀', '𑜚'),
+    ('\u{1171d}', '\u{1172b}'),
+    ('𑜰', '𑜹'),
+    ('𑝀', '𑝆'),
+    ('𑠀', '\u{1183a}'),
+    ('𑢠', '𑣩'),
+    ('𑣿', '𑤆'),
+    ('𑤉', '𑤉'),
+    ('𑤌', '𑤓'),
+    ('𑤕', '𑤖'),
+    ('𑤘', '𑤵'),
+    ('𑤷', '𑤸'),
+    ('\u{1193b}', '\u{11943}'),
+    ('𑥐', '𑥙'),
+    ('𑦠', '𑦧'),
+    ('𑦪', '\u{119d7}'),
+    ('\u{119da}', '𑧡'),
+    ('𑧣', '𑧤'),
+    ('𑨀', '\u{11a3e}'),
+    ('\u{11a47}', '\u{11a47}'),
+    ('𑩐', '\u{11a99}'),
+    ('𑪝', '𑪝'),
+    ('𑪰', '𑫸'),
+    ('𑰀', '𑰈'),
+    ('𑰊', '\u{11c36}'),
+    ('\u{11c38}', '𑱀'),
+    ('𑱐', '𑱙'),
+    ('𑱲', '𑲏'),
+    ('\u{11c92}', '\u{11ca7}'),
+    ('𑲩', '\u{11cb6}'),
+    ('𑴀', '𑴆'),
+    ('𑴈', '𑴉'),
+    ('𑴋', '\u{11d36}'),
+    ('\u{11d3a}', '\u{11d3a}'),
+    ('\u{11d3c}', '\u{11d3d}'),
+    ('\u{11d3f}', '\u{11d47}'),
+    ('𑵐', '𑵙'),
+    ('𑵠', '𑵥'),
+    ('𑵧', '𑵨'),
+    ('𑵪', '𑶎'),
+    ('\u{11d90}', '\u{11d91}'),
+    ('𑶓', '𑶘'),
+    ('𑶠', '𑶩'),
+    ('𑻠', '𑻶'),
+    ('\u{11f00}', '𑼐'),
+    ('𑼒', '\u{11f3a}'),
+    ('𑼾', '\u{11f42}'),
+    ('𑽐', '𑽙'),
+    ('𑾰', '𑾰'),
+    ('𒀀', '𒎙'),
+    ('𒐀', '𒑮'),
+    ('𒒀', '𒕃'),
+    ('𒾐', '𒿰'),
+    ('𓀀', '𓐯'),
+    ('\u{13440}', '\u{13455}'),
+    ('𔐀', '𔙆'),
+    ('𖠀', '𖨸'),
+    ('𖩀', '𖩞'),
+    ('𖩠', '𖩩'),
+    ('𖩰', '𖪾'),
+    ('𖫀', '𖫉'),
+    ('𖫐', '𖫭'),
+    ('\u{16af0}', '\u{16af4}'),
+    ('𖬀', '\u{16b36}'),
+    ('𖭀', '𖭃'),
+    ('𖭐', '𖭙'),
+    ('𖭣', '𖭷'),
+    ('𖭽', '𖮏'),
+    ('𖹀', '𖹿'),
+    ('𖼀', '𖽊'),
+    ('\u{16f4f}', '𖾇'),
+    ('\u{16f8f}', '𖾟'),
+    ('𖿠', '𖿡'),
+    ('𖿣', '\u{16fe4}'),
+    ('𖿰', '𖿱'),
+    ('𗀀', '𘟷'),
+    ('𘠀', '𘳕'),
+    ('𘴀', '𘴈'),
+    ('𚿰', '𚿳'),
+    ('𚿵', '𚿻'),
+    ('𚿽', '𚿾'),
+    ('𛀀', '𛄢'),
+    ('𛄲', '𛄲'),
+    ('𛅐', '𛅒'),
+    ('𛅕', '𛅕'),
+    ('𛅤', '𛅧'),
+    ('𛅰', '𛋻'),
+    ('𛰀', '𛱪'),
+    ('𛱰', '𛱼'),
+    ('𛲀', '𛲈'),
+    ('𛲐', '𛲙'),
+    ('\u{1bc9d}', '\u{1bc9e}'),
+    ('\u{1cf00}', '\u{1cf2d}'),
+    ('\u{1cf30}', '\u{1cf46}'),
+    ('\u{1d165}', '\u{1d169}'),
+    ('𝅭', '\u{1d172}'),
+    ('\u{1d17b}', '\u{1d182}'),
+    ('\u{1d185}', '\u{1d18b}'),
+    ('\u{1d1aa}', '\u{1d1ad}'),
+    ('\u{1d242}', '\u{1d244}'),
+    ('𝐀', '𝑔'),
+    ('𝑖', '𝒜'),
+    ('𝒞', '𝒟'),
+    ('𝒢', '𝒢'),
+    ('𝒥', '𝒦'),
+    ('𝒩', '𝒬'),
+    ('𝒮', '𝒹'),
+    ('𝒻', '𝒻'),
+    ('𝒽', '𝓃'),
+    ('𝓅', '𝔅'),
+    ('𝔇', '𝔊'),
+    ('𝔍', '𝔔'),
+    ('𝔖', '𝔜'),
+    ('𝔞', '𝔹'),
+    ('𝔻', '𝔾'),
+    ('𝕀', '𝕄'),
+    ('𝕆', '𝕆'),
+    ('𝕊', '𝕐'),
+    ('𝕒', '𝚥'),
+    ('𝚨', '𝛀'),
+    ('𝛂', '𝛚'),
+    ('𝛜', '𝛺'),
+    ('𝛼', '𝜔'),
+    ('𝜖', '𝜴'),
+    ('𝜶', '𝝎'),
+    ('𝝐', '𝝮'),
+    ('𝝰', '𝞈'),
+    ('𝞊', '𝞨'),
+    ('𝞪', '𝟂'),
+    ('𝟄', '𝟋'),
+    ('𝟎', '𝟿'),
+    ('\u{1da00}', '\u{1da36}'),
+    ('\u{1da3b}', '\u{1da6c}'),
+    ('\u{1da75}', '\u{1da75}'),
+    ('\u{1da84}', '\u{1da84}'),
+    ('\u{1da9b}', '\u{1da9f}'),
+    ('\u{1daa1}', '\u{1daaf}'),
+    ('𝼀', '𝼞'),
+    ('𝼥', '𝼪'),
+    ('\u{1e000}', '\u{1e006}'),
+    ('\u{1e008}', '\u{1e018}'),
+    ('\u{1e01b}', '\u{1e021}'),
+    ('\u{1e023}', '\u{1e024}'),
+    ('\u{1e026}', '\u{1e02a}'),
+    ('𞀰', '𞁭'),
+    ('\u{1e08f}', '\u{1e08f}'),
+    ('𞄀', '𞄬'),
+    ('\u{1e130}', '𞄽'),
+    ('𞅀', '𞅉'),
+    ('𞅎', '𞅎'),
+    ('𞊐', '\u{1e2ae}'),
+    ('𞋀', '𞋹'),
+    ('𞓐', '𞓹'),
+    ('𞟠', '𞟦'),
+    ('𞟨', '𞟫'),
+    ('𞟭', '𞟮'),
+    ('𞟰', '𞟾'),
+    ('𞠀', '𞣄'),
+    ('\u{1e8d0}', '\u{1e8d6}'),
+    ('𞤀', '𞥋'),
+    ('𞥐', '𞥙'),
+    ('𞸀', '𞸃'),
+    ('𞸅', '𞸟'),
+    ('𞸡', '𞸢'),
+    ('𞸤', '𞸤'),
+    ('𞸧', '𞸧'),
+    ('𞸩', '𞸲'),
+    ('𞸴', '𞸷'),
+    ('𞸹', '𞸹'),
+    ('𞸻', '𞸻'),
+    ('𞹂', '𞹂'),
+    ('𞹇', '𞹇'),
+    ('𞹉', '𞹉'),
+    ('𞹋', '𞹋'),
+    ('𞹍', '𞹏'),
+    ('𞹑', '𞹒'),
+    ('𞹔', '𞹔'),
+    ('𞹗', '𞹗'),
+    ('𞹙', '𞹙'),
+    ('𞹛', '𞹛'),
+    ('𞹝', '𞹝'),
+    ('𞹟', '𞹟'),
+    ('𞹡', '𞹢'),
+    ('𞹤', '𞹤'),
+    ('𞹧', '𞹪'),
+    ('𞹬', '𞹲'),
+    ('𞹴', '𞹷'),
+    ('𞹹', '𞹼'),
+    ('𞹾', '𞹾'),
+    ('𞺀', '𞺉'),
+    ('𞺋', '𞺛'),
+    ('𞺡', '𞺣'),
+    ('𞺥', '𞺩'),
+    ('𞺫', '𞺻'),
+    ('🄰', '🅉'),
+    ('🅐', '🅩'),
+    ('🅰', '🆉'),
+    ('🯰', '🯹'),
+    ('𠀀', '𪛟'),
+    ('𪜀', '𫜹'),
+    ('𫝀', '𫠝'),
+    ('𫠠', '𬺡'),
+    ('𬺰', '𮯠'),
+    ('丽', '𪘀'),
+    ('𰀀', '𱍊'),
+    ('𱍐', '𲎯'),
+    ('\u{e0100}', '\u{e01ef}'),
+];
diff --git a/crates/regex-syntax/src/unicode_tables/property_bool.rs b/crates/regex-syntax/src/unicode_tables/property_bool.rs
new file mode 100644
index 0000000..a3e84b5
--- /dev/null
+++ b/crates/regex-syntax/src/unicode_tables/property_bool.rs
@@ -0,0 +1,11367 @@
+// DO NOT EDIT THIS FILE. IT WAS AUTOMATICALLY GENERATED BY:
+//
+//   ucd-generate property-bool ucd-15.0.0 --chars
+//
+// Unicode version: 15.0.0.
+//
+// ucd-generate 0.2.14 is available on crates.io.
+
+pub const BY_NAME: &'static [(&'static str, &'static [(char, char)])] = &[
+    ("ASCII_Hex_Digit", ASCII_HEX_DIGIT),
+    ("Alphabetic", ALPHABETIC),
+    ("Bidi_Control", BIDI_CONTROL),
+    ("Bidi_Mirrored", BIDI_MIRRORED),
+    ("Case_Ignorable", CASE_IGNORABLE),
+    ("Cased", CASED),
+    ("Changes_When_Casefolded", CHANGES_WHEN_CASEFOLDED),
+    ("Changes_When_Casemapped", CHANGES_WHEN_CASEMAPPED),
+    ("Changes_When_Lowercased", CHANGES_WHEN_LOWERCASED),
+    ("Changes_When_Titlecased", CHANGES_WHEN_TITLECASED),
+    ("Changes_When_Uppercased", CHANGES_WHEN_UPPERCASED),
+    ("Dash", DASH),
+    ("Default_Ignorable_Code_Point", DEFAULT_IGNORABLE_CODE_POINT),
+    ("Deprecated", DEPRECATED),
+    ("Diacritic", DIACRITIC),
+    ("Emoji", EMOJI),
+    ("Emoji_Component", EMOJI_COMPONENT),
+    ("Emoji_Modifier", EMOJI_MODIFIER),
+    ("Emoji_Modifier_Base", EMOJI_MODIFIER_BASE),
+    ("Emoji_Presentation", EMOJI_PRESENTATION),
+    ("Extended_Pictographic", EXTENDED_PICTOGRAPHIC),
+    ("Extender", EXTENDER),
+    ("Grapheme_Base", GRAPHEME_BASE),
+    ("Grapheme_Extend", GRAPHEME_EXTEND),
+    ("Grapheme_Link", GRAPHEME_LINK),
+    ("Hex_Digit", HEX_DIGIT),
+    ("Hyphen", HYPHEN),
+    ("IDS_Binary_Operator", IDS_BINARY_OPERATOR),
+    ("IDS_Trinary_Operator", IDS_TRINARY_OPERATOR),
+    ("ID_Continue", ID_CONTINUE),
+    ("ID_Start", ID_START),
+    ("Ideographic", IDEOGRAPHIC),
+    ("Join_Control", JOIN_CONTROL),
+    ("Logical_Order_Exception", LOGICAL_ORDER_EXCEPTION),
+    ("Lowercase", LOWERCASE),
+    ("Math", MATH),
+    ("Noncharacter_Code_Point", NONCHARACTER_CODE_POINT),
+    ("Other_Alphabetic", OTHER_ALPHABETIC),
+    ("Other_Default_Ignorable_Code_Point", OTHER_DEFAULT_IGNORABLE_CODE_POINT),
+    ("Other_Grapheme_Extend", OTHER_GRAPHEME_EXTEND),
+    ("Other_ID_Continue", OTHER_ID_CONTINUE),
+    ("Other_ID_Start", OTHER_ID_START),
+    ("Other_Lowercase", OTHER_LOWERCASE),
+    ("Other_Math", OTHER_MATH),
+    ("Other_Uppercase", OTHER_UPPERCASE),
+    ("Pattern_Syntax", PATTERN_SYNTAX),
+    ("Pattern_White_Space", PATTERN_WHITE_SPACE),
+    ("Prepended_Concatenation_Mark", PREPENDED_CONCATENATION_MARK),
+    ("Quotation_Mark", QUOTATION_MARK),
+    ("Radical", RADICAL),
+    ("Regional_Indicator", REGIONAL_INDICATOR),
+    ("Sentence_Terminal", SENTENCE_TERMINAL),
+    ("Soft_Dotted", SOFT_DOTTED),
+    ("Terminal_Punctuation", TERMINAL_PUNCTUATION),
+    ("Unified_Ideograph", UNIFIED_IDEOGRAPH),
+    ("Uppercase", UPPERCASE),
+    ("Variation_Selector", VARIATION_SELECTOR),
+    ("White_Space", WHITE_SPACE),
+    ("XID_Continue", XID_CONTINUE),
+    ("XID_Start", XID_START),
+];
+
+pub const ASCII_HEX_DIGIT: &'static [(char, char)] =
+    &[('0', '9'), ('A', 'F'), ('a', 'f')];
+
+pub const ALPHABETIC: &'static [(char, char)] = &[
+    ('A', 'Z'),
+    ('a', 'z'),
+    ('ª', 'ª'),
+    ('µ', 'µ'),
+    ('º', 'º'),
+    ('À', 'Ö'),
+    ('Ø', 'ö'),
+    ('ø', 'ˁ'),
+    ('ˆ', 'ˑ'),
+    ('ˠ', 'ˤ'),
+    ('ˬ', 'ˬ'),
+    ('ˮ', 'ˮ'),
+    ('\u{345}', '\u{345}'),
+    ('Ͱ', 'ʹ'),
+    ('Ͷ', 'ͷ'),
+    ('ͺ', 'ͽ'),
+    ('Ϳ', 'Ϳ'),
+    ('Ά', 'Ά'),
+    ('Έ', 'Ί'),
+    ('Ό', 'Ό'),
+    ('Ύ', 'Ρ'),
+    ('Σ', 'ϵ'),
+    ('Ϸ', 'ҁ'),
+    ('Ҋ', 'ԯ'),
+    ('Ա', 'Ֆ'),
+    ('ՙ', 'ՙ'),
+    ('ՠ', 'ֈ'),
+    ('\u{5b0}', '\u{5bd}'),
+    ('\u{5bf}', '\u{5bf}'),
+    ('\u{5c1}', '\u{5c2}'),
+    ('\u{5c4}', '\u{5c5}'),
+    ('\u{5c7}', '\u{5c7}'),
+    ('א', 'ת'),
+    ('ׯ', 'ײ'),
+    ('\u{610}', '\u{61a}'),
+    ('ؠ', '\u{657}'),
+    ('\u{659}', '\u{65f}'),
+    ('ٮ', 'ۓ'),
+    ('ە', '\u{6dc}'),
+    ('\u{6e1}', '\u{6e8}'),
+    ('\u{6ed}', 'ۯ'),
+    ('ۺ', 'ۼ'),
+    ('ۿ', 'ۿ'),
+    ('ܐ', '\u{73f}'),
+    ('ݍ', 'ޱ'),
+    ('ߊ', 'ߪ'),
+    ('ߴ', 'ߵ'),
+    ('ߺ', 'ߺ'),
+    ('ࠀ', '\u{817}'),
+    ('ࠚ', '\u{82c}'),
+    ('ࡀ', 'ࡘ'),
+    ('ࡠ', 'ࡪ'),
+    ('ࡰ', 'ࢇ'),
+    ('ࢉ', 'ࢎ'),
+    ('ࢠ', 'ࣉ'),
+    ('\u{8d4}', '\u{8df}'),
+    ('\u{8e3}', '\u{8e9}'),
+    ('\u{8f0}', 'ऻ'),
+    ('ऽ', 'ौ'),
+    ('ॎ', 'ॐ'),
+    ('\u{955}', '\u{963}'),
+    ('ॱ', 'ঃ'),
+    ('অ', 'ঌ'),
+    ('এ', 'ঐ'),
+    ('ও', 'ন'),
+    ('প', 'র'),
+    ('ল', 'ল'),
+    ('শ', 'হ'),
+    ('ঽ', '\u{9c4}'),
+    ('ে', 'ৈ'),
+    ('ো', 'ৌ'),
+    ('ৎ', 'ৎ'),
+    ('\u{9d7}', '\u{9d7}'),
+    ('ড়', 'ঢ়'),
+    ('য়', '\u{9e3}'),
+    ('ৰ', 'ৱ'),
+    ('ৼ', 'ৼ'),
+    ('\u{a01}', 'ਃ'),
+    ('ਅ', 'ਊ'),
+    ('ਏ', 'ਐ'),
+    ('ਓ', 'ਨ'),
+    ('ਪ', 'ਰ'),
+    ('ਲ', 'ਲ਼'),
+    ('ਵ', 'ਸ਼'),
+    ('ਸ', 'ਹ'),
+    ('ਾ', '\u{a42}'),
+    ('\u{a47}', '\u{a48}'),
+    ('\u{a4b}', '\u{a4c}'),
+    ('\u{a51}', '\u{a51}'),
+    ('ਖ਼', 'ੜ'),
+    ('ਫ਼', 'ਫ਼'),
+    ('\u{a70}', '\u{a75}'),
+    ('\u{a81}', 'ઃ'),
+    ('અ', 'ઍ'),
+    ('એ', 'ઑ'),
+    ('ઓ', 'ન'),
+    ('પ', 'ર'),
+    ('લ', 'ળ'),
+    ('વ', 'હ'),
+    ('ઽ', '\u{ac5}'),
+    ('\u{ac7}', 'ૉ'),
+    ('ો', 'ૌ'),
+    ('ૐ', 'ૐ'),
+    ('ૠ', '\u{ae3}'),
+    ('ૹ', '\u{afc}'),
+    ('\u{b01}', 'ଃ'),
+    ('ଅ', 'ଌ'),
+    ('ଏ', 'ଐ'),
+    ('ଓ', 'ନ'),
+    ('ପ', 'ର'),
+    ('ଲ', 'ଳ'),
+    ('ଵ', 'ହ'),
+    ('ଽ', '\u{b44}'),
+    ('େ', 'ୈ'),
+    ('ୋ', 'ୌ'),
+    ('\u{b56}', '\u{b57}'),
+    ('ଡ଼', 'ଢ଼'),
+    ('ୟ', '\u{b63}'),
+    ('ୱ', 'ୱ'),
+    ('\u{b82}', 'ஃ'),
+    ('அ', 'ஊ'),
+    ('எ', 'ஐ'),
+    ('ஒ', 'க'),
+    ('ங', 'ச'),
+    ('ஜ', 'ஜ'),
+    ('ஞ', 'ட'),
+    ('ண', 'த'),
+    ('ந', 'ப'),
+    ('ம', 'ஹ'),
+    ('\u{bbe}', 'ூ'),
+    ('ெ', 'ை'),
+    ('ொ', 'ௌ'),
+    ('ௐ', 'ௐ'),
+    ('\u{bd7}', '\u{bd7}'),
+    ('\u{c00}', 'ఌ'),
+    ('ఎ', 'ఐ'),
+    ('ఒ', 'న'),
+    ('ప', 'హ'),
+    ('ఽ', 'ౄ'),
+    ('\u{c46}', '\u{c48}'),
+    ('\u{c4a}', '\u{c4c}'),
+    ('\u{c55}', '\u{c56}'),
+    ('ౘ', 'ౚ'),
+    ('ౝ', 'ౝ'),
+    ('ౠ', '\u{c63}'),
+    ('ಀ', 'ಃ'),
+    ('ಅ', 'ಌ'),
+    ('ಎ', 'ಐ'),
+    ('ಒ', 'ನ'),
+    ('ಪ', 'ಳ'),
+    ('ವ', 'ಹ'),
+    ('ಽ', 'ೄ'),
+    ('\u{cc6}', 'ೈ'),
+    ('ೊ', '\u{ccc}'),
+    ('\u{cd5}', '\u{cd6}'),
+    ('ೝ', 'ೞ'),
+    ('ೠ', '\u{ce3}'),
+    ('ೱ', 'ೳ'),
+    ('\u{d00}', 'ഌ'),
+    ('എ', 'ഐ'),
+    ('ഒ', 'ഺ'),
+    ('ഽ', '\u{d44}'),
+    ('െ', 'ൈ'),
+    ('ൊ', 'ൌ'),
+    ('ൎ', 'ൎ'),
+    ('ൔ', '\u{d57}'),
+    ('ൟ', '\u{d63}'),
+    ('ൺ', 'ൿ'),
+    ('\u{d81}', 'ඃ'),
+    ('අ', 'ඖ'),
+    ('ක', 'න'),
+    ('ඳ', 'ර'),
+    ('ල', 'ල'),
+    ('ව', 'ෆ'),
+    ('\u{dcf}', '\u{dd4}'),
+    ('\u{dd6}', '\u{dd6}'),
+    ('ෘ', '\u{ddf}'),
+    ('ෲ', 'ෳ'),
+    ('ก', '\u{e3a}'),
+    ('เ', 'ๆ'),
+    ('\u{e4d}', '\u{e4d}'),
+    ('ກ', 'ຂ'),
+    ('ຄ', 'ຄ'),
+    ('ຆ', 'ຊ'),
+    ('ຌ', 'ຣ'),
+    ('ລ', 'ລ'),
+    ('ວ', '\u{eb9}'),
+    ('\u{ebb}', 'ຽ'),
+    ('ເ', 'ໄ'),
+    ('ໆ', 'ໆ'),
+    ('\u{ecd}', '\u{ecd}'),
+    ('ໜ', 'ໟ'),
+    ('ༀ', 'ༀ'),
+    ('ཀ', 'ཇ'),
+    ('ཉ', 'ཬ'),
+    ('\u{f71}', '\u{f83}'),
+    ('ྈ', '\u{f97}'),
+    ('\u{f99}', '\u{fbc}'),
+    ('က', '\u{1036}'),
+    ('း', 'း'),
+    ('ျ', 'ဿ'),
+    ('ၐ', 'ႏ'),
+    ('ႚ', '\u{109d}'),
+    ('Ⴀ', 'Ⴥ'),
+    ('Ⴧ', 'Ⴧ'),
+    ('Ⴭ', 'Ⴭ'),
+    ('ა', 'ჺ'),
+    ('ჼ', 'ቈ'),
+    ('ቊ', 'ቍ'),
+    ('ቐ', 'ቖ'),
+    ('ቘ', 'ቘ'),
+    ('ቚ', 'ቝ'),
+    ('በ', 'ኈ'),
+    ('ኊ', 'ኍ'),
+    ('ነ', 'ኰ'),
+    ('ኲ', 'ኵ'),
+    ('ኸ', 'ኾ'),
+    ('ዀ', 'ዀ'),
+    ('ዂ', 'ዅ'),
+    ('ወ', 'ዖ'),
+    ('ዘ', 'ጐ'),
+    ('ጒ', 'ጕ'),
+    ('ጘ', 'ፚ'),
+    ('ᎀ', 'ᎏ'),
+    ('Ꭰ', 'Ᏽ'),
+    ('ᏸ', 'ᏽ'),
+    ('ᐁ', 'ᙬ'),
+    ('ᙯ', 'ᙿ'),
+    ('ᚁ', 'ᚚ'),
+    ('ᚠ', 'ᛪ'),
+    ('ᛮ', 'ᛸ'),
+    ('ᜀ', '\u{1713}'),
+    ('ᜟ', '\u{1733}'),
+    ('ᝀ', '\u{1753}'),
+    ('ᝠ', 'ᝬ'),
+    ('ᝮ', 'ᝰ'),
+    ('\u{1772}', '\u{1773}'),
+    ('ក', 'ឳ'),
+    ('ា', 'ៈ'),
+    ('ៗ', 'ៗ'),
+    ('ៜ', 'ៜ'),
+    ('ᠠ', 'ᡸ'),
+    ('ᢀ', 'ᢪ'),
+    ('ᢰ', 'ᣵ'),
+    ('ᤀ', 'ᤞ'),
+    ('\u{1920}', 'ᤫ'),
+    ('ᤰ', 'ᤸ'),
+    ('ᥐ', 'ᥭ'),
+    ('ᥰ', 'ᥴ'),
+    ('ᦀ', 'ᦫ'),
+    ('ᦰ', 'ᧉ'),
+    ('ᨀ', '\u{1a1b}'),
+    ('ᨠ', '\u{1a5e}'),
+    ('ᩡ', '\u{1a74}'),
+    ('ᪧ', 'ᪧ'),
+    ('\u{1abf}', '\u{1ac0}'),
+    ('\u{1acc}', '\u{1ace}'),
+    ('\u{1b00}', 'ᬳ'),
+    ('\u{1b35}', 'ᭃ'),
+    ('ᭅ', 'ᭌ'),
+    ('\u{1b80}', '\u{1ba9}'),
+    ('\u{1bac}', 'ᮯ'),
+    ('ᮺ', 'ᯥ'),
+    ('ᯧ', '\u{1bf1}'),
+    ('ᰀ', '\u{1c36}'),
+    ('ᱍ', 'ᱏ'),
+    ('ᱚ', 'ᱽ'),
+    ('ᲀ', 'ᲈ'),
+    ('Ა', 'Ჺ'),
+    ('Ჽ', 'Ჿ'),
+    ('ᳩ', 'ᳬ'),
+    ('ᳮ', 'ᳳ'),
+    ('ᳵ', 'ᳶ'),
+    ('ᳺ', 'ᳺ'),
+    ('ᴀ', 'ᶿ'),
+    ('\u{1de7}', '\u{1df4}'),
+    ('Ḁ', 'ἕ'),
+    ('Ἐ', 'Ἕ'),
+    ('ἠ', 'ὅ'),
+    ('Ὀ', 'Ὅ'),
+    ('ὐ', 'ὗ'),
+    ('Ὑ', 'Ὑ'),
+    ('Ὓ', 'Ὓ'),
+    ('Ὕ', 'Ὕ'),
+    ('Ὗ', 'ώ'),
+    ('ᾀ', 'ᾴ'),
+    ('ᾶ', 'ᾼ'),
+    ('ι', 'ι'),
+    ('ῂ', 'ῄ'),
+    ('ῆ', 'ῌ'),
+    ('ῐ', 'ΐ'),
+    ('ῖ', 'Ί'),
+    ('ῠ', 'Ῥ'),
+    ('ῲ', 'ῴ'),
+    ('ῶ', 'ῼ'),
+    ('ⁱ', 'ⁱ'),
+    ('ⁿ', 'ⁿ'),
+    ('ₐ', 'ₜ'),
+    ('ℂ', 'ℂ'),
+    ('ℇ', 'ℇ'),
+    ('ℊ', 'ℓ'),
+    ('ℕ', 'ℕ'),
+    ('ℙ', 'ℝ'),
+    ('ℤ', 'ℤ'),
+    ('Ω', 'Ω'),
+    ('ℨ', 'ℨ'),
+    ('K', 'ℭ'),
+    ('ℯ', 'ℹ'),
+    ('ℼ', 'ℿ'),
+    ('ⅅ', 'ⅉ'),
+    ('ⅎ', 'ⅎ'),
+    ('Ⅰ', 'ↈ'),
+    ('Ⓐ', 'ⓩ'),
+    ('Ⰰ', 'ⳤ'),
+    ('Ⳬ', 'ⳮ'),
+    ('Ⳳ', 'ⳳ'),
+    ('ⴀ', 'ⴥ'),
+    ('ⴧ', 'ⴧ'),
+    ('ⴭ', 'ⴭ'),
+    ('ⴰ', 'ⵧ'),
+    ('ⵯ', 'ⵯ'),
+    ('ⶀ', 'ⶖ'),
+    ('ⶠ', 'ⶦ'),
+    ('ⶨ', 'ⶮ'),
+    ('ⶰ', 'ⶶ'),
+    ('ⶸ', 'ⶾ'),
+    ('ⷀ', 'ⷆ'),
+    ('ⷈ', 'ⷎ'),
+    ('ⷐ', 'ⷖ'),
+    ('ⷘ', 'ⷞ'),
+    ('\u{2de0}', '\u{2dff}'),
+    ('ⸯ', 'ⸯ'),
+    ('々', '〇'),
+    ('〡', '〩'),
+    ('〱', '〵'),
+    ('〸', '〼'),
+    ('ぁ', 'ゖ'),
+    ('ゝ', 'ゟ'),
+    ('ァ', 'ヺ'),
+    ('ー', 'ヿ'),
+    ('ㄅ', 'ㄯ'),
+    ('ㄱ', 'ㆎ'),
+    ('ㆠ', 'ㆿ'),
+    ('ㇰ', 'ㇿ'),
+    ('㐀', '䶿'),
+    ('一', 'ꒌ'),
+    ('ꓐ', 'ꓽ'),
+    ('ꔀ', 'ꘌ'),
+    ('ꘐ', 'ꘟ'),
+    ('ꘪ', 'ꘫ'),
+    ('Ꙁ', 'ꙮ'),
+    ('\u{a674}', '\u{a67b}'),
+    ('ꙿ', 'ꛯ'),
+    ('ꜗ', 'ꜟ'),
+    ('Ꜣ', 'ꞈ'),
+    ('Ꞌ', 'ꟊ'),
+    ('Ꟑ', 'ꟑ'),
+    ('ꟓ', 'ꟓ'),
+    ('ꟕ', 'ꟙ'),
+    ('ꟲ', 'ꠅ'),
+    ('ꠇ', 'ꠧ'),
+    ('ꡀ', 'ꡳ'),
+    ('ꢀ', 'ꣃ'),
+    ('\u{a8c5}', '\u{a8c5}'),
+    ('ꣲ', 'ꣷ'),
+    ('ꣻ', 'ꣻ'),
+    ('ꣽ', '\u{a8ff}'),
+    ('ꤊ', '\u{a92a}'),
+    ('ꤰ', 'ꥒ'),
+    ('ꥠ', 'ꥼ'),
+    ('\u{a980}', 'ꦲ'),
+    ('ꦴ', 'ꦿ'),
+    ('ꧏ', 'ꧏ'),
+    ('ꧠ', 'ꧯ'),
+    ('ꧺ', 'ꧾ'),
+    ('ꨀ', '\u{aa36}'),
+    ('ꩀ', 'ꩍ'),
+    ('ꩠ', 'ꩶ'),
+    ('ꩺ', '\u{aabe}'),
+    ('ꫀ', 'ꫀ'),
+    ('ꫂ', 'ꫂ'),
+    ('ꫛ', 'ꫝ'),
+    ('ꫠ', 'ꫯ'),
+    ('ꫲ', 'ꫵ'),
+    ('ꬁ', 'ꬆ'),
+    ('ꬉ', 'ꬎ'),
+    ('ꬑ', 'ꬖ'),
+    ('ꬠ', 'ꬦ'),
+    ('ꬨ', 'ꬮ'),
+    ('ꬰ', 'ꭚ'),
+    ('ꭜ', 'ꭩ'),
+    ('ꭰ', 'ꯪ'),
+    ('가', '힣'),
+    ('ힰ', 'ퟆ'),
+    ('ퟋ', 'ퟻ'),
+    ('豈', '舘'),
+    ('並', '龎'),
+    ('ﬀ', 'ﬆ'),
+    ('ﬓ', 'ﬗ'),
+    ('יִ', 'ﬨ'),
+    ('שׁ', 'זּ'),
+    ('טּ', 'לּ'),
+    ('מּ', 'מּ'),
+    ('נּ', 'סּ'),
+    ('ףּ', 'פּ'),
+    ('צּ', 'ﮱ'),
+    ('ﯓ', 'ﴽ'),
+    ('ﵐ', 'ﶏ'),
+    ('ﶒ', 'ﷇ'),
+    ('ﷰ', 'ﷻ'),
+    ('ﹰ', 'ﹴ'),
+    ('ﹶ', 'ﻼ'),
+    ('Ａ', 'Ｚ'),
+    ('ａ', 'ｚ'),
+    ('ｦ', 'ﾾ'),
+    ('ￂ', 'ￇ'),
+    ('ￊ', 'ￏ'),
+    ('ￒ', 'ￗ'),
+    ('ￚ', 'ￜ'),
+    ('𐀀', '𐀋'),
+    ('𐀍', '𐀦'),
+    ('𐀨', '𐀺'),
+    ('𐀼', '𐀽'),
+    ('𐀿', '𐁍'),
+    ('𐁐', '𐁝'),
+    ('𐂀', '𐃺'),
+    ('𐅀', '𐅴'),
+    ('𐊀', '𐊜'),
+    ('𐊠', '𐋐'),
+    ('𐌀', '𐌟'),
+    ('𐌭', '𐍊'),
+    ('𐍐', '\u{1037a}'),
+    ('𐎀', '𐎝'),
+    ('𐎠', '𐏃'),
+    ('𐏈', '𐏏'),
+    ('𐏑', '𐏕'),
+    ('𐐀', '𐒝'),
+    ('𐒰', '𐓓'),
+    ('𐓘', '𐓻'),
+    ('𐔀', '𐔧'),
+    ('𐔰', '𐕣'),
+    ('𐕰', '𐕺'),
+    ('𐕼', '𐖊'),
+    ('𐖌', '𐖒'),
+    ('𐖔', '𐖕'),
+    ('𐖗', '𐖡'),
+    ('𐖣', '𐖱'),
+    ('𐖳', '𐖹'),
+    ('𐖻', '𐖼'),
+    ('𐘀', '𐜶'),
+    ('𐝀', '𐝕'),
+    ('𐝠', '𐝧'),
+    ('𐞀', '𐞅'),
+    ('𐞇', '𐞰'),
+    ('𐞲', '𐞺'),
+    ('𐠀', '𐠅'),
+    ('𐠈', '𐠈'),
+    ('𐠊', '𐠵'),
+    ('𐠷', '𐠸'),
+    ('𐠼', '𐠼'),
+    ('𐠿', '𐡕'),
+    ('𐡠', '𐡶'),
+    ('𐢀', '𐢞'),
+    ('𐣠', '𐣲'),
+    ('𐣴', '𐣵'),
+    ('𐤀', '𐤕'),
+    ('𐤠', '𐤹'),
+    ('𐦀', '𐦷'),
+    ('𐦾', '𐦿'),
+    ('𐨀', '\u{10a03}'),
+    ('\u{10a05}', '\u{10a06}'),
+    ('\u{10a0c}', '𐨓'),
+    ('𐨕', '𐨗'),
+    ('𐨙', '𐨵'),
+    ('𐩠', '𐩼'),
+    ('𐪀', '𐪜'),
+    ('𐫀', '𐫇'),
+    ('𐫉', '𐫤'),
+    ('𐬀', '𐬵'),
+    ('𐭀', '𐭕'),
+    ('𐭠', '𐭲'),
+    ('𐮀', '𐮑'),
+    ('𐰀', '𐱈'),
+    ('𐲀', '𐲲'),
+    ('𐳀', '𐳲'),
+    ('𐴀', '\u{10d27}'),
+    ('𐺀', '𐺩'),
+    ('\u{10eab}', '\u{10eac}'),
+    ('𐺰', '𐺱'),
+    ('𐼀', '𐼜'),
+    ('𐼧', '𐼧'),
+    ('𐼰', '𐽅'),
+    ('𐽰', '𐾁'),
+    ('𐾰', '𐿄'),
+    ('𐿠', '𐿶'),
+    ('𑀀', '\u{11045}'),
+    ('𑁱', '𑁵'),
+    ('\u{11080}', '𑂸'),
+    ('\u{110c2}', '\u{110c2}'),
+    ('𑃐', '𑃨'),
+    ('\u{11100}', '\u{11132}'),
+    ('𑅄', '𑅇'),
+    ('𑅐', '𑅲'),
+    ('𑅶', '𑅶'),
+    ('\u{11180}', '𑆿'),
+    ('𑇁', '𑇄'),
+    ('𑇎', '\u{111cf}'),
+    ('𑇚', '𑇚'),
+    ('𑇜', '𑇜'),
+    ('𑈀', '𑈑'),
+    ('𑈓', '\u{11234}'),
+    ('\u{11237}', '\u{11237}'),
+    ('\u{1123e}', '\u{11241}'),
+    ('𑊀', '𑊆'),
+    ('𑊈', '𑊈'),
+    ('𑊊', '𑊍'),
+    ('𑊏', '𑊝'),
+    ('𑊟', '𑊨'),
+    ('𑊰', '\u{112e8}'),
+    ('\u{11300}', '𑌃'),
+    ('𑌅', '𑌌'),
+    ('𑌏', '𑌐'),
+    ('𑌓', '𑌨'),
+    ('𑌪', '𑌰'),
+    ('𑌲', '𑌳'),
+    ('𑌵', '𑌹'),
+    ('𑌽', '𑍄'),
+    ('𑍇', '𑍈'),
+    ('𑍋', '𑍌'),
+    ('𑍐', '𑍐'),
+    ('\u{11357}', '\u{11357}'),
+    ('𑍝', '𑍣'),
+    ('𑐀', '𑑁'),
+    ('\u{11443}', '𑑅'),
+    ('𑑇', '𑑊'),
+    ('𑑟', '𑑡'),
+    ('𑒀', '𑓁'),
+    ('𑓄', '𑓅'),
+    ('𑓇', '𑓇'),
+    ('𑖀', '\u{115b5}'),
+    ('𑖸', '𑖾'),
+    ('𑗘', '\u{115dd}'),
+    ('𑘀', '𑘾'),
+    ('\u{11640}', '\u{11640}'),
+    ('𑙄', '𑙄'),
+    ('𑚀', '\u{116b5}'),
+    ('𑚸', '𑚸'),
+    ('𑜀', '𑜚'),
+    ('\u{1171d}', '\u{1172a}'),
+    ('𑝀', '𑝆'),
+    ('𑠀', '𑠸'),
+    ('𑢠', '𑣟'),
+    ('𑣿', '𑤆'),
+    ('𑤉', '𑤉'),
+    ('𑤌', '𑤓'),
+    ('𑤕', '𑤖'),
+    ('𑤘', '𑤵'),
+    ('𑤷', '𑤸'),
+    ('\u{1193b}', '\u{1193c}'),
+    ('𑤿', '𑥂'),
+    ('𑦠', '𑦧'),
+    ('𑦪', '\u{119d7}'),
+    ('\u{119da}', '𑧟'),
+    ('𑧡', '𑧡'),
+    ('𑧣', '𑧤'),
+    ('𑨀', '𑨲'),
+    ('\u{11a35}', '\u{11a3e}'),
+    ('𑩐', '𑪗'),
+    ('𑪝', '𑪝'),
+    ('𑪰', '𑫸'),
+    ('𑰀', '𑰈'),
+    ('𑰊', '\u{11c36}'),
+    ('\u{11c38}', '𑰾'),
+    ('𑱀', '𑱀'),
+    ('𑱲', '𑲏'),
+    ('\u{11c92}', '\u{11ca7}'),
+    ('𑲩', '\u{11cb6}'),
+    ('𑴀', '𑴆'),
+    ('𑴈', '𑴉'),
+    ('𑴋', '\u{11d36}'),
+    ('\u{11d3a}', '\u{11d3a}'),
+    ('\u{11d3c}', '\u{11d3d}'),
+    ('\u{11d3f}', '\u{11d41}'),
+    ('\u{11d43}', '\u{11d43}'),
+    ('𑵆', '\u{11d47}'),
+    ('𑵠', '𑵥'),
+    ('𑵧', '𑵨'),
+    ('𑵪', '𑶎'),
+    ('\u{11d90}', '\u{11d91}'),
+    ('𑶓', '𑶖'),
+    ('𑶘', '𑶘'),
+    ('𑻠', '𑻶'),
+    ('\u{11f00}', '𑼐'),
+    ('𑼒', '\u{11f3a}'),
+    ('𑼾', '\u{11f40}'),
+    ('𑾰', '𑾰'),
+    ('𒀀', '𒎙'),
+    ('𒐀', '𒑮'),
+    ('𒒀', '𒕃'),
+    ('𒾐', '𒿰'),
+    ('𓀀', '𓐯'),
+    ('𓑁', '𓑆'),
+    ('𔐀', '𔙆'),
+    ('𖠀', '𖨸'),
+    ('𖩀', '𖩞'),
+    ('𖩰', '𖪾'),
+    ('𖫐', '𖫭'),
+    ('𖬀', '𖬯'),
+    ('𖭀', '𖭃'),
+    ('𖭣', '𖭷'),
+    ('𖭽', '𖮏'),
+    ('𖹀', '𖹿'),
+    ('𖼀', '𖽊'),
+    ('\u{16f4f}', '𖾇'),
+    ('\u{16f8f}', '𖾟'),
+    ('𖿠', '𖿡'),
+    ('𖿣', '𖿣'),
+    ('𖿰', '𖿱'),
+    ('𗀀', '𘟷'),
+    ('𘠀', '𘳕'),
+    ('𘴀', '𘴈'),
+    ('𚿰', '𚿳'),
+    ('𚿵', '𚿻'),
+    ('𚿽', '𚿾'),
+    ('𛀀', '𛄢'),
+    ('𛄲', '𛄲'),
+    ('𛅐', '𛅒'),
+    ('𛅕', '𛅕'),
+    ('𛅤', '𛅧'),
+    ('𛅰', '𛋻'),
+    ('𛰀', '𛱪'),
+    ('𛱰', '𛱼'),
+    ('𛲀', '𛲈'),
+    ('𛲐', '𛲙'),
+    ('\u{1bc9e}', '\u{1bc9e}'),
+    ('𝐀', '𝑔'),
+    ('𝑖', '𝒜'),
+    ('𝒞', '𝒟'),
+    ('𝒢', '𝒢'),
+    ('𝒥', '𝒦'),
+    ('𝒩', '𝒬'),
+    ('𝒮', '𝒹'),
+    ('𝒻', '𝒻'),
+    ('𝒽', '𝓃'),
+    ('𝓅', '𝔅'),
+    ('𝔇', '𝔊'),
+    ('𝔍', '𝔔'),
+    ('𝔖', '𝔜'),
+    ('𝔞', '𝔹'),
+    ('𝔻', '𝔾'),
+    ('𝕀', '𝕄'),
+    ('𝕆', '𝕆'),
+    ('𝕊', '𝕐'),
+    ('𝕒', '𝚥'),
+    ('𝚨', '𝛀'),
+    ('𝛂', '𝛚'),
+    ('𝛜', '𝛺'),
+    ('𝛼', '𝜔'),
+    ('𝜖', '𝜴'),
+    ('𝜶', '𝝎'),
+    ('𝝐', '𝝮'),
+    ('𝝰', '𝞈'),
+    ('𝞊', '𝞨'),
+    ('𝞪', '𝟂'),
+    ('𝟄', '𝟋'),
+    ('𝼀', '𝼞'),
+    ('𝼥', '𝼪'),
+    ('\u{1e000}', '\u{1e006}'),
+    ('\u{1e008}', '\u{1e018}'),
+    ('\u{1e01b}', '\u{1e021}'),
+    ('\u{1e023}', '\u{1e024}'),
+    ('\u{1e026}', '\u{1e02a}'),
+    ('𞀰', '𞁭'),
+    ('\u{1e08f}', '\u{1e08f}'),
+    ('𞄀', '𞄬'),
+    ('𞄷', '𞄽'),
+    ('𞅎', '𞅎'),
+    ('𞊐', '𞊭'),
+    ('𞋀', '𞋫'),
+    ('𞓐', '𞓫'),
+    ('𞟠', '𞟦'),
+    ('𞟨', '𞟫'),
+    ('𞟭', '𞟮'),
+    ('𞟰', '𞟾'),
+    ('𞠀', '𞣄'),
+    ('𞤀', '𞥃'),
+    ('\u{1e947}', '\u{1e947}'),
+    ('𞥋', '𞥋'),
+    ('𞸀', '𞸃'),
+    ('𞸅', '𞸟'),
+    ('𞸡', '𞸢'),
+    ('𞸤', '𞸤'),
+    ('𞸧', '𞸧'),
+    ('𞸩', '𞸲'),
+    ('𞸴', '𞸷'),
+    ('𞸹', '𞸹'),
+    ('𞸻', '𞸻'),
+    ('𞹂', '𞹂'),
+    ('𞹇', '𞹇'),
+    ('𞹉', '𞹉'),
+    ('𞹋', '𞹋'),
+    ('𞹍', '𞹏'),
+    ('𞹑', '𞹒'),
+    ('𞹔', '𞹔'),
+    ('𞹗', '𞹗'),
+    ('𞹙', '𞹙'),
+    ('𞹛', '𞹛'),
+    ('𞹝', '𞹝'),
+    ('𞹟', '𞹟'),
+    ('𞹡', '𞹢'),
+    ('𞹤', '𞹤'),
+    ('𞹧', '𞹪'),
+    ('𞹬', '𞹲'),
+    ('𞹴', '𞹷'),
+    ('𞹹', '𞹼'),
+    ('𞹾', '𞹾'),
+    ('𞺀', '𞺉'),
+    ('𞺋', '𞺛'),
+    ('𞺡', '𞺣'),
+    ('𞺥', '𞺩'),
+    ('𞺫', '𞺻'),
+    ('🄰', '🅉'),
+    ('🅐', '🅩'),
+    ('🅰', '🆉'),
+    ('𠀀', '𪛟'),
+    ('𪜀', '𫜹'),
+    ('𫝀', '𫠝'),
+    ('𫠠', '𬺡'),
+    ('𬺰', '𮯠'),
+    ('丽', '𪘀'),
+    ('𰀀', '𱍊'),
+    ('𱍐', '𲎯'),
+];
+
+pub const BIDI_CONTROL: &'static [(char, char)] = &[
+    ('\u{61c}', '\u{61c}'),
+    ('\u{200e}', '\u{200f}'),
+    ('\u{202a}', '\u{202e}'),
+    ('\u{2066}', '\u{2069}'),
+];
+
+pub const BIDI_MIRRORED: &'static [(char, char)] = &[
+    ('(', ')'),
+    ('<', '<'),
+    ('>', '>'),
+    ('[', '['),
+    (']', ']'),
+    ('{', '{'),
+    ('}', '}'),
+    ('«', '«'),
+    ('»', '»'),
+    ('༺', '༽'),
+    ('᚛', '᚜'),
+    ('‹', '›'),
+    ('⁅', '⁆'),
+    ('⁽', '⁾'),
+    ('₍', '₎'),
+    ('⅀', '⅀'),
+    ('∁', '∄'),
+    ('∈', '∍'),
+    ('∑', '∑'),
+    ('∕', '∖'),
+    ('√', '∝'),
+    ('∟', '∢'),
+    ('∤', '∤'),
+    ('∦', '∦'),
+    ('∫', '∳'),
+    ('∹', '∹'),
+    ('∻', '≌'),
+    ('≒', '≕'),
+    ('≟', '≠'),
+    ('≢', '≢'),
+    ('≤', '≫'),
+    ('≮', '⊌'),
+    ('⊏', '⊒'),
+    ('⊘', '⊘'),
+    ('⊢', '⊣'),
+    ('⊦', '⊸'),
+    ('⊾', '⊿'),
+    ('⋉', '⋍'),
+    ('⋐', '⋑'),
+    ('⋖', '⋭'),
+    ('⋰', '⋿'),
+    ('⌈', '⌋'),
+    ('⌠', '⌡'),
+    ('〈', '〉'),
+    ('❨', '❵'),
+    ('⟀', '⟀'),
+    ('⟃', '⟆'),
+    ('⟈', '⟉'),
+    ('⟋', '⟍'),
+    ('⟓', '⟖'),
+    ('⟜', '⟞'),
+    ('⟢', '⟯'),
+    ('⦃', '⦘'),
+    ('⦛', '⦠'),
+    ('⦢', '⦯'),
+    ('⦸', '⦸'),
+    ('⧀', '⧅'),
+    ('⧉', '⧉'),
+    ('⧎', '⧒'),
+    ('⧔', '⧕'),
+    ('⧘', '⧜'),
+    ('⧡', '⧡'),
+    ('⧣', '⧥'),
+    ('⧨', '⧩'),
+    ('⧴', '⧹'),
+    ('⧼', '⧽'),
+    ('⨊', '⨜'),
+    ('⨞', '⨡'),
+    ('⨤', '⨤'),
+    ('⨦', '⨦'),
+    ('⨩', '⨩'),
+    ('⨫', '⨮'),
+    ('⨴', '⨵'),
+    ('⨼', '⨾'),
+    ('⩗', '⩘'),
+    ('⩤', '⩥'),
+    ('⩪', '⩭'),
+    ('⩯', '⩰'),
+    ('⩳', '⩴'),
+    ('⩹', '⪣'),
+    ('⪦', '⪭'),
+    ('⪯', '⫖'),
+    ('⫝̸', '⫝̸'),
+    ('⫞', '⫞'),
+    ('⫢', '⫦'),
+    ('⫬', '⫮'),
+    ('⫳', '⫳'),
+    ('⫷', '⫻'),
+    ('⫽', '⫽'),
+    ('⯾', '⯾'),
+    ('⸂', '⸅'),
+    ('⸉', '⸊'),
+    ('⸌', '⸍'),
+    ('⸜', '⸝'),
+    ('⸠', '⸩'),
+    ('⹕', '⹜'),
+    ('〈', '】'),
+    ('〔', '〛'),
+    ('﹙', '﹞'),
+    ('﹤', '﹥'),
+    ('（', '）'),
+    ('＜', '＜'),
+    ('＞', '＞'),
+    ('［', '［'),
+    ('］', '］'),
+    ('｛', '｛'),
+    ('｝', '｝'),
+    ('｟', '｠'),
+    ('｢', '｣'),
+    ('𝛛', '𝛛'),
+    ('𝜕', '𝜕'),
+    ('𝝏', '𝝏'),
+    ('𝞉', '𝞉'),
+    ('𝟃', '𝟃'),
+];
+
+pub const CASE_IGNORABLE: &'static [(char, char)] = &[
+    ('\'', '\''),
+    ('.', '.'),
+    (':', ':'),
+    ('^', '^'),
+    ('`', '`'),
+    ('¨', '¨'),
+    ('\u{ad}', '\u{ad}'),
+    ('¯', '¯'),
+    ('´', '´'),
+    ('·', '¸'),
+    ('ʰ', '\u{36f}'),
+    ('ʹ', '͵'),
+    ('ͺ', 'ͺ'),
+    ('΄', '΅'),
+    ('·', '·'),
+    ('\u{483}', '\u{489}'),
+    ('ՙ', 'ՙ'),
+    ('՟', '՟'),
+    ('\u{591}', '\u{5bd}'),
+    ('\u{5bf}', '\u{5bf}'),
+    ('\u{5c1}', '\u{5c2}'),
+    ('\u{5c4}', '\u{5c5}'),
+    ('\u{5c7}', '\u{5c7}'),
+    ('״', '״'),
+    ('\u{600}', '\u{605}'),
+    ('\u{610}', '\u{61a}'),
+    ('\u{61c}', '\u{61c}'),
+    ('ـ', 'ـ'),
+    ('\u{64b}', '\u{65f}'),
+    ('\u{670}', '\u{670}'),
+    ('\u{6d6}', '\u{6dd}'),
+    ('\u{6df}', '\u{6e8}'),
+    ('\u{6ea}', '\u{6ed}'),
+    ('\u{70f}', '\u{70f}'),
+    ('\u{711}', '\u{711}'),
+    ('\u{730}', '\u{74a}'),
+    ('\u{7a6}', '\u{7b0}'),
+    ('\u{7eb}', 'ߵ'),
+    ('ߺ', 'ߺ'),
+    ('\u{7fd}', '\u{7fd}'),
+    ('\u{816}', '\u{82d}'),
+    ('\u{859}', '\u{85b}'),
+    ('࢈', '࢈'),
+    ('\u{890}', '\u{891}'),
+    ('\u{898}', '\u{89f}'),
+    ('ࣉ', '\u{902}'),
+    ('\u{93a}', '\u{93a}'),
+    ('\u{93c}', '\u{93c}'),
+    ('\u{941}', '\u{948}'),
+    ('\u{94d}', '\u{94d}'),
+    ('\u{951}', '\u{957}'),
+    ('\u{962}', '\u{963}'),
+    ('ॱ', 'ॱ'),
+    ('\u{981}', '\u{981}'),
+    ('\u{9bc}', '\u{9bc}'),
+    ('\u{9c1}', '\u{9c4}'),
+    ('\u{9cd}', '\u{9cd}'),
+    ('\u{9e2}', '\u{9e3}'),
+    ('\u{9fe}', '\u{9fe}'),
+    ('\u{a01}', '\u{a02}'),
+    ('\u{a3c}', '\u{a3c}'),
+    ('\u{a41}', '\u{a42}'),
+    ('\u{a47}', '\u{a48}'),
+    ('\u{a4b}', '\u{a4d}'),
+    ('\u{a51}', '\u{a51}'),
+    ('\u{a70}', '\u{a71}'),
+    ('\u{a75}', '\u{a75}'),
+    ('\u{a81}', '\u{a82}'),
+    ('\u{abc}', '\u{abc}'),
+    ('\u{ac1}', '\u{ac5}'),
+    ('\u{ac7}', '\u{ac8}'),
+    ('\u{acd}', '\u{acd}'),
+    ('\u{ae2}', '\u{ae3}'),
+    ('\u{afa}', '\u{aff}'),
+    ('\u{b01}', '\u{b01}'),
+    ('\u{b3c}', '\u{b3c}'),
+    ('\u{b3f}', '\u{b3f}'),
+    ('\u{b41}', '\u{b44}'),
+    ('\u{b4d}', '\u{b4d}'),
+    ('\u{b55}', '\u{b56}'),
+    ('\u{b62}', '\u{b63}'),
+    ('\u{b82}', '\u{b82}'),
+    ('\u{bc0}', '\u{bc0}'),
+    ('\u{bcd}', '\u{bcd}'),
+    ('\u{c00}', '\u{c00}'),
+    ('\u{c04}', '\u{c04}'),
+    ('\u{c3c}', '\u{c3c}'),
+    ('\u{c3e}', '\u{c40}'),
+    ('\u{c46}', '\u{c48}'),
+    ('\u{c4a}', '\u{c4d}'),
+    ('\u{c55}', '\u{c56}'),
+    ('\u{c62}', '\u{c63}'),
+    ('\u{c81}', '\u{c81}'),
+    ('\u{cbc}', '\u{cbc}'),
+    ('\u{cbf}', '\u{cbf}'),
+    ('\u{cc6}', '\u{cc6}'),
+    ('\u{ccc}', '\u{ccd}'),
+    ('\u{ce2}', '\u{ce3}'),
+    ('\u{d00}', '\u{d01}'),
+    ('\u{d3b}', '\u{d3c}'),
+    ('\u{d41}', '\u{d44}'),
+    ('\u{d4d}', '\u{d4d}'),
+    ('\u{d62}', '\u{d63}'),
+    ('\u{d81}', '\u{d81}'),
+    ('\u{dca}', '\u{dca}'),
+    ('\u{dd2}', '\u{dd4}'),
+    ('\u{dd6}', '\u{dd6}'),
+    ('\u{e31}', '\u{e31}'),
+    ('\u{e34}', '\u{e3a}'),
+    ('ๆ', '\u{e4e}'),
+    ('\u{eb1}', '\u{eb1}'),
+    ('\u{eb4}', '\u{ebc}'),
+    ('ໆ', 'ໆ'),
+    ('\u{ec8}', '\u{ece}'),
+    ('\u{f18}', '\u{f19}'),
+    ('\u{f35}', '\u{f35}'),
+    ('\u{f37}', '\u{f37}'),
+    ('\u{f39}', '\u{f39}'),
+    ('\u{f71}', '\u{f7e}'),
+    ('\u{f80}', '\u{f84}'),
+    ('\u{f86}', '\u{f87}'),
+    ('\u{f8d}', '\u{f97}'),
+    ('\u{f99}', '\u{fbc}'),
+    ('\u{fc6}', '\u{fc6}'),
+    ('\u{102d}', '\u{1030}'),
+    ('\u{1032}', '\u{1037}'),
+    ('\u{1039}', '\u{103a}'),
+    ('\u{103d}', '\u{103e}'),
+    ('\u{1058}', '\u{1059}'),
+    ('\u{105e}', '\u{1060}'),
+    ('\u{1071}', '\u{1074}'),
+    ('\u{1082}', '\u{1082}'),
+    ('\u{1085}', '\u{1086}'),
+    ('\u{108d}', '\u{108d}'),
+    ('\u{109d}', '\u{109d}'),
+    ('ჼ', 'ჼ'),
+    ('\u{135d}', '\u{135f}'),
+    ('\u{1712}', '\u{1714}'),
+    ('\u{1732}', '\u{1733}'),
+    ('\u{1752}', '\u{1753}'),
+    ('\u{1772}', '\u{1773}'),
+    ('\u{17b4}', '\u{17b5}'),
+    ('\u{17b7}', '\u{17bd}'),
+    ('\u{17c6}', '\u{17c6}'),
+    ('\u{17c9}', '\u{17d3}'),
+    ('ៗ', 'ៗ'),
+    ('\u{17dd}', '\u{17dd}'),
+    ('\u{180b}', '\u{180f}'),
+    ('ᡃ', 'ᡃ'),
+    ('\u{1885}', '\u{1886}'),
+    ('\u{18a9}', '\u{18a9}'),
+    ('\u{1920}', '\u{1922}'),
+    ('\u{1927}', '\u{1928}'),
+    ('\u{1932}', '\u{1932}'),
+    ('\u{1939}', '\u{193b}'),
+    ('\u{1a17}', '\u{1a18}'),
+    ('\u{1a1b}', '\u{1a1b}'),
+    ('\u{1a56}', '\u{1a56}'),
+    ('\u{1a58}', '\u{1a5e}'),
+    ('\u{1a60}', '\u{1a60}'),
+    ('\u{1a62}', '\u{1a62}'),
+    ('\u{1a65}', '\u{1a6c}'),
+    ('\u{1a73}', '\u{1a7c}'),
+    ('\u{1a7f}', '\u{1a7f}'),
+    ('ᪧ', 'ᪧ'),
+    ('\u{1ab0}', '\u{1ace}'),
+    ('\u{1b00}', '\u{1b03}'),
+    ('\u{1b34}', '\u{1b34}'),
+    ('\u{1b36}', '\u{1b3a}'),
+    ('\u{1b3c}', '\u{1b3c}'),
+    ('\u{1b42}', '\u{1b42}'),
+    ('\u{1b6b}', '\u{1b73}'),
+    ('\u{1b80}', '\u{1b81}'),
+    ('\u{1ba2}', '\u{1ba5}'),
+    ('\u{1ba8}', '\u{1ba9}'),
+    ('\u{1bab}', '\u{1bad}'),
+    ('\u{1be6}', '\u{1be6}'),
+    ('\u{1be8}', '\u{1be9}'),
+    ('\u{1bed}', '\u{1bed}'),
+    ('\u{1bef}', '\u{1bf1}'),
+    ('\u{1c2c}', '\u{1c33}'),
+    ('\u{1c36}', '\u{1c37}'),
+    ('ᱸ', 'ᱽ'),
+    ('\u{1cd0}', '\u{1cd2}'),
+    ('\u{1cd4}', '\u{1ce0}'),
+    ('\u{1ce2}', '\u{1ce8}'),
+    ('\u{1ced}', '\u{1ced}'),
+    ('\u{1cf4}', '\u{1cf4}'),
+    ('\u{1cf8}', '\u{1cf9}'),
+    ('ᴬ', 'ᵪ'),
+    ('ᵸ', 'ᵸ'),
+    ('ᶛ', '\u{1dff}'),
+    ('᾽', '᾽'),
+    ('᾿', '῁'),
+    ('῍', '῏'),
+    ('῝', '῟'),
+    ('῭', '`'),
+    ('´', '῾'),
+    ('\u{200b}', '\u{200f}'),
+    ('‘', '’'),
+    ('․', '․'),
+    ('‧', '‧'),
+    ('\u{202a}', '\u{202e}'),
+    ('\u{2060}', '\u{2064}'),
+    ('\u{2066}', '\u{206f}'),
+    ('ⁱ', 'ⁱ'),
+    ('ⁿ', 'ⁿ'),
+    ('ₐ', 'ₜ'),
+    ('\u{20d0}', '\u{20f0}'),
+    ('ⱼ', 'ⱽ'),
+    ('\u{2cef}', '\u{2cf1}'),
+    ('ⵯ', 'ⵯ'),
+    ('\u{2d7f}', '\u{2d7f}'),
+    ('\u{2de0}', '\u{2dff}'),
+    ('ⸯ', 'ⸯ'),
+    ('々', '々'),
+    ('\u{302a}', '\u{302d}'),
+    ('〱', '〵'),
+    ('〻', '〻'),
+    ('\u{3099}', 'ゞ'),
+    ('ー', 'ヾ'),
+    ('ꀕ', 'ꀕ'),
+    ('ꓸ', 'ꓽ'),
+    ('ꘌ', 'ꘌ'),
+    ('\u{a66f}', '\u{a672}'),
+    ('\u{a674}', '\u{a67d}'),
+    ('ꙿ', 'ꙿ'),
+    ('ꚜ', '\u{a69f}'),
+    ('\u{a6f0}', '\u{a6f1}'),
+    ('꜀', '꜡'),
+    ('ꝰ', 'ꝰ'),
+    ('ꞈ', '꞊'),
+    ('ꟲ', 'ꟴ'),
+    ('ꟸ', 'ꟹ'),
+    ('\u{a802}', '\u{a802}'),
+    ('\u{a806}', '\u{a806}'),
+    ('\u{a80b}', '\u{a80b}'),
+    ('\u{a825}', '\u{a826}'),
+    ('\u{a82c}', '\u{a82c}'),
+    ('\u{a8c4}', '\u{a8c5}'),
+    ('\u{a8e0}', '\u{a8f1}'),
+    ('\u{a8ff}', '\u{a8ff}'),
+    ('\u{a926}', '\u{a92d}'),
+    ('\u{a947}', '\u{a951}'),
+    ('\u{a980}', '\u{a982}'),
+    ('\u{a9b3}', '\u{a9b3}'),
+    ('\u{a9b6}', '\u{a9b9}'),
+    ('\u{a9bc}', '\u{a9bd}'),
+    ('ꧏ', 'ꧏ'),
+    ('\u{a9e5}', 'ꧦ'),
+    ('\u{aa29}', '\u{aa2e}'),
+    ('\u{aa31}', '\u{aa32}'),
+    ('\u{aa35}', '\u{aa36}'),
+    ('\u{aa43}', '\u{aa43}'),
+    ('\u{aa4c}', '\u{aa4c}'),
+    ('ꩰ', 'ꩰ'),
+    ('\u{aa7c}', '\u{aa7c}'),
+    ('\u{aab0}', '\u{aab0}'),
+    ('\u{aab2}', '\u{aab4}'),
+    ('\u{aab7}', '\u{aab8}'),
+    ('\u{aabe}', '\u{aabf}'),
+    ('\u{aac1}', '\u{aac1}'),
+    ('ꫝ', 'ꫝ'),
+    ('\u{aaec}', '\u{aaed}'),
+    ('ꫳ', 'ꫴ'),
+    ('\u{aaf6}', '\u{aaf6}'),
+    ('꭛', 'ꭟ'),
+    ('ꭩ', '꭫'),
+    ('\u{abe5}', '\u{abe5}'),
+    ('\u{abe8}', '\u{abe8}'),
+    ('\u{abed}', '\u{abed}'),
+    ('\u{fb1e}', '\u{fb1e}'),
+    ('﮲', '﯂'),
+    ('\u{fe00}', '\u{fe0f}'),
+    ('︓', '︓'),
+    ('\u{fe20}', '\u{fe2f}'),
+    ('﹒', '﹒'),
+    ('﹕', '﹕'),
+    ('\u{feff}', '\u{feff}'),
+    ('＇', '＇'),
+    ('．', '．'),
+    ('：', '：'),
+    ('＾', '＾'),
+    ('｀', '｀'),
+    ('ｰ', 'ｰ'),
+    ('\u{ff9e}', '\u{ff9f}'),
+    ('￣', '￣'),
+    ('\u{fff9}', '\u{fffb}'),
+    ('\u{101fd}', '\u{101fd}'),
+    ('\u{102e0}', '\u{102e0}'),
+    ('\u{10376}', '\u{1037a}'),
+    ('𐞀', '𐞅'),
+    ('𐞇', '𐞰'),
+    ('𐞲', '𐞺'),
+    ('\u{10a01}', '\u{10a03}'),
+    ('\u{10a05}', '\u{10a06}'),
+    ('\u{10a0c}', '\u{10a0f}'),
+    ('\u{10a38}', '\u{10a3a}'),
+    ('\u{10a3f}', '\u{10a3f}'),
+    ('\u{10ae5}', '\u{10ae6}'),
+    ('\u{10d24}', '\u{10d27}'),
+    ('\u{10eab}', '\u{10eac}'),
+    ('\u{10efd}', '\u{10eff}'),
+    ('\u{10f46}', '\u{10f50}'),
+    ('\u{10f82}', '\u{10f85}'),
+    ('\u{11001}', '\u{11001}'),
+    ('\u{11038}', '\u{11046}'),
+    ('\u{11070}', '\u{11070}'),
+    ('\u{11073}', '\u{11074}'),
+    ('\u{1107f}', '\u{11081}'),
+    ('\u{110b3}', '\u{110b6}'),
+    ('\u{110b9}', '\u{110ba}'),
+    ('\u{110bd}', '\u{110bd}'),
+    ('\u{110c2}', '\u{110c2}'),
+    ('\u{110cd}', '\u{110cd}'),
+    ('\u{11100}', '\u{11102}'),
+    ('\u{11127}', '\u{1112b}'),
+    ('\u{1112d}', '\u{11134}'),
+    ('\u{11173}', '\u{11173}'),
+    ('\u{11180}', '\u{11181}'),
+    ('\u{111b6}', '\u{111be}'),
+    ('\u{111c9}', '\u{111cc}'),
+    ('\u{111cf}', '\u{111cf}'),
+    ('\u{1122f}', '\u{11231}'),
+    ('\u{11234}', '\u{11234}'),
+    ('\u{11236}', '\u{11237}'),
+    ('\u{1123e}', '\u{1123e}'),
+    ('\u{11241}', '\u{11241}'),
+    ('\u{112df}', '\u{112df}'),
+    ('\u{112e3}', '\u{112ea}'),
+    ('\u{11300}', '\u{11301}'),
+    ('\u{1133b}', '\u{1133c}'),
+    ('\u{11340}', '\u{11340}'),
+    ('\u{11366}', '\u{1136c}'),
+    ('\u{11370}', '\u{11374}'),
+    ('\u{11438}', '\u{1143f}'),
+    ('\u{11442}', '\u{11444}'),
+    ('\u{11446}', '\u{11446}'),
+    ('\u{1145e}', '\u{1145e}'),
+    ('\u{114b3}', '\u{114b8}'),
+    ('\u{114ba}', '\u{114ba}'),
+    ('\u{114bf}', '\u{114c0}'),
+    ('\u{114c2}', '\u{114c3}'),
+    ('\u{115b2}', '\u{115b5}'),
+    ('\u{115bc}', '\u{115bd}'),
+    ('\u{115bf}', '\u{115c0}'),
+    ('\u{115dc}', '\u{115dd}'),
+    ('\u{11633}', '\u{1163a}'),
+    ('\u{1163d}', '\u{1163d}'),
+    ('\u{1163f}', '\u{11640}'),
+    ('\u{116ab}', '\u{116ab}'),
+    ('\u{116ad}', '\u{116ad}'),
+    ('\u{116b0}', '\u{116b5}'),
+    ('\u{116b7}', '\u{116b7}'),
+    ('\u{1171d}', '\u{1171f}'),
+    ('\u{11722}', '\u{11725}'),
+    ('\u{11727}', '\u{1172b}'),
+    ('\u{1182f}', '\u{11837}'),
+    ('\u{11839}', '\u{1183a}'),
+    ('\u{1193b}', '\u{1193c}'),
+    ('\u{1193e}', '\u{1193e}'),
+    ('\u{11943}', '\u{11943}'),
+    ('\u{119d4}', '\u{119d7}'),
+    ('\u{119da}', '\u{119db}'),
+    ('\u{119e0}', '\u{119e0}'),
+    ('\u{11a01}', '\u{11a0a}'),
+    ('\u{11a33}', '\u{11a38}'),
+    ('\u{11a3b}', '\u{11a3e}'),
+    ('\u{11a47}', '\u{11a47}'),
+    ('\u{11a51}', '\u{11a56}'),
+    ('\u{11a59}', '\u{11a5b}'),
+    ('\u{11a8a}', '\u{11a96}'),
+    ('\u{11a98}', '\u{11a99}'),
+    ('\u{11c30}', '\u{11c36}'),
+    ('\u{11c38}', '\u{11c3d}'),
+    ('\u{11c3f}', '\u{11c3f}'),
+    ('\u{11c92}', '\u{11ca7}'),
+    ('\u{11caa}', '\u{11cb0}'),
+    ('\u{11cb2}', '\u{11cb3}'),
+    ('\u{11cb5}', '\u{11cb6}'),
+    ('\u{11d31}', '\u{11d36}'),
+    ('\u{11d3a}', '\u{11d3a}'),
+    ('\u{11d3c}', '\u{11d3d}'),
+    ('\u{11d3f}', '\u{11d45}'),
+    ('\u{11d47}', '\u{11d47}'),
+    ('\u{11d90}', '\u{11d91}'),
+    ('\u{11d95}', '\u{11d95}'),
+    ('\u{11d97}', '\u{11d97}'),
+    ('\u{11ef3}', '\u{11ef4}'),
+    ('\u{11f00}', '\u{11f01}'),
+    ('\u{11f36}', '\u{11f3a}'),
+    ('\u{11f40}', '\u{11f40}'),
+    ('\u{11f42}', '\u{11f42}'),
+    ('\u{13430}', '\u{13440}'),
+    ('\u{13447}', '\u{13455}'),
+    ('\u{16af0}', '\u{16af4}'),
+    ('\u{16b30}', '\u{16b36}'),
+    ('𖭀', '𖭃'),
+    ('\u{16f4f}', '\u{16f4f}'),
+    ('\u{16f8f}', '𖾟'),
+    ('𖿠', '𖿡'),
+    ('𖿣', '\u{16fe4}'),
+    ('𚿰', '𚿳'),
+    ('𚿵', '𚿻'),
+    ('𚿽', '𚿾'),
+    ('\u{1bc9d}', '\u{1bc9e}'),
+    ('\u{1bca0}', '\u{1bca3}'),
+    ('\u{1cf00}', '\u{1cf2d}'),
+    ('\u{1cf30}', '\u{1cf46}'),
+    ('\u{1d167}', '\u{1d169}'),
+    ('\u{1d173}', '\u{1d182}'),
+    ('\u{1d185}', '\u{1d18b}'),
+    ('\u{1d1aa}', '\u{1d1ad}'),
+    ('\u{1d242}', '\u{1d244}'),
+    ('\u{1da00}', '\u{1da36}'),
+    ('\u{1da3b}', '\u{1da6c}'),
+    ('\u{1da75}', '\u{1da75}'),
+    ('\u{1da84}', '\u{1da84}'),
+    ('\u{1da9b}', '\u{1da9f}'),
+    ('\u{1daa1}', '\u{1daaf}'),
+    ('\u{1e000}', '\u{1e006}'),
+    ('\u{1e008}', '\u{1e018}'),
+    ('\u{1e01b}', '\u{1e021}'),
+    ('\u{1e023}', '\u{1e024}'),
+    ('\u{1e026}', '\u{1e02a}'),
+    ('𞀰', '𞁭'),
+    ('\u{1e08f}', '\u{1e08f}'),
+    ('\u{1e130}', '𞄽'),
+    ('\u{1e2ae}', '\u{1e2ae}'),
+    ('\u{1e2ec}', '\u{1e2ef}'),
+    ('𞓫', '\u{1e4ef}'),
+    ('\u{1e8d0}', '\u{1e8d6}'),
+    ('\u{1e944}', '𞥋'),
+    ('🏻', '🏿'),
+    ('\u{e0001}', '\u{e0001}'),
+    ('\u{e0020}', '\u{e007f}'),
+    ('\u{e0100}', '\u{e01ef}'),
+];
+
+pub const CASED: &'static [(char, char)] = &[
+    ('A', 'Z'),
+    ('a', 'z'),
+    ('ª', 'ª'),
+    ('µ', 'µ'),
+    ('º', 'º'),
+    ('À', 'Ö'),
+    ('Ø', 'ö'),
+    ('ø', 'ƺ'),
+    ('Ƽ', 'ƿ'),
+    ('Ǆ', 'ʓ'),
+    ('ʕ', 'ʸ'),
+    ('ˀ', 'ˁ'),
+    ('ˠ', 'ˤ'),
+    ('\u{345}', '\u{345}'),
+    ('Ͱ', 'ͳ'),
+    ('Ͷ', 'ͷ'),
+    ('ͺ', 'ͽ'),
+    ('Ϳ', 'Ϳ'),
+    ('Ά', 'Ά'),
+    ('Έ', 'Ί'),
+    ('Ό', 'Ό'),
+    ('Ύ', 'Ρ'),
+    ('Σ', 'ϵ'),
+    ('Ϸ', 'ҁ'),
+    ('Ҋ', 'ԯ'),
+    ('Ա', 'Ֆ'),
+    ('ՠ', 'ֈ'),
+    ('Ⴀ', 'Ⴥ'),
+    ('Ⴧ', 'Ⴧ'),
+    ('Ⴭ', 'Ⴭ'),
+    ('ა', 'ჺ'),
+    ('ჼ', 'ჿ'),
+    ('Ꭰ', 'Ᏽ'),
+    ('ᏸ', 'ᏽ'),
+    ('ᲀ', 'ᲈ'),
+    ('Ა', 'Ჺ'),
+    ('Ჽ', 'Ჿ'),
+    ('ᴀ', 'ᶿ'),
+    ('Ḁ', 'ἕ'),
+    ('Ἐ', 'Ἕ'),
+    ('ἠ', 'ὅ'),
+    ('Ὀ', 'Ὅ'),
+    ('ὐ', 'ὗ'),
+    ('Ὑ', 'Ὑ'),
+    ('Ὓ', 'Ὓ'),
+    ('Ὕ', 'Ὕ'),
+    ('Ὗ', 'ώ'),
+    ('ᾀ', 'ᾴ'),
+    ('ᾶ', 'ᾼ'),
+    ('ι', 'ι'),
+    ('ῂ', 'ῄ'),
+    ('ῆ', 'ῌ'),
+    ('ῐ', 'ΐ'),
+    ('ῖ', 'Ί'),
+    ('ῠ', 'Ῥ'),
+    ('ῲ', 'ῴ'),
+    ('ῶ', 'ῼ'),
+    ('ⁱ', 'ⁱ'),
+    ('ⁿ', 'ⁿ'),
+    ('ₐ', 'ₜ'),
+    ('ℂ', 'ℂ'),
+    ('ℇ', 'ℇ'),
+    ('ℊ', 'ℓ'),
+    ('ℕ', 'ℕ'),
+    ('ℙ', 'ℝ'),
+    ('ℤ', 'ℤ'),
+    ('Ω', 'Ω'),
+    ('ℨ', 'ℨ'),
+    ('K', 'ℭ'),
+    ('ℯ', 'ℴ'),
+    ('ℹ', 'ℹ'),
+    ('ℼ', 'ℿ'),
+    ('ⅅ', 'ⅉ'),
+    ('ⅎ', 'ⅎ'),
+    ('Ⅰ', 'ⅿ'),
+    ('Ↄ', 'ↄ'),
+    ('Ⓐ', 'ⓩ'),
+    ('Ⰰ', 'ⳤ'),
+    ('Ⳬ', 'ⳮ'),
+    ('Ⳳ', 'ⳳ'),
+    ('ⴀ', 'ⴥ'),
+    ('ⴧ', 'ⴧ'),
+    ('ⴭ', 'ⴭ'),
+    ('Ꙁ', 'ꙭ'),
+    ('Ꚁ', 'ꚝ'),
+    ('Ꜣ', 'ꞇ'),
+    ('Ꞌ', 'ꞎ'),
+    ('Ꞑ', 'ꟊ'),
+    ('Ꟑ', 'ꟑ'),
+    ('ꟓ', 'ꟓ'),
+    ('ꟕ', 'ꟙ'),
+    ('ꟲ', 'ꟶ'),
+    ('ꟸ', 'ꟺ'),
+    ('ꬰ', 'ꭚ'),
+    ('ꭜ', 'ꭩ'),
+    ('ꭰ', 'ꮿ'),
+    ('ﬀ', 'ﬆ'),
+    ('ﬓ', 'ﬗ'),
+    ('Ａ', 'Ｚ'),
+    ('ａ', 'ｚ'),
+    ('𐐀', '𐑏'),
+    ('𐒰', '𐓓'),
+    ('𐓘', '𐓻'),
+    ('𐕰', '𐕺'),
+    ('𐕼', '𐖊'),
+    ('𐖌', '𐖒'),
+    ('𐖔', '𐖕'),
+    ('𐖗', '𐖡'),
+    ('𐖣', '𐖱'),
+    ('𐖳', '𐖹'),
+    ('𐖻', '𐖼'),
+    ('𐞀', '𐞀'),
+    ('𐞃', '𐞅'),
+    ('𐞇', '𐞰'),
+    ('𐞲', '𐞺'),
+    ('𐲀', '𐲲'),
+    ('𐳀', '𐳲'),
+    ('𑢠', '𑣟'),
+    ('𖹀', '𖹿'),
+    ('𝐀', '𝑔'),
+    ('𝑖', '𝒜'),
+    ('𝒞', '𝒟'),
+    ('𝒢', '𝒢'),
+    ('𝒥', '𝒦'),
+    ('𝒩', '𝒬'),
+    ('𝒮', '𝒹'),
+    ('𝒻', '𝒻'),
+    ('𝒽', '𝓃'),
+    ('𝓅', '𝔅'),
+    ('𝔇', '𝔊'),
+    ('𝔍', '𝔔'),
+    ('𝔖', '𝔜'),
+    ('𝔞', '𝔹'),
+    ('𝔻', '𝔾'),
+    ('𝕀', '𝕄'),
+    ('𝕆', '𝕆'),
+    ('𝕊', '𝕐'),
+    ('𝕒', '𝚥'),
+    ('𝚨', '𝛀'),
+    ('𝛂', '𝛚'),
+    ('𝛜', '𝛺'),
+    ('𝛼', '𝜔'),
+    ('𝜖', '𝜴'),
+    ('𝜶', '𝝎'),
+    ('𝝐', '𝝮'),
+    ('𝝰', '𝞈'),
+    ('𝞊', '𝞨'),
+    ('𝞪', '𝟂'),
+    ('𝟄', '𝟋'),
+    ('𝼀', '𝼉'),
+    ('𝼋', '𝼞'),
+    ('𝼥', '𝼪'),
+    ('𞀰', '𞁭'),
+    ('𞤀', '𞥃'),
+    ('🄰', '🅉'),
+    ('🅐', '🅩'),
+    ('🅰', '🆉'),
+];
+
+pub const CHANGES_WHEN_CASEFOLDED: &'static [(char, char)] = &[
+    ('A', 'Z'),
+    ('µ', 'µ'),
+    ('À', 'Ö'),
+    ('Ø', 'ß'),
+    ('Ā', 'Ā'),
+    ('Ă', 'Ă'),
+    ('Ą', 'Ą'),
+    ('Ć', 'Ć'),
+    ('Ĉ', 'Ĉ'),
+    ('Ċ', 'Ċ'),
+    ('Č', 'Č'),
+    ('Ď', 'Ď'),
+    ('Đ', 'Đ'),
+    ('Ē', 'Ē'),
+    ('Ĕ', 'Ĕ'),
+    ('Ė', 'Ė'),
+    ('Ę', 'Ę'),
+    ('Ě', 'Ě'),
+    ('Ĝ', 'Ĝ'),
+    ('Ğ', 'Ğ'),
+    ('Ġ', 'Ġ'),
+    ('Ģ', 'Ģ'),
+    ('Ĥ', 'Ĥ'),
+    ('Ħ', 'Ħ'),
+    ('Ĩ', 'Ĩ'),
+    ('Ī', 'Ī'),
+    ('Ĭ', 'Ĭ'),
+    ('Į', 'Į'),
+    ('İ', 'İ'),
+    ('Ĳ', 'Ĳ'),
+    ('Ĵ', 'Ĵ'),
+    ('Ķ', 'Ķ'),
+    ('Ĺ', 'Ĺ'),
+    ('Ļ', 'Ļ'),
+    ('Ľ', 'Ľ'),
+    ('Ŀ', 'Ŀ'),
+    ('Ł', 'Ł'),
+    ('Ń', 'Ń'),
+    ('Ņ', 'Ņ'),
+    ('Ň', 'Ň'),
+    ('ŉ', 'Ŋ'),
+    ('Ō', 'Ō'),
+    ('Ŏ', 'Ŏ'),
+    ('Ő', 'Ő'),
+    ('Œ', 'Œ'),
+    ('Ŕ', 'Ŕ'),
+    ('Ŗ', 'Ŗ'),
+    ('Ř', 'Ř'),
+    ('Ś', 'Ś'),
+    ('Ŝ', 'Ŝ'),
+    ('Ş', 'Ş'),
+    ('Š', 'Š'),
+    ('Ţ', 'Ţ'),
+    ('Ť', 'Ť'),
+    ('Ŧ', 'Ŧ'),
+    ('Ũ', 'Ũ'),
+    ('Ū', 'Ū'),
+    ('Ŭ', 'Ŭ'),
+    ('Ů', 'Ů'),
+    ('Ű', 'Ű'),
+    ('Ų', 'Ų'),
+    ('Ŵ', 'Ŵ'),
+    ('Ŷ', 'Ŷ'),
+    ('Ÿ', 'Ź'),
+    ('Ż', 'Ż'),
+    ('Ž', 'Ž'),
+    ('ſ', 'ſ'),
+    ('Ɓ', 'Ƃ'),
+    ('Ƅ', 'Ƅ'),
+    ('Ɔ', 'Ƈ'),
+    ('Ɖ', 'Ƌ'),
+    ('Ǝ', 'Ƒ'),
+    ('Ɠ', 'Ɣ'),
+    ('Ɩ', 'Ƙ'),
+    ('Ɯ', 'Ɲ'),
+    ('Ɵ', 'Ơ'),
+    ('Ƣ', 'Ƣ'),
+    ('Ƥ', 'Ƥ'),
+    ('Ʀ', 'Ƨ'),
+    ('Ʃ', 'Ʃ'),
+    ('Ƭ', 'Ƭ'),
+    ('Ʈ', 'Ư'),
+    ('Ʊ', 'Ƴ'),
+    ('Ƶ', 'Ƶ'),
+    ('Ʒ', 'Ƹ'),
+    ('Ƽ', 'Ƽ'),
+    ('Ǆ', 'ǅ'),
+    ('Ǉ', 'ǈ'),
+    ('Ǌ', 'ǋ'),
+    ('Ǎ', 'Ǎ'),
+    ('Ǐ', 'Ǐ'),
+    ('Ǒ', 'Ǒ'),
+    ('Ǔ', 'Ǔ'),
+    ('Ǖ', 'Ǖ'),
+    ('Ǘ', 'Ǘ'),
+    ('Ǚ', 'Ǚ'),
+    ('Ǜ', 'Ǜ'),
+    ('Ǟ', 'Ǟ'),
+    ('Ǡ', 'Ǡ'),
+    ('Ǣ', 'Ǣ'),
+    ('Ǥ', 'Ǥ'),
+    ('Ǧ', 'Ǧ'),
+    ('Ǩ', 'Ǩ'),
+    ('Ǫ', 'Ǫ'),
+    ('Ǭ', 'Ǭ'),
+    ('Ǯ', 'Ǯ'),
+    ('Ǳ', 'ǲ'),
+    ('Ǵ', 'Ǵ'),
+    ('Ƕ', 'Ǹ'),
+    ('Ǻ', 'Ǻ'),
+    ('Ǽ', 'Ǽ'),
+    ('Ǿ', 'Ǿ'),
+    ('Ȁ', 'Ȁ'),
+    ('Ȃ', 'Ȃ'),
+    ('Ȅ', 'Ȅ'),
+    ('Ȇ', 'Ȇ'),
+    ('Ȉ', 'Ȉ'),
+    ('Ȋ', 'Ȋ'),
+    ('Ȍ', 'Ȍ'),
+    ('Ȏ', 'Ȏ'),
+    ('Ȑ', 'Ȑ'),
+    ('Ȓ', 'Ȓ'),
+    ('Ȕ', 'Ȕ'),
+    ('Ȗ', 'Ȗ'),
+    ('Ș', 'Ș'),
+    ('Ț', 'Ț'),
+    ('Ȝ', 'Ȝ'),
+    ('Ȟ', 'Ȟ'),
+    ('Ƞ', 'Ƞ'),
+    ('Ȣ', 'Ȣ'),
+    ('Ȥ', 'Ȥ'),
+    ('Ȧ', 'Ȧ'),
+    ('Ȩ', 'Ȩ'),
+    ('Ȫ', 'Ȫ'),
+    ('Ȭ', 'Ȭ'),
+    ('Ȯ', 'Ȯ'),
+    ('Ȱ', 'Ȱ'),
+    ('Ȳ', 'Ȳ'),
+    ('Ⱥ', 'Ȼ'),
+    ('Ƚ', 'Ⱦ'),
+    ('Ɂ', 'Ɂ'),
+    ('Ƀ', 'Ɇ'),
+    ('Ɉ', 'Ɉ'),
+    ('Ɋ', 'Ɋ'),
+    ('Ɍ', 'Ɍ'),
+    ('Ɏ', 'Ɏ'),
+    ('\u{345}', '\u{345}'),
+    ('Ͱ', 'Ͱ'),
+    ('Ͳ', 'Ͳ'),
+    ('Ͷ', 'Ͷ'),
+    ('Ϳ', 'Ϳ'),
+    ('Ά', 'Ά'),
+    ('Έ', 'Ί'),
+    ('Ό', 'Ό'),
+    ('Ύ', 'Ώ'),
+    ('Α', 'Ρ'),
+    ('Σ', 'Ϋ'),
+    ('ς', 'ς'),
+    ('Ϗ', 'ϑ'),
+    ('ϕ', 'ϖ'),
+    ('Ϙ', 'Ϙ'),
+    ('Ϛ', 'Ϛ'),
+    ('Ϝ', 'Ϝ'),
+    ('Ϟ', 'Ϟ'),
+    ('Ϡ', 'Ϡ'),
+    ('Ϣ', 'Ϣ'),
+    ('Ϥ', 'Ϥ'),
+    ('Ϧ', 'Ϧ'),
+    ('Ϩ', 'Ϩ'),
+    ('Ϫ', 'Ϫ'),
+    ('Ϭ', 'Ϭ'),
+    ('Ϯ', 'Ϯ'),
+    ('ϰ', 'ϱ'),
+    ('ϴ', 'ϵ'),
+    ('Ϸ', 'Ϸ'),
+    ('Ϲ', 'Ϻ'),
+    ('Ͻ', 'Я'),
+    ('Ѡ', 'Ѡ'),
+    ('Ѣ', 'Ѣ'),
+    ('Ѥ', 'Ѥ'),
+    ('Ѧ', 'Ѧ'),
+    ('Ѩ', 'Ѩ'),
+    ('Ѫ', 'Ѫ'),
+    ('Ѭ', 'Ѭ'),
+    ('Ѯ', 'Ѯ'),
+    ('Ѱ', 'Ѱ'),
+    ('Ѳ', 'Ѳ'),
+    ('Ѵ', 'Ѵ'),
+    ('Ѷ', 'Ѷ'),
+    ('Ѹ', 'Ѹ'),
+    ('Ѻ', 'Ѻ'),
+    ('Ѽ', 'Ѽ'),
+    ('Ѿ', 'Ѿ'),
+    ('Ҁ', 'Ҁ'),
+    ('Ҋ', 'Ҋ'),
+    ('Ҍ', 'Ҍ'),
+    ('Ҏ', 'Ҏ'),
+    ('Ґ', 'Ґ'),
+    ('Ғ', 'Ғ'),
+    ('Ҕ', 'Ҕ'),
+    ('Җ', 'Җ'),
+    ('Ҙ', 'Ҙ'),
+    ('Қ', 'Қ'),
+    ('Ҝ', 'Ҝ'),
+    ('Ҟ', 'Ҟ'),
+    ('Ҡ', 'Ҡ'),
+    ('Ң', 'Ң'),
+    ('Ҥ', 'Ҥ'),
+    ('Ҧ', 'Ҧ'),
+    ('Ҩ', 'Ҩ'),
+    ('Ҫ', 'Ҫ'),
+    ('Ҭ', 'Ҭ'),
+    ('Ү', 'Ү'),
+    ('Ұ', 'Ұ'),
+    ('Ҳ', 'Ҳ'),
+    ('Ҵ', 'Ҵ'),
+    ('Ҷ', 'Ҷ'),
+    ('Ҹ', 'Ҹ'),
+    ('Һ', 'Һ'),
+    ('Ҽ', 'Ҽ'),
+    ('Ҿ', 'Ҿ'),
+    ('Ӏ', 'Ӂ'),
+    ('Ӄ', 'Ӄ'),
+    ('Ӆ', 'Ӆ'),
+    ('Ӈ', 'Ӈ'),
+    ('Ӊ', 'Ӊ'),
+    ('Ӌ', 'Ӌ'),
+    ('Ӎ', 'Ӎ'),
+    ('Ӑ', 'Ӑ'),
+    ('Ӓ', 'Ӓ'),
+    ('Ӕ', 'Ӕ'),
+    ('Ӗ', 'Ӗ'),
+    ('Ә', 'Ә'),
+    ('Ӛ', 'Ӛ'),
+    ('Ӝ', 'Ӝ'),
+    ('Ӟ', 'Ӟ'),
+    ('Ӡ', 'Ӡ'),
+    ('Ӣ', 'Ӣ'),
+    ('Ӥ', 'Ӥ'),
+    ('Ӧ', 'Ӧ'),
+    ('Ө', 'Ө'),
+    ('Ӫ', 'Ӫ'),
+    ('Ӭ', 'Ӭ'),
+    ('Ӯ', 'Ӯ'),
+    ('Ӱ', 'Ӱ'),
+    ('Ӳ', 'Ӳ'),
+    ('Ӵ', 'Ӵ'),
+    ('Ӷ', 'Ӷ'),
+    ('Ӹ', 'Ӹ'),
+    ('Ӻ', 'Ӻ'),
+    ('Ӽ', 'Ӽ'),
+    ('Ӿ', 'Ӿ'),
+    ('Ԁ', 'Ԁ'),
+    ('Ԃ', 'Ԃ'),
+    ('Ԅ', 'Ԅ'),
+    ('Ԇ', 'Ԇ'),
+    ('Ԉ', 'Ԉ'),
+    ('Ԋ', 'Ԋ'),
+    ('Ԍ', 'Ԍ'),
+    ('Ԏ', 'Ԏ'),
+    ('Ԑ', 'Ԑ'),
+    ('Ԓ', 'Ԓ'),
+    ('Ԕ', 'Ԕ'),
+    ('Ԗ', 'Ԗ'),
+    ('Ԙ', 'Ԙ'),
+    ('Ԛ', 'Ԛ'),
+    ('Ԝ', 'Ԝ'),
+    ('Ԟ', 'Ԟ'),
+    ('Ԡ', 'Ԡ'),
+    ('Ԣ', 'Ԣ'),
+    ('Ԥ', 'Ԥ'),
+    ('Ԧ', 'Ԧ'),
+    ('Ԩ', 'Ԩ'),
+    ('Ԫ', 'Ԫ'),
+    ('Ԭ', 'Ԭ'),
+    ('Ԯ', 'Ԯ'),
+    ('Ա', 'Ֆ'),
+    ('և', 'և'),
+    ('Ⴀ', 'Ⴥ'),
+    ('Ⴧ', 'Ⴧ'),
+    ('Ⴭ', 'Ⴭ'),
+    ('ᏸ', 'ᏽ'),
+    ('ᲀ', 'ᲈ'),
+    ('Ა', 'Ჺ'),
+    ('Ჽ', 'Ჿ'),
+    ('Ḁ', 'Ḁ'),
+    ('Ḃ', 'Ḃ'),
+    ('Ḅ', 'Ḅ'),
+    ('Ḇ', 'Ḇ'),
+    ('Ḉ', 'Ḉ'),
+    ('Ḋ', 'Ḋ'),
+    ('Ḍ', 'Ḍ'),
+    ('Ḏ', 'Ḏ'),
+    ('Ḑ', 'Ḑ'),
+    ('Ḓ', 'Ḓ'),
+    ('Ḕ', 'Ḕ'),
+    ('Ḗ', 'Ḗ'),
+    ('Ḙ', 'Ḙ'),
+    ('Ḛ', 'Ḛ'),
+    ('Ḝ', 'Ḝ'),
+    ('Ḟ', 'Ḟ'),
+    ('Ḡ', 'Ḡ'),
+    ('Ḣ', 'Ḣ'),
+    ('Ḥ', 'Ḥ'),
+    ('Ḧ', 'Ḧ'),
+    ('Ḩ', 'Ḩ'),
+    ('Ḫ', 'Ḫ'),
+    ('Ḭ', 'Ḭ'),
+    ('Ḯ', 'Ḯ'),
+    ('Ḱ', 'Ḱ'),
+    ('Ḳ', 'Ḳ'),
+    ('Ḵ', 'Ḵ'),
+    ('Ḷ', 'Ḷ'),
+    ('Ḹ', 'Ḹ'),
+    ('Ḻ', 'Ḻ'),
+    ('Ḽ', 'Ḽ'),
+    ('Ḿ', 'Ḿ'),
+    ('Ṁ', 'Ṁ'),
+    ('Ṃ', 'Ṃ'),
+    ('Ṅ', 'Ṅ'),
+    ('Ṇ', 'Ṇ'),
+    ('Ṉ', 'Ṉ'),
+    ('Ṋ', 'Ṋ'),
+    ('Ṍ', 'Ṍ'),
+    ('Ṏ', 'Ṏ'),
+    ('Ṑ', 'Ṑ'),
+    ('Ṓ', 'Ṓ'),
+    ('Ṕ', 'Ṕ'),
+    ('Ṗ', 'Ṗ'),
+    ('Ṙ', 'Ṙ'),
+    ('Ṛ', 'Ṛ'),
+    ('Ṝ', 'Ṝ'),
+    ('Ṟ', 'Ṟ'),
+    ('Ṡ', 'Ṡ'),
+    ('Ṣ', 'Ṣ'),
+    ('Ṥ', 'Ṥ'),
+    ('Ṧ', 'Ṧ'),
+    ('Ṩ', 'Ṩ'),
+    ('Ṫ', 'Ṫ'),
+    ('Ṭ', 'Ṭ'),
+    ('Ṯ', 'Ṯ'),
+    ('Ṱ', 'Ṱ'),
+    ('Ṳ', 'Ṳ'),
+    ('Ṵ', 'Ṵ'),
+    ('Ṷ', 'Ṷ'),
+    ('Ṹ', 'Ṹ'),
+    ('Ṻ', 'Ṻ'),
+    ('Ṽ', 'Ṽ'),
+    ('Ṿ', 'Ṿ'),
+    ('Ẁ', 'Ẁ'),
+    ('Ẃ', 'Ẃ'),
+    ('Ẅ', 'Ẅ'),
+    ('Ẇ', 'Ẇ'),
+    ('Ẉ', 'Ẉ'),
+    ('Ẋ', 'Ẋ'),
+    ('Ẍ', 'Ẍ'),
+    ('Ẏ', 'Ẏ'),
+    ('Ẑ', 'Ẑ'),
+    ('Ẓ', 'Ẓ'),
+    ('Ẕ', 'Ẕ'),
+    ('ẚ', 'ẛ'),
+    ('ẞ', 'ẞ'),
+    ('Ạ', 'Ạ'),
+    ('Ả', 'Ả'),
+    ('Ấ', 'Ấ'),
+    ('Ầ', 'Ầ'),
+    ('Ẩ', 'Ẩ'),
+    ('Ẫ', 'Ẫ'),
+    ('Ậ', 'Ậ'),
+    ('Ắ', 'Ắ'),
+    ('Ằ', 'Ằ'),
+    ('Ẳ', 'Ẳ'),
+    ('Ẵ', 'Ẵ'),
+    ('Ặ', 'Ặ'),
+    ('Ẹ', 'Ẹ'),
+    ('Ẻ', 'Ẻ'),
+    ('Ẽ', 'Ẽ'),
+    ('Ế', 'Ế'),
+    ('Ề', 'Ề'),
+    ('Ể', 'Ể'),
+    ('Ễ', 'Ễ'),
+    ('Ệ', 'Ệ'),
+    ('Ỉ', 'Ỉ'),
+    ('Ị', 'Ị'),
+    ('Ọ', 'Ọ'),
+    ('Ỏ', 'Ỏ'),
+    ('Ố', 'Ố'),
+    ('Ồ', 'Ồ'),
+    ('Ổ', 'Ổ'),
+    ('Ỗ', 'Ỗ'),
+    ('Ộ', 'Ộ'),
+    ('Ớ', 'Ớ'),
+    ('Ờ', 'Ờ'),
+    ('Ở', 'Ở'),
+    ('Ỡ', 'Ỡ'),
+    ('Ợ', 'Ợ'),
+    ('Ụ', 'Ụ'),
+    ('Ủ', 'Ủ'),
+    ('Ứ', 'Ứ'),
+    ('Ừ', 'Ừ'),
+    ('Ử', 'Ử'),
+    ('Ữ', 'Ữ'),
+    ('Ự', 'Ự'),
+    ('Ỳ', 'Ỳ'),
+    ('Ỵ', 'Ỵ'),
+    ('Ỷ', 'Ỷ'),
+    ('Ỹ', 'Ỹ'),
+    ('Ỻ', 'Ỻ'),
+    ('Ỽ', 'Ỽ'),
+    ('Ỿ', 'Ỿ'),
+    ('Ἀ', 'Ἇ'),
+    ('Ἐ', 'Ἕ'),
+    ('Ἠ', 'Ἧ'),
+    ('Ἰ', 'Ἷ'),
+    ('Ὀ', 'Ὅ'),
+    ('Ὑ', 'Ὑ'),
+    ('Ὓ', 'Ὓ'),
+    ('Ὕ', 'Ὕ'),
+    ('Ὗ', 'Ὗ'),
+    ('Ὠ', 'Ὧ'),
+    ('ᾀ', 'ᾯ'),
+    ('ᾲ', 'ᾴ'),
+    ('ᾷ', 'ᾼ'),
+    ('ῂ', 'ῄ'),
+    ('ῇ', 'ῌ'),
+    ('Ῐ', 'Ί'),
+    ('Ῠ', 'Ῥ'),
+    ('ῲ', 'ῴ'),
+    ('ῷ', 'ῼ'),
+    ('Ω', 'Ω'),
+    ('K', 'Å'),
+    ('Ⅎ', 'Ⅎ'),
+    ('Ⅰ', 'Ⅿ'),
+    ('Ↄ', 'Ↄ'),
+    ('Ⓐ', 'Ⓩ'),
+    ('Ⰰ', 'Ⱟ'),
+    ('Ⱡ', 'Ⱡ'),
+    ('Ɫ', 'Ɽ'),
+    ('Ⱨ', 'Ⱨ'),
+    ('Ⱪ', 'Ⱪ'),
+    ('Ⱬ', 'Ⱬ'),
+    ('Ɑ', 'Ɒ'),
+    ('Ⱳ', 'Ⱳ'),
+    ('Ⱶ', 'Ⱶ'),
+    ('Ȿ', 'Ⲁ'),
+    ('Ⲃ', 'Ⲃ'),
+    ('Ⲅ', 'Ⲅ'),
+    ('Ⲇ', 'Ⲇ'),
+    ('Ⲉ', 'Ⲉ'),
+    ('Ⲋ', 'Ⲋ'),
+    ('Ⲍ', 'Ⲍ'),
+    ('Ⲏ', 'Ⲏ'),
+    ('Ⲑ', 'Ⲑ'),
+    ('Ⲓ', 'Ⲓ'),
+    ('Ⲕ', 'Ⲕ'),
+    ('Ⲗ', 'Ⲗ'),
+    ('Ⲙ', 'Ⲙ'),
+    ('Ⲛ', 'Ⲛ'),
+    ('Ⲝ', 'Ⲝ'),
+    ('Ⲟ', 'Ⲟ'),
+    ('Ⲡ', 'Ⲡ'),
+    ('Ⲣ', 'Ⲣ'),
+    ('Ⲥ', 'Ⲥ'),
+    ('Ⲧ', 'Ⲧ'),
+    ('Ⲩ', 'Ⲩ'),
+    ('Ⲫ', 'Ⲫ'),
+    ('Ⲭ', 'Ⲭ'),
+    ('Ⲯ', 'Ⲯ'),
+    ('Ⲱ', 'Ⲱ'),
+    ('Ⲳ', 'Ⲳ'),
+    ('Ⲵ', 'Ⲵ'),
+    ('Ⲷ', 'Ⲷ'),
+    ('Ⲹ', 'Ⲹ'),
+    ('Ⲻ', 'Ⲻ'),
+    ('Ⲽ', 'Ⲽ'),
+    ('Ⲿ', 'Ⲿ'),
+    ('Ⳁ', 'Ⳁ'),
+    ('Ⳃ', 'Ⳃ'),
+    ('Ⳅ', 'Ⳅ'),
+    ('Ⳇ', 'Ⳇ'),
+    ('Ⳉ', 'Ⳉ'),
+    ('Ⳋ', 'Ⳋ'),
+    ('Ⳍ', 'Ⳍ'),
+    ('Ⳏ', 'Ⳏ'),
+    ('Ⳑ', 'Ⳑ'),
+    ('Ⳓ', 'Ⳓ'),
+    ('Ⳕ', 'Ⳕ'),
+    ('Ⳗ', 'Ⳗ'),
+    ('Ⳙ', 'Ⳙ'),
+    ('Ⳛ', 'Ⳛ'),
+    ('Ⳝ', 'Ⳝ'),
+    ('Ⳟ', 'Ⳟ'),
+    ('Ⳡ', 'Ⳡ'),
+    ('Ⳣ', 'Ⳣ'),
+    ('Ⳬ', 'Ⳬ'),
+    ('Ⳮ', 'Ⳮ'),
+    ('Ⳳ', 'Ⳳ'),
+    ('Ꙁ', 'Ꙁ'),
+    ('Ꙃ', 'Ꙃ'),
+    ('Ꙅ', 'Ꙅ'),
+    ('Ꙇ', 'Ꙇ'),
+    ('Ꙉ', 'Ꙉ'),
+    ('Ꙋ', 'Ꙋ'),
+    ('Ꙍ', 'Ꙍ'),
+    ('Ꙏ', 'Ꙏ'),
+    ('Ꙑ', 'Ꙑ'),
+    ('Ꙓ', 'Ꙓ'),
+    ('Ꙕ', 'Ꙕ'),
+    ('Ꙗ', 'Ꙗ'),
+    ('Ꙙ', 'Ꙙ'),
+    ('Ꙛ', 'Ꙛ'),
+    ('Ꙝ', 'Ꙝ'),
+    ('Ꙟ', 'Ꙟ'),
+    ('Ꙡ', 'Ꙡ'),
+    ('Ꙣ', 'Ꙣ'),
+    ('Ꙥ', 'Ꙥ'),
+    ('Ꙧ', 'Ꙧ'),
+    ('Ꙩ', 'Ꙩ'),
+    ('Ꙫ', 'Ꙫ'),
+    ('Ꙭ', 'Ꙭ'),
+    ('Ꚁ', 'Ꚁ'),
+    ('Ꚃ', 'Ꚃ'),
+    ('Ꚅ', 'Ꚅ'),
+    ('Ꚇ', 'Ꚇ'),
+    ('Ꚉ', 'Ꚉ'),
+    ('Ꚋ', 'Ꚋ'),
+    ('Ꚍ', 'Ꚍ'),
+    ('Ꚏ', 'Ꚏ'),
+    ('Ꚑ', 'Ꚑ'),
+    ('Ꚓ', 'Ꚓ'),
+    ('Ꚕ', 'Ꚕ'),
+    ('Ꚗ', 'Ꚗ'),
+    ('Ꚙ', 'Ꚙ'),
+    ('Ꚛ', 'Ꚛ'),
+    ('Ꜣ', 'Ꜣ'),
+    ('Ꜥ', 'Ꜥ'),
+    ('Ꜧ', 'Ꜧ'),
+    ('Ꜩ', 'Ꜩ'),
+    ('Ꜫ', 'Ꜫ'),
+    ('Ꜭ', 'Ꜭ'),
+    ('Ꜯ', 'Ꜯ'),
+    ('Ꜳ', 'Ꜳ'),
+    ('Ꜵ', 'Ꜵ'),
+    ('Ꜷ', 'Ꜷ'),
+    ('Ꜹ', 'Ꜹ'),
+    ('Ꜻ', 'Ꜻ'),
+    ('Ꜽ', 'Ꜽ'),
+    ('Ꜿ', 'Ꜿ'),
+    ('Ꝁ', 'Ꝁ'),
+    ('Ꝃ', 'Ꝃ'),
+    ('Ꝅ', 'Ꝅ'),
+    ('Ꝇ', 'Ꝇ'),
+    ('Ꝉ', 'Ꝉ'),
+    ('Ꝋ', 'Ꝋ'),
+    ('Ꝍ', 'Ꝍ'),
+    ('Ꝏ', 'Ꝏ'),
+    ('Ꝑ', 'Ꝑ'),
+    ('Ꝓ', 'Ꝓ'),
+    ('Ꝕ', 'Ꝕ'),
+    ('Ꝗ', 'Ꝗ'),
+    ('Ꝙ', 'Ꝙ'),
+    ('Ꝛ', 'Ꝛ'),
+    ('Ꝝ', 'Ꝝ'),
+    ('Ꝟ', 'Ꝟ'),
+    ('Ꝡ', 'Ꝡ'),
+    ('Ꝣ', 'Ꝣ'),
+    ('Ꝥ', 'Ꝥ'),
+    ('Ꝧ', 'Ꝧ'),
+    ('Ꝩ', 'Ꝩ'),
+    ('Ꝫ', 'Ꝫ'),
+    ('Ꝭ', 'Ꝭ'),
+    ('Ꝯ', 'Ꝯ'),
+    ('Ꝺ', 'Ꝺ'),
+    ('Ꝼ', 'Ꝼ'),
+    ('Ᵹ', 'Ꝿ'),
+    ('Ꞁ', 'Ꞁ'),
+    ('Ꞃ', 'Ꞃ'),
+    ('Ꞅ', 'Ꞅ'),
+    ('Ꞇ', 'Ꞇ'),
+    ('Ꞌ', 'Ꞌ'),
+    ('Ɥ', 'Ɥ'),
+    ('Ꞑ', 'Ꞑ'),
+    ('Ꞓ', 'Ꞓ'),
+    ('Ꞗ', 'Ꞗ'),
+    ('Ꞙ', 'Ꞙ'),
+    ('Ꞛ', 'Ꞛ'),
+    ('Ꞝ', 'Ꞝ'),
+    ('Ꞟ', 'Ꞟ'),
+    ('Ꞡ', 'Ꞡ'),
+    ('Ꞣ', 'Ꞣ'),
+    ('Ꞥ', 'Ꞥ'),
+    ('Ꞧ', 'Ꞧ'),
+    ('Ꞩ', 'Ꞩ'),
+    ('Ɦ', 'Ɪ'),
+    ('Ʞ', 'Ꞵ'),
+    ('Ꞷ', 'Ꞷ'),
+    ('Ꞹ', 'Ꞹ'),
+    ('Ꞻ', 'Ꞻ'),
+    ('Ꞽ', 'Ꞽ'),
+    ('Ꞿ', 'Ꞿ'),
+    ('Ꟁ', 'Ꟁ'),
+    ('Ꟃ', 'Ꟃ'),
+    ('Ꞔ', 'Ꟈ'),
+    ('Ꟊ', 'Ꟊ'),
+    ('Ꟑ', 'Ꟑ'),
+    ('Ꟗ', 'Ꟗ'),
+    ('Ꟙ', 'Ꟙ'),
+    ('Ꟶ', 'Ꟶ'),
+    ('ꭰ', 'ꮿ'),
+    ('ﬀ', 'ﬆ'),
+    ('ﬓ', 'ﬗ'),
+    ('Ａ', 'Ｚ'),
+    ('𐐀', '𐐧'),
+    ('𐒰', '𐓓'),
+    ('𐕰', '𐕺'),
+    ('𐕼', '𐖊'),
+    ('𐖌', '𐖒'),
+    ('𐖔', '𐖕'),
+    ('𐲀', '𐲲'),
+    ('𑢠', '𑢿'),
+    ('𖹀', '𖹟'),
+    ('𞤀', '𞤡'),
+];
+
+pub const CHANGES_WHEN_CASEMAPPED: &'static [(char, char)] = &[
+    ('A', 'Z'),
+    ('a', 'z'),
+    ('µ', 'µ'),
+    ('À', 'Ö'),
+    ('Ø', 'ö'),
+    ('ø', 'ķ'),
+    ('Ĺ', 'ƌ'),
+    ('Ǝ', 'ƚ'),
+    ('Ɯ', 'Ʃ'),
+    ('Ƭ', 'ƹ'),
+    ('Ƽ', 'ƽ'),
+    ('ƿ', 'ƿ'),
+    ('Ǆ', 'Ƞ'),
+    ('Ȣ', 'ȳ'),
+    ('Ⱥ', 'ɔ'),
+    ('ɖ', 'ɗ'),
+    ('ə', 'ə'),
+    ('ɛ', 'ɜ'),
+    ('ɠ', 'ɡ'),
+    ('ɣ', 'ɣ'),
+    ('ɥ', 'ɦ'),
+    ('ɨ', 'ɬ'),
+    ('ɯ', 'ɯ'),
+    ('ɱ', 'ɲ'),
+    ('ɵ', 'ɵ'),
+    ('ɽ', 'ɽ'),
+    ('ʀ', 'ʀ'),
+    ('ʂ', 'ʃ'),
+    ('ʇ', 'ʌ'),
+    ('ʒ', 'ʒ'),
+    ('ʝ', 'ʞ'),
+    ('\u{345}', '\u{345}'),
+    ('Ͱ', 'ͳ'),
+    ('Ͷ', 'ͷ'),
+    ('ͻ', 'ͽ'),
+    ('Ϳ', 'Ϳ'),
+    ('Ά', 'Ά'),
+    ('Έ', 'Ί'),
+    ('Ό', 'Ό'),
+    ('Ύ', 'Ρ'),
+    ('Σ', 'ϑ'),
+    ('ϕ', 'ϵ'),
+    ('Ϸ', 'ϻ'),
+    ('Ͻ', 'ҁ'),
+    ('Ҋ', 'ԯ'),
+    ('Ա', 'Ֆ'),
+    ('ա', 'և'),
+    ('Ⴀ', 'Ⴥ'),
+    ('Ⴧ', 'Ⴧ'),
+    ('Ⴭ', 'Ⴭ'),
+    ('ა', 'ჺ'),
+    ('ჽ', 'ჿ'),
+    ('Ꭰ', 'Ᏽ'),
+    ('ᏸ', 'ᏽ'),
+    ('ᲀ', 'ᲈ'),
+    ('Ა', 'Ჺ'),
+    ('Ჽ', 'Ჿ'),
+    ('ᵹ', 'ᵹ'),
+    ('ᵽ', 'ᵽ'),
+    ('ᶎ', 'ᶎ'),
+    ('Ḁ', 'ẛ'),
+    ('ẞ', 'ẞ'),
+    ('Ạ', 'ἕ'),
+    ('Ἐ', 'Ἕ'),
+    ('ἠ', 'ὅ'),
+    ('Ὀ', 'Ὅ'),
+    ('ὐ', 'ὗ'),
+    ('Ὑ', 'Ὑ'),
+    ('Ὓ', 'Ὓ'),
+    ('Ὕ', 'Ὕ'),
+    ('Ὗ', 'ώ'),
+    ('ᾀ', 'ᾴ'),
+    ('ᾶ', 'ᾼ'),
+    ('ι', 'ι'),
+    ('ῂ', 'ῄ'),
+    ('ῆ', 'ῌ'),
+    ('ῐ', 'ΐ'),
+    ('ῖ', 'Ί'),
+    ('ῠ', 'Ῥ'),
+    ('ῲ', 'ῴ'),
+    ('ῶ', 'ῼ'),
+    ('Ω', 'Ω'),
+    ('K', 'Å'),
+    ('Ⅎ', 'Ⅎ'),
+    ('ⅎ', 'ⅎ'),
+    ('Ⅰ', 'ⅿ'),
+    ('Ↄ', 'ↄ'),
+    ('Ⓐ', 'ⓩ'),
+    ('Ⰰ', 'Ɒ'),
+    ('Ⱳ', 'ⱳ'),
+    ('Ⱶ', 'ⱶ'),
+    ('Ȿ', 'ⳣ'),
+    ('Ⳬ', 'ⳮ'),
+    ('Ⳳ', 'ⳳ'),
+    ('ⴀ', 'ⴥ'),
+    ('ⴧ', 'ⴧ'),
+    ('ⴭ', 'ⴭ'),
+    ('Ꙁ', 'ꙭ'),
+    ('Ꚁ', 'ꚛ'),
+    ('Ꜣ', 'ꜯ'),
+    ('Ꜳ', 'ꝯ'),
+    ('Ꝺ', 'ꞇ'),
+    ('Ꞌ', 'Ɥ'),
+    ('Ꞑ', 'ꞔ'),
+    ('Ꞗ', 'Ɪ'),
+    ('Ʞ', 'ꟊ'),
+    ('Ꟑ', 'ꟑ'),
+    ('Ꟗ', 'ꟙ'),
+    ('Ꟶ', 'ꟶ'),
+    ('ꭓ', 'ꭓ'),
+    ('ꭰ', 'ꮿ'),
+    ('ﬀ', 'ﬆ'),
+    ('ﬓ', 'ﬗ'),
+    ('Ａ', 'Ｚ'),
+    ('ａ', 'ｚ'),
+    ('𐐀', '𐑏'),
+    ('𐒰', '𐓓'),
+    ('𐓘', '𐓻'),
+    ('𐕰', '𐕺'),
+    ('𐕼', '𐖊'),
+    ('𐖌', '𐖒'),
+    ('𐖔', '𐖕'),
+    ('𐖗', '𐖡'),
+    ('𐖣', '𐖱'),
+    ('𐖳', '𐖹'),
+    ('𐖻', '𐖼'),
+    ('𐲀', '𐲲'),
+    ('𐳀', '𐳲'),
+    ('𑢠', '𑣟'),
+    ('𖹀', '𖹿'),
+    ('𞤀', '𞥃'),
+];
+
+pub const CHANGES_WHEN_LOWERCASED: &'static [(char, char)] = &[
+    ('A', 'Z'),
+    ('À', 'Ö'),
+    ('Ø', 'Þ'),
+    ('Ā', 'Ā'),
+    ('Ă', 'Ă'),
+    ('Ą', 'Ą'),
+    ('Ć', 'Ć'),
+    ('Ĉ', 'Ĉ'),
+    ('Ċ', 'Ċ'),
+    ('Č', 'Č'),
+    ('Ď', 'Ď'),
+    ('Đ', 'Đ'),
+    ('Ē', 'Ē'),
+    ('Ĕ', 'Ĕ'),
+    ('Ė', 'Ė'),
+    ('Ę', 'Ę'),
+    ('Ě', 'Ě'),
+    ('Ĝ', 'Ĝ'),
+    ('Ğ', 'Ğ'),
+    ('Ġ', 'Ġ'),
+    ('Ģ', 'Ģ'),
+    ('Ĥ', 'Ĥ'),
+    ('Ħ', 'Ħ'),
+    ('Ĩ', 'Ĩ'),
+    ('Ī', 'Ī'),
+    ('Ĭ', 'Ĭ'),
+    ('Į', 'Į'),
+    ('İ', 'İ'),
+    ('Ĳ', 'Ĳ'),
+    ('Ĵ', 'Ĵ'),
+    ('Ķ', 'Ķ'),
+    ('Ĺ', 'Ĺ'),
+    ('Ļ', 'Ļ'),
+    ('Ľ', 'Ľ'),
+    ('Ŀ', 'Ŀ'),
+    ('Ł', 'Ł'),
+    ('Ń', 'Ń'),
+    ('Ņ', 'Ņ'),
+    ('Ň', 'Ň'),
+    ('Ŋ', 'Ŋ'),
+    ('Ō', 'Ō'),
+    ('Ŏ', 'Ŏ'),
+    ('Ő', 'Ő'),
+    ('Œ', 'Œ'),
+    ('Ŕ', 'Ŕ'),
+    ('Ŗ', 'Ŗ'),
+    ('Ř', 'Ř'),
+    ('Ś', 'Ś'),
+    ('Ŝ', 'Ŝ'),
+    ('Ş', 'Ş'),
+    ('Š', 'Š'),
+    ('Ţ', 'Ţ'),
+    ('Ť', 'Ť'),
+    ('Ŧ', 'Ŧ'),
+    ('Ũ', 'Ũ'),
+    ('Ū', 'Ū'),
+    ('Ŭ', 'Ŭ'),
+    ('Ů', 'Ů'),
+    ('Ű', 'Ű'),
+    ('Ų', 'Ų'),
+    ('Ŵ', 'Ŵ'),
+    ('Ŷ', 'Ŷ'),
+    ('Ÿ', 'Ź'),
+    ('Ż', 'Ż'),
+    ('Ž', 'Ž'),
+    ('Ɓ', 'Ƃ'),
+    ('Ƅ', 'Ƅ'),
+    ('Ɔ', 'Ƈ'),
+    ('Ɖ', 'Ƌ'),
+    ('Ǝ', 'Ƒ'),
+    ('Ɠ', 'Ɣ'),
+    ('Ɩ', 'Ƙ'),
+    ('Ɯ', 'Ɲ'),
+    ('Ɵ', 'Ơ'),
+    ('Ƣ', 'Ƣ'),
+    ('Ƥ', 'Ƥ'),
+    ('Ʀ', 'Ƨ'),
+    ('Ʃ', 'Ʃ'),
+    ('Ƭ', 'Ƭ'),
+    ('Ʈ', 'Ư'),
+    ('Ʊ', 'Ƴ'),
+    ('Ƶ', 'Ƶ'),
+    ('Ʒ', 'Ƹ'),
+    ('Ƽ', 'Ƽ'),
+    ('Ǆ', 'ǅ'),
+    ('Ǉ', 'ǈ'),
+    ('Ǌ', 'ǋ'),
+    ('Ǎ', 'Ǎ'),
+    ('Ǐ', 'Ǐ'),
+    ('Ǒ', 'Ǒ'),
+    ('Ǔ', 'Ǔ'),
+    ('Ǖ', 'Ǖ'),
+    ('Ǘ', 'Ǘ'),
+    ('Ǚ', 'Ǚ'),
+    ('Ǜ', 'Ǜ'),
+    ('Ǟ', 'Ǟ'),
+    ('Ǡ', 'Ǡ'),
+    ('Ǣ', 'Ǣ'),
+    ('Ǥ', 'Ǥ'),
+    ('Ǧ', 'Ǧ'),
+    ('Ǩ', 'Ǩ'),
+    ('Ǫ', 'Ǫ'),
+    ('Ǭ', 'Ǭ'),
+    ('Ǯ', 'Ǯ'),
+    ('Ǳ', 'ǲ'),
+    ('Ǵ', 'Ǵ'),
+    ('Ƕ', 'Ǹ'),
+    ('Ǻ', 'Ǻ'),
+    ('Ǽ', 'Ǽ'),
+    ('Ǿ', 'Ǿ'),
+    ('Ȁ', 'Ȁ'),
+    ('Ȃ', 'Ȃ'),
+    ('Ȅ', 'Ȅ'),
+    ('Ȇ', 'Ȇ'),
+    ('Ȉ', 'Ȉ'),
+    ('Ȋ', 'Ȋ'),
+    ('Ȍ', 'Ȍ'),
+    ('Ȏ', 'Ȏ'),
+    ('Ȑ', 'Ȑ'),
+    ('Ȓ', 'Ȓ'),
+    ('Ȕ', 'Ȕ'),
+    ('Ȗ', 'Ȗ'),
+    ('Ș', 'Ș'),
+    ('Ț', 'Ț'),
+    ('Ȝ', 'Ȝ'),
+    ('Ȟ', 'Ȟ'),
+    ('Ƞ', 'Ƞ'),
+    ('Ȣ', 'Ȣ'),
+    ('Ȥ', 'Ȥ'),
+    ('Ȧ', 'Ȧ'),
+    ('Ȩ', 'Ȩ'),
+    ('Ȫ', 'Ȫ'),
+    ('Ȭ', 'Ȭ'),
+    ('Ȯ', 'Ȯ'),
+    ('Ȱ', 'Ȱ'),
+    ('Ȳ', 'Ȳ'),
+    ('Ⱥ', 'Ȼ'),
+    ('Ƚ', 'Ⱦ'),
+    ('Ɂ', 'Ɂ'),
+    ('Ƀ', 'Ɇ'),
+    ('Ɉ', 'Ɉ'),
+    ('Ɋ', 'Ɋ'),
+    ('Ɍ', 'Ɍ'),
+    ('Ɏ', 'Ɏ'),
+    ('Ͱ', 'Ͱ'),
+    ('Ͳ', 'Ͳ'),
+    ('Ͷ', 'Ͷ'),
+    ('Ϳ', 'Ϳ'),
+    ('Ά', 'Ά'),
+    ('Έ', 'Ί'),
+    ('Ό', 'Ό'),
+    ('Ύ', 'Ώ'),
+    ('Α', 'Ρ'),
+    ('Σ', 'Ϋ'),
+    ('Ϗ', 'Ϗ'),
+    ('Ϙ', 'Ϙ'),
+    ('Ϛ', 'Ϛ'),
+    ('Ϝ', 'Ϝ'),
+    ('Ϟ', 'Ϟ'),
+    ('Ϡ', 'Ϡ'),
+    ('Ϣ', 'Ϣ'),
+    ('Ϥ', 'Ϥ'),
+    ('Ϧ', 'Ϧ'),
+    ('Ϩ', 'Ϩ'),
+    ('Ϫ', 'Ϫ'),
+    ('Ϭ', 'Ϭ'),
+    ('Ϯ', 'Ϯ'),
+    ('ϴ', 'ϴ'),
+    ('Ϸ', 'Ϸ'),
+    ('Ϲ', 'Ϻ'),
+    ('Ͻ', 'Я'),
+    ('Ѡ', 'Ѡ'),
+    ('Ѣ', 'Ѣ'),
+    ('Ѥ', 'Ѥ'),
+    ('Ѧ', 'Ѧ'),
+    ('Ѩ', 'Ѩ'),
+    ('Ѫ', 'Ѫ'),
+    ('Ѭ', 'Ѭ'),
+    ('Ѯ', 'Ѯ'),
+    ('Ѱ', 'Ѱ'),
+    ('Ѳ', 'Ѳ'),
+    ('Ѵ', 'Ѵ'),
+    ('Ѷ', 'Ѷ'),
+    ('Ѹ', 'Ѹ'),
+    ('Ѻ', 'Ѻ'),
+    ('Ѽ', 'Ѽ'),
+    ('Ѿ', 'Ѿ'),
+    ('Ҁ', 'Ҁ'),
+    ('Ҋ', 'Ҋ'),
+    ('Ҍ', 'Ҍ'),
+    ('Ҏ', 'Ҏ'),
+    ('Ґ', 'Ґ'),
+    ('Ғ', 'Ғ'),
+    ('Ҕ', 'Ҕ'),
+    ('Җ', 'Җ'),
+    ('Ҙ', 'Ҙ'),
+    ('Қ', 'Қ'),
+    ('Ҝ', 'Ҝ'),
+    ('Ҟ', 'Ҟ'),
+    ('Ҡ', 'Ҡ'),
+    ('Ң', 'Ң'),
+    ('Ҥ', 'Ҥ'),
+    ('Ҧ', 'Ҧ'),
+    ('Ҩ', 'Ҩ'),
+    ('Ҫ', 'Ҫ'),
+    ('Ҭ', 'Ҭ'),
+    ('Ү', 'Ү'),
+    ('Ұ', 'Ұ'),
+    ('Ҳ', 'Ҳ'),
+    ('Ҵ', 'Ҵ'),
+    ('Ҷ', 'Ҷ'),
+    ('Ҹ', 'Ҹ'),
+    ('Һ', 'Һ'),
+    ('Ҽ', 'Ҽ'),
+    ('Ҿ', 'Ҿ'),
+    ('Ӏ', 'Ӂ'),
+    ('Ӄ', 'Ӄ'),
+    ('Ӆ', 'Ӆ'),
+    ('Ӈ', 'Ӈ'),
+    ('Ӊ', 'Ӊ'),
+    ('Ӌ', 'Ӌ'),
+    ('Ӎ', 'Ӎ'),
+    ('Ӑ', 'Ӑ'),
+    ('Ӓ', 'Ӓ'),
+    ('Ӕ', 'Ӕ'),
+    ('Ӗ', 'Ӗ'),
+    ('Ә', 'Ә'),
+    ('Ӛ', 'Ӛ'),
+    ('Ӝ', 'Ӝ'),
+    ('Ӟ', 'Ӟ'),
+    ('Ӡ', 'Ӡ'),
+    ('Ӣ', 'Ӣ'),
+    ('Ӥ', 'Ӥ'),
+    ('Ӧ', 'Ӧ'),
+    ('Ө', 'Ө'),
+    ('Ӫ', 'Ӫ'),
+    ('Ӭ', 'Ӭ'),
+    ('Ӯ', 'Ӯ'),
+    ('Ӱ', 'Ӱ'),
+    ('Ӳ', 'Ӳ'),
+    ('Ӵ', 'Ӵ'),
+    ('Ӷ', 'Ӷ'),
+    ('Ӹ', 'Ӹ'),
+    ('Ӻ', 'Ӻ'),
+    ('Ӽ', 'Ӽ'),
+    ('Ӿ', 'Ӿ'),
+    ('Ԁ', 'Ԁ'),
+    ('Ԃ', 'Ԃ'),
+    ('Ԅ', 'Ԅ'),
+    ('Ԇ', 'Ԇ'),
+    ('Ԉ', 'Ԉ'),
+    ('Ԋ', 'Ԋ'),
+    ('Ԍ', 'Ԍ'),
+    ('Ԏ', 'Ԏ'),
+    ('Ԑ', 'Ԑ'),
+    ('Ԓ', 'Ԓ'),
+    ('Ԕ', 'Ԕ'),
+    ('Ԗ', 'Ԗ'),
+    ('Ԙ', 'Ԙ'),
+    ('Ԛ', 'Ԛ'),
+    ('Ԝ', 'Ԝ'),
+    ('Ԟ', 'Ԟ'),
+    ('Ԡ', 'Ԡ'),
+    ('Ԣ', 'Ԣ'),
+    ('Ԥ', 'Ԥ'),
+    ('Ԧ', 'Ԧ'),
+    ('Ԩ', 'Ԩ'),
+    ('Ԫ', 'Ԫ'),
+    ('Ԭ', 'Ԭ'),
+    ('Ԯ', 'Ԯ'),
+    ('Ա', 'Ֆ'),
+    ('Ⴀ', 'Ⴥ'),
+    ('Ⴧ', 'Ⴧ'),
+    ('Ⴭ', 'Ⴭ'),
+    ('Ꭰ', 'Ᏽ'),
+    ('Ა', 'Ჺ'),
+    ('Ჽ', 'Ჿ'),
+    ('Ḁ', 'Ḁ'),
+    ('Ḃ', 'Ḃ'),
+    ('Ḅ', 'Ḅ'),
+    ('Ḇ', 'Ḇ'),
+    ('Ḉ', 'Ḉ'),
+    ('Ḋ', 'Ḋ'),
+    ('Ḍ', 'Ḍ'),
+    ('Ḏ', 'Ḏ'),
+    ('Ḑ', 'Ḑ'),
+    ('Ḓ', 'Ḓ'),
+    ('Ḕ', 'Ḕ'),
+    ('Ḗ', 'Ḗ'),
+    ('Ḙ', 'Ḙ'),
+    ('Ḛ', 'Ḛ'),
+    ('Ḝ', 'Ḝ'),
+    ('Ḟ', 'Ḟ'),
+    ('Ḡ', 'Ḡ'),
+    ('Ḣ', 'Ḣ'),
+    ('Ḥ', 'Ḥ'),
+    ('Ḧ', 'Ḧ'),
+    ('Ḩ', 'Ḩ'),
+    ('Ḫ', 'Ḫ'),
+    ('Ḭ', 'Ḭ'),
+    ('Ḯ', 'Ḯ'),
+    ('Ḱ', 'Ḱ'),
+    ('Ḳ', 'Ḳ'),
+    ('Ḵ', 'Ḵ'),
+    ('Ḷ', 'Ḷ'),
+    ('Ḹ', 'Ḹ'),
+    ('Ḻ', 'Ḻ'),
+    ('Ḽ', 'Ḽ'),
+    ('Ḿ', 'Ḿ'),
+    ('Ṁ', 'Ṁ'),
+    ('Ṃ', 'Ṃ'),
+    ('Ṅ', 'Ṅ'),
+    ('Ṇ', 'Ṇ'),
+    ('Ṉ', 'Ṉ'),
+    ('Ṋ', 'Ṋ'),
+    ('Ṍ', 'Ṍ'),
+    ('Ṏ', 'Ṏ'),
+    ('Ṑ', 'Ṑ'),
+    ('Ṓ', 'Ṓ'),
+    ('Ṕ', 'Ṕ'),
+    ('Ṗ', 'Ṗ'),
+    ('Ṙ', 'Ṙ'),
+    ('Ṛ', 'Ṛ'),
+    ('Ṝ', 'Ṝ'),
+    ('Ṟ', 'Ṟ'),
+    ('Ṡ', 'Ṡ'),
+    ('Ṣ', 'Ṣ'),
+    ('Ṥ', 'Ṥ'),
+    ('Ṧ', 'Ṧ'),
+    ('Ṩ', 'Ṩ'),
+    ('Ṫ', 'Ṫ'),
+    ('Ṭ', 'Ṭ'),
+    ('Ṯ', 'Ṯ'),
+    ('Ṱ', 'Ṱ'),
+    ('Ṳ', 'Ṳ'),
+    ('Ṵ', 'Ṵ'),
+    ('Ṷ', 'Ṷ'),
+    ('Ṹ', 'Ṹ'),
+    ('Ṻ', 'Ṻ'),
+    ('Ṽ', 'Ṽ'),
+    ('Ṿ', 'Ṿ'),
+    ('Ẁ', 'Ẁ'),
+    ('Ẃ', 'Ẃ'),
+    ('Ẅ', 'Ẅ'),
+    ('Ẇ', 'Ẇ'),
+    ('Ẉ', 'Ẉ'),
+    ('Ẋ', 'Ẋ'),
+    ('Ẍ', 'Ẍ'),
+    ('Ẏ', 'Ẏ'),
+    ('Ẑ', 'Ẑ'),
+    ('Ẓ', 'Ẓ'),
+    ('Ẕ', 'Ẕ'),
+    ('ẞ', 'ẞ'),
+    ('Ạ', 'Ạ'),
+    ('Ả', 'Ả'),
+    ('Ấ', 'Ấ'),
+    ('Ầ', 'Ầ'),
+    ('Ẩ', 'Ẩ'),
+    ('Ẫ', 'Ẫ'),
+    ('Ậ', 'Ậ'),
+    ('Ắ', 'Ắ'),
+    ('Ằ', 'Ằ'),
+    ('Ẳ', 'Ẳ'),
+    ('Ẵ', 'Ẵ'),
+    ('Ặ', 'Ặ'),
+    ('Ẹ', 'Ẹ'),
+    ('Ẻ', 'Ẻ'),
+    ('Ẽ', 'Ẽ'),
+    ('Ế', 'Ế'),
+    ('Ề', 'Ề'),
+    ('Ể', 'Ể'),
+    ('Ễ', 'Ễ'),
+    ('Ệ', 'Ệ'),
+    ('Ỉ', 'Ỉ'),
+    ('Ị', 'Ị'),
+    ('Ọ', 'Ọ'),
+    ('Ỏ', 'Ỏ'),
+    ('Ố', 'Ố'),
+    ('Ồ', 'Ồ'),
+    ('Ổ', 'Ổ'),
+    ('Ỗ', 'Ỗ'),
+    ('Ộ', 'Ộ'),
+    ('Ớ', 'Ớ'),
+    ('Ờ', 'Ờ'),
+    ('Ở', 'Ở'),
+    ('Ỡ', 'Ỡ'),
+    ('Ợ', 'Ợ'),
+    ('Ụ', 'Ụ'),
+    ('Ủ', 'Ủ'),
+    ('Ứ', 'Ứ'),
+    ('Ừ', 'Ừ'),
+    ('Ử', 'Ử'),
+    ('Ữ', 'Ữ'),
+    ('Ự', 'Ự'),
+    ('Ỳ', 'Ỳ'),
+    ('Ỵ', 'Ỵ'),
+    ('Ỷ', 'Ỷ'),
+    ('Ỹ', 'Ỹ'),
+    ('Ỻ', 'Ỻ'),
+    ('Ỽ', 'Ỽ'),
+    ('Ỿ', 'Ỿ'),
+    ('Ἀ', 'Ἇ'),
+    ('Ἐ', 'Ἕ'),
+    ('Ἠ', 'Ἧ'),
+    ('Ἰ', 'Ἷ'),
+    ('Ὀ', 'Ὅ'),
+    ('Ὑ', 'Ὑ'),
+    ('Ὓ', 'Ὓ'),
+    ('Ὕ', 'Ὕ'),
+    ('Ὗ', 'Ὗ'),
+    ('Ὠ', 'Ὧ'),
+    ('ᾈ', 'ᾏ'),
+    ('ᾘ', 'ᾟ'),
+    ('ᾨ', 'ᾯ'),
+    ('Ᾰ', 'ᾼ'),
+    ('Ὲ', 'ῌ'),
+    ('Ῐ', 'Ί'),
+    ('Ῠ', 'Ῥ'),
+    ('Ὸ', 'ῼ'),
+    ('Ω', 'Ω'),
+    ('K', 'Å'),
+    ('Ⅎ', 'Ⅎ'),
+    ('Ⅰ', 'Ⅿ'),
+    ('Ↄ', 'Ↄ'),
+    ('Ⓐ', 'Ⓩ'),
+    ('Ⰰ', 'Ⱟ'),
+    ('Ⱡ', 'Ⱡ'),
+    ('Ɫ', 'Ɽ'),
+    ('Ⱨ', 'Ⱨ'),
+    ('Ⱪ', 'Ⱪ'),
+    ('Ⱬ', 'Ⱬ'),
+    ('Ɑ', 'Ɒ'),
+    ('Ⱳ', 'Ⱳ'),
+    ('Ⱶ', 'Ⱶ'),
+    ('Ȿ', 'Ⲁ'),
+    ('Ⲃ', 'Ⲃ'),
+    ('Ⲅ', 'Ⲅ'),
+    ('Ⲇ', 'Ⲇ'),
+    ('Ⲉ', 'Ⲉ'),
+    ('Ⲋ', 'Ⲋ'),
+    ('Ⲍ', 'Ⲍ'),
+    ('Ⲏ', 'Ⲏ'),
+    ('Ⲑ', 'Ⲑ'),
+    ('Ⲓ', 'Ⲓ'),
+    ('Ⲕ', 'Ⲕ'),
+    ('Ⲗ', 'Ⲗ'),
+    ('Ⲙ', 'Ⲙ'),
+    ('Ⲛ', 'Ⲛ'),
+    ('Ⲝ', 'Ⲝ'),
+    ('Ⲟ', 'Ⲟ'),
+    ('Ⲡ', 'Ⲡ'),
+    ('Ⲣ', 'Ⲣ'),
+    ('Ⲥ', 'Ⲥ'),
+    ('Ⲧ', 'Ⲧ'),
+    ('Ⲩ', 'Ⲩ'),
+    ('Ⲫ', 'Ⲫ'),
+    ('Ⲭ', 'Ⲭ'),
+    ('Ⲯ', 'Ⲯ'),
+    ('Ⲱ', 'Ⲱ'),
+    ('Ⲳ', 'Ⲳ'),
+    ('Ⲵ', 'Ⲵ'),
+    ('Ⲷ', 'Ⲷ'),
+    ('Ⲹ', 'Ⲹ'),
+    ('Ⲻ', 'Ⲻ'),
+    ('Ⲽ', 'Ⲽ'),
+    ('Ⲿ', 'Ⲿ'),
+    ('Ⳁ', 'Ⳁ'),
+    ('Ⳃ', 'Ⳃ'),
+    ('Ⳅ', 'Ⳅ'),
+    ('Ⳇ', 'Ⳇ'),
+    ('Ⳉ', 'Ⳉ'),
+    ('Ⳋ', 'Ⳋ'),
+    ('Ⳍ', 'Ⳍ'),
+    ('Ⳏ', 'Ⳏ'),
+    ('Ⳑ', 'Ⳑ'),
+    ('Ⳓ', 'Ⳓ'),
+    ('Ⳕ', 'Ⳕ'),
+    ('Ⳗ', 'Ⳗ'),
+    ('Ⳙ', 'Ⳙ'),
+    ('Ⳛ', 'Ⳛ'),
+    ('Ⳝ', 'Ⳝ'),
+    ('Ⳟ', 'Ⳟ'),
+    ('Ⳡ', 'Ⳡ'),
+    ('Ⳣ', 'Ⳣ'),
+    ('Ⳬ', 'Ⳬ'),
+    ('Ⳮ', 'Ⳮ'),
+    ('Ⳳ', 'Ⳳ'),
+    ('Ꙁ', 'Ꙁ'),
+    ('Ꙃ', 'Ꙃ'),
+    ('Ꙅ', 'Ꙅ'),
+    ('Ꙇ', 'Ꙇ'),
+    ('Ꙉ', 'Ꙉ'),
+    ('Ꙋ', 'Ꙋ'),
+    ('Ꙍ', 'Ꙍ'),
+    ('Ꙏ', 'Ꙏ'),
+    ('Ꙑ', 'Ꙑ'),
+    ('Ꙓ', 'Ꙓ'),
+    ('Ꙕ', 'Ꙕ'),
+    ('Ꙗ', 'Ꙗ'),
+    ('Ꙙ', 'Ꙙ'),
+    ('Ꙛ', 'Ꙛ'),
+    ('Ꙝ', 'Ꙝ'),
+    ('Ꙟ', 'Ꙟ'),
+    ('Ꙡ', 'Ꙡ'),
+    ('Ꙣ', 'Ꙣ'),
+    ('Ꙥ', 'Ꙥ'),
+    ('Ꙧ', 'Ꙧ'),
+    ('Ꙩ', 'Ꙩ'),
+    ('Ꙫ', 'Ꙫ'),
+    ('Ꙭ', 'Ꙭ'),
+    ('Ꚁ', 'Ꚁ'),
+    ('Ꚃ', 'Ꚃ'),
+    ('Ꚅ', 'Ꚅ'),
+    ('Ꚇ', 'Ꚇ'),
+    ('Ꚉ', 'Ꚉ'),
+    ('Ꚋ', 'Ꚋ'),
+    ('Ꚍ', 'Ꚍ'),
+    ('Ꚏ', 'Ꚏ'),
+    ('Ꚑ', 'Ꚑ'),
+    ('Ꚓ', 'Ꚓ'),
+    ('Ꚕ', 'Ꚕ'),
+    ('Ꚗ', 'Ꚗ'),
+    ('Ꚙ', 'Ꚙ'),
+    ('Ꚛ', 'Ꚛ'),
+    ('Ꜣ', 'Ꜣ'),
+    ('Ꜥ', 'Ꜥ'),
+    ('Ꜧ', 'Ꜧ'),
+    ('Ꜩ', 'Ꜩ'),
+    ('Ꜫ', 'Ꜫ'),
+    ('Ꜭ', 'Ꜭ'),
+    ('Ꜯ', 'Ꜯ'),
+    ('Ꜳ', 'Ꜳ'),
+    ('Ꜵ', 'Ꜵ'),
+    ('Ꜷ', 'Ꜷ'),
+    ('Ꜹ', 'Ꜹ'),
+    ('Ꜻ', 'Ꜻ'),
+    ('Ꜽ', 'Ꜽ'),
+    ('Ꜿ', 'Ꜿ'),
+    ('Ꝁ', 'Ꝁ'),
+    ('Ꝃ', 'Ꝃ'),
+    ('Ꝅ', 'Ꝅ'),
+    ('Ꝇ', 'Ꝇ'),
+    ('Ꝉ', 'Ꝉ'),
+    ('Ꝋ', 'Ꝋ'),
+    ('Ꝍ', 'Ꝍ'),
+    ('Ꝏ', 'Ꝏ'),
+    ('Ꝑ', 'Ꝑ'),
+    ('Ꝓ', 'Ꝓ'),
+    ('Ꝕ', 'Ꝕ'),
+    ('Ꝗ', 'Ꝗ'),
+    ('Ꝙ', 'Ꝙ'),
+    ('Ꝛ', 'Ꝛ'),
+    ('Ꝝ', 'Ꝝ'),
+    ('Ꝟ', 'Ꝟ'),
+    ('Ꝡ', 'Ꝡ'),
+    ('Ꝣ', 'Ꝣ'),
+    ('Ꝥ', 'Ꝥ'),
+    ('Ꝧ', 'Ꝧ'),
+    ('Ꝩ', 'Ꝩ'),
+    ('Ꝫ', 'Ꝫ'),
+    ('Ꝭ', 'Ꝭ'),
+    ('Ꝯ', 'Ꝯ'),
+    ('Ꝺ', 'Ꝺ'),
+    ('Ꝼ', 'Ꝼ'),
+    ('Ᵹ', 'Ꝿ'),
+    ('Ꞁ', 'Ꞁ'),
+    ('Ꞃ', 'Ꞃ'),
+    ('Ꞅ', 'Ꞅ'),
+    ('Ꞇ', 'Ꞇ'),
+    ('Ꞌ', 'Ꞌ'),
+    ('Ɥ', 'Ɥ'),
+    ('Ꞑ', 'Ꞑ'),
+    ('Ꞓ', 'Ꞓ'),
+    ('Ꞗ', 'Ꞗ'),
+    ('Ꞙ', 'Ꞙ'),
+    ('Ꞛ', 'Ꞛ'),
+    ('Ꞝ', 'Ꞝ'),
+    ('Ꞟ', 'Ꞟ'),
+    ('Ꞡ', 'Ꞡ'),
+    ('Ꞣ', 'Ꞣ'),
+    ('Ꞥ', 'Ꞥ'),
+    ('Ꞧ', 'Ꞧ'),
+    ('Ꞩ', 'Ꞩ'),
+    ('Ɦ', 'Ɪ'),
+    ('Ʞ', 'Ꞵ'),
+    ('Ꞷ', 'Ꞷ'),
+    ('Ꞹ', 'Ꞹ'),
+    ('Ꞻ', 'Ꞻ'),
+    ('Ꞽ', 'Ꞽ'),
+    ('Ꞿ', 'Ꞿ'),
+    ('Ꟁ', 'Ꟁ'),
+    ('Ꟃ', 'Ꟃ'),
+    ('Ꞔ', 'Ꟈ'),
+    ('Ꟊ', 'Ꟊ'),
+    ('Ꟑ', 'Ꟑ'),
+    ('Ꟗ', 'Ꟗ'),
+    ('Ꟙ', 'Ꟙ'),
+    ('Ꟶ', 'Ꟶ'),
+    ('Ａ', 'Ｚ'),
+    ('𐐀', '𐐧'),
+    ('𐒰', '𐓓'),
+    ('𐕰', '𐕺'),
+    ('𐕼', '𐖊'),
+    ('𐖌', '𐖒'),
+    ('𐖔', '𐖕'),
+    ('𐲀', '𐲲'),
+    ('𑢠', '𑢿'),
+    ('𖹀', '𖹟'),
+    ('𞤀', '𞤡'),
+];
+
+pub const CHANGES_WHEN_TITLECASED: &'static [(char, char)] = &[
+    ('a', 'z'),
+    ('µ', 'µ'),
+    ('ß', 'ö'),
+    ('ø', 'ÿ'),
+    ('ā', 'ā'),
+    ('ă', 'ă'),
+    ('ą', 'ą'),
+    ('ć', 'ć'),
+    ('ĉ', 'ĉ'),
+    ('ċ', 'ċ'),
+    ('č', 'č'),
+    ('ď', 'ď'),
+    ('đ', 'đ'),
+    ('ē', 'ē'),
+    ('ĕ', 'ĕ'),
+    ('ė', 'ė'),
+    ('ę', 'ę'),
+    ('ě', 'ě'),
+    ('ĝ', 'ĝ'),
+    ('ğ', 'ğ'),
+    ('ġ', 'ġ'),
+    ('ģ', 'ģ'),
+    ('ĥ', 'ĥ'),
+    ('ħ', 'ħ'),
+    ('ĩ', 'ĩ'),
+    ('ī', 'ī'),
+    ('ĭ', 'ĭ'),
+    ('į', 'į'),
+    ('ı', 'ı'),
+    ('ĳ', 'ĳ'),
+    ('ĵ', 'ĵ'),
+    ('ķ', 'ķ'),
+    ('ĺ', 'ĺ'),
+    ('ļ', 'ļ'),
+    ('ľ', 'ľ'),
+    ('ŀ', 'ŀ'),
+    ('ł', 'ł'),
+    ('ń', 'ń'),
+    ('ņ', 'ņ'),
+    ('ň', 'ŉ'),
+    ('ŋ', 'ŋ'),
+    ('ō', 'ō'),
+    ('ŏ', 'ŏ'),
+    ('ő', 'ő'),
+    ('œ', 'œ'),
+    ('ŕ', 'ŕ'),
+    ('ŗ', 'ŗ'),
+    ('ř', 'ř'),
+    ('ś', 'ś'),
+    ('ŝ', 'ŝ'),
+    ('ş', 'ş'),
+    ('š', 'š'),
+    ('ţ', 'ţ'),
+    ('ť', 'ť'),
+    ('ŧ', 'ŧ'),
+    ('ũ', 'ũ'),
+    ('ū', 'ū'),
+    ('ŭ', 'ŭ'),
+    ('ů', 'ů'),
+    ('ű', 'ű'),
+    ('ų', 'ų'),
+    ('ŵ', 'ŵ'),
+    ('ŷ', 'ŷ'),
+    ('ź', 'ź'),
+    ('ż', 'ż'),
+    ('ž', 'ƀ'),
+    ('ƃ', 'ƃ'),
+    ('ƅ', 'ƅ'),
+    ('ƈ', 'ƈ'),
+    ('ƌ', 'ƌ'),
+    ('ƒ', 'ƒ'),
+    ('ƕ', 'ƕ'),
+    ('ƙ', 'ƚ'),
+    ('ƞ', 'ƞ'),
+    ('ơ', 'ơ'),
+    ('ƣ', 'ƣ'),
+    ('ƥ', 'ƥ'),
+    ('ƨ', 'ƨ'),
+    ('ƭ', 'ƭ'),
+    ('ư', 'ư'),
+    ('ƴ', 'ƴ'),
+    ('ƶ', 'ƶ'),
+    ('ƹ', 'ƹ'),
+    ('ƽ', 'ƽ'),
+    ('ƿ', 'ƿ'),
+    ('Ǆ', 'Ǆ'),
+    ('ǆ', 'Ǉ'),
+    ('ǉ', 'Ǌ'),
+    ('ǌ', 'ǌ'),
+    ('ǎ', 'ǎ'),
+    ('ǐ', 'ǐ'),
+    ('ǒ', 'ǒ'),
+    ('ǔ', 'ǔ'),
+    ('ǖ', 'ǖ'),
+    ('ǘ', 'ǘ'),
+    ('ǚ', 'ǚ'),
+    ('ǜ', 'ǝ'),
+    ('ǟ', 'ǟ'),
+    ('ǡ', 'ǡ'),
+    ('ǣ', 'ǣ'),
+    ('ǥ', 'ǥ'),
+    ('ǧ', 'ǧ'),
+    ('ǩ', 'ǩ'),
+    ('ǫ', 'ǫ'),
+    ('ǭ', 'ǭ'),
+    ('ǯ', 'Ǳ'),
+    ('ǳ', 'ǳ'),
+    ('ǵ', 'ǵ'),
+    ('ǹ', 'ǹ'),
+    ('ǻ', 'ǻ'),
+    ('ǽ', 'ǽ'),
+    ('ǿ', 'ǿ'),
+    ('ȁ', 'ȁ'),
+    ('ȃ', 'ȃ'),
+    ('ȅ', 'ȅ'),
+    ('ȇ', 'ȇ'),
+    ('ȉ', 'ȉ'),
+    ('ȋ', 'ȋ'),
+    ('ȍ', 'ȍ'),
+    ('ȏ', 'ȏ'),
+    ('ȑ', 'ȑ'),
+    ('ȓ', 'ȓ'),
+    ('ȕ', 'ȕ'),
+    ('ȗ', 'ȗ'),
+    ('ș', 'ș'),
+    ('ț', 'ț'),
+    ('ȝ', 'ȝ'),
+    ('ȟ', 'ȟ'),
+    ('ȣ', 'ȣ'),
+    ('ȥ', 'ȥ'),
+    ('ȧ', 'ȧ'),
+    ('ȩ', 'ȩ'),
+    ('ȫ', 'ȫ'),
+    ('ȭ', 'ȭ'),
+    ('ȯ', 'ȯ'),
+    ('ȱ', 'ȱ'),
+    ('ȳ', 'ȳ'),
+    ('ȼ', 'ȼ'),
+    ('ȿ', 'ɀ'),
+    ('ɂ', 'ɂ'),
+    ('ɇ', 'ɇ'),
+    ('ɉ', 'ɉ'),
+    ('ɋ', 'ɋ'),
+    ('ɍ', 'ɍ'),
+    ('ɏ', 'ɔ'),
+    ('ɖ', 'ɗ'),
+    ('ə', 'ə'),
+    ('ɛ', 'ɜ'),
+    ('ɠ', 'ɡ'),
+    ('ɣ', 'ɣ'),
+    ('ɥ', 'ɦ'),
+    ('ɨ', 'ɬ'),
+    ('ɯ', 'ɯ'),
+    ('ɱ', 'ɲ'),
+    ('ɵ', 'ɵ'),
+    ('ɽ', 'ɽ'),
+    ('ʀ', 'ʀ'),
+    ('ʂ', 'ʃ'),
+    ('ʇ', 'ʌ'),
+    ('ʒ', 'ʒ'),
+    ('ʝ', 'ʞ'),
+    ('\u{345}', '\u{345}'),
+    ('ͱ', 'ͱ'),
+    ('ͳ', 'ͳ'),
+    ('ͷ', 'ͷ'),
+    ('ͻ', 'ͽ'),
+    ('ΐ', 'ΐ'),
+    ('ά', 'ώ'),
+    ('ϐ', 'ϑ'),
+    ('ϕ', 'ϗ'),
+    ('ϙ', 'ϙ'),
+    ('ϛ', 'ϛ'),
+    ('ϝ', 'ϝ'),
+    ('ϟ', 'ϟ'),
+    ('ϡ', 'ϡ'),
+    ('ϣ', 'ϣ'),
+    ('ϥ', 'ϥ'),
+    ('ϧ', 'ϧ'),
+    ('ϩ', 'ϩ'),
+    ('ϫ', 'ϫ'),
+    ('ϭ', 'ϭ'),
+    ('ϯ', 'ϳ'),
+    ('ϵ', 'ϵ'),
+    ('ϸ', 'ϸ'),
+    ('ϻ', 'ϻ'),
+    ('а', 'џ'),
+    ('ѡ', 'ѡ'),
+    ('ѣ', 'ѣ'),
+    ('ѥ', 'ѥ'),
+    ('ѧ', 'ѧ'),
+    ('ѩ', 'ѩ'),
+    ('ѫ', 'ѫ'),
+    ('ѭ', 'ѭ'),
+    ('ѯ', 'ѯ'),
+    ('ѱ', 'ѱ'),
+    ('ѳ', 'ѳ'),
+    ('ѵ', 'ѵ'),
+    ('ѷ', 'ѷ'),
+    ('ѹ', 'ѹ'),
+    ('ѻ', 'ѻ'),
+    ('ѽ', 'ѽ'),
+    ('ѿ', 'ѿ'),
+    ('ҁ', 'ҁ'),
+    ('ҋ', 'ҋ'),
+    ('ҍ', 'ҍ'),
+    ('ҏ', 'ҏ'),
+    ('ґ', 'ґ'),
+    ('ғ', 'ғ'),
+    ('ҕ', 'ҕ'),
+    ('җ', 'җ'),
+    ('ҙ', 'ҙ'),
+    ('қ', 'қ'),
+    ('ҝ', 'ҝ'),
+    ('ҟ', 'ҟ'),
+    ('ҡ', 'ҡ'),
+    ('ң', 'ң'),
+    ('ҥ', 'ҥ'),
+    ('ҧ', 'ҧ'),
+    ('ҩ', 'ҩ'),
+    ('ҫ', 'ҫ'),
+    ('ҭ', 'ҭ'),
+    ('ү', 'ү'),
+    ('ұ', 'ұ'),
+    ('ҳ', 'ҳ'),
+    ('ҵ', 'ҵ'),
+    ('ҷ', 'ҷ'),
+    ('ҹ', 'ҹ'),
+    ('һ', 'һ'),
+    ('ҽ', 'ҽ'),
+    ('ҿ', 'ҿ'),
+    ('ӂ', 'ӂ'),
+    ('ӄ', 'ӄ'),
+    ('ӆ', 'ӆ'),
+    ('ӈ', 'ӈ'),
+    ('ӊ', 'ӊ'),
+    ('ӌ', 'ӌ'),
+    ('ӎ', 'ӏ'),
+    ('ӑ', 'ӑ'),
+    ('ӓ', 'ӓ'),
+    ('ӕ', 'ӕ'),
+    ('ӗ', 'ӗ'),
+    ('ә', 'ә'),
+    ('ӛ', 'ӛ'),
+    ('ӝ', 'ӝ'),
+    ('ӟ', 'ӟ'),
+    ('ӡ', 'ӡ'),
+    ('ӣ', 'ӣ'),
+    ('ӥ', 'ӥ'),
+    ('ӧ', 'ӧ'),
+    ('ө', 'ө'),
+    ('ӫ', 'ӫ'),
+    ('ӭ', 'ӭ'),
+    ('ӯ', 'ӯ'),
+    ('ӱ', 'ӱ'),
+    ('ӳ', 'ӳ'),
+    ('ӵ', 'ӵ'),
+    ('ӷ', 'ӷ'),
+    ('ӹ', 'ӹ'),
+    ('ӻ', 'ӻ'),
+    ('ӽ', 'ӽ'),
+    ('ӿ', 'ӿ'),
+    ('ԁ', 'ԁ'),
+    ('ԃ', 'ԃ'),
+    ('ԅ', 'ԅ'),
+    ('ԇ', 'ԇ'),
+    ('ԉ', 'ԉ'),
+    ('ԋ', 'ԋ'),
+    ('ԍ', 'ԍ'),
+    ('ԏ', 'ԏ'),
+    ('ԑ', 'ԑ'),
+    ('ԓ', 'ԓ'),
+    ('ԕ', 'ԕ'),
+    ('ԗ', 'ԗ'),
+    ('ԙ', 'ԙ'),
+    ('ԛ', 'ԛ'),
+    ('ԝ', 'ԝ'),
+    ('ԟ', 'ԟ'),
+    ('ԡ', 'ԡ'),
+    ('ԣ', 'ԣ'),
+    ('ԥ', 'ԥ'),
+    ('ԧ', 'ԧ'),
+    ('ԩ', 'ԩ'),
+    ('ԫ', 'ԫ'),
+    ('ԭ', 'ԭ'),
+    ('ԯ', 'ԯ'),
+    ('ա', 'և'),
+    ('ᏸ', 'ᏽ'),
+    ('ᲀ', 'ᲈ'),
+    ('ᵹ', 'ᵹ'),
+    ('ᵽ', 'ᵽ'),
+    ('ᶎ', 'ᶎ'),
+    ('ḁ', 'ḁ'),
+    ('ḃ', 'ḃ'),
+    ('ḅ', 'ḅ'),
+    ('ḇ', 'ḇ'),
+    ('ḉ', 'ḉ'),
+    ('ḋ', 'ḋ'),
+    ('ḍ', 'ḍ'),
+    ('ḏ', 'ḏ'),
+    ('ḑ', 'ḑ'),
+    ('ḓ', 'ḓ'),
+    ('ḕ', 'ḕ'),
+    ('ḗ', 'ḗ'),
+    ('ḙ', 'ḙ'),
+    ('ḛ', 'ḛ'),
+    ('ḝ', 'ḝ'),
+    ('ḟ', 'ḟ'),
+    ('ḡ', 'ḡ'),
+    ('ḣ', 'ḣ'),
+    ('ḥ', 'ḥ'),
+    ('ḧ', 'ḧ'),
+    ('ḩ', 'ḩ'),
+    ('ḫ', 'ḫ'),
+    ('ḭ', 'ḭ'),
+    ('ḯ', 'ḯ'),
+    ('ḱ', 'ḱ'),
+    ('ḳ', 'ḳ'),
+    ('ḵ', 'ḵ'),
+    ('ḷ', 'ḷ'),
+    ('ḹ', 'ḹ'),
+    ('ḻ', 'ḻ'),
+    ('ḽ', 'ḽ'),
+    ('ḿ', 'ḿ'),
+    ('ṁ', 'ṁ'),
+    ('ṃ', 'ṃ'),
+    ('ṅ', 'ṅ'),
+    ('ṇ', 'ṇ'),
+    ('ṉ', 'ṉ'),
+    ('ṋ', 'ṋ'),
+    ('ṍ', 'ṍ'),
+    ('ṏ', 'ṏ'),
+    ('ṑ', 'ṑ'),
+    ('ṓ', 'ṓ'),
+    ('ṕ', 'ṕ'),
+    ('ṗ', 'ṗ'),
+    ('ṙ', 'ṙ'),
+    ('ṛ', 'ṛ'),
+    ('ṝ', 'ṝ'),
+    ('ṟ', 'ṟ'),
+    ('ṡ', 'ṡ'),
+    ('ṣ', 'ṣ'),
+    ('ṥ', 'ṥ'),
+    ('ṧ', 'ṧ'),
+    ('ṩ', 'ṩ'),
+    ('ṫ', 'ṫ'),
+    ('ṭ', 'ṭ'),
+    ('ṯ', 'ṯ'),
+    ('ṱ', 'ṱ'),
+    ('ṳ', 'ṳ'),
+    ('ṵ', 'ṵ'),
+    ('ṷ', 'ṷ'),
+    ('ṹ', 'ṹ'),
+    ('ṻ', 'ṻ'),
+    ('ṽ', 'ṽ'),
+    ('ṿ', 'ṿ'),
+    ('ẁ', 'ẁ'),
+    ('ẃ', 'ẃ'),
+    ('ẅ', 'ẅ'),
+    ('ẇ', 'ẇ'),
+    ('ẉ', 'ẉ'),
+    ('ẋ', 'ẋ'),
+    ('ẍ', 'ẍ'),
+    ('ẏ', 'ẏ'),
+    ('ẑ', 'ẑ'),
+    ('ẓ', 'ẓ'),
+    ('ẕ', 'ẛ'),
+    ('ạ', 'ạ'),
+    ('ả', 'ả'),
+    ('ấ', 'ấ'),
+    ('ầ', 'ầ'),
+    ('ẩ', 'ẩ'),
+    ('ẫ', 'ẫ'),
+    ('ậ', 'ậ'),
+    ('ắ', 'ắ'),
+    ('ằ', 'ằ'),
+    ('ẳ', 'ẳ'),
+    ('ẵ', 'ẵ'),
+    ('ặ', 'ặ'),
+    ('ẹ', 'ẹ'),
+    ('ẻ', 'ẻ'),
+    ('ẽ', 'ẽ'),
+    ('ế', 'ế'),
+    ('ề', 'ề'),
+    ('ể', 'ể'),
+    ('ễ', 'ễ'),
+    ('ệ', 'ệ'),
+    ('ỉ', 'ỉ'),
+    ('ị', 'ị'),
+    ('ọ', 'ọ'),
+    ('ỏ', 'ỏ'),
+    ('ố', 'ố'),
+    ('ồ', 'ồ'),
+    ('ổ', 'ổ'),
+    ('ỗ', 'ỗ'),
+    ('ộ', 'ộ'),
+    ('ớ', 'ớ'),
+    ('ờ', 'ờ'),
+    ('ở', 'ở'),
+    ('ỡ', 'ỡ'),
+    ('ợ', 'ợ'),
+    ('ụ', 'ụ'),
+    ('ủ', 'ủ'),
+    ('ứ', 'ứ'),
+    ('ừ', 'ừ'),
+    ('ử', 'ử'),
+    ('ữ', 'ữ'),
+    ('ự', 'ự'),
+    ('ỳ', 'ỳ'),
+    ('ỵ', 'ỵ'),
+    ('ỷ', 'ỷ'),
+    ('ỹ', 'ỹ'),
+    ('ỻ', 'ỻ'),
+    ('ỽ', 'ỽ'),
+    ('ỿ', 'ἇ'),
+    ('ἐ', 'ἕ'),
+    ('ἠ', 'ἧ'),
+    ('ἰ', 'ἷ'),
+    ('ὀ', 'ὅ'),
+    ('ὐ', 'ὗ'),
+    ('ὠ', 'ὧ'),
+    ('ὰ', 'ώ'),
+    ('ᾀ', 'ᾇ'),
+    ('ᾐ', 'ᾗ'),
+    ('ᾠ', 'ᾧ'),
+    ('ᾰ', 'ᾴ'),
+    ('ᾶ', 'ᾷ'),
+    ('ι', 'ι'),
+    ('ῂ', 'ῄ'),
+    ('ῆ', 'ῇ'),
+    ('ῐ', 'ΐ'),
+    ('ῖ', 'ῗ'),
+    ('ῠ', 'ῧ'),
+    ('ῲ', 'ῴ'),
+    ('ῶ', 'ῷ'),
+    ('ⅎ', 'ⅎ'),
+    ('ⅰ', 'ⅿ'),
+    ('ↄ', 'ↄ'),
+    ('ⓐ', 'ⓩ'),
+    ('ⰰ', 'ⱟ'),
+    ('ⱡ', 'ⱡ'),
+    ('ⱥ', 'ⱦ'),
+    ('ⱨ', 'ⱨ'),
+    ('ⱪ', 'ⱪ'),
+    ('ⱬ', 'ⱬ'),
+    ('ⱳ', 'ⱳ'),
+    ('ⱶ', 'ⱶ'),
+    ('ⲁ', 'ⲁ'),
+    ('ⲃ', 'ⲃ'),
+    ('ⲅ', 'ⲅ'),
+    ('ⲇ', 'ⲇ'),
+    ('ⲉ', 'ⲉ'),
+    ('ⲋ', 'ⲋ'),
+    ('ⲍ', 'ⲍ'),
+    ('ⲏ', 'ⲏ'),
+    ('ⲑ', 'ⲑ'),
+    ('ⲓ', 'ⲓ'),
+    ('ⲕ', 'ⲕ'),
+    ('ⲗ', 'ⲗ'),
+    ('ⲙ', 'ⲙ'),
+    ('ⲛ', 'ⲛ'),
+    ('ⲝ', 'ⲝ'),
+    ('ⲟ', 'ⲟ'),
+    ('ⲡ', 'ⲡ'),
+    ('ⲣ', 'ⲣ'),
+    ('ⲥ', 'ⲥ'),
+    ('ⲧ', 'ⲧ'),
+    ('ⲩ', 'ⲩ'),
+    ('ⲫ', 'ⲫ'),
+    ('ⲭ', 'ⲭ'),
+    ('ⲯ', 'ⲯ'),
+    ('ⲱ', 'ⲱ'),
+    ('ⲳ', 'ⲳ'),
+    ('ⲵ', 'ⲵ'),
+    ('ⲷ', 'ⲷ'),
+    ('ⲹ', 'ⲹ'),
+    ('ⲻ', 'ⲻ'),
+    ('ⲽ', 'ⲽ'),
+    ('ⲿ', 'ⲿ'),
+    ('ⳁ', 'ⳁ'),
+    ('ⳃ', 'ⳃ'),
+    ('ⳅ', 'ⳅ'),
+    ('ⳇ', 'ⳇ'),
+    ('ⳉ', 'ⳉ'),
+    ('ⳋ', 'ⳋ'),
+    ('ⳍ', 'ⳍ'),
+    ('ⳏ', 'ⳏ'),
+    ('ⳑ', 'ⳑ'),
+    ('ⳓ', 'ⳓ'),
+    ('ⳕ', 'ⳕ'),
+    ('ⳗ', 'ⳗ'),
+    ('ⳙ', 'ⳙ'),
+    ('ⳛ', 'ⳛ'),
+    ('ⳝ', 'ⳝ'),
+    ('ⳟ', 'ⳟ'),
+    ('ⳡ', 'ⳡ'),
+    ('ⳣ', 'ⳣ'),
+    ('ⳬ', 'ⳬ'),
+    ('ⳮ', 'ⳮ'),
+    ('ⳳ', 'ⳳ'),
+    ('ⴀ', 'ⴥ'),
+    ('ⴧ', 'ⴧ'),
+    ('ⴭ', 'ⴭ'),
+    ('ꙁ', 'ꙁ'),
+    ('ꙃ', 'ꙃ'),
+    ('ꙅ', 'ꙅ'),
+    ('ꙇ', 'ꙇ'),
+    ('ꙉ', 'ꙉ'),
+    ('ꙋ', 'ꙋ'),
+    ('ꙍ', 'ꙍ'),
+    ('ꙏ', 'ꙏ'),
+    ('ꙑ', 'ꙑ'),
+    ('ꙓ', 'ꙓ'),
+    ('ꙕ', 'ꙕ'),
+    ('ꙗ', 'ꙗ'),
+    ('ꙙ', 'ꙙ'),
+    ('ꙛ', 'ꙛ'),
+    ('ꙝ', 'ꙝ'),
+    ('ꙟ', 'ꙟ'),
+    ('ꙡ', 'ꙡ'),
+    ('ꙣ', 'ꙣ'),
+    ('ꙥ', 'ꙥ'),
+    ('ꙧ', 'ꙧ'),
+    ('ꙩ', 'ꙩ'),
+    ('ꙫ', 'ꙫ'),
+    ('ꙭ', 'ꙭ'),
+    ('ꚁ', 'ꚁ'),
+    ('ꚃ', 'ꚃ'),
+    ('ꚅ', 'ꚅ'),
+    ('ꚇ', 'ꚇ'),
+    ('ꚉ', 'ꚉ'),
+    ('ꚋ', 'ꚋ'),
+    ('ꚍ', 'ꚍ'),
+    ('ꚏ', 'ꚏ'),
+    ('ꚑ', 'ꚑ'),
+    ('ꚓ', 'ꚓ'),
+    ('ꚕ', 'ꚕ'),
+    ('ꚗ', 'ꚗ'),
+    ('ꚙ', 'ꚙ'),
+    ('ꚛ', 'ꚛ'),
+    ('ꜣ', 'ꜣ'),
+    ('ꜥ', 'ꜥ'),
+    ('ꜧ', 'ꜧ'),
+    ('ꜩ', 'ꜩ'),
+    ('ꜫ', 'ꜫ'),
+    ('ꜭ', 'ꜭ'),
+    ('ꜯ', 'ꜯ'),
+    ('ꜳ', 'ꜳ'),
+    ('ꜵ', 'ꜵ'),
+    ('ꜷ', 'ꜷ'),
+    ('ꜹ', 'ꜹ'),
+    ('ꜻ', 'ꜻ'),
+    ('ꜽ', 'ꜽ'),
+    ('ꜿ', 'ꜿ'),
+    ('ꝁ', 'ꝁ'),
+    ('ꝃ', 'ꝃ'),
+    ('ꝅ', 'ꝅ'),
+    ('ꝇ', 'ꝇ'),
+    ('ꝉ', 'ꝉ'),
+    ('ꝋ', 'ꝋ'),
+    ('ꝍ', 'ꝍ'),
+    ('ꝏ', 'ꝏ'),
+    ('ꝑ', 'ꝑ'),
+    ('ꝓ', 'ꝓ'),
+    ('ꝕ', 'ꝕ'),
+    ('ꝗ', 'ꝗ'),
+    ('ꝙ', 'ꝙ'),
+    ('ꝛ', 'ꝛ'),
+    ('ꝝ', 'ꝝ'),
+    ('ꝟ', 'ꝟ'),
+    ('ꝡ', 'ꝡ'),
+    ('ꝣ', 'ꝣ'),
+    ('ꝥ', 'ꝥ'),
+    ('ꝧ', 'ꝧ'),
+    ('ꝩ', 'ꝩ'),
+    ('ꝫ', 'ꝫ'),
+    ('ꝭ', 'ꝭ'),
+    ('ꝯ', 'ꝯ'),
+    ('ꝺ', 'ꝺ'),
+    ('ꝼ', 'ꝼ'),
+    ('ꝿ', 'ꝿ'),
+    ('ꞁ', 'ꞁ'),
+    ('ꞃ', 'ꞃ'),
+    ('ꞅ', 'ꞅ'),
+    ('ꞇ', 'ꞇ'),
+    ('ꞌ', 'ꞌ'),
+    ('ꞑ', 'ꞑ'),
+    ('ꞓ', 'ꞔ'),
+    ('ꞗ', 'ꞗ'),
+    ('ꞙ', 'ꞙ'),
+    ('ꞛ', 'ꞛ'),
+    ('ꞝ', 'ꞝ'),
+    ('ꞟ', 'ꞟ'),
+    ('ꞡ', 'ꞡ'),
+    ('ꞣ', 'ꞣ'),
+    ('ꞥ', 'ꞥ'),
+    ('ꞧ', 'ꞧ'),
+    ('ꞩ', 'ꞩ'),
+    ('ꞵ', 'ꞵ'),
+    ('ꞷ', 'ꞷ'),
+    ('ꞹ', 'ꞹ'),
+    ('ꞻ', 'ꞻ'),
+    ('ꞽ', 'ꞽ'),
+    ('ꞿ', 'ꞿ'),
+    ('ꟁ', 'ꟁ'),
+    ('ꟃ', 'ꟃ'),
+    ('ꟈ', 'ꟈ'),
+    ('ꟊ', 'ꟊ'),
+    ('ꟑ', 'ꟑ'),
+    ('ꟗ', 'ꟗ'),
+    ('ꟙ', 'ꟙ'),
+    ('ꟶ', 'ꟶ'),
+    ('ꭓ', 'ꭓ'),
+    ('ꭰ', 'ꮿ'),
+    ('ﬀ', 'ﬆ'),
+    ('ﬓ', 'ﬗ'),
+    ('ａ', 'ｚ'),
+    ('𐐨', '𐑏'),
+    ('𐓘', '𐓻'),
+    ('𐖗', '𐖡'),
+    ('𐖣', '𐖱'),
+    ('𐖳', '𐖹'),
+    ('𐖻', '𐖼'),
+    ('𐳀', '𐳲'),
+    ('𑣀', '𑣟'),
+    ('𖹠', '𖹿'),
+    ('𞤢', '𞥃'),
+];
+
+pub const CHANGES_WHEN_UPPERCASED: &'static [(char, char)] = &[
+    ('a', 'z'),
+    ('µ', 'µ'),
+    ('ß', 'ö'),
+    ('ø', 'ÿ'),
+    ('ā', 'ā'),
+    ('ă', 'ă'),
+    ('ą', 'ą'),
+    ('ć', 'ć'),
+    ('ĉ', 'ĉ'),
+    ('ċ', 'ċ'),
+    ('č', 'č'),
+    ('ď', 'ď'),
+    ('đ', 'đ'),
+    ('ē', 'ē'),
+    ('ĕ', 'ĕ'),
+    ('ė', 'ė'),
+    ('ę', 'ę'),
+    ('ě', 'ě'),
+    ('ĝ', 'ĝ'),
+    ('ğ', 'ğ'),
+    ('ġ', 'ġ'),
+    ('ģ', 'ģ'),
+    ('ĥ', 'ĥ'),
+    ('ħ', 'ħ'),
+    ('ĩ', 'ĩ'),
+    ('ī', 'ī'),
+    ('ĭ', 'ĭ'),
+    ('į', 'į'),
+    ('ı', 'ı'),
+    ('ĳ', 'ĳ'),
+    ('ĵ', 'ĵ'),
+    ('ķ', 'ķ'),
+    ('ĺ', 'ĺ'),
+    ('ļ', 'ļ'),
+    ('ľ', 'ľ'),
+    ('ŀ', 'ŀ'),
+    ('ł', 'ł'),
+    ('ń', 'ń'),
+    ('ņ', 'ņ'),
+    ('ň', 'ŉ'),
+    ('ŋ', 'ŋ'),
+    ('ō', 'ō'),
+    ('ŏ', 'ŏ'),
+    ('ő', 'ő'),
+    ('œ', 'œ'),
+    ('ŕ', 'ŕ'),
+    ('ŗ', 'ŗ'),
+    ('ř', 'ř'),
+    ('ś', 'ś'),
+    ('ŝ', 'ŝ'),
+    ('ş', 'ş'),
+    ('š', 'š'),
+    ('ţ', 'ţ'),
+    ('ť', 'ť'),
+    ('ŧ', 'ŧ'),
+    ('ũ', 'ũ'),
+    ('ū', 'ū'),
+    ('ŭ', 'ŭ'),
+    ('ů', 'ů'),
+    ('ű', 'ű'),
+    ('ų', 'ų'),
+    ('ŵ', 'ŵ'),
+    ('ŷ', 'ŷ'),
+    ('ź', 'ź'),
+    ('ż', 'ż'),
+    ('ž', 'ƀ'),
+    ('ƃ', 'ƃ'),
+    ('ƅ', 'ƅ'),
+    ('ƈ', 'ƈ'),
+    ('ƌ', 'ƌ'),
+    ('ƒ', 'ƒ'),
+    ('ƕ', 'ƕ'),
+    ('ƙ', 'ƚ'),
+    ('ƞ', 'ƞ'),
+    ('ơ', 'ơ'),
+    ('ƣ', 'ƣ'),
+    ('ƥ', 'ƥ'),
+    ('ƨ', 'ƨ'),
+    ('ƭ', 'ƭ'),
+    ('ư', 'ư'),
+    ('ƴ', 'ƴ'),
+    ('ƶ', 'ƶ'),
+    ('ƹ', 'ƹ'),
+    ('ƽ', 'ƽ'),
+    ('ƿ', 'ƿ'),
+    ('ǅ', 'ǆ'),
+    ('ǈ', 'ǉ'),
+    ('ǋ', 'ǌ'),
+    ('ǎ', 'ǎ'),
+    ('ǐ', 'ǐ'),
+    ('ǒ', 'ǒ'),
+    ('ǔ', 'ǔ'),
+    ('ǖ', 'ǖ'),
+    ('ǘ', 'ǘ'),
+    ('ǚ', 'ǚ'),
+    ('ǜ', 'ǝ'),
+    ('ǟ', 'ǟ'),
+    ('ǡ', 'ǡ'),
+    ('ǣ', 'ǣ'),
+    ('ǥ', 'ǥ'),
+    ('ǧ', 'ǧ'),
+    ('ǩ', 'ǩ'),
+    ('ǫ', 'ǫ'),
+    ('ǭ', 'ǭ'),
+    ('ǯ', 'ǰ'),
+    ('ǲ', 'ǳ'),
+    ('ǵ', 'ǵ'),
+    ('ǹ', 'ǹ'),
+    ('ǻ', 'ǻ'),
+    ('ǽ', 'ǽ'),
+    ('ǿ', 'ǿ'),
+    ('ȁ', 'ȁ'),
+    ('ȃ', 'ȃ'),
+    ('ȅ', 'ȅ'),
+    ('ȇ', 'ȇ'),
+    ('ȉ', 'ȉ'),
+    ('ȋ', 'ȋ'),
+    ('ȍ', 'ȍ'),
+    ('ȏ', 'ȏ'),
+    ('ȑ', 'ȑ'),
+    ('ȓ', 'ȓ'),
+    ('ȕ', 'ȕ'),
+    ('ȗ', 'ȗ'),
+    ('ș', 'ș'),
+    ('ț', 'ț'),
+    ('ȝ', 'ȝ'),
+    ('ȟ', 'ȟ'),
+    ('ȣ', 'ȣ'),
+    ('ȥ', 'ȥ'),
+    ('ȧ', 'ȧ'),
+    ('ȩ', 'ȩ'),
+    ('ȫ', 'ȫ'),
+    ('ȭ', 'ȭ'),
+    ('ȯ', 'ȯ'),
+    ('ȱ', 'ȱ'),
+    ('ȳ', 'ȳ'),
+    ('ȼ', 'ȼ'),
+    ('ȿ', 'ɀ'),
+    ('ɂ', 'ɂ'),
+    ('ɇ', 'ɇ'),
+    ('ɉ', 'ɉ'),
+    ('ɋ', 'ɋ'),
+    ('ɍ', 'ɍ'),
+    ('ɏ', 'ɔ'),
+    ('ɖ', 'ɗ'),
+    ('ə', 'ə'),
+    ('ɛ', 'ɜ'),
+    ('ɠ', 'ɡ'),
+    ('ɣ', 'ɣ'),
+    ('ɥ', 'ɦ'),
+    ('ɨ', 'ɬ'),
+    ('ɯ', 'ɯ'),
+    ('ɱ', 'ɲ'),
+    ('ɵ', 'ɵ'),
+    ('ɽ', 'ɽ'),
+    ('ʀ', 'ʀ'),
+    ('ʂ', 'ʃ'),
+    ('ʇ', 'ʌ'),
+    ('ʒ', 'ʒ'),
+    ('ʝ', 'ʞ'),
+    ('\u{345}', '\u{345}'),
+    ('ͱ', 'ͱ'),
+    ('ͳ', 'ͳ'),
+    ('ͷ', 'ͷ'),
+    ('ͻ', 'ͽ'),
+    ('ΐ', 'ΐ'),
+    ('ά', 'ώ'),
+    ('ϐ', 'ϑ'),
+    ('ϕ', 'ϗ'),
+    ('ϙ', 'ϙ'),
+    ('ϛ', 'ϛ'),
+    ('ϝ', 'ϝ'),
+    ('ϟ', 'ϟ'),
+    ('ϡ', 'ϡ'),
+    ('ϣ', 'ϣ'),
+    ('ϥ', 'ϥ'),
+    ('ϧ', 'ϧ'),
+    ('ϩ', 'ϩ'),
+    ('ϫ', 'ϫ'),
+    ('ϭ', 'ϭ'),
+    ('ϯ', 'ϳ'),
+    ('ϵ', 'ϵ'),
+    ('ϸ', 'ϸ'),
+    ('ϻ', 'ϻ'),
+    ('а', 'џ'),
+    ('ѡ', 'ѡ'),
+    ('ѣ', 'ѣ'),
+    ('ѥ', 'ѥ'),
+    ('ѧ', 'ѧ'),
+    ('ѩ', 'ѩ'),
+    ('ѫ', 'ѫ'),
+    ('ѭ', 'ѭ'),
+    ('ѯ', 'ѯ'),
+    ('ѱ', 'ѱ'),
+    ('ѳ', 'ѳ'),
+    ('ѵ', 'ѵ'),
+    ('ѷ', 'ѷ'),
+    ('ѹ', 'ѹ'),
+    ('ѻ', 'ѻ'),
+    ('ѽ', 'ѽ'),
+    ('ѿ', 'ѿ'),
+    ('ҁ', 'ҁ'),
+    ('ҋ', 'ҋ'),
+    ('ҍ', 'ҍ'),
+    ('ҏ', 'ҏ'),
+    ('ґ', 'ґ'),
+    ('ғ', 'ғ'),
+    ('ҕ', 'ҕ'),
+    ('җ', 'җ'),
+    ('ҙ', 'ҙ'),
+    ('қ', 'қ'),
+    ('ҝ', 'ҝ'),
+    ('ҟ', 'ҟ'),
+    ('ҡ', 'ҡ'),
+    ('ң', 'ң'),
+    ('ҥ', 'ҥ'),
+    ('ҧ', 'ҧ'),
+    ('ҩ', 'ҩ'),
+    ('ҫ', 'ҫ'),
+    ('ҭ', 'ҭ'),
+    ('ү', 'ү'),
+    ('ұ', 'ұ'),
+    ('ҳ', 'ҳ'),
+    ('ҵ', 'ҵ'),
+    ('ҷ', 'ҷ'),
+    ('ҹ', 'ҹ'),
+    ('һ', 'һ'),
+    ('ҽ', 'ҽ'),
+    ('ҿ', 'ҿ'),
+    ('ӂ', 'ӂ'),
+    ('ӄ', 'ӄ'),
+    ('ӆ', 'ӆ'),
+    ('ӈ', 'ӈ'),
+    ('ӊ', 'ӊ'),
+    ('ӌ', 'ӌ'),
+    ('ӎ', 'ӏ'),
+    ('ӑ', 'ӑ'),
+    ('ӓ', 'ӓ'),
+    ('ӕ', 'ӕ'),
+    ('ӗ', 'ӗ'),
+    ('ә', 'ә'),
+    ('ӛ', 'ӛ'),
+    ('ӝ', 'ӝ'),
+    ('ӟ', 'ӟ'),
+    ('ӡ', 'ӡ'),
+    ('ӣ', 'ӣ'),
+    ('ӥ', 'ӥ'),
+    ('ӧ', 'ӧ'),
+    ('ө', 'ө'),
+    ('ӫ', 'ӫ'),
+    ('ӭ', 'ӭ'),
+    ('ӯ', 'ӯ'),
+    ('ӱ', 'ӱ'),
+    ('ӳ', 'ӳ'),
+    ('ӵ', 'ӵ'),
+    ('ӷ', 'ӷ'),
+    ('ӹ', 'ӹ'),
+    ('ӻ', 'ӻ'),
+    ('ӽ', 'ӽ'),
+    ('ӿ', 'ӿ'),
+    ('ԁ', 'ԁ'),
+    ('ԃ', 'ԃ'),
+    ('ԅ', 'ԅ'),
+    ('ԇ', 'ԇ'),
+    ('ԉ', 'ԉ'),
+    ('ԋ', 'ԋ'),
+    ('ԍ', 'ԍ'),
+    ('ԏ', 'ԏ'),
+    ('ԑ', 'ԑ'),
+    ('ԓ', 'ԓ'),
+    ('ԕ', 'ԕ'),
+    ('ԗ', 'ԗ'),
+    ('ԙ', 'ԙ'),
+    ('ԛ', 'ԛ'),
+    ('ԝ', 'ԝ'),
+    ('ԟ', 'ԟ'),
+    ('ԡ', 'ԡ'),
+    ('ԣ', 'ԣ'),
+    ('ԥ', 'ԥ'),
+    ('ԧ', 'ԧ'),
+    ('ԩ', 'ԩ'),
+    ('ԫ', 'ԫ'),
+    ('ԭ', 'ԭ'),
+    ('ԯ', 'ԯ'),
+    ('ա', 'և'),
+    ('ა', 'ჺ'),
+    ('ჽ', 'ჿ'),
+    ('ᏸ', 'ᏽ'),
+    ('ᲀ', 'ᲈ'),
+    ('ᵹ', 'ᵹ'),
+    ('ᵽ', 'ᵽ'),
+    ('ᶎ', 'ᶎ'),
+    ('ḁ', 'ḁ'),
+    ('ḃ', 'ḃ'),
+    ('ḅ', 'ḅ'),
+    ('ḇ', 'ḇ'),
+    ('ḉ', 'ḉ'),
+    ('ḋ', 'ḋ'),
+    ('ḍ', 'ḍ'),
+    ('ḏ', 'ḏ'),
+    ('ḑ', 'ḑ'),
+    ('ḓ', 'ḓ'),
+    ('ḕ', 'ḕ'),
+    ('ḗ', 'ḗ'),
+    ('ḙ', 'ḙ'),
+    ('ḛ', 'ḛ'),
+    ('ḝ', 'ḝ'),
+    ('ḟ', 'ḟ'),
+    ('ḡ', 'ḡ'),
+    ('ḣ', 'ḣ'),
+    ('ḥ', 'ḥ'),
+    ('ḧ', 'ḧ'),
+    ('ḩ', 'ḩ'),
+    ('ḫ', 'ḫ'),
+    ('ḭ', 'ḭ'),
+    ('ḯ', 'ḯ'),
+    ('ḱ', 'ḱ'),
+    ('ḳ', 'ḳ'),
+    ('ḵ', 'ḵ'),
+    ('ḷ', 'ḷ'),
+    ('ḹ', 'ḹ'),
+    ('ḻ', 'ḻ'),
+    ('ḽ', 'ḽ'),
+    ('ḿ', 'ḿ'),
+    ('ṁ', 'ṁ'),
+    ('ṃ', 'ṃ'),
+    ('ṅ', 'ṅ'),
+    ('ṇ', 'ṇ'),
+    ('ṉ', 'ṉ'),
+    ('ṋ', 'ṋ'),
+    ('ṍ', 'ṍ'),
+    ('ṏ', 'ṏ'),
+    ('ṑ', 'ṑ'),
+    ('ṓ', 'ṓ'),
+    ('ṕ', 'ṕ'),
+    ('ṗ', 'ṗ'),
+    ('ṙ', 'ṙ'),
+    ('ṛ', 'ṛ'),
+    ('ṝ', 'ṝ'),
+    ('ṟ', 'ṟ'),
+    ('ṡ', 'ṡ'),
+    ('ṣ', 'ṣ'),
+    ('ṥ', 'ṥ'),
+    ('ṧ', 'ṧ'),
+    ('ṩ', 'ṩ'),
+    ('ṫ', 'ṫ'),
+    ('ṭ', 'ṭ'),
+    ('ṯ', 'ṯ'),
+    ('ṱ', 'ṱ'),
+    ('ṳ', 'ṳ'),
+    ('ṵ', 'ṵ'),
+    ('ṷ', 'ṷ'),
+    ('ṹ', 'ṹ'),
+    ('ṻ', 'ṻ'),
+    ('ṽ', 'ṽ'),
+    ('ṿ', 'ṿ'),
+    ('ẁ', 'ẁ'),
+    ('ẃ', 'ẃ'),
+    ('ẅ', 'ẅ'),
+    ('ẇ', 'ẇ'),
+    ('ẉ', 'ẉ'),
+    ('ẋ', 'ẋ'),
+    ('ẍ', 'ẍ'),
+    ('ẏ', 'ẏ'),
+    ('ẑ', 'ẑ'),
+    ('ẓ', 'ẓ'),
+    ('ẕ', 'ẛ'),
+    ('ạ', 'ạ'),
+    ('ả', 'ả'),
+    ('ấ', 'ấ'),
+    ('ầ', 'ầ'),
+    ('ẩ', 'ẩ'),
+    ('ẫ', 'ẫ'),
+    ('ậ', 'ậ'),
+    ('ắ', 'ắ'),
+    ('ằ', 'ằ'),
+    ('ẳ', 'ẳ'),
+    ('ẵ', 'ẵ'),
+    ('ặ', 'ặ'),
+    ('ẹ', 'ẹ'),
+    ('ẻ', 'ẻ'),
+    ('ẽ', 'ẽ'),
+    ('ế', 'ế'),
+    ('ề', 'ề'),
+    ('ể', 'ể'),
+    ('ễ', 'ễ'),
+    ('ệ', 'ệ'),
+    ('ỉ', 'ỉ'),
+    ('ị', 'ị'),
+    ('ọ', 'ọ'),
+    ('ỏ', 'ỏ'),
+    ('ố', 'ố'),
+    ('ồ', 'ồ'),
+    ('ổ', 'ổ'),
+    ('ỗ', 'ỗ'),
+    ('ộ', 'ộ'),
+    ('ớ', 'ớ'),
+    ('ờ', 'ờ'),
+    ('ở', 'ở'),
+    ('ỡ', 'ỡ'),
+    ('ợ', 'ợ'),
+    ('ụ', 'ụ'),
+    ('ủ', 'ủ'),
+    ('ứ', 'ứ'),
+    ('ừ', 'ừ'),
+    ('ử', 'ử'),
+    ('ữ', 'ữ'),
+    ('ự', 'ự'),
+    ('ỳ', 'ỳ'),
+    ('ỵ', 'ỵ'),
+    ('ỷ', 'ỷ'),
+    ('ỹ', 'ỹ'),
+    ('ỻ', 'ỻ'),
+    ('ỽ', 'ỽ'),
+    ('ỿ', 'ἇ'),
+    ('ἐ', 'ἕ'),
+    ('ἠ', 'ἧ'),
+    ('ἰ', 'ἷ'),
+    ('ὀ', 'ὅ'),
+    ('ὐ', 'ὗ'),
+    ('ὠ', 'ὧ'),
+    ('ὰ', 'ώ'),
+    ('ᾀ', 'ᾴ'),
+    ('ᾶ', 'ᾷ'),
+    ('ᾼ', 'ᾼ'),
+    ('ι', 'ι'),
+    ('ῂ', 'ῄ'),
+    ('ῆ', 'ῇ'),
+    ('ῌ', 'ῌ'),
+    ('ῐ', 'ΐ'),
+    ('ῖ', 'ῗ'),
+    ('ῠ', 'ῧ'),
+    ('ῲ', 'ῴ'),
+    ('ῶ', 'ῷ'),
+    ('ῼ', 'ῼ'),
+    ('ⅎ', 'ⅎ'),
+    ('ⅰ', 'ⅿ'),
+    ('ↄ', 'ↄ'),
+    ('ⓐ', 'ⓩ'),
+    ('ⰰ', 'ⱟ'),
+    ('ⱡ', 'ⱡ'),
+    ('ⱥ', 'ⱦ'),
+    ('ⱨ', 'ⱨ'),
+    ('ⱪ', 'ⱪ'),
+    ('ⱬ', 'ⱬ'),
+    ('ⱳ', 'ⱳ'),
+    ('ⱶ', 'ⱶ'),
+    ('ⲁ', 'ⲁ'),
+    ('ⲃ', 'ⲃ'),
+    ('ⲅ', 'ⲅ'),
+    ('ⲇ', 'ⲇ'),
+    ('ⲉ', 'ⲉ'),
+    ('ⲋ', 'ⲋ'),
+    ('ⲍ', 'ⲍ'),
+    ('ⲏ', 'ⲏ'),
+    ('ⲑ', 'ⲑ'),
+    ('ⲓ', 'ⲓ'),
+    ('ⲕ', 'ⲕ'),
+    ('ⲗ', 'ⲗ'),
+    ('ⲙ', 'ⲙ'),
+    ('ⲛ', 'ⲛ'),
+    ('ⲝ', 'ⲝ'),
+    ('ⲟ', 'ⲟ'),
+    ('ⲡ', 'ⲡ'),
+    ('ⲣ', 'ⲣ'),
+    ('ⲥ', 'ⲥ'),
+    ('ⲧ', 'ⲧ'),
+    ('ⲩ', 'ⲩ'),
+    ('ⲫ', 'ⲫ'),
+    ('ⲭ', 'ⲭ'),
+    ('ⲯ', 'ⲯ'),
+    ('ⲱ', 'ⲱ'),
+    ('ⲳ', 'ⲳ'),
+    ('ⲵ', 'ⲵ'),
+    ('ⲷ', 'ⲷ'),
+    ('ⲹ', 'ⲹ'),
+    ('ⲻ', 'ⲻ'),
+    ('ⲽ', 'ⲽ'),
+    ('ⲿ', 'ⲿ'),
+    ('ⳁ', 'ⳁ'),
+    ('ⳃ', 'ⳃ'),
+    ('ⳅ', 'ⳅ'),
+    ('ⳇ', 'ⳇ'),
+    ('ⳉ', 'ⳉ'),
+    ('ⳋ', 'ⳋ'),
+    ('ⳍ', 'ⳍ'),
+    ('ⳏ', 'ⳏ'),
+    ('ⳑ', 'ⳑ'),
+    ('ⳓ', 'ⳓ'),
+    ('ⳕ', 'ⳕ'),
+    ('ⳗ', 'ⳗ'),
+    ('ⳙ', 'ⳙ'),
+    ('ⳛ', 'ⳛ'),
+    ('ⳝ', 'ⳝ'),
+    ('ⳟ', 'ⳟ'),
+    ('ⳡ', 'ⳡ'),
+    ('ⳣ', 'ⳣ'),
+    ('ⳬ', 'ⳬ'),
+    ('ⳮ', 'ⳮ'),
+    ('ⳳ', 'ⳳ'),
+    ('ⴀ', 'ⴥ'),
+    ('ⴧ', 'ⴧ'),
+    ('ⴭ', 'ⴭ'),
+    ('ꙁ', 'ꙁ'),
+    ('ꙃ', 'ꙃ'),
+    ('ꙅ', 'ꙅ'),
+    ('ꙇ', 'ꙇ'),
+    ('ꙉ', 'ꙉ'),
+    ('ꙋ', 'ꙋ'),
+    ('ꙍ', 'ꙍ'),
+    ('ꙏ', 'ꙏ'),
+    ('ꙑ', 'ꙑ'),
+    ('ꙓ', 'ꙓ'),
+    ('ꙕ', 'ꙕ'),
+    ('ꙗ', 'ꙗ'),
+    ('ꙙ', 'ꙙ'),
+    ('ꙛ', 'ꙛ'),
+    ('ꙝ', 'ꙝ'),
+    ('ꙟ', 'ꙟ'),
+    ('ꙡ', 'ꙡ'),
+    ('ꙣ', 'ꙣ'),
+    ('ꙥ', 'ꙥ'),
+    ('ꙧ', 'ꙧ'),
+    ('ꙩ', 'ꙩ'),
+    ('ꙫ', 'ꙫ'),
+    ('ꙭ', 'ꙭ'),
+    ('ꚁ', 'ꚁ'),
+    ('ꚃ', 'ꚃ'),
+    ('ꚅ', 'ꚅ'),
+    ('ꚇ', 'ꚇ'),
+    ('ꚉ', 'ꚉ'),
+    ('ꚋ', 'ꚋ'),
+    ('ꚍ', 'ꚍ'),
+    ('ꚏ', 'ꚏ'),
+    ('ꚑ', 'ꚑ'),
+    ('ꚓ', 'ꚓ'),
+    ('ꚕ', 'ꚕ'),
+    ('ꚗ', 'ꚗ'),
+    ('ꚙ', 'ꚙ'),
+    ('ꚛ', 'ꚛ'),
+    ('ꜣ', 'ꜣ'),
+    ('ꜥ', 'ꜥ'),
+    ('ꜧ', 'ꜧ'),
+    ('ꜩ', 'ꜩ'),
+    ('ꜫ', 'ꜫ'),
+    ('ꜭ', 'ꜭ'),
+    ('ꜯ', 'ꜯ'),
+    ('ꜳ', 'ꜳ'),
+    ('ꜵ', 'ꜵ'),
+    ('ꜷ', 'ꜷ'),
+    ('ꜹ', 'ꜹ'),
+    ('ꜻ', 'ꜻ'),
+    ('ꜽ', 'ꜽ'),
+    ('ꜿ', 'ꜿ'),
+    ('ꝁ', 'ꝁ'),
+    ('ꝃ', 'ꝃ'),
+    ('ꝅ', 'ꝅ'),
+    ('ꝇ', 'ꝇ'),
+    ('ꝉ', 'ꝉ'),
+    ('ꝋ', 'ꝋ'),
+    ('ꝍ', 'ꝍ'),
+    ('ꝏ', 'ꝏ'),
+    ('ꝑ', 'ꝑ'),
+    ('ꝓ', 'ꝓ'),
+    ('ꝕ', 'ꝕ'),
+    ('ꝗ', 'ꝗ'),
+    ('ꝙ', 'ꝙ'),
+    ('ꝛ', 'ꝛ'),
+    ('ꝝ', 'ꝝ'),
+    ('ꝟ', 'ꝟ'),
+    ('ꝡ', 'ꝡ'),
+    ('ꝣ', 'ꝣ'),
+    ('ꝥ', 'ꝥ'),
+    ('ꝧ', 'ꝧ'),
+    ('ꝩ', 'ꝩ'),
+    ('ꝫ', 'ꝫ'),
+    ('ꝭ', 'ꝭ'),
+    ('ꝯ', 'ꝯ'),
+    ('ꝺ', 'ꝺ'),
+    ('ꝼ', 'ꝼ'),
+    ('ꝿ', 'ꝿ'),
+    ('ꞁ', 'ꞁ'),
+    ('ꞃ', 'ꞃ'),
+    ('ꞅ', 'ꞅ'),
+    ('ꞇ', 'ꞇ'),
+    ('ꞌ', 'ꞌ'),
+    ('ꞑ', 'ꞑ'),
+    ('ꞓ', 'ꞔ'),
+    ('ꞗ', 'ꞗ'),
+    ('ꞙ', 'ꞙ'),
+    ('ꞛ', 'ꞛ'),
+    ('ꞝ', 'ꞝ'),
+    ('ꞟ', 'ꞟ'),
+    ('ꞡ', 'ꞡ'),
+    ('ꞣ', 'ꞣ'),
+    ('ꞥ', 'ꞥ'),
+    ('ꞧ', 'ꞧ'),
+    ('ꞩ', 'ꞩ'),
+    ('ꞵ', 'ꞵ'),
+    ('ꞷ', 'ꞷ'),
+    ('ꞹ', 'ꞹ'),
+    ('ꞻ', 'ꞻ'),
+    ('ꞽ', 'ꞽ'),
+    ('ꞿ', 'ꞿ'),
+    ('ꟁ', 'ꟁ'),
+    ('ꟃ', 'ꟃ'),
+    ('ꟈ', 'ꟈ'),
+    ('ꟊ', 'ꟊ'),
+    ('ꟑ', 'ꟑ'),
+    ('ꟗ', 'ꟗ'),
+    ('ꟙ', 'ꟙ'),
+    ('ꟶ', 'ꟶ'),
+    ('ꭓ', 'ꭓ'),
+    ('ꭰ', 'ꮿ'),
+    ('ﬀ', 'ﬆ'),
+    ('ﬓ', 'ﬗ'),
+    ('ａ', 'ｚ'),
+    ('𐐨', '𐑏'),
+    ('𐓘', '𐓻'),
+    ('𐖗', '𐖡'),
+    ('𐖣', '𐖱'),
+    ('𐖳', '𐖹'),
+    ('𐖻', '𐖼'),
+    ('𐳀', '𐳲'),
+    ('𑣀', '𑣟'),
+    ('𖹠', '𖹿'),
+    ('𞤢', '𞥃'),
+];
+
+pub const DASH: &'static [(char, char)] = &[
+    ('-', '-'),
+    ('֊', '֊'),
+    ('־', '־'),
+    ('᐀', '᐀'),
+    ('᠆', '᠆'),
+    ('‐', '―'),
+    ('⁓', '⁓'),
+    ('⁻', '⁻'),
+    ('₋', '₋'),
+    ('−', '−'),
+    ('⸗', '⸗'),
+    ('⸚', '⸚'),
+    ('⸺', '⸻'),
+    ('⹀', '⹀'),
+    ('⹝', '⹝'),
+    ('〜', '〜'),
+    ('〰', '〰'),
+    ('゠', '゠'),
+    ('︱', '︲'),
+    ('﹘', '﹘'),
+    ('﹣', '﹣'),
+    ('－', '－'),
+    ('𐺭', '𐺭'),
+];
+
+pub const DEFAULT_IGNORABLE_CODE_POINT: &'static [(char, char)] = &[
+    ('\u{ad}', '\u{ad}'),
+    ('\u{34f}', '\u{34f}'),
+    ('\u{61c}', '\u{61c}'),
+    ('ᅟ', 'ᅠ'),
+    ('\u{17b4}', '\u{17b5}'),
+    ('\u{180b}', '\u{180f}'),
+    ('\u{200b}', '\u{200f}'),
+    ('\u{202a}', '\u{202e}'),
+    ('\u{2060}', '\u{206f}'),
+    ('ㅤ', 'ㅤ'),
+    ('\u{fe00}', '\u{fe0f}'),
+    ('\u{feff}', '\u{feff}'),
+    ('ﾠ', 'ﾠ'),
+    ('\u{fff0}', '\u{fff8}'),
+    ('\u{1bca0}', '\u{1bca3}'),
+    ('\u{1d173}', '\u{1d17a}'),
+    ('\u{e0000}', '\u{e0fff}'),
+];
+
+pub const DEPRECATED: &'static [(char, char)] = &[
+    ('ŉ', 'ŉ'),
+    ('ٳ', 'ٳ'),
+    ('\u{f77}', '\u{f77}'),
+    ('\u{f79}', '\u{f79}'),
+    ('ឣ', 'ឤ'),
+    ('\u{206a}', '\u{206f}'),
+    ('〈', '〉'),
+    ('\u{e0001}', '\u{e0001}'),
+];
+
+pub const DIACRITIC: &'static [(char, char)] = &[
+    ('^', '^'),
+    ('`', '`'),
+    ('¨', '¨'),
+    ('¯', '¯'),
+    ('´', '´'),
+    ('·', '¸'),
+    ('ʰ', '\u{34e}'),
+    ('\u{350}', '\u{357}'),
+    ('\u{35d}', '\u{362}'),
+    ('ʹ', '͵'),
+    ('ͺ', 'ͺ'),
+    ('΄', '΅'),
+    ('\u{483}', '\u{487}'),
+    ('ՙ', 'ՙ'),
+    ('\u{591}', '\u{5a1}'),
+    ('\u{5a3}', '\u{5bd}'),
+    ('\u{5bf}', '\u{5bf}'),
+    ('\u{5c1}', '\u{5c2}'),
+    ('\u{5c4}', '\u{5c4}'),
+    ('\u{64b}', '\u{652}'),
+    ('\u{657}', '\u{658}'),
+    ('\u{6df}', '\u{6e0}'),
+    ('ۥ', 'ۦ'),
+    ('\u{6ea}', '\u{6ec}'),
+    ('\u{730}', '\u{74a}'),
+    ('\u{7a6}', '\u{7b0}'),
+    ('\u{7eb}', 'ߵ'),
+    ('\u{818}', '\u{819}'),
+    ('\u{898}', '\u{89f}'),
+    ('ࣉ', '\u{8d2}'),
+    ('\u{8e3}', '\u{8fe}'),
+    ('\u{93c}', '\u{93c}'),
+    ('\u{94d}', '\u{94d}'),
+    ('\u{951}', '\u{954}'),
+    ('ॱ', 'ॱ'),
+    ('\u{9bc}', '\u{9bc}'),
+    ('\u{9cd}', '\u{9cd}'),
+    ('\u{a3c}', '\u{a3c}'),
+    ('\u{a4d}', '\u{a4d}'),
+    ('\u{abc}', '\u{abc}'),
+    ('\u{acd}', '\u{acd}'),
+    ('\u{afd}', '\u{aff}'),
+    ('\u{b3c}', '\u{b3c}'),
+    ('\u{b4d}', '\u{b4d}'),
+    ('\u{b55}', '\u{b55}'),
+    ('\u{bcd}', '\u{bcd}'),
+    ('\u{c3c}', '\u{c3c}'),
+    ('\u{c4d}', '\u{c4d}'),
+    ('\u{cbc}', '\u{cbc}'),
+    ('\u{ccd}', '\u{ccd}'),
+    ('\u{d3b}', '\u{d3c}'),
+    ('\u{d4d}', '\u{d4d}'),
+    ('\u{dca}', '\u{dca}'),
+    ('\u{e47}', '\u{e4c}'),
+    ('\u{e4e}', '\u{e4e}'),
+    ('\u{eba}', '\u{eba}'),
+    ('\u{ec8}', '\u{ecc}'),
+    ('\u{f18}', '\u{f19}'),
+    ('\u{f35}', '\u{f35}'),
+    ('\u{f37}', '\u{f37}'),
+    ('\u{f39}', '\u{f39}'),
+    ('༾', '༿'),
+    ('\u{f82}', '\u{f84}'),
+    ('\u{f86}', '\u{f87}'),
+    ('\u{fc6}', '\u{fc6}'),
+    ('\u{1037}', '\u{1037}'),
+    ('\u{1039}', '\u{103a}'),
+    ('ၣ', 'ၤ'),
+    ('ၩ', 'ၭ'),
+    ('ႇ', '\u{108d}'),
+    ('ႏ', 'ႏ'),
+    ('ႚ', 'ႛ'),
+    ('\u{135d}', '\u{135f}'),
+    ('\u{1714}', '᜕'),
+    ('\u{17c9}', '\u{17d3}'),
+    ('\u{17dd}', '\u{17dd}'),
+    ('\u{1939}', '\u{193b}'),
+    ('\u{1a75}', '\u{1a7c}'),
+    ('\u{1a7f}', '\u{1a7f}'),
+    ('\u{1ab0}', '\u{1abe}'),
+    ('\u{1ac1}', '\u{1acb}'),
+    ('\u{1b34}', '\u{1b34}'),
+    ('᭄', '᭄'),
+    ('\u{1b6b}', '\u{1b73}'),
+    ('᮪', '\u{1bab}'),
+    ('\u{1c36}', '\u{1c37}'),
+    ('ᱸ', 'ᱽ'),
+    ('\u{1cd0}', '\u{1ce8}'),
+    ('\u{1ced}', '\u{1ced}'),
+    ('\u{1cf4}', '\u{1cf4}'),
+    ('᳷', '\u{1cf9}'),
+    ('ᴬ', 'ᵪ'),
+    ('\u{1dc4}', '\u{1dcf}'),
+    ('\u{1df5}', '\u{1dff}'),
+    ('᾽', '᾽'),
+    ('᾿', '῁'),
+    ('῍', '῏'),
+    ('῝', '῟'),
+    ('῭', '`'),
+    ('´', '῾'),
+    ('\u{2cef}', '\u{2cf1}'),
+    ('ⸯ', 'ⸯ'),
+    ('\u{302a}', '\u{302f}'),
+    ('\u{3099}', '゜'),
+    ('ー', 'ー'),
+    ('\u{a66f}', '\u{a66f}'),
+    ('\u{a67c}', '\u{a67d}'),
+    ('ꙿ', 'ꙿ'),
+    ('ꚜ', 'ꚝ'),
+    ('\u{a6f0}', '\u{a6f1}'),
+    ('꜀', '꜡'),
+    ('ꞈ', '꞊'),
+    ('ꟸ', 'ꟹ'),
+    ('\u{a8c4}', '\u{a8c4}'),
+    ('\u{a8e0}', '\u{a8f1}'),
+    ('\u{a92b}', '꤮'),
+    ('꥓', '꥓'),
+    ('\u{a9b3}', '\u{a9b3}'),
+    ('꧀', '꧀'),
+    ('\u{a9e5}', '\u{a9e5}'),
+    ('ꩻ', 'ꩽ'),
+    ('\u{aabf}', 'ꫂ'),
+    ('\u{aaf6}', '\u{aaf6}'),
+    ('꭛', 'ꭟ'),
+    ('ꭩ', '꭫'),
+    ('꯬', '\u{abed}'),
+    ('\u{fb1e}', '\u{fb1e}'),
+    ('\u{fe20}', '\u{fe2f}'),
+    ('＾', '＾'),
+    ('｀', '｀'),
+    ('ｰ', 'ｰ'),
+    ('\u{ff9e}', '\u{ff9f}'),
+    ('￣', '￣'),
+    ('\u{102e0}', '\u{102e0}'),
+    ('𐞀', '𐞅'),
+    ('𐞇', '𐞰'),
+    ('𐞲', '𐞺'),
+    ('\u{10ae5}', '\u{10ae6}'),
+    ('𐴢', '\u{10d27}'),
+    ('\u{10efd}', '\u{10eff}'),
+    ('\u{10f46}', '\u{10f50}'),
+    ('\u{10f82}', '\u{10f85}'),
+    ('\u{11046}', '\u{11046}'),
+    ('\u{11070}', '\u{11070}'),
+    ('\u{110b9}', '\u{110ba}'),
+    ('\u{11133}', '\u{11134}'),
+    ('\u{11173}', '\u{11173}'),
+    ('𑇀', '𑇀'),
+    ('\u{111ca}', '\u{111cc}'),
+    ('𑈵', '\u{11236}'),
+    ('\u{112e9}', '\u{112ea}'),
+    ('\u{1133c}', '\u{1133c}'),
+    ('𑍍', '𑍍'),
+    ('\u{11366}', '\u{1136c}'),
+    ('\u{11370}', '\u{11374}'),
+    ('\u{11442}', '\u{11442}'),
+    ('\u{11446}', '\u{11446}'),
+    ('\u{114c2}', '\u{114c3}'),
+    ('\u{115bf}', '\u{115c0}'),
+    ('\u{1163f}', '\u{1163f}'),
+    ('𑚶', '\u{116b7}'),
+    ('\u{1172b}', '\u{1172b}'),
+    ('\u{11839}', '\u{1183a}'),
+    ('𑤽', '\u{1193e}'),
+    ('\u{11943}', '\u{11943}'),
+    ('\u{119e0}', '\u{119e0}'),
+    ('\u{11a34}', '\u{11a34}'),
+    ('\u{11a47}', '\u{11a47}'),
+    ('\u{11a99}', '\u{11a99}'),
+    ('\u{11c3f}', '\u{11c3f}'),
+    ('\u{11d42}', '\u{11d42}'),
+    ('\u{11d44}', '\u{11d45}'),
+    ('\u{11d97}', '\u{11d97}'),
+    ('\u{13447}', '\u{13455}'),
+    ('\u{16af0}', '\u{16af4}'),
+    ('\u{16b30}', '\u{16b36}'),
+    ('\u{16f8f}', '𖾟'),
+    ('𖿰', '𖿱'),
+    ('𚿰', '𚿳'),
+    ('𚿵', '𚿻'),
+    ('𚿽', '𚿾'),
+    ('\u{1cf00}', '\u{1cf2d}'),
+    ('\u{1cf30}', '\u{1cf46}'),
+    ('\u{1d167}', '\u{1d169}'),
+    ('𝅭', '\u{1d172}'),
+    ('\u{1d17b}', '\u{1d182}'),
+    ('\u{1d185}', '\u{1d18b}'),
+    ('\u{1d1aa}', '\u{1d1ad}'),
+    ('𞀰', '𞁭'),
+    ('\u{1e130}', '\u{1e136}'),
+    ('\u{1e2ae}', '\u{1e2ae}'),
+    ('\u{1e2ec}', '\u{1e2ef}'),
+    ('\u{1e8d0}', '\u{1e8d6}'),
+    ('\u{1e944}', '\u{1e946}'),
+    ('\u{1e948}', '\u{1e94a}'),
+];
+
+pub const EMOJI: &'static [(char, char)] = &[
+    ('#', '#'),
+    ('*', '*'),
+    ('0', '9'),
+    ('©', '©'),
+    ('®', '®'),
+    ('‼', '‼'),
+    ('⁉', '⁉'),
+    ('™', '™'),
+    ('ℹ', 'ℹ'),
+    ('↔', '↙'),
+    ('↩', '↪'),
+    ('⌚', '⌛'),
+    ('⌨', '⌨'),
+    ('⏏', '⏏'),
+    ('⏩', '⏳'),
+    ('⏸', '⏺'),
+    ('Ⓜ', 'Ⓜ'),
+    ('▪', '▫'),
+    ('▶', '▶'),
+    ('◀', '◀'),
+    ('◻', '◾'),
+    ('☀', '☄'),
+    ('☎', '☎'),
+    ('☑', '☑'),
+    ('☔', '☕'),
+    ('☘', '☘'),
+    ('☝', '☝'),
+    ('☠', '☠'),
+    ('☢', '☣'),
+    ('☦', '☦'),
+    ('☪', '☪'),
+    ('☮', '☯'),
+    ('☸', '☺'),
+    ('♀', '♀'),
+    ('♂', '♂'),
+    ('♈', '♓'),
+    ('♟', '♠'),
+    ('♣', '♣'),
+    ('♥', '♦'),
+    ('♨', '♨'),
+    ('♻', '♻'),
+    ('♾', '♿'),
+    ('⚒', '⚗'),
+    ('⚙', '⚙'),
+    ('⚛', '⚜'),
+    ('⚠', '⚡'),
+    ('⚧', '⚧'),
+    ('⚪', '⚫'),
+    ('⚰', '⚱'),
+    ('⚽', '⚾'),
+    ('⛄', '⛅'),
+    ('⛈', '⛈'),
+    ('⛎', '⛏'),
+    ('⛑', '⛑'),
+    ('⛓', '⛔'),
+    ('⛩', '⛪'),
+    ('⛰', '⛵'),
+    ('⛷', '⛺'),
+    ('⛽', '⛽'),
+    ('✂', '✂'),
+    ('✅', '✅'),
+    ('✈', '✍'),
+    ('✏', '✏'),
+    ('✒', '✒'),
+    ('✔', '✔'),
+    ('✖', '✖'),
+    ('✝', '✝'),
+    ('✡', '✡'),
+    ('✨', '✨'),
+    ('✳', '✴'),
+    ('❄', '❄'),
+    ('❇', '❇'),
+    ('❌', '❌'),
+    ('❎', '❎'),
+    ('❓', '❕'),
+    ('❗', '❗'),
+    ('❣', '❤'),
+    ('➕', '➗'),
+    ('➡', '➡'),
+    ('➰', '➰'),
+    ('➿', '➿'),
+    ('⤴', '⤵'),
+    ('⬅', '⬇'),
+    ('⬛', '⬜'),
+    ('⭐', '⭐'),
+    ('⭕', '⭕'),
+    ('〰', '〰'),
+    ('〽', '〽'),
+    ('㊗', '㊗'),
+    ('㊙', '㊙'),
+    ('🀄', '🀄'),
+    ('🃏', '🃏'),
+    ('🅰', '🅱'),
+    ('🅾', '🅿'),
+    ('🆎', '🆎'),
+    ('🆑', '🆚'),
+    ('🇦', '🇿'),
+    ('🈁', '🈂'),
+    ('🈚', '🈚'),
+    ('🈯', '🈯'),
+    ('🈲', '🈺'),
+    ('🉐', '🉑'),
+    ('🌀', '🌡'),
+    ('🌤', '🎓'),
+    ('🎖', '🎗'),
+    ('🎙', '🎛'),
+    ('🎞', '🏰'),
+    ('🏳', '🏵'),
+    ('🏷', '📽'),
+    ('📿', '🔽'),
+    ('🕉', '🕎'),
+    ('🕐', '🕧'),
+    ('🕯', '🕰'),
+    ('🕳', '🕺'),
+    ('🖇', '🖇'),
+    ('🖊', '🖍'),
+    ('🖐', '🖐'),
+    ('🖕', '🖖'),
+    ('🖤', '🖥'),
+    ('🖨', '🖨'),
+    ('🖱', '🖲'),
+    ('🖼', '🖼'),
+    ('🗂', '🗄'),
+    ('🗑', '🗓'),
+    ('🗜', '🗞'),
+    ('🗡', '🗡'),
+    ('🗣', '🗣'),
+    ('🗨', '🗨'),
+    ('🗯', '🗯'),
+    ('🗳', '🗳'),
+    ('🗺', '🙏'),
+    ('🚀', '🛅'),
+    ('🛋', '🛒'),
+    ('🛕', '🛗'),
+    ('🛜', '🛥'),
+    ('🛩', '🛩'),
+    ('🛫', '🛬'),
+    ('🛰', '🛰'),
+    ('🛳', '🛼'),
+    ('🟠', '🟫'),
+    ('🟰', '🟰'),
+    ('🤌', '🤺'),
+    ('🤼', '🥅'),
+    ('🥇', '🧿'),
+    ('🩰', '🩼'),
+    ('🪀', '🪈'),
+    ('🪐', '🪽'),
+    ('🪿', '🫅'),
+    ('🫎', '🫛'),
+    ('🫠', '🫨'),
+    ('🫰', '🫸'),
+];
+
+pub const EMOJI_COMPONENT: &'static [(char, char)] = &[
+    ('#', '#'),
+    ('*', '*'),
+    ('0', '9'),
+    ('\u{200d}', '\u{200d}'),
+    ('\u{20e3}', '\u{20e3}'),
+    ('\u{fe0f}', '\u{fe0f}'),
+    ('🇦', '🇿'),
+    ('🏻', '🏿'),
+    ('🦰', '🦳'),
+    ('\u{e0020}', '\u{e007f}'),
+];
+
+pub const EMOJI_MODIFIER: &'static [(char, char)] = &[('🏻', '🏿')];
+
+pub const EMOJI_MODIFIER_BASE: &'static [(char, char)] = &[
+    ('☝', '☝'),
+    ('⛹', '⛹'),
+    ('✊', '✍'),
+    ('🎅', '🎅'),
+    ('🏂', '🏄'),
+    ('🏇', '🏇'),
+    ('🏊', '🏌'),
+    ('👂', '👃'),
+    ('👆', '👐'),
+    ('👦', '👸'),
+    ('👼', '👼'),
+    ('💁', '💃'),
+    ('💅', '💇'),
+    ('💏', '💏'),
+    ('💑', '💑'),
+    ('💪', '💪'),
+    ('🕴', '🕵'),
+    ('🕺', '🕺'),
+    ('🖐', '🖐'),
+    ('🖕', '🖖'),
+    ('🙅', '🙇'),
+    ('🙋', '🙏'),
+    ('🚣', '🚣'),
+    ('🚴', '🚶'),
+    ('🛀', '🛀'),
+    ('🛌', '🛌'),
+    ('🤌', '🤌'),
+    ('🤏', '🤏'),
+    ('🤘', '🤟'),
+    ('🤦', '🤦'),
+    ('🤰', '🤹'),
+    ('🤼', '🤾'),
+    ('🥷', '🥷'),
+    ('🦵', '🦶'),
+    ('🦸', '🦹'),
+    ('🦻', '🦻'),
+    ('🧍', '🧏'),
+    ('🧑', '🧝'),
+    ('🫃', '🫅'),
+    ('🫰', '🫸'),
+];
+
+pub const EMOJI_PRESENTATION: &'static [(char, char)] = &[
+    ('⌚', '⌛'),
+    ('⏩', '⏬'),
+    ('⏰', '⏰'),
+    ('⏳', '⏳'),
+    ('◽', '◾'),
+    ('☔', '☕'),
+    ('♈', '♓'),
+    ('♿', '♿'),
+    ('⚓', '⚓'),
+    ('⚡', '⚡'),
+    ('⚪', '⚫'),
+    ('⚽', '⚾'),
+    ('⛄', '⛅'),
+    ('⛎', '⛎'),
+    ('⛔', '⛔'),
+    ('⛪', '⛪'),
+    ('⛲', '⛳'),
+    ('⛵', '⛵'),
+    ('⛺', '⛺'),
+    ('⛽', '⛽'),
+    ('✅', '✅'),
+    ('✊', '✋'),
+    ('✨', '✨'),
+    ('❌', '❌'),
+    ('❎', '❎'),
+    ('❓', '❕'),
+    ('❗', '❗'),
+    ('➕', '➗'),
+    ('➰', '➰'),
+    ('➿', '➿'),
+    ('⬛', '⬜'),
+    ('⭐', '⭐'),
+    ('⭕', '⭕'),
+    ('🀄', '🀄'),
+    ('🃏', '🃏'),
+    ('🆎', '🆎'),
+    ('🆑', '🆚'),
+    ('🇦', '🇿'),
+    ('🈁', '🈁'),
+    ('🈚', '🈚'),
+    ('🈯', '🈯'),
+    ('🈲', '🈶'),
+    ('🈸', '🈺'),
+    ('🉐', '🉑'),
+    ('🌀', '🌠'),
+    ('🌭', '🌵'),
+    ('🌷', '🍼'),
+    ('🍾', '🎓'),
+    ('🎠', '🏊'),
+    ('🏏', '🏓'),
+    ('🏠', '🏰'),
+    ('🏴', '🏴'),
+    ('🏸', '🐾'),
+    ('👀', '👀'),
+    ('👂', '📼'),
+    ('📿', '🔽'),
+    ('🕋', '🕎'),
+    ('🕐', '🕧'),
+    ('🕺', '🕺'),
+    ('🖕', '🖖'),
+    ('🖤', '🖤'),
+    ('🗻', '🙏'),
+    ('🚀', '🛅'),
+    ('🛌', '🛌'),
+    ('🛐', '🛒'),
+    ('🛕', '🛗'),
+    ('🛜', '🛟'),
+    ('🛫', '🛬'),
+    ('🛴', '🛼'),
+    ('🟠', '🟫'),
+    ('🟰', '🟰'),
+    ('🤌', '🤺'),
+    ('🤼', '🥅'),
+    ('🥇', '🧿'),
+    ('🩰', '🩼'),
+    ('🪀', '🪈'),
+    ('🪐', '🪽'),
+    ('🪿', '🫅'),
+    ('🫎', '🫛'),
+    ('🫠', '🫨'),
+    ('🫰', '🫸'),
+];
+
+pub const EXTENDED_PICTOGRAPHIC: &'static [(char, char)] = &[
+    ('©', '©'),
+    ('®', '®'),
+    ('‼', '‼'),
+    ('⁉', '⁉'),
+    ('™', '™'),
+    ('ℹ', 'ℹ'),
+    ('↔', '↙'),
+    ('↩', '↪'),
+    ('⌚', '⌛'),
+    ('⌨', '⌨'),
+    ('⎈', '⎈'),
+    ('⏏', '⏏'),
+    ('⏩', '⏳'),
+    ('⏸', '⏺'),
+    ('Ⓜ', 'Ⓜ'),
+    ('▪', '▫'),
+    ('▶', '▶'),
+    ('◀', '◀'),
+    ('◻', '◾'),
+    ('☀', '★'),
+    ('☇', '☒'),
+    ('☔', '⚅'),
+    ('⚐', '✅'),
+    ('✈', '✒'),
+    ('✔', '✔'),
+    ('✖', '✖'),
+    ('✝', '✝'),
+    ('✡', '✡'),
+    ('✨', '✨'),
+    ('✳', '✴'),
+    ('❄', '❄'),
+    ('❇', '❇'),
+    ('❌', '❌'),
+    ('❎', '❎'),
+    ('❓', '❕'),
+    ('❗', '❗'),
+    ('❣', '❧'),
+    ('➕', '➗'),
+    ('➡', '➡'),
+    ('➰', '➰'),
+    ('➿', '➿'),
+    ('⤴', '⤵'),
+    ('⬅', '⬇'),
+    ('⬛', '⬜'),
+    ('⭐', '⭐'),
+    ('⭕', '⭕'),
+    ('〰', '〰'),
+    ('〽', '〽'),
+    ('㊗', '㊗'),
+    ('㊙', '㊙'),
+    ('🀀', '\u{1f0ff}'),
+    ('🄍', '🄏'),
+    ('🄯', '🄯'),
+    ('🅬', '🅱'),
+    ('🅾', '🅿'),
+    ('🆎', '🆎'),
+    ('🆑', '🆚'),
+    ('🆭', '\u{1f1e5}'),
+    ('🈁', '\u{1f20f}'),
+    ('🈚', '🈚'),
+    ('🈯', '🈯'),
+    ('🈲', '🈺'),
+    ('\u{1f23c}', '\u{1f23f}'),
+    ('\u{1f249}', '🏺'),
+    ('🐀', '🔽'),
+    ('🕆', '🙏'),
+    ('🚀', '\u{1f6ff}'),
+    ('🝴', '🝿'),
+    ('🟕', '\u{1f7ff}'),
+    ('\u{1f80c}', '\u{1f80f}'),
+    ('\u{1f848}', '\u{1f84f}'),
+    ('\u{1f85a}', '\u{1f85f}'),
+    ('\u{1f888}', '\u{1f88f}'),
+    ('\u{1f8ae}', '\u{1f8ff}'),
+    ('🤌', '🤺'),
+    ('🤼', '🥅'),
+    ('🥇', '\u{1faff}'),
+    ('\u{1fc00}', '\u{1fffd}'),
+];
+
+pub const EXTENDER: &'static [(char, char)] = &[
+    ('·', '·'),
+    ('ː', 'ˑ'),
+    ('ـ', 'ـ'),
+    ('ߺ', 'ߺ'),
+    ('\u{b55}', '\u{b55}'),
+    ('ๆ', 'ๆ'),
+    ('ໆ', 'ໆ'),
+    ('᠊', '᠊'),
+    ('ᡃ', 'ᡃ'),
+    ('ᪧ', 'ᪧ'),
+    ('\u{1c36}', '\u{1c36}'),
+    ('ᱻ', 'ᱻ'),
+    ('々', '々'),
+    ('〱', '〵'),
+    ('ゝ', 'ゞ'),
+    ('ー', 'ヾ'),
+    ('ꀕ', 'ꀕ'),
+    ('ꘌ', 'ꘌ'),
+    ('ꧏ', 'ꧏ'),
+    ('ꧦ', 'ꧦ'),
+    ('ꩰ', 'ꩰ'),
+    ('ꫝ', 'ꫝ'),
+    ('ꫳ', 'ꫴ'),
+    ('ｰ', 'ｰ'),
+    ('𐞁', '𐞂'),
+    ('𑍝', '𑍝'),
+    ('𑗆', '𑗈'),
+    ('\u{11a98}', '\u{11a98}'),
+    ('𖭂', '𖭃'),
+    ('𖿠', '𖿡'),
+    ('𖿣', '𖿣'),
+    ('𞄼', '𞄽'),
+    ('\u{1e944}', '\u{1e946}'),
+];
+
+pub const GRAPHEME_BASE: &'static [(char, char)] = &[
+    (' ', '~'),
+    ('\u{a0}', '¬'),
+    ('®', '˿'),
+    ('Ͱ', 'ͷ'),
+    ('ͺ', 'Ϳ'),
+    ('΄', 'Ί'),
+    ('Ό', 'Ό'),
+    ('Ύ', 'Ρ'),
+    ('Σ', '҂'),
+    ('Ҋ', 'ԯ'),
+    ('Ա', 'Ֆ'),
+    ('ՙ', '֊'),
+    ('֍', '֏'),
+    ('־', '־'),
+    ('׀', '׀'),
+    ('׃', '׃'),
+    ('׆', '׆'),
+    ('א', 'ת'),
+    ('ׯ', '״'),
+    ('؆', '؏'),
+    ('؛', '؛'),
+    ('؝', 'ي'),
+    ('٠', 'ٯ'),
+    ('ٱ', 'ە'),
+    ('۞', '۞'),
+    ('ۥ', 'ۦ'),
+    ('۩', '۩'),
+    ('ۮ', '܍'),
+    ('ܐ', 'ܐ'),
+    ('ܒ', 'ܯ'),
+    ('ݍ', 'ޥ'),
+    ('ޱ', 'ޱ'),
+    ('߀', 'ߪ'),
+    ('ߴ', 'ߺ'),
+    ('߾', 'ࠕ'),
+    ('ࠚ', 'ࠚ'),
+    ('ࠤ', 'ࠤ'),
+    ('ࠨ', 'ࠨ'),
+    ('࠰', '࠾'),
+    ('ࡀ', 'ࡘ'),
+    ('࡞', '࡞'),
+    ('ࡠ', 'ࡪ'),
+    ('ࡰ', 'ࢎ'),
+    ('ࢠ', 'ࣉ'),
+    ('ः', 'ह'),
+    ('ऻ', 'ऻ'),
+    ('ऽ', 'ी'),
+    ('ॉ', 'ौ'),
+    ('ॎ', 'ॐ'),
+    ('क़', 'ॡ'),
+    ('।', 'ঀ'),
+    ('ং', 'ঃ'),
+    ('অ', 'ঌ'),
+    ('এ', 'ঐ'),
+    ('ও', 'ন'),
+    ('প', 'র'),
+    ('ল', 'ল'),
+    ('শ', 'হ'),
+    ('ঽ', 'ঽ'),
+    ('ি', 'ী'),
+    ('ে', 'ৈ'),
+    ('ো', 'ৌ'),
+    ('ৎ', 'ৎ'),
+    ('ড়', 'ঢ়'),
+    ('য়', 'ৡ'),
+    ('০', '৽'),
+    ('ਃ', 'ਃ'),
+    ('ਅ', 'ਊ'),
+    ('ਏ', 'ਐ'),
+    ('ਓ', 'ਨ'),
+    ('ਪ', 'ਰ'),
+    ('ਲ', 'ਲ਼'),
+    ('ਵ', 'ਸ਼'),
+    ('ਸ', 'ਹ'),
+    ('ਾ', 'ੀ'),
+    ('ਖ਼', 'ੜ'),
+    ('ਫ਼', 'ਫ਼'),
+    ('੦', '੯'),
+    ('ੲ', 'ੴ'),
+    ('੶', '੶'),
+    ('ઃ', 'ઃ'),
+    ('અ', 'ઍ'),
+    ('એ', 'ઑ'),
+    ('ઓ', 'ન'),
+    ('પ', 'ર'),
+    ('લ', 'ળ'),
+    ('વ', 'હ'),
+    ('ઽ', 'ી'),
+    ('ૉ', 'ૉ'),
+    ('ો', 'ૌ'),
+    ('ૐ', 'ૐ'),
+    ('ૠ', 'ૡ'),
+    ('૦', '૱'),
+    ('ૹ', 'ૹ'),
+    ('ଂ', 'ଃ'),
+    ('ଅ', 'ଌ'),
+    ('ଏ', 'ଐ'),
+    ('ଓ', 'ନ'),
+    ('ପ', 'ର'),
+    ('ଲ', 'ଳ'),
+    ('ଵ', 'ହ'),
+    ('ଽ', 'ଽ'),
+    ('ୀ', 'ୀ'),
+    ('େ', 'ୈ'),
+    ('ୋ', 'ୌ'),
+    ('ଡ଼', 'ଢ଼'),
+    ('ୟ', 'ୡ'),
+    ('୦', '୷'),
+    ('ஃ', 'ஃ'),
+    ('அ', 'ஊ'),
+    ('எ', 'ஐ'),
+    ('ஒ', 'க'),
+    ('ங', 'ச'),
+    ('ஜ', 'ஜ'),
+    ('ஞ', 'ட'),
+    ('ண', 'த'),
+    ('ந', 'ப'),
+    ('ம', 'ஹ'),
+    ('ி', 'ி'),
+    ('ு', 'ூ'),
+    ('ெ', 'ை'),
+    ('ொ', 'ௌ'),
+    ('ௐ', 'ௐ'),
+    ('௦', '௺'),
+    ('ఁ', 'ః'),
+    ('అ', 'ఌ'),
+    ('ఎ', 'ఐ'),
+    ('ఒ', 'న'),
+    ('ప', 'హ'),
+    ('ఽ', 'ఽ'),
+    ('ు', 'ౄ'),
+    ('ౘ', 'ౚ'),
+    ('ౝ', 'ౝ'),
+    ('ౠ', 'ౡ'),
+    ('౦', '౯'),
+    ('౷', 'ಀ'),
+    ('ಂ', 'ಌ'),
+    ('ಎ', 'ಐ'),
+    ('ಒ', 'ನ'),
+    ('ಪ', 'ಳ'),
+    ('ವ', 'ಹ'),
+    ('ಽ', 'ಾ'),
+    ('ೀ', 'ು'),
+    ('ೃ', 'ೄ'),
+    ('ೇ', 'ೈ'),
+    ('ೊ', 'ೋ'),
+    ('ೝ', 'ೞ'),
+    ('ೠ', 'ೡ'),
+    ('೦', '೯'),
+    ('ೱ', 'ೳ'),
+    ('ം', 'ഌ'),
+    ('എ', 'ഐ'),
+    ('ഒ', 'ഺ'),
+    ('ഽ', 'ഽ'),
+    ('ി', 'ീ'),
+    ('െ', 'ൈ'),
+    ('ൊ', 'ൌ'),
+    ('ൎ', '൏'),
+    ('ൔ', 'ൖ'),
+    ('൘', 'ൡ'),
+    ('൦', 'ൿ'),
+    ('ං', 'ඃ'),
+    ('අ', 'ඖ'),
+    ('ක', 'න'),
+    ('ඳ', 'ර'),
+    ('ල', 'ල'),
+    ('ව', 'ෆ'),
+    ('ැ', 'ෑ'),
+    ('ෘ', 'ෞ'),
+    ('෦', '෯'),
+    ('ෲ', '෴'),
+    ('ก', 'ะ'),
+    ('า', 'ำ'),
+    ('฿', 'ๆ'),
+    ('๏', '๛'),
+    ('ກ', 'ຂ'),
+    ('ຄ', 'ຄ'),
+    ('ຆ', 'ຊ'),
+    ('ຌ', 'ຣ'),
+    ('ລ', 'ລ'),
+    ('ວ', 'ະ'),
+    ('າ', 'ຳ'),
+    ('ຽ', 'ຽ'),
+    ('ເ', 'ໄ'),
+    ('ໆ', 'ໆ'),
+    ('໐', '໙'),
+    ('ໜ', 'ໟ'),
+    ('ༀ', '༗'),
+    ('༚', '༴'),
+    ('༶', '༶'),
+    ('༸', '༸'),
+    ('༺', 'ཇ'),
+    ('ཉ', 'ཬ'),
+    ('ཿ', 'ཿ'),
+    ('྅', '྅'),
+    ('ྈ', 'ྌ'),
+    ('྾', '࿅'),
+    ('࿇', '࿌'),
+    ('࿎', '࿚'),
+    ('က', 'ာ'),
+    ('ေ', 'ေ'),
+    ('း', 'း'),
+    ('ျ', 'ြ'),
+    ('ဿ', 'ၗ'),
+    ('ၚ', 'ၝ'),
+    ('ၡ', 'ၰ'),
+    ('ၵ', 'ႁ'),
+    ('ႃ', 'ႄ'),
+    ('ႇ', 'ႌ'),
+    ('ႎ', 'ႜ'),
+    ('႞', 'Ⴥ'),
+    ('Ⴧ', 'Ⴧ'),
+    ('Ⴭ', 'Ⴭ'),
+    ('ა', 'ቈ'),
+    ('ቊ', 'ቍ'),
+    ('ቐ', 'ቖ'),
+    ('ቘ', 'ቘ'),
+    ('ቚ', 'ቝ'),
+    ('በ', 'ኈ'),
+    ('ኊ', 'ኍ'),
+    ('ነ', 'ኰ'),
+    ('ኲ', 'ኵ'),
+    ('ኸ', 'ኾ'),
+    ('ዀ', 'ዀ'),
+    ('ዂ', 'ዅ'),
+    ('ወ', 'ዖ'),
+    ('ዘ', 'ጐ'),
+    ('ጒ', 'ጕ'),
+    ('ጘ', 'ፚ'),
+    ('፠', '፼'),
+    ('ᎀ', '᎙'),
+    ('Ꭰ', 'Ᏽ'),
+    ('ᏸ', 'ᏽ'),
+    ('᐀', '᚜'),
+    ('ᚠ', 'ᛸ'),
+    ('ᜀ', 'ᜑ'),
+    ('᜕', '᜕'),
+    ('ᜟ', 'ᜱ'),
+    ('᜴', '᜶'),
+    ('ᝀ', 'ᝑ'),
+    ('ᝠ', 'ᝬ'),
+    ('ᝮ', 'ᝰ'),
+    ('ក', 'ឳ'),
+    ('ា', 'ា'),
+    ('ើ', 'ៅ'),
+    ('ះ', 'ៈ'),
+    ('។', 'ៜ'),
+    ('០', '៩'),
+    ('៰', '៹'),
+    ('᠀', '᠊'),
+    ('᠐', '᠙'),
+    ('ᠠ', 'ᡸ'),
+    ('ᢀ', 'ᢄ'),
+    ('ᢇ', 'ᢨ'),
+    ('ᢪ', 'ᢪ'),
+    ('ᢰ', 'ᣵ'),
+    ('ᤀ', 'ᤞ'),
+    ('ᤣ', 'ᤦ'),
+    ('ᤩ', 'ᤫ'),
+    ('ᤰ', 'ᤱ'),
+    ('ᤳ', 'ᤸ'),
+    ('᥀', '᥀'),
+    ('᥄', 'ᥭ'),
+    ('ᥰ', 'ᥴ'),
+    ('ᦀ', 'ᦫ'),
+    ('ᦰ', 'ᧉ'),
+    ('᧐', '᧚'),
+    ('᧞', 'ᨖ'),
+    ('ᨙ', 'ᨚ'),
+    ('᨞', 'ᩕ'),
+    ('ᩗ', 'ᩗ'),
+    ('ᩡ', 'ᩡ'),
+    ('ᩣ', 'ᩤ'),
+    ('ᩭ', 'ᩲ'),
+    ('᪀', '᪉'),
+    ('᪐', '᪙'),
+    ('᪠', '᪭'),
+    ('ᬄ', 'ᬳ'),
+    ('ᬻ', 'ᬻ'),
+    ('ᬽ', 'ᭁ'),
+    ('ᭃ', 'ᭌ'),
+    ('᭐', '᭪'),
+    ('᭴', '᭾'),
+    ('ᮂ', 'ᮡ'),
+    ('ᮦ', 'ᮧ'),
+    ('᮪', '᮪'),
+    ('ᮮ', 'ᯥ'),
+    ('ᯧ', 'ᯧ'),
+    ('ᯪ', 'ᯬ'),
+    ('ᯮ', 'ᯮ'),
+    ('᯲', '᯳'),
+    ('᯼', 'ᰫ'),
+    ('ᰴ', 'ᰵ'),
+    ('᰻', '᱉'),
+    ('ᱍ', 'ᲈ'),
+    ('Ა', 'Ჺ'),
+    ('Ჽ', '᳇'),
+    ('᳓', '᳓'),
+    ('᳡', '᳡'),
+    ('ᳩ', 'ᳬ'),
+    ('ᳮ', 'ᳳ'),
+    ('ᳵ', '᳷'),
+    ('ᳺ', 'ᳺ'),
+    ('ᴀ', 'ᶿ'),
+    ('Ḁ', 'ἕ'),
+    ('Ἐ', 'Ἕ'),
+    ('ἠ', 'ὅ'),
+    ('Ὀ', 'Ὅ'),
+    ('ὐ', 'ὗ'),
+    ('Ὑ', 'Ὑ'),
+    ('Ὓ', 'Ὓ'),
+    ('Ὕ', 'Ὕ'),
+    ('Ὗ', 'ώ'),
+    ('ᾀ', 'ᾴ'),
+    ('ᾶ', 'ῄ'),
+    ('ῆ', 'ΐ'),
+    ('ῖ', 'Ί'),
+    ('῝', '`'),
+    ('ῲ', 'ῴ'),
+    ('ῶ', '῾'),
+    ('\u{2000}', '\u{200a}'),
+    ('‐', '‧'),
+    ('\u{202f}', '\u{205f}'),
+    ('⁰', 'ⁱ'),
+    ('⁴', '₎'),
+    ('ₐ', 'ₜ'),
+    ('₠', '⃀'),
+    ('℀', '↋'),
+    ('←', '␦'),
+    ('⑀', '⑊'),
+    ('①', '⭳'),
+    ('⭶', '⮕'),
+    ('⮗', 'ⳮ'),
+    ('Ⳳ', 'ⳳ'),
+    ('⳹', 'ⴥ'),
+    ('ⴧ', 'ⴧ'),
+    ('ⴭ', 'ⴭ'),
+    ('ⴰ', 'ⵧ'),
+    ('ⵯ', '⵰'),
+    ('ⶀ', 'ⶖ'),
+    ('ⶠ', 'ⶦ'),
+    ('ⶨ', 'ⶮ'),
+    ('ⶰ', 'ⶶ'),
+    ('ⶸ', 'ⶾ'),
+    ('ⷀ', 'ⷆ'),
+    ('ⷈ', 'ⷎ'),
+    ('ⷐ', 'ⷖ'),
+    ('ⷘ', 'ⷞ'),
+    ('⸀', '⹝'),
+    ('⺀', '⺙'),
+    ('⺛', '⻳'),
+    ('⼀', '⿕'),
+    ('⿰', '⿻'),
+    ('\u{3000}', '〩'),
+    ('〰', '〿'),
+    ('ぁ', 'ゖ'),
+    ('゛', 'ヿ'),
+    ('ㄅ', 'ㄯ'),
+    ('ㄱ', 'ㆎ'),
+    ('㆐', '㇣'),
+    ('ㇰ', '㈞'),
+    ('㈠', 'ꒌ'),
+    ('꒐', '꓆'),
+    ('ꓐ', 'ꘫ'),
+    ('Ꙁ', 'ꙮ'),
+    ('꙳', '꙳'),
+    ('꙾', 'ꚝ'),
+    ('ꚠ', 'ꛯ'),
+    ('꛲', '꛷'),
+    ('꜀', 'ꟊ'),
+    ('Ꟑ', 'ꟑ'),
+    ('ꟓ', 'ꟓ'),
+    ('ꟕ', 'ꟙ'),
+    ('ꟲ', 'ꠁ'),
+    ('ꠃ', 'ꠅ'),
+    ('ꠇ', 'ꠊ'),
+    ('ꠌ', 'ꠤ'),
+    ('ꠧ', '꠫'),
+    ('꠰', '꠹'),
+    ('ꡀ', '꡷'),
+    ('ꢀ', 'ꣃ'),
+    ('꣎', '꣙'),
+    ('ꣲ', 'ꣾ'),
+    ('꤀', 'ꤥ'),
+    ('꤮', 'ꥆ'),
+    ('ꥒ', '꥓'),
+    ('꥟', 'ꥼ'),
+    ('ꦃ', 'ꦲ'),
+    ('ꦴ', 'ꦵ'),
+    ('ꦺ', 'ꦻ'),
+    ('ꦾ', '꧍'),
+    ('ꧏ', '꧙'),
+    ('꧞', 'ꧤ'),
+    ('ꧦ', 'ꧾ'),
+    ('ꨀ', 'ꨨ'),
+    ('ꨯ', 'ꨰ'),
+    ('ꨳ', 'ꨴ'),
+    ('ꩀ', 'ꩂ'),
+    ('ꩄ', 'ꩋ'),
+    ('ꩍ', 'ꩍ'),
+    ('꩐', '꩙'),
+    ('꩜', 'ꩻ'),
+    ('ꩽ', 'ꪯ'),
+    ('ꪱ', 'ꪱ'),
+    ('ꪵ', 'ꪶ'),
+    ('ꪹ', 'ꪽ'),
+    ('ꫀ', 'ꫀ'),
+    ('ꫂ', 'ꫂ'),
+    ('ꫛ', 'ꫫ'),
+    ('ꫮ', 'ꫵ'),
+    ('ꬁ', 'ꬆ'),
+    ('ꬉ', 'ꬎ'),
+    ('ꬑ', 'ꬖ'),
+    ('ꬠ', 'ꬦ'),
+    ('ꬨ', 'ꬮ'),
+    ('ꬰ', '꭫'),
+    ('ꭰ', 'ꯤ'),
+    ('ꯦ', 'ꯧ'),
+    ('ꯩ', '꯬'),
+    ('꯰', '꯹'),
+    ('가', '힣'),
+    ('ힰ', 'ퟆ'),
+    ('ퟋ', 'ퟻ'),
+    ('豈', '舘'),
+    ('並', '龎'),
+    ('ﬀ', 'ﬆ'),
+    ('ﬓ', 'ﬗ'),
+    ('יִ', 'יִ'),
+    ('ײַ', 'זּ'),
+    ('טּ', 'לּ'),
+    ('מּ', 'מּ'),
+    ('נּ', 'סּ'),
+    ('ףּ', 'פּ'),
+    ('צּ', '﯂'),
+    ('ﯓ', 'ﶏ'),
+    ('ﶒ', 'ﷇ'),
+    ('﷏', '﷏'),
+    ('ﷰ', '﷿'),
+    ('︐', '︙'),
+    ('︰', '﹒'),
+    ('﹔', '﹦'),
+    ('﹨', '﹫'),
+    ('ﹰ', 'ﹴ'),
+    ('ﹶ', 'ﻼ'),
+    ('！', 'ﾝ'),
+    ('ﾠ', 'ﾾ'),
+    ('ￂ', 'ￇ'),
+    ('ￊ', 'ￏ'),
+    ('ￒ', 'ￗ'),
+    ('ￚ', 'ￜ'),
+    ('￠', '￦'),
+    ('￨', '￮'),
+    ('￼', '�'),
+    ('𐀀', '𐀋'),
+    ('𐀍', '𐀦'),
+    ('𐀨', '𐀺'),
+    ('𐀼', '𐀽'),
+    ('𐀿', '𐁍'),
+    ('𐁐', '𐁝'),
+    ('𐂀', '𐃺'),
+    ('𐄀', '𐄂'),
+    ('𐄇', '𐄳'),
+    ('𐄷', '𐆎'),
+    ('𐆐', '𐆜'),
+    ('𐆠', '𐆠'),
+    ('𐇐', '𐇼'),
+    ('𐊀', '𐊜'),
+    ('𐊠', '𐋐'),
+    ('𐋡', '𐋻'),
+    ('𐌀', '𐌣'),
+    ('𐌭', '𐍊'),
+    ('𐍐', '𐍵'),
+    ('𐎀', '𐎝'),
+    ('𐎟', '𐏃'),
+    ('𐏈', '𐏕'),
+    ('𐐀', '𐒝'),
+    ('𐒠', '𐒩'),
+    ('𐒰', '𐓓'),
+    ('𐓘', '𐓻'),
+    ('𐔀', '𐔧'),
+    ('𐔰', '𐕣'),
+    ('𐕯', '𐕺'),
+    ('𐕼', '𐖊'),
+    ('𐖌', '𐖒'),
+    ('𐖔', '𐖕'),
+    ('𐖗', '𐖡'),
+    ('𐖣', '𐖱'),
+    ('𐖳', '𐖹'),
+    ('𐖻', '𐖼'),
+    ('𐘀', '𐜶'),
+    ('𐝀', '𐝕'),
+    ('𐝠', '𐝧'),
+    ('𐞀', '𐞅'),
+    ('𐞇', '𐞰'),
+    ('𐞲', '𐞺'),
+    ('𐠀', '𐠅'),
+    ('𐠈', '𐠈'),
+    ('𐠊', '𐠵'),
+    ('𐠷', '𐠸'),
+    ('𐠼', '𐠼'),
+    ('𐠿', '𐡕'),
+    ('𐡗', '𐢞'),
+    ('𐢧', '𐢯'),
+    ('𐣠', '𐣲'),
+    ('𐣴', '𐣵'),
+    ('𐣻', '𐤛'),
+    ('𐤟', '𐤹'),
+    ('𐤿', '𐤿'),
+    ('𐦀', '𐦷'),
+    ('𐦼', '𐧏'),
+    ('𐧒', '𐨀'),
+    ('𐨐', '𐨓'),
+    ('𐨕', '𐨗'),
+    ('𐨙', '𐨵'),
+    ('𐩀', '𐩈'),
+    ('𐩐', '𐩘'),
+    ('𐩠', '𐪟'),
+    ('𐫀', '𐫤'),
+    ('𐫫', '𐫶'),
+    ('𐬀', '𐬵'),
+    ('𐬹', '𐭕'),
+    ('𐭘', '𐭲'),
+    ('𐭸', '𐮑'),
+    ('𐮙', '𐮜'),
+    ('𐮩', '𐮯'),
+    ('𐰀', '𐱈'),
+    ('𐲀', '𐲲'),
+    ('𐳀', '𐳲'),
+    ('𐳺', '𐴣'),
+    ('𐴰', '𐴹'),
+    ('𐹠', '𐹾'),
+    ('𐺀', '𐺩'),
+    ('𐺭', '𐺭'),
+    ('𐺰', '𐺱'),
+    ('𐼀', '𐼧'),
+    ('𐼰', '𐽅'),
+    ('𐽑', '𐽙'),
+    ('𐽰', '𐾁'),
+    ('𐾆', '𐾉'),
+    ('𐾰', '𐿋'),
+    ('𐿠', '𐿶'),
+    ('𑀀', '𑀀'),
+    ('𑀂', '𑀷'),
+    ('𑁇', '𑁍'),
+    ('𑁒', '𑁯'),
+    ('𑁱', '𑁲'),
+    ('𑁵', '𑁵'),
+    ('𑂂', '𑂲'),
+    ('𑂷', '𑂸'),
+    ('𑂻', '𑂼'),
+    ('𑂾', '𑃁'),
+    ('𑃐', '𑃨'),
+    ('𑃰', '𑃹'),
+    ('𑄃', '𑄦'),
+    ('𑄬', '𑄬'),
+    ('𑄶', '𑅇'),
+    ('𑅐', '𑅲'),
+    ('𑅴', '𑅶'),
+    ('𑆂', '𑆵'),
+    ('𑆿', '𑇈'),
+    ('𑇍', '𑇎'),
+    ('𑇐', '𑇟'),
+    ('𑇡', '𑇴'),
+    ('𑈀', '𑈑'),
+    ('𑈓', '𑈮'),
+    ('𑈲', '𑈳'),
+    ('𑈵', '𑈵'),
+    ('𑈸', '𑈽'),
+    ('𑈿', '𑉀'),
+    ('𑊀', '𑊆'),
+    ('𑊈', '𑊈'),
+    ('𑊊', '𑊍'),
+    ('𑊏', '𑊝'),
+    ('𑊟', '𑊩'),
+    ('𑊰', '𑋞'),
+    ('𑋠', '𑋢'),
+    ('𑋰', '𑋹'),
+    ('𑌂', '𑌃'),
+    ('𑌅', '𑌌'),
+    ('𑌏', '𑌐'),
+    ('𑌓', '𑌨'),
+    ('𑌪', '𑌰'),
+    ('𑌲', '𑌳'),
+    ('𑌵', '𑌹'),
+    ('𑌽', '𑌽'),
+    ('𑌿', '𑌿'),
+    ('𑍁', '𑍄'),
+    ('𑍇', '𑍈'),
+    ('𑍋', '𑍍'),
+    ('𑍐', '𑍐'),
+    ('𑍝', '𑍣'),
+    ('𑐀', '𑐷'),
+    ('𑑀', '𑑁'),
+    ('𑑅', '𑑅'),
+    ('𑑇', '𑑛'),
+    ('𑑝', '𑑝'),
+    ('𑑟', '𑑡'),
+    ('𑒀', '𑒯'),
+    ('𑒱', '𑒲'),
+    ('𑒹', '𑒹'),
+    ('𑒻', '𑒼'),
+    ('𑒾', '𑒾'),
+    ('𑓁', '𑓁'),
+    ('𑓄', '𑓇'),
+    ('𑓐', '𑓙'),
+    ('𑖀', '𑖮'),
+    ('𑖰', '𑖱'),
+    ('𑖸', '𑖻'),
+    ('𑖾', '𑖾'),
+    ('𑗁', '𑗛'),
+    ('𑘀', '𑘲'),
+    ('𑘻', '𑘼'),
+    ('𑘾', '𑘾'),
+    ('𑙁', '𑙄'),
+    ('𑙐', '𑙙'),
+    ('𑙠', '𑙬'),
+    ('𑚀', '𑚪'),
+    ('𑚬', '𑚬'),
+    ('𑚮', '𑚯'),
+    ('𑚶', '𑚶'),
+    ('𑚸', '𑚹'),
+    ('𑛀', '𑛉'),
+    ('𑜀', '𑜚'),
+    ('𑜠', '𑜡'),
+    ('𑜦', '𑜦'),
+    ('𑜰', '𑝆'),
+    ('𑠀', '𑠮'),
+    ('𑠸', '𑠸'),
+    ('𑠻', '𑠻'),
+    ('𑢠', '𑣲'),
+    ('𑣿', '𑤆'),
+    ('𑤉', '𑤉'),
+    ('𑤌', '𑤓'),
+    ('𑤕', '𑤖'),
+    ('𑤘', '𑤯'),
+    ('𑤱', '𑤵'),
+    ('𑤷', '𑤸'),
+    ('𑤽', '𑤽'),
+    ('𑤿', '𑥂'),
+    ('𑥄', '𑥆'),
+    ('𑥐', '𑥙'),
+    ('𑦠', '𑦧'),
+    ('𑦪', '𑧓'),
+    ('𑧜', '𑧟'),
+    ('𑧡', '𑧤'),
+    ('𑨀', '𑨀'),
+    ('𑨋', '𑨲'),
+    ('𑨹', '𑨺'),
+    ('𑨿', '𑩆'),
+    ('𑩐', '𑩐'),
+    ('𑩗', '𑩘'),
+    ('𑩜', '𑪉'),
+    ('𑪗', '𑪗'),
+    ('𑪚', '𑪢'),
+    ('𑪰', '𑫸'),
+    ('𑬀', '𑬉'),
+    ('𑰀', '𑰈'),
+    ('𑰊', '𑰯'),
+    ('𑰾', '𑰾'),
+    ('𑱀', '𑱅'),
+    ('𑱐', '𑱬'),
+    ('𑱰', '𑲏'),
+    ('𑲩', '𑲩'),
+    ('𑲱', '𑲱'),
+    ('𑲴', '𑲴'),
+    ('𑴀', '𑴆'),
+    ('𑴈', '𑴉'),
+    ('𑴋', '𑴰'),
+    ('𑵆', '𑵆'),
+    ('𑵐', '𑵙'),
+    ('𑵠', '𑵥'),
+    ('𑵧', '𑵨'),
+    ('𑵪', '𑶎'),
+    ('𑶓', '𑶔'),
+    ('𑶖', '𑶖'),
+    ('𑶘', '𑶘'),
+    ('𑶠', '𑶩'),
+    ('𑻠', '𑻲'),
+    ('𑻵', '𑻸'),
+    ('𑼂', '𑼐'),
+    ('𑼒', '𑼵'),
+    ('𑼾', '𑼿'),
+    ('𑽁', '𑽁'),
+    ('𑽃', '𑽙'),
+    ('𑾰', '𑾰'),
+    ('𑿀', '𑿱'),
+    ('𑿿', '𒎙'),
+    ('𒐀', '𒑮'),
+    ('𒑰', '𒑴'),
+    ('𒒀', '𒕃'),
+    ('𒾐', '𒿲'),
+    ('𓀀', '𓐯'),
+    ('𓑁', '𓑆'),
+    ('𔐀', '𔙆'),
+    ('𖠀', '𖨸'),
+    ('𖩀', '𖩞'),
+    ('𖩠', '𖩩'),
+    ('𖩮', '𖪾'),
+    ('𖫀', '𖫉'),
+    ('𖫐', '𖫭'),
+    ('𖫵', '𖫵'),
+    ('𖬀', '𖬯'),
+    ('𖬷', '𖭅'),
+    ('𖭐', '𖭙'),
+    ('𖭛', '𖭡'),
+    ('𖭣', '𖭷'),
+    ('𖭽', '𖮏'),
+    ('𖹀', '𖺚'),
+    ('𖼀', '𖽊'),
+    ('𖽐', '𖾇'),
+    ('𖾓', '𖾟'),
+    ('𖿠', '𖿣'),
+    ('𖿰', '𖿱'),
+    ('𗀀', '𘟷'),
+    ('𘠀', '𘳕'),
+    ('𘴀', '𘴈'),
+    ('𚿰', '𚿳'),
+    ('𚿵', '𚿻'),
+    ('𚿽', '𚿾'),
+    ('𛀀', '𛄢'),
+    ('𛄲', '𛄲'),
+    ('𛅐', '𛅒'),
+    ('𛅕', '𛅕'),
+    ('𛅤', '𛅧'),
+    ('𛅰', '𛋻'),
+    ('𛰀', '𛱪'),
+    ('𛱰', '𛱼'),
+    ('𛲀', '𛲈'),
+    ('𛲐', '𛲙'),
+    ('𛲜', '𛲜'),
+    ('𛲟', '𛲟'),
+    ('𜽐', '𜿃'),
+    ('𝀀', '𝃵'),
+    ('𝄀', '𝄦'),
+    ('𝄩', '𝅘𝅥𝅲'),
+    ('𝅦', '𝅦'),
+    ('𝅪', '𝅭'),
+    ('𝆃', '𝆄'),
+    ('𝆌', '𝆩'),
+    ('𝆮', '𝇪'),
+    ('𝈀', '𝉁'),
+    ('𝉅', '𝉅'),
+    ('𝋀', '𝋓'),
+    ('𝋠', '𝋳'),
+    ('𝌀', '𝍖'),
+    ('𝍠', '𝍸'),
+    ('𝐀', '𝑔'),
+    ('𝑖', '𝒜'),
+    ('𝒞', '𝒟'),
+    ('𝒢', '𝒢'),
+    ('𝒥', '𝒦'),
+    ('𝒩', '𝒬'),
+    ('𝒮', '𝒹'),
+    ('𝒻', '𝒻'),
+    ('𝒽', '𝓃'),
+    ('𝓅', '𝔅'),
+    ('𝔇', '𝔊'),
+    ('𝔍', '𝔔'),
+    ('𝔖', '𝔜'),
+    ('𝔞', '𝔹'),
+    ('𝔻', '𝔾'),
+    ('𝕀', '𝕄'),
+    ('𝕆', '𝕆'),
+    ('𝕊', '𝕐'),
+    ('𝕒', '𝚥'),
+    ('𝚨', '𝟋'),
+    ('𝟎', '𝧿'),
+    ('𝨷', '𝨺'),
+    ('𝩭', '𝩴'),
+    ('𝩶', '𝪃'),
+    ('𝪅', '𝪋'),
+    ('𝼀', '𝼞'),
+    ('𝼥', '𝼪'),
+    ('𞀰', '𞁭'),
+    ('𞄀', '𞄬'),
+    ('𞄷', '𞄽'),
+    ('𞅀', '𞅉'),
+    ('𞅎', '𞅏'),
+    ('𞊐', '𞊭'),
+    ('𞋀', '𞋫'),
+    ('𞋰', '𞋹'),
+    ('𞋿', '𞋿'),
+    ('𞓐', '𞓫'),
+    ('𞓰', '𞓹'),
+    ('𞟠', '𞟦'),
+    ('𞟨', '𞟫'),
+    ('𞟭', '𞟮'),
+    ('𞟰', '𞟾'),
+    ('𞠀', '𞣄'),
+    ('𞣇', '𞣏'),
+    ('𞤀', '𞥃'),
+    ('𞥋', '𞥋'),
+    ('𞥐', '𞥙'),
+    ('𞥞', '𞥟'),
+    ('𞱱', '𞲴'),
+    ('𞴁', '𞴽'),
+    ('𞸀', '𞸃'),
+    ('𞸅', '𞸟'),
+    ('𞸡', '𞸢'),
+    ('𞸤', '𞸤'),
+    ('𞸧', '𞸧'),
+    ('𞸩', '𞸲'),
+    ('𞸴', '𞸷'),
+    ('𞸹', '𞸹'),
+    ('𞸻', '𞸻'),
+    ('𞹂', '𞹂'),
+    ('𞹇', '𞹇'),
+    ('𞹉', '𞹉'),
+    ('𞹋', '𞹋'),
+    ('𞹍', '𞹏'),
+    ('𞹑', '𞹒'),
+    ('𞹔', '𞹔'),
+    ('𞹗', '𞹗'),
+    ('𞹙', '𞹙'),
+    ('𞹛', '𞹛'),
+    ('𞹝', '𞹝'),
+    ('𞹟', '𞹟'),
+    ('𞹡', '𞹢'),
+    ('𞹤', '𞹤'),
+    ('𞹧', '𞹪'),
+    ('𞹬', '𞹲'),
+    ('𞹴', '𞹷'),
+    ('𞹹', '𞹼'),
+    ('𞹾', '𞹾'),
+    ('𞺀', '𞺉'),
+    ('𞺋', '𞺛'),
+    ('𞺡', '𞺣'),
+    ('𞺥', '𞺩'),
+    ('𞺫', '𞺻'),
+    ('𞻰', '𞻱'),
+    ('🀀', '🀫'),
+    ('🀰', '🂓'),
+    ('🂠', '🂮'),
+    ('🂱', '🂿'),
+    ('🃁', '🃏'),
+    ('🃑', '🃵'),
+    ('🄀', '🆭'),
+    ('🇦', '🈂'),
+    ('🈐', '🈻'),
+    ('🉀', '🉈'),
+    ('🉐', '🉑'),
+    ('🉠', '🉥'),
+    ('🌀', '🛗'),
+    ('🛜', '🛬'),
+    ('🛰', '🛼'),
+    ('🜀', '🝶'),
+    ('🝻', '🟙'),
+    ('🟠', '🟫'),
+    ('🟰', '🟰'),
+    ('🠀', '🠋'),
+    ('🠐', '🡇'),
+    ('🡐', '🡙'),
+    ('🡠', '🢇'),
+    ('🢐', '🢭'),
+    ('🢰', '🢱'),
+    ('🤀', '🩓'),
+    ('🩠', '🩭'),
+    ('🩰', '🩼'),
+    ('🪀', '🪈'),
+    ('🪐', '🪽'),
+    ('🪿', '🫅'),
+    ('🫎', '🫛'),
+    ('🫠', '🫨'),
+    ('🫰', '🫸'),
+    ('🬀', '🮒'),
+    ('🮔', '🯊'),
+    ('🯰', '🯹'),
+    ('𠀀', '𪛟'),
+    ('𪜀', '𫜹'),
+    ('𫝀', '𫠝'),
+    ('𫠠', '𬺡'),
+    ('𬺰', '𮯠'),
+    ('丽', '𪘀'),
+    ('𰀀', '𱍊'),
+    ('𱍐', '𲎯'),
+];
+
+pub const GRAPHEME_EXTEND: &'static [(char, char)] = &[
+    ('\u{300}', '\u{36f}'),
+    ('\u{483}', '\u{489}'),
+    ('\u{591}', '\u{5bd}'),
+    ('\u{5bf}', '\u{5bf}'),
+    ('\u{5c1}', '\u{5c2}'),
+    ('\u{5c4}', '\u{5c5}'),
+    ('\u{5c7}', '\u{5c7}'),
+    ('\u{610}', '\u{61a}'),
+    ('\u{64b}', '\u{65f}'),
+    ('\u{670}', '\u{670}'),
+    ('\u{6d6}', '\u{6dc}'),
+    ('\u{6df}', '\u{6e4}'),
+    ('\u{6e7}', '\u{6e8}'),
+    ('\u{6ea}', '\u{6ed}'),
+    ('\u{711}', '\u{711}'),
+    ('\u{730}', '\u{74a}'),
+    ('\u{7a6}', '\u{7b0}'),
+    ('\u{7eb}', '\u{7f3}'),
+    ('\u{7fd}', '\u{7fd}'),
+    ('\u{816}', '\u{819}'),
+    ('\u{81b}', '\u{823}'),
+    ('\u{825}', '\u{827}'),
+    ('\u{829}', '\u{82d}'),
+    ('\u{859}', '\u{85b}'),
+    ('\u{898}', '\u{89f}'),
+    ('\u{8ca}', '\u{8e1}'),
+    ('\u{8e3}', '\u{902}'),
+    ('\u{93a}', '\u{93a}'),
+    ('\u{93c}', '\u{93c}'),
+    ('\u{941}', '\u{948}'),
+    ('\u{94d}', '\u{94d}'),
+    ('\u{951}', '\u{957}'),
+    ('\u{962}', '\u{963}'),
+    ('\u{981}', '\u{981}'),
+    ('\u{9bc}', '\u{9bc}'),
+    ('\u{9be}', '\u{9be}'),
+    ('\u{9c1}', '\u{9c4}'),
+    ('\u{9cd}', '\u{9cd}'),
+    ('\u{9d7}', '\u{9d7}'),
+    ('\u{9e2}', '\u{9e3}'),
+    ('\u{9fe}', '\u{9fe}'),
+    ('\u{a01}', '\u{a02}'),
+    ('\u{a3c}', '\u{a3c}'),
+    ('\u{a41}', '\u{a42}'),
+    ('\u{a47}', '\u{a48}'),
+    ('\u{a4b}', '\u{a4d}'),
+    ('\u{a51}', '\u{a51}'),
+    ('\u{a70}', '\u{a71}'),
+    ('\u{a75}', '\u{a75}'),
+    ('\u{a81}', '\u{a82}'),
+    ('\u{abc}', '\u{abc}'),
+    ('\u{ac1}', '\u{ac5}'),
+    ('\u{ac7}', '\u{ac8}'),
+    ('\u{acd}', '\u{acd}'),
+    ('\u{ae2}', '\u{ae3}'),
+    ('\u{afa}', '\u{aff}'),
+    ('\u{b01}', '\u{b01}'),
+    ('\u{b3c}', '\u{b3c}'),
+    ('\u{b3e}', '\u{b3f}'),
+    ('\u{b41}', '\u{b44}'),
+    ('\u{b4d}', '\u{b4d}'),
+    ('\u{b55}', '\u{b57}'),
+    ('\u{b62}', '\u{b63}'),
+    ('\u{b82}', '\u{b82}'),
+    ('\u{bbe}', '\u{bbe}'),
+    ('\u{bc0}', '\u{bc0}'),
+    ('\u{bcd}', '\u{bcd}'),
+    ('\u{bd7}', '\u{bd7}'),
+    ('\u{c00}', '\u{c00}'),
+    ('\u{c04}', '\u{c04}'),
+    ('\u{c3c}', '\u{c3c}'),
+    ('\u{c3e}', '\u{c40}'),
+    ('\u{c46}', '\u{c48}'),
+    ('\u{c4a}', '\u{c4d}'),
+    ('\u{c55}', '\u{c56}'),
+    ('\u{c62}', '\u{c63}'),
+    ('\u{c81}', '\u{c81}'),
+    ('\u{cbc}', '\u{cbc}'),
+    ('\u{cbf}', '\u{cbf}'),
+    ('\u{cc2}', '\u{cc2}'),
+    ('\u{cc6}', '\u{cc6}'),
+    ('\u{ccc}', '\u{ccd}'),
+    ('\u{cd5}', '\u{cd6}'),
+    ('\u{ce2}', '\u{ce3}'),
+    ('\u{d00}', '\u{d01}'),
+    ('\u{d3b}', '\u{d3c}'),
+    ('\u{d3e}', '\u{d3e}'),
+    ('\u{d41}', '\u{d44}'),
+    ('\u{d4d}', '\u{d4d}'),
+    ('\u{d57}', '\u{d57}'),
+    ('\u{d62}', '\u{d63}'),
+    ('\u{d81}', '\u{d81}'),
+    ('\u{dca}', '\u{dca}'),
+    ('\u{dcf}', '\u{dcf}'),
+    ('\u{dd2}', '\u{dd4}'),
+    ('\u{dd6}', '\u{dd6}'),
+    ('\u{ddf}', '\u{ddf}'),
+    ('\u{e31}', '\u{e31}'),
+    ('\u{e34}', '\u{e3a}'),
+    ('\u{e47}', '\u{e4e}'),
+    ('\u{eb1}', '\u{eb1}'),
+    ('\u{eb4}', '\u{ebc}'),
+    ('\u{ec8}', '\u{ece}'),
+    ('\u{f18}', '\u{f19}'),
+    ('\u{f35}', '\u{f35}'),
+    ('\u{f37}', '\u{f37}'),
+    ('\u{f39}', '\u{f39}'),
+    ('\u{f71}', '\u{f7e}'),
+    ('\u{f80}', '\u{f84}'),
+    ('\u{f86}', '\u{f87}'),
+    ('\u{f8d}', '\u{f97}'),
+    ('\u{f99}', '\u{fbc}'),
+    ('\u{fc6}', '\u{fc6}'),
+    ('\u{102d}', '\u{1030}'),
+    ('\u{1032}', '\u{1037}'),
+    ('\u{1039}', '\u{103a}'),
+    ('\u{103d}', '\u{103e}'),
+    ('\u{1058}', '\u{1059}'),
+    ('\u{105e}', '\u{1060}'),
+    ('\u{1071}', '\u{1074}'),
+    ('\u{1082}', '\u{1082}'),
+    ('\u{1085}', '\u{1086}'),
+    ('\u{108d}', '\u{108d}'),
+    ('\u{109d}', '\u{109d}'),
+    ('\u{135d}', '\u{135f}'),
+    ('\u{1712}', '\u{1714}'),
+    ('\u{1732}', '\u{1733}'),
+    ('\u{1752}', '\u{1753}'),
+    ('\u{1772}', '\u{1773}'),
+    ('\u{17b4}', '\u{17b5}'),
+    ('\u{17b7}', '\u{17bd}'),
+    ('\u{17c6}', '\u{17c6}'),
+    ('\u{17c9}', '\u{17d3}'),
+    ('\u{17dd}', '\u{17dd}'),
+    ('\u{180b}', '\u{180d}'),
+    ('\u{180f}', '\u{180f}'),
+    ('\u{1885}', '\u{1886}'),
+    ('\u{18a9}', '\u{18a9}'),
+    ('\u{1920}', '\u{1922}'),
+    ('\u{1927}', '\u{1928}'),
+    ('\u{1932}', '\u{1932}'),
+    ('\u{1939}', '\u{193b}'),
+    ('\u{1a17}', '\u{1a18}'),
+    ('\u{1a1b}', '\u{1a1b}'),
+    ('\u{1a56}', '\u{1a56}'),
+    ('\u{1a58}', '\u{1a5e}'),
+    ('\u{1a60}', '\u{1a60}'),
+    ('\u{1a62}', '\u{1a62}'),
+    ('\u{1a65}', '\u{1a6c}'),
+    ('\u{1a73}', '\u{1a7c}'),
+    ('\u{1a7f}', '\u{1a7f}'),
+    ('\u{1ab0}', '\u{1ace}'),
+    ('\u{1b00}', '\u{1b03}'),
+    ('\u{1b34}', '\u{1b3a}'),
+    ('\u{1b3c}', '\u{1b3c}'),
+    ('\u{1b42}', '\u{1b42}'),
+    ('\u{1b6b}', '\u{1b73}'),
+    ('\u{1b80}', '\u{1b81}'),
+    ('\u{1ba2}', '\u{1ba5}'),
+    ('\u{1ba8}', '\u{1ba9}'),
+    ('\u{1bab}', '\u{1bad}'),
+    ('\u{1be6}', '\u{1be6}'),
+    ('\u{1be8}', '\u{1be9}'),
+    ('\u{1bed}', '\u{1bed}'),
+    ('\u{1bef}', '\u{1bf1}'),
+    ('\u{1c2c}', '\u{1c33}'),
+    ('\u{1c36}', '\u{1c37}'),
+    ('\u{1cd0}', '\u{1cd2}'),
+    ('\u{1cd4}', '\u{1ce0}'),
+    ('\u{1ce2}', '\u{1ce8}'),
+    ('\u{1ced}', '\u{1ced}'),
+    ('\u{1cf4}', '\u{1cf4}'),
+    ('\u{1cf8}', '\u{1cf9}'),
+    ('\u{1dc0}', '\u{1dff}'),
+    ('\u{200c}', '\u{200c}'),
+    ('\u{20d0}', '\u{20f0}'),
+    ('\u{2cef}', '\u{2cf1}'),
+    ('\u{2d7f}', '\u{2d7f}'),
+    ('\u{2de0}', '\u{2dff}'),
+    ('\u{302a}', '\u{302f}'),
+    ('\u{3099}', '\u{309a}'),
+    ('\u{a66f}', '\u{a672}'),
+    ('\u{a674}', '\u{a67d}'),
+    ('\u{a69e}', '\u{a69f}'),
+    ('\u{a6f0}', '\u{a6f1}'),
+    ('\u{a802}', '\u{a802}'),
+    ('\u{a806}', '\u{a806}'),
+    ('\u{a80b}', '\u{a80b}'),
+    ('\u{a825}', '\u{a826}'),
+    ('\u{a82c}', '\u{a82c}'),
+    ('\u{a8c4}', '\u{a8c5}'),
+    ('\u{a8e0}', '\u{a8f1}'),
+    ('\u{a8ff}', '\u{a8ff}'),
+    ('\u{a926}', '\u{a92d}'),
+    ('\u{a947}', '\u{a951}'),
+    ('\u{a980}', '\u{a982}'),
+    ('\u{a9b3}', '\u{a9b3}'),
+    ('\u{a9b6}', '\u{a9b9}'),
+    ('\u{a9bc}', '\u{a9bd}'),
+    ('\u{a9e5}', '\u{a9e5}'),
+    ('\u{aa29}', '\u{aa2e}'),
+    ('\u{aa31}', '\u{aa32}'),
+    ('\u{aa35}', '\u{aa36}'),
+    ('\u{aa43}', '\u{aa43}'),
+    ('\u{aa4c}', '\u{aa4c}'),
+    ('\u{aa7c}', '\u{aa7c}'),
+    ('\u{aab0}', '\u{aab0}'),
+    ('\u{aab2}', '\u{aab4}'),
+    ('\u{aab7}', '\u{aab8}'),
+    ('\u{aabe}', '\u{aabf}'),
+    ('\u{aac1}', '\u{aac1}'),
+    ('\u{aaec}', '\u{aaed}'),
+    ('\u{aaf6}', '\u{aaf6}'),
+    ('\u{abe5}', '\u{abe5}'),
+    ('\u{abe8}', '\u{abe8}'),
+    ('\u{abed}', '\u{abed}'),
+    ('\u{fb1e}', '\u{fb1e}'),
+    ('\u{fe00}', '\u{fe0f}'),
+    ('\u{fe20}', '\u{fe2f}'),
+    ('\u{ff9e}', '\u{ff9f}'),
+    ('\u{101fd}', '\u{101fd}'),
+    ('\u{102e0}', '\u{102e0}'),
+    ('\u{10376}', '\u{1037a}'),
+    ('\u{10a01}', '\u{10a03}'),
+    ('\u{10a05}', '\u{10a06}'),
+    ('\u{10a0c}', '\u{10a0f}'),
+    ('\u{10a38}', '\u{10a3a}'),
+    ('\u{10a3f}', '\u{10a3f}'),
+    ('\u{10ae5}', '\u{10ae6}'),
+    ('\u{10d24}', '\u{10d27}'),
+    ('\u{10eab}', '\u{10eac}'),
+    ('\u{10efd}', '\u{10eff}'),
+    ('\u{10f46}', '\u{10f50}'),
+    ('\u{10f82}', '\u{10f85}'),
+    ('\u{11001}', '\u{11001}'),
+    ('\u{11038}', '\u{11046}'),
+    ('\u{11070}', '\u{11070}'),
+    ('\u{11073}', '\u{11074}'),
+    ('\u{1107f}', '\u{11081}'),
+    ('\u{110b3}', '\u{110b6}'),
+    ('\u{110b9}', '\u{110ba}'),
+    ('\u{110c2}', '\u{110c2}'),
+    ('\u{11100}', '\u{11102}'),
+    ('\u{11127}', '\u{1112b}'),
+    ('\u{1112d}', '\u{11134}'),
+    ('\u{11173}', '\u{11173}'),
+    ('\u{11180}', '\u{11181}'),
+    ('\u{111b6}', '\u{111be}'),
+    ('\u{111c9}', '\u{111cc}'),
+    ('\u{111cf}', '\u{111cf}'),
+    ('\u{1122f}', '\u{11231}'),
+    ('\u{11234}', '\u{11234}'),
+    ('\u{11236}', '\u{11237}'),
+    ('\u{1123e}', '\u{1123e}'),
+    ('\u{11241}', '\u{11241}'),
+    ('\u{112df}', '\u{112df}'),
+    ('\u{112e3}', '\u{112ea}'),
+    ('\u{11300}', '\u{11301}'),
+    ('\u{1133b}', '\u{1133c}'),
+    ('\u{1133e}', '\u{1133e}'),
+    ('\u{11340}', '\u{11340}'),
+    ('\u{11357}', '\u{11357}'),
+    ('\u{11366}', '\u{1136c}'),
+    ('\u{11370}', '\u{11374}'),
+    ('\u{11438}', '\u{1143f}'),
+    ('\u{11442}', '\u{11444}'),
+    ('\u{11446}', '\u{11446}'),
+    ('\u{1145e}', '\u{1145e}'),
+    ('\u{114b0}', '\u{114b0}'),
+    ('\u{114b3}', '\u{114b8}'),
+    ('\u{114ba}', '\u{114ba}'),
+    ('\u{114bd}', '\u{114bd}'),
+    ('\u{114bf}', '\u{114c0}'),
+    ('\u{114c2}', '\u{114c3}'),
+    ('\u{115af}', '\u{115af}'),
+    ('\u{115b2}', '\u{115b5}'),
+    ('\u{115bc}', '\u{115bd}'),
+    ('\u{115bf}', '\u{115c0}'),
+    ('\u{115dc}', '\u{115dd}'),
+    ('\u{11633}', '\u{1163a}'),
+    ('\u{1163d}', '\u{1163d}'),
+    ('\u{1163f}', '\u{11640}'),
+    ('\u{116ab}', '\u{116ab}'),
+    ('\u{116ad}', '\u{116ad}'),
+    ('\u{116b0}', '\u{116b5}'),
+    ('\u{116b7}', '\u{116b7}'),
+    ('\u{1171d}', '\u{1171f}'),
+    ('\u{11722}', '\u{11725}'),
+    ('\u{11727}', '\u{1172b}'),
+    ('\u{1182f}', '\u{11837}'),
+    ('\u{11839}', '\u{1183a}'),
+    ('\u{11930}', '\u{11930}'),
+    ('\u{1193b}', '\u{1193c}'),
+    ('\u{1193e}', '\u{1193e}'),
+    ('\u{11943}', '\u{11943}'),
+    ('\u{119d4}', '\u{119d7}'),
+    ('\u{119da}', '\u{119db}'),
+    ('\u{119e0}', '\u{119e0}'),
+    ('\u{11a01}', '\u{11a0a}'),
+    ('\u{11a33}', '\u{11a38}'),
+    ('\u{11a3b}', '\u{11a3e}'),
+    ('\u{11a47}', '\u{11a47}'),
+    ('\u{11a51}', '\u{11a56}'),
+    ('\u{11a59}', '\u{11a5b}'),
+    ('\u{11a8a}', '\u{11a96}'),
+    ('\u{11a98}', '\u{11a99}'),
+    ('\u{11c30}', '\u{11c36}'),
+    ('\u{11c38}', '\u{11c3d}'),
+    ('\u{11c3f}', '\u{11c3f}'),
+    ('\u{11c92}', '\u{11ca7}'),
+    ('\u{11caa}', '\u{11cb0}'),
+    ('\u{11cb2}', '\u{11cb3}'),
+    ('\u{11cb5}', '\u{11cb6}'),
+    ('\u{11d31}', '\u{11d36}'),
+    ('\u{11d3a}', '\u{11d3a}'),
+    ('\u{11d3c}', '\u{11d3d}'),
+    ('\u{11d3f}', '\u{11d45}'),
+    ('\u{11d47}', '\u{11d47}'),
+    ('\u{11d90}', '\u{11d91}'),
+    ('\u{11d95}', '\u{11d95}'),
+    ('\u{11d97}', '\u{11d97}'),
+    ('\u{11ef3}', '\u{11ef4}'),
+    ('\u{11f00}', '\u{11f01}'),
+    ('\u{11f36}', '\u{11f3a}'),
+    ('\u{11f40}', '\u{11f40}'),
+    ('\u{11f42}', '\u{11f42}'),
+    ('\u{13440}', '\u{13440}'),
+    ('\u{13447}', '\u{13455}'),
+    ('\u{16af0}', '\u{16af4}'),
+    ('\u{16b30}', '\u{16b36}'),
+    ('\u{16f4f}', '\u{16f4f}'),
+    ('\u{16f8f}', '\u{16f92}'),
+    ('\u{16fe4}', '\u{16fe4}'),
+    ('\u{1bc9d}', '\u{1bc9e}'),
+    ('\u{1cf00}', '\u{1cf2d}'),
+    ('\u{1cf30}', '\u{1cf46}'),
+    ('\u{1d165}', '\u{1d165}'),
+    ('\u{1d167}', '\u{1d169}'),
+    ('\u{1d16e}', '\u{1d172}'),
+    ('\u{1d17b}', '\u{1d182}'),
+    ('\u{1d185}', '\u{1d18b}'),
+    ('\u{1d1aa}', '\u{1d1ad}'),
+    ('\u{1d242}', '\u{1d244}'),
+    ('\u{1da00}', '\u{1da36}'),
+    ('\u{1da3b}', '\u{1da6c}'),
+    ('\u{1da75}', '\u{1da75}'),
+    ('\u{1da84}', '\u{1da84}'),
+    ('\u{1da9b}', '\u{1da9f}'),
+    ('\u{1daa1}', '\u{1daaf}'),
+    ('\u{1e000}', '\u{1e006}'),
+    ('\u{1e008}', '\u{1e018}'),
+    ('\u{1e01b}', '\u{1e021}'),
+    ('\u{1e023}', '\u{1e024}'),
+    ('\u{1e026}', '\u{1e02a}'),
+    ('\u{1e08f}', '\u{1e08f}'),
+    ('\u{1e130}', '\u{1e136}'),
+    ('\u{1e2ae}', '\u{1e2ae}'),
+    ('\u{1e2ec}', '\u{1e2ef}'),
+    ('\u{1e4ec}', '\u{1e4ef}'),
+    ('\u{1e8d0}', '\u{1e8d6}'),
+    ('\u{1e944}', '\u{1e94a}'),
+    ('\u{e0020}', '\u{e007f}'),
+    ('\u{e0100}', '\u{e01ef}'),
+];
+
+pub const GRAPHEME_LINK: &'static [(char, char)] = &[
+    ('\u{94d}', '\u{94d}'),
+    ('\u{9cd}', '\u{9cd}'),
+    ('\u{a4d}', '\u{a4d}'),
+    ('\u{acd}', '\u{acd}'),
+    ('\u{b4d}', '\u{b4d}'),
+    ('\u{bcd}', '\u{bcd}'),
+    ('\u{c4d}', '\u{c4d}'),
+    ('\u{ccd}', '\u{ccd}'),
+    ('\u{d3b}', '\u{d3c}'),
+    ('\u{d4d}', '\u{d4d}'),
+    ('\u{dca}', '\u{dca}'),
+    ('\u{e3a}', '\u{e3a}'),
+    ('\u{eba}', '\u{eba}'),
+    ('\u{f84}', '\u{f84}'),
+    ('\u{1039}', '\u{103a}'),
+    ('\u{1714}', '᜕'),
+    ('᜴', '᜴'),
+    ('\u{17d2}', '\u{17d2}'),
+    ('\u{1a60}', '\u{1a60}'),
+    ('᭄', '᭄'),
+    ('᮪', '\u{1bab}'),
+    ('᯲', '᯳'),
+    ('\u{2d7f}', '\u{2d7f}'),
+    ('\u{a806}', '\u{a806}'),
+    ('\u{a82c}', '\u{a82c}'),
+    ('\u{a8c4}', '\u{a8c4}'),
+    ('꥓', '꥓'),
+    ('꧀', '꧀'),
+    ('\u{aaf6}', '\u{aaf6}'),
+    ('\u{abed}', '\u{abed}'),
+    ('\u{10a3f}', '\u{10a3f}'),
+    ('\u{11046}', '\u{11046}'),
+    ('\u{11070}', '\u{11070}'),
+    ('\u{1107f}', '\u{1107f}'),
+    ('\u{110b9}', '\u{110b9}'),
+    ('\u{11133}', '\u{11134}'),
+    ('𑇀', '𑇀'),
+    ('𑈵', '𑈵'),
+    ('\u{112ea}', '\u{112ea}'),
+    ('𑍍', '𑍍'),
+    ('\u{11442}', '\u{11442}'),
+    ('\u{114c2}', '\u{114c2}'),
+    ('\u{115bf}', '\u{115bf}'),
+    ('\u{1163f}', '\u{1163f}'),
+    ('𑚶', '𑚶'),
+    ('\u{1172b}', '\u{1172b}'),
+    ('\u{11839}', '\u{11839}'),
+    ('𑤽', '\u{1193e}'),
+    ('\u{119e0}', '\u{119e0}'),
+    ('\u{11a34}', '\u{11a34}'),
+    ('\u{11a47}', '\u{11a47}'),
+    ('\u{11a99}', '\u{11a99}'),
+    ('\u{11c3f}', '\u{11c3f}'),
+    ('\u{11d44}', '\u{11d45}'),
+    ('\u{11d97}', '\u{11d97}'),
+    ('𑽁', '\u{11f42}'),
+];
+
+pub const HEX_DIGIT: &'static [(char, char)] = &[
+    ('0', '9'),
+    ('A', 'F'),
+    ('a', 'f'),
+    ('０', '９'),
+    ('Ａ', 'Ｆ'),
+    ('ａ', 'ｆ'),
+];
+
+pub const HYPHEN: &'static [(char, char)] = &[
+    ('-', '-'),
+    ('\u{ad}', '\u{ad}'),
+    ('֊', '֊'),
+    ('᠆', '᠆'),
+    ('‐', '‑'),
+    ('⸗', '⸗'),
+    ('・', '・'),
+    ('﹣', '﹣'),
+    ('－', '－'),
+    ('･', '･'),
+];
+
+pub const IDS_BINARY_OPERATOR: &'static [(char, char)] =
+    &[('⿰', '⿱'), ('⿴', '⿻')];
+
+pub const IDS_TRINARY_OPERATOR: &'static [(char, char)] = &[('⿲', '⿳')];
+
+pub const ID_CONTINUE: &'static [(char, char)] = &[
+    ('0', '9'),
+    ('A', 'Z'),
+    ('_', '_'),
+    ('a', 'z'),
+    ('ª', 'ª'),
+    ('µ', 'µ'),
+    ('·', '·'),
+    ('º', 'º'),
+    ('À', 'Ö'),
+    ('Ø', 'ö'),
+    ('ø', 'ˁ'),
+    ('ˆ', 'ˑ'),
+    ('ˠ', 'ˤ'),
+    ('ˬ', 'ˬ'),
+    ('ˮ', 'ˮ'),
+    ('\u{300}', 'ʹ'),
+    ('Ͷ', 'ͷ'),
+    ('ͺ', 'ͽ'),
+    ('Ϳ', 'Ϳ'),
+    ('Ά', 'Ί'),
+    ('Ό', 'Ό'),
+    ('Ύ', 'Ρ'),
+    ('Σ', 'ϵ'),
+    ('Ϸ', 'ҁ'),
+    ('\u{483}', '\u{487}'),
+    ('Ҋ', 'ԯ'),
+    ('Ա', 'Ֆ'),
+    ('ՙ', 'ՙ'),
+    ('ՠ', 'ֈ'),
+    ('\u{591}', '\u{5bd}'),
+    ('\u{5bf}', '\u{5bf}'),
+    ('\u{5c1}', '\u{5c2}'),
+    ('\u{5c4}', '\u{5c5}'),
+    ('\u{5c7}', '\u{5c7}'),
+    ('א', 'ת'),
+    ('ׯ', 'ײ'),
+    ('\u{610}', '\u{61a}'),
+    ('ؠ', '٩'),
+    ('ٮ', 'ۓ'),
+    ('ە', '\u{6dc}'),
+    ('\u{6df}', '\u{6e8}'),
+    ('\u{6ea}', 'ۼ'),
+    ('ۿ', 'ۿ'),
+    ('ܐ', '\u{74a}'),
+    ('ݍ', 'ޱ'),
+    ('߀', 'ߵ'),
+    ('ߺ', 'ߺ'),
+    ('\u{7fd}', '\u{7fd}'),
+    ('ࠀ', '\u{82d}'),
+    ('ࡀ', '\u{85b}'),
+    ('ࡠ', 'ࡪ'),
+    ('ࡰ', 'ࢇ'),
+    ('ࢉ', 'ࢎ'),
+    ('\u{898}', '\u{8e1}'),
+    ('\u{8e3}', '\u{963}'),
+    ('०', '९'),
+    ('ॱ', 'ঃ'),
+    ('অ', 'ঌ'),
+    ('এ', 'ঐ'),
+    ('ও', 'ন'),
+    ('প', 'র'),
+    ('ল', 'ল'),
+    ('শ', 'হ'),
+    ('\u{9bc}', '\u{9c4}'),
+    ('ে', 'ৈ'),
+    ('ো', 'ৎ'),
+    ('\u{9d7}', '\u{9d7}'),
+    ('ড়', 'ঢ়'),
+    ('য়', '\u{9e3}'),
+    ('০', 'ৱ'),
+    ('ৼ', 'ৼ'),
+    ('\u{9fe}', '\u{9fe}'),
+    ('\u{a01}', 'ਃ'),
+    ('ਅ', 'ਊ'),
+    ('ਏ', 'ਐ'),
+    ('ਓ', 'ਨ'),
+    ('ਪ', 'ਰ'),
+    ('ਲ', 'ਲ਼'),
+    ('ਵ', 'ਸ਼'),
+    ('ਸ', 'ਹ'),
+    ('\u{a3c}', '\u{a3c}'),
+    ('ਾ', '\u{a42}'),
+    ('\u{a47}', '\u{a48}'),
+    ('\u{a4b}', '\u{a4d}'),
+    ('\u{a51}', '\u{a51}'),
+    ('ਖ਼', 'ੜ'),
+    ('ਫ਼', 'ਫ਼'),
+    ('੦', '\u{a75}'),
+    ('\u{a81}', 'ઃ'),
+    ('અ', 'ઍ'),
+    ('એ', 'ઑ'),
+    ('ઓ', 'ન'),
+    ('પ', 'ર'),
+    ('લ', 'ળ'),
+    ('વ', 'હ'),
+    ('\u{abc}', '\u{ac5}'),
+    ('\u{ac7}', 'ૉ'),
+    ('ો', '\u{acd}'),
+    ('ૐ', 'ૐ'),
+    ('ૠ', '\u{ae3}'),
+    ('૦', '૯'),
+    ('ૹ', '\u{aff}'),
+    ('\u{b01}', 'ଃ'),
+    ('ଅ', 'ଌ'),
+    ('ଏ', 'ଐ'),
+    ('ଓ', 'ନ'),
+    ('ପ', 'ର'),
+    ('ଲ', 'ଳ'),
+    ('ଵ', 'ହ'),
+    ('\u{b3c}', '\u{b44}'),
+    ('େ', 'ୈ'),
+    ('ୋ', '\u{b4d}'),
+    ('\u{b55}', '\u{b57}'),
+    ('ଡ଼', 'ଢ଼'),
+    ('ୟ', '\u{b63}'),
+    ('୦', '୯'),
+    ('ୱ', 'ୱ'),
+    ('\u{b82}', 'ஃ'),
+    ('அ', 'ஊ'),
+    ('எ', 'ஐ'),
+    ('ஒ', 'க'),
+    ('ங', 'ச'),
+    ('ஜ', 'ஜ'),
+    ('ஞ', 'ட'),
+    ('ண', 'த'),
+    ('ந', 'ப'),
+    ('ம', 'ஹ'),
+    ('\u{bbe}', 'ூ'),
+    ('ெ', 'ை'),
+    ('ொ', '\u{bcd}'),
+    ('ௐ', 'ௐ'),
+    ('\u{bd7}', '\u{bd7}'),
+    ('௦', '௯'),
+    ('\u{c00}', 'ఌ'),
+    ('ఎ', 'ఐ'),
+    ('ఒ', 'న'),
+    ('ప', 'హ'),
+    ('\u{c3c}', 'ౄ'),
+    ('\u{c46}', '\u{c48}'),
+    ('\u{c4a}', '\u{c4d}'),
+    ('\u{c55}', '\u{c56}'),
+    ('ౘ', 'ౚ'),
+    ('ౝ', 'ౝ'),
+    ('ౠ', '\u{c63}'),
+    ('౦', '౯'),
+    ('ಀ', 'ಃ'),
+    ('ಅ', 'ಌ'),
+    ('ಎ', 'ಐ'),
+    ('ಒ', 'ನ'),
+    ('ಪ', 'ಳ'),
+    ('ವ', 'ಹ'),
+    ('\u{cbc}', 'ೄ'),
+    ('\u{cc6}', 'ೈ'),
+    ('ೊ', '\u{ccd}'),
+    ('\u{cd5}', '\u{cd6}'),
+    ('ೝ', 'ೞ'),
+    ('ೠ', '\u{ce3}'),
+    ('೦', '೯'),
+    ('ೱ', 'ೳ'),
+    ('\u{d00}', 'ഌ'),
+    ('എ', 'ഐ'),
+    ('ഒ', '\u{d44}'),
+    ('െ', 'ൈ'),
+    ('ൊ', 'ൎ'),
+    ('ൔ', '\u{d57}'),
+    ('ൟ', '\u{d63}'),
+    ('൦', '൯'),
+    ('ൺ', 'ൿ'),
+    ('\u{d81}', 'ඃ'),
+    ('අ', 'ඖ'),
+    ('ක', 'න'),
+    ('ඳ', 'ර'),
+    ('ල', 'ල'),
+    ('ව', 'ෆ'),
+    ('\u{dca}', '\u{dca}'),
+    ('\u{dcf}', '\u{dd4}'),
+    ('\u{dd6}', '\u{dd6}'),
+    ('ෘ', '\u{ddf}'),
+    ('෦', '෯'),
+    ('ෲ', 'ෳ'),
+    ('ก', '\u{e3a}'),
+    ('เ', '\u{e4e}'),
+    ('๐', '๙'),
+    ('ກ', 'ຂ'),
+    ('ຄ', 'ຄ'),
+    ('ຆ', 'ຊ'),
+    ('ຌ', 'ຣ'),
+    ('ລ', 'ລ'),
+    ('ວ', 'ຽ'),
+    ('ເ', 'ໄ'),
+    ('ໆ', 'ໆ'),
+    ('\u{ec8}', '\u{ece}'),
+    ('໐', '໙'),
+    ('ໜ', 'ໟ'),
+    ('ༀ', 'ༀ'),
+    ('\u{f18}', '\u{f19}'),
+    ('༠', '༩'),
+    ('\u{f35}', '\u{f35}'),
+    ('\u{f37}', '\u{f37}'),
+    ('\u{f39}', '\u{f39}'),
+    ('༾', 'ཇ'),
+    ('ཉ', 'ཬ'),
+    ('\u{f71}', '\u{f84}'),
+    ('\u{f86}', '\u{f97}'),
+    ('\u{f99}', '\u{fbc}'),
+    ('\u{fc6}', '\u{fc6}'),
+    ('က', '၉'),
+    ('ၐ', '\u{109d}'),
+    ('Ⴀ', 'Ⴥ'),
+    ('Ⴧ', 'Ⴧ'),
+    ('Ⴭ', 'Ⴭ'),
+    ('ა', 'ჺ'),
+    ('ჼ', 'ቈ'),
+    ('ቊ', 'ቍ'),
+    ('ቐ', 'ቖ'),
+    ('ቘ', 'ቘ'),
+    ('ቚ', 'ቝ'),
+    ('በ', 'ኈ'),
+    ('ኊ', 'ኍ'),
+    ('ነ', 'ኰ'),
+    ('ኲ', 'ኵ'),
+    ('ኸ', 'ኾ'),
+    ('ዀ', 'ዀ'),
+    ('ዂ', 'ዅ'),
+    ('ወ', 'ዖ'),
+    ('ዘ', 'ጐ'),
+    ('ጒ', 'ጕ'),
+    ('ጘ', 'ፚ'),
+    ('\u{135d}', '\u{135f}'),
+    ('፩', '፱'),
+    ('ᎀ', 'ᎏ'),
+    ('Ꭰ', 'Ᏽ'),
+    ('ᏸ', 'ᏽ'),
+    ('ᐁ', 'ᙬ'),
+    ('ᙯ', 'ᙿ'),
+    ('ᚁ', 'ᚚ'),
+    ('ᚠ', 'ᛪ'),
+    ('ᛮ', 'ᛸ'),
+    ('ᜀ', '᜕'),
+    ('ᜟ', '᜴'),
+    ('ᝀ', '\u{1753}'),
+    ('ᝠ', 'ᝬ'),
+    ('ᝮ', 'ᝰ'),
+    ('\u{1772}', '\u{1773}'),
+    ('ក', '\u{17d3}'),
+    ('ៗ', 'ៗ'),
+    ('ៜ', '\u{17dd}'),
+    ('០', '៩'),
+    ('\u{180b}', '\u{180d}'),
+    ('\u{180f}', '᠙'),
+    ('ᠠ', 'ᡸ'),
+    ('ᢀ', 'ᢪ'),
+    ('ᢰ', 'ᣵ'),
+    ('ᤀ', 'ᤞ'),
+    ('\u{1920}', 'ᤫ'),
+    ('ᤰ', '\u{193b}'),
+    ('᥆', 'ᥭ'),
+    ('ᥰ', 'ᥴ'),
+    ('ᦀ', 'ᦫ'),
+    ('ᦰ', 'ᧉ'),
+    ('᧐', '᧚'),
+    ('ᨀ', '\u{1a1b}'),
+    ('ᨠ', '\u{1a5e}'),
+    ('\u{1a60}', '\u{1a7c}'),
+    ('\u{1a7f}', '᪉'),
+    ('᪐', '᪙'),
+    ('ᪧ', 'ᪧ'),
+    ('\u{1ab0}', '\u{1abd}'),
+    ('\u{1abf}', '\u{1ace}'),
+    ('\u{1b00}', 'ᭌ'),
+    ('᭐', '᭙'),
+    ('\u{1b6b}', '\u{1b73}'),
+    ('\u{1b80}', '᯳'),
+    ('ᰀ', '\u{1c37}'),
+    ('᱀', '᱉'),
+    ('ᱍ', 'ᱽ'),
+    ('ᲀ', 'ᲈ'),
+    ('Ა', 'Ჺ'),
+    ('Ჽ', 'Ჿ'),
+    ('\u{1cd0}', '\u{1cd2}'),
+    ('\u{1cd4}', 'ᳺ'),
+    ('ᴀ', 'ἕ'),
+    ('Ἐ', 'Ἕ'),
+    ('ἠ', 'ὅ'),
+    ('Ὀ', 'Ὅ'),
+    ('ὐ', 'ὗ'),
+    ('Ὑ', 'Ὑ'),
+    ('Ὓ', 'Ὓ'),
+    ('Ὕ', 'Ὕ'),
+    ('Ὗ', 'ώ'),
+    ('ᾀ', 'ᾴ'),
+    ('ᾶ', 'ᾼ'),
+    ('ι', 'ι'),
+    ('ῂ', 'ῄ'),
+    ('ῆ', 'ῌ'),
+    ('ῐ', 'ΐ'),
+    ('ῖ', 'Ί'),
+    ('ῠ', 'Ῥ'),
+    ('ῲ', 'ῴ'),
+    ('ῶ', 'ῼ'),
+    ('‿', '⁀'),
+    ('⁔', '⁔'),
+    ('ⁱ', 'ⁱ'),
+    ('ⁿ', 'ⁿ'),
+    ('ₐ', 'ₜ'),
+    ('\u{20d0}', '\u{20dc}'),
+    ('\u{20e1}', '\u{20e1}'),
+    ('\u{20e5}', '\u{20f0}'),
+    ('ℂ', 'ℂ'),
+    ('ℇ', 'ℇ'),
+    ('ℊ', 'ℓ'),
+    ('ℕ', 'ℕ'),
+    ('℘', 'ℝ'),
+    ('ℤ', 'ℤ'),
+    ('Ω', 'Ω'),
+    ('ℨ', 'ℨ'),
+    ('K', 'ℹ'),
+    ('ℼ', 'ℿ'),
+    ('ⅅ', 'ⅉ'),
+    ('ⅎ', 'ⅎ'),
+    ('Ⅰ', 'ↈ'),
+    ('Ⰰ', 'ⳤ'),
+    ('Ⳬ', 'ⳳ'),
+    ('ⴀ', 'ⴥ'),
+    ('ⴧ', 'ⴧ'),
+    ('ⴭ', 'ⴭ'),
+    ('ⴰ', 'ⵧ'),
+    ('ⵯ', 'ⵯ'),
+    ('\u{2d7f}', 'ⶖ'),
+    ('ⶠ', 'ⶦ'),
+    ('ⶨ', 'ⶮ'),
+    ('ⶰ', 'ⶶ'),
+    ('ⶸ', 'ⶾ'),
+    ('ⷀ', 'ⷆ'),
+    ('ⷈ', 'ⷎ'),
+    ('ⷐ', 'ⷖ'),
+    ('ⷘ', 'ⷞ'),
+    ('\u{2de0}', '\u{2dff}'),
+    ('々', '〇'),
+    ('〡', '\u{302f}'),
+    ('〱', '〵'),
+    ('〸', '〼'),
+    ('ぁ', 'ゖ'),
+    ('\u{3099}', 'ゟ'),
+    ('ァ', 'ヺ'),
+    ('ー', 'ヿ'),
+    ('ㄅ', 'ㄯ'),
+    ('ㄱ', 'ㆎ'),
+    ('ㆠ', 'ㆿ'),
+    ('ㇰ', 'ㇿ'),
+    ('㐀', '䶿'),
+    ('一', 'ꒌ'),
+    ('ꓐ', 'ꓽ'),
+    ('ꔀ', 'ꘌ'),
+    ('ꘐ', 'ꘫ'),
+    ('Ꙁ', '\u{a66f}'),
+    ('\u{a674}', '\u{a67d}'),
+    ('ꙿ', '\u{a6f1}'),
+    ('ꜗ', 'ꜟ'),
+    ('Ꜣ', 'ꞈ'),
+    ('Ꞌ', 'ꟊ'),
+    ('Ꟑ', 'ꟑ'),
+    ('ꟓ', 'ꟓ'),
+    ('ꟕ', 'ꟙ'),
+    ('ꟲ', 'ꠧ'),
+    ('\u{a82c}', '\u{a82c}'),
+    ('ꡀ', 'ꡳ'),
+    ('ꢀ', '\u{a8c5}'),
+    ('꣐', '꣙'),
+    ('\u{a8e0}', 'ꣷ'),
+    ('ꣻ', 'ꣻ'),
+    ('ꣽ', '\u{a92d}'),
+    ('ꤰ', '꥓'),
+    ('ꥠ', 'ꥼ'),
+    ('\u{a980}', '꧀'),
+    ('ꧏ', '꧙'),
+    ('ꧠ', 'ꧾ'),
+    ('ꨀ', '\u{aa36}'),
+    ('ꩀ', 'ꩍ'),
+    ('꩐', '꩙'),
+    ('ꩠ', 'ꩶ'),
+    ('ꩺ', 'ꫂ'),
+    ('ꫛ', 'ꫝ'),
+    ('ꫠ', 'ꫯ'),
+    ('ꫲ', '\u{aaf6}'),
+    ('ꬁ', 'ꬆ'),
+    ('ꬉ', 'ꬎ'),
+    ('ꬑ', 'ꬖ'),
+    ('ꬠ', 'ꬦ'),
+    ('ꬨ', 'ꬮ'),
+    ('ꬰ', 'ꭚ'),
+    ('ꭜ', 'ꭩ'),
+    ('ꭰ', 'ꯪ'),
+    ('꯬', '\u{abed}'),
+    ('꯰', '꯹'),
+    ('가', '힣'),
+    ('ힰ', 'ퟆ'),
+    ('ퟋ', 'ퟻ'),
+    ('豈', '舘'),
+    ('並', '龎'),
+    ('ﬀ', 'ﬆ'),
+    ('ﬓ', 'ﬗ'),
+    ('יִ', 'ﬨ'),
+    ('שׁ', 'זּ'),
+    ('טּ', 'לּ'),
+    ('מּ', 'מּ'),
+    ('נּ', 'סּ'),
+    ('ףּ', 'פּ'),
+    ('צּ', 'ﮱ'),
+    ('ﯓ', 'ﴽ'),
+    ('ﵐ', 'ﶏ'),
+    ('ﶒ', 'ﷇ'),
+    ('ﷰ', 'ﷻ'),
+    ('\u{fe00}', '\u{fe0f}'),
+    ('\u{fe20}', '\u{fe2f}'),
+    ('︳', '︴'),
+    ('﹍', '﹏'),
+    ('ﹰ', 'ﹴ'),
+    ('ﹶ', 'ﻼ'),
+    ('０', '９'),
+    ('Ａ', 'Ｚ'),
+    ('＿', '＿'),
+    ('ａ', 'ｚ'),
+    ('ｦ', 'ﾾ'),
+    ('ￂ', 'ￇ'),
+    ('ￊ', 'ￏ'),
+    ('ￒ', 'ￗ'),
+    ('ￚ', 'ￜ'),
+    ('𐀀', '𐀋'),
+    ('𐀍', '𐀦'),
+    ('𐀨', '𐀺'),
+    ('𐀼', '𐀽'),
+    ('𐀿', '𐁍'),
+    ('𐁐', '𐁝'),
+    ('𐂀', '𐃺'),
+    ('𐅀', '𐅴'),
+    ('\u{101fd}', '\u{101fd}'),
+    ('𐊀', '𐊜'),
+    ('𐊠', '𐋐'),
+    ('\u{102e0}', '\u{102e0}'),
+    ('𐌀', '𐌟'),
+    ('𐌭', '𐍊'),
+    ('𐍐', '\u{1037a}'),
+    ('𐎀', '𐎝'),
+    ('𐎠', '𐏃'),
+    ('𐏈', '𐏏'),
+    ('𐏑', '𐏕'),
+    ('𐐀', '𐒝'),
+    ('𐒠', '𐒩'),
+    ('𐒰', '𐓓'),
+    ('𐓘', '𐓻'),
+    ('𐔀', '𐔧'),
+    ('𐔰', '𐕣'),
+    ('𐕰', '𐕺'),
+    ('𐕼', '𐖊'),
+    ('𐖌', '𐖒'),
+    ('𐖔', '𐖕'),
+    ('𐖗', '𐖡'),
+    ('𐖣', '𐖱'),
+    ('𐖳', '𐖹'),
+    ('𐖻', '𐖼'),
+    ('𐘀', '𐜶'),
+    ('𐝀', '𐝕'),
+    ('𐝠', '𐝧'),
+    ('𐞀', '𐞅'),
+    ('𐞇', '𐞰'),
+    ('𐞲', '𐞺'),
+    ('𐠀', '𐠅'),
+    ('𐠈', '𐠈'),
+    ('𐠊', '𐠵'),
+    ('𐠷', '𐠸'),
+    ('𐠼', '𐠼'),
+    ('𐠿', '𐡕'),
+    ('𐡠', '𐡶'),
+    ('𐢀', '𐢞'),
+    ('𐣠', '𐣲'),
+    ('𐣴', '𐣵'),
+    ('𐤀', '𐤕'),
+    ('𐤠', '𐤹'),
+    ('𐦀', '𐦷'),
+    ('𐦾', '𐦿'),
+    ('𐨀', '\u{10a03}'),
+    ('\u{10a05}', '\u{10a06}'),
+    ('\u{10a0c}', '𐨓'),
+    ('𐨕', '𐨗'),
+    ('𐨙', '𐨵'),
+    ('\u{10a38}', '\u{10a3a}'),
+    ('\u{10a3f}', '\u{10a3f}'),
+    ('𐩠', '𐩼'),
+    ('𐪀', '𐪜'),
+    ('𐫀', '𐫇'),
+    ('𐫉', '\u{10ae6}'),
+    ('𐬀', '𐬵'),
+    ('𐭀', '𐭕'),
+    ('𐭠', '𐭲'),
+    ('𐮀', '𐮑'),
+    ('𐰀', '𐱈'),
+    ('𐲀', '𐲲'),
+    ('𐳀', '𐳲'),
+    ('𐴀', '\u{10d27}'),
+    ('𐴰', '𐴹'),
+    ('𐺀', '𐺩'),
+    ('\u{10eab}', '\u{10eac}'),
+    ('𐺰', '𐺱'),
+    ('\u{10efd}', '𐼜'),
+    ('𐼧', '𐼧'),
+    ('𐼰', '\u{10f50}'),
+    ('𐽰', '\u{10f85}'),
+    ('𐾰', '𐿄'),
+    ('𐿠', '𐿶'),
+    ('𑀀', '\u{11046}'),
+    ('𑁦', '𑁵'),
+    ('\u{1107f}', '\u{110ba}'),
+    ('\u{110c2}', '\u{110c2}'),
+    ('𑃐', '𑃨'),
+    ('𑃰', '𑃹'),
+    ('\u{11100}', '\u{11134}'),
+    ('𑄶', '𑄿'),
+    ('𑅄', '𑅇'),
+    ('𑅐', '\u{11173}'),
+    ('𑅶', '𑅶'),
+    ('\u{11180}', '𑇄'),
+    ('\u{111c9}', '\u{111cc}'),
+    ('𑇎', '𑇚'),
+    ('𑇜', '𑇜'),
+    ('𑈀', '𑈑'),
+    ('𑈓', '\u{11237}'),
+    ('\u{1123e}', '\u{11241}'),
+    ('𑊀', '𑊆'),
+    ('𑊈', '𑊈'),
+    ('𑊊', '𑊍'),
+    ('𑊏', '𑊝'),
+    ('𑊟', '𑊨'),
+    ('𑊰', '\u{112ea}'),
+    ('𑋰', '𑋹'),
+    ('\u{11300}', '𑌃'),
+    ('𑌅', '𑌌'),
+    ('𑌏', '𑌐'),
+    ('𑌓', '𑌨'),
+    ('𑌪', '𑌰'),
+    ('𑌲', '𑌳'),
+    ('𑌵', '𑌹'),
+    ('\u{1133b}', '𑍄'),
+    ('𑍇', '𑍈'),
+    ('𑍋', '𑍍'),
+    ('𑍐', '𑍐'),
+    ('\u{11357}', '\u{11357}'),
+    ('𑍝', '𑍣'),
+    ('\u{11366}', '\u{1136c}'),
+    ('\u{11370}', '\u{11374}'),
+    ('𑐀', '𑑊'),
+    ('𑑐', '𑑙'),
+    ('\u{1145e}', '𑑡'),
+    ('𑒀', '𑓅'),
+    ('𑓇', '𑓇'),
+    ('𑓐', '𑓙'),
+    ('𑖀', '\u{115b5}'),
+    ('𑖸', '\u{115c0}'),
+    ('𑗘', '\u{115dd}'),
+    ('𑘀', '\u{11640}'),
+    ('𑙄', '𑙄'),
+    ('𑙐', '𑙙'),
+    ('𑚀', '𑚸'),
+    ('𑛀', '𑛉'),
+    ('𑜀', '𑜚'),
+    ('\u{1171d}', '\u{1172b}'),
+    ('𑜰', '𑜹'),
+    ('𑝀', '𑝆'),
+    ('𑠀', '\u{1183a}'),
+    ('𑢠', '𑣩'),
+    ('𑣿', '𑤆'),
+    ('𑤉', '𑤉'),
+    ('𑤌', '𑤓'),
+    ('𑤕', '𑤖'),
+    ('𑤘', '𑤵'),
+    ('𑤷', '𑤸'),
+    ('\u{1193b}', '\u{11943}'),
+    ('𑥐', '𑥙'),
+    ('𑦠', '𑦧'),
+    ('𑦪', '\u{119d7}'),
+    ('\u{119da}', '𑧡'),
+    ('𑧣', '𑧤'),
+    ('𑨀', '\u{11a3e}'),
+    ('\u{11a47}', '\u{11a47}'),
+    ('𑩐', '\u{11a99}'),
+    ('𑪝', '𑪝'),
+    ('𑪰', '𑫸'),
+    ('𑰀', '𑰈'),
+    ('𑰊', '\u{11c36}'),
+    ('\u{11c38}', '𑱀'),
+    ('𑱐', '𑱙'),
+    ('𑱲', '𑲏'),
+    ('\u{11c92}', '\u{11ca7}'),
+    ('𑲩', '\u{11cb6}'),
+    ('𑴀', '𑴆'),
+    ('𑴈', '𑴉'),
+    ('𑴋', '\u{11d36}'),
+    ('\u{11d3a}', '\u{11d3a}'),
+    ('\u{11d3c}', '\u{11d3d}'),
+    ('\u{11d3f}', '\u{11d47}'),
+    ('𑵐', '𑵙'),
+    ('𑵠', '𑵥'),
+    ('𑵧', '𑵨'),
+    ('𑵪', '𑶎'),
+    ('\u{11d90}', '\u{11d91}'),
+    ('𑶓', '𑶘'),
+    ('𑶠', '𑶩'),
+    ('𑻠', '𑻶'),
+    ('\u{11f00}', '𑼐'),
+    ('𑼒', '\u{11f3a}'),
+    ('𑼾', '\u{11f42}'),
+    ('𑽐', '𑽙'),
+    ('𑾰', '𑾰'),
+    ('𒀀', '𒎙'),
+    ('𒐀', '𒑮'),
+    ('𒒀', '𒕃'),
+    ('𒾐', '𒿰'),
+    ('𓀀', '𓐯'),
+    ('\u{13440}', '\u{13455}'),
+    ('𔐀', '𔙆'),
+    ('𖠀', '𖨸'),
+    ('𖩀', '𖩞'),
+    ('𖩠', '𖩩'),
+    ('𖩰', '𖪾'),
+    ('𖫀', '𖫉'),
+    ('𖫐', '𖫭'),
+    ('\u{16af0}', '\u{16af4}'),
+    ('𖬀', '\u{16b36}'),
+    ('𖭀', '𖭃'),
+    ('𖭐', '𖭙'),
+    ('𖭣', '𖭷'),
+    ('𖭽', '𖮏'),
+    ('𖹀', '𖹿'),
+    ('𖼀', '𖽊'),
+    ('\u{16f4f}', '𖾇'),
+    ('\u{16f8f}', '𖾟'),
+    ('𖿠', '𖿡'),
+    ('𖿣', '\u{16fe4}'),
+    ('𖿰', '𖿱'),
+    ('𗀀', '𘟷'),
+    ('𘠀', '𘳕'),
+    ('𘴀', '𘴈'),
+    ('𚿰', '𚿳'),
+    ('𚿵', '𚿻'),
+    ('𚿽', '𚿾'),
+    ('𛀀', '𛄢'),
+    ('𛄲', '𛄲'),
+    ('𛅐', '𛅒'),
+    ('𛅕', '𛅕'),
+    ('𛅤', '𛅧'),
+    ('𛅰', '𛋻'),
+    ('𛰀', '𛱪'),
+    ('𛱰', '𛱼'),
+    ('𛲀', '𛲈'),
+    ('𛲐', '𛲙'),
+    ('\u{1bc9d}', '\u{1bc9e}'),
+    ('\u{1cf00}', '\u{1cf2d}'),
+    ('\u{1cf30}', '\u{1cf46}'),
+    ('\u{1d165}', '\u{1d169}'),
+    ('𝅭', '\u{1d172}'),
+    ('\u{1d17b}', '\u{1d182}'),
+    ('\u{1d185}', '\u{1d18b}'),
+    ('\u{1d1aa}', '\u{1d1ad}'),
+    ('\u{1d242}', '\u{1d244}'),
+    ('𝐀', '𝑔'),
+    ('𝑖', '𝒜'),
+    ('𝒞', '𝒟'),
+    ('𝒢', '𝒢'),
+    ('𝒥', '𝒦'),
+    ('𝒩', '𝒬'),
+    ('𝒮', '𝒹'),
+    ('𝒻', '𝒻'),
+    ('𝒽', '𝓃'),
+    ('𝓅', '𝔅'),
+    ('𝔇', '𝔊'),
+    ('𝔍', '𝔔'),
+    ('𝔖', '𝔜'),
+    ('𝔞', '𝔹'),
+    ('𝔻', '𝔾'),
+    ('𝕀', '𝕄'),
+    ('𝕆', '𝕆'),
+    ('𝕊', '𝕐'),
+    ('𝕒', '𝚥'),
+    ('𝚨', '𝛀'),
+    ('𝛂', '𝛚'),
+    ('𝛜', '𝛺'),
+    ('𝛼', '𝜔'),
+    ('𝜖', '𝜴'),
+    ('𝜶', '𝝎'),
+    ('𝝐', '𝝮'),
+    ('𝝰', '𝞈'),
+    ('𝞊', '𝞨'),
+    ('𝞪', '𝟂'),
+    ('𝟄', '𝟋'),
+    ('𝟎', '𝟿'),
+    ('\u{1da00}', '\u{1da36}'),
+    ('\u{1da3b}', '\u{1da6c}'),
+    ('\u{1da75}', '\u{1da75}'),
+    ('\u{1da84}', '\u{1da84}'),
+    ('\u{1da9b}', '\u{1da9f}'),
+    ('\u{1daa1}', '\u{1daaf}'),
+    ('𝼀', '𝼞'),
+    ('𝼥', '𝼪'),
+    ('\u{1e000}', '\u{1e006}'),
+    ('\u{1e008}', '\u{1e018}'),
+    ('\u{1e01b}', '\u{1e021}'),
+    ('\u{1e023}', '\u{1e024}'),
+    ('\u{1e026}', '\u{1e02a}'),
+    ('𞀰', '𞁭'),
+    ('\u{1e08f}', '\u{1e08f}'),
+    ('𞄀', '𞄬'),
+    ('\u{1e130}', '𞄽'),
+    ('𞅀', '𞅉'),
+    ('𞅎', '𞅎'),
+    ('𞊐', '\u{1e2ae}'),
+    ('𞋀', '𞋹'),
+    ('𞓐', '𞓹'),
+    ('𞟠', '𞟦'),
+    ('𞟨', '𞟫'),
+    ('𞟭', '𞟮'),
+    ('𞟰', '𞟾'),
+    ('𞠀', '𞣄'),
+    ('\u{1e8d0}', '\u{1e8d6}'),
+    ('𞤀', '𞥋'),
+    ('𞥐', '𞥙'),
+    ('𞸀', '𞸃'),
+    ('𞸅', '𞸟'),
+    ('𞸡', '𞸢'),
+    ('𞸤', '𞸤'),
+    ('𞸧', '𞸧'),
+    ('𞸩', '𞸲'),
+    ('𞸴', '𞸷'),
+    ('𞸹', '𞸹'),
+    ('𞸻', '𞸻'),
+    ('𞹂', '𞹂'),
+    ('𞹇', '𞹇'),
+    ('𞹉', '𞹉'),
+    ('𞹋', '𞹋'),
+    ('𞹍', '𞹏'),
+    ('𞹑', '𞹒'),
+    ('𞹔', '𞹔'),
+    ('𞹗', '𞹗'),
+    ('𞹙', '𞹙'),
+    ('𞹛', '𞹛'),
+    ('𞹝', '𞹝'),
+    ('𞹟', '𞹟'),
+    ('𞹡', '𞹢'),
+    ('𞹤', '𞹤'),
+    ('𞹧', '𞹪'),
+    ('𞹬', '𞹲'),
+    ('𞹴', '𞹷'),
+    ('𞹹', '𞹼'),
+    ('𞹾', '𞹾'),
+    ('𞺀', '𞺉'),
+    ('𞺋', '𞺛'),
+    ('𞺡', '𞺣'),
+    ('𞺥', '𞺩'),
+    ('𞺫', '𞺻'),
+    ('🯰', '🯹'),
+    ('𠀀', '𪛟'),
+    ('𪜀', '𫜹'),
+    ('𫝀', '𫠝'),
+    ('𫠠', '𬺡'),
+    ('𬺰', '𮯠'),
+    ('丽', '𪘀'),
+    ('𰀀', '𱍊'),
+    ('𱍐', '𲎯'),
+    ('\u{e0100}', '\u{e01ef}'),
+];
+
+pub const ID_START: &'static [(char, char)] = &[
+    ('A', 'Z'),
+    ('a', 'z'),
+    ('ª', 'ª'),
+    ('µ', 'µ'),
+    ('º', 'º'),
+    ('À', 'Ö'),
+    ('Ø', 'ö'),
+    ('ø', 'ˁ'),
+    ('ˆ', 'ˑ'),
+    ('ˠ', 'ˤ'),
+    ('ˬ', 'ˬ'),
+    ('ˮ', 'ˮ'),
+    ('Ͱ', 'ʹ'),
+    ('Ͷ', 'ͷ'),
+    ('ͺ', 'ͽ'),
+    ('Ϳ', 'Ϳ'),
+    ('Ά', 'Ά'),
+    ('Έ', 'Ί'),
+    ('Ό', 'Ό'),
+    ('Ύ', 'Ρ'),
+    ('Σ', 'ϵ'),
+    ('Ϸ', 'ҁ'),
+    ('Ҋ', 'ԯ'),
+    ('Ա', 'Ֆ'),
+    ('ՙ', 'ՙ'),
+    ('ՠ', 'ֈ'),
+    ('א', 'ת'),
+    ('ׯ', 'ײ'),
+    ('ؠ', 'ي'),
+    ('ٮ', 'ٯ'),
+    ('ٱ', 'ۓ'),
+    ('ە', 'ە'),
+    ('ۥ', 'ۦ'),
+    ('ۮ', 'ۯ'),
+    ('ۺ', 'ۼ'),
+    ('ۿ', 'ۿ'),
+    ('ܐ', 'ܐ'),
+    ('ܒ', 'ܯ'),
+    ('ݍ', 'ޥ'),
+    ('ޱ', 'ޱ'),
+    ('ߊ', 'ߪ'),
+    ('ߴ', 'ߵ'),
+    ('ߺ', 'ߺ'),
+    ('ࠀ', 'ࠕ'),
+    ('ࠚ', 'ࠚ'),
+    ('ࠤ', 'ࠤ'),
+    ('ࠨ', 'ࠨ'),
+    ('ࡀ', 'ࡘ'),
+    ('ࡠ', 'ࡪ'),
+    ('ࡰ', 'ࢇ'),
+    ('ࢉ', 'ࢎ'),
+    ('ࢠ', 'ࣉ'),
+    ('ऄ', 'ह'),
+    ('ऽ', 'ऽ'),
+    ('ॐ', 'ॐ'),
+    ('क़', 'ॡ'),
+    ('ॱ', 'ঀ'),
+    ('অ', 'ঌ'),
+    ('এ', 'ঐ'),
+    ('ও', 'ন'),
+    ('প', 'র'),
+    ('ল', 'ল'),
+    ('শ', 'হ'),
+    ('ঽ', 'ঽ'),
+    ('ৎ', 'ৎ'),
+    ('ড়', 'ঢ়'),
+    ('য়', 'ৡ'),
+    ('ৰ', 'ৱ'),
+    ('ৼ', 'ৼ'),
+    ('ਅ', 'ਊ'),
+    ('ਏ', 'ਐ'),
+    ('ਓ', 'ਨ'),
+    ('ਪ', 'ਰ'),
+    ('ਲ', 'ਲ਼'),
+    ('ਵ', 'ਸ਼'),
+    ('ਸ', 'ਹ'),
+    ('ਖ਼', 'ੜ'),
+    ('ਫ਼', 'ਫ਼'),
+    ('ੲ', 'ੴ'),
+    ('અ', 'ઍ'),
+    ('એ', 'ઑ'),
+    ('ઓ', 'ન'),
+    ('પ', 'ર'),
+    ('લ', 'ળ'),
+    ('વ', 'હ'),
+    ('ઽ', 'ઽ'),
+    ('ૐ', 'ૐ'),
+    ('ૠ', 'ૡ'),
+    ('ૹ', 'ૹ'),
+    ('ଅ', 'ଌ'),
+    ('ଏ', 'ଐ'),
+    ('ଓ', 'ନ'),
+    ('ପ', 'ର'),
+    ('ଲ', 'ଳ'),
+    ('ଵ', 'ହ'),
+    ('ଽ', 'ଽ'),
+    ('ଡ଼', 'ଢ଼'),
+    ('ୟ', 'ୡ'),
+    ('ୱ', 'ୱ'),
+    ('ஃ', 'ஃ'),
+    ('அ', 'ஊ'),
+    ('எ', 'ஐ'),
+    ('ஒ', 'க'),
+    ('ங', 'ச'),
+    ('ஜ', 'ஜ'),
+    ('ஞ', 'ட'),
+    ('ண', 'த'),
+    ('ந', 'ப'),
+    ('ம', 'ஹ'),
+    ('ௐ', 'ௐ'),
+    ('అ', 'ఌ'),
+    ('ఎ', 'ఐ'),
+    ('ఒ', 'న'),
+    ('ప', 'హ'),
+    ('ఽ', 'ఽ'),
+    ('ౘ', 'ౚ'),
+    ('ౝ', 'ౝ'),
+    ('ౠ', 'ౡ'),
+    ('ಀ', 'ಀ'),
+    ('ಅ', 'ಌ'),
+    ('ಎ', 'ಐ'),
+    ('ಒ', 'ನ'),
+    ('ಪ', 'ಳ'),
+    ('ವ', 'ಹ'),
+    ('ಽ', 'ಽ'),
+    ('ೝ', 'ೞ'),
+    ('ೠ', 'ೡ'),
+    ('ೱ', 'ೲ'),
+    ('ഄ', 'ഌ'),
+    ('എ', 'ഐ'),
+    ('ഒ', 'ഺ'),
+    ('ഽ', 'ഽ'),
+    ('ൎ', 'ൎ'),
+    ('ൔ', 'ൖ'),
+    ('ൟ', 'ൡ'),
+    ('ൺ', 'ൿ'),
+    ('අ', 'ඖ'),
+    ('ක', 'න'),
+    ('ඳ', 'ර'),
+    ('ල', 'ල'),
+    ('ව', 'ෆ'),
+    ('ก', 'ะ'),
+    ('า', 'ำ'),
+    ('เ', 'ๆ'),
+    ('ກ', 'ຂ'),
+    ('ຄ', 'ຄ'),
+    ('ຆ', 'ຊ'),
+    ('ຌ', 'ຣ'),
+    ('ລ', 'ລ'),
+    ('ວ', 'ະ'),
+    ('າ', 'ຳ'),
+    ('ຽ', 'ຽ'),
+    ('ເ', 'ໄ'),
+    ('ໆ', 'ໆ'),
+    ('ໜ', 'ໟ'),
+    ('ༀ', 'ༀ'),
+    ('ཀ', 'ཇ'),
+    ('ཉ', 'ཬ'),
+    ('ྈ', 'ྌ'),
+    ('က', 'ဪ'),
+    ('ဿ', 'ဿ'),
+    ('ၐ', 'ၕ'),
+    ('ၚ', 'ၝ'),
+    ('ၡ', 'ၡ'),
+    ('ၥ', 'ၦ'),
+    ('ၮ', 'ၰ'),
+    ('ၵ', 'ႁ'),
+    ('ႎ', 'ႎ'),
+    ('Ⴀ', 'Ⴥ'),
+    ('Ⴧ', 'Ⴧ'),
+    ('Ⴭ', 'Ⴭ'),
+    ('ა', 'ჺ'),
+    ('ჼ', 'ቈ'),
+    ('ቊ', 'ቍ'),
+    ('ቐ', 'ቖ'),
+    ('ቘ', 'ቘ'),
+    ('ቚ', 'ቝ'),
+    ('በ', 'ኈ'),
+    ('ኊ', 'ኍ'),
+    ('ነ', 'ኰ'),
+    ('ኲ', 'ኵ'),
+    ('ኸ', 'ኾ'),
+    ('ዀ', 'ዀ'),
+    ('ዂ', 'ዅ'),
+    ('ወ', 'ዖ'),
+    ('ዘ', 'ጐ'),
+    ('ጒ', 'ጕ'),
+    ('ጘ', 'ፚ'),
+    ('ᎀ', 'ᎏ'),
+    ('Ꭰ', 'Ᏽ'),
+    ('ᏸ', 'ᏽ'),
+    ('ᐁ', 'ᙬ'),
+    ('ᙯ', 'ᙿ'),
+    ('ᚁ', 'ᚚ'),
+    ('ᚠ', 'ᛪ'),
+    ('ᛮ', 'ᛸ'),
+    ('ᜀ', 'ᜑ'),
+    ('ᜟ', 'ᜱ'),
+    ('ᝀ', 'ᝑ'),
+    ('ᝠ', 'ᝬ'),
+    ('ᝮ', 'ᝰ'),
+    ('ក', 'ឳ'),
+    ('ៗ', 'ៗ'),
+    ('ៜ', 'ៜ'),
+    ('ᠠ', 'ᡸ'),
+    ('ᢀ', 'ᢨ'),
+    ('ᢪ', 'ᢪ'),
+    ('ᢰ', 'ᣵ'),
+    ('ᤀ', 'ᤞ'),
+    ('ᥐ', 'ᥭ'),
+    ('ᥰ', 'ᥴ'),
+    ('ᦀ', 'ᦫ'),
+    ('ᦰ', 'ᧉ'),
+    ('ᨀ', 'ᨖ'),
+    ('ᨠ', 'ᩔ'),
+    ('ᪧ', 'ᪧ'),
+    ('ᬅ', 'ᬳ'),
+    ('ᭅ', 'ᭌ'),
+    ('ᮃ', 'ᮠ'),
+    ('ᮮ', 'ᮯ'),
+    ('ᮺ', 'ᯥ'),
+    ('ᰀ', 'ᰣ'),
+    ('ᱍ', 'ᱏ'),
+    ('ᱚ', 'ᱽ'),
+    ('ᲀ', 'ᲈ'),
+    ('Ა', 'Ჺ'),
+    ('Ჽ', 'Ჿ'),
+    ('ᳩ', 'ᳬ'),
+    ('ᳮ', 'ᳳ'),
+    ('ᳵ', 'ᳶ'),
+    ('ᳺ', 'ᳺ'),
+    ('ᴀ', 'ᶿ'),
+    ('Ḁ', 'ἕ'),
+    ('Ἐ', 'Ἕ'),
+    ('ἠ', 'ὅ'),
+    ('Ὀ', 'Ὅ'),
+    ('ὐ', 'ὗ'),
+    ('Ὑ', 'Ὑ'),
+    ('Ὓ', 'Ὓ'),
+    ('Ὕ', 'Ὕ'),
+    ('Ὗ', 'ώ'),
+    ('ᾀ', 'ᾴ'),
+    ('ᾶ', 'ᾼ'),
+    ('ι', 'ι'),
+    ('ῂ', 'ῄ'),
+    ('ῆ', 'ῌ'),
+    ('ῐ', 'ΐ'),
+    ('ῖ', 'Ί'),
+    ('ῠ', 'Ῥ'),
+    ('ῲ', 'ῴ'),
+    ('ῶ', 'ῼ'),
+    ('ⁱ', 'ⁱ'),
+    ('ⁿ', 'ⁿ'),
+    ('ₐ', 'ₜ'),
+    ('ℂ', 'ℂ'),
+    ('ℇ', 'ℇ'),
+    ('ℊ', 'ℓ'),
+    ('ℕ', 'ℕ'),
+    ('℘', 'ℝ'),
+    ('ℤ', 'ℤ'),
+    ('Ω', 'Ω'),
+    ('ℨ', 'ℨ'),
+    ('K', 'ℹ'),
+    ('ℼ', 'ℿ'),
+    ('ⅅ', 'ⅉ'),
+    ('ⅎ', 'ⅎ'),
+    ('Ⅰ', 'ↈ'),
+    ('Ⰰ', 'ⳤ'),
+    ('Ⳬ', 'ⳮ'),
+    ('Ⳳ', 'ⳳ'),
+    ('ⴀ', 'ⴥ'),
+    ('ⴧ', 'ⴧ'),
+    ('ⴭ', 'ⴭ'),
+    ('ⴰ', 'ⵧ'),
+    ('ⵯ', 'ⵯ'),
+    ('ⶀ', 'ⶖ'),
+    ('ⶠ', 'ⶦ'),
+    ('ⶨ', 'ⶮ'),
+    ('ⶰ', 'ⶶ'),
+    ('ⶸ', 'ⶾ'),
+    ('ⷀ', 'ⷆ'),
+    ('ⷈ', 'ⷎ'),
+    ('ⷐ', 'ⷖ'),
+    ('ⷘ', 'ⷞ'),
+    ('々', '〇'),
+    ('〡', '〩'),
+    ('〱', '〵'),
+    ('〸', '〼'),
+    ('ぁ', 'ゖ'),
+    ('゛', 'ゟ'),
+    ('ァ', 'ヺ'),
+    ('ー', 'ヿ'),
+    ('ㄅ', 'ㄯ'),
+    ('ㄱ', 'ㆎ'),
+    ('ㆠ', 'ㆿ'),
+    ('ㇰ', 'ㇿ'),
+    ('㐀', '䶿'),
+    ('一', 'ꒌ'),
+    ('ꓐ', 'ꓽ'),
+    ('ꔀ', 'ꘌ'),
+    ('ꘐ', 'ꘟ'),
+    ('ꘪ', 'ꘫ'),
+    ('Ꙁ', 'ꙮ'),
+    ('ꙿ', 'ꚝ'),
+    ('ꚠ', 'ꛯ'),
+    ('ꜗ', 'ꜟ'),
+    ('Ꜣ', 'ꞈ'),
+    ('Ꞌ', 'ꟊ'),
+    ('Ꟑ', 'ꟑ'),
+    ('ꟓ', 'ꟓ'),
+    ('ꟕ', 'ꟙ'),
+    ('ꟲ', 'ꠁ'),
+    ('ꠃ', 'ꠅ'),
+    ('ꠇ', 'ꠊ'),
+    ('ꠌ', 'ꠢ'),
+    ('ꡀ', 'ꡳ'),
+    ('ꢂ', 'ꢳ'),
+    ('ꣲ', 'ꣷ'),
+    ('ꣻ', 'ꣻ'),
+    ('ꣽ', 'ꣾ'),
+    ('ꤊ', 'ꤥ'),
+    ('ꤰ', 'ꥆ'),
+    ('ꥠ', 'ꥼ'),
+    ('ꦄ', 'ꦲ'),
+    ('ꧏ', 'ꧏ'),
+    ('ꧠ', 'ꧤ'),
+    ('ꧦ', 'ꧯ'),
+    ('ꧺ', 'ꧾ'),
+    ('ꨀ', 'ꨨ'),
+    ('ꩀ', 'ꩂ'),
+    ('ꩄ', 'ꩋ'),
+    ('ꩠ', 'ꩶ'),
+    ('ꩺ', 'ꩺ'),
+    ('ꩾ', 'ꪯ'),
+    ('ꪱ', 'ꪱ'),
+    ('ꪵ', 'ꪶ'),
+    ('ꪹ', 'ꪽ'),
+    ('ꫀ', 'ꫀ'),
+    ('ꫂ', 'ꫂ'),
+    ('ꫛ', 'ꫝ'),
+    ('ꫠ', 'ꫪ'),
+    ('ꫲ', 'ꫴ'),
+    ('ꬁ', 'ꬆ'),
+    ('ꬉ', 'ꬎ'),
+    ('ꬑ', 'ꬖ'),
+    ('ꬠ', 'ꬦ'),
+    ('ꬨ', 'ꬮ'),
+    ('ꬰ', 'ꭚ'),
+    ('ꭜ', 'ꭩ'),
+    ('ꭰ', 'ꯢ'),
+    ('가', '힣'),
+    ('ힰ', 'ퟆ'),
+    ('ퟋ', 'ퟻ'),
+    ('豈', '舘'),
+    ('並', '龎'),
+    ('ﬀ', 'ﬆ'),
+    ('ﬓ', 'ﬗ'),
+    ('יִ', 'יִ'),
+    ('ײַ', 'ﬨ'),
+    ('שׁ', 'זּ'),
+    ('טּ', 'לּ'),
+    ('מּ', 'מּ'),
+    ('נּ', 'סּ'),
+    ('ףּ', 'פּ'),
+    ('צּ', 'ﮱ'),
+    ('ﯓ', 'ﴽ'),
+    ('ﵐ', 'ﶏ'),
+    ('ﶒ', 'ﷇ'),
+    ('ﷰ', 'ﷻ'),
+    ('ﹰ', 'ﹴ'),
+    ('ﹶ', 'ﻼ'),
+    ('Ａ', 'Ｚ'),
+    ('ａ', 'ｚ'),
+    ('ｦ', 'ﾾ'),
+    ('ￂ', 'ￇ'),
+    ('ￊ', 'ￏ'),
+    ('ￒ', 'ￗ'),
+    ('ￚ', 'ￜ'),
+    ('𐀀', '𐀋'),
+    ('𐀍', '𐀦'),
+    ('𐀨', '𐀺'),
+    ('𐀼', '𐀽'),
+    ('𐀿', '𐁍'),
+    ('𐁐', '𐁝'),
+    ('𐂀', '𐃺'),
+    ('𐅀', '𐅴'),
+    ('𐊀', '𐊜'),
+    ('𐊠', '𐋐'),
+    ('𐌀', '𐌟'),
+    ('𐌭', '𐍊'),
+    ('𐍐', '𐍵'),
+    ('𐎀', '𐎝'),
+    ('𐎠', '𐏃'),
+    ('𐏈', '𐏏'),
+    ('𐏑', '𐏕'),
+    ('𐐀', '𐒝'),
+    ('𐒰', '𐓓'),
+    ('𐓘', '𐓻'),
+    ('𐔀', '𐔧'),
+    ('𐔰', '𐕣'),
+    ('𐕰', '𐕺'),
+    ('𐕼', '𐖊'),
+    ('𐖌', '𐖒'),
+    ('𐖔', '𐖕'),
+    ('𐖗', '𐖡'),
+    ('𐖣', '𐖱'),
+    ('𐖳', '𐖹'),
+    ('𐖻', '𐖼'),
+    ('𐘀', '𐜶'),
+    ('𐝀', '𐝕'),
+    ('𐝠', '𐝧'),
+    ('𐞀', '𐞅'),
+    ('𐞇', '𐞰'),
+    ('𐞲', '𐞺'),
+    ('𐠀', '𐠅'),
+    ('𐠈', '𐠈'),
+    ('𐠊', '𐠵'),
+    ('𐠷', '𐠸'),
+    ('𐠼', '𐠼'),
+    ('𐠿', '𐡕'),
+    ('𐡠', '𐡶'),
+    ('𐢀', '𐢞'),
+    ('𐣠', '𐣲'),
+    ('𐣴', '𐣵'),
+    ('𐤀', '𐤕'),
+    ('𐤠', '𐤹'),
+    ('𐦀', '𐦷'),
+    ('𐦾', '𐦿'),
+    ('𐨀', '𐨀'),
+    ('𐨐', '𐨓'),
+    ('𐨕', '𐨗'),
+    ('𐨙', '𐨵'),
+    ('𐩠', '𐩼'),
+    ('𐪀', '𐪜'),
+    ('𐫀', '𐫇'),
+    ('𐫉', '𐫤'),
+    ('𐬀', '𐬵'),
+    ('𐭀', '𐭕'),
+    ('𐭠', '𐭲'),
+    ('𐮀', '𐮑'),
+    ('𐰀', '𐱈'),
+    ('𐲀', '𐲲'),
+    ('𐳀', '𐳲'),
+    ('𐴀', '𐴣'),
+    ('𐺀', '𐺩'),
+    ('𐺰', '𐺱'),
+    ('𐼀', '𐼜'),
+    ('𐼧', '𐼧'),
+    ('𐼰', '𐽅'),
+    ('𐽰', '𐾁'),
+    ('𐾰', '𐿄'),
+    ('𐿠', '𐿶'),
+    ('𑀃', '𑀷'),
+    ('𑁱', '𑁲'),
+    ('𑁵', '𑁵'),
+    ('𑂃', '𑂯'),
+    ('𑃐', '𑃨'),
+    ('𑄃', '𑄦'),
+    ('𑅄', '𑅄'),
+    ('𑅇', '𑅇'),
+    ('𑅐', '𑅲'),
+    ('𑅶', '𑅶'),
+    ('𑆃', '𑆲'),
+    ('𑇁', '𑇄'),
+    ('𑇚', '𑇚'),
+    ('𑇜', '𑇜'),
+    ('𑈀', '𑈑'),
+    ('𑈓', '𑈫'),
+    ('𑈿', '𑉀'),
+    ('𑊀', '𑊆'),
+    ('𑊈', '𑊈'),
+    ('𑊊', '𑊍'),
+    ('𑊏', '𑊝'),
+    ('𑊟', '𑊨'),
+    ('𑊰', '𑋞'),
+    ('𑌅', '𑌌'),
+    ('𑌏', '𑌐'),
+    ('𑌓', '𑌨'),
+    ('𑌪', '𑌰'),
+    ('𑌲', '𑌳'),
+    ('𑌵', '𑌹'),
+    ('𑌽', '𑌽'),
+    ('𑍐', '𑍐'),
+    ('𑍝', '𑍡'),
+    ('𑐀', '𑐴'),
+    ('𑑇', '𑑊'),
+    ('𑑟', '𑑡'),
+    ('𑒀', '𑒯'),
+    ('𑓄', '𑓅'),
+    ('𑓇', '𑓇'),
+    ('𑖀', '𑖮'),
+    ('𑗘', '𑗛'),
+    ('𑘀', '𑘯'),
+    ('𑙄', '𑙄'),
+    ('𑚀', '𑚪'),
+    ('𑚸', '𑚸'),
+    ('𑜀', '𑜚'),
+    ('𑝀', '𑝆'),
+    ('𑠀', '𑠫'),
+    ('𑢠', '𑣟'),
+    ('𑣿', '𑤆'),
+    ('𑤉', '𑤉'),
+    ('𑤌', '𑤓'),
+    ('𑤕', '𑤖'),
+    ('𑤘', '𑤯'),
+    ('𑤿', '𑤿'),
+    ('𑥁', '𑥁'),
+    ('𑦠', '𑦧'),
+    ('𑦪', '𑧐'),
+    ('𑧡', '𑧡'),
+    ('𑧣', '𑧣'),
+    ('𑨀', '𑨀'),
+    ('𑨋', '𑨲'),
+    ('𑨺', '𑨺'),
+    ('𑩐', '𑩐'),
+    ('𑩜', '𑪉'),
+    ('𑪝', '𑪝'),
+    ('𑪰', '𑫸'),
+    ('𑰀', '𑰈'),
+    ('𑰊', '𑰮'),
+    ('𑱀', '𑱀'),
+    ('𑱲', '𑲏'),
+    ('𑴀', '𑴆'),
+    ('𑴈', '𑴉'),
+    ('𑴋', '𑴰'),
+    ('𑵆', '𑵆'),
+    ('𑵠', '𑵥'),
+    ('𑵧', '𑵨'),
+    ('𑵪', '𑶉'),
+    ('𑶘', '𑶘'),
+    ('𑻠', '𑻲'),
+    ('𑼂', '𑼂'),
+    ('𑼄', '𑼐'),
+    ('𑼒', '𑼳'),
+    ('𑾰', '𑾰'),
+    ('𒀀', '𒎙'),
+    ('𒐀', '𒑮'),
+    ('𒒀', '𒕃'),
+    ('𒾐', '𒿰'),
+    ('𓀀', '𓐯'),
+    ('𓑁', '𓑆'),
+    ('𔐀', '𔙆'),
+    ('𖠀', '𖨸'),
+    ('𖩀', '𖩞'),
+    ('𖩰', '𖪾'),
+    ('𖫐', '𖫭'),
+    ('𖬀', '𖬯'),
+    ('𖭀', '𖭃'),
+    ('𖭣', '𖭷'),
+    ('𖭽', '𖮏'),
+    ('𖹀', '𖹿'),
+    ('𖼀', '𖽊'),
+    ('𖽐', '𖽐'),
+    ('𖾓', '𖾟'),
+    ('𖿠', '𖿡'),
+    ('𖿣', '𖿣'),
+    ('𗀀', '𘟷'),
+    ('𘠀', '𘳕'),
+    ('𘴀', '𘴈'),
+    ('𚿰', '𚿳'),
+    ('𚿵', '𚿻'),
+    ('𚿽', '𚿾'),
+    ('𛀀', '𛄢'),
+    ('𛄲', '𛄲'),
+    ('𛅐', '𛅒'),
+    ('𛅕', '𛅕'),
+    ('𛅤', '𛅧'),
+    ('𛅰', '𛋻'),
+    ('𛰀', '𛱪'),
+    ('𛱰', '𛱼'),
+    ('𛲀', '𛲈'),
+    ('𛲐', '𛲙'),
+    ('𝐀', '𝑔'),
+    ('𝑖', '𝒜'),
+    ('𝒞', '𝒟'),
+    ('𝒢', '𝒢'),
+    ('𝒥', '𝒦'),
+    ('𝒩', '𝒬'),
+    ('𝒮', '𝒹'),
+    ('𝒻', '𝒻'),
+    ('𝒽', '𝓃'),
+    ('𝓅', '𝔅'),
+    ('𝔇', '𝔊'),
+    ('𝔍', '𝔔'),
+    ('𝔖', '𝔜'),
+    ('𝔞', '𝔹'),
+    ('𝔻', '𝔾'),
+    ('𝕀', '𝕄'),
+    ('𝕆', '𝕆'),
+    ('𝕊', '𝕐'),
+    ('𝕒', '𝚥'),
+    ('𝚨', '𝛀'),
+    ('𝛂', '𝛚'),
+    ('𝛜', '𝛺'),
+    ('𝛼', '𝜔'),
+    ('𝜖', '𝜴'),
+    ('𝜶', '𝝎'),
+    ('𝝐', '𝝮'),
+    ('𝝰', '𝞈'),
+    ('𝞊', '𝞨'),
+    ('𝞪', '𝟂'),
+    ('𝟄', '𝟋'),
+    ('𝼀', '𝼞'),
+    ('𝼥', '𝼪'),
+    ('𞀰', '𞁭'),
+    ('𞄀', '𞄬'),
+    ('𞄷', '𞄽'),
+    ('𞅎', '𞅎'),
+    ('𞊐', '𞊭'),
+    ('𞋀', '𞋫'),
+    ('𞓐', '𞓫'),
+    ('𞟠', '𞟦'),
+    ('𞟨', '𞟫'),
+    ('𞟭', '𞟮'),
+    ('𞟰', '𞟾'),
+    ('𞠀', '𞣄'),
+    ('𞤀', '𞥃'),
+    ('𞥋', '𞥋'),
+    ('𞸀', '𞸃'),
+    ('𞸅', '𞸟'),
+    ('𞸡', '𞸢'),
+    ('𞸤', '𞸤'),
+    ('𞸧', '𞸧'),
+    ('𞸩', '𞸲'),
+    ('𞸴', '𞸷'),
+    ('𞸹', '𞸹'),
+    ('𞸻', '𞸻'),
+    ('𞹂', '𞹂'),
+    ('𞹇', '𞹇'),
+    ('𞹉', '𞹉'),
+    ('𞹋', '𞹋'),
+    ('𞹍', '𞹏'),
+    ('𞹑', '𞹒'),
+    ('𞹔', '𞹔'),
+    ('𞹗', '𞹗'),
+    ('𞹙', '𞹙'),
+    ('𞹛', '𞹛'),
+    ('𞹝', '𞹝'),
+    ('𞹟', '𞹟'),
+    ('𞹡', '𞹢'),
+    ('𞹤', '𞹤'),
+    ('𞹧', '𞹪'),
+    ('𞹬', '𞹲'),
+    ('𞹴', '𞹷'),
+    ('𞹹', '𞹼'),
+    ('𞹾', '𞹾'),
+    ('𞺀', '𞺉'),
+    ('𞺋', '𞺛'),
+    ('𞺡', '𞺣'),
+    ('𞺥', '𞺩'),
+    ('𞺫', '𞺻'),
+    ('𠀀', '𪛟'),
+    ('𪜀', '𫜹'),
+    ('𫝀', '𫠝'),
+    ('𫠠', '𬺡'),
+    ('𬺰', '𮯠'),
+    ('丽', '𪘀'),
+    ('𰀀', '𱍊'),
+    ('𱍐', '𲎯'),
+];
+
+pub const IDEOGRAPHIC: &'static [(char, char)] = &[
+    ('〆', '〇'),
+    ('〡', '〩'),
+    ('〸', '〺'),
+    ('㐀', '䶿'),
+    ('一', '鿿'),
+    ('豈', '舘'),
+    ('並', '龎'),
+    ('\u{16fe4}', '\u{16fe4}'),
+    ('𗀀', '𘟷'),
+    ('𘠀', '𘳕'),
+    ('𘴀', '𘴈'),
+    ('𛅰', '𛋻'),
+    ('𠀀', '𪛟'),
+    ('𪜀', '𫜹'),
+    ('𫝀', '𫠝'),
+    ('𫠠', '𬺡'),
+    ('𬺰', '𮯠'),
+    ('丽', '𪘀'),
+    ('𰀀', '𱍊'),
+    ('𱍐', '𲎯'),
+];
+
+pub const JOIN_CONTROL: &'static [(char, char)] = &[('\u{200c}', '\u{200d}')];
+
+pub const LOGICAL_ORDER_EXCEPTION: &'static [(char, char)] = &[
+    ('เ', 'ไ'),
+    ('ເ', 'ໄ'),
+    ('ᦵ', 'ᦷ'),
+    ('ᦺ', 'ᦺ'),
+    ('ꪵ', 'ꪶ'),
+    ('ꪹ', 'ꪹ'),
+    ('ꪻ', 'ꪼ'),
+];
+
+pub const LOWERCASE: &'static [(char, char)] = &[
+    ('a', 'z'),
+    ('ª', 'ª'),
+    ('µ', 'µ'),
+    ('º', 'º'),
+    ('ß', 'ö'),
+    ('ø', 'ÿ'),
+    ('ā', 'ā'),
+    ('ă', 'ă'),
+    ('ą', 'ą'),
+    ('ć', 'ć'),
+    ('ĉ', 'ĉ'),
+    ('ċ', 'ċ'),
+    ('č', 'č'),
+    ('ď', 'ď'),
+    ('đ', 'đ'),
+    ('ē', 'ē'),
+    ('ĕ', 'ĕ'),
+    ('ė', 'ė'),
+    ('ę', 'ę'),
+    ('ě', 'ě'),
+    ('ĝ', 'ĝ'),
+    ('ğ', 'ğ'),
+    ('ġ', 'ġ'),
+    ('ģ', 'ģ'),
+    ('ĥ', 'ĥ'),
+    ('ħ', 'ħ'),
+    ('ĩ', 'ĩ'),
+    ('ī', 'ī'),
+    ('ĭ', 'ĭ'),
+    ('į', 'į'),
+    ('ı', 'ı'),
+    ('ĳ', 'ĳ'),
+    ('ĵ', 'ĵ'),
+    ('ķ', 'ĸ'),
+    ('ĺ', 'ĺ'),
+    ('ļ', 'ļ'),
+    ('ľ', 'ľ'),
+    ('ŀ', 'ŀ'),
+    ('ł', 'ł'),
+    ('ń', 'ń'),
+    ('ņ', 'ņ'),
+    ('ň', 'ŉ'),
+    ('ŋ', 'ŋ'),
+    ('ō', 'ō'),
+    ('ŏ', 'ŏ'),
+    ('ő', 'ő'),
+    ('œ', 'œ'),
+    ('ŕ', 'ŕ'),
+    ('ŗ', 'ŗ'),
+    ('ř', 'ř'),
+    ('ś', 'ś'),
+    ('ŝ', 'ŝ'),
+    ('ş', 'ş'),
+    ('š', 'š'),
+    ('ţ', 'ţ'),
+    ('ť', 'ť'),
+    ('ŧ', 'ŧ'),
+    ('ũ', 'ũ'),
+    ('ū', 'ū'),
+    ('ŭ', 'ŭ'),
+    ('ů', 'ů'),
+    ('ű', 'ű'),
+    ('ų', 'ų'),
+    ('ŵ', 'ŵ'),
+    ('ŷ', 'ŷ'),
+    ('ź', 'ź'),
+    ('ż', 'ż'),
+    ('ž', 'ƀ'),
+    ('ƃ', 'ƃ'),
+    ('ƅ', 'ƅ'),
+    ('ƈ', 'ƈ'),
+    ('ƌ', 'ƍ'),
+    ('ƒ', 'ƒ'),
+    ('ƕ', 'ƕ'),
+    ('ƙ', 'ƛ'),
+    ('ƞ', 'ƞ'),
+    ('ơ', 'ơ'),
+    ('ƣ', 'ƣ'),
+    ('ƥ', 'ƥ'),
+    ('ƨ', 'ƨ'),
+    ('ƪ', 'ƫ'),
+    ('ƭ', 'ƭ'),
+    ('ư', 'ư'),
+    ('ƴ', 'ƴ'),
+    ('ƶ', 'ƶ'),
+    ('ƹ', 'ƺ'),
+    ('ƽ', 'ƿ'),
+    ('ǆ', 'ǆ'),
+    ('ǉ', 'ǉ'),
+    ('ǌ', 'ǌ'),
+    ('ǎ', 'ǎ'),
+    ('ǐ', 'ǐ'),
+    ('ǒ', 'ǒ'),
+    ('ǔ', 'ǔ'),
+    ('ǖ', 'ǖ'),
+    ('ǘ', 'ǘ'),
+    ('ǚ', 'ǚ'),
+    ('ǜ', 'ǝ'),
+    ('ǟ', 'ǟ'),
+    ('ǡ', 'ǡ'),
+    ('ǣ', 'ǣ'),
+    ('ǥ', 'ǥ'),
+    ('ǧ', 'ǧ'),
+    ('ǩ', 'ǩ'),
+    ('ǫ', 'ǫ'),
+    ('ǭ', 'ǭ'),
+    ('ǯ', 'ǰ'),
+    ('ǳ', 'ǳ'),
+    ('ǵ', 'ǵ'),
+    ('ǹ', 'ǹ'),
+    ('ǻ', 'ǻ'),
+    ('ǽ', 'ǽ'),
+    ('ǿ', 'ǿ'),
+    ('ȁ', 'ȁ'),
+    ('ȃ', 'ȃ'),
+    ('ȅ', 'ȅ'),
+    ('ȇ', 'ȇ'),
+    ('ȉ', 'ȉ'),
+    ('ȋ', 'ȋ'),
+    ('ȍ', 'ȍ'),
+    ('ȏ', 'ȏ'),
+    ('ȑ', 'ȑ'),
+    ('ȓ', 'ȓ'),
+    ('ȕ', 'ȕ'),
+    ('ȗ', 'ȗ'),
+    ('ș', 'ș'),
+    ('ț', 'ț'),
+    ('ȝ', 'ȝ'),
+    ('ȟ', 'ȟ'),
+    ('ȡ', 'ȡ'),
+    ('ȣ', 'ȣ'),
+    ('ȥ', 'ȥ'),
+    ('ȧ', 'ȧ'),
+    ('ȩ', 'ȩ'),
+    ('ȫ', 'ȫ'),
+    ('ȭ', 'ȭ'),
+    ('ȯ', 'ȯ'),
+    ('ȱ', 'ȱ'),
+    ('ȳ', 'ȹ'),
+    ('ȼ', 'ȼ'),
+    ('ȿ', 'ɀ'),
+    ('ɂ', 'ɂ'),
+    ('ɇ', 'ɇ'),
+    ('ɉ', 'ɉ'),
+    ('ɋ', 'ɋ'),
+    ('ɍ', 'ɍ'),
+    ('ɏ', 'ʓ'),
+    ('ʕ', 'ʸ'),
+    ('ˀ', 'ˁ'),
+    ('ˠ', 'ˤ'),
+    ('\u{345}', '\u{345}'),
+    ('ͱ', 'ͱ'),
+    ('ͳ', 'ͳ'),
+    ('ͷ', 'ͷ'),
+    ('ͺ', 'ͽ'),
+    ('ΐ', 'ΐ'),
+    ('ά', 'ώ'),
+    ('ϐ', 'ϑ'),
+    ('ϕ', 'ϗ'),
+    ('ϙ', 'ϙ'),
+    ('ϛ', 'ϛ'),
+    ('ϝ', 'ϝ'),
+    ('ϟ', 'ϟ'),
+    ('ϡ', 'ϡ'),
+    ('ϣ', 'ϣ'),
+    ('ϥ', 'ϥ'),
+    ('ϧ', 'ϧ'),
+    ('ϩ', 'ϩ'),
+    ('ϫ', 'ϫ'),
+    ('ϭ', 'ϭ'),
+    ('ϯ', 'ϳ'),
+    ('ϵ', 'ϵ'),
+    ('ϸ', 'ϸ'),
+    ('ϻ', 'ϼ'),
+    ('а', 'џ'),
+    ('ѡ', 'ѡ'),
+    ('ѣ', 'ѣ'),
+    ('ѥ', 'ѥ'),
+    ('ѧ', 'ѧ'),
+    ('ѩ', 'ѩ'),
+    ('ѫ', 'ѫ'),
+    ('ѭ', 'ѭ'),
+    ('ѯ', 'ѯ'),
+    ('ѱ', 'ѱ'),
+    ('ѳ', 'ѳ'),
+    ('ѵ', 'ѵ'),
+    ('ѷ', 'ѷ'),
+    ('ѹ', 'ѹ'),
+    ('ѻ', 'ѻ'),
+    ('ѽ', 'ѽ'),
+    ('ѿ', 'ѿ'),
+    ('ҁ', 'ҁ'),
+    ('ҋ', 'ҋ'),
+    ('ҍ', 'ҍ'),
+    ('ҏ', 'ҏ'),
+    ('ґ', 'ґ'),
+    ('ғ', 'ғ'),
+    ('ҕ', 'ҕ'),
+    ('җ', 'җ'),
+    ('ҙ', 'ҙ'),
+    ('қ', 'қ'),
+    ('ҝ', 'ҝ'),
+    ('ҟ', 'ҟ'),
+    ('ҡ', 'ҡ'),
+    ('ң', 'ң'),
+    ('ҥ', 'ҥ'),
+    ('ҧ', 'ҧ'),
+    ('ҩ', 'ҩ'),
+    ('ҫ', 'ҫ'),
+    ('ҭ', 'ҭ'),
+    ('ү', 'ү'),
+    ('ұ', 'ұ'),
+    ('ҳ', 'ҳ'),
+    ('ҵ', 'ҵ'),
+    ('ҷ', 'ҷ'),
+    ('ҹ', 'ҹ'),
+    ('һ', 'һ'),
+    ('ҽ', 'ҽ'),
+    ('ҿ', 'ҿ'),
+    ('ӂ', 'ӂ'),
+    ('ӄ', 'ӄ'),
+    ('ӆ', 'ӆ'),
+    ('ӈ', 'ӈ'),
+    ('ӊ', 'ӊ'),
+    ('ӌ', 'ӌ'),
+    ('ӎ', 'ӏ'),
+    ('ӑ', 'ӑ'),
+    ('ӓ', 'ӓ'),
+    ('ӕ', 'ӕ'),
+    ('ӗ', 'ӗ'),
+    ('ә', 'ә'),
+    ('ӛ', 'ӛ'),
+    ('ӝ', 'ӝ'),
+    ('ӟ', 'ӟ'),
+    ('ӡ', 'ӡ'),
+    ('ӣ', 'ӣ'),
+    ('ӥ', 'ӥ'),
+    ('ӧ', 'ӧ'),
+    ('ө', 'ө'),
+    ('ӫ', 'ӫ'),
+    ('ӭ', 'ӭ'),
+    ('ӯ', 'ӯ'),
+    ('ӱ', 'ӱ'),
+    ('ӳ', 'ӳ'),
+    ('ӵ', 'ӵ'),
+    ('ӷ', 'ӷ'),
+    ('ӹ', 'ӹ'),
+    ('ӻ', 'ӻ'),
+    ('ӽ', 'ӽ'),
+    ('ӿ', 'ӿ'),
+    ('ԁ', 'ԁ'),
+    ('ԃ', 'ԃ'),
+    ('ԅ', 'ԅ'),
+    ('ԇ', 'ԇ'),
+    ('ԉ', 'ԉ'),
+    ('ԋ', 'ԋ'),
+    ('ԍ', 'ԍ'),
+    ('ԏ', 'ԏ'),
+    ('ԑ', 'ԑ'),
+    ('ԓ', 'ԓ'),
+    ('ԕ', 'ԕ'),
+    ('ԗ', 'ԗ'),
+    ('ԙ', 'ԙ'),
+    ('ԛ', 'ԛ'),
+    ('ԝ', 'ԝ'),
+    ('ԟ', 'ԟ'),
+    ('ԡ', 'ԡ'),
+    ('ԣ', 'ԣ'),
+    ('ԥ', 'ԥ'),
+    ('ԧ', 'ԧ'),
+    ('ԩ', 'ԩ'),
+    ('ԫ', 'ԫ'),
+    ('ԭ', 'ԭ'),
+    ('ԯ', 'ԯ'),
+    ('ՠ', 'ֈ'),
+    ('ა', 'ჺ'),
+    ('ჼ', 'ჿ'),
+    ('ᏸ', 'ᏽ'),
+    ('ᲀ', 'ᲈ'),
+    ('ᴀ', 'ᶿ'),
+    ('ḁ', 'ḁ'),
+    ('ḃ', 'ḃ'),
+    ('ḅ', 'ḅ'),
+    ('ḇ', 'ḇ'),
+    ('ḉ', 'ḉ'),
+    ('ḋ', 'ḋ'),
+    ('ḍ', 'ḍ'),
+    ('ḏ', 'ḏ'),
+    ('ḑ', 'ḑ'),
+    ('ḓ', 'ḓ'),
+    ('ḕ', 'ḕ'),
+    ('ḗ', 'ḗ'),
+    ('ḙ', 'ḙ'),
+    ('ḛ', 'ḛ'),
+    ('ḝ', 'ḝ'),
+    ('ḟ', 'ḟ'),
+    ('ḡ', 'ḡ'),
+    ('ḣ', 'ḣ'),
+    ('ḥ', 'ḥ'),
+    ('ḧ', 'ḧ'),
+    ('ḩ', 'ḩ'),
+    ('ḫ', 'ḫ'),
+    ('ḭ', 'ḭ'),
+    ('ḯ', 'ḯ'),
+    ('ḱ', 'ḱ'),
+    ('ḳ', 'ḳ'),
+    ('ḵ', 'ḵ'),
+    ('ḷ', 'ḷ'),
+    ('ḹ', 'ḹ'),
+    ('ḻ', 'ḻ'),
+    ('ḽ', 'ḽ'),
+    ('ḿ', 'ḿ'),
+    ('ṁ', 'ṁ'),
+    ('ṃ', 'ṃ'),
+    ('ṅ', 'ṅ'),
+    ('ṇ', 'ṇ'),
+    ('ṉ', 'ṉ'),
+    ('ṋ', 'ṋ'),
+    ('ṍ', 'ṍ'),
+    ('ṏ', 'ṏ'),
+    ('ṑ', 'ṑ'),
+    ('ṓ', 'ṓ'),
+    ('ṕ', 'ṕ'),
+    ('ṗ', 'ṗ'),
+    ('ṙ', 'ṙ'),
+    ('ṛ', 'ṛ'),
+    ('ṝ', 'ṝ'),
+    ('ṟ', 'ṟ'),
+    ('ṡ', 'ṡ'),
+    ('ṣ', 'ṣ'),
+    ('ṥ', 'ṥ'),
+    ('ṧ', 'ṧ'),
+    ('ṩ', 'ṩ'),
+    ('ṫ', 'ṫ'),
+    ('ṭ', 'ṭ'),
+    ('ṯ', 'ṯ'),
+    ('ṱ', 'ṱ'),
+    ('ṳ', 'ṳ'),
+    ('ṵ', 'ṵ'),
+    ('ṷ', 'ṷ'),
+    ('ṹ', 'ṹ'),
+    ('ṻ', 'ṻ'),
+    ('ṽ', 'ṽ'),
+    ('ṿ', 'ṿ'),
+    ('ẁ', 'ẁ'),
+    ('ẃ', 'ẃ'),
+    ('ẅ', 'ẅ'),
+    ('ẇ', 'ẇ'),
+    ('ẉ', 'ẉ'),
+    ('ẋ', 'ẋ'),
+    ('ẍ', 'ẍ'),
+    ('ẏ', 'ẏ'),
+    ('ẑ', 'ẑ'),
+    ('ẓ', 'ẓ'),
+    ('ẕ', 'ẝ'),
+    ('ẟ', 'ẟ'),
+    ('ạ', 'ạ'),
+    ('ả', 'ả'),
+    ('ấ', 'ấ'),
+    ('ầ', 'ầ'),
+    ('ẩ', 'ẩ'),
+    ('ẫ', 'ẫ'),
+    ('ậ', 'ậ'),
+    ('ắ', 'ắ'),
+    ('ằ', 'ằ'),
+    ('ẳ', 'ẳ'),
+    ('ẵ', 'ẵ'),
+    ('ặ', 'ặ'),
+    ('ẹ', 'ẹ'),
+    ('ẻ', 'ẻ'),
+    ('ẽ', 'ẽ'),
+    ('ế', 'ế'),
+    ('ề', 'ề'),
+    ('ể', 'ể'),
+    ('ễ', 'ễ'),
+    ('ệ', 'ệ'),
+    ('ỉ', 'ỉ'),
+    ('ị', 'ị'),
+    ('ọ', 'ọ'),
+    ('ỏ', 'ỏ'),
+    ('ố', 'ố'),
+    ('ồ', 'ồ'),
+    ('ổ', 'ổ'),
+    ('ỗ', 'ỗ'),
+    ('ộ', 'ộ'),
+    ('ớ', 'ớ'),
+    ('ờ', 'ờ'),
+    ('ở', 'ở'),
+    ('ỡ', 'ỡ'),
+    ('ợ', 'ợ'),
+    ('ụ', 'ụ'),
+    ('ủ', 'ủ'),
+    ('ứ', 'ứ'),
+    ('ừ', 'ừ'),
+    ('ử', 'ử'),
+    ('ữ', 'ữ'),
+    ('ự', 'ự'),
+    ('ỳ', 'ỳ'),
+    ('ỵ', 'ỵ'),
+    ('ỷ', 'ỷ'),
+    ('ỹ', 'ỹ'),
+    ('ỻ', 'ỻ'),
+    ('ỽ', 'ỽ'),
+    ('ỿ', 'ἇ'),
+    ('ἐ', 'ἕ'),
+    ('ἠ', 'ἧ'),
+    ('ἰ', 'ἷ'),
+    ('ὀ', 'ὅ'),
+    ('ὐ', 'ὗ'),
+    ('ὠ', 'ὧ'),
+    ('ὰ', 'ώ'),
+    ('ᾀ', 'ᾇ'),
+    ('ᾐ', 'ᾗ'),
+    ('ᾠ', 'ᾧ'),
+    ('ᾰ', 'ᾴ'),
+    ('ᾶ', 'ᾷ'),
+    ('ι', 'ι'),
+    ('ῂ', 'ῄ'),
+    ('ῆ', 'ῇ'),
+    ('ῐ', 'ΐ'),
+    ('ῖ', 'ῗ'),
+    ('ῠ', 'ῧ'),
+    ('ῲ', 'ῴ'),
+    ('ῶ', 'ῷ'),
+    ('ⁱ', 'ⁱ'),
+    ('ⁿ', 'ⁿ'),
+    ('ₐ', 'ₜ'),
+    ('ℊ', 'ℊ'),
+    ('ℎ', 'ℏ'),
+    ('ℓ', 'ℓ'),
+    ('ℯ', 'ℯ'),
+    ('ℴ', 'ℴ'),
+    ('ℹ', 'ℹ'),
+    ('ℼ', 'ℽ'),
+    ('ⅆ', 'ⅉ'),
+    ('ⅎ', 'ⅎ'),
+    ('ⅰ', 'ⅿ'),
+    ('ↄ', 'ↄ'),
+    ('ⓐ', 'ⓩ'),
+    ('ⰰ', 'ⱟ'),
+    ('ⱡ', 'ⱡ'),
+    ('ⱥ', 'ⱦ'),
+    ('ⱨ', 'ⱨ'),
+    ('ⱪ', 'ⱪ'),
+    ('ⱬ', 'ⱬ'),
+    ('ⱱ', 'ⱱ'),
+    ('ⱳ', 'ⱴ'),
+    ('ⱶ', 'ⱽ'),
+    ('ⲁ', 'ⲁ'),
+    ('ⲃ', 'ⲃ'),
+    ('ⲅ', 'ⲅ'),
+    ('ⲇ', 'ⲇ'),
+    ('ⲉ', 'ⲉ'),
+    ('ⲋ', 'ⲋ'),
+    ('ⲍ', 'ⲍ'),
+    ('ⲏ', 'ⲏ'),
+    ('ⲑ', 'ⲑ'),
+    ('ⲓ', 'ⲓ'),
+    ('ⲕ', 'ⲕ'),
+    ('ⲗ', 'ⲗ'),
+    ('ⲙ', 'ⲙ'),
+    ('ⲛ', 'ⲛ'),
+    ('ⲝ', 'ⲝ'),
+    ('ⲟ', 'ⲟ'),
+    ('ⲡ', 'ⲡ'),
+    ('ⲣ', 'ⲣ'),
+    ('ⲥ', 'ⲥ'),
+    ('ⲧ', 'ⲧ'),
+    ('ⲩ', 'ⲩ'),
+    ('ⲫ', 'ⲫ'),
+    ('ⲭ', 'ⲭ'),
+    ('ⲯ', 'ⲯ'),
+    ('ⲱ', 'ⲱ'),
+    ('ⲳ', 'ⲳ'),
+    ('ⲵ', 'ⲵ'),
+    ('ⲷ', 'ⲷ'),
+    ('ⲹ', 'ⲹ'),
+    ('ⲻ', 'ⲻ'),
+    ('ⲽ', 'ⲽ'),
+    ('ⲿ', 'ⲿ'),
+    ('ⳁ', 'ⳁ'),
+    ('ⳃ', 'ⳃ'),
+    ('ⳅ', 'ⳅ'),
+    ('ⳇ', 'ⳇ'),
+    ('ⳉ', 'ⳉ'),
+    ('ⳋ', 'ⳋ'),
+    ('ⳍ', 'ⳍ'),
+    ('ⳏ', 'ⳏ'),
+    ('ⳑ', 'ⳑ'),
+    ('ⳓ', 'ⳓ'),
+    ('ⳕ', 'ⳕ'),
+    ('ⳗ', 'ⳗ'),
+    ('ⳙ', 'ⳙ'),
+    ('ⳛ', 'ⳛ'),
+    ('ⳝ', 'ⳝ'),
+    ('ⳟ', 'ⳟ'),
+    ('ⳡ', 'ⳡ'),
+    ('ⳣ', 'ⳤ'),
+    ('ⳬ', 'ⳬ'),
+    ('ⳮ', 'ⳮ'),
+    ('ⳳ', 'ⳳ'),
+    ('ⴀ', 'ⴥ'),
+    ('ⴧ', 'ⴧ'),
+    ('ⴭ', 'ⴭ'),
+    ('ꙁ', 'ꙁ'),
+    ('ꙃ', 'ꙃ'),
+    ('ꙅ', 'ꙅ'),
+    ('ꙇ', 'ꙇ'),
+    ('ꙉ', 'ꙉ'),
+    ('ꙋ', 'ꙋ'),
+    ('ꙍ', 'ꙍ'),
+    ('ꙏ', 'ꙏ'),
+    ('ꙑ', 'ꙑ'),
+    ('ꙓ', 'ꙓ'),
+    ('ꙕ', 'ꙕ'),
+    ('ꙗ', 'ꙗ'),
+    ('ꙙ', 'ꙙ'),
+    ('ꙛ', 'ꙛ'),
+    ('ꙝ', 'ꙝ'),
+    ('ꙟ', 'ꙟ'),
+    ('ꙡ', 'ꙡ'),
+    ('ꙣ', 'ꙣ'),
+    ('ꙥ', 'ꙥ'),
+    ('ꙧ', 'ꙧ'),
+    ('ꙩ', 'ꙩ'),
+    ('ꙫ', 'ꙫ'),
+    ('ꙭ', 'ꙭ'),
+    ('ꚁ', 'ꚁ'),
+    ('ꚃ', 'ꚃ'),
+    ('ꚅ', 'ꚅ'),
+    ('ꚇ', 'ꚇ'),
+    ('ꚉ', 'ꚉ'),
+    ('ꚋ', 'ꚋ'),
+    ('ꚍ', 'ꚍ'),
+    ('ꚏ', 'ꚏ'),
+    ('ꚑ', 'ꚑ'),
+    ('ꚓ', 'ꚓ'),
+    ('ꚕ', 'ꚕ'),
+    ('ꚗ', 'ꚗ'),
+    ('ꚙ', 'ꚙ'),
+    ('ꚛ', 'ꚝ'),
+    ('ꜣ', 'ꜣ'),
+    ('ꜥ', 'ꜥ'),
+    ('ꜧ', 'ꜧ'),
+    ('ꜩ', 'ꜩ'),
+    ('ꜫ', 'ꜫ'),
+    ('ꜭ', 'ꜭ'),
+    ('ꜯ', 'ꜱ'),
+    ('ꜳ', 'ꜳ'),
+    ('ꜵ', 'ꜵ'),
+    ('ꜷ', 'ꜷ'),
+    ('ꜹ', 'ꜹ'),
+    ('ꜻ', 'ꜻ'),
+    ('ꜽ', 'ꜽ'),
+    ('ꜿ', 'ꜿ'),
+    ('ꝁ', 'ꝁ'),
+    ('ꝃ', 'ꝃ'),
+    ('ꝅ', 'ꝅ'),
+    ('ꝇ', 'ꝇ'),
+    ('ꝉ', 'ꝉ'),
+    ('ꝋ', 'ꝋ'),
+    ('ꝍ', 'ꝍ'),
+    ('ꝏ', 'ꝏ'),
+    ('ꝑ', 'ꝑ'),
+    ('ꝓ', 'ꝓ'),
+    ('ꝕ', 'ꝕ'),
+    ('ꝗ', 'ꝗ'),
+    ('ꝙ', 'ꝙ'),
+    ('ꝛ', 'ꝛ'),
+    ('ꝝ', 'ꝝ'),
+    ('ꝟ', 'ꝟ'),
+    ('ꝡ', 'ꝡ'),
+    ('ꝣ', 'ꝣ'),
+    ('ꝥ', 'ꝥ'),
+    ('ꝧ', 'ꝧ'),
+    ('ꝩ', 'ꝩ'),
+    ('ꝫ', 'ꝫ'),
+    ('ꝭ', 'ꝭ'),
+    ('ꝯ', 'ꝸ'),
+    ('ꝺ', 'ꝺ'),
+    ('ꝼ', 'ꝼ'),
+    ('ꝿ', 'ꝿ'),
+    ('ꞁ', 'ꞁ'),
+    ('ꞃ', 'ꞃ'),
+    ('ꞅ', 'ꞅ'),
+    ('ꞇ', 'ꞇ'),
+    ('ꞌ', 'ꞌ'),
+    ('ꞎ', 'ꞎ'),
+    ('ꞑ', 'ꞑ'),
+    ('ꞓ', 'ꞕ'),
+    ('ꞗ', 'ꞗ'),
+    ('ꞙ', 'ꞙ'),
+    ('ꞛ', 'ꞛ'),
+    ('ꞝ', 'ꞝ'),
+    ('ꞟ', 'ꞟ'),
+    ('ꞡ', 'ꞡ'),
+    ('ꞣ', 'ꞣ'),
+    ('ꞥ', 'ꞥ'),
+    ('ꞧ', 'ꞧ'),
+    ('ꞩ', 'ꞩ'),
+    ('ꞯ', 'ꞯ'),
+    ('ꞵ', 'ꞵ'),
+    ('ꞷ', 'ꞷ'),
+    ('ꞹ', 'ꞹ'),
+    ('ꞻ', 'ꞻ'),
+    ('ꞽ', 'ꞽ'),
+    ('ꞿ', 'ꞿ'),
+    ('ꟁ', 'ꟁ'),
+    ('ꟃ', 'ꟃ'),
+    ('ꟈ', 'ꟈ'),
+    ('ꟊ', 'ꟊ'),
+    ('ꟑ', 'ꟑ'),
+    ('ꟓ', 'ꟓ'),
+    ('ꟕ', 'ꟕ'),
+    ('ꟗ', 'ꟗ'),
+    ('ꟙ', 'ꟙ'),
+    ('ꟲ', 'ꟴ'),
+    ('ꟶ', 'ꟶ'),
+    ('ꟸ', 'ꟺ'),
+    ('ꬰ', 'ꭚ'),
+    ('ꭜ', 'ꭩ'),
+    ('ꭰ', 'ꮿ'),
+    ('ﬀ', 'ﬆ'),
+    ('ﬓ', 'ﬗ'),
+    ('ａ', 'ｚ'),
+    ('𐐨', '𐑏'),
+    ('𐓘', '𐓻'),
+    ('𐖗', '𐖡'),
+    ('𐖣', '𐖱'),
+    ('𐖳', '𐖹'),
+    ('𐖻', '𐖼'),
+    ('𐞀', '𐞀'),
+    ('𐞃', '𐞅'),
+    ('𐞇', '𐞰'),
+    ('𐞲', '𐞺'),
+    ('𐳀', '𐳲'),
+    ('𑣀', '𑣟'),
+    ('𖹠', '𖹿'),
+    ('𝐚', '𝐳'),
+    ('𝑎', '𝑔'),
+    ('𝑖', '𝑧'),
+    ('𝒂', '𝒛'),
+    ('𝒶', '𝒹'),
+    ('𝒻', '𝒻'),
+    ('𝒽', '𝓃'),
+    ('𝓅', '𝓏'),
+    ('𝓪', '𝔃'),
+    ('𝔞', '𝔷'),
+    ('𝕒', '𝕫'),
+    ('𝖆', '𝖟'),
+    ('𝖺', '𝗓'),
+    ('𝗮', '𝘇'),
+    ('𝘢', '𝘻'),
+    ('𝙖', '𝙯'),
+    ('𝚊', '𝚥'),
+    ('𝛂', '𝛚'),
+    ('𝛜', '𝛡'),
+    ('𝛼', '𝜔'),
+    ('𝜖', '𝜛'),
+    ('𝜶', '𝝎'),
+    ('𝝐', '𝝕'),
+    ('𝝰', '𝞈'),
+    ('𝞊', '𝞏'),
+    ('𝞪', '𝟂'),
+    ('𝟄', '𝟉'),
+    ('𝟋', '𝟋'),
+    ('𝼀', '𝼉'),
+    ('𝼋', '𝼞'),
+    ('𝼥', '𝼪'),
+    ('𞀰', '𞁭'),
+    ('𞤢', '𞥃'),
+];
+
+pub const MATH: &'static [(char, char)] = &[
+    ('+', '+'),
+    ('<', '>'),
+    ('^', '^'),
+    ('|', '|'),
+    ('~', '~'),
+    ('¬', '¬'),
+    ('±', '±'),
+    ('×', '×'),
+    ('÷', '÷'),
+    ('ϐ', 'ϒ'),
+    ('ϕ', 'ϕ'),
+    ('ϰ', 'ϱ'),
+    ('ϴ', '϶'),
+    ('؆', '؈'),
+    ('‖', '‖'),
+    ('′', '‴'),
+    ('⁀', '⁀'),
+    ('⁄', '⁄'),
+    ('⁒', '⁒'),
+    ('\u{2061}', '\u{2064}'),
+    ('⁺', '⁾'),
+    ('₊', '₎'),
+    ('\u{20d0}', '\u{20dc}'),
+    ('\u{20e1}', '\u{20e1}'),
+    ('\u{20e5}', '\u{20e6}'),
+    ('\u{20eb}', '\u{20ef}'),
+    ('ℂ', 'ℂ'),
+    ('ℇ', 'ℇ'),
+    ('ℊ', 'ℓ'),
+    ('ℕ', 'ℕ'),
+    ('℘', 'ℝ'),
+    ('ℤ', 'ℤ'),
+    ('ℨ', '℩'),
+    ('ℬ', 'ℭ'),
+    ('ℯ', 'ℱ'),
+    ('ℳ', 'ℸ'),
+    ('ℼ', 'ⅉ'),
+    ('⅋', '⅋'),
+    ('←', '↧'),
+    ('↩', '↮'),
+    ('↰', '↱'),
+    ('↶', '↷'),
+    ('↼', '⇛'),
+    ('⇝', '⇝'),
+    ('⇤', '⇥'),
+    ('⇴', '⋿'),
+    ('⌈', '⌋'),
+    ('⌠', '⌡'),
+    ('⍼', '⍼'),
+    ('⎛', '⎵'),
+    ('⎷', '⎷'),
+    ('⏐', '⏐'),
+    ('⏜', '⏢'),
+    ('■', '□'),
+    ('▮', '▷'),
+    ('▼', '◁'),
+    ('◆', '◇'),
+    ('◊', '○'),
+    ('●', '◓'),
+    ('◢', '◢'),
+    ('◤', '◤'),
+    ('◧', '◬'),
+    ('◸', '◿'),
+    ('★', '☆'),
+    ('♀', '♀'),
+    ('♂', '♂'),
+    ('♠', '♣'),
+    ('♭', '♯'),
+    ('⟀', '⟿'),
+    ('⤀', '⫿'),
+    ('⬰', '⭄'),
+    ('⭇', '⭌'),
+    ('﬩', '﬩'),
+    ('﹡', '﹦'),
+    ('﹨', '﹨'),
+    ('＋', '＋'),
+    ('＜', '＞'),
+    ('＼', '＼'),
+    ('＾', '＾'),
+    ('｜', '｜'),
+    ('～', '～'),
+    ('￢', '￢'),
+    ('￩', '￬'),
+    ('𝐀', '𝑔'),
+    ('𝑖', '𝒜'),
+    ('𝒞', '𝒟'),
+    ('𝒢', '𝒢'),
+    ('𝒥', '𝒦'),
+    ('𝒩', '𝒬'),
+    ('𝒮', '𝒹'),
+    ('𝒻', '𝒻'),
+    ('𝒽', '𝓃'),
+    ('𝓅', '𝔅'),
+    ('𝔇', '𝔊'),
+    ('𝔍', '𝔔'),
+    ('𝔖', '𝔜'),
+    ('𝔞', '𝔹'),
+    ('𝔻', '𝔾'),
+    ('𝕀', '𝕄'),
+    ('𝕆', '𝕆'),
+    ('𝕊', '𝕐'),
+    ('𝕒', '𝚥'),
+    ('𝚨', '𝟋'),
+    ('𝟎', '𝟿'),
+    ('𞸀', '𞸃'),
+    ('𞸅', '𞸟'),
+    ('𞸡', '𞸢'),
+    ('𞸤', '𞸤'),
+    ('𞸧', '𞸧'),
+    ('𞸩', '𞸲'),
+    ('𞸴', '𞸷'),
+    ('𞸹', '𞸹'),
+    ('𞸻', '𞸻'),
+    ('𞹂', '𞹂'),
+    ('𞹇', '𞹇'),
+    ('𞹉', '𞹉'),
+    ('𞹋', '𞹋'),
+    ('𞹍', '𞹏'),
+    ('𞹑', '𞹒'),
+    ('𞹔', '𞹔'),
+    ('𞹗', '𞹗'),
+    ('𞹙', '𞹙'),
+    ('𞹛', '𞹛'),
+    ('𞹝', '𞹝'),
+    ('𞹟', '𞹟'),
+    ('𞹡', '𞹢'),
+    ('𞹤', '𞹤'),
+    ('𞹧', '𞹪'),
+    ('𞹬', '𞹲'),
+    ('𞹴', '𞹷'),
+    ('𞹹', '𞹼'),
+    ('𞹾', '𞹾'),
+    ('𞺀', '𞺉'),
+    ('𞺋', '𞺛'),
+    ('𞺡', '𞺣'),
+    ('𞺥', '𞺩'),
+    ('𞺫', '𞺻'),
+    ('𞻰', '𞻱'),
+];
+
+pub const NONCHARACTER_CODE_POINT: &'static [(char, char)] = &[
+    ('\u{fdd0}', '\u{fdef}'),
+    ('\u{fffe}', '\u{ffff}'),
+    ('\u{1fffe}', '\u{1ffff}'),
+    ('\u{2fffe}', '\u{2ffff}'),
+    ('\u{3fffe}', '\u{3ffff}'),
+    ('\u{4fffe}', '\u{4ffff}'),
+    ('\u{5fffe}', '\u{5ffff}'),
+    ('\u{6fffe}', '\u{6ffff}'),
+    ('\u{7fffe}', '\u{7ffff}'),
+    ('\u{8fffe}', '\u{8ffff}'),
+    ('\u{9fffe}', '\u{9ffff}'),
+    ('\u{afffe}', '\u{affff}'),
+    ('\u{bfffe}', '\u{bffff}'),
+    ('\u{cfffe}', '\u{cffff}'),
+    ('\u{dfffe}', '\u{dffff}'),
+    ('\u{efffe}', '\u{effff}'),
+    ('\u{ffffe}', '\u{fffff}'),
+    ('\u{10fffe}', '\u{10ffff}'),
+];
+
+pub const OTHER_ALPHABETIC: &'static [(char, char)] = &[
+    ('\u{345}', '\u{345}'),
+    ('\u{5b0}', '\u{5bd}'),
+    ('\u{5bf}', '\u{5bf}'),
+    ('\u{5c1}', '\u{5c2}'),
+    ('\u{5c4}', '\u{5c5}'),
+    ('\u{5c7}', '\u{5c7}'),
+    ('\u{610}', '\u{61a}'),
+    ('\u{64b}', '\u{657}'),
+    ('\u{659}', '\u{65f}'),
+    ('\u{670}', '\u{670}'),
+    ('\u{6d6}', '\u{6dc}'),
+    ('\u{6e1}', '\u{6e4}'),
+    ('\u{6e7}', '\u{6e8}'),
+    ('\u{6ed}', '\u{6ed}'),
+    ('\u{711}', '\u{711}'),
+    ('\u{730}', '\u{73f}'),
+    ('\u{7a6}', '\u{7b0}'),
+    ('\u{816}', '\u{817}'),
+    ('\u{81b}', '\u{823}'),
+    ('\u{825}', '\u{827}'),
+    ('\u{829}', '\u{82c}'),
+    ('\u{8d4}', '\u{8df}'),
+    ('\u{8e3}', '\u{8e9}'),
+    ('\u{8f0}', 'ः'),
+    ('\u{93a}', 'ऻ'),
+    ('ा', 'ौ'),
+    ('ॎ', 'ॏ'),
+    ('\u{955}', '\u{957}'),
+    ('\u{962}', '\u{963}'),
+    ('\u{981}', 'ঃ'),
+    ('\u{9be}', '\u{9c4}'),
+    ('ে', 'ৈ'),
+    ('ো', 'ৌ'),
+    ('\u{9d7}', '\u{9d7}'),
+    ('\u{9e2}', '\u{9e3}'),
+    ('\u{a01}', 'ਃ'),
+    ('ਾ', '\u{a42}'),
+    ('\u{a47}', '\u{a48}'),
+    ('\u{a4b}', '\u{a4c}'),
+    ('\u{a51}', '\u{a51}'),
+    ('\u{a70}', '\u{a71}'),
+    ('\u{a75}', '\u{a75}'),
+    ('\u{a81}', 'ઃ'),
+    ('ા', '\u{ac5}'),
+    ('\u{ac7}', 'ૉ'),
+    ('ો', 'ૌ'),
+    ('\u{ae2}', '\u{ae3}'),
+    ('\u{afa}', '\u{afc}'),
+    ('\u{b01}', 'ଃ'),
+    ('\u{b3e}', '\u{b44}'),
+    ('େ', 'ୈ'),
+    ('ୋ', 'ୌ'),
+    ('\u{b56}', '\u{b57}'),
+    ('\u{b62}', '\u{b63}'),
+    ('\u{b82}', '\u{b82}'),
+    ('\u{bbe}', 'ூ'),
+    ('ெ', 'ை'),
+    ('ொ', 'ௌ'),
+    ('\u{bd7}', '\u{bd7}'),
+    ('\u{c00}', '\u{c04}'),
+    ('\u{c3e}', 'ౄ'),
+    ('\u{c46}', '\u{c48}'),
+    ('\u{c4a}', '\u{c4c}'),
+    ('\u{c55}', '\u{c56}'),
+    ('\u{c62}', '\u{c63}'),
+    ('\u{c81}', 'ಃ'),
+    ('ಾ', 'ೄ'),
+    ('\u{cc6}', 'ೈ'),
+    ('ೊ', '\u{ccc}'),
+    ('\u{cd5}', '\u{cd6}'),
+    ('\u{ce2}', '\u{ce3}'),
+    ('ೳ', 'ೳ'),
+    ('\u{d00}', 'ഃ'),
+    ('\u{d3e}', '\u{d44}'),
+    ('െ', 'ൈ'),
+    ('ൊ', 'ൌ'),
+    ('\u{d57}', '\u{d57}'),
+    ('\u{d62}', '\u{d63}'),
+    ('\u{d81}', 'ඃ'),
+    ('\u{dcf}', '\u{dd4}'),
+    ('\u{dd6}', '\u{dd6}'),
+    ('ෘ', '\u{ddf}'),
+    ('ෲ', 'ෳ'),
+    ('\u{e31}', '\u{e31}'),
+    ('\u{e34}', '\u{e3a}'),
+    ('\u{e4d}', '\u{e4d}'),
+    ('\u{eb1}', '\u{eb1}'),
+    ('\u{eb4}', '\u{eb9}'),
+    ('\u{ebb}', '\u{ebc}'),
+    ('\u{ecd}', '\u{ecd}'),
+    ('\u{f71}', '\u{f83}'),
+    ('\u{f8d}', '\u{f97}'),
+    ('\u{f99}', '\u{fbc}'),
+    ('ါ', '\u{1036}'),
+    ('း', 'း'),
+    ('ျ', '\u{103e}'),
+    ('ၖ', '\u{1059}'),
+    ('\u{105e}', '\u{1060}'),
+    ('ၢ', 'ၤ'),
+    ('ၧ', 'ၭ'),
+    ('\u{1071}', '\u{1074}'),
+    ('\u{1082}', '\u{108d}'),
+    ('ႏ', 'ႏ'),
+    ('ႚ', '\u{109d}'),
+    ('\u{1712}', '\u{1713}'),
+    ('\u{1732}', '\u{1733}'),
+    ('\u{1752}', '\u{1753}'),
+    ('\u{1772}', '\u{1773}'),
+    ('ា', 'ៈ'),
+    ('\u{1885}', '\u{1886}'),
+    ('\u{18a9}', '\u{18a9}'),
+    ('\u{1920}', 'ᤫ'),
+    ('ᤰ', 'ᤸ'),
+    ('\u{1a17}', '\u{1a1b}'),
+    ('ᩕ', '\u{1a5e}'),
+    ('ᩡ', '\u{1a74}'),
+    ('\u{1abf}', '\u{1ac0}'),
+    ('\u{1acc}', '\u{1ace}'),
+    ('\u{1b00}', 'ᬄ'),
+    ('\u{1b35}', 'ᭃ'),
+    ('\u{1b80}', 'ᮂ'),
+    ('ᮡ', '\u{1ba9}'),
+    ('\u{1bac}', '\u{1bad}'),
+    ('ᯧ', '\u{1bf1}'),
+    ('ᰤ', '\u{1c36}'),
+    ('\u{1de7}', '\u{1df4}'),
+    ('Ⓐ', 'ⓩ'),
+    ('\u{2de0}', '\u{2dff}'),
+    ('\u{a674}', '\u{a67b}'),
+    ('\u{a69e}', '\u{a69f}'),
+    ('\u{a802}', '\u{a802}'),
+    ('\u{a80b}', '\u{a80b}'),
+    ('ꠣ', 'ꠧ'),
+    ('ꢀ', 'ꢁ'),
+    ('ꢴ', 'ꣃ'),
+    ('\u{a8c5}', '\u{a8c5}'),
+    ('\u{a8ff}', '\u{a8ff}'),
+    ('\u{a926}', '\u{a92a}'),
+    ('\u{a947}', 'ꥒ'),
+    ('\u{a980}', 'ꦃ'),
+    ('ꦴ', 'ꦿ'),
+    ('\u{a9e5}', '\u{a9e5}'),
+    ('\u{aa29}', '\u{aa36}'),
+    ('\u{aa43}', '\u{aa43}'),
+    ('\u{aa4c}', 'ꩍ'),
+    ('ꩻ', 'ꩽ'),
+    ('\u{aab0}', '\u{aab0}'),
+    ('\u{aab2}', '\u{aab4}'),
+    ('\u{aab7}', '\u{aab8}'),
+    ('\u{aabe}', '\u{aabe}'),
+    ('ꫫ', 'ꫯ'),
+    ('ꫵ', 'ꫵ'),
+    ('ꯣ', 'ꯪ'),
+    ('\u{fb1e}', '\u{fb1e}'),
+    ('\u{10376}', '\u{1037a}'),
+    ('\u{10a01}', '\u{10a03}'),
+    ('\u{10a05}', '\u{10a06}'),
+    ('\u{10a0c}', '\u{10a0f}'),
+    ('\u{10d24}', '\u{10d27}'),
+    ('\u{10eab}', '\u{10eac}'),
+    ('𑀀', '𑀂'),
+    ('\u{11038}', '\u{11045}'),
+    ('\u{11073}', '\u{11074}'),
+    ('\u{11080}', '𑂂'),
+    ('𑂰', '𑂸'),
+    ('\u{110c2}', '\u{110c2}'),
+    ('\u{11100}', '\u{11102}'),
+    ('\u{11127}', '\u{11132}'),
+    ('𑅅', '𑅆'),
+    ('\u{11180}', '𑆂'),
+    ('𑆳', '𑆿'),
+    ('𑇎', '\u{111cf}'),
+    ('𑈬', '\u{11234}'),
+    ('\u{11237}', '\u{11237}'),
+    ('\u{1123e}', '\u{1123e}'),
+    ('\u{11241}', '\u{11241}'),
+    ('\u{112df}', '\u{112e8}'),
+    ('\u{11300}', '𑌃'),
+    ('\u{1133e}', '𑍄'),
+    ('𑍇', '𑍈'),
+    ('𑍋', '𑍌'),
+    ('\u{11357}', '\u{11357}'),
+    ('𑍢', '𑍣'),
+    ('𑐵', '𑑁'),
+    ('\u{11443}', '𑑅'),
+    ('\u{114b0}', '𑓁'),
+    ('\u{115af}', '\u{115b5}'),
+    ('𑖸', '𑖾'),
+    ('\u{115dc}', '\u{115dd}'),
+    ('𑘰', '𑘾'),
+    ('\u{11640}', '\u{11640}'),
+    ('\u{116ab}', '\u{116b5}'),
+    ('\u{1171d}', '\u{1172a}'),
+    ('𑠬', '𑠸'),
+    ('\u{11930}', '𑤵'),
+    ('𑤷', '𑤸'),
+    ('\u{1193b}', '\u{1193c}'),
+    ('𑥀', '𑥀'),
+    ('𑥂', '𑥂'),
+    ('𑧑', '\u{119d7}'),
+    ('\u{119da}', '𑧟'),
+    ('𑧤', '𑧤'),
+    ('\u{11a01}', '\u{11a0a}'),
+    ('\u{11a35}', '𑨹'),
+    ('\u{11a3b}', '\u{11a3e}'),
+    ('\u{11a51}', '\u{11a5b}'),
+    ('\u{11a8a}', '𑪗'),
+    ('𑰯', '\u{11c36}'),
+    ('\u{11c38}', '𑰾'),
+    ('\u{11c92}', '\u{11ca7}'),
+    ('𑲩', '\u{11cb6}'),
+    ('\u{11d31}', '\u{11d36}'),
+    ('\u{11d3a}', '\u{11d3a}'),
+    ('\u{11d3c}', '\u{11d3d}'),
+    ('\u{11d3f}', '\u{11d41}'),
+    ('\u{11d43}', '\u{11d43}'),
+    ('\u{11d47}', '\u{11d47}'),
+    ('𑶊', '𑶎'),
+    ('\u{11d90}', '\u{11d91}'),
+    ('𑶓', '𑶖'),
+    ('\u{11ef3}', '𑻶'),
+    ('\u{11f00}', '\u{11f01}'),
+    ('𑼃', '𑼃'),
+    ('𑼴', '\u{11f3a}'),
+    ('𑼾', '\u{11f40}'),
+    ('\u{16f4f}', '\u{16f4f}'),
+    ('𖽑', '𖾇'),
+    ('\u{16f8f}', '\u{16f92}'),
+    ('𖿰', '𖿱'),
+    ('\u{1bc9e}', '\u{1bc9e}'),
+    ('\u{1e000}', '\u{1e006}'),
+    ('\u{1e008}', '\u{1e018}'),
+    ('\u{1e01b}', '\u{1e021}'),
+    ('\u{1e023}', '\u{1e024}'),
+    ('\u{1e026}', '\u{1e02a}'),
+    ('\u{1e08f}', '\u{1e08f}'),
+    ('\u{1e947}', '\u{1e947}'),
+    ('🄰', '🅉'),
+    ('🅐', '🅩'),
+    ('🅰', '🆉'),
+];
+
+pub const OTHER_DEFAULT_IGNORABLE_CODE_POINT: &'static [(char, char)] = &[
+    ('\u{34f}', '\u{34f}'),
+    ('ᅟ', 'ᅠ'),
+    ('\u{17b4}', '\u{17b5}'),
+    ('\u{2065}', '\u{2065}'),
+    ('ㅤ', 'ㅤ'),
+    ('ﾠ', 'ﾠ'),
+    ('\u{fff0}', '\u{fff8}'),
+    ('\u{e0000}', '\u{e0000}'),
+    ('\u{e0002}', '\u{e001f}'),
+    ('\u{e0080}', '\u{e00ff}'),
+    ('\u{e01f0}', '\u{e0fff}'),
+];
+
+pub const OTHER_GRAPHEME_EXTEND: &'static [(char, char)] = &[
+    ('\u{9be}', '\u{9be}'),
+    ('\u{9d7}', '\u{9d7}'),
+    ('\u{b3e}', '\u{b3e}'),
+    ('\u{b57}', '\u{b57}'),
+    ('\u{bbe}', '\u{bbe}'),
+    ('\u{bd7}', '\u{bd7}'),
+    ('\u{cc2}', '\u{cc2}'),
+    ('\u{cd5}', '\u{cd6}'),
+    ('\u{d3e}', '\u{d3e}'),
+    ('\u{d57}', '\u{d57}'),
+    ('\u{dcf}', '\u{dcf}'),
+    ('\u{ddf}', '\u{ddf}'),
+    ('\u{1b35}', '\u{1b35}'),
+    ('\u{200c}', '\u{200c}'),
+    ('\u{302e}', '\u{302f}'),
+    ('\u{ff9e}', '\u{ff9f}'),
+    ('\u{1133e}', '\u{1133e}'),
+    ('\u{11357}', '\u{11357}'),
+    ('\u{114b0}', '\u{114b0}'),
+    ('\u{114bd}', '\u{114bd}'),
+    ('\u{115af}', '\u{115af}'),
+    ('\u{11930}', '\u{11930}'),
+    ('\u{1d165}', '\u{1d165}'),
+    ('\u{1d16e}', '\u{1d172}'),
+    ('\u{e0020}', '\u{e007f}'),
+];
+
+pub const OTHER_ID_CONTINUE: &'static [(char, char)] =
+    &[('·', '·'), ('·', '·'), ('፩', '፱'), ('᧚', '᧚')];
+
+pub const OTHER_ID_START: &'static [(char, char)] =
+    &[('\u{1885}', '\u{1886}'), ('℘', '℘'), ('℮', '℮'), ('゛', '゜')];
+
+pub const OTHER_LOWERCASE: &'static [(char, char)] = &[
+    ('ª', 'ª'),
+    ('º', 'º'),
+    ('ʰ', 'ʸ'),
+    ('ˀ', 'ˁ'),
+    ('ˠ', 'ˤ'),
+    ('\u{345}', '\u{345}'),
+    ('ͺ', 'ͺ'),
+    ('ჼ', 'ჼ'),
+    ('ᴬ', 'ᵪ'),
+    ('ᵸ', 'ᵸ'),
+    ('ᶛ', 'ᶿ'),
+    ('ⁱ', 'ⁱ'),
+    ('ⁿ', 'ⁿ'),
+    ('ₐ', 'ₜ'),
+    ('ⅰ', 'ⅿ'),
+    ('ⓐ', 'ⓩ'),
+    ('ⱼ', 'ⱽ'),
+    ('ꚜ', 'ꚝ'),
+    ('ꝰ', 'ꝰ'),
+    ('ꟲ', 'ꟴ'),
+    ('ꟸ', 'ꟹ'),
+    ('ꭜ', 'ꭟ'),
+    ('ꭩ', 'ꭩ'),
+    ('𐞀', '𐞀'),
+    ('𐞃', '𐞅'),
+    ('𐞇', '𐞰'),
+    ('𐞲', '𐞺'),
+    ('𞀰', '𞁭'),
+];
+
+pub const OTHER_MATH: &'static [(char, char)] = &[
+    ('^', '^'),
+    ('ϐ', 'ϒ'),
+    ('ϕ', 'ϕ'),
+    ('ϰ', 'ϱ'),
+    ('ϴ', 'ϵ'),
+    ('‖', '‖'),
+    ('′', '‴'),
+    ('⁀', '⁀'),
+    ('\u{2061}', '\u{2064}'),
+    ('⁽', '⁾'),
+    ('₍', '₎'),
+    ('\u{20d0}', '\u{20dc}'),
+    ('\u{20e1}', '\u{20e1}'),
+    ('\u{20e5}', '\u{20e6}'),
+    ('\u{20eb}', '\u{20ef}'),
+    ('ℂ', 'ℂ'),
+    ('ℇ', 'ℇ'),
+    ('ℊ', 'ℓ'),
+    ('ℕ', 'ℕ'),
+    ('ℙ', 'ℝ'),
+    ('ℤ', 'ℤ'),
+    ('ℨ', '℩'),
+    ('ℬ', 'ℭ'),
+    ('ℯ', 'ℱ'),
+    ('ℳ', 'ℸ'),
+    ('ℼ', 'ℿ'),
+    ('ⅅ', 'ⅉ'),
+    ('↕', '↙'),
+    ('↜', '↟'),
+    ('↡', '↢'),
+    ('↤', '↥'),
+    ('↧', '↧'),
+    ('↩', '↭'),
+    ('↰', '↱'),
+    ('↶', '↷'),
+    ('↼', '⇍'),
+    ('⇐', '⇑'),
+    ('⇓', '⇓'),
+    ('⇕', '⇛'),
+    ('⇝', '⇝'),
+    ('⇤', '⇥'),
+    ('⌈', '⌋'),
+    ('⎴', '⎵'),
+    ('⎷', '⎷'),
+    ('⏐', '⏐'),
+    ('⏢', '⏢'),
+    ('■', '□'),
+    ('▮', '▶'),
+    ('▼', '◀'),
+    ('◆', '◇'),
+    ('◊', '○'),
+    ('●', '◓'),
+    ('◢', '◢'),
+    ('◤', '◤'),
+    ('◧', '◬'),
+    ('★', '☆'),
+    ('♀', '♀'),
+    ('♂', '♂'),
+    ('♠', '♣'),
+    ('♭', '♮'),
+    ('⟅', '⟆'),
+    ('⟦', '⟯'),
+    ('⦃', '⦘'),
+    ('⧘', '⧛'),
+    ('⧼', '⧽'),
+    ('﹡', '﹡'),
+    ('﹣', '﹣'),
+    ('﹨', '﹨'),
+    ('＼', '＼'),
+    ('＾', '＾'),
+    ('𝐀', '𝑔'),
+    ('𝑖', '𝒜'),
+    ('𝒞', '𝒟'),
+    ('𝒢', '𝒢'),
+    ('𝒥', '𝒦'),
+    ('𝒩', '𝒬'),
+    ('𝒮', '𝒹'),
+    ('𝒻', '𝒻'),
+    ('𝒽', '𝓃'),
+    ('𝓅', '𝔅'),
+    ('𝔇', '𝔊'),
+    ('𝔍', '𝔔'),
+    ('𝔖', '𝔜'),
+    ('𝔞', '𝔹'),
+    ('𝔻', '𝔾'),
+    ('𝕀', '𝕄'),
+    ('𝕆', '𝕆'),
+    ('𝕊', '𝕐'),
+    ('𝕒', '𝚥'),
+    ('𝚨', '𝛀'),
+    ('𝛂', '𝛚'),
+    ('𝛜', '𝛺'),
+    ('𝛼', '𝜔'),
+    ('𝜖', '𝜴'),
+    ('𝜶', '𝝎'),
+    ('𝝐', '𝝮'),
+    ('𝝰', '𝞈'),
+    ('𝞊', '𝞨'),
+    ('𝞪', '𝟂'),
+    ('𝟄', '𝟋'),
+    ('𝟎', '𝟿'),
+    ('𞸀', '𞸃'),
+    ('𞸅', '𞸟'),
+    ('𞸡', '𞸢'),
+    ('𞸤', '𞸤'),
+    ('𞸧', '𞸧'),
+    ('𞸩', '𞸲'),
+    ('𞸴', '𞸷'),
+    ('𞸹', '𞸹'),
+    ('𞸻', '𞸻'),
+    ('𞹂', '𞹂'),
+    ('𞹇', '𞹇'),
+    ('𞹉', '𞹉'),
+    ('𞹋', '𞹋'),
+    ('𞹍', '𞹏'),
+    ('𞹑', '𞹒'),
+    ('𞹔', '𞹔'),
+    ('𞹗', '𞹗'),
+    ('𞹙', '𞹙'),
+    ('𞹛', '𞹛'),
+    ('𞹝', '𞹝'),
+    ('𞹟', '𞹟'),
+    ('𞹡', '𞹢'),
+    ('𞹤', '𞹤'),
+    ('𞹧', '𞹪'),
+    ('𞹬', '𞹲'),
+    ('𞹴', '𞹷'),
+    ('𞹹', '𞹼'),
+    ('𞹾', '𞹾'),
+    ('𞺀', '𞺉'),
+    ('𞺋', '𞺛'),
+    ('𞺡', '𞺣'),
+    ('𞺥', '𞺩'),
+    ('𞺫', '𞺻'),
+];
+
+pub const OTHER_UPPERCASE: &'static [(char, char)] =
+    &[('Ⅰ', 'Ⅿ'), ('Ⓐ', 'Ⓩ'), ('🄰', '🅉'), ('🅐', '🅩'), ('🅰', '🆉')];
+
+pub const PATTERN_SYNTAX: &'static [(char, char)] = &[
+    ('!', '/'),
+    (':', '@'),
+    ('[', '^'),
+    ('`', '`'),
+    ('{', '~'),
+    ('¡', '§'),
+    ('©', '©'),
+    ('«', '¬'),
+    ('®', '®'),
+    ('°', '±'),
+    ('¶', '¶'),
+    ('»', '»'),
+    ('¿', '¿'),
+    ('×', '×'),
+    ('÷', '÷'),
+    ('‐', '‧'),
+    ('‰', '‾'),
+    ('⁁', '⁓'),
+    ('⁕', '⁞'),
+    ('←', '\u{245f}'),
+    ('─', '❵'),
+    ('➔', '⯿'),
+    ('⸀', '\u{2e7f}'),
+    ('、', '〃'),
+    ('〈', '〠'),
+    ('〰', '〰'),
+    ('﴾', '﴿'),
+    ('﹅', '﹆'),
+];
+
+pub const PATTERN_WHITE_SPACE: &'static [(char, char)] = &[
+    ('\t', '\r'),
+    (' ', ' '),
+    ('\u{85}', '\u{85}'),
+    ('\u{200e}', '\u{200f}'),
+    ('\u{2028}', '\u{2029}'),
+];
+
+pub const PREPENDED_CONCATENATION_MARK: &'static [(char, char)] = &[
+    ('\u{600}', '\u{605}'),
+    ('\u{6dd}', '\u{6dd}'),
+    ('\u{70f}', '\u{70f}'),
+    ('\u{890}', '\u{891}'),
+    ('\u{8e2}', '\u{8e2}'),
+    ('\u{110bd}', '\u{110bd}'),
+    ('\u{110cd}', '\u{110cd}'),
+];
+
+pub const QUOTATION_MARK: &'static [(char, char)] = &[
+    ('"', '"'),
+    ('\'', '\''),
+    ('«', '«'),
+    ('»', '»'),
+    ('‘', '‟'),
+    ('‹', '›'),
+    ('⹂', '⹂'),
+    ('「', '』'),
+    ('〝', '〟'),
+    ('﹁', '﹄'),
+    ('＂', '＂'),
+    ('＇', '＇'),
+    ('｢', '｣'),
+];
+
+pub const RADICAL: &'static [(char, char)] =
+    &[('⺀', '⺙'), ('⺛', '⻳'), ('⼀', '⿕')];
+
+pub const REGIONAL_INDICATOR: &'static [(char, char)] = &[('🇦', '🇿')];
+
+pub const SENTENCE_TERMINAL: &'static [(char, char)] = &[
+    ('!', '!'),
+    ('.', '.'),
+    ('?', '?'),
+    ('։', '։'),
+    ('؝', '؟'),
+    ('۔', '۔'),
+    ('܀', '܂'),
+    ('߹', '߹'),
+    ('࠷', '࠷'),
+    ('࠹', '࠹'),
+    ('࠽', '࠾'),
+    ('।', '॥'),
+    ('၊', '။'),
+    ('።', '።'),
+    ('፧', '፨'),
+    ('᙮', '᙮'),
+    ('᜵', '᜶'),
+    ('᠃', '᠃'),
+    ('᠉', '᠉'),
+    ('᥄', '᥅'),
+    ('᪨', '᪫'),
+    ('᭚', '᭛'),
+    ('᭞', '᭟'),
+    ('᭽', '᭾'),
+    ('᰻', '᰼'),
+    ('᱾', '᱿'),
+    ('‼', '‽'),
+    ('⁇', '⁉'),
+    ('⸮', '⸮'),
+    ('⸼', '⸼'),
+    ('⹓', '⹔'),
+    ('。', '。'),
+    ('꓿', '꓿'),
+    ('꘎', '꘏'),
+    ('꛳', '꛳'),
+    ('꛷', '꛷'),
+    ('꡶', '꡷'),
+    ('꣎', '꣏'),
+    ('꤯', '꤯'),
+    ('꧈', '꧉'),
+    ('꩝', '꩟'),
+    ('꫰', '꫱'),
+    ('꯫', '꯫'),
+    ('﹒', '﹒'),
+    ('﹖', '﹗'),
+    ('！', '！'),
+    ('．', '．'),
+    ('？', '？'),
+    ('｡', '｡'),
+    ('𐩖', '𐩗'),
+    ('𐽕', '𐽙'),
+    ('𐾆', '𐾉'),
+    ('𑁇', '𑁈'),
+    ('𑂾', '𑃁'),
+    ('𑅁', '𑅃'),
+    ('𑇅', '𑇆'),
+    ('𑇍', '𑇍'),
+    ('𑇞', '𑇟'),
+    ('𑈸', '𑈹'),
+    ('𑈻', '𑈼'),
+    ('𑊩', '𑊩'),
+    ('𑑋', '𑑌'),
+    ('𑗂', '𑗃'),
+    ('𑗉', '𑗗'),
+    ('𑙁', '𑙂'),
+    ('𑜼', '𑜾'),
+    ('𑥄', '𑥄'),
+    ('𑥆', '𑥆'),
+    ('𑩂', '𑩃'),
+    ('𑪛', '𑪜'),
+    ('𑱁', '𑱂'),
+    ('𑻷', '𑻸'),
+    ('𑽃', '𑽄'),
+    ('𖩮', '𖩯'),
+    ('𖫵', '𖫵'),
+    ('𖬷', '𖬸'),
+    ('𖭄', '𖭄'),
+    ('𖺘', '𖺘'),
+    ('𛲟', '𛲟'),
+    ('𝪈', '𝪈'),
+];
+
+pub const SOFT_DOTTED: &'static [(char, char)] = &[
+    ('i', 'j'),
+    ('į', 'į'),
+    ('ɉ', 'ɉ'),
+    ('ɨ', 'ɨ'),
+    ('ʝ', 'ʝ'),
+    ('ʲ', 'ʲ'),
+    ('ϳ', 'ϳ'),
+    ('і', 'і'),
+    ('ј', 'ј'),
+    ('ᵢ', 'ᵢ'),
+    ('ᶖ', 'ᶖ'),
+    ('ᶤ', 'ᶤ'),
+    ('ᶨ', 'ᶨ'),
+    ('ḭ', 'ḭ'),
+    ('ị', 'ị'),
+    ('ⁱ', 'ⁱ'),
+    ('ⅈ', 'ⅉ'),
+    ('ⱼ', 'ⱼ'),
+    ('𝐢', '𝐣'),
+    ('𝑖', '𝑗'),
+    ('𝒊', '𝒋'),
+    ('𝒾', '𝒿'),
+    ('𝓲', '𝓳'),
+    ('𝔦', '𝔧'),
+    ('𝕚', '𝕛'),
+    ('𝖎', '𝖏'),
+    ('𝗂', '𝗃'),
+    ('𝗶', '𝗷'),
+    ('𝘪', '𝘫'),
+    ('𝙞', '𝙟'),
+    ('𝚒', '𝚓'),
+    ('𝼚', '𝼚'),
+    ('𞁌', '𞁍'),
+    ('𞁨', '𞁨'),
+];
+
+pub const TERMINAL_PUNCTUATION: &'static [(char, char)] = &[
+    ('!', '!'),
+    (',', ','),
+    ('.', '.'),
+    (':', ';'),
+    ('?', '?'),
+    (';', ';'),
+    ('·', '·'),
+    ('։', '։'),
+    ('׃', '׃'),
+    ('،', '،'),
+    ('؛', '؛'),
+    ('؝', '؟'),
+    ('۔', '۔'),
+    ('܀', '܊'),
+    ('܌', '܌'),
+    ('߸', '߹'),
+    ('࠰', '࠾'),
+    ('࡞', '࡞'),
+    ('।', '॥'),
+    ('๚', '๛'),
+    ('༈', '༈'),
+    ('།', '༒'),
+    ('၊', '။'),
+    ('፡', '፨'),
+    ('᙮', '᙮'),
+    ('᛫', '᛭'),
+    ('᜵', '᜶'),
+    ('។', '៖'),
+    ('៚', '៚'),
+    ('᠂', '᠅'),
+    ('᠈', '᠉'),
+    ('᥄', '᥅'),
+    ('᪨', '᪫'),
+    ('᭚', '᭛'),
+    ('᭝', '᭟'),
+    ('᭽', '᭾'),
+    ('᰻', '᰿'),
+    ('᱾', '᱿'),
+    ('‼', '‽'),
+    ('⁇', '⁉'),
+    ('⸮', '⸮'),
+    ('⸼', '⸼'),
+    ('⹁', '⹁'),
+    ('⹌', '⹌'),
+    ('⹎', '⹏'),
+    ('⹓', '⹔'),
+    ('、', '。'),
+    ('꓾', '꓿'),
+    ('꘍', '꘏'),
+    ('꛳', '꛷'),
+    ('꡶', '꡷'),
+    ('꣎', '꣏'),
+    ('꤯', '꤯'),
+    ('꧇', '꧉'),
+    ('꩝', '꩟'),
+    ('꫟', '꫟'),
+    ('꫰', '꫱'),
+    ('꯫', '꯫'),
+    ('﹐', '﹒'),
+    ('﹔', '﹗'),
+    ('！', '！'),
+    ('，', '，'),
+    ('．', '．'),
+    ('：', '；'),
+    ('？', '？'),
+    ('｡', '｡'),
+    ('､', '､'),
+    ('𐎟', '𐎟'),
+    ('𐏐', '𐏐'),
+    ('𐡗', '𐡗'),
+    ('𐤟', '𐤟'),
+    ('𐩖', '𐩗'),
+    ('𐫰', '𐫵'),
+    ('𐬺', '𐬿'),
+    ('𐮙', '𐮜'),
+    ('𐽕', '𐽙'),
+    ('𐾆', '𐾉'),
+    ('𑁇', '𑁍'),
+    ('𑂾', '𑃁'),
+    ('𑅁', '𑅃'),
+    ('𑇅', '𑇆'),
+    ('𑇍', '𑇍'),
+    ('𑇞', '𑇟'),
+    ('𑈸', '𑈼'),
+    ('𑊩', '𑊩'),
+    ('𑑋', '𑑍'),
+    ('𑑚', '𑑛'),
+    ('𑗂', '𑗅'),
+    ('𑗉', '𑗗'),
+    ('𑙁', '𑙂'),
+    ('𑜼', '𑜾'),
+    ('𑥄', '𑥄'),
+    ('𑥆', '𑥆'),
+    ('𑩂', '𑩃'),
+    ('𑪛', '𑪜'),
+    ('𑪡', '𑪢'),
+    ('𑱁', '𑱃'),
+    ('𑱱', '𑱱'),
+    ('𑻷', '𑻸'),
+    ('𑽃', '𑽄'),
+    ('𒑰', '𒑴'),
+    ('𖩮', '𖩯'),
+    ('𖫵', '𖫵'),
+    ('𖬷', '𖬹'),
+    ('𖭄', '𖭄'),
+    ('𖺗', '𖺘'),
+    ('𛲟', '𛲟'),
+    ('𝪇', '𝪊'),
+];
+
+pub const UNIFIED_IDEOGRAPH: &'static [(char, char)] = &[
+    ('㐀', '䶿'),
+    ('一', '鿿'),
+    ('﨎', '﨏'),
+    ('﨑', '﨑'),
+    ('﨓', '﨔'),
+    ('﨟', '﨟'),
+    ('﨡', '﨡'),
+    ('﨣', '﨤'),
+    ('﨧', '﨩'),
+    ('𠀀', '𪛟'),
+    ('𪜀', '𫜹'),
+    ('𫝀', '𫠝'),
+    ('𫠠', '𬺡'),
+    ('𬺰', '𮯠'),
+    ('𰀀', '𱍊'),
+    ('𱍐', '𲎯'),
+];
+
+pub const UPPERCASE: &'static [(char, char)] = &[
+    ('A', 'Z'),
+    ('À', 'Ö'),
+    ('Ø', 'Þ'),
+    ('Ā', 'Ā'),
+    ('Ă', 'Ă'),
+    ('Ą', 'Ą'),
+    ('Ć', 'Ć'),
+    ('Ĉ', 'Ĉ'),
+    ('Ċ', 'Ċ'),
+    ('Č', 'Č'),
+    ('Ď', 'Ď'),
+    ('Đ', 'Đ'),
+    ('Ē', 'Ē'),
+    ('Ĕ', 'Ĕ'),
+    ('Ė', 'Ė'),
+    ('Ę', 'Ę'),
+    ('Ě', 'Ě'),
+    ('Ĝ', 'Ĝ'),
+    ('Ğ', 'Ğ'),
+    ('Ġ', 'Ġ'),
+    ('Ģ', 'Ģ'),
+    ('Ĥ', 'Ĥ'),
+    ('Ħ', 'Ħ'),
+    ('Ĩ', 'Ĩ'),
+    ('Ī', 'Ī'),
+    ('Ĭ', 'Ĭ'),
+    ('Į', 'Į'),
+    ('İ', 'İ'),
+    ('Ĳ', 'Ĳ'),
+    ('Ĵ', 'Ĵ'),
+    ('Ķ', 'Ķ'),
+    ('Ĺ', 'Ĺ'),
+    ('Ļ', 'Ļ'),
+    ('Ľ', 'Ľ'),
+    ('Ŀ', 'Ŀ'),
+    ('Ł', 'Ł'),
+    ('Ń', 'Ń'),
+    ('Ņ', 'Ņ'),
+    ('Ň', 'Ň'),
+    ('Ŋ', 'Ŋ'),
+    ('Ō', 'Ō'),
+    ('Ŏ', 'Ŏ'),
+    ('Ő', 'Ő'),
+    ('Œ', 'Œ'),
+    ('Ŕ', 'Ŕ'),
+    ('Ŗ', 'Ŗ'),
+    ('Ř', 'Ř'),
+    ('Ś', 'Ś'),
+    ('Ŝ', 'Ŝ'),
+    ('Ş', 'Ş'),
+    ('Š', 'Š'),
+    ('Ţ', 'Ţ'),
+    ('Ť', 'Ť'),
+    ('Ŧ', 'Ŧ'),
+    ('Ũ', 'Ũ'),
+    ('Ū', 'Ū'),
+    ('Ŭ', 'Ŭ'),
+    ('Ů', 'Ů'),
+    ('Ű', 'Ű'),
+    ('Ų', 'Ų'),
+    ('Ŵ', 'Ŵ'),
+    ('Ŷ', 'Ŷ'),
+    ('Ÿ', 'Ź'),
+    ('Ż', 'Ż'),
+    ('Ž', 'Ž'),
+    ('Ɓ', 'Ƃ'),
+    ('Ƅ', 'Ƅ'),
+    ('Ɔ', 'Ƈ'),
+    ('Ɖ', 'Ƌ'),
+    ('Ǝ', 'Ƒ'),
+    ('Ɠ', 'Ɣ'),
+    ('Ɩ', 'Ƙ'),
+    ('Ɯ', 'Ɲ'),
+    ('Ɵ', 'Ơ'),
+    ('Ƣ', 'Ƣ'),
+    ('Ƥ', 'Ƥ'),
+    ('Ʀ', 'Ƨ'),
+    ('Ʃ', 'Ʃ'),
+    ('Ƭ', 'Ƭ'),
+    ('Ʈ', 'Ư'),
+    ('Ʊ', 'Ƴ'),
+    ('Ƶ', 'Ƶ'),
+    ('Ʒ', 'Ƹ'),
+    ('Ƽ', 'Ƽ'),
+    ('Ǆ', 'Ǆ'),
+    ('Ǉ', 'Ǉ'),
+    ('Ǌ', 'Ǌ'),
+    ('Ǎ', 'Ǎ'),
+    ('Ǐ', 'Ǐ'),
+    ('Ǒ', 'Ǒ'),
+    ('Ǔ', 'Ǔ'),
+    ('Ǖ', 'Ǖ'),
+    ('Ǘ', 'Ǘ'),
+    ('Ǚ', 'Ǚ'),
+    ('Ǜ', 'Ǜ'),
+    ('Ǟ', 'Ǟ'),
+    ('Ǡ', 'Ǡ'),
+    ('Ǣ', 'Ǣ'),
+    ('Ǥ', 'Ǥ'),
+    ('Ǧ', 'Ǧ'),
+    ('Ǩ', 'Ǩ'),
+    ('Ǫ', 'Ǫ'),
+    ('Ǭ', 'Ǭ'),
+    ('Ǯ', 'Ǯ'),
+    ('Ǳ', 'Ǳ'),
+    ('Ǵ', 'Ǵ'),
+    ('Ƕ', 'Ǹ'),
+    ('Ǻ', 'Ǻ'),
+    ('Ǽ', 'Ǽ'),
+    ('Ǿ', 'Ǿ'),
+    ('Ȁ', 'Ȁ'),
+    ('Ȃ', 'Ȃ'),
+    ('Ȅ', 'Ȅ'),
+    ('Ȇ', 'Ȇ'),
+    ('Ȉ', 'Ȉ'),
+    ('Ȋ', 'Ȋ'),
+    ('Ȍ', 'Ȍ'),
+    ('Ȏ', 'Ȏ'),
+    ('Ȑ', 'Ȑ'),
+    ('Ȓ', 'Ȓ'),
+    ('Ȕ', 'Ȕ'),
+    ('Ȗ', 'Ȗ'),
+    ('Ș', 'Ș'),
+    ('Ț', 'Ț'),
+    ('Ȝ', 'Ȝ'),
+    ('Ȟ', 'Ȟ'),
+    ('Ƞ', 'Ƞ'),
+    ('Ȣ', 'Ȣ'),
+    ('Ȥ', 'Ȥ'),
+    ('Ȧ', 'Ȧ'),
+    ('Ȩ', 'Ȩ'),
+    ('Ȫ', 'Ȫ'),
+    ('Ȭ', 'Ȭ'),
+    ('Ȯ', 'Ȯ'),
+    ('Ȱ', 'Ȱ'),
+    ('Ȳ', 'Ȳ'),
+    ('Ⱥ', 'Ȼ'),
+    ('Ƚ', 'Ⱦ'),
+    ('Ɂ', 'Ɂ'),
+    ('Ƀ', 'Ɇ'),
+    ('Ɉ', 'Ɉ'),
+    ('Ɋ', 'Ɋ'),
+    ('Ɍ', 'Ɍ'),
+    ('Ɏ', 'Ɏ'),
+    ('Ͱ', 'Ͱ'),
+    ('Ͳ', 'Ͳ'),
+    ('Ͷ', 'Ͷ'),
+    ('Ϳ', 'Ϳ'),
+    ('Ά', 'Ά'),
+    ('Έ', 'Ί'),
+    ('Ό', 'Ό'),
+    ('Ύ', 'Ώ'),
+    ('Α', 'Ρ'),
+    ('Σ', 'Ϋ'),
+    ('Ϗ', 'Ϗ'),
+    ('ϒ', 'ϔ'),
+    ('Ϙ', 'Ϙ'),
+    ('Ϛ', 'Ϛ'),
+    ('Ϝ', 'Ϝ'),
+    ('Ϟ', 'Ϟ'),
+    ('Ϡ', 'Ϡ'),
+    ('Ϣ', 'Ϣ'),
+    ('Ϥ', 'Ϥ'),
+    ('Ϧ', 'Ϧ'),
+    ('Ϩ', 'Ϩ'),
+    ('Ϫ', 'Ϫ'),
+    ('Ϭ', 'Ϭ'),
+    ('Ϯ', 'Ϯ'),
+    ('ϴ', 'ϴ'),
+    ('Ϸ', 'Ϸ'),
+    ('Ϲ', 'Ϻ'),
+    ('Ͻ', 'Я'),
+    ('Ѡ', 'Ѡ'),
+    ('Ѣ', 'Ѣ'),
+    ('Ѥ', 'Ѥ'),
+    ('Ѧ', 'Ѧ'),
+    ('Ѩ', 'Ѩ'),
+    ('Ѫ', 'Ѫ'),
+    ('Ѭ', 'Ѭ'),
+    ('Ѯ', 'Ѯ'),
+    ('Ѱ', 'Ѱ'),
+    ('Ѳ', 'Ѳ'),
+    ('Ѵ', 'Ѵ'),
+    ('Ѷ', 'Ѷ'),
+    ('Ѹ', 'Ѹ'),
+    ('Ѻ', 'Ѻ'),
+    ('Ѽ', 'Ѽ'),
+    ('Ѿ', 'Ѿ'),
+    ('Ҁ', 'Ҁ'),
+    ('Ҋ', 'Ҋ'),
+    ('Ҍ', 'Ҍ'),
+    ('Ҏ', 'Ҏ'),
+    ('Ґ', 'Ґ'),
+    ('Ғ', 'Ғ'),
+    ('Ҕ', 'Ҕ'),
+    ('Җ', 'Җ'),
+    ('Ҙ', 'Ҙ'),
+    ('Қ', 'Қ'),
+    ('Ҝ', 'Ҝ'),
+    ('Ҟ', 'Ҟ'),
+    ('Ҡ', 'Ҡ'),
+    ('Ң', 'Ң'),
+    ('Ҥ', 'Ҥ'),
+    ('Ҧ', 'Ҧ'),
+    ('Ҩ', 'Ҩ'),
+    ('Ҫ', 'Ҫ'),
+    ('Ҭ', 'Ҭ'),
+    ('Ү', 'Ү'),
+    ('Ұ', 'Ұ'),
+    ('Ҳ', 'Ҳ'),
+    ('Ҵ', 'Ҵ'),
+    ('Ҷ', 'Ҷ'),
+    ('Ҹ', 'Ҹ'),
+    ('Һ', 'Һ'),
+    ('Ҽ', 'Ҽ'),
+    ('Ҿ', 'Ҿ'),
+    ('Ӏ', 'Ӂ'),
+    ('Ӄ', 'Ӄ'),
+    ('Ӆ', 'Ӆ'),
+    ('Ӈ', 'Ӈ'),
+    ('Ӊ', 'Ӊ'),
+    ('Ӌ', 'Ӌ'),
+    ('Ӎ', 'Ӎ'),
+    ('Ӑ', 'Ӑ'),
+    ('Ӓ', 'Ӓ'),
+    ('Ӕ', 'Ӕ'),
+    ('Ӗ', 'Ӗ'),
+    ('Ә', 'Ә'),
+    ('Ӛ', 'Ӛ'),
+    ('Ӝ', 'Ӝ'),
+    ('Ӟ', 'Ӟ'),
+    ('Ӡ', 'Ӡ'),
+    ('Ӣ', 'Ӣ'),
+    ('Ӥ', 'Ӥ'),
+    ('Ӧ', 'Ӧ'),
+    ('Ө', 'Ө'),
+    ('Ӫ', 'Ӫ'),
+    ('Ӭ', 'Ӭ'),
+    ('Ӯ', 'Ӯ'),
+    ('Ӱ', 'Ӱ'),
+    ('Ӳ', 'Ӳ'),
+    ('Ӵ', 'Ӵ'),
+    ('Ӷ', 'Ӷ'),
+    ('Ӹ', 'Ӹ'),
+    ('Ӻ', 'Ӻ'),
+    ('Ӽ', 'Ӽ'),
+    ('Ӿ', 'Ӿ'),
+    ('Ԁ', 'Ԁ'),
+    ('Ԃ', 'Ԃ'),
+    ('Ԅ', 'Ԅ'),
+    ('Ԇ', 'Ԇ'),
+    ('Ԉ', 'Ԉ'),
+    ('Ԋ', 'Ԋ'),
+    ('Ԍ', 'Ԍ'),
+    ('Ԏ', 'Ԏ'),
+    ('Ԑ', 'Ԑ'),
+    ('Ԓ', 'Ԓ'),
+    ('Ԕ', 'Ԕ'),
+    ('Ԗ', 'Ԗ'),
+    ('Ԙ', 'Ԙ'),
+    ('Ԛ', 'Ԛ'),
+    ('Ԝ', 'Ԝ'),
+    ('Ԟ', 'Ԟ'),
+    ('Ԡ', 'Ԡ'),
+    ('Ԣ', 'Ԣ'),
+    ('Ԥ', 'Ԥ'),
+    ('Ԧ', 'Ԧ'),
+    ('Ԩ', 'Ԩ'),
+    ('Ԫ', 'Ԫ'),
+    ('Ԭ', 'Ԭ'),
+    ('Ԯ', 'Ԯ'),
+    ('Ա', 'Ֆ'),
+    ('Ⴀ', 'Ⴥ'),
+    ('Ⴧ', 'Ⴧ'),
+    ('Ⴭ', 'Ⴭ'),
+    ('Ꭰ', 'Ᏽ'),
+    ('Ა', 'Ჺ'),
+    ('Ჽ', 'Ჿ'),
+    ('Ḁ', 'Ḁ'),
+    ('Ḃ', 'Ḃ'),
+    ('Ḅ', 'Ḅ'),
+    ('Ḇ', 'Ḇ'),
+    ('Ḉ', 'Ḉ'),
+    ('Ḋ', 'Ḋ'),
+    ('Ḍ', 'Ḍ'),
+    ('Ḏ', 'Ḏ'),
+    ('Ḑ', 'Ḑ'),
+    ('Ḓ', 'Ḓ'),
+    ('Ḕ', 'Ḕ'),
+    ('Ḗ', 'Ḗ'),
+    ('Ḙ', 'Ḙ'),
+    ('Ḛ', 'Ḛ'),
+    ('Ḝ', 'Ḝ'),
+    ('Ḟ', 'Ḟ'),
+    ('Ḡ', 'Ḡ'),
+    ('Ḣ', 'Ḣ'),
+    ('Ḥ', 'Ḥ'),
+    ('Ḧ', 'Ḧ'),
+    ('Ḩ', 'Ḩ'),
+    ('Ḫ', 'Ḫ'),
+    ('Ḭ', 'Ḭ'),
+    ('Ḯ', 'Ḯ'),
+    ('Ḱ', 'Ḱ'),
+    ('Ḳ', 'Ḳ'),
+    ('Ḵ', 'Ḵ'),
+    ('Ḷ', 'Ḷ'),
+    ('Ḹ', 'Ḹ'),
+    ('Ḻ', 'Ḻ'),
+    ('Ḽ', 'Ḽ'),
+    ('Ḿ', 'Ḿ'),
+    ('Ṁ', 'Ṁ'),
+    ('Ṃ', 'Ṃ'),
+    ('Ṅ', 'Ṅ'),
+    ('Ṇ', 'Ṇ'),
+    ('Ṉ', 'Ṉ'),
+    ('Ṋ', 'Ṋ'),
+    ('Ṍ', 'Ṍ'),
+    ('Ṏ', 'Ṏ'),
+    ('Ṑ', 'Ṑ'),
+    ('Ṓ', 'Ṓ'),
+    ('Ṕ', 'Ṕ'),
+    ('Ṗ', 'Ṗ'),
+    ('Ṙ', 'Ṙ'),
+    ('Ṛ', 'Ṛ'),
+    ('Ṝ', 'Ṝ'),
+    ('Ṟ', 'Ṟ'),
+    ('Ṡ', 'Ṡ'),
+    ('Ṣ', 'Ṣ'),
+    ('Ṥ', 'Ṥ'),
+    ('Ṧ', 'Ṧ'),
+    ('Ṩ', 'Ṩ'),
+    ('Ṫ', 'Ṫ'),
+    ('Ṭ', 'Ṭ'),
+    ('Ṯ', 'Ṯ'),
+    ('Ṱ', 'Ṱ'),
+    ('Ṳ', 'Ṳ'),
+    ('Ṵ', 'Ṵ'),
+    ('Ṷ', 'Ṷ'),
+    ('Ṹ', 'Ṹ'),
+    ('Ṻ', 'Ṻ'),
+    ('Ṽ', 'Ṽ'),
+    ('Ṿ', 'Ṿ'),
+    ('Ẁ', 'Ẁ'),
+    ('Ẃ', 'Ẃ'),
+    ('Ẅ', 'Ẅ'),
+    ('Ẇ', 'Ẇ'),
+    ('Ẉ', 'Ẉ'),
+    ('Ẋ', 'Ẋ'),
+    ('Ẍ', 'Ẍ'),
+    ('Ẏ', 'Ẏ'),
+    ('Ẑ', 'Ẑ'),
+    ('Ẓ', 'Ẓ'),
+    ('Ẕ', 'Ẕ'),
+    ('ẞ', 'ẞ'),
+    ('Ạ', 'Ạ'),
+    ('Ả', 'Ả'),
+    ('Ấ', 'Ấ'),
+    ('Ầ', 'Ầ'),
+    ('Ẩ', 'Ẩ'),
+    ('Ẫ', 'Ẫ'),
+    ('Ậ', 'Ậ'),
+    ('Ắ', 'Ắ'),
+    ('Ằ', 'Ằ'),
+    ('Ẳ', 'Ẳ'),
+    ('Ẵ', 'Ẵ'),
+    ('Ặ', 'Ặ'),
+    ('Ẹ', 'Ẹ'),
+    ('Ẻ', 'Ẻ'),
+    ('Ẽ', 'Ẽ'),
+    ('Ế', 'Ế'),
+    ('Ề', 'Ề'),
+    ('Ể', 'Ể'),
+    ('Ễ', 'Ễ'),
+    ('Ệ', 'Ệ'),
+    ('Ỉ', 'Ỉ'),
+    ('Ị', 'Ị'),
+    ('Ọ', 'Ọ'),
+    ('Ỏ', 'Ỏ'),
+    ('Ố', 'Ố'),
+    ('Ồ', 'Ồ'),
+    ('Ổ', 'Ổ'),
+    ('Ỗ', 'Ỗ'),
+    ('Ộ', 'Ộ'),
+    ('Ớ', 'Ớ'),
+    ('Ờ', 'Ờ'),
+    ('Ở', 'Ở'),
+    ('Ỡ', 'Ỡ'),
+    ('Ợ', 'Ợ'),
+    ('Ụ', 'Ụ'),
+    ('Ủ', 'Ủ'),
+    ('Ứ', 'Ứ'),
+    ('Ừ', 'Ừ'),
+    ('Ử', 'Ử'),
+    ('Ữ', 'Ữ'),
+    ('Ự', 'Ự'),
+    ('Ỳ', 'Ỳ'),
+    ('Ỵ', 'Ỵ'),
+    ('Ỷ', 'Ỷ'),
+    ('Ỹ', 'Ỹ'),
+    ('Ỻ', 'Ỻ'),
+    ('Ỽ', 'Ỽ'),
+    ('Ỿ', 'Ỿ'),
+    ('Ἀ', 'Ἇ'),
+    ('Ἐ', 'Ἕ'),
+    ('Ἠ', 'Ἧ'),
+    ('Ἰ', 'Ἷ'),
+    ('Ὀ', 'Ὅ'),
+    ('Ὑ', 'Ὑ'),
+    ('Ὓ', 'Ὓ'),
+    ('Ὕ', 'Ὕ'),
+    ('Ὗ', 'Ὗ'),
+    ('Ὠ', 'Ὧ'),
+    ('Ᾰ', 'Ά'),
+    ('Ὲ', 'Ή'),
+    ('Ῐ', 'Ί'),
+    ('Ῠ', 'Ῥ'),
+    ('Ὸ', 'Ώ'),
+    ('ℂ', 'ℂ'),
+    ('ℇ', 'ℇ'),
+    ('ℋ', 'ℍ'),
+    ('ℐ', 'ℒ'),
+    ('ℕ', 'ℕ'),
+    ('ℙ', 'ℝ'),
+    ('ℤ', 'ℤ'),
+    ('Ω', 'Ω'),
+    ('ℨ', 'ℨ'),
+    ('K', 'ℭ'),
+    ('ℰ', 'ℳ'),
+    ('ℾ', 'ℿ'),
+    ('ⅅ', 'ⅅ'),
+    ('Ⅰ', 'Ⅿ'),
+    ('Ↄ', 'Ↄ'),
+    ('Ⓐ', 'Ⓩ'),
+    ('Ⰰ', 'Ⱟ'),
+    ('Ⱡ', 'Ⱡ'),
+    ('Ɫ', 'Ɽ'),
+    ('Ⱨ', 'Ⱨ'),
+    ('Ⱪ', 'Ⱪ'),
+    ('Ⱬ', 'Ⱬ'),
+    ('Ɑ', 'Ɒ'),
+    ('Ⱳ', 'Ⱳ'),
+    ('Ⱶ', 'Ⱶ'),
+    ('Ȿ', 'Ⲁ'),
+    ('Ⲃ', 'Ⲃ'),
+    ('Ⲅ', 'Ⲅ'),
+    ('Ⲇ', 'Ⲇ'),
+    ('Ⲉ', 'Ⲉ'),
+    ('Ⲋ', 'Ⲋ'),
+    ('Ⲍ', 'Ⲍ'),
+    ('Ⲏ', 'Ⲏ'),
+    ('Ⲑ', 'Ⲑ'),
+    ('Ⲓ', 'Ⲓ'),
+    ('Ⲕ', 'Ⲕ'),
+    ('Ⲗ', 'Ⲗ'),
+    ('Ⲙ', 'Ⲙ'),
+    ('Ⲛ', 'Ⲛ'),
+    ('Ⲝ', 'Ⲝ'),
+    ('Ⲟ', 'Ⲟ'),
+    ('Ⲡ', 'Ⲡ'),
+    ('Ⲣ', 'Ⲣ'),
+    ('Ⲥ', 'Ⲥ'),
+    ('Ⲧ', 'Ⲧ'),
+    ('Ⲩ', 'Ⲩ'),
+    ('Ⲫ', 'Ⲫ'),
+    ('Ⲭ', 'Ⲭ'),
+    ('Ⲯ', 'Ⲯ'),
+    ('Ⲱ', 'Ⲱ'),
+    ('Ⲳ', 'Ⲳ'),
+    ('Ⲵ', 'Ⲵ'),
+    ('Ⲷ', 'Ⲷ'),
+    ('Ⲹ', 'Ⲹ'),
+    ('Ⲻ', 'Ⲻ'),
+    ('Ⲽ', 'Ⲽ'),
+    ('Ⲿ', 'Ⲿ'),
+    ('Ⳁ', 'Ⳁ'),
+    ('Ⳃ', 'Ⳃ'),
+    ('Ⳅ', 'Ⳅ'),
+    ('Ⳇ', 'Ⳇ'),
+    ('Ⳉ', 'Ⳉ'),
+    ('Ⳋ', 'Ⳋ'),
+    ('Ⳍ', 'Ⳍ'),
+    ('Ⳏ', 'Ⳏ'),
+    ('Ⳑ', 'Ⳑ'),
+    ('Ⳓ', 'Ⳓ'),
+    ('Ⳕ', 'Ⳕ'),
+    ('Ⳗ', 'Ⳗ'),
+    ('Ⳙ', 'Ⳙ'),
+    ('Ⳛ', 'Ⳛ'),
+    ('Ⳝ', 'Ⳝ'),
+    ('Ⳟ', 'Ⳟ'),
+    ('Ⳡ', 'Ⳡ'),
+    ('Ⳣ', 'Ⳣ'),
+    ('Ⳬ', 'Ⳬ'),
+    ('Ⳮ', 'Ⳮ'),
+    ('Ⳳ', 'Ⳳ'),
+    ('Ꙁ', 'Ꙁ'),
+    ('Ꙃ', 'Ꙃ'),
+    ('Ꙅ', 'Ꙅ'),
+    ('Ꙇ', 'Ꙇ'),
+    ('Ꙉ', 'Ꙉ'),
+    ('Ꙋ', 'Ꙋ'),
+    ('Ꙍ', 'Ꙍ'),
+    ('Ꙏ', 'Ꙏ'),
+    ('Ꙑ', 'Ꙑ'),
+    ('Ꙓ', 'Ꙓ'),
+    ('Ꙕ', 'Ꙕ'),
+    ('Ꙗ', 'Ꙗ'),
+    ('Ꙙ', 'Ꙙ'),
+    ('Ꙛ', 'Ꙛ'),
+    ('Ꙝ', 'Ꙝ'),
+    ('Ꙟ', 'Ꙟ'),
+    ('Ꙡ', 'Ꙡ'),
+    ('Ꙣ', 'Ꙣ'),
+    ('Ꙥ', 'Ꙥ'),
+    ('Ꙧ', 'Ꙧ'),
+    ('Ꙩ', 'Ꙩ'),
+    ('Ꙫ', 'Ꙫ'),
+    ('Ꙭ', 'Ꙭ'),
+    ('Ꚁ', 'Ꚁ'),
+    ('Ꚃ', 'Ꚃ'),
+    ('Ꚅ', 'Ꚅ'),
+    ('Ꚇ', 'Ꚇ'),
+    ('Ꚉ', 'Ꚉ'),
+    ('Ꚋ', 'Ꚋ'),
+    ('Ꚍ', 'Ꚍ'),
+    ('Ꚏ', 'Ꚏ'),
+    ('Ꚑ', 'Ꚑ'),
+    ('Ꚓ', 'Ꚓ'),
+    ('Ꚕ', 'Ꚕ'),
+    ('Ꚗ', 'Ꚗ'),
+    ('Ꚙ', 'Ꚙ'),
+    ('Ꚛ', 'Ꚛ'),
+    ('Ꜣ', 'Ꜣ'),
+    ('Ꜥ', 'Ꜥ'),
+    ('Ꜧ', 'Ꜧ'),
+    ('Ꜩ', 'Ꜩ'),
+    ('Ꜫ', 'Ꜫ'),
+    ('Ꜭ', 'Ꜭ'),
+    ('Ꜯ', 'Ꜯ'),
+    ('Ꜳ', 'Ꜳ'),
+    ('Ꜵ', 'Ꜵ'),
+    ('Ꜷ', 'Ꜷ'),
+    ('Ꜹ', 'Ꜹ'),
+    ('Ꜻ', 'Ꜻ'),
+    ('Ꜽ', 'Ꜽ'),
+    ('Ꜿ', 'Ꜿ'),
+    ('Ꝁ', 'Ꝁ'),
+    ('Ꝃ', 'Ꝃ'),
+    ('Ꝅ', 'Ꝅ'),
+    ('Ꝇ', 'Ꝇ'),
+    ('Ꝉ', 'Ꝉ'),
+    ('Ꝋ', 'Ꝋ'),
+    ('Ꝍ', 'Ꝍ'),
+    ('Ꝏ', 'Ꝏ'),
+    ('Ꝑ', 'Ꝑ'),
+    ('Ꝓ', 'Ꝓ'),
+    ('Ꝕ', 'Ꝕ'),
+    ('Ꝗ', 'Ꝗ'),
+    ('Ꝙ', 'Ꝙ'),
+    ('Ꝛ', 'Ꝛ'),
+    ('Ꝝ', 'Ꝝ'),
+    ('Ꝟ', 'Ꝟ'),
+    ('Ꝡ', 'Ꝡ'),
+    ('Ꝣ', 'Ꝣ'),
+    ('Ꝥ', 'Ꝥ'),
+    ('Ꝧ', 'Ꝧ'),
+    ('Ꝩ', 'Ꝩ'),
+    ('Ꝫ', 'Ꝫ'),
+    ('Ꝭ', 'Ꝭ'),
+    ('Ꝯ', 'Ꝯ'),
+    ('Ꝺ', 'Ꝺ'),
+    ('Ꝼ', 'Ꝼ'),
+    ('Ᵹ', 'Ꝿ'),
+    ('Ꞁ', 'Ꞁ'),
+    ('Ꞃ', 'Ꞃ'),
+    ('Ꞅ', 'Ꞅ'),
+    ('Ꞇ', 'Ꞇ'),
+    ('Ꞌ', 'Ꞌ'),
+    ('Ɥ', 'Ɥ'),
+    ('Ꞑ', 'Ꞑ'),
+    ('Ꞓ', 'Ꞓ'),
+    ('Ꞗ', 'Ꞗ'),
+    ('Ꞙ', 'Ꞙ'),
+    ('Ꞛ', 'Ꞛ'),
+    ('Ꞝ', 'Ꞝ'),
+    ('Ꞟ', 'Ꞟ'),
+    ('Ꞡ', 'Ꞡ'),
+    ('Ꞣ', 'Ꞣ'),
+    ('Ꞥ', 'Ꞥ'),
+    ('Ꞧ', 'Ꞧ'),
+    ('Ꞩ', 'Ꞩ'),
+    ('Ɦ', 'Ɪ'),
+    ('Ʞ', 'Ꞵ'),
+    ('Ꞷ', 'Ꞷ'),
+    ('Ꞹ', 'Ꞹ'),
+    ('Ꞻ', 'Ꞻ'),
+    ('Ꞽ', 'Ꞽ'),
+    ('Ꞿ', 'Ꞿ'),
+    ('Ꟁ', 'Ꟁ'),
+    ('Ꟃ', 'Ꟃ'),
+    ('Ꞔ', 'Ꟈ'),
+    ('Ꟊ', 'Ꟊ'),
+    ('Ꟑ', 'Ꟑ'),
+    ('Ꟗ', 'Ꟗ'),
+    ('Ꟙ', 'Ꟙ'),
+    ('Ꟶ', 'Ꟶ'),
+    ('Ａ', 'Ｚ'),
+    ('𐐀', '𐐧'),
+    ('𐒰', '𐓓'),
+    ('𐕰', '𐕺'),
+    ('𐕼', '𐖊'),
+    ('𐖌', '𐖒'),
+    ('𐖔', '𐖕'),
+    ('𐲀', '𐲲'),
+    ('𑢠', '𑢿'),
+    ('𖹀', '𖹟'),
+    ('𝐀', '𝐙'),
+    ('𝐴', '𝑍'),
+    ('𝑨', '𝒁'),
+    ('𝒜', '𝒜'),
+    ('𝒞', '𝒟'),
+    ('𝒢', '𝒢'),
+    ('𝒥', '𝒦'),
+    ('𝒩', '𝒬'),
+    ('𝒮', '𝒵'),
+    ('𝓐', '𝓩'),
+    ('𝔄', '𝔅'),
+    ('𝔇', '𝔊'),
+    ('𝔍', '𝔔'),
+    ('𝔖', '𝔜'),
+    ('𝔸', '𝔹'),
+    ('𝔻', '𝔾'),
+    ('𝕀', '𝕄'),
+    ('𝕆', '𝕆'),
+    ('𝕊', '𝕐'),
+    ('𝕬', '𝖅'),
+    ('𝖠', '𝖹'),
+    ('𝗔', '𝗭'),
+    ('𝘈', '𝘡'),
+    ('𝘼', '𝙕'),
+    ('𝙰', '𝚉'),
+    ('𝚨', '𝛀'),
+    ('𝛢', '𝛺'),
+    ('𝜜', '𝜴'),
+    ('𝝖', '𝝮'),
+    ('𝞐', '𝞨'),
+    ('𝟊', '𝟊'),
+    ('𞤀', '𞤡'),
+    ('🄰', '🅉'),
+    ('🅐', '🅩'),
+    ('🅰', '🆉'),
+];
+
+pub const VARIATION_SELECTOR: &'static [(char, char)] = &[
+    ('\u{180b}', '\u{180d}'),
+    ('\u{180f}', '\u{180f}'),
+    ('\u{fe00}', '\u{fe0f}'),
+    ('\u{e0100}', '\u{e01ef}'),
+];
+
+pub const WHITE_SPACE: &'static [(char, char)] = &[
+    ('\t', '\r'),
+    (' ', ' '),
+    ('\u{85}', '\u{85}'),
+    ('\u{a0}', '\u{a0}'),
+    ('\u{1680}', '\u{1680}'),
+    ('\u{2000}', '\u{200a}'),
+    ('\u{2028}', '\u{2029}'),
+    ('\u{202f}', '\u{202f}'),
+    ('\u{205f}', '\u{205f}'),
+    ('\u{3000}', '\u{3000}'),
+];
+
+pub const XID_CONTINUE: &'static [(char, char)] = &[
+    ('0', '9'),
+    ('A', 'Z'),
+    ('_', '_'),
+    ('a', 'z'),
+    ('ª', 'ª'),
+    ('µ', 'µ'),
+    ('·', '·'),
+    ('º', 'º'),
+    ('À', 'Ö'),
+    ('Ø', 'ö'),
+    ('ø', 'ˁ'),
+    ('ˆ', 'ˑ'),
+    ('ˠ', 'ˤ'),
+    ('ˬ', 'ˬ'),
+    ('ˮ', 'ˮ'),
+    ('\u{300}', 'ʹ'),
+    ('Ͷ', 'ͷ'),
+    ('ͻ', 'ͽ'),
+    ('Ϳ', 'Ϳ'),
+    ('Ά', 'Ί'),
+    ('Ό', 'Ό'),
+    ('Ύ', 'Ρ'),
+    ('Σ', 'ϵ'),
+    ('Ϸ', 'ҁ'),
+    ('\u{483}', '\u{487}'),
+    ('Ҋ', 'ԯ'),
+    ('Ա', 'Ֆ'),
+    ('ՙ', 'ՙ'),
+    ('ՠ', 'ֈ'),
+    ('\u{591}', '\u{5bd}'),
+    ('\u{5bf}', '\u{5bf}'),
+    ('\u{5c1}', '\u{5c2}'),
+    ('\u{5c4}', '\u{5c5}'),
+    ('\u{5c7}', '\u{5c7}'),
+    ('א', 'ת'),
+    ('ׯ', 'ײ'),
+    ('\u{610}', '\u{61a}'),
+    ('ؠ', '٩'),
+    ('ٮ', 'ۓ'),
+    ('ە', '\u{6dc}'),
+    ('\u{6df}', '\u{6e8}'),
+    ('\u{6ea}', 'ۼ'),
+    ('ۿ', 'ۿ'),
+    ('ܐ', '\u{74a}'),
+    ('ݍ', 'ޱ'),
+    ('߀', 'ߵ'),
+    ('ߺ', 'ߺ'),
+    ('\u{7fd}', '\u{7fd}'),
+    ('ࠀ', '\u{82d}'),
+    ('ࡀ', '\u{85b}'),
+    ('ࡠ', 'ࡪ'),
+    ('ࡰ', 'ࢇ'),
+    ('ࢉ', 'ࢎ'),
+    ('\u{898}', '\u{8e1}'),
+    ('\u{8e3}', '\u{963}'),
+    ('०', '९'),
+    ('ॱ', 'ঃ'),
+    ('অ', 'ঌ'),
+    ('এ', 'ঐ'),
+    ('ও', 'ন'),
+    ('প', 'র'),
+    ('ল', 'ল'),
+    ('শ', 'হ'),
+    ('\u{9bc}', '\u{9c4}'),
+    ('ে', 'ৈ'),
+    ('ো', 'ৎ'),
+    ('\u{9d7}', '\u{9d7}'),
+    ('ড়', 'ঢ়'),
+    ('য়', '\u{9e3}'),
+    ('০', 'ৱ'),
+    ('ৼ', 'ৼ'),
+    ('\u{9fe}', '\u{9fe}'),
+    ('\u{a01}', 'ਃ'),
+    ('ਅ', 'ਊ'),
+    ('ਏ', 'ਐ'),
+    ('ਓ', 'ਨ'),
+    ('ਪ', 'ਰ'),
+    ('ਲ', 'ਲ਼'),
+    ('ਵ', 'ਸ਼'),
+    ('ਸ', 'ਹ'),
+    ('\u{a3c}', '\u{a3c}'),
+    ('ਾ', '\u{a42}'),
+    ('\u{a47}', '\u{a48}'),
+    ('\u{a4b}', '\u{a4d}'),
+    ('\u{a51}', '\u{a51}'),
+    ('ਖ਼', 'ੜ'),
+    ('ਫ਼', 'ਫ਼'),
+    ('੦', '\u{a75}'),
+    ('\u{a81}', 'ઃ'),
+    ('અ', 'ઍ'),
+    ('એ', 'ઑ'),
+    ('ઓ', 'ન'),
+    ('પ', 'ર'),
+    ('લ', 'ળ'),
+    ('વ', 'હ'),
+    ('\u{abc}', '\u{ac5}'),
+    ('\u{ac7}', 'ૉ'),
+    ('ો', '\u{acd}'),
+    ('ૐ', 'ૐ'),
+    ('ૠ', '\u{ae3}'),
+    ('૦', '૯'),
+    ('ૹ', '\u{aff}'),
+    ('\u{b01}', 'ଃ'),
+    ('ଅ', 'ଌ'),
+    ('ଏ', 'ଐ'),
+    ('ଓ', 'ନ'),
+    ('ପ', 'ର'),
+    ('ଲ', 'ଳ'),
+    ('ଵ', 'ହ'),
+    ('\u{b3c}', '\u{b44}'),
+    ('େ', 'ୈ'),
+    ('ୋ', '\u{b4d}'),
+    ('\u{b55}', '\u{b57}'),
+    ('ଡ଼', 'ଢ଼'),
+    ('ୟ', '\u{b63}'),
+    ('୦', '୯'),
+    ('ୱ', 'ୱ'),
+    ('\u{b82}', 'ஃ'),
+    ('அ', 'ஊ'),
+    ('எ', 'ஐ'),
+    ('ஒ', 'க'),
+    ('ங', 'ச'),
+    ('ஜ', 'ஜ'),
+    ('ஞ', 'ட'),
+    ('ண', 'த'),
+    ('ந', 'ப'),
+    ('ம', 'ஹ'),
+    ('\u{bbe}', 'ூ'),
+    ('ெ', 'ை'),
+    ('ொ', '\u{bcd}'),
+    ('ௐ', 'ௐ'),
+    ('\u{bd7}', '\u{bd7}'),
+    ('௦', '௯'),
+    ('\u{c00}', 'ఌ'),
+    ('ఎ', 'ఐ'),
+    ('ఒ', 'న'),
+    ('ప', 'హ'),
+    ('\u{c3c}', 'ౄ'),
+    ('\u{c46}', '\u{c48}'),
+    ('\u{c4a}', '\u{c4d}'),
+    ('\u{c55}', '\u{c56}'),
+    ('ౘ', 'ౚ'),
+    ('ౝ', 'ౝ'),
+    ('ౠ', '\u{c63}'),
+    ('౦', '౯'),
+    ('ಀ', 'ಃ'),
+    ('ಅ', 'ಌ'),
+    ('ಎ', 'ಐ'),
+    ('ಒ', 'ನ'),
+    ('ಪ', 'ಳ'),
+    ('ವ', 'ಹ'),
+    ('\u{cbc}', 'ೄ'),
+    ('\u{cc6}', 'ೈ'),
+    ('ೊ', '\u{ccd}'),
+    ('\u{cd5}', '\u{cd6}'),
+    ('ೝ', 'ೞ'),
+    ('ೠ', '\u{ce3}'),
+    ('೦', '೯'),
+    ('ೱ', 'ೳ'),
+    ('\u{d00}', 'ഌ'),
+    ('എ', 'ഐ'),
+    ('ഒ', '\u{d44}'),
+    ('െ', 'ൈ'),
+    ('ൊ', 'ൎ'),
+    ('ൔ', '\u{d57}'),
+    ('ൟ', '\u{d63}'),
+    ('൦', '൯'),
+    ('ൺ', 'ൿ'),
+    ('\u{d81}', 'ඃ'),
+    ('අ', 'ඖ'),
+    ('ක', 'න'),
+    ('ඳ', 'ර'),
+    ('ල', 'ල'),
+    ('ව', 'ෆ'),
+    ('\u{dca}', '\u{dca}'),
+    ('\u{dcf}', '\u{dd4}'),
+    ('\u{dd6}', '\u{dd6}'),
+    ('ෘ', '\u{ddf}'),
+    ('෦', '෯'),
+    ('ෲ', 'ෳ'),
+    ('ก', '\u{e3a}'),
+    ('เ', '\u{e4e}'),
+    ('๐', '๙'),
+    ('ກ', 'ຂ'),
+    ('ຄ', 'ຄ'),
+    ('ຆ', 'ຊ'),
+    ('ຌ', 'ຣ'),
+    ('ລ', 'ລ'),
+    ('ວ', 'ຽ'),
+    ('ເ', 'ໄ'),
+    ('ໆ', 'ໆ'),
+    ('\u{ec8}', '\u{ece}'),
+    ('໐', '໙'),
+    ('ໜ', 'ໟ'),
+    ('ༀ', 'ༀ'),
+    ('\u{f18}', '\u{f19}'),
+    ('༠', '༩'),
+    ('\u{f35}', '\u{f35}'),
+    ('\u{f37}', '\u{f37}'),
+    ('\u{f39}', '\u{f39}'),
+    ('༾', 'ཇ'),
+    ('ཉ', 'ཬ'),
+    ('\u{f71}', '\u{f84}'),
+    ('\u{f86}', '\u{f97}'),
+    ('\u{f99}', '\u{fbc}'),
+    ('\u{fc6}', '\u{fc6}'),
+    ('က', '၉'),
+    ('ၐ', '\u{109d}'),
+    ('Ⴀ', 'Ⴥ'),
+    ('Ⴧ', 'Ⴧ'),
+    ('Ⴭ', 'Ⴭ'),
+    ('ა', 'ჺ'),
+    ('ჼ', 'ቈ'),
+    ('ቊ', 'ቍ'),
+    ('ቐ', 'ቖ'),
+    ('ቘ', 'ቘ'),
+    ('ቚ', 'ቝ'),
+    ('በ', 'ኈ'),
+    ('ኊ', 'ኍ'),
+    ('ነ', 'ኰ'),
+    ('ኲ', 'ኵ'),
+    ('ኸ', 'ኾ'),
+    ('ዀ', 'ዀ'),
+    ('ዂ', 'ዅ'),
+    ('ወ', 'ዖ'),
+    ('ዘ', 'ጐ'),
+    ('ጒ', 'ጕ'),
+    ('ጘ', 'ፚ'),
+    ('\u{135d}', '\u{135f}'),
+    ('፩', '፱'),
+    ('ᎀ', 'ᎏ'),
+    ('Ꭰ', 'Ᏽ'),
+    ('ᏸ', 'ᏽ'),
+    ('ᐁ', 'ᙬ'),
+    ('ᙯ', 'ᙿ'),
+    ('ᚁ', 'ᚚ'),
+    ('ᚠ', 'ᛪ'),
+    ('ᛮ', 'ᛸ'),
+    ('ᜀ', '᜕'),
+    ('ᜟ', '᜴'),
+    ('ᝀ', '\u{1753}'),
+    ('ᝠ', 'ᝬ'),
+    ('ᝮ', 'ᝰ'),
+    ('\u{1772}', '\u{1773}'),
+    ('ក', '\u{17d3}'),
+    ('ៗ', 'ៗ'),
+    ('ៜ', '\u{17dd}'),
+    ('០', '៩'),
+    ('\u{180b}', '\u{180d}'),
+    ('\u{180f}', '᠙'),
+    ('ᠠ', 'ᡸ'),
+    ('ᢀ', 'ᢪ'),
+    ('ᢰ', 'ᣵ'),
+    ('ᤀ', 'ᤞ'),
+    ('\u{1920}', 'ᤫ'),
+    ('ᤰ', '\u{193b}'),
+    ('᥆', 'ᥭ'),
+    ('ᥰ', 'ᥴ'),
+    ('ᦀ', 'ᦫ'),
+    ('ᦰ', 'ᧉ'),
+    ('᧐', '᧚'),
+    ('ᨀ', '\u{1a1b}'),
+    ('ᨠ', '\u{1a5e}'),
+    ('\u{1a60}', '\u{1a7c}'),
+    ('\u{1a7f}', '᪉'),
+    ('᪐', '᪙'),
+    ('ᪧ', 'ᪧ'),
+    ('\u{1ab0}', '\u{1abd}'),
+    ('\u{1abf}', '\u{1ace}'),
+    ('\u{1b00}', 'ᭌ'),
+    ('᭐', '᭙'),
+    ('\u{1b6b}', '\u{1b73}'),
+    ('\u{1b80}', '᯳'),
+    ('ᰀ', '\u{1c37}'),
+    ('᱀', '᱉'),
+    ('ᱍ', 'ᱽ'),
+    ('ᲀ', 'ᲈ'),
+    ('Ა', 'Ჺ'),
+    ('Ჽ', 'Ჿ'),
+    ('\u{1cd0}', '\u{1cd2}'),
+    ('\u{1cd4}', 'ᳺ'),
+    ('ᴀ', 'ἕ'),
+    ('Ἐ', 'Ἕ'),
+    ('ἠ', 'ὅ'),
+    ('Ὀ', 'Ὅ'),
+    ('ὐ', 'ὗ'),
+    ('Ὑ', 'Ὑ'),
+    ('Ὓ', 'Ὓ'),
+    ('Ὕ', 'Ὕ'),
+    ('Ὗ', 'ώ'),
+    ('ᾀ', 'ᾴ'),
+    ('ᾶ', 'ᾼ'),
+    ('ι', 'ι'),
+    ('ῂ', 'ῄ'),
+    ('ῆ', 'ῌ'),
+    ('ῐ', 'ΐ'),
+    ('ῖ', 'Ί'),
+    ('ῠ', 'Ῥ'),
+    ('ῲ', 'ῴ'),
+    ('ῶ', 'ῼ'),
+    ('‿', '⁀'),
+    ('⁔', '⁔'),
+    ('ⁱ', 'ⁱ'),
+    ('ⁿ', 'ⁿ'),
+    ('ₐ', 'ₜ'),
+    ('\u{20d0}', '\u{20dc}'),
+    ('\u{20e1}', '\u{20e1}'),
+    ('\u{20e5}', '\u{20f0}'),
+    ('ℂ', 'ℂ'),
+    ('ℇ', 'ℇ'),
+    ('ℊ', 'ℓ'),
+    ('ℕ', 'ℕ'),
+    ('℘', 'ℝ'),
+    ('ℤ', 'ℤ'),
+    ('Ω', 'Ω'),
+    ('ℨ', 'ℨ'),
+    ('K', 'ℹ'),
+    ('ℼ', 'ℿ'),
+    ('ⅅ', 'ⅉ'),
+    ('ⅎ', 'ⅎ'),
+    ('Ⅰ', 'ↈ'),
+    ('Ⰰ', 'ⳤ'),
+    ('Ⳬ', 'ⳳ'),
+    ('ⴀ', 'ⴥ'),
+    ('ⴧ', 'ⴧ'),
+    ('ⴭ', 'ⴭ'),
+    ('ⴰ', 'ⵧ'),
+    ('ⵯ', 'ⵯ'),
+    ('\u{2d7f}', 'ⶖ'),
+    ('ⶠ', 'ⶦ'),
+    ('ⶨ', 'ⶮ'),
+    ('ⶰ', 'ⶶ'),
+    ('ⶸ', 'ⶾ'),
+    ('ⷀ', 'ⷆ'),
+    ('ⷈ', 'ⷎ'),
+    ('ⷐ', 'ⷖ'),
+    ('ⷘ', 'ⷞ'),
+    ('\u{2de0}', '\u{2dff}'),
+    ('々', '〇'),
+    ('〡', '\u{302f}'),
+    ('〱', '〵'),
+    ('〸', '〼'),
+    ('ぁ', 'ゖ'),
+    ('\u{3099}', '\u{309a}'),
+    ('ゝ', 'ゟ'),
+    ('ァ', 'ヺ'),
+    ('ー', 'ヿ'),
+    ('ㄅ', 'ㄯ'),
+    ('ㄱ', 'ㆎ'),
+    ('ㆠ', 'ㆿ'),
+    ('ㇰ', 'ㇿ'),
+    ('㐀', '䶿'),
+    ('一', 'ꒌ'),
+    ('ꓐ', 'ꓽ'),
+    ('ꔀ', 'ꘌ'),
+    ('ꘐ', 'ꘫ'),
+    ('Ꙁ', '\u{a66f}'),
+    ('\u{a674}', '\u{a67d}'),
+    ('ꙿ', '\u{a6f1}'),
+    ('ꜗ', 'ꜟ'),
+    ('Ꜣ', 'ꞈ'),
+    ('Ꞌ', 'ꟊ'),
+    ('Ꟑ', 'ꟑ'),
+    ('ꟓ', 'ꟓ'),
+    ('ꟕ', 'ꟙ'),
+    ('ꟲ', 'ꠧ'),
+    ('\u{a82c}', '\u{a82c}'),
+    ('ꡀ', 'ꡳ'),
+    ('ꢀ', '\u{a8c5}'),
+    ('꣐', '꣙'),
+    ('\u{a8e0}', 'ꣷ'),
+    ('ꣻ', 'ꣻ'),
+    ('ꣽ', '\u{a92d}'),
+    ('ꤰ', '꥓'),
+    ('ꥠ', 'ꥼ'),
+    ('\u{a980}', '꧀'),
+    ('ꧏ', '꧙'),
+    ('ꧠ', 'ꧾ'),
+    ('ꨀ', '\u{aa36}'),
+    ('ꩀ', 'ꩍ'),
+    ('꩐', '꩙'),
+    ('ꩠ', 'ꩶ'),
+    ('ꩺ', 'ꫂ'),
+    ('ꫛ', 'ꫝ'),
+    ('ꫠ', 'ꫯ'),
+    ('ꫲ', '\u{aaf6}'),
+    ('ꬁ', 'ꬆ'),
+    ('ꬉ', 'ꬎ'),
+    ('ꬑ', 'ꬖ'),
+    ('ꬠ', 'ꬦ'),
+    ('ꬨ', 'ꬮ'),
+    ('ꬰ', 'ꭚ'),
+    ('ꭜ', 'ꭩ'),
+    ('ꭰ', 'ꯪ'),
+    ('꯬', '\u{abed}'),
+    ('꯰', '꯹'),
+    ('가', '힣'),
+    ('ힰ', 'ퟆ'),
+    ('ퟋ', 'ퟻ'),
+    ('豈', '舘'),
+    ('並', '龎'),
+    ('ﬀ', 'ﬆ'),
+    ('ﬓ', 'ﬗ'),
+    ('יִ', 'ﬨ'),
+    ('שׁ', 'זּ'),
+    ('טּ', 'לּ'),
+    ('מּ', 'מּ'),
+    ('נּ', 'סּ'),
+    ('ףּ', 'פּ'),
+    ('צּ', 'ﮱ'),
+    ('ﯓ', 'ﱝ'),
+    ('ﱤ', 'ﴽ'),
+    ('ﵐ', 'ﶏ'),
+    ('ﶒ', 'ﷇ'),
+    ('ﷰ', 'ﷹ'),
+    ('\u{fe00}', '\u{fe0f}'),
+    ('\u{fe20}', '\u{fe2f}'),
+    ('︳', '︴'),
+    ('﹍', '﹏'),
+    ('ﹱ', 'ﹱ'),
+    ('ﹳ', 'ﹳ'),
+    ('ﹷ', 'ﹷ'),
+    ('ﹹ', 'ﹹ'),
+    ('ﹻ', 'ﹻ'),
+    ('ﹽ', 'ﹽ'),
+    ('ﹿ', 'ﻼ'),
+    ('０', '９'),
+    ('Ａ', 'Ｚ'),
+    ('＿', '＿'),
+    ('ａ', 'ｚ'),
+    ('ｦ', 'ﾾ'),
+    ('ￂ', 'ￇ'),
+    ('ￊ', 'ￏ'),
+    ('ￒ', 'ￗ'),
+    ('ￚ', 'ￜ'),
+    ('𐀀', '𐀋'),
+    ('𐀍', '𐀦'),
+    ('𐀨', '𐀺'),
+    ('𐀼', '𐀽'),
+    ('𐀿', '𐁍'),
+    ('𐁐', '𐁝'),
+    ('𐂀', '𐃺'),
+    ('𐅀', '𐅴'),
+    ('\u{101fd}', '\u{101fd}'),
+    ('𐊀', '𐊜'),
+    ('𐊠', '𐋐'),
+    ('\u{102e0}', '\u{102e0}'),
+    ('𐌀', '𐌟'),
+    ('𐌭', '𐍊'),
+    ('𐍐', '\u{1037a}'),
+    ('𐎀', '𐎝'),
+    ('𐎠', '𐏃'),
+    ('𐏈', '𐏏'),
+    ('𐏑', '𐏕'),
+    ('𐐀', '𐒝'),
+    ('𐒠', '𐒩'),
+    ('𐒰', '𐓓'),
+    ('𐓘', '𐓻'),
+    ('𐔀', '𐔧'),
+    ('𐔰', '𐕣'),
+    ('𐕰', '𐕺'),
+    ('𐕼', '𐖊'),
+    ('𐖌', '𐖒'),
+    ('𐖔', '𐖕'),
+    ('𐖗', '𐖡'),
+    ('𐖣', '𐖱'),
+    ('𐖳', '𐖹'),
+    ('𐖻', '𐖼'),
+    ('𐘀', '𐜶'),
+    ('𐝀', '𐝕'),
+    ('𐝠', '𐝧'),
+    ('𐞀', '𐞅'),
+    ('𐞇', '𐞰'),
+    ('𐞲', '𐞺'),
+    ('𐠀', '𐠅'),
+    ('𐠈', '𐠈'),
+    ('𐠊', '𐠵'),
+    ('𐠷', '𐠸'),
+    ('𐠼', '𐠼'),
+    ('𐠿', '𐡕'),
+    ('𐡠', '𐡶'),
+    ('𐢀', '𐢞'),
+    ('𐣠', '𐣲'),
+    ('𐣴', '𐣵'),
+    ('𐤀', '𐤕'),
+    ('𐤠', '𐤹'),
+    ('𐦀', '𐦷'),
+    ('𐦾', '𐦿'),
+    ('𐨀', '\u{10a03}'),
+    ('\u{10a05}', '\u{10a06}'),
+    ('\u{10a0c}', '𐨓'),
+    ('𐨕', '𐨗'),
+    ('𐨙', '𐨵'),
+    ('\u{10a38}', '\u{10a3a}'),
+    ('\u{10a3f}', '\u{10a3f}'),
+    ('𐩠', '𐩼'),
+    ('𐪀', '𐪜'),
+    ('𐫀', '𐫇'),
+    ('𐫉', '\u{10ae6}'),
+    ('𐬀', '𐬵'),
+    ('𐭀', '𐭕'),
+    ('𐭠', '𐭲'),
+    ('𐮀', '𐮑'),
+    ('𐰀', '𐱈'),
+    ('𐲀', '𐲲'),
+    ('𐳀', '𐳲'),
+    ('𐴀', '\u{10d27}'),
+    ('𐴰', '𐴹'),
+    ('𐺀', '𐺩'),
+    ('\u{10eab}', '\u{10eac}'),
+    ('𐺰', '𐺱'),
+    ('\u{10efd}', '𐼜'),
+    ('𐼧', '𐼧'),
+    ('𐼰', '\u{10f50}'),
+    ('𐽰', '\u{10f85}'),
+    ('𐾰', '𐿄'),
+    ('𐿠', '𐿶'),
+    ('𑀀', '\u{11046}'),
+    ('𑁦', '𑁵'),
+    ('\u{1107f}', '\u{110ba}'),
+    ('\u{110c2}', '\u{110c2}'),
+    ('𑃐', '𑃨'),
+    ('𑃰', '𑃹'),
+    ('\u{11100}', '\u{11134}'),
+    ('𑄶', '𑄿'),
+    ('𑅄', '𑅇'),
+    ('𑅐', '\u{11173}'),
+    ('𑅶', '𑅶'),
+    ('\u{11180}', '𑇄'),
+    ('\u{111c9}', '\u{111cc}'),
+    ('𑇎', '𑇚'),
+    ('𑇜', '𑇜'),
+    ('𑈀', '𑈑'),
+    ('𑈓', '\u{11237}'),
+    ('\u{1123e}', '\u{11241}'),
+    ('𑊀', '𑊆'),
+    ('𑊈', '𑊈'),
+    ('𑊊', '𑊍'),
+    ('𑊏', '𑊝'),
+    ('𑊟', '𑊨'),
+    ('𑊰', '\u{112ea}'),
+    ('𑋰', '𑋹'),
+    ('\u{11300}', '𑌃'),
+    ('𑌅', '𑌌'),
+    ('𑌏', '𑌐'),
+    ('𑌓', '𑌨'),
+    ('𑌪', '𑌰'),
+    ('𑌲', '𑌳'),
+    ('𑌵', '𑌹'),
+    ('\u{1133b}', '𑍄'),
+    ('𑍇', '𑍈'),
+    ('𑍋', '𑍍'),
+    ('𑍐', '𑍐'),
+    ('\u{11357}', '\u{11357}'),
+    ('𑍝', '𑍣'),
+    ('\u{11366}', '\u{1136c}'),
+    ('\u{11370}', '\u{11374}'),
+    ('𑐀', '𑑊'),
+    ('𑑐', '𑑙'),
+    ('\u{1145e}', '𑑡'),
+    ('𑒀', '𑓅'),
+    ('𑓇', '𑓇'),
+    ('𑓐', '𑓙'),
+    ('𑖀', '\u{115b5}'),
+    ('𑖸', '\u{115c0}'),
+    ('𑗘', '\u{115dd}'),
+    ('𑘀', '\u{11640}'),
+    ('𑙄', '𑙄'),
+    ('𑙐', '𑙙'),
+    ('𑚀', '𑚸'),
+    ('𑛀', '𑛉'),
+    ('𑜀', '𑜚'),
+    ('\u{1171d}', '\u{1172b}'),
+    ('𑜰', '𑜹'),
+    ('𑝀', '𑝆'),
+    ('𑠀', '\u{1183a}'),
+    ('𑢠', '𑣩'),
+    ('𑣿', '𑤆'),
+    ('𑤉', '𑤉'),
+    ('𑤌', '𑤓'),
+    ('𑤕', '𑤖'),
+    ('𑤘', '𑤵'),
+    ('𑤷', '𑤸'),
+    ('\u{1193b}', '\u{11943}'),
+    ('𑥐', '𑥙'),
+    ('𑦠', '𑦧'),
+    ('𑦪', '\u{119d7}'),
+    ('\u{119da}', '𑧡'),
+    ('𑧣', '𑧤'),
+    ('𑨀', '\u{11a3e}'),
+    ('\u{11a47}', '\u{11a47}'),
+    ('𑩐', '\u{11a99}'),
+    ('𑪝', '𑪝'),
+    ('𑪰', '𑫸'),
+    ('𑰀', '𑰈'),
+    ('𑰊', '\u{11c36}'),
+    ('\u{11c38}', '𑱀'),
+    ('𑱐', '𑱙'),
+    ('𑱲', '𑲏'),
+    ('\u{11c92}', '\u{11ca7}'),
+    ('𑲩', '\u{11cb6}'),
+    ('𑴀', '𑴆'),
+    ('𑴈', '𑴉'),
+    ('𑴋', '\u{11d36}'),
+    ('\u{11d3a}', '\u{11d3a}'),
+    ('\u{11d3c}', '\u{11d3d}'),
+    ('\u{11d3f}', '\u{11d47}'),
+    ('𑵐', '𑵙'),
+    ('𑵠', '𑵥'),
+    ('𑵧', '𑵨'),
+    ('𑵪', '𑶎'),
+    ('\u{11d90}', '\u{11d91}'),
+    ('𑶓', '𑶘'),
+    ('𑶠', '𑶩'),
+    ('𑻠', '𑻶'),
+    ('\u{11f00}', '𑼐'),
+    ('𑼒', '\u{11f3a}'),
+    ('𑼾', '\u{11f42}'),
+    ('𑽐', '𑽙'),
+    ('𑾰', '𑾰'),
+    ('𒀀', '𒎙'),
+    ('𒐀', '𒑮'),
+    ('𒒀', '𒕃'),
+    ('𒾐', '𒿰'),
+    ('𓀀', '𓐯'),
+    ('\u{13440}', '\u{13455}'),
+    ('𔐀', '𔙆'),
+    ('𖠀', '𖨸'),
+    ('𖩀', '𖩞'),
+    ('𖩠', '𖩩'),
+    ('𖩰', '𖪾'),
+    ('𖫀', '𖫉'),
+    ('𖫐', '𖫭'),
+    ('\u{16af0}', '\u{16af4}'),
+    ('𖬀', '\u{16b36}'),
+    ('𖭀', '𖭃'),
+    ('𖭐', '𖭙'),
+    ('𖭣', '𖭷'),
+    ('𖭽', '𖮏'),
+    ('𖹀', '𖹿'),
+    ('𖼀', '𖽊'),
+    ('\u{16f4f}', '𖾇'),
+    ('\u{16f8f}', '𖾟'),
+    ('𖿠', '𖿡'),
+    ('𖿣', '\u{16fe4}'),
+    ('𖿰', '𖿱'),
+    ('𗀀', '𘟷'),
+    ('𘠀', '𘳕'),
+    ('𘴀', '𘴈'),
+    ('𚿰', '𚿳'),
+    ('𚿵', '𚿻'),
+    ('𚿽', '𚿾'),
+    ('𛀀', '𛄢'),
+    ('𛄲', '𛄲'),
+    ('𛅐', '𛅒'),
+    ('𛅕', '𛅕'),
+    ('𛅤', '𛅧'),
+    ('𛅰', '𛋻'),
+    ('𛰀', '𛱪'),
+    ('𛱰', '𛱼'),
+    ('𛲀', '𛲈'),
+    ('𛲐', '𛲙'),
+    ('\u{1bc9d}', '\u{1bc9e}'),
+    ('\u{1cf00}', '\u{1cf2d}'),
+    ('\u{1cf30}', '\u{1cf46}'),
+    ('\u{1d165}', '\u{1d169}'),
+    ('𝅭', '\u{1d172}'),
+    ('\u{1d17b}', '\u{1d182}'),
+    ('\u{1d185}', '\u{1d18b}'),
+    ('\u{1d1aa}', '\u{1d1ad}'),
+    ('\u{1d242}', '\u{1d244}'),
+    ('𝐀', '𝑔'),
+    ('𝑖', '𝒜'),
+    ('𝒞', '𝒟'),
+    ('𝒢', '𝒢'),
+    ('𝒥', '𝒦'),
+    ('𝒩', '𝒬'),
+    ('𝒮', '𝒹'),
+    ('𝒻', '𝒻'),
+    ('𝒽', '𝓃'),
+    ('𝓅', '𝔅'),
+    ('𝔇', '𝔊'),
+    ('𝔍', '𝔔'),
+    ('𝔖', '𝔜'),
+    ('𝔞', '𝔹'),
+    ('𝔻', '𝔾'),
+    ('𝕀', '𝕄'),
+    ('𝕆', '𝕆'),
+    ('𝕊', '𝕐'),
+    ('𝕒', '𝚥'),
+    ('𝚨', '𝛀'),
+    ('𝛂', '𝛚'),
+    ('𝛜', '𝛺'),
+    ('𝛼', '𝜔'),
+    ('𝜖', '𝜴'),
+    ('𝜶', '𝝎'),
+    ('𝝐', '𝝮'),
+    ('𝝰', '𝞈'),
+    ('𝞊', '𝞨'),
+    ('𝞪', '𝟂'),
+    ('𝟄', '𝟋'),
+    ('𝟎', '𝟿'),
+    ('\u{1da00}', '\u{1da36}'),
+    ('\u{1da3b}', '\u{1da6c}'),
+    ('\u{1da75}', '\u{1da75}'),
+    ('\u{1da84}', '\u{1da84}'),
+    ('\u{1da9b}', '\u{1da9f}'),
+    ('\u{1daa1}', '\u{1daaf}'),
+    ('𝼀', '𝼞'),
+    ('𝼥', '𝼪'),
+    ('\u{1e000}', '\u{1e006}'),
+    ('\u{1e008}', '\u{1e018}'),
+    ('\u{1e01b}', '\u{1e021}'),
+    ('\u{1e023}', '\u{1e024}'),
+    ('\u{1e026}', '\u{1e02a}'),
+    ('𞀰', '𞁭'),
+    ('\u{1e08f}', '\u{1e08f}'),
+    ('𞄀', '𞄬'),
+    ('\u{1e130}', '𞄽'),
+    ('𞅀', '𞅉'),
+    ('𞅎', '𞅎'),
+    ('𞊐', '\u{1e2ae}'),
+    ('𞋀', '𞋹'),
+    ('𞓐', '𞓹'),
+    ('𞟠', '𞟦'),
+    ('𞟨', '𞟫'),
+    ('𞟭', '𞟮'),
+    ('𞟰', '𞟾'),
+    ('𞠀', '𞣄'),
+    ('\u{1e8d0}', '\u{1e8d6}'),
+    ('𞤀', '𞥋'),
+    ('𞥐', '𞥙'),
+    ('𞸀', '𞸃'),
+    ('𞸅', '𞸟'),
+    ('𞸡', '𞸢'),
+    ('𞸤', '𞸤'),
+    ('𞸧', '𞸧'),
+    ('𞸩', '𞸲'),
+    ('𞸴', '𞸷'),
+    ('𞸹', '𞸹'),
+    ('𞸻', '𞸻'),
+    ('𞹂', '𞹂'),
+    ('𞹇', '𞹇'),
+    ('𞹉', '𞹉'),
+    ('𞹋', '𞹋'),
+    ('𞹍', '𞹏'),
+    ('𞹑', '𞹒'),
+    ('𞹔', '𞹔'),
+    ('𞹗', '𞹗'),
+    ('𞹙', '𞹙'),
+    ('𞹛', '𞹛'),
+    ('𞹝', '𞹝'),
+    ('𞹟', '𞹟'),
+    ('𞹡', '𞹢'),
+    ('𞹤', '𞹤'),
+    ('𞹧', '𞹪'),
+    ('𞹬', '𞹲'),
+    ('𞹴', '𞹷'),
+    ('𞹹', '𞹼'),
+    ('𞹾', '𞹾'),
+    ('𞺀', '𞺉'),
+    ('𞺋', '𞺛'),
+    ('𞺡', '𞺣'),
+    ('𞺥', '𞺩'),
+    ('𞺫', '𞺻'),
+    ('🯰', '🯹'),
+    ('𠀀', '𪛟'),
+    ('𪜀', '𫜹'),
+    ('𫝀', '𫠝'),
+    ('𫠠', '𬺡'),
+    ('𬺰', '𮯠'),
+    ('丽', '𪘀'),
+    ('𰀀', '𱍊'),
+    ('𱍐', '𲎯'),
+    ('\u{e0100}', '\u{e01ef}'),
+];
+
+pub const XID_START: &'static [(char, char)] = &[
+    ('A', 'Z'),
+    ('a', 'z'),
+    ('ª', 'ª'),
+    ('µ', 'µ'),
+    ('º', 'º'),
+    ('À', 'Ö'),
+    ('Ø', 'ö'),
+    ('ø', 'ˁ'),
+    ('ˆ', 'ˑ'),
+    ('ˠ', 'ˤ'),
+    ('ˬ', 'ˬ'),
+    ('ˮ', 'ˮ'),
+    ('Ͱ', 'ʹ'),
+    ('Ͷ', 'ͷ'),
+    ('ͻ', 'ͽ'),
+    ('Ϳ', 'Ϳ'),
+    ('Ά', 'Ά'),
+    ('Έ', 'Ί'),
+    ('Ό', 'Ό'),
+    ('Ύ', 'Ρ'),
+    ('Σ', 'ϵ'),
+    ('Ϸ', 'ҁ'),
+    ('Ҋ', 'ԯ'),
+    ('Ա', 'Ֆ'),
+    ('ՙ', 'ՙ'),
+    ('ՠ', 'ֈ'),
+    ('א', 'ת'),
+    ('ׯ', 'ײ'),
+    ('ؠ', 'ي'),
+    ('ٮ', 'ٯ'),
+    ('ٱ', 'ۓ'),
+    ('ە', 'ە'),
+    ('ۥ', 'ۦ'),
+    ('ۮ', 'ۯ'),
+    ('ۺ', 'ۼ'),
+    ('ۿ', 'ۿ'),
+    ('ܐ', 'ܐ'),
+    ('ܒ', 'ܯ'),
+    ('ݍ', 'ޥ'),
+    ('ޱ', 'ޱ'),
+    ('ߊ', 'ߪ'),
+    ('ߴ', 'ߵ'),
+    ('ߺ', 'ߺ'),
+    ('ࠀ', 'ࠕ'),
+    ('ࠚ', 'ࠚ'),
+    ('ࠤ', 'ࠤ'),
+    ('ࠨ', 'ࠨ'),
+    ('ࡀ', 'ࡘ'),
+    ('ࡠ', 'ࡪ'),
+    ('ࡰ', 'ࢇ'),
+    ('ࢉ', 'ࢎ'),
+    ('ࢠ', 'ࣉ'),
+    ('ऄ', 'ह'),
+    ('ऽ', 'ऽ'),
+    ('ॐ', 'ॐ'),
+    ('क़', 'ॡ'),
+    ('ॱ', 'ঀ'),
+    ('অ', 'ঌ'),
+    ('এ', 'ঐ'),
+    ('ও', 'ন'),
+    ('প', 'র'),
+    ('ল', 'ল'),
+    ('শ', 'হ'),
+    ('ঽ', 'ঽ'),
+    ('ৎ', 'ৎ'),
+    ('ড়', 'ঢ়'),
+    ('য়', 'ৡ'),
+    ('ৰ', 'ৱ'),
+    ('ৼ', 'ৼ'),
+    ('ਅ', 'ਊ'),
+    ('ਏ', 'ਐ'),
+    ('ਓ', 'ਨ'),
+    ('ਪ', 'ਰ'),
+    ('ਲ', 'ਲ਼'),
+    ('ਵ', 'ਸ਼'),
+    ('ਸ', 'ਹ'),
+    ('ਖ਼', 'ੜ'),
+    ('ਫ਼', 'ਫ਼'),
+    ('ੲ', 'ੴ'),
+    ('અ', 'ઍ'),
+    ('એ', 'ઑ'),
+    ('ઓ', 'ન'),
+    ('પ', 'ર'),
+    ('લ', 'ળ'),
+    ('વ', 'હ'),
+    ('ઽ', 'ઽ'),
+    ('ૐ', 'ૐ'),
+    ('ૠ', 'ૡ'),
+    ('ૹ', 'ૹ'),
+    ('ଅ', 'ଌ'),
+    ('ଏ', 'ଐ'),
+    ('ଓ', 'ନ'),
+    ('ପ', 'ର'),
+    ('ଲ', 'ଳ'),
+    ('ଵ', 'ହ'),
+    ('ଽ', 'ଽ'),
+    ('ଡ଼', 'ଢ଼'),
+    ('ୟ', 'ୡ'),
+    ('ୱ', 'ୱ'),
+    ('ஃ', 'ஃ'),
+    ('அ', 'ஊ'),
+    ('எ', 'ஐ'),
+    ('ஒ', 'க'),
+    ('ங', 'ச'),
+    ('ஜ', 'ஜ'),
+    ('ஞ', 'ட'),
+    ('ண', 'த'),
+    ('ந', 'ப'),
+    ('ம', 'ஹ'),
+    ('ௐ', 'ௐ'),
+    ('అ', 'ఌ'),
+    ('ఎ', 'ఐ'),
+    ('ఒ', 'న'),
+    ('ప', 'హ'),
+    ('ఽ', 'ఽ'),
+    ('ౘ', 'ౚ'),
+    ('ౝ', 'ౝ'),
+    ('ౠ', 'ౡ'),
+    ('ಀ', 'ಀ'),
+    ('ಅ', 'ಌ'),
+    ('ಎ', 'ಐ'),
+    ('ಒ', 'ನ'),
+    ('ಪ', 'ಳ'),
+    ('ವ', 'ಹ'),
+    ('ಽ', 'ಽ'),
+    ('ೝ', 'ೞ'),
+    ('ೠ', 'ೡ'),
+    ('ೱ', 'ೲ'),
+    ('ഄ', 'ഌ'),
+    ('എ', 'ഐ'),
+    ('ഒ', 'ഺ'),
+    ('ഽ', 'ഽ'),
+    ('ൎ', 'ൎ'),
+    ('ൔ', 'ൖ'),
+    ('ൟ', 'ൡ'),
+    ('ൺ', 'ൿ'),
+    ('අ', 'ඖ'),
+    ('ක', 'න'),
+    ('ඳ', 'ර'),
+    ('ල', 'ල'),
+    ('ව', 'ෆ'),
+    ('ก', 'ะ'),
+    ('า', 'า'),
+    ('เ', 'ๆ'),
+    ('ກ', 'ຂ'),
+    ('ຄ', 'ຄ'),
+    ('ຆ', 'ຊ'),
+    ('ຌ', 'ຣ'),
+    ('ລ', 'ລ'),
+    ('ວ', 'ະ'),
+    ('າ', 'າ'),
+    ('ຽ', 'ຽ'),
+    ('ເ', 'ໄ'),
+    ('ໆ', 'ໆ'),
+    ('ໜ', 'ໟ'),
+    ('ༀ', 'ༀ'),
+    ('ཀ', 'ཇ'),
+    ('ཉ', 'ཬ'),
+    ('ྈ', 'ྌ'),
+    ('က', 'ဪ'),
+    ('ဿ', 'ဿ'),
+    ('ၐ', 'ၕ'),
+    ('ၚ', 'ၝ'),
+    ('ၡ', 'ၡ'),
+    ('ၥ', 'ၦ'),
+    ('ၮ', 'ၰ'),
+    ('ၵ', 'ႁ'),
+    ('ႎ', 'ႎ'),
+    ('Ⴀ', 'Ⴥ'),
+    ('Ⴧ', 'Ⴧ'),
+    ('Ⴭ', 'Ⴭ'),
+    ('ა', 'ჺ'),
+    ('ჼ', 'ቈ'),
+    ('ቊ', 'ቍ'),
+    ('ቐ', 'ቖ'),
+    ('ቘ', 'ቘ'),
+    ('ቚ', 'ቝ'),
+    ('በ', 'ኈ'),
+    ('ኊ', 'ኍ'),
+    ('ነ', 'ኰ'),
+    ('ኲ', 'ኵ'),
+    ('ኸ', 'ኾ'),
+    ('ዀ', 'ዀ'),
+    ('ዂ', 'ዅ'),
+    ('ወ', 'ዖ'),
+    ('ዘ', 'ጐ'),
+    ('ጒ', 'ጕ'),
+    ('ጘ', 'ፚ'),
+    ('ᎀ', 'ᎏ'),
+    ('Ꭰ', 'Ᏽ'),
+    ('ᏸ', 'ᏽ'),
+    ('ᐁ', 'ᙬ'),
+    ('ᙯ', 'ᙿ'),
+    ('ᚁ', 'ᚚ'),
+    ('ᚠ', 'ᛪ'),
+    ('ᛮ', 'ᛸ'),
+    ('ᜀ', 'ᜑ'),
+    ('ᜟ', 'ᜱ'),
+    ('ᝀ', 'ᝑ'),
+    ('ᝠ', 'ᝬ'),
+    ('ᝮ', 'ᝰ'),
+    ('ក', 'ឳ'),
+    ('ៗ', 'ៗ'),
+    ('ៜ', 'ៜ'),
+    ('ᠠ', 'ᡸ'),
+    ('ᢀ', 'ᢨ'),
+    ('ᢪ', 'ᢪ'),
+    ('ᢰ', 'ᣵ'),
+    ('ᤀ', 'ᤞ'),
+    ('ᥐ', 'ᥭ'),
+    ('ᥰ', 'ᥴ'),
+    ('ᦀ', 'ᦫ'),
+    ('ᦰ', 'ᧉ'),
+    ('ᨀ', 'ᨖ'),
+    ('ᨠ', 'ᩔ'),
+    ('ᪧ', 'ᪧ'),
+    ('ᬅ', 'ᬳ'),
+    ('ᭅ', 'ᭌ'),
+    ('ᮃ', 'ᮠ'),
+    ('ᮮ', 'ᮯ'),
+    ('ᮺ', 'ᯥ'),
+    ('ᰀ', 'ᰣ'),
+    ('ᱍ', 'ᱏ'),
+    ('ᱚ', 'ᱽ'),
+    ('ᲀ', 'ᲈ'),
+    ('Ა', 'Ჺ'),
+    ('Ჽ', 'Ჿ'),
+    ('ᳩ', 'ᳬ'),
+    ('ᳮ', 'ᳳ'),
+    ('ᳵ', 'ᳶ'),
+    ('ᳺ', 'ᳺ'),
+    ('ᴀ', 'ᶿ'),
+    ('Ḁ', 'ἕ'),
+    ('Ἐ', 'Ἕ'),
+    ('ἠ', 'ὅ'),
+    ('Ὀ', 'Ὅ'),
+    ('ὐ', 'ὗ'),
+    ('Ὑ', 'Ὑ'),
+    ('Ὓ', 'Ὓ'),
+    ('Ὕ', 'Ὕ'),
+    ('Ὗ', 'ώ'),
+    ('ᾀ', 'ᾴ'),
+    ('ᾶ', 'ᾼ'),
+    ('ι', 'ι'),
+    ('ῂ', 'ῄ'),
+    ('ῆ', 'ῌ'),
+    ('ῐ', 'ΐ'),
+    ('ῖ', 'Ί'),
+    ('ῠ', 'Ῥ'),
+    ('ῲ', 'ῴ'),
+    ('ῶ', 'ῼ'),
+    ('ⁱ', 'ⁱ'),
+    ('ⁿ', 'ⁿ'),
+    ('ₐ', 'ₜ'),
+    ('ℂ', 'ℂ'),
+    ('ℇ', 'ℇ'),
+    ('ℊ', 'ℓ'),
+    ('ℕ', 'ℕ'),
+    ('℘', 'ℝ'),
+    ('ℤ', 'ℤ'),
+    ('Ω', 'Ω'),
+    ('ℨ', 'ℨ'),
+    ('K', 'ℹ'),
+    ('ℼ', 'ℿ'),
+    ('ⅅ', 'ⅉ'),
+    ('ⅎ', 'ⅎ'),
+    ('Ⅰ', 'ↈ'),
+    ('Ⰰ', 'ⳤ'),
+    ('Ⳬ', 'ⳮ'),
+    ('Ⳳ', 'ⳳ'),
+    ('ⴀ', 'ⴥ'),
+    ('ⴧ', 'ⴧ'),
+    ('ⴭ', 'ⴭ'),
+    ('ⴰ', 'ⵧ'),
+    ('ⵯ', 'ⵯ'),
+    ('ⶀ', 'ⶖ'),
+    ('ⶠ', 'ⶦ'),
+    ('ⶨ', 'ⶮ'),
+    ('ⶰ', 'ⶶ'),
+    ('ⶸ', 'ⶾ'),
+    ('ⷀ', 'ⷆ'),
+    ('ⷈ', 'ⷎ'),
+    ('ⷐ', 'ⷖ'),
+    ('ⷘ', 'ⷞ'),
+    ('々', '〇'),
+    ('〡', '〩'),
+    ('〱', '〵'),
+    ('〸', '〼'),
+    ('ぁ', 'ゖ'),
+    ('ゝ', 'ゟ'),
+    ('ァ', 'ヺ'),
+    ('ー', 'ヿ'),
+    ('ㄅ', 'ㄯ'),
+    ('ㄱ', 'ㆎ'),
+    ('ㆠ', 'ㆿ'),
+    ('ㇰ', 'ㇿ'),
+    ('㐀', '䶿'),
+    ('一', 'ꒌ'),
+    ('ꓐ', 'ꓽ'),
+    ('ꔀ', 'ꘌ'),
+    ('ꘐ', 'ꘟ'),
+    ('ꘪ', 'ꘫ'),
+    ('Ꙁ', 'ꙮ'),
+    ('ꙿ', 'ꚝ'),
+    ('ꚠ', 'ꛯ'),
+    ('ꜗ', 'ꜟ'),
+    ('Ꜣ', 'ꞈ'),
+    ('Ꞌ', 'ꟊ'),
+    ('Ꟑ', 'ꟑ'),
+    ('ꟓ', 'ꟓ'),
+    ('ꟕ', 'ꟙ'),
+    ('ꟲ', 'ꠁ'),
+    ('ꠃ', 'ꠅ'),
+    ('ꠇ', 'ꠊ'),
+    ('ꠌ', 'ꠢ'),
+    ('ꡀ', 'ꡳ'),
+    ('ꢂ', 'ꢳ'),
+    ('ꣲ', 'ꣷ'),
+    ('ꣻ', 'ꣻ'),
+    ('ꣽ', 'ꣾ'),
+    ('ꤊ', 'ꤥ'),
+    ('ꤰ', 'ꥆ'),
+    ('ꥠ', 'ꥼ'),
+    ('ꦄ', 'ꦲ'),
+    ('ꧏ', 'ꧏ'),
+    ('ꧠ', 'ꧤ'),
+    ('ꧦ', 'ꧯ'),
+    ('ꧺ', 'ꧾ'),
+    ('ꨀ', 'ꨨ'),
+    ('ꩀ', 'ꩂ'),
+    ('ꩄ', 'ꩋ'),
+    ('ꩠ', 'ꩶ'),
+    ('ꩺ', 'ꩺ'),
+    ('ꩾ', 'ꪯ'),
+    ('ꪱ', 'ꪱ'),
+    ('ꪵ', 'ꪶ'),
+    ('ꪹ', 'ꪽ'),
+    ('ꫀ', 'ꫀ'),
+    ('ꫂ', 'ꫂ'),
+    ('ꫛ', 'ꫝ'),
+    ('ꫠ', 'ꫪ'),
+    ('ꫲ', 'ꫴ'),
+    ('ꬁ', 'ꬆ'),
+    ('ꬉ', 'ꬎ'),
+    ('ꬑ', 'ꬖ'),
+    ('ꬠ', 'ꬦ'),
+    ('ꬨ', 'ꬮ'),
+    ('ꬰ', 'ꭚ'),
+    ('ꭜ', 'ꭩ'),
+    ('ꭰ', 'ꯢ'),
+    ('가', '힣'),
+    ('ힰ', 'ퟆ'),
+    ('ퟋ', 'ퟻ'),
+    ('豈', '舘'),
+    ('並', '龎'),
+    ('ﬀ', 'ﬆ'),
+    ('ﬓ', 'ﬗ'),
+    ('יִ', 'יִ'),
+    ('ײַ', 'ﬨ'),
+    ('שׁ', 'זּ'),
+    ('טּ', 'לּ'),
+    ('מּ', 'מּ'),
+    ('נּ', 'סּ'),
+    ('ףּ', 'פּ'),
+    ('צּ', 'ﮱ'),
+    ('ﯓ', 'ﱝ'),
+    ('ﱤ', 'ﴽ'),
+    ('ﵐ', 'ﶏ'),
+    ('ﶒ', 'ﷇ'),
+    ('ﷰ', 'ﷹ'),
+    ('ﹱ', 'ﹱ'),
+    ('ﹳ', 'ﹳ'),
+    ('ﹷ', 'ﹷ'),
+    ('ﹹ', 'ﹹ'),
+    ('ﹻ', 'ﹻ'),
+    ('ﹽ', 'ﹽ'),
+    ('ﹿ', 'ﻼ'),
+    ('Ａ', 'Ｚ'),
+    ('ａ', 'ｚ'),
+    ('ｦ', 'ﾝ'),
+    ('ﾠ', 'ﾾ'),
+    ('ￂ', 'ￇ'),
+    ('ￊ', 'ￏ'),
+    ('ￒ', 'ￗ'),
+    ('ￚ', 'ￜ'),
+    ('𐀀', '𐀋'),
+    ('𐀍', '𐀦'),
+    ('𐀨', '𐀺'),
+    ('𐀼', '𐀽'),
+    ('𐀿', '𐁍'),
+    ('𐁐', '𐁝'),
+    ('𐂀', '𐃺'),
+    ('𐅀', '𐅴'),
+    ('𐊀', '𐊜'),
+    ('𐊠', '𐋐'),
+    ('𐌀', '𐌟'),
+    ('𐌭', '𐍊'),
+    ('𐍐', '𐍵'),
+    ('𐎀', '𐎝'),
+    ('𐎠', '𐏃'),
+    ('𐏈', '𐏏'),
+    ('𐏑', '𐏕'),
+    ('𐐀', '𐒝'),
+    ('𐒰', '𐓓'),
+    ('𐓘', '𐓻'),
+    ('𐔀', '𐔧'),
+    ('𐔰', '𐕣'),
+    ('𐕰', '𐕺'),
+    ('𐕼', '𐖊'),
+    ('𐖌', '𐖒'),
+    ('𐖔', '𐖕'),
+    ('𐖗', '𐖡'),
+    ('𐖣', '𐖱'),
+    ('𐖳', '𐖹'),
+    ('𐖻', '𐖼'),
+    ('𐘀', '𐜶'),
+    ('𐝀', '𐝕'),
+    ('𐝠', '𐝧'),
+    ('𐞀', '𐞅'),
+    ('𐞇', '𐞰'),
+    ('𐞲', '𐞺'),
+    ('𐠀', '𐠅'),
+    ('𐠈', '𐠈'),
+    ('𐠊', '𐠵'),
+    ('𐠷', '𐠸'),
+    ('𐠼', '𐠼'),
+    ('𐠿', '𐡕'),
+    ('𐡠', '𐡶'),
+    ('𐢀', '𐢞'),
+    ('𐣠', '𐣲'),
+    ('𐣴', '𐣵'),
+    ('𐤀', '𐤕'),
+    ('𐤠', '𐤹'),
+    ('𐦀', '𐦷'),
+    ('𐦾', '𐦿'),
+    ('𐨀', '𐨀'),
+    ('𐨐', '𐨓'),
+    ('𐨕', '𐨗'),
+    ('𐨙', '𐨵'),
+    ('𐩠', '𐩼'),
+    ('𐪀', '𐪜'),
+    ('𐫀', '𐫇'),
+    ('𐫉', '𐫤'),
+    ('𐬀', '𐬵'),
+    ('𐭀', '𐭕'),
+    ('𐭠', '𐭲'),
+    ('𐮀', '𐮑'),
+    ('𐰀', '𐱈'),
+    ('𐲀', '𐲲'),
+    ('𐳀', '𐳲'),
+    ('𐴀', '𐴣'),
+    ('𐺀', '𐺩'),
+    ('𐺰', '𐺱'),
+    ('𐼀', '𐼜'),
+    ('𐼧', '𐼧'),
+    ('𐼰', '𐽅'),
+    ('𐽰', '𐾁'),
+    ('𐾰', '𐿄'),
+    ('𐿠', '𐿶'),
+    ('𑀃', '𑀷'),
+    ('𑁱', '𑁲'),
+    ('𑁵', '𑁵'),
+    ('𑂃', '𑂯'),
+    ('𑃐', '𑃨'),
+    ('𑄃', '𑄦'),
+    ('𑅄', '𑅄'),
+    ('𑅇', '𑅇'),
+    ('𑅐', '𑅲'),
+    ('𑅶', '𑅶'),
+    ('𑆃', '𑆲'),
+    ('𑇁', '𑇄'),
+    ('𑇚', '𑇚'),
+    ('𑇜', '𑇜'),
+    ('𑈀', '𑈑'),
+    ('𑈓', '𑈫'),
+    ('𑈿', '𑉀'),
+    ('𑊀', '𑊆'),
+    ('𑊈', '𑊈'),
+    ('𑊊', '𑊍'),
+    ('𑊏', '𑊝'),
+    ('𑊟', '𑊨'),
+    ('𑊰', '𑋞'),
+    ('𑌅', '𑌌'),
+    ('𑌏', '𑌐'),
+    ('𑌓', '𑌨'),
+    ('𑌪', '𑌰'),
+    ('𑌲', '𑌳'),
+    ('𑌵', '𑌹'),
+    ('𑌽', '𑌽'),
+    ('𑍐', '𑍐'),
+    ('𑍝', '𑍡'),
+    ('𑐀', '𑐴'),
+    ('𑑇', '𑑊'),
+    ('𑑟', '𑑡'),
+    ('𑒀', '𑒯'),
+    ('𑓄', '𑓅'),
+    ('𑓇', '𑓇'),
+    ('𑖀', '𑖮'),
+    ('𑗘', '𑗛'),
+    ('𑘀', '𑘯'),
+    ('𑙄', '𑙄'),
+    ('𑚀', '𑚪'),
+    ('𑚸', '𑚸'),
+    ('𑜀', '𑜚'),
+    ('𑝀', '𑝆'),
+    ('𑠀', '𑠫'),
+    ('𑢠', '𑣟'),
+    ('𑣿', '𑤆'),
+    ('𑤉', '𑤉'),
+    ('𑤌', '𑤓'),
+    ('𑤕', '𑤖'),
+    ('𑤘', '𑤯'),
+    ('𑤿', '𑤿'),
+    ('𑥁', '𑥁'),
+    ('𑦠', '𑦧'),
+    ('𑦪', '𑧐'),
+    ('𑧡', '𑧡'),
+    ('𑧣', '𑧣'),
+    ('𑨀', '𑨀'),
+    ('𑨋', '𑨲'),
+    ('𑨺', '𑨺'),
+    ('𑩐', '𑩐'),
+    ('𑩜', '𑪉'),
+    ('𑪝', '𑪝'),
+    ('𑪰', '𑫸'),
+    ('𑰀', '𑰈'),
+    ('𑰊', '𑰮'),
+    ('𑱀', '𑱀'),
+    ('𑱲', '𑲏'),
+    ('𑴀', '𑴆'),
+    ('𑴈', '𑴉'),
+    ('𑴋', '𑴰'),
+    ('𑵆', '𑵆'),
+    ('𑵠', '𑵥'),
+    ('𑵧', '𑵨'),
+    ('𑵪', '𑶉'),
+    ('𑶘', '𑶘'),
+    ('𑻠', '𑻲'),
+    ('𑼂', '𑼂'),
+    ('𑼄', '𑼐'),
+    ('𑼒', '𑼳'),
+    ('𑾰', '𑾰'),
+    ('𒀀', '𒎙'),
+    ('𒐀', '𒑮'),
+    ('𒒀', '𒕃'),
+    ('𒾐', '𒿰'),
+    ('𓀀', '𓐯'),
+    ('𓑁', '𓑆'),
+    ('𔐀', '𔙆'),
+    ('𖠀', '𖨸'),
+    ('𖩀', '𖩞'),
+    ('𖩰', '𖪾'),
+    ('𖫐', '𖫭'),
+    ('𖬀', '𖬯'),
+    ('𖭀', '𖭃'),
+    ('𖭣', '𖭷'),
+    ('𖭽', '𖮏'),
+    ('𖹀', '𖹿'),
+    ('𖼀', '𖽊'),
+    ('𖽐', '𖽐'),
+    ('𖾓', '𖾟'),
+    ('𖿠', '𖿡'),
+    ('𖿣', '𖿣'),
+    ('𗀀', '𘟷'),
+    ('𘠀', '𘳕'),
+    ('𘴀', '𘴈'),
+    ('𚿰', '𚿳'),
+    ('𚿵', '𚿻'),
+    ('𚿽', '𚿾'),
+    ('𛀀', '𛄢'),
+    ('𛄲', '𛄲'),
+    ('𛅐', '𛅒'),
+    ('𛅕', '𛅕'),
+    ('𛅤', '𛅧'),
+    ('𛅰', '𛋻'),
+    ('𛰀', '𛱪'),
+    ('𛱰', '𛱼'),
+    ('𛲀', '𛲈'),
+    ('𛲐', '𛲙'),
+    ('𝐀', '𝑔'),
+    ('𝑖', '𝒜'),
+    ('𝒞', '𝒟'),
+    ('𝒢', '𝒢'),
+    ('𝒥', '𝒦'),
+    ('𝒩', '𝒬'),
+    ('𝒮', '𝒹'),
+    ('𝒻', '𝒻'),
+    ('𝒽', '𝓃'),
+    ('𝓅', '𝔅'),
+    ('𝔇', '𝔊'),
+    ('𝔍', '𝔔'),
+    ('𝔖', '𝔜'),
+    ('𝔞', '𝔹'),
+    ('𝔻', '𝔾'),
+    ('𝕀', '𝕄'),
+    ('𝕆', '𝕆'),
+    ('𝕊', '𝕐'),
+    ('𝕒', '𝚥'),
+    ('𝚨', '𝛀'),
+    ('𝛂', '𝛚'),
+    ('𝛜', '𝛺'),
+    ('𝛼', '𝜔'),
+    ('𝜖', '𝜴'),
+    ('𝜶', '𝝎'),
+    ('𝝐', '𝝮'),
+    ('𝝰', '𝞈'),
+    ('𝞊', '𝞨'),
+    ('𝞪', '𝟂'),
+    ('𝟄', '𝟋'),
+    ('𝼀', '𝼞'),
+    ('𝼥', '𝼪'),
+    ('𞀰', '𞁭'),
+    ('𞄀', '𞄬'),
+    ('𞄷', '𞄽'),
+    ('𞅎', '𞅎'),
+    ('𞊐', '𞊭'),
+    ('𞋀', '𞋫'),
+    ('𞓐', '𞓫'),
+    ('𞟠', '𞟦'),
+    ('𞟨', '𞟫'),
+    ('𞟭', '𞟮'),
+    ('𞟰', '𞟾'),
+    ('𞠀', '𞣄'),
+    ('𞤀', '𞥃'),
+    ('𞥋', '𞥋'),
+    ('𞸀', '𞸃'),
+    ('𞸅', '𞸟'),
+    ('𞸡', '𞸢'),
+    ('𞸤', '𞸤'),
+    ('𞸧', '𞸧'),
+    ('𞸩', '𞸲'),
+    ('𞸴', '𞸷'),
+    ('𞸹', '𞸹'),
+    ('𞸻', '𞸻'),
+    ('𞹂', '𞹂'),
+    ('𞹇', '𞹇'),
+    ('𞹉', '𞹉'),
+    ('𞹋', '𞹋'),
+    ('𞹍', '𞹏'),
+    ('𞹑', '𞹒'),
+    ('𞹔', '𞹔'),
+    ('𞹗', '𞹗'),
+    ('𞹙', '𞹙'),
+    ('𞹛', '𞹛'),
+    ('𞹝', '𞹝'),
+    ('𞹟', '𞹟'),
+    ('𞹡', '𞹢'),
+    ('𞹤', '𞹤'),
+    ('𞹧', '𞹪'),
+    ('𞹬', '𞹲'),
+    ('𞹴', '𞹷'),
+    ('𞹹', '𞹼'),
+    ('𞹾', '𞹾'),
+    ('𞺀', '𞺉'),
+    ('𞺋', '𞺛'),
+    ('𞺡', '𞺣'),
+    ('𞺥', '𞺩'),
+    ('𞺫', '𞺻'),
+    ('𠀀', '𪛟'),
+    ('𪜀', '𫜹'),
+    ('𫝀', '𫠝'),
+    ('𫠠', '𬺡'),
+    ('𬺰', '𮯠'),
+    ('丽', '𪘀'),
+    ('𰀀', '𱍊'),
+    ('𱍐', '𲎯'),
+];
diff --git a/crates/regex-syntax/src/unicode_tables/property_names.rs b/crates/regex-syntax/src/unicode_tables/property_names.rs
new file mode 100644
index 0000000..599a123
--- /dev/null
+++ b/crates/regex-syntax/src/unicode_tables/property_names.rs
@@ -0,0 +1,264 @@
+// DO NOT EDIT THIS FILE. IT WAS AUTOMATICALLY GENERATED BY:
+//
+//   ucd-generate property-names ucd-15.0.0
+//
+// Unicode version: 15.0.0.
+//
+// ucd-generate 0.2.14 is available on crates.io.
+
+pub const PROPERTY_NAMES: &'static [(&'static str, &'static str)] = &[
+    ("age", "Age"),
+    ("ahex", "ASCII_Hex_Digit"),
+    ("alpha", "Alphabetic"),
+    ("alphabetic", "Alphabetic"),
+    ("asciihexdigit", "ASCII_Hex_Digit"),
+    ("bc", "Bidi_Class"),
+    ("bidic", "Bidi_Control"),
+    ("bidiclass", "Bidi_Class"),
+    ("bidicontrol", "Bidi_Control"),
+    ("bidim", "Bidi_Mirrored"),
+    ("bidimirrored", "Bidi_Mirrored"),
+    ("bidimirroringglyph", "Bidi_Mirroring_Glyph"),
+    ("bidipairedbracket", "Bidi_Paired_Bracket"),
+    ("bidipairedbrackettype", "Bidi_Paired_Bracket_Type"),
+    ("blk", "Block"),
+    ("block", "Block"),
+    ("bmg", "Bidi_Mirroring_Glyph"),
+    ("bpb", "Bidi_Paired_Bracket"),
+    ("bpt", "Bidi_Paired_Bracket_Type"),
+    ("canonicalcombiningclass", "Canonical_Combining_Class"),
+    ("cased", "Cased"),
+    ("casefolding", "Case_Folding"),
+    ("caseignorable", "Case_Ignorable"),
+    ("ccc", "Canonical_Combining_Class"),
+    ("ce", "Composition_Exclusion"),
+    ("cf", "Case_Folding"),
+    ("changeswhencasefolded", "Changes_When_Casefolded"),
+    ("changeswhencasemapped", "Changes_When_Casemapped"),
+    ("changeswhenlowercased", "Changes_When_Lowercased"),
+    ("changeswhennfkccasefolded", "Changes_When_NFKC_Casefolded"),
+    ("changeswhentitlecased", "Changes_When_Titlecased"),
+    ("changeswhenuppercased", "Changes_When_Uppercased"),
+    ("ci", "Case_Ignorable"),
+    ("cjkaccountingnumeric", "kAccountingNumeric"),
+    ("cjkcompatibilityvariant", "kCompatibilityVariant"),
+    ("cjkiicore", "kIICore"),
+    ("cjkirggsource", "kIRG_GSource"),
+    ("cjkirghsource", "kIRG_HSource"),
+    ("cjkirgjsource", "kIRG_JSource"),
+    ("cjkirgkpsource", "kIRG_KPSource"),
+    ("cjkirgksource", "kIRG_KSource"),
+    ("cjkirgmsource", "kIRG_MSource"),
+    ("cjkirgssource", "kIRG_SSource"),
+    ("cjkirgtsource", "kIRG_TSource"),
+    ("cjkirguksource", "kIRG_UKSource"),
+    ("cjkirgusource", "kIRG_USource"),
+    ("cjkirgvsource", "kIRG_VSource"),
+    ("cjkothernumeric", "kOtherNumeric"),
+    ("cjkprimarynumeric", "kPrimaryNumeric"),
+    ("cjkrsunicode", "kRSUnicode"),
+    ("compex", "Full_Composition_Exclusion"),
+    ("compositionexclusion", "Composition_Exclusion"),
+    ("cwcf", "Changes_When_Casefolded"),
+    ("cwcm", "Changes_When_Casemapped"),
+    ("cwkcf", "Changes_When_NFKC_Casefolded"),
+    ("cwl", "Changes_When_Lowercased"),
+    ("cwt", "Changes_When_Titlecased"),
+    ("cwu", "Changes_When_Uppercased"),
+    ("dash", "Dash"),
+    ("decompositionmapping", "Decomposition_Mapping"),
+    ("decompositiontype", "Decomposition_Type"),
+    ("defaultignorablecodepoint", "Default_Ignorable_Code_Point"),
+    ("dep", "Deprecated"),
+    ("deprecated", "Deprecated"),
+    ("di", "Default_Ignorable_Code_Point"),
+    ("dia", "Diacritic"),
+    ("diacritic", "Diacritic"),
+    ("dm", "Decomposition_Mapping"),
+    ("dt", "Decomposition_Type"),
+    ("ea", "East_Asian_Width"),
+    ("eastasianwidth", "East_Asian_Width"),
+    ("ebase", "Emoji_Modifier_Base"),
+    ("ecomp", "Emoji_Component"),
+    ("emod", "Emoji_Modifier"),
+    ("emoji", "Emoji"),
+    ("emojicomponent", "Emoji_Component"),
+    ("emojimodifier", "Emoji_Modifier"),
+    ("emojimodifierbase", "Emoji_Modifier_Base"),
+    ("emojipresentation", "Emoji_Presentation"),
+    ("epres", "Emoji_Presentation"),
+    ("equideo", "Equivalent_Unified_Ideograph"),
+    ("equivalentunifiedideograph", "Equivalent_Unified_Ideograph"),
+    ("expandsonnfc", "Expands_On_NFC"),
+    ("expandsonnfd", "Expands_On_NFD"),
+    ("expandsonnfkc", "Expands_On_NFKC"),
+    ("expandsonnfkd", "Expands_On_NFKD"),
+    ("ext", "Extender"),
+    ("extendedpictographic", "Extended_Pictographic"),
+    ("extender", "Extender"),
+    ("extpict", "Extended_Pictographic"),
+    ("fcnfkc", "FC_NFKC_Closure"),
+    ("fcnfkcclosure", "FC_NFKC_Closure"),
+    ("fullcompositionexclusion", "Full_Composition_Exclusion"),
+    ("gc", "General_Category"),
+    ("gcb", "Grapheme_Cluster_Break"),
+    ("generalcategory", "General_Category"),
+    ("graphemebase", "Grapheme_Base"),
+    ("graphemeclusterbreak", "Grapheme_Cluster_Break"),
+    ("graphemeextend", "Grapheme_Extend"),
+    ("graphemelink", "Grapheme_Link"),
+    ("grbase", "Grapheme_Base"),
+    ("grext", "Grapheme_Extend"),
+    ("grlink", "Grapheme_Link"),
+    ("hangulsyllabletype", "Hangul_Syllable_Type"),
+    ("hex", "Hex_Digit"),
+    ("hexdigit", "Hex_Digit"),
+    ("hst", "Hangul_Syllable_Type"),
+    ("hyphen", "Hyphen"),
+    ("idc", "ID_Continue"),
+    ("idcontinue", "ID_Continue"),
+    ("ideo", "Ideographic"),
+    ("ideographic", "Ideographic"),
+    ("ids", "ID_Start"),
+    ("idsb", "IDS_Binary_Operator"),
+    ("idsbinaryoperator", "IDS_Binary_Operator"),
+    ("idst", "IDS_Trinary_Operator"),
+    ("idstart", "ID_Start"),
+    ("idstrinaryoperator", "IDS_Trinary_Operator"),
+    ("indicpositionalcategory", "Indic_Positional_Category"),
+    ("indicsyllabiccategory", "Indic_Syllabic_Category"),
+    ("inpc", "Indic_Positional_Category"),
+    ("insc", "Indic_Syllabic_Category"),
+    ("isc", "ISO_Comment"),
+    ("jamoshortname", "Jamo_Short_Name"),
+    ("jg", "Joining_Group"),
+    ("joinc", "Join_Control"),
+    ("joincontrol", "Join_Control"),
+    ("joininggroup", "Joining_Group"),
+    ("joiningtype", "Joining_Type"),
+    ("jsn", "Jamo_Short_Name"),
+    ("jt", "Joining_Type"),
+    ("kaccountingnumeric", "kAccountingNumeric"),
+    ("kcompatibilityvariant", "kCompatibilityVariant"),
+    ("kiicore", "kIICore"),
+    ("kirggsource", "kIRG_GSource"),
+    ("kirghsource", "kIRG_HSource"),
+    ("kirgjsource", "kIRG_JSource"),
+    ("kirgkpsource", "kIRG_KPSource"),
+    ("kirgksource", "kIRG_KSource"),
+    ("kirgmsource", "kIRG_MSource"),
+    ("kirgssource", "kIRG_SSource"),
+    ("kirgtsource", "kIRG_TSource"),
+    ("kirguksource", "kIRG_UKSource"),
+    ("kirgusource", "kIRG_USource"),
+    ("kirgvsource", "kIRG_VSource"),
+    ("kothernumeric", "kOtherNumeric"),
+    ("kprimarynumeric", "kPrimaryNumeric"),
+    ("krsunicode", "kRSUnicode"),
+    ("lb", "Line_Break"),
+    ("lc", "Lowercase_Mapping"),
+    ("linebreak", "Line_Break"),
+    ("loe", "Logical_Order_Exception"),
+    ("logicalorderexception", "Logical_Order_Exception"),
+    ("lower", "Lowercase"),
+    ("lowercase", "Lowercase"),
+    ("lowercasemapping", "Lowercase_Mapping"),
+    ("math", "Math"),
+    ("na", "Name"),
+    ("na1", "Unicode_1_Name"),
+    ("name", "Name"),
+    ("namealias", "Name_Alias"),
+    ("nchar", "Noncharacter_Code_Point"),
+    ("nfcqc", "NFC_Quick_Check"),
+    ("nfcquickcheck", "NFC_Quick_Check"),
+    ("nfdqc", "NFD_Quick_Check"),
+    ("nfdquickcheck", "NFD_Quick_Check"),
+    ("nfkccasefold", "NFKC_Casefold"),
+    ("nfkccf", "NFKC_Casefold"),
+    ("nfkcqc", "NFKC_Quick_Check"),
+    ("nfkcquickcheck", "NFKC_Quick_Check"),
+    ("nfkdqc", "NFKD_Quick_Check"),
+    ("nfkdquickcheck", "NFKD_Quick_Check"),
+    ("noncharactercodepoint", "Noncharacter_Code_Point"),
+    ("nt", "Numeric_Type"),
+    ("numerictype", "Numeric_Type"),
+    ("numericvalue", "Numeric_Value"),
+    ("nv", "Numeric_Value"),
+    ("oalpha", "Other_Alphabetic"),
+    ("ocomment", "ISO_Comment"),
+    ("odi", "Other_Default_Ignorable_Code_Point"),
+    ("ogrext", "Other_Grapheme_Extend"),
+    ("oidc", "Other_ID_Continue"),
+    ("oids", "Other_ID_Start"),
+    ("olower", "Other_Lowercase"),
+    ("omath", "Other_Math"),
+    ("otheralphabetic", "Other_Alphabetic"),
+    ("otherdefaultignorablecodepoint", "Other_Default_Ignorable_Code_Point"),
+    ("othergraphemeextend", "Other_Grapheme_Extend"),
+    ("otheridcontinue", "Other_ID_Continue"),
+    ("otheridstart", "Other_ID_Start"),
+    ("otherlowercase", "Other_Lowercase"),
+    ("othermath", "Other_Math"),
+    ("otheruppercase", "Other_Uppercase"),
+    ("oupper", "Other_Uppercase"),
+    ("patsyn", "Pattern_Syntax"),
+    ("patternsyntax", "Pattern_Syntax"),
+    ("patternwhitespace", "Pattern_White_Space"),
+    ("patws", "Pattern_White_Space"),
+    ("pcm", "Prepended_Concatenation_Mark"),
+    ("prependedconcatenationmark", "Prepended_Concatenation_Mark"),
+    ("qmark", "Quotation_Mark"),
+    ("quotationmark", "Quotation_Mark"),
+    ("radical", "Radical"),
+    ("regionalindicator", "Regional_Indicator"),
+    ("ri", "Regional_Indicator"),
+    ("sb", "Sentence_Break"),
+    ("sc", "Script"),
+    ("scf", "Simple_Case_Folding"),
+    ("script", "Script"),
+    ("scriptextensions", "Script_Extensions"),
+    ("scx", "Script_Extensions"),
+    ("sd", "Soft_Dotted"),
+    ("sentencebreak", "Sentence_Break"),
+    ("sentenceterminal", "Sentence_Terminal"),
+    ("sfc", "Simple_Case_Folding"),
+    ("simplecasefolding", "Simple_Case_Folding"),
+    ("simplelowercasemapping", "Simple_Lowercase_Mapping"),
+    ("simpletitlecasemapping", "Simple_Titlecase_Mapping"),
+    ("simpleuppercasemapping", "Simple_Uppercase_Mapping"),
+    ("slc", "Simple_Lowercase_Mapping"),
+    ("softdotted", "Soft_Dotted"),
+    ("space", "White_Space"),
+    ("stc", "Simple_Titlecase_Mapping"),
+    ("sterm", "Sentence_Terminal"),
+    ("suc", "Simple_Uppercase_Mapping"),
+    ("tc", "Titlecase_Mapping"),
+    ("term", "Terminal_Punctuation"),
+    ("terminalpunctuation", "Terminal_Punctuation"),
+    ("titlecasemapping", "Titlecase_Mapping"),
+    ("uc", "Uppercase_Mapping"),
+    ("uideo", "Unified_Ideograph"),
+    ("unicode1name", "Unicode_1_Name"),
+    ("unicoderadicalstroke", "kRSUnicode"),
+    ("unifiedideograph", "Unified_Ideograph"),
+    ("upper", "Uppercase"),
+    ("uppercase", "Uppercase"),
+    ("uppercasemapping", "Uppercase_Mapping"),
+    ("urs", "kRSUnicode"),
+    ("variationselector", "Variation_Selector"),
+    ("verticalorientation", "Vertical_Orientation"),
+    ("vo", "Vertical_Orientation"),
+    ("vs", "Variation_Selector"),
+    ("wb", "Word_Break"),
+    ("whitespace", "White_Space"),
+    ("wordbreak", "Word_Break"),
+    ("wspace", "White_Space"),
+    ("xidc", "XID_Continue"),
+    ("xidcontinue", "XID_Continue"),
+    ("xids", "XID_Start"),
+    ("xidstart", "XID_Start"),
+    ("xonfc", "Expands_On_NFC"),
+    ("xonfd", "Expands_On_NFD"),
+    ("xonfkc", "Expands_On_NFKC"),
+    ("xonfkd", "Expands_On_NFKD"),
+];
diff --git a/crates/regex-syntax/src/unicode_tables/property_values.rs b/crates/regex-syntax/src/unicode_tables/property_values.rs
new file mode 100644
index 0000000..cb2d32f
--- /dev/null
+++ b/crates/regex-syntax/src/unicode_tables/property_values.rs
@@ -0,0 +1,924 @@
+// DO NOT EDIT THIS FILE. IT WAS AUTOMATICALLY GENERATED BY:
+//
+//   ucd-generate property-values ucd-15.0.0 --include gc,script,scx,age,gcb,wb,sb
+//
+// Unicode version: 15.0.0.
+//
+// ucd-generate 0.2.14 is available on crates.io.
+
+pub const PROPERTY_VALUES: &'static [(
+    &'static str,
+    &'static [(&'static str, &'static str)],
+)] = &[
+    (
+        "Age",
+        &[
+            ("1.1", "V1_1"),
+            ("10.0", "V10_0"),
+            ("11.0", "V11_0"),
+            ("12.0", "V12_0"),
+            ("12.1", "V12_1"),
+            ("13.0", "V13_0"),
+            ("14.0", "V14_0"),
+            ("15.0", "V15_0"),
+            ("2.0", "V2_0"),
+            ("2.1", "V2_1"),
+            ("3.0", "V3_0"),
+            ("3.1", "V3_1"),
+            ("3.2", "V3_2"),
+            ("4.0", "V4_0"),
+            ("4.1", "V4_1"),
+            ("5.0", "V5_0"),
+            ("5.1", "V5_1"),
+            ("5.2", "V5_2"),
+            ("6.0", "V6_0"),
+            ("6.1", "V6_1"),
+            ("6.2", "V6_2"),
+            ("6.3", "V6_3"),
+            ("7.0", "V7_0"),
+            ("8.0", "V8_0"),
+            ("9.0", "V9_0"),
+            ("na", "Unassigned"),
+            ("unassigned", "Unassigned"),
+            ("v100", "V10_0"),
+            ("v11", "V1_1"),
+            ("v110", "V11_0"),
+            ("v120", "V12_0"),
+            ("v121", "V12_1"),
+            ("v130", "V13_0"),
+            ("v140", "V14_0"),
+            ("v150", "V15_0"),
+            ("v20", "V2_0"),
+            ("v21", "V2_1"),
+            ("v30", "V3_0"),
+            ("v31", "V3_1"),
+            ("v32", "V3_2"),
+            ("v40", "V4_0"),
+            ("v41", "V4_1"),
+            ("v50", "V5_0"),
+            ("v51", "V5_1"),
+            ("v52", "V5_2"),
+            ("v60", "V6_0"),
+            ("v61", "V6_1"),
+            ("v62", "V6_2"),
+            ("v63", "V6_3"),
+            ("v70", "V7_0"),
+            ("v80", "V8_0"),
+            ("v90", "V9_0"),
+        ],
+    ),
+    (
+        "General_Category",
+        &[
+            ("c", "Other"),
+            ("casedletter", "Cased_Letter"),
+            ("cc", "Control"),
+            ("cf", "Format"),
+            ("closepunctuation", "Close_Punctuation"),
+            ("cn", "Unassigned"),
+            ("cntrl", "Control"),
+            ("co", "Private_Use"),
+            ("combiningmark", "Mark"),
+            ("connectorpunctuation", "Connector_Punctuation"),
+            ("control", "Control"),
+            ("cs", "Surrogate"),
+            ("currencysymbol", "Currency_Symbol"),
+            ("dashpunctuation", "Dash_Punctuation"),
+            ("decimalnumber", "Decimal_Number"),
+            ("digit", "Decimal_Number"),
+            ("enclosingmark", "Enclosing_Mark"),
+            ("finalpunctuation", "Final_Punctuation"),
+            ("format", "Format"),
+            ("initialpunctuation", "Initial_Punctuation"),
+            ("l", "Letter"),
+            ("lc", "Cased_Letter"),
+            ("letter", "Letter"),
+            ("letternumber", "Letter_Number"),
+            ("lineseparator", "Line_Separator"),
+            ("ll", "Lowercase_Letter"),
+            ("lm", "Modifier_Letter"),
+            ("lo", "Other_Letter"),
+            ("lowercaseletter", "Lowercase_Letter"),
+            ("lt", "Titlecase_Letter"),
+            ("lu", "Uppercase_Letter"),
+            ("m", "Mark"),
+            ("mark", "Mark"),
+            ("mathsymbol", "Math_Symbol"),
+            ("mc", "Spacing_Mark"),
+            ("me", "Enclosing_Mark"),
+            ("mn", "Nonspacing_Mark"),
+            ("modifierletter", "Modifier_Letter"),
+            ("modifiersymbol", "Modifier_Symbol"),
+            ("n", "Number"),
+            ("nd", "Decimal_Number"),
+            ("nl", "Letter_Number"),
+            ("no", "Other_Number"),
+            ("nonspacingmark", "Nonspacing_Mark"),
+            ("number", "Number"),
+            ("openpunctuation", "Open_Punctuation"),
+            ("other", "Other"),
+            ("otherletter", "Other_Letter"),
+            ("othernumber", "Other_Number"),
+            ("otherpunctuation", "Other_Punctuation"),
+            ("othersymbol", "Other_Symbol"),
+            ("p", "Punctuation"),
+            ("paragraphseparator", "Paragraph_Separator"),
+            ("pc", "Connector_Punctuation"),
+            ("pd", "Dash_Punctuation"),
+            ("pe", "Close_Punctuation"),
+            ("pf", "Final_Punctuation"),
+            ("pi", "Initial_Punctuation"),
+            ("po", "Other_Punctuation"),
+            ("privateuse", "Private_Use"),
+            ("ps", "Open_Punctuation"),
+            ("punct", "Punctuation"),
+            ("punctuation", "Punctuation"),
+            ("s", "Symbol"),
+            ("sc", "Currency_Symbol"),
+            ("separator", "Separator"),
+            ("sk", "Modifier_Symbol"),
+            ("sm", "Math_Symbol"),
+            ("so", "Other_Symbol"),
+            ("spaceseparator", "Space_Separator"),
+            ("spacingmark", "Spacing_Mark"),
+            ("surrogate", "Surrogate"),
+            ("symbol", "Symbol"),
+            ("titlecaseletter", "Titlecase_Letter"),
+            ("unassigned", "Unassigned"),
+            ("uppercaseletter", "Uppercase_Letter"),
+            ("z", "Separator"),
+            ("zl", "Line_Separator"),
+            ("zp", "Paragraph_Separator"),
+            ("zs", "Space_Separator"),
+        ],
+    ),
+    (
+        "Grapheme_Cluster_Break",
+        &[
+            ("cn", "Control"),
+            ("control", "Control"),
+            ("cr", "CR"),
+            ("eb", "E_Base"),
+            ("ebase", "E_Base"),
+            ("ebasegaz", "E_Base_GAZ"),
+            ("ebg", "E_Base_GAZ"),
+            ("em", "E_Modifier"),
+            ("emodifier", "E_Modifier"),
+            ("ex", "Extend"),
+            ("extend", "Extend"),
+            ("gaz", "Glue_After_Zwj"),
+            ("glueafterzwj", "Glue_After_Zwj"),
+            ("l", "L"),
+            ("lf", "LF"),
+            ("lv", "LV"),
+            ("lvt", "LVT"),
+            ("other", "Other"),
+            ("pp", "Prepend"),
+            ("prepend", "Prepend"),
+            ("regionalindicator", "Regional_Indicator"),
+            ("ri", "Regional_Indicator"),
+            ("sm", "SpacingMark"),
+            ("spacingmark", "SpacingMark"),
+            ("t", "T"),
+            ("v", "V"),
+            ("xx", "Other"),
+            ("zwj", "ZWJ"),
+        ],
+    ),
+    (
+        "Script",
+        &[
+            ("adlam", "Adlam"),
+            ("adlm", "Adlam"),
+            ("aghb", "Caucasian_Albanian"),
+            ("ahom", "Ahom"),
+            ("anatolianhieroglyphs", "Anatolian_Hieroglyphs"),
+            ("arab", "Arabic"),
+            ("arabic", "Arabic"),
+            ("armenian", "Armenian"),
+            ("armi", "Imperial_Aramaic"),
+            ("armn", "Armenian"),
+            ("avestan", "Avestan"),
+            ("avst", "Avestan"),
+            ("bali", "Balinese"),
+            ("balinese", "Balinese"),
+            ("bamu", "Bamum"),
+            ("bamum", "Bamum"),
+            ("bass", "Bassa_Vah"),
+            ("bassavah", "Bassa_Vah"),
+            ("batak", "Batak"),
+            ("batk", "Batak"),
+            ("beng", "Bengali"),
+            ("bengali", "Bengali"),
+            ("bhaiksuki", "Bhaiksuki"),
+            ("bhks", "Bhaiksuki"),
+            ("bopo", "Bopomofo"),
+            ("bopomofo", "Bopomofo"),
+            ("brah", "Brahmi"),
+            ("brahmi", "Brahmi"),
+            ("brai", "Braille"),
+            ("braille", "Braille"),
+            ("bugi", "Buginese"),
+            ("buginese", "Buginese"),
+            ("buhd", "Buhid"),
+            ("buhid", "Buhid"),
+            ("cakm", "Chakma"),
+            ("canadianaboriginal", "Canadian_Aboriginal"),
+            ("cans", "Canadian_Aboriginal"),
+            ("cari", "Carian"),
+            ("carian", "Carian"),
+            ("caucasianalbanian", "Caucasian_Albanian"),
+            ("chakma", "Chakma"),
+            ("cham", "Cham"),
+            ("cher", "Cherokee"),
+            ("cherokee", "Cherokee"),
+            ("chorasmian", "Chorasmian"),
+            ("chrs", "Chorasmian"),
+            ("common", "Common"),
+            ("copt", "Coptic"),
+            ("coptic", "Coptic"),
+            ("cpmn", "Cypro_Minoan"),
+            ("cprt", "Cypriot"),
+            ("cuneiform", "Cuneiform"),
+            ("cypriot", "Cypriot"),
+            ("cyprominoan", "Cypro_Minoan"),
+            ("cyrillic", "Cyrillic"),
+            ("cyrl", "Cyrillic"),
+            ("deseret", "Deseret"),
+            ("deva", "Devanagari"),
+            ("devanagari", "Devanagari"),
+            ("diak", "Dives_Akuru"),
+            ("divesakuru", "Dives_Akuru"),
+            ("dogr", "Dogra"),
+            ("dogra", "Dogra"),
+            ("dsrt", "Deseret"),
+            ("dupl", "Duployan"),
+            ("duployan", "Duployan"),
+            ("egyp", "Egyptian_Hieroglyphs"),
+            ("egyptianhieroglyphs", "Egyptian_Hieroglyphs"),
+            ("elba", "Elbasan"),
+            ("elbasan", "Elbasan"),
+            ("elym", "Elymaic"),
+            ("elymaic", "Elymaic"),
+            ("ethi", "Ethiopic"),
+            ("ethiopic", "Ethiopic"),
+            ("geor", "Georgian"),
+            ("georgian", "Georgian"),
+            ("glag", "Glagolitic"),
+            ("glagolitic", "Glagolitic"),
+            ("gong", "Gunjala_Gondi"),
+            ("gonm", "Masaram_Gondi"),
+            ("goth", "Gothic"),
+            ("gothic", "Gothic"),
+            ("gran", "Grantha"),
+            ("grantha", "Grantha"),
+            ("greek", "Greek"),
+            ("grek", "Greek"),
+            ("gujarati", "Gujarati"),
+            ("gujr", "Gujarati"),
+            ("gunjalagondi", "Gunjala_Gondi"),
+            ("gurmukhi", "Gurmukhi"),
+            ("guru", "Gurmukhi"),
+            ("han", "Han"),
+            ("hang", "Hangul"),
+            ("hangul", "Hangul"),
+            ("hani", "Han"),
+            ("hanifirohingya", "Hanifi_Rohingya"),
+            ("hano", "Hanunoo"),
+            ("hanunoo", "Hanunoo"),
+            ("hatr", "Hatran"),
+            ("hatran", "Hatran"),
+            ("hebr", "Hebrew"),
+            ("hebrew", "Hebrew"),
+            ("hira", "Hiragana"),
+            ("hiragana", "Hiragana"),
+            ("hluw", "Anatolian_Hieroglyphs"),
+            ("hmng", "Pahawh_Hmong"),
+            ("hmnp", "Nyiakeng_Puachue_Hmong"),
+            ("hrkt", "Katakana_Or_Hiragana"),
+            ("hung", "Old_Hungarian"),
+            ("imperialaramaic", "Imperial_Aramaic"),
+            ("inherited", "Inherited"),
+            ("inscriptionalpahlavi", "Inscriptional_Pahlavi"),
+            ("inscriptionalparthian", "Inscriptional_Parthian"),
+            ("ital", "Old_Italic"),
+            ("java", "Javanese"),
+            ("javanese", "Javanese"),
+            ("kaithi", "Kaithi"),
+            ("kali", "Kayah_Li"),
+            ("kana", "Katakana"),
+            ("kannada", "Kannada"),
+            ("katakana", "Katakana"),
+            ("katakanaorhiragana", "Katakana_Or_Hiragana"),
+            ("kawi", "Kawi"),
+            ("kayahli", "Kayah_Li"),
+            ("khar", "Kharoshthi"),
+            ("kharoshthi", "Kharoshthi"),
+            ("khitansmallscript", "Khitan_Small_Script"),
+            ("khmer", "Khmer"),
+            ("khmr", "Khmer"),
+            ("khoj", "Khojki"),
+            ("khojki", "Khojki"),
+            ("khudawadi", "Khudawadi"),
+            ("kits", "Khitan_Small_Script"),
+            ("knda", "Kannada"),
+            ("kthi", "Kaithi"),
+            ("lana", "Tai_Tham"),
+            ("lao", "Lao"),
+            ("laoo", "Lao"),
+            ("latin", "Latin"),
+            ("latn", "Latin"),
+            ("lepc", "Lepcha"),
+            ("lepcha", "Lepcha"),
+            ("limb", "Limbu"),
+            ("limbu", "Limbu"),
+            ("lina", "Linear_A"),
+            ("linb", "Linear_B"),
+            ("lineara", "Linear_A"),
+            ("linearb", "Linear_B"),
+            ("lisu", "Lisu"),
+            ("lyci", "Lycian"),
+            ("lycian", "Lycian"),
+            ("lydi", "Lydian"),
+            ("lydian", "Lydian"),
+            ("mahajani", "Mahajani"),
+            ("mahj", "Mahajani"),
+            ("maka", "Makasar"),
+            ("makasar", "Makasar"),
+            ("malayalam", "Malayalam"),
+            ("mand", "Mandaic"),
+            ("mandaic", "Mandaic"),
+            ("mani", "Manichaean"),
+            ("manichaean", "Manichaean"),
+            ("marc", "Marchen"),
+            ("marchen", "Marchen"),
+            ("masaramgondi", "Masaram_Gondi"),
+            ("medefaidrin", "Medefaidrin"),
+            ("medf", "Medefaidrin"),
+            ("meeteimayek", "Meetei_Mayek"),
+            ("mend", "Mende_Kikakui"),
+            ("mendekikakui", "Mende_Kikakui"),
+            ("merc", "Meroitic_Cursive"),
+            ("mero", "Meroitic_Hieroglyphs"),
+            ("meroiticcursive", "Meroitic_Cursive"),
+            ("meroitichieroglyphs", "Meroitic_Hieroglyphs"),
+            ("miao", "Miao"),
+            ("mlym", "Malayalam"),
+            ("modi", "Modi"),
+            ("mong", "Mongolian"),
+            ("mongolian", "Mongolian"),
+            ("mro", "Mro"),
+            ("mroo", "Mro"),
+            ("mtei", "Meetei_Mayek"),
+            ("mult", "Multani"),
+            ("multani", "Multani"),
+            ("myanmar", "Myanmar"),
+            ("mymr", "Myanmar"),
+            ("nabataean", "Nabataean"),
+            ("nagm", "Nag_Mundari"),
+            ("nagmundari", "Nag_Mundari"),
+            ("nand", "Nandinagari"),
+            ("nandinagari", "Nandinagari"),
+            ("narb", "Old_North_Arabian"),
+            ("nbat", "Nabataean"),
+            ("newa", "Newa"),
+            ("newtailue", "New_Tai_Lue"),
+            ("nko", "Nko"),
+            ("nkoo", "Nko"),
+            ("nshu", "Nushu"),
+            ("nushu", "Nushu"),
+            ("nyiakengpuachuehmong", "Nyiakeng_Puachue_Hmong"),
+            ("ogam", "Ogham"),
+            ("ogham", "Ogham"),
+            ("olchiki", "Ol_Chiki"),
+            ("olck", "Ol_Chiki"),
+            ("oldhungarian", "Old_Hungarian"),
+            ("olditalic", "Old_Italic"),
+            ("oldnortharabian", "Old_North_Arabian"),
+            ("oldpermic", "Old_Permic"),
+            ("oldpersian", "Old_Persian"),
+            ("oldsogdian", "Old_Sogdian"),
+            ("oldsoutharabian", "Old_South_Arabian"),
+            ("oldturkic", "Old_Turkic"),
+            ("olduyghur", "Old_Uyghur"),
+            ("oriya", "Oriya"),
+            ("orkh", "Old_Turkic"),
+            ("orya", "Oriya"),
+            ("osage", "Osage"),
+            ("osge", "Osage"),
+            ("osma", "Osmanya"),
+            ("osmanya", "Osmanya"),
+            ("ougr", "Old_Uyghur"),
+            ("pahawhhmong", "Pahawh_Hmong"),
+            ("palm", "Palmyrene"),
+            ("palmyrene", "Palmyrene"),
+            ("pauc", "Pau_Cin_Hau"),
+            ("paucinhau", "Pau_Cin_Hau"),
+            ("perm", "Old_Permic"),
+            ("phag", "Phags_Pa"),
+            ("phagspa", "Phags_Pa"),
+            ("phli", "Inscriptional_Pahlavi"),
+            ("phlp", "Psalter_Pahlavi"),
+            ("phnx", "Phoenician"),
+            ("phoenician", "Phoenician"),
+            ("plrd", "Miao"),
+            ("prti", "Inscriptional_Parthian"),
+            ("psalterpahlavi", "Psalter_Pahlavi"),
+            ("qaac", "Coptic"),
+            ("qaai", "Inherited"),
+            ("rejang", "Rejang"),
+            ("rjng", "Rejang"),
+            ("rohg", "Hanifi_Rohingya"),
+            ("runic", "Runic"),
+            ("runr", "Runic"),
+            ("samaritan", "Samaritan"),
+            ("samr", "Samaritan"),
+            ("sarb", "Old_South_Arabian"),
+            ("saur", "Saurashtra"),
+            ("saurashtra", "Saurashtra"),
+            ("sgnw", "SignWriting"),
+            ("sharada", "Sharada"),
+            ("shavian", "Shavian"),
+            ("shaw", "Shavian"),
+            ("shrd", "Sharada"),
+            ("sidd", "Siddham"),
+            ("siddham", "Siddham"),
+            ("signwriting", "SignWriting"),
+            ("sind", "Khudawadi"),
+            ("sinh", "Sinhala"),
+            ("sinhala", "Sinhala"),
+            ("sogd", "Sogdian"),
+            ("sogdian", "Sogdian"),
+            ("sogo", "Old_Sogdian"),
+            ("sora", "Sora_Sompeng"),
+            ("sorasompeng", "Sora_Sompeng"),
+            ("soyo", "Soyombo"),
+            ("soyombo", "Soyombo"),
+            ("sund", "Sundanese"),
+            ("sundanese", "Sundanese"),
+            ("sylo", "Syloti_Nagri"),
+            ("sylotinagri", "Syloti_Nagri"),
+            ("syrc", "Syriac"),
+            ("syriac", "Syriac"),
+            ("tagalog", "Tagalog"),
+            ("tagb", "Tagbanwa"),
+            ("tagbanwa", "Tagbanwa"),
+            ("taile", "Tai_Le"),
+            ("taitham", "Tai_Tham"),
+            ("taiviet", "Tai_Viet"),
+            ("takr", "Takri"),
+            ("takri", "Takri"),
+            ("tale", "Tai_Le"),
+            ("talu", "New_Tai_Lue"),
+            ("tamil", "Tamil"),
+            ("taml", "Tamil"),
+            ("tang", "Tangut"),
+            ("tangsa", "Tangsa"),
+            ("tangut", "Tangut"),
+            ("tavt", "Tai_Viet"),
+            ("telu", "Telugu"),
+            ("telugu", "Telugu"),
+            ("tfng", "Tifinagh"),
+            ("tglg", "Tagalog"),
+            ("thaa", "Thaana"),
+            ("thaana", "Thaana"),
+            ("thai", "Thai"),
+            ("tibetan", "Tibetan"),
+            ("tibt", "Tibetan"),
+            ("tifinagh", "Tifinagh"),
+            ("tirh", "Tirhuta"),
+            ("tirhuta", "Tirhuta"),
+            ("tnsa", "Tangsa"),
+            ("toto", "Toto"),
+            ("ugar", "Ugaritic"),
+            ("ugaritic", "Ugaritic"),
+            ("unknown", "Unknown"),
+            ("vai", "Vai"),
+            ("vaii", "Vai"),
+            ("vith", "Vithkuqi"),
+            ("vithkuqi", "Vithkuqi"),
+            ("wancho", "Wancho"),
+            ("wara", "Warang_Citi"),
+            ("warangciti", "Warang_Citi"),
+            ("wcho", "Wancho"),
+            ("xpeo", "Old_Persian"),
+            ("xsux", "Cuneiform"),
+            ("yezi", "Yezidi"),
+            ("yezidi", "Yezidi"),
+            ("yi", "Yi"),
+            ("yiii", "Yi"),
+            ("zanabazarsquare", "Zanabazar_Square"),
+            ("zanb", "Zanabazar_Square"),
+            ("zinh", "Inherited"),
+            ("zyyy", "Common"),
+            ("zzzz", "Unknown"),
+        ],
+    ),
+    (
+        "Script_Extensions",
+        &[
+            ("adlam", "Adlam"),
+            ("adlm", "Adlam"),
+            ("aghb", "Caucasian_Albanian"),
+            ("ahom", "Ahom"),
+            ("anatolianhieroglyphs", "Anatolian_Hieroglyphs"),
+            ("arab", "Arabic"),
+            ("arabic", "Arabic"),
+            ("armenian", "Armenian"),
+            ("armi", "Imperial_Aramaic"),
+            ("armn", "Armenian"),
+            ("avestan", "Avestan"),
+            ("avst", "Avestan"),
+            ("bali", "Balinese"),
+            ("balinese", "Balinese"),
+            ("bamu", "Bamum"),
+            ("bamum", "Bamum"),
+            ("bass", "Bassa_Vah"),
+            ("bassavah", "Bassa_Vah"),
+            ("batak", "Batak"),
+            ("batk", "Batak"),
+            ("beng", "Bengali"),
+            ("bengali", "Bengali"),
+            ("bhaiksuki", "Bhaiksuki"),
+            ("bhks", "Bhaiksuki"),
+            ("bopo", "Bopomofo"),
+            ("bopomofo", "Bopomofo"),
+            ("brah", "Brahmi"),
+            ("brahmi", "Brahmi"),
+            ("brai", "Braille"),
+            ("braille", "Braille"),
+            ("bugi", "Buginese"),
+            ("buginese", "Buginese"),
+            ("buhd", "Buhid"),
+            ("buhid", "Buhid"),
+            ("cakm", "Chakma"),
+            ("canadianaboriginal", "Canadian_Aboriginal"),
+            ("cans", "Canadian_Aboriginal"),
+            ("cari", "Carian"),
+            ("carian", "Carian"),
+            ("caucasianalbanian", "Caucasian_Albanian"),
+            ("chakma", "Chakma"),
+            ("cham", "Cham"),
+            ("cher", "Cherokee"),
+            ("cherokee", "Cherokee"),
+            ("chorasmian", "Chorasmian"),
+            ("chrs", "Chorasmian"),
+            ("common", "Common"),
+            ("copt", "Coptic"),
+            ("coptic", "Coptic"),
+            ("cpmn", "Cypro_Minoan"),
+            ("cprt", "Cypriot"),
+            ("cuneiform", "Cuneiform"),
+            ("cypriot", "Cypriot"),
+            ("cyprominoan", "Cypro_Minoan"),
+            ("cyrillic", "Cyrillic"),
+            ("cyrl", "Cyrillic"),
+            ("deseret", "Deseret"),
+            ("deva", "Devanagari"),
+            ("devanagari", "Devanagari"),
+            ("diak", "Dives_Akuru"),
+            ("divesakuru", "Dives_Akuru"),
+            ("dogr", "Dogra"),
+            ("dogra", "Dogra"),
+            ("dsrt", "Deseret"),
+            ("dupl", "Duployan"),
+            ("duployan", "Duployan"),
+            ("egyp", "Egyptian_Hieroglyphs"),
+            ("egyptianhieroglyphs", "Egyptian_Hieroglyphs"),
+            ("elba", "Elbasan"),
+            ("elbasan", "Elbasan"),
+            ("elym", "Elymaic"),
+            ("elymaic", "Elymaic"),
+            ("ethi", "Ethiopic"),
+            ("ethiopic", "Ethiopic"),
+            ("geor", "Georgian"),
+            ("georgian", "Georgian"),
+            ("glag", "Glagolitic"),
+            ("glagolitic", "Glagolitic"),
+            ("gong", "Gunjala_Gondi"),
+            ("gonm", "Masaram_Gondi"),
+            ("goth", "Gothic"),
+            ("gothic", "Gothic"),
+            ("gran", "Grantha"),
+            ("grantha", "Grantha"),
+            ("greek", "Greek"),
+            ("grek", "Greek"),
+            ("gujarati", "Gujarati"),
+            ("gujr", "Gujarati"),
+            ("gunjalagondi", "Gunjala_Gondi"),
+            ("gurmukhi", "Gurmukhi"),
+            ("guru", "Gurmukhi"),
+            ("han", "Han"),
+            ("hang", "Hangul"),
+            ("hangul", "Hangul"),
+            ("hani", "Han"),
+            ("hanifirohingya", "Hanifi_Rohingya"),
+            ("hano", "Hanunoo"),
+            ("hanunoo", "Hanunoo"),
+            ("hatr", "Hatran"),
+            ("hatran", "Hatran"),
+            ("hebr", "Hebrew"),
+            ("hebrew", "Hebrew"),
+            ("hira", "Hiragana"),
+            ("hiragana", "Hiragana"),
+            ("hluw", "Anatolian_Hieroglyphs"),
+            ("hmng", "Pahawh_Hmong"),
+            ("hmnp", "Nyiakeng_Puachue_Hmong"),
+            ("hrkt", "Katakana_Or_Hiragana"),
+            ("hung", "Old_Hungarian"),
+            ("imperialaramaic", "Imperial_Aramaic"),
+            ("inherited", "Inherited"),
+            ("inscriptionalpahlavi", "Inscriptional_Pahlavi"),
+            ("inscriptionalparthian", "Inscriptional_Parthian"),
+            ("ital", "Old_Italic"),
+            ("java", "Javanese"),
+            ("javanese", "Javanese"),
+            ("kaithi", "Kaithi"),
+            ("kali", "Kayah_Li"),
+            ("kana", "Katakana"),
+            ("kannada", "Kannada"),
+            ("katakana", "Katakana"),
+            ("katakanaorhiragana", "Katakana_Or_Hiragana"),
+            ("kawi", "Kawi"),
+            ("kayahli", "Kayah_Li"),
+            ("khar", "Kharoshthi"),
+            ("kharoshthi", "Kharoshthi"),
+            ("khitansmallscript", "Khitan_Small_Script"),
+            ("khmer", "Khmer"),
+            ("khmr", "Khmer"),
+            ("khoj", "Khojki"),
+            ("khojki", "Khojki"),
+            ("khudawadi", "Khudawadi"),
+            ("kits", "Khitan_Small_Script"),
+            ("knda", "Kannada"),
+            ("kthi", "Kaithi"),
+            ("lana", "Tai_Tham"),
+            ("lao", "Lao"),
+            ("laoo", "Lao"),
+            ("latin", "Latin"),
+            ("latn", "Latin"),
+            ("lepc", "Lepcha"),
+            ("lepcha", "Lepcha"),
+            ("limb", "Limbu"),
+            ("limbu", "Limbu"),
+            ("lina", "Linear_A"),
+            ("linb", "Linear_B"),
+            ("lineara", "Linear_A"),
+            ("linearb", "Linear_B"),
+            ("lisu", "Lisu"),
+            ("lyci", "Lycian"),
+            ("lycian", "Lycian"),
+            ("lydi", "Lydian"),
+            ("lydian", "Lydian"),
+            ("mahajani", "Mahajani"),
+            ("mahj", "Mahajani"),
+            ("maka", "Makasar"),
+            ("makasar", "Makasar"),
+            ("malayalam", "Malayalam"),
+            ("mand", "Mandaic"),
+            ("mandaic", "Mandaic"),
+            ("mani", "Manichaean"),
+            ("manichaean", "Manichaean"),
+            ("marc", "Marchen"),
+            ("marchen", "Marchen"),
+            ("masaramgondi", "Masaram_Gondi"),
+            ("medefaidrin", "Medefaidrin"),
+            ("medf", "Medefaidrin"),
+            ("meeteimayek", "Meetei_Mayek"),
+            ("mend", "Mende_Kikakui"),
+            ("mendekikakui", "Mende_Kikakui"),
+            ("merc", "Meroitic_Cursive"),
+            ("mero", "Meroitic_Hieroglyphs"),
+            ("meroiticcursive", "Meroitic_Cursive"),
+            ("meroitichieroglyphs", "Meroitic_Hieroglyphs"),
+            ("miao", "Miao"),
+            ("mlym", "Malayalam"),
+            ("modi", "Modi"),
+            ("mong", "Mongolian"),
+            ("mongolian", "Mongolian"),
+            ("mro", "Mro"),
+            ("mroo", "Mro"),
+            ("mtei", "Meetei_Mayek"),
+            ("mult", "Multani"),
+            ("multani", "Multani"),
+            ("myanmar", "Myanmar"),
+            ("mymr", "Myanmar"),
+            ("nabataean", "Nabataean"),
+            ("nagm", "Nag_Mundari"),
+            ("nagmundari", "Nag_Mundari"),
+            ("nand", "Nandinagari"),
+            ("nandinagari", "Nandinagari"),
+            ("narb", "Old_North_Arabian"),
+            ("nbat", "Nabataean"),
+            ("newa", "Newa"),
+            ("newtailue", "New_Tai_Lue"),
+            ("nko", "Nko"),
+            ("nkoo", "Nko"),
+            ("nshu", "Nushu"),
+            ("nushu", "Nushu"),
+            ("nyiakengpuachuehmong", "Nyiakeng_Puachue_Hmong"),
+            ("ogam", "Ogham"),
+            ("ogham", "Ogham"),
+            ("olchiki", "Ol_Chiki"),
+            ("olck", "Ol_Chiki"),
+            ("oldhungarian", "Old_Hungarian"),
+            ("olditalic", "Old_Italic"),
+            ("oldnortharabian", "Old_North_Arabian"),
+            ("oldpermic", "Old_Permic"),
+            ("oldpersian", "Old_Persian"),
+            ("oldsogdian", "Old_Sogdian"),
+            ("oldsoutharabian", "Old_South_Arabian"),
+            ("oldturkic", "Old_Turkic"),
+            ("olduyghur", "Old_Uyghur"),
+            ("oriya", "Oriya"),
+            ("orkh", "Old_Turkic"),
+            ("orya", "Oriya"),
+            ("osage", "Osage"),
+            ("osge", "Osage"),
+            ("osma", "Osmanya"),
+            ("osmanya", "Osmanya"),
+            ("ougr", "Old_Uyghur"),
+            ("pahawhhmong", "Pahawh_Hmong"),
+            ("palm", "Palmyrene"),
+            ("palmyrene", "Palmyrene"),
+            ("pauc", "Pau_Cin_Hau"),
+            ("paucinhau", "Pau_Cin_Hau"),
+            ("perm", "Old_Permic"),
+            ("phag", "Phags_Pa"),
+            ("phagspa", "Phags_Pa"),
+            ("phli", "Inscriptional_Pahlavi"),
+            ("phlp", "Psalter_Pahlavi"),
+            ("phnx", "Phoenician"),
+            ("phoenician", "Phoenician"),
+            ("plrd", "Miao"),
+            ("prti", "Inscriptional_Parthian"),
+            ("psalterpahlavi", "Psalter_Pahlavi"),
+            ("qaac", "Coptic"),
+            ("qaai", "Inherited"),
+            ("rejang", "Rejang"),
+            ("rjng", "Rejang"),
+            ("rohg", "Hanifi_Rohingya"),
+            ("runic", "Runic"),
+            ("runr", "Runic"),
+            ("samaritan", "Samaritan"),
+            ("samr", "Samaritan"),
+            ("sarb", "Old_South_Arabian"),
+            ("saur", "Saurashtra"),
+            ("saurashtra", "Saurashtra"),
+            ("sgnw", "SignWriting"),
+            ("sharada", "Sharada"),
+            ("shavian", "Shavian"),
+            ("shaw", "Shavian"),
+            ("shrd", "Sharada"),
+            ("sidd", "Siddham"),
+            ("siddham", "Siddham"),
+            ("signwriting", "SignWriting"),
+            ("sind", "Khudawadi"),
+            ("sinh", "Sinhala"),
+            ("sinhala", "Sinhala"),
+            ("sogd", "Sogdian"),
+            ("sogdian", "Sogdian"),
+            ("sogo", "Old_Sogdian"),
+            ("sora", "Sora_Sompeng"),
+            ("sorasompeng", "Sora_Sompeng"),
+            ("soyo", "Soyombo"),
+            ("soyombo", "Soyombo"),
+            ("sund", "Sundanese"),
+            ("sundanese", "Sundanese"),
+            ("sylo", "Syloti_Nagri"),
+            ("sylotinagri", "Syloti_Nagri"),
+            ("syrc", "Syriac"),
+            ("syriac", "Syriac"),
+            ("tagalog", "Tagalog"),
+            ("tagb", "Tagbanwa"),
+            ("tagbanwa", "Tagbanwa"),
+            ("taile", "Tai_Le"),
+            ("taitham", "Tai_Tham"),
+            ("taiviet", "Tai_Viet"),
+            ("takr", "Takri"),
+            ("takri", "Takri"),
+            ("tale", "Tai_Le"),
+            ("talu", "New_Tai_Lue"),
+            ("tamil", "Tamil"),
+            ("taml", "Tamil"),
+            ("tang", "Tangut"),
+            ("tangsa", "Tangsa"),
+            ("tangut", "Tangut"),
+            ("tavt", "Tai_Viet"),
+            ("telu", "Telugu"),
+            ("telugu", "Telugu"),
+            ("tfng", "Tifinagh"),
+            ("tglg", "Tagalog"),
+            ("thaa", "Thaana"),
+            ("thaana", "Thaana"),
+            ("thai", "Thai"),
+            ("tibetan", "Tibetan"),
+            ("tibt", "Tibetan"),
+            ("tifinagh", "Tifinagh"),
+            ("tirh", "Tirhuta"),
+            ("tirhuta", "Tirhuta"),
+            ("tnsa", "Tangsa"),
+            ("toto", "Toto"),
+            ("ugar", "Ugaritic"),
+            ("ugaritic", "Ugaritic"),
+            ("unknown", "Unknown"),
+            ("vai", "Vai"),
+            ("vaii", "Vai"),
+            ("vith", "Vithkuqi"),
+            ("vithkuqi", "Vithkuqi"),
+            ("wancho", "Wancho"),
+            ("wara", "Warang_Citi"),
+            ("warangciti", "Warang_Citi"),
+            ("wcho", "Wancho"),
+            ("xpeo", "Old_Persian"),
+            ("xsux", "Cuneiform"),
+            ("yezi", "Yezidi"),
+            ("yezidi", "Yezidi"),
+            ("yi", "Yi"),
+            ("yiii", "Yi"),
+            ("zanabazarsquare", "Zanabazar_Square"),
+            ("zanb", "Zanabazar_Square"),
+            ("zinh", "Inherited"),
+            ("zyyy", "Common"),
+            ("zzzz", "Unknown"),
+        ],
+    ),
+    (
+        "Sentence_Break",
+        &[
+            ("at", "ATerm"),
+            ("aterm", "ATerm"),
+            ("cl", "Close"),
+            ("close", "Close"),
+            ("cr", "CR"),
+            ("ex", "Extend"),
+            ("extend", "Extend"),
+            ("fo", "Format"),
+            ("format", "Format"),
+            ("le", "OLetter"),
+            ("lf", "LF"),
+            ("lo", "Lower"),
+            ("lower", "Lower"),
+            ("nu", "Numeric"),
+            ("numeric", "Numeric"),
+            ("oletter", "OLetter"),
+            ("other", "Other"),
+            ("sc", "SContinue"),
+            ("scontinue", "SContinue"),
+            ("se", "Sep"),
+            ("sep", "Sep"),
+            ("sp", "Sp"),
+            ("st", "STerm"),
+            ("sterm", "STerm"),
+            ("up", "Upper"),
+            ("upper", "Upper"),
+            ("xx", "Other"),
+        ],
+    ),
+    (
+        "Word_Break",
+        &[
+            ("aletter", "ALetter"),
+            ("cr", "CR"),
+            ("doublequote", "Double_Quote"),
+            ("dq", "Double_Quote"),
+            ("eb", "E_Base"),
+            ("ebase", "E_Base"),
+            ("ebasegaz", "E_Base_GAZ"),
+            ("ebg", "E_Base_GAZ"),
+            ("em", "E_Modifier"),
+            ("emodifier", "E_Modifier"),
+            ("ex", "ExtendNumLet"),
+            ("extend", "Extend"),
+            ("extendnumlet", "ExtendNumLet"),
+            ("fo", "Format"),
+            ("format", "Format"),
+            ("gaz", "Glue_After_Zwj"),
+            ("glueafterzwj", "Glue_After_Zwj"),
+            ("hebrewletter", "Hebrew_Letter"),
+            ("hl", "Hebrew_Letter"),
+            ("ka", "Katakana"),
+            ("katakana", "Katakana"),
+            ("le", "ALetter"),
+            ("lf", "LF"),
+            ("mb", "MidNumLet"),
+            ("midletter", "MidLetter"),
+            ("midnum", "MidNum"),
+            ("midnumlet", "MidNumLet"),
+            ("ml", "MidLetter"),
+            ("mn", "MidNum"),
+            ("newline", "Newline"),
+            ("nl", "Newline"),
+            ("nu", "Numeric"),
+            ("numeric", "Numeric"),
+            ("other", "Other"),
+            ("regionalindicator", "Regional_Indicator"),
+            ("ri", "Regional_Indicator"),
+            ("singlequote", "Single_Quote"),
+            ("sq", "Single_Quote"),
+            ("wsegspace", "WSegSpace"),
+            ("xx", "Other"),
+            ("zwj", "ZWJ"),
+        ],
+    ),
+];
diff --git a/crates/regex-syntax/src/unicode_tables/script.rs b/crates/regex-syntax/src/unicode_tables/script.rs
new file mode 100644
index 0000000..cc5c400
--- /dev/null
+++ b/crates/regex-syntax/src/unicode_tables/script.rs
@@ -0,0 +1,1263 @@
+// DO NOT EDIT THIS FILE. IT WAS AUTOMATICALLY GENERATED BY:
+//
+//   ucd-generate script ucd-15.0.0 --chars
+//
+// Unicode version: 15.0.0.
+//
+// ucd-generate 0.2.14 is available on crates.io.
+
+pub const BY_NAME: &'static [(&'static str, &'static [(char, char)])] = &[
+    ("Adlam", ADLAM),
+    ("Ahom", AHOM),
+    ("Anatolian_Hieroglyphs", ANATOLIAN_HIEROGLYPHS),
+    ("Arabic", ARABIC),
+    ("Armenian", ARMENIAN),
+    ("Avestan", AVESTAN),
+    ("Balinese", BALINESE),
+    ("Bamum", BAMUM),
+    ("Bassa_Vah", BASSA_VAH),
+    ("Batak", BATAK),
+    ("Bengali", BENGALI),
+    ("Bhaiksuki", BHAIKSUKI),
+    ("Bopomofo", BOPOMOFO),
+    ("Brahmi", BRAHMI),
+    ("Braille", BRAILLE),
+    ("Buginese", BUGINESE),
+    ("Buhid", BUHID),
+    ("Canadian_Aboriginal", CANADIAN_ABORIGINAL),
+    ("Carian", CARIAN),
+    ("Caucasian_Albanian", CAUCASIAN_ALBANIAN),
+    ("Chakma", CHAKMA),
+    ("Cham", CHAM),
+    ("Cherokee", CHEROKEE),
+    ("Chorasmian", CHORASMIAN),
+    ("Common", COMMON),
+    ("Coptic", COPTIC),
+    ("Cuneiform", CUNEIFORM),
+    ("Cypriot", CYPRIOT),
+    ("Cypro_Minoan", CYPRO_MINOAN),
+    ("Cyrillic", CYRILLIC),
+    ("Deseret", DESERET),
+    ("Devanagari", DEVANAGARI),
+    ("Dives_Akuru", DIVES_AKURU),
+    ("Dogra", DOGRA),
+    ("Duployan", DUPLOYAN),
+    ("Egyptian_Hieroglyphs", EGYPTIAN_HIEROGLYPHS),
+    ("Elbasan", ELBASAN),
+    ("Elymaic", ELYMAIC),
+    ("Ethiopic", ETHIOPIC),
+    ("Georgian", GEORGIAN),
+    ("Glagolitic", GLAGOLITIC),
+    ("Gothic", GOTHIC),
+    ("Grantha", GRANTHA),
+    ("Greek", GREEK),
+    ("Gujarati", GUJARATI),
+    ("Gunjala_Gondi", GUNJALA_GONDI),
+    ("Gurmukhi", GURMUKHI),
+    ("Han", HAN),
+    ("Hangul", HANGUL),
+    ("Hanifi_Rohingya", HANIFI_ROHINGYA),
+    ("Hanunoo", HANUNOO),
+    ("Hatran", HATRAN),
+    ("Hebrew", HEBREW),
+    ("Hiragana", HIRAGANA),
+    ("Imperial_Aramaic", IMPERIAL_ARAMAIC),
+    ("Inherited", INHERITED),
+    ("Inscriptional_Pahlavi", INSCRIPTIONAL_PAHLAVI),
+    ("Inscriptional_Parthian", INSCRIPTIONAL_PARTHIAN),
+    ("Javanese", JAVANESE),
+    ("Kaithi", KAITHI),
+    ("Kannada", KANNADA),
+    ("Katakana", KATAKANA),
+    ("Kawi", KAWI),
+    ("Kayah_Li", KAYAH_LI),
+    ("Kharoshthi", KHAROSHTHI),
+    ("Khitan_Small_Script", KHITAN_SMALL_SCRIPT),
+    ("Khmer", KHMER),
+    ("Khojki", KHOJKI),
+    ("Khudawadi", KHUDAWADI),
+    ("Lao", LAO),
+    ("Latin", LATIN),
+    ("Lepcha", LEPCHA),
+    ("Limbu", LIMBU),
+    ("Linear_A", LINEAR_A),
+    ("Linear_B", LINEAR_B),
+    ("Lisu", LISU),
+    ("Lycian", LYCIAN),
+    ("Lydian", LYDIAN),
+    ("Mahajani", MAHAJANI),
+    ("Makasar", MAKASAR),
+    ("Malayalam", MALAYALAM),
+    ("Mandaic", MANDAIC),
+    ("Manichaean", MANICHAEAN),
+    ("Marchen", MARCHEN),
+    ("Masaram_Gondi", MASARAM_GONDI),
+    ("Medefaidrin", MEDEFAIDRIN),
+    ("Meetei_Mayek", MEETEI_MAYEK),
+    ("Mende_Kikakui", MENDE_KIKAKUI),
+    ("Meroitic_Cursive", MEROITIC_CURSIVE),
+    ("Meroitic_Hieroglyphs", MEROITIC_HIEROGLYPHS),
+    ("Miao", MIAO),
+    ("Modi", MODI),
+    ("Mongolian", MONGOLIAN),
+    ("Mro", MRO),
+    ("Multani", MULTANI),
+    ("Myanmar", MYANMAR),
+    ("Nabataean", NABATAEAN),
+    ("Nag_Mundari", NAG_MUNDARI),
+    ("Nandinagari", NANDINAGARI),
+    ("New_Tai_Lue", NEW_TAI_LUE),
+    ("Newa", NEWA),
+    ("Nko", NKO),
+    ("Nushu", NUSHU),
+    ("Nyiakeng_Puachue_Hmong", NYIAKENG_PUACHUE_HMONG),
+    ("Ogham", OGHAM),
+    ("Ol_Chiki", OL_CHIKI),
+    ("Old_Hungarian", OLD_HUNGARIAN),
+    ("Old_Italic", OLD_ITALIC),
+    ("Old_North_Arabian", OLD_NORTH_ARABIAN),
+    ("Old_Permic", OLD_PERMIC),
+    ("Old_Persian", OLD_PERSIAN),
+    ("Old_Sogdian", OLD_SOGDIAN),
+    ("Old_South_Arabian", OLD_SOUTH_ARABIAN),
+    ("Old_Turkic", OLD_TURKIC),
+    ("Old_Uyghur", OLD_UYGHUR),
+    ("Oriya", ORIYA),
+    ("Osage", OSAGE),
+    ("Osmanya", OSMANYA),
+    ("Pahawh_Hmong", PAHAWH_HMONG),
+    ("Palmyrene", PALMYRENE),
+    ("Pau_Cin_Hau", PAU_CIN_HAU),
+    ("Phags_Pa", PHAGS_PA),
+    ("Phoenician", PHOENICIAN),
+    ("Psalter_Pahlavi", PSALTER_PAHLAVI),
+    ("Rejang", REJANG),
+    ("Runic", RUNIC),
+    ("Samaritan", SAMARITAN),
+    ("Saurashtra", SAURASHTRA),
+    ("Sharada", SHARADA),
+    ("Shavian", SHAVIAN),
+    ("Siddham", SIDDHAM),
+    ("SignWriting", SIGNWRITING),
+    ("Sinhala", SINHALA),
+    ("Sogdian", SOGDIAN),
+    ("Sora_Sompeng", SORA_SOMPENG),
+    ("Soyombo", SOYOMBO),
+    ("Sundanese", SUNDANESE),
+    ("Syloti_Nagri", SYLOTI_NAGRI),
+    ("Syriac", SYRIAC),
+    ("Tagalog", TAGALOG),
+    ("Tagbanwa", TAGBANWA),
+    ("Tai_Le", TAI_LE),
+    ("Tai_Tham", TAI_THAM),
+    ("Tai_Viet", TAI_VIET),
+    ("Takri", TAKRI),
+    ("Tamil", TAMIL),
+    ("Tangsa", TANGSA),
+    ("Tangut", TANGUT),
+    ("Telugu", TELUGU),
+    ("Thaana", THAANA),
+    ("Thai", THAI),
+    ("Tibetan", TIBETAN),
+    ("Tifinagh", TIFINAGH),
+    ("Tirhuta", TIRHUTA),
+    ("Toto", TOTO),
+    ("Ugaritic", UGARITIC),
+    ("Vai", VAI),
+    ("Vithkuqi", VITHKUQI),
+    ("Wancho", WANCHO),
+    ("Warang_Citi", WARANG_CITI),
+    ("Yezidi", YEZIDI),
+    ("Yi", YI),
+    ("Zanabazar_Square", ZANABAZAR_SQUARE),
+];
+
+pub const ADLAM: &'static [(char, char)] =
+    &[('𞤀', '𞥋'), ('𞥐', '𞥙'), ('𞥞', '𞥟')];
+
+pub const AHOM: &'static [(char, char)] =
+    &[('𑜀', '𑜚'), ('\u{1171d}', '\u{1172b}'), ('𑜰', '𑝆')];
+
+pub const ANATOLIAN_HIEROGLYPHS: &'static [(char, char)] = &[('𔐀', '𔙆')];
+
+pub const ARABIC: &'static [(char, char)] = &[
+    ('\u{600}', '\u{604}'),
+    ('؆', '؋'),
+    ('؍', '\u{61a}'),
+    ('\u{61c}', '؞'),
+    ('ؠ', 'ؿ'),
+    ('ف', 'ي'),
+    ('\u{656}', 'ٯ'),
+    ('ٱ', '\u{6dc}'),
+    ('۞', 'ۿ'),
+    ('ݐ', 'ݿ'),
+    ('ࡰ', 'ࢎ'),
+    ('\u{890}', '\u{891}'),
+    ('\u{898}', '\u{8e1}'),
+    ('\u{8e3}', '\u{8ff}'),
+    ('ﭐ', '﯂'),
+    ('ﯓ', 'ﴽ'),
+    ('﵀', 'ﶏ'),
+    ('ﶒ', 'ﷇ'),
+    ('﷏', '﷏'),
+    ('ﷰ', '﷿'),
+    ('ﹰ', 'ﹴ'),
+    ('ﹶ', 'ﻼ'),
+    ('𐹠', '𐹾'),
+    ('\u{10efd}', '\u{10eff}'),
+    ('𞸀', '𞸃'),
+    ('𞸅', '𞸟'),
+    ('𞸡', '𞸢'),
+    ('𞸤', '𞸤'),
+    ('𞸧', '𞸧'),
+    ('𞸩', '𞸲'),
+    ('𞸴', '𞸷'),
+    ('𞸹', '𞸹'),
+    ('𞸻', '𞸻'),
+    ('𞹂', '𞹂'),
+    ('𞹇', '𞹇'),
+    ('𞹉', '𞹉'),
+    ('𞹋', '𞹋'),
+    ('𞹍', '𞹏'),
+    ('𞹑', '𞹒'),
+    ('𞹔', '𞹔'),
+    ('𞹗', '𞹗'),
+    ('𞹙', '𞹙'),
+    ('𞹛', '𞹛'),
+    ('𞹝', '𞹝'),
+    ('𞹟', '𞹟'),
+    ('𞹡', '𞹢'),
+    ('𞹤', '𞹤'),
+    ('𞹧', '𞹪'),
+    ('𞹬', '𞹲'),
+    ('𞹴', '𞹷'),
+    ('𞹹', '𞹼'),
+    ('𞹾', '𞹾'),
+    ('𞺀', '𞺉'),
+    ('𞺋', '𞺛'),
+    ('𞺡', '𞺣'),
+    ('𞺥', '𞺩'),
+    ('𞺫', '𞺻'),
+    ('𞻰', '𞻱'),
+];
+
+pub const ARMENIAN: &'static [(char, char)] =
+    &[('Ա', 'Ֆ'), ('ՙ', '֊'), ('֍', '֏'), ('ﬓ', 'ﬗ')];
+
+pub const AVESTAN: &'static [(char, char)] = &[('𐬀', '𐬵'), ('𐬹', '𐬿')];
+
+pub const BALINESE: &'static [(char, char)] = &[('\u{1b00}', 'ᭌ'), ('᭐', '᭾')];
+
+pub const BAMUM: &'static [(char, char)] = &[('ꚠ', '꛷'), ('𖠀', '𖨸')];
+
+pub const BASSA_VAH: &'static [(char, char)] =
+    &[('𖫐', '𖫭'), ('\u{16af0}', '𖫵')];
+
+pub const BATAK: &'static [(char, char)] = &[('ᯀ', '᯳'), ('᯼', '᯿')];
+
+pub const BENGALI: &'static [(char, char)] = &[
+    ('ঀ', 'ঃ'),
+    ('অ', 'ঌ'),
+    ('এ', 'ঐ'),
+    ('ও', 'ন'),
+    ('প', 'র'),
+    ('ল', 'ল'),
+    ('শ', 'হ'),
+    ('\u{9bc}', '\u{9c4}'),
+    ('ে', 'ৈ'),
+    ('ো', 'ৎ'),
+    ('\u{9d7}', '\u{9d7}'),
+    ('ড়', 'ঢ়'),
+    ('য়', '\u{9e3}'),
+    ('০', '\u{9fe}'),
+];
+
+pub const BHAIKSUKI: &'static [(char, char)] =
+    &[('𑰀', '𑰈'), ('𑰊', '\u{11c36}'), ('\u{11c38}', '𑱅'), ('𑱐', '𑱬')];
+
+pub const BOPOMOFO: &'static [(char, char)] =
+    &[('˪', '˫'), ('ㄅ', 'ㄯ'), ('ㆠ', 'ㆿ')];
+
+pub const BRAHMI: &'static [(char, char)] =
+    &[('𑀀', '𑁍'), ('𑁒', '𑁵'), ('\u{1107f}', '\u{1107f}')];
+
+pub const BRAILLE: &'static [(char, char)] = &[('⠀', '⣿')];
+
+pub const BUGINESE: &'static [(char, char)] = &[('ᨀ', '\u{1a1b}'), ('᨞', '᨟')];
+
+pub const BUHID: &'static [(char, char)] = &[('ᝀ', '\u{1753}')];
+
+pub const CANADIAN_ABORIGINAL: &'static [(char, char)] =
+    &[('᐀', 'ᙿ'), ('ᢰ', 'ᣵ'), ('𑪰', '𑪿')];
+
+pub const CARIAN: &'static [(char, char)] = &[('𐊠', '𐋐')];
+
+pub const CAUCASIAN_ALBANIAN: &'static [(char, char)] =
+    &[('𐔰', '𐕣'), ('𐕯', '𐕯')];
+
+pub const CHAKMA: &'static [(char, char)] =
+    &[('\u{11100}', '\u{11134}'), ('𑄶', '𑅇')];
+
+pub const CHAM: &'static [(char, char)] =
+    &[('ꨀ', '\u{aa36}'), ('ꩀ', 'ꩍ'), ('꩐', '꩙'), ('꩜', '꩟')];
+
+pub const CHEROKEE: &'static [(char, char)] =
+    &[('Ꭰ', 'Ᏽ'), ('ᏸ', 'ᏽ'), ('ꭰ', 'ꮿ')];
+
+pub const CHORASMIAN: &'static [(char, char)] = &[('𐾰', '𐿋')];
+
+pub const COMMON: &'static [(char, char)] = &[
+    ('\0', '@'),
+    ('[', '`'),
+    ('{', '©'),
+    ('«', '¹'),
+    ('»', '¿'),
+    ('×', '×'),
+    ('÷', '÷'),
+    ('ʹ', '˟'),
+    ('˥', '˩'),
+    ('ˬ', '˿'),
+    ('ʹ', 'ʹ'),
+    (';', ';'),
+    ('΅', '΅'),
+    ('·', '·'),
+    ('\u{605}', '\u{605}'),
+    ('،', '،'),
+    ('؛', '؛'),
+    ('؟', '؟'),
+    ('ـ', 'ـ'),
+    ('\u{6dd}', '\u{6dd}'),
+    ('\u{8e2}', '\u{8e2}'),
+    ('।', '॥'),
+    ('฿', '฿'),
+    ('࿕', '࿘'),
+    ('჻', '჻'),
+    ('᛫', '᛭'),
+    ('᜵', '᜶'),
+    ('᠂', '᠃'),
+    ('᠅', '᠅'),
+    ('᳓', '᳓'),
+    ('᳡', '᳡'),
+    ('ᳩ', 'ᳬ'),
+    ('ᳮ', 'ᳳ'),
+    ('ᳵ', '᳷'),
+    ('ᳺ', 'ᳺ'),
+    ('\u{2000}', '\u{200b}'),
+    ('\u{200e}', '\u{2064}'),
+    ('\u{2066}', '⁰'),
+    ('⁴', '⁾'),
+    ('₀', '₎'),
+    ('₠', '⃀'),
+    ('℀', '℥'),
+    ('℧', '℩'),
+    ('ℬ', 'ℱ'),
+    ('ℳ', '⅍'),
+    ('⅏', '⅟'),
+    ('↉', '↋'),
+    ('←', '␦'),
+    ('⑀', '⑊'),
+    ('①', '⟿'),
+    ('⤀', '⭳'),
+    ('⭶', '⮕'),
+    ('⮗', '⯿'),
+    ('⸀', '⹝'),
+    ('⿰', '⿻'),
+    ('\u{3000}', '〄'),
+    ('〆', '〆'),
+    ('〈', '〠'),
+    ('〰', '〷'),
+    ('〼', '〿'),
+    ('゛', '゜'),
+    ('゠', '゠'),
+    ('・', 'ー'),
+    ('㆐', '㆟'),
+    ('㇀', '㇣'),
+    ('㈠', '㉟'),
+    ('㉿', '㋏'),
+    ('㋿', '㋿'),
+    ('㍘', '㏿'),
+    ('䷀', '䷿'),
+    ('꜀', '꜡'),
+    ('ꞈ', '꞊'),
+    ('꠰', '꠹'),
+    ('꤮', '꤮'),
+    ('ꧏ', 'ꧏ'),
+    ('꭛', '꭛'),
+    ('꭪', '꭫'),
+    ('﴾', '﴿'),
+    ('︐', '︙'),
+    ('︰', '﹒'),
+    ('﹔', '﹦'),
+    ('﹨', '﹫'),
+    ('\u{feff}', '\u{feff}'),
+    ('！', '＠'),
+    ('［', '｀'),
+    ('｛', '･'),
+    ('ｰ', 'ｰ'),
+    ('\u{ff9e}', '\u{ff9f}'),
+    ('￠', '￦'),
+    ('￨', '￮'),
+    ('\u{fff9}', '�'),
+    ('𐄀', '𐄂'),
+    ('𐄇', '𐄳'),
+    ('𐄷', '𐄿'),
+    ('𐆐', '𐆜'),
+    ('𐇐', '𐇼'),
+    ('𐋡', '𐋻'),
+    ('\u{1bca0}', '\u{1bca3}'),
+    ('𜽐', '𜿃'),
+    ('𝀀', '𝃵'),
+    ('𝄀', '𝄦'),
+    ('𝄩', '𝅦'),
+    ('𝅪', '\u{1d17a}'),
+    ('𝆃', '𝆄'),
+    ('𝆌', '𝆩'),
+    ('𝆮', '𝇪'),
+    ('𝋀', '𝋓'),
+    ('𝋠', '𝋳'),
+    ('𝌀', '𝍖'),
+    ('𝍠', '𝍸'),
+    ('𝐀', '𝑔'),
+    ('𝑖', '𝒜'),
+    ('𝒞', '𝒟'),
+    ('𝒢', '𝒢'),
+    ('𝒥', '𝒦'),
+    ('𝒩', '𝒬'),
+    ('𝒮', '𝒹'),
+    ('𝒻', '𝒻'),
+    ('𝒽', '𝓃'),
+    ('𝓅', '𝔅'),
+    ('𝔇', '𝔊'),
+    ('𝔍', '𝔔'),
+    ('𝔖', '𝔜'),
+    ('𝔞', '𝔹'),
+    ('𝔻', '𝔾'),
+    ('𝕀', '𝕄'),
+    ('𝕆', '𝕆'),
+    ('𝕊', '𝕐'),
+    ('𝕒', '𝚥'),
+    ('𝚨', '𝟋'),
+    ('𝟎', '𝟿'),
+    ('𞱱', '𞲴'),
+    ('𞴁', '𞴽'),
+    ('🀀', '🀫'),
+    ('🀰', '🂓'),
+    ('🂠', '🂮'),
+    ('🂱', '🂿'),
+    ('🃁', '🃏'),
+    ('🃑', '🃵'),
+    ('🄀', '🆭'),
+    ('🇦', '🇿'),
+    ('🈁', '🈂'),
+    ('🈐', '🈻'),
+    ('🉀', '🉈'),
+    ('🉐', '🉑'),
+    ('🉠', '🉥'),
+    ('🌀', '🛗'),
+    ('🛜', '🛬'),
+    ('🛰', '🛼'),
+    ('🜀', '🝶'),
+    ('🝻', '🟙'),
+    ('🟠', '🟫'),
+    ('🟰', '🟰'),
+    ('🠀', '🠋'),
+    ('🠐', '🡇'),
+    ('🡐', '🡙'),
+    ('🡠', '🢇'),
+    ('🢐', '🢭'),
+    ('🢰', '🢱'),
+    ('🤀', '🩓'),
+    ('🩠', '🩭'),
+    ('🩰', '🩼'),
+    ('🪀', '🪈'),
+    ('🪐', '🪽'),
+    ('🪿', '🫅'),
+    ('🫎', '🫛'),
+    ('🫠', '🫨'),
+    ('🫰', '🫸'),
+    ('🬀', '🮒'),
+    ('🮔', '🯊'),
+    ('🯰', '🯹'),
+    ('\u{e0001}', '\u{e0001}'),
+    ('\u{e0020}', '\u{e007f}'),
+];
+
+pub const COPTIC: &'static [(char, char)] =
+    &[('Ϣ', 'ϯ'), ('Ⲁ', 'ⳳ'), ('⳹', '⳿')];
+
+pub const CUNEIFORM: &'static [(char, char)] =
+    &[('𒀀', '𒎙'), ('𒐀', '𒑮'), ('𒑰', '𒑴'), ('𒒀', '𒕃')];
+
+pub const CYPRIOT: &'static [(char, char)] =
+    &[('𐠀', '𐠅'), ('𐠈', '𐠈'), ('𐠊', '𐠵'), ('𐠷', '𐠸'), ('𐠼', '𐠼'), ('𐠿', '𐠿')];
+
+pub const CYPRO_MINOAN: &'static [(char, char)] = &[('𒾐', '𒿲')];
+
+pub const CYRILLIC: &'static [(char, char)] = &[
+    ('Ѐ', '\u{484}'),
+    ('\u{487}', 'ԯ'),
+    ('ᲀ', 'ᲈ'),
+    ('ᴫ', 'ᴫ'),
+    ('ᵸ', 'ᵸ'),
+    ('\u{2de0}', '\u{2dff}'),
+    ('Ꙁ', '\u{a69f}'),
+    ('\u{fe2e}', '\u{fe2f}'),
+    ('𞀰', '𞁭'),
+    ('\u{1e08f}', '\u{1e08f}'),
+];
+
+pub const DESERET: &'static [(char, char)] = &[('𐐀', '𐑏')];
+
+pub const DEVANAGARI: &'static [(char, char)] = &[
+    ('\u{900}', 'ॐ'),
+    ('\u{955}', '\u{963}'),
+    ('०', 'ॿ'),
+    ('\u{a8e0}', '\u{a8ff}'),
+    ('𑬀', '𑬉'),
+];
+
+pub const DIVES_AKURU: &'static [(char, char)] = &[
+    ('𑤀', '𑤆'),
+    ('𑤉', '𑤉'),
+    ('𑤌', '𑤓'),
+    ('𑤕', '𑤖'),
+    ('𑤘', '𑤵'),
+    ('𑤷', '𑤸'),
+    ('\u{1193b}', '𑥆'),
+    ('𑥐', '𑥙'),
+];
+
+pub const DOGRA: &'static [(char, char)] = &[('𑠀', '𑠻')];
+
+pub const DUPLOYAN: &'static [(char, char)] =
+    &[('𛰀', '𛱪'), ('𛱰', '𛱼'), ('𛲀', '𛲈'), ('𛲐', '𛲙'), ('𛲜', '𛲟')];
+
+pub const EGYPTIAN_HIEROGLYPHS: &'static [(char, char)] =
+    &[('𓀀', '\u{13455}')];
+
+pub const ELBASAN: &'static [(char, char)] = &[('𐔀', '𐔧')];
+
+pub const ELYMAIC: &'static [(char, char)] = &[('𐿠', '𐿶')];
+
+pub const ETHIOPIC: &'static [(char, char)] = &[
+    ('ሀ', 'ቈ'),
+    ('ቊ', 'ቍ'),
+    ('ቐ', 'ቖ'),
+    ('ቘ', 'ቘ'),
+    ('ቚ', 'ቝ'),
+    ('በ', 'ኈ'),
+    ('ኊ', 'ኍ'),
+    ('ነ', 'ኰ'),
+    ('ኲ', 'ኵ'),
+    ('ኸ', 'ኾ'),
+    ('ዀ', 'ዀ'),
+    ('ዂ', 'ዅ'),
+    ('ወ', 'ዖ'),
+    ('ዘ', 'ጐ'),
+    ('ጒ', 'ጕ'),
+    ('ጘ', 'ፚ'),
+    ('\u{135d}', '፼'),
+    ('ᎀ', '᎙'),
+    ('ⶀ', 'ⶖ'),
+    ('ⶠ', 'ⶦ'),
+    ('ⶨ', 'ⶮ'),
+    ('ⶰ', 'ⶶ'),
+    ('ⶸ', 'ⶾ'),
+    ('ⷀ', 'ⷆ'),
+    ('ⷈ', 'ⷎ'),
+    ('ⷐ', 'ⷖ'),
+    ('ⷘ', 'ⷞ'),
+    ('ꬁ', 'ꬆ'),
+    ('ꬉ', 'ꬎ'),
+    ('ꬑ', 'ꬖ'),
+    ('ꬠ', 'ꬦ'),
+    ('ꬨ', 'ꬮ'),
+    ('𞟠', '𞟦'),
+    ('𞟨', '𞟫'),
+    ('𞟭', '𞟮'),
+    ('𞟰', '𞟾'),
+];
+
+pub const GEORGIAN: &'static [(char, char)] = &[
+    ('Ⴀ', 'Ⴥ'),
+    ('Ⴧ', 'Ⴧ'),
+    ('Ⴭ', 'Ⴭ'),
+    ('ა', 'ჺ'),
+    ('ჼ', 'ჿ'),
+    ('Ა', 'Ჺ'),
+    ('Ჽ', 'Ჿ'),
+    ('ⴀ', 'ⴥ'),
+    ('ⴧ', 'ⴧ'),
+    ('ⴭ', 'ⴭ'),
+];
+
+pub const GLAGOLITIC: &'static [(char, char)] = &[
+    ('Ⰰ', 'ⱟ'),
+    ('\u{1e000}', '\u{1e006}'),
+    ('\u{1e008}', '\u{1e018}'),
+    ('\u{1e01b}', '\u{1e021}'),
+    ('\u{1e023}', '\u{1e024}'),
+    ('\u{1e026}', '\u{1e02a}'),
+];
+
+pub const GOTHIC: &'static [(char, char)] = &[('𐌰', '𐍊')];
+
+pub const GRANTHA: &'static [(char, char)] = &[
+    ('\u{11300}', '𑌃'),
+    ('𑌅', '𑌌'),
+    ('𑌏', '𑌐'),
+    ('𑌓', '𑌨'),
+    ('𑌪', '𑌰'),
+    ('𑌲', '𑌳'),
+    ('𑌵', '𑌹'),
+    ('\u{1133c}', '𑍄'),
+    ('𑍇', '𑍈'),
+    ('𑍋', '𑍍'),
+    ('𑍐', '𑍐'),
+    ('\u{11357}', '\u{11357}'),
+    ('𑍝', '𑍣'),
+    ('\u{11366}', '\u{1136c}'),
+    ('\u{11370}', '\u{11374}'),
+];
+
+pub const GREEK: &'static [(char, char)] = &[
+    ('Ͱ', 'ͳ'),
+    ('͵', 'ͷ'),
+    ('ͺ', 'ͽ'),
+    ('Ϳ', 'Ϳ'),
+    ('΄', '΄'),
+    ('Ά', 'Ά'),
+    ('Έ', 'Ί'),
+    ('Ό', 'Ό'),
+    ('Ύ', 'Ρ'),
+    ('Σ', 'ϡ'),
+    ('ϰ', 'Ͽ'),
+    ('ᴦ', 'ᴪ'),
+    ('ᵝ', 'ᵡ'),
+    ('ᵦ', 'ᵪ'),
+    ('ᶿ', 'ᶿ'),
+    ('ἀ', 'ἕ'),
+    ('Ἐ', 'Ἕ'),
+    ('ἠ', 'ὅ'),
+    ('Ὀ', 'Ὅ'),
+    ('ὐ', 'ὗ'),
+    ('Ὑ', 'Ὑ'),
+    ('Ὓ', 'Ὓ'),
+    ('Ὕ', 'Ὕ'),
+    ('Ὗ', 'ώ'),
+    ('ᾀ', 'ᾴ'),
+    ('ᾶ', 'ῄ'),
+    ('ῆ', 'ΐ'),
+    ('ῖ', 'Ί'),
+    ('῝', '`'),
+    ('ῲ', 'ῴ'),
+    ('ῶ', '῾'),
+    ('Ω', 'Ω'),
+    ('ꭥ', 'ꭥ'),
+    ('𐅀', '𐆎'),
+    ('𐆠', '𐆠'),
+    ('𝈀', '𝉅'),
+];
+
+pub const GUJARATI: &'static [(char, char)] = &[
+    ('\u{a81}', 'ઃ'),
+    ('અ', 'ઍ'),
+    ('એ', 'ઑ'),
+    ('ઓ', 'ન'),
+    ('પ', 'ર'),
+    ('લ', 'ળ'),
+    ('વ', 'હ'),
+    ('\u{abc}', '\u{ac5}'),
+    ('\u{ac7}', 'ૉ'),
+    ('ો', '\u{acd}'),
+    ('ૐ', 'ૐ'),
+    ('ૠ', '\u{ae3}'),
+    ('૦', '૱'),
+    ('ૹ', '\u{aff}'),
+];
+
+pub const GUNJALA_GONDI: &'static [(char, char)] = &[
+    ('𑵠', '𑵥'),
+    ('𑵧', '𑵨'),
+    ('𑵪', '𑶎'),
+    ('\u{11d90}', '\u{11d91}'),
+    ('𑶓', '𑶘'),
+    ('𑶠', '𑶩'),
+];
+
+pub const GURMUKHI: &'static [(char, char)] = &[
+    ('\u{a01}', 'ਃ'),
+    ('ਅ', 'ਊ'),
+    ('ਏ', 'ਐ'),
+    ('ਓ', 'ਨ'),
+    ('ਪ', 'ਰ'),
+    ('ਲ', 'ਲ਼'),
+    ('ਵ', 'ਸ਼'),
+    ('ਸ', 'ਹ'),
+    ('\u{a3c}', '\u{a3c}'),
+    ('ਾ', '\u{a42}'),
+    ('\u{a47}', '\u{a48}'),
+    ('\u{a4b}', '\u{a4d}'),
+    ('\u{a51}', '\u{a51}'),
+    ('ਖ਼', 'ੜ'),
+    ('ਫ਼', 'ਫ਼'),
+    ('੦', '੶'),
+];
+
+pub const HAN: &'static [(char, char)] = &[
+    ('⺀', '⺙'),
+    ('⺛', '⻳'),
+    ('⼀', '⿕'),
+    ('々', '々'),
+    ('〇', '〇'),
+    ('〡', '〩'),
+    ('〸', '〻'),
+    ('㐀', '䶿'),
+    ('一', '鿿'),
+    ('豈', '舘'),
+    ('並', '龎'),
+    ('𖿢', '𖿣'),
+    ('𖿰', '𖿱'),
+    ('𠀀', '𪛟'),
+    ('𪜀', '𫜹'),
+    ('𫝀', '𫠝'),
+    ('𫠠', '𬺡'),
+    ('𬺰', '𮯠'),
+    ('丽', '𪘀'),
+    ('𰀀', '𱍊'),
+    ('𱍐', '𲎯'),
+];
+
+pub const HANGUL: &'static [(char, char)] = &[
+    ('ᄀ', 'ᇿ'),
+    ('\u{302e}', '\u{302f}'),
+    ('ㄱ', 'ㆎ'),
+    ('㈀', '㈞'),
+    ('㉠', '㉾'),
+    ('ꥠ', 'ꥼ'),
+    ('가', '힣'),
+    ('ힰ', 'ퟆ'),
+    ('ퟋ', 'ퟻ'),
+    ('ﾠ', 'ﾾ'),
+    ('ￂ', 'ￇ'),
+    ('ￊ', 'ￏ'),
+    ('ￒ', 'ￗ'),
+    ('ￚ', 'ￜ'),
+];
+
+pub const HANIFI_ROHINGYA: &'static [(char, char)] =
+    &[('𐴀', '\u{10d27}'), ('𐴰', '𐴹')];
+
+pub const HANUNOO: &'static [(char, char)] = &[('ᜠ', '᜴')];
+
+pub const HATRAN: &'static [(char, char)] =
+    &[('𐣠', '𐣲'), ('𐣴', '𐣵'), ('𐣻', '𐣿')];
+
+pub const HEBREW: &'static [(char, char)] = &[
+    ('\u{591}', '\u{5c7}'),
+    ('א', 'ת'),
+    ('ׯ', '״'),
+    ('יִ', 'זּ'),
+    ('טּ', 'לּ'),
+    ('מּ', 'מּ'),
+    ('נּ', 'סּ'),
+    ('ףּ', 'פּ'),
+    ('צּ', 'ﭏ'),
+];
+
+pub const HIRAGANA: &'static [(char, char)] = &[
+    ('ぁ', 'ゖ'),
+    ('ゝ', 'ゟ'),
+    ('𛀁', '𛄟'),
+    ('𛄲', '𛄲'),
+    ('𛅐', '𛅒'),
+    ('🈀', '🈀'),
+];
+
+pub const IMPERIAL_ARAMAIC: &'static [(char, char)] =
+    &[('𐡀', '𐡕'), ('𐡗', '𐡟')];
+
+pub const INHERITED: &'static [(char, char)] = &[
+    ('\u{300}', '\u{36f}'),
+    ('\u{485}', '\u{486}'),
+    ('\u{64b}', '\u{655}'),
+    ('\u{670}', '\u{670}'),
+    ('\u{951}', '\u{954}'),
+    ('\u{1ab0}', '\u{1ace}'),
+    ('\u{1cd0}', '\u{1cd2}'),
+    ('\u{1cd4}', '\u{1ce0}'),
+    ('\u{1ce2}', '\u{1ce8}'),
+    ('\u{1ced}', '\u{1ced}'),
+    ('\u{1cf4}', '\u{1cf4}'),
+    ('\u{1cf8}', '\u{1cf9}'),
+    ('\u{1dc0}', '\u{1dff}'),
+    ('\u{200c}', '\u{200d}'),
+    ('\u{20d0}', '\u{20f0}'),
+    ('\u{302a}', '\u{302d}'),
+    ('\u{3099}', '\u{309a}'),
+    ('\u{fe00}', '\u{fe0f}'),
+    ('\u{fe20}', '\u{fe2d}'),
+    ('\u{101fd}', '\u{101fd}'),
+    ('\u{102e0}', '\u{102e0}'),
+    ('\u{1133b}', '\u{1133b}'),
+    ('\u{1cf00}', '\u{1cf2d}'),
+    ('\u{1cf30}', '\u{1cf46}'),
+    ('\u{1d167}', '\u{1d169}'),
+    ('\u{1d17b}', '\u{1d182}'),
+    ('\u{1d185}', '\u{1d18b}'),
+    ('\u{1d1aa}', '\u{1d1ad}'),
+    ('\u{e0100}', '\u{e01ef}'),
+];
+
+pub const INSCRIPTIONAL_PAHLAVI: &'static [(char, char)] =
+    &[('𐭠', '𐭲'), ('𐭸', '𐭿')];
+
+pub const INSCRIPTIONAL_PARTHIAN: &'static [(char, char)] =
+    &[('𐭀', '𐭕'), ('𐭘', '𐭟')];
+
+pub const JAVANESE: &'static [(char, char)] =
+    &[('\u{a980}', '꧍'), ('꧐', '꧙'), ('꧞', '꧟')];
+
+pub const KAITHI: &'static [(char, char)] =
+    &[('\u{11080}', '\u{110c2}'), ('\u{110cd}', '\u{110cd}')];
+
+pub const KANNADA: &'static [(char, char)] = &[
+    ('ಀ', 'ಌ'),
+    ('ಎ', 'ಐ'),
+    ('ಒ', 'ನ'),
+    ('ಪ', 'ಳ'),
+    ('ವ', 'ಹ'),
+    ('\u{cbc}', 'ೄ'),
+    ('\u{cc6}', 'ೈ'),
+    ('ೊ', '\u{ccd}'),
+    ('\u{cd5}', '\u{cd6}'),
+    ('ೝ', 'ೞ'),
+    ('ೠ', '\u{ce3}'),
+    ('೦', '೯'),
+    ('ೱ', 'ೳ'),
+];
+
+pub const KATAKANA: &'static [(char, char)] = &[
+    ('ァ', 'ヺ'),
+    ('ヽ', 'ヿ'),
+    ('ㇰ', 'ㇿ'),
+    ('㋐', '㋾'),
+    ('㌀', '㍗'),
+    ('ｦ', 'ｯ'),
+    ('ｱ', 'ﾝ'),
+    ('𚿰', '𚿳'),
+    ('𚿵', '𚿻'),
+    ('𚿽', '𚿾'),
+    ('𛀀', '𛀀'),
+    ('𛄠', '𛄢'),
+    ('𛅕', '𛅕'),
+    ('𛅤', '𛅧'),
+];
+
+pub const KAWI: &'static [(char, char)] =
+    &[('\u{11f00}', '𑼐'), ('𑼒', '\u{11f3a}'), ('𑼾', '𑽙')];
+
+pub const KAYAH_LI: &'static [(char, char)] = &[('꤀', '\u{a92d}'), ('꤯', '꤯')];
+
+pub const KHAROSHTHI: &'static [(char, char)] = &[
+    ('𐨀', '\u{10a03}'),
+    ('\u{10a05}', '\u{10a06}'),
+    ('\u{10a0c}', '𐨓'),
+    ('𐨕', '𐨗'),
+    ('𐨙', '𐨵'),
+    ('\u{10a38}', '\u{10a3a}'),
+    ('\u{10a3f}', '𐩈'),
+    ('𐩐', '𐩘'),
+];
+
+pub const KHITAN_SMALL_SCRIPT: &'static [(char, char)] =
+    &[('\u{16fe4}', '\u{16fe4}'), ('𘬀', '𘳕')];
+
+pub const KHMER: &'static [(char, char)] =
+    &[('ក', '\u{17dd}'), ('០', '៩'), ('៰', '៹'), ('᧠', '᧿')];
+
+pub const KHOJKI: &'static [(char, char)] = &[('𑈀', '𑈑'), ('𑈓', '\u{11241}')];
+
+pub const KHUDAWADI: &'static [(char, char)] =
+    &[('𑊰', '\u{112ea}'), ('𑋰', '𑋹')];
+
+pub const LAO: &'static [(char, char)] = &[
+    ('ກ', 'ຂ'),
+    ('ຄ', 'ຄ'),
+    ('ຆ', 'ຊ'),
+    ('ຌ', 'ຣ'),
+    ('ລ', 'ລ'),
+    ('ວ', 'ຽ'),
+    ('ເ', 'ໄ'),
+    ('ໆ', 'ໆ'),
+    ('\u{ec8}', '\u{ece}'),
+    ('໐', '໙'),
+    ('ໜ', 'ໟ'),
+];
+
+pub const LATIN: &'static [(char, char)] = &[
+    ('A', 'Z'),
+    ('a', 'z'),
+    ('ª', 'ª'),
+    ('º', 'º'),
+    ('À', 'Ö'),
+    ('Ø', 'ö'),
+    ('ø', 'ʸ'),
+    ('ˠ', 'ˤ'),
+    ('ᴀ', 'ᴥ'),
+    ('ᴬ', 'ᵜ'),
+    ('ᵢ', 'ᵥ'),
+    ('ᵫ', 'ᵷ'),
+    ('ᵹ', 'ᶾ'),
+    ('Ḁ', 'ỿ'),
+    ('ⁱ', 'ⁱ'),
+    ('ⁿ', 'ⁿ'),
+    ('ₐ', 'ₜ'),
+    ('K', 'Å'),
+    ('Ⅎ', 'Ⅎ'),
+    ('ⅎ', 'ⅎ'),
+    ('Ⅰ', 'ↈ'),
+    ('Ⱡ', 'Ɀ'),
+    ('Ꜣ', 'ꞇ'),
+    ('Ꞌ', 'ꟊ'),
+    ('Ꟑ', 'ꟑ'),
+    ('ꟓ', 'ꟓ'),
+    ('ꟕ', 'ꟙ'),
+    ('ꟲ', 'ꟿ'),
+    ('ꬰ', 'ꭚ'),
+    ('ꭜ', 'ꭤ'),
+    ('ꭦ', 'ꭩ'),
+    ('ﬀ', 'ﬆ'),
+    ('Ａ', 'Ｚ'),
+    ('ａ', 'ｚ'),
+    ('𐞀', '𐞅'),
+    ('𐞇', '𐞰'),
+    ('𐞲', '𐞺'),
+    ('𝼀', '𝼞'),
+    ('𝼥', '𝼪'),
+];
+
+pub const LEPCHA: &'static [(char, char)] =
+    &[('ᰀ', '\u{1c37}'), ('᰻', '᱉'), ('ᱍ', 'ᱏ')];
+
+pub const LIMBU: &'static [(char, char)] = &[
+    ('ᤀ', 'ᤞ'),
+    ('\u{1920}', 'ᤫ'),
+    ('ᤰ', '\u{193b}'),
+    ('᥀', '᥀'),
+    ('᥄', '᥏'),
+];
+
+pub const LINEAR_A: &'static [(char, char)] =
+    &[('𐘀', '𐜶'), ('𐝀', '𐝕'), ('𐝠', '𐝧')];
+
+pub const LINEAR_B: &'static [(char, char)] = &[
+    ('𐀀', '𐀋'),
+    ('𐀍', '𐀦'),
+    ('𐀨', '𐀺'),
+    ('𐀼', '𐀽'),
+    ('𐀿', '𐁍'),
+    ('𐁐', '𐁝'),
+    ('𐂀', '𐃺'),
+];
+
+pub const LISU: &'static [(char, char)] = &[('ꓐ', '꓿'), ('𑾰', '𑾰')];
+
+pub const LYCIAN: &'static [(char, char)] = &[('𐊀', '𐊜')];
+
+pub const LYDIAN: &'static [(char, char)] = &[('𐤠', '𐤹'), ('𐤿', '𐤿')];
+
+pub const MAHAJANI: &'static [(char, char)] = &[('𑅐', '𑅶')];
+
+pub const MAKASAR: &'static [(char, char)] = &[('𑻠', '𑻸')];
+
+pub const MALAYALAM: &'static [(char, char)] = &[
+    ('\u{d00}', 'ഌ'),
+    ('എ', 'ഐ'),
+    ('ഒ', '\u{d44}'),
+    ('െ', 'ൈ'),
+    ('ൊ', '൏'),
+    ('ൔ', '\u{d63}'),
+    ('൦', 'ൿ'),
+];
+
+pub const MANDAIC: &'static [(char, char)] = &[('ࡀ', '\u{85b}'), ('࡞', '࡞')];
+
+pub const MANICHAEAN: &'static [(char, char)] =
+    &[('𐫀', '\u{10ae6}'), ('𐫫', '𐫶')];
+
+pub const MARCHEN: &'static [(char, char)] =
+    &[('𑱰', '𑲏'), ('\u{11c92}', '\u{11ca7}'), ('𑲩', '\u{11cb6}')];
+
+pub const MASARAM_GONDI: &'static [(char, char)] = &[
+    ('𑴀', '𑴆'),
+    ('𑴈', '𑴉'),
+    ('𑴋', '\u{11d36}'),
+    ('\u{11d3a}', '\u{11d3a}'),
+    ('\u{11d3c}', '\u{11d3d}'),
+    ('\u{11d3f}', '\u{11d47}'),
+    ('𑵐', '𑵙'),
+];
+
+pub const MEDEFAIDRIN: &'static [(char, char)] = &[('𖹀', '𖺚')];
+
+pub const MEETEI_MAYEK: &'static [(char, char)] =
+    &[('ꫠ', '\u{aaf6}'), ('ꯀ', '\u{abed}'), ('꯰', '꯹')];
+
+pub const MENDE_KIKAKUI: &'static [(char, char)] =
+    &[('𞠀', '𞣄'), ('𞣇', '\u{1e8d6}')];
+
+pub const MEROITIC_CURSIVE: &'static [(char, char)] =
+    &[('𐦠', '𐦷'), ('𐦼', '𐧏'), ('𐧒', '𐧿')];
+
+pub const MEROITIC_HIEROGLYPHS: &'static [(char, char)] = &[('𐦀', '𐦟')];
+
+pub const MIAO: &'static [(char, char)] =
+    &[('𖼀', '𖽊'), ('\u{16f4f}', '𖾇'), ('\u{16f8f}', '𖾟')];
+
+pub const MODI: &'static [(char, char)] = &[('𑘀', '𑙄'), ('𑙐', '𑙙')];
+
+pub const MONGOLIAN: &'static [(char, char)] =
+    &[('᠀', '᠁'), ('᠄', '᠄'), ('᠆', '᠙'), ('ᠠ', 'ᡸ'), ('ᢀ', 'ᢪ'), ('𑙠', '𑙬')];
+
+pub const MRO: &'static [(char, char)] = &[('𖩀', '𖩞'), ('𖩠', '𖩩'), ('𖩮', '𖩯')];
+
+pub const MULTANI: &'static [(char, char)] =
+    &[('𑊀', '𑊆'), ('𑊈', '𑊈'), ('𑊊', '𑊍'), ('𑊏', '𑊝'), ('𑊟', '𑊩')];
+
+pub const MYANMAR: &'static [(char, char)] =
+    &[('က', '႟'), ('ꧠ', 'ꧾ'), ('ꩠ', 'ꩿ')];
+
+pub const NABATAEAN: &'static [(char, char)] = &[('𐢀', '𐢞'), ('𐢧', '𐢯')];
+
+pub const NAG_MUNDARI: &'static [(char, char)] = &[('𞓐', '𞓹')];
+
+pub const NANDINAGARI: &'static [(char, char)] =
+    &[('𑦠', '𑦧'), ('𑦪', '\u{119d7}'), ('\u{119da}', '𑧤')];
+
+pub const NEW_TAI_LUE: &'static [(char, char)] =
+    &[('ᦀ', 'ᦫ'), ('ᦰ', 'ᧉ'), ('᧐', '᧚'), ('᧞', '᧟')];
+
+pub const NEWA: &'static [(char, char)] = &[('𑐀', '𑑛'), ('𑑝', '𑑡')];
+
+pub const NKO: &'static [(char, char)] = &[('߀', 'ߺ'), ('\u{7fd}', '߿')];
+
+pub const NUSHU: &'static [(char, char)] = &[('𖿡', '𖿡'), ('𛅰', '𛋻')];
+
+pub const NYIAKENG_PUACHUE_HMONG: &'static [(char, char)] =
+    &[('𞄀', '𞄬'), ('\u{1e130}', '𞄽'), ('𞅀', '𞅉'), ('𞅎', '𞅏')];
+
+pub const OGHAM: &'static [(char, char)] = &[('\u{1680}', '᚜')];
+
+pub const OL_CHIKI: &'static [(char, char)] = &[('᱐', '᱿')];
+
+pub const OLD_HUNGARIAN: &'static [(char, char)] =
+    &[('𐲀', '𐲲'), ('𐳀', '𐳲'), ('𐳺', '𐳿')];
+
+pub const OLD_ITALIC: &'static [(char, char)] = &[('𐌀', '𐌣'), ('𐌭', '𐌯')];
+
+pub const OLD_NORTH_ARABIAN: &'static [(char, char)] = &[('𐪀', '𐪟')];
+
+pub const OLD_PERMIC: &'static [(char, char)] = &[('𐍐', '\u{1037a}')];
+
+pub const OLD_PERSIAN: &'static [(char, char)] = &[('𐎠', '𐏃'), ('𐏈', '𐏕')];
+
+pub const OLD_SOGDIAN: &'static [(char, char)] = &[('𐼀', '𐼧')];
+
+pub const OLD_SOUTH_ARABIAN: &'static [(char, char)] = &[('𐩠', '𐩿')];
+
+pub const OLD_TURKIC: &'static [(char, char)] = &[('𐰀', '𐱈')];
+
+pub const OLD_UYGHUR: &'static [(char, char)] = &[('𐽰', '𐾉')];
+
+pub const ORIYA: &'static [(char, char)] = &[
+    ('\u{b01}', 'ଃ'),
+    ('ଅ', 'ଌ'),
+    ('ଏ', 'ଐ'),
+    ('ଓ', 'ନ'),
+    ('ପ', 'ର'),
+    ('ଲ', 'ଳ'),
+    ('ଵ', 'ହ'),
+    ('\u{b3c}', '\u{b44}'),
+    ('େ', 'ୈ'),
+    ('ୋ', '\u{b4d}'),
+    ('\u{b55}', '\u{b57}'),
+    ('ଡ଼', 'ଢ଼'),
+    ('ୟ', '\u{b63}'),
+    ('୦', '୷'),
+];
+
+pub const OSAGE: &'static [(char, char)] = &[('𐒰', '𐓓'), ('𐓘', '𐓻')];
+
+pub const OSMANYA: &'static [(char, char)] = &[('𐒀', '𐒝'), ('𐒠', '𐒩')];
+
+pub const PAHAWH_HMONG: &'static [(char, char)] =
+    &[('𖬀', '𖭅'), ('𖭐', '𖭙'), ('𖭛', '𖭡'), ('𖭣', '𖭷'), ('𖭽', '𖮏')];
+
+pub const PALMYRENE: &'static [(char, char)] = &[('𐡠', '𐡿')];
+
+pub const PAU_CIN_HAU: &'static [(char, char)] = &[('𑫀', '𑫸')];
+
+pub const PHAGS_PA: &'static [(char, char)] = &[('ꡀ', '꡷')];
+
+pub const PHOENICIAN: &'static [(char, char)] = &[('𐤀', '𐤛'), ('𐤟', '𐤟')];
+
+pub const PSALTER_PAHLAVI: &'static [(char, char)] =
+    &[('𐮀', '𐮑'), ('𐮙', '𐮜'), ('𐮩', '𐮯')];
+
+pub const REJANG: &'static [(char, char)] = &[('ꤰ', '꥓'), ('꥟', '꥟')];
+
+pub const RUNIC: &'static [(char, char)] = &[('ᚠ', 'ᛪ'), ('ᛮ', 'ᛸ')];
+
+pub const SAMARITAN: &'static [(char, char)] = &[('ࠀ', '\u{82d}'), ('࠰', '࠾')];
+
+pub const SAURASHTRA: &'static [(char, char)] =
+    &[('ꢀ', '\u{a8c5}'), ('꣎', '꣙')];
+
+pub const SHARADA: &'static [(char, char)] = &[('\u{11180}', '𑇟')];
+
+pub const SHAVIAN: &'static [(char, char)] = &[('𐑐', '𐑿')];
+
+pub const SIDDHAM: &'static [(char, char)] =
+    &[('𑖀', '\u{115b5}'), ('𑖸', '\u{115dd}')];
+
+pub const SIGNWRITING: &'static [(char, char)] =
+    &[('𝠀', '𝪋'), ('\u{1da9b}', '\u{1da9f}'), ('\u{1daa1}', '\u{1daaf}')];
+
+pub const SINHALA: &'static [(char, char)] = &[
+    ('\u{d81}', 'ඃ'),
+    ('අ', 'ඖ'),
+    ('ක', 'න'),
+    ('ඳ', 'ර'),
+    ('ල', 'ල'),
+    ('ව', 'ෆ'),
+    ('\u{dca}', '\u{dca}'),
+    ('\u{dcf}', '\u{dd4}'),
+    ('\u{dd6}', '\u{dd6}'),
+    ('ෘ', '\u{ddf}'),
+    ('෦', '෯'),
+    ('ෲ', '෴'),
+    ('𑇡', '𑇴'),
+];
+
+pub const SOGDIAN: &'static [(char, char)] = &[('𐼰', '𐽙')];
+
+pub const SORA_SOMPENG: &'static [(char, char)] = &[('𑃐', '𑃨'), ('𑃰', '𑃹')];
+
+pub const SOYOMBO: &'static [(char, char)] = &[('𑩐', '𑪢')];
+
+pub const SUNDANESE: &'static [(char, char)] =
+    &[('\u{1b80}', 'ᮿ'), ('᳀', '᳇')];
+
+pub const SYLOTI_NAGRI: &'static [(char, char)] = &[('ꠀ', '\u{a82c}')];
+
+pub const SYRIAC: &'static [(char, char)] =
+    &[('܀', '܍'), ('\u{70f}', '\u{74a}'), ('ݍ', 'ݏ'), ('ࡠ', 'ࡪ')];
+
+pub const TAGALOG: &'static [(char, char)] = &[('ᜀ', '᜕'), ('ᜟ', 'ᜟ')];
+
+pub const TAGBANWA: &'static [(char, char)] =
+    &[('ᝠ', 'ᝬ'), ('ᝮ', 'ᝰ'), ('\u{1772}', '\u{1773}')];
+
+pub const TAI_LE: &'static [(char, char)] = &[('ᥐ', 'ᥭ'), ('ᥰ', 'ᥴ')];
+
+pub const TAI_THAM: &'static [(char, char)] = &[
+    ('ᨠ', '\u{1a5e}'),
+    ('\u{1a60}', '\u{1a7c}'),
+    ('\u{1a7f}', '᪉'),
+    ('᪐', '᪙'),
+    ('᪠', '᪭'),
+];
+
+pub const TAI_VIET: &'static [(char, char)] = &[('ꪀ', 'ꫂ'), ('ꫛ', '꫟')];
+
+pub const TAKRI: &'static [(char, char)] = &[('𑚀', '𑚹'), ('𑛀', '𑛉')];
+
+pub const TAMIL: &'static [(char, char)] = &[
+    ('\u{b82}', 'ஃ'),
+    ('அ', 'ஊ'),
+    ('எ', 'ஐ'),
+    ('ஒ', 'க'),
+    ('ங', 'ச'),
+    ('ஜ', 'ஜ'),
+    ('ஞ', 'ட'),
+    ('ண', 'த'),
+    ('ந', 'ப'),
+    ('ம', 'ஹ'),
+    ('\u{bbe}', 'ூ'),
+    ('ெ', 'ை'),
+    ('ொ', '\u{bcd}'),
+    ('ௐ', 'ௐ'),
+    ('\u{bd7}', '\u{bd7}'),
+    ('௦', '௺'),
+    ('𑿀', '𑿱'),
+    ('𑿿', '𑿿'),
+];
+
+pub const TANGSA: &'static [(char, char)] = &[('𖩰', '𖪾'), ('𖫀', '𖫉')];
+
+pub const TANGUT: &'static [(char, char)] =
+    &[('𖿠', '𖿠'), ('𗀀', '𘟷'), ('𘠀', '𘫿'), ('𘴀', '𘴈')];
+
+pub const TELUGU: &'static [(char, char)] = &[
+    ('\u{c00}', 'ఌ'),
+    ('ఎ', 'ఐ'),
+    ('ఒ', 'న'),
+    ('ప', 'హ'),
+    ('\u{c3c}', 'ౄ'),
+    ('\u{c46}', '\u{c48}'),
+    ('\u{c4a}', '\u{c4d}'),
+    ('\u{c55}', '\u{c56}'),
+    ('ౘ', 'ౚ'),
+    ('ౝ', 'ౝ'),
+    ('ౠ', '\u{c63}'),
+    ('౦', '౯'),
+    ('౷', '౿'),
+];
+
+pub const THAANA: &'static [(char, char)] = &[('ހ', 'ޱ')];
+
+pub const THAI: &'static [(char, char)] = &[('ก', '\u{e3a}'), ('เ', '๛')];
+
+pub const TIBETAN: &'static [(char, char)] = &[
+    ('ༀ', 'ཇ'),
+    ('ཉ', 'ཬ'),
+    ('\u{f71}', '\u{f97}'),
+    ('\u{f99}', '\u{fbc}'),
+    ('྾', '࿌'),
+    ('࿎', '࿔'),
+    ('࿙', '࿚'),
+];
+
+pub const TIFINAGH: &'static [(char, char)] =
+    &[('ⴰ', 'ⵧ'), ('ⵯ', '⵰'), ('\u{2d7f}', '\u{2d7f}')];
+
+pub const TIRHUTA: &'static [(char, char)] = &[('𑒀', '𑓇'), ('𑓐', '𑓙')];
+
+pub const TOTO: &'static [(char, char)] = &[('𞊐', '\u{1e2ae}')];
+
+pub const UGARITIC: &'static [(char, char)] = &[('𐎀', '𐎝'), ('𐎟', '𐎟')];
+
+pub const VAI: &'static [(char, char)] = &[('ꔀ', 'ꘫ')];
+
+pub const VITHKUQI: &'static [(char, char)] = &[
+    ('𐕰', '𐕺'),
+    ('𐕼', '𐖊'),
+    ('𐖌', '𐖒'),
+    ('𐖔', '𐖕'),
+    ('𐖗', '𐖡'),
+    ('𐖣', '𐖱'),
+    ('𐖳', '𐖹'),
+    ('𐖻', '𐖼'),
+];
+
+pub const WANCHO: &'static [(char, char)] = &[('𞋀', '𞋹'), ('𞋿', '𞋿')];
+
+pub const WARANG_CITI: &'static [(char, char)] = &[('𑢠', '𑣲'), ('𑣿', '𑣿')];
+
+pub const YEZIDI: &'static [(char, char)] =
+    &[('𐺀', '𐺩'), ('\u{10eab}', '𐺭'), ('𐺰', '𐺱')];
+
+pub const YI: &'static [(char, char)] = &[('ꀀ', 'ꒌ'), ('꒐', '꓆')];
+
+pub const ZANABAZAR_SQUARE: &'static [(char, char)] = &[('𑨀', '\u{11a47}')];
diff --git a/crates/regex-syntax/src/unicode_tables/script_extension.rs b/crates/regex-syntax/src/unicode_tables/script_extension.rs
new file mode 100644
index 0000000..42625e2
--- /dev/null
+++ b/crates/regex-syntax/src/unicode_tables/script_extension.rs
@@ -0,0 +1,1457 @@
+// DO NOT EDIT THIS FILE. IT WAS AUTOMATICALLY GENERATED BY:
+//
+//   ucd-generate script-extension ucd-15.0.0 --chars
+//
+// Unicode version: 15.0.0.
+//
+// ucd-generate 0.2.14 is available on crates.io.
+
+pub const BY_NAME: &'static [(&'static str, &'static [(char, char)])] = &[
+    ("Adlam", ADLAM),
+    ("Ahom", AHOM),
+    ("Anatolian_Hieroglyphs", ANATOLIAN_HIEROGLYPHS),
+    ("Arabic", ARABIC),
+    ("Armenian", ARMENIAN),
+    ("Avestan", AVESTAN),
+    ("Balinese", BALINESE),
+    ("Bamum", BAMUM),
+    ("Bassa_Vah", BASSA_VAH),
+    ("Batak", BATAK),
+    ("Bengali", BENGALI),
+    ("Bhaiksuki", BHAIKSUKI),
+    ("Bopomofo", BOPOMOFO),
+    ("Brahmi", BRAHMI),
+    ("Braille", BRAILLE),
+    ("Buginese", BUGINESE),
+    ("Buhid", BUHID),
+    ("Canadian_Aboriginal", CANADIAN_ABORIGINAL),
+    ("Carian", CARIAN),
+    ("Caucasian_Albanian", CAUCASIAN_ALBANIAN),
+    ("Chakma", CHAKMA),
+    ("Cham", CHAM),
+    ("Cherokee", CHEROKEE),
+    ("Chorasmian", CHORASMIAN),
+    ("Common", COMMON),
+    ("Coptic", COPTIC),
+    ("Cuneiform", CUNEIFORM),
+    ("Cypriot", CYPRIOT),
+    ("Cypro_Minoan", CYPRO_MINOAN),
+    ("Cyrillic", CYRILLIC),
+    ("Deseret", DESERET),
+    ("Devanagari", DEVANAGARI),
+    ("Dives_Akuru", DIVES_AKURU),
+    ("Dogra", DOGRA),
+    ("Duployan", DUPLOYAN),
+    ("Egyptian_Hieroglyphs", EGYPTIAN_HIEROGLYPHS),
+    ("Elbasan", ELBASAN),
+    ("Elymaic", ELYMAIC),
+    ("Ethiopic", ETHIOPIC),
+    ("Georgian", GEORGIAN),
+    ("Glagolitic", GLAGOLITIC),
+    ("Gothic", GOTHIC),
+    ("Grantha", GRANTHA),
+    ("Greek", GREEK),
+    ("Gujarati", GUJARATI),
+    ("Gunjala_Gondi", GUNJALA_GONDI),
+    ("Gurmukhi", GURMUKHI),
+    ("Han", HAN),
+    ("Hangul", HANGUL),
+    ("Hanifi_Rohingya", HANIFI_ROHINGYA),
+    ("Hanunoo", HANUNOO),
+    ("Hatran", HATRAN),
+    ("Hebrew", HEBREW),
+    ("Hiragana", HIRAGANA),
+    ("Imperial_Aramaic", IMPERIAL_ARAMAIC),
+    ("Inherited", INHERITED),
+    ("Inscriptional_Pahlavi", INSCRIPTIONAL_PAHLAVI),
+    ("Inscriptional_Parthian", INSCRIPTIONAL_PARTHIAN),
+    ("Javanese", JAVANESE),
+    ("Kaithi", KAITHI),
+    ("Kannada", KANNADA),
+    ("Katakana", KATAKANA),
+    ("Kawi", KAWI),
+    ("Kayah_Li", KAYAH_LI),
+    ("Kharoshthi", KHAROSHTHI),
+    ("Khitan_Small_Script", KHITAN_SMALL_SCRIPT),
+    ("Khmer", KHMER),
+    ("Khojki", KHOJKI),
+    ("Khudawadi", KHUDAWADI),
+    ("Lao", LAO),
+    ("Latin", LATIN),
+    ("Lepcha", LEPCHA),
+    ("Limbu", LIMBU),
+    ("Linear_A", LINEAR_A),
+    ("Linear_B", LINEAR_B),
+    ("Lisu", LISU),
+    ("Lycian", LYCIAN),
+    ("Lydian", LYDIAN),
+    ("Mahajani", MAHAJANI),
+    ("Makasar", MAKASAR),
+    ("Malayalam", MALAYALAM),
+    ("Mandaic", MANDAIC),
+    ("Manichaean", MANICHAEAN),
+    ("Marchen", MARCHEN),
+    ("Masaram_Gondi", MASARAM_GONDI),
+    ("Medefaidrin", MEDEFAIDRIN),
+    ("Meetei_Mayek", MEETEI_MAYEK),
+    ("Mende_Kikakui", MENDE_KIKAKUI),
+    ("Meroitic_Cursive", MEROITIC_CURSIVE),
+    ("Meroitic_Hieroglyphs", MEROITIC_HIEROGLYPHS),
+    ("Miao", MIAO),
+    ("Modi", MODI),
+    ("Mongolian", MONGOLIAN),
+    ("Mro", MRO),
+    ("Multani", MULTANI),
+    ("Myanmar", MYANMAR),
+    ("Nabataean", NABATAEAN),
+    ("Nag_Mundari", NAG_MUNDARI),
+    ("Nandinagari", NANDINAGARI),
+    ("New_Tai_Lue", NEW_TAI_LUE),
+    ("Newa", NEWA),
+    ("Nko", NKO),
+    ("Nushu", NUSHU),
+    ("Nyiakeng_Puachue_Hmong", NYIAKENG_PUACHUE_HMONG),
+    ("Ogham", OGHAM),
+    ("Ol_Chiki", OL_CHIKI),
+    ("Old_Hungarian", OLD_HUNGARIAN),
+    ("Old_Italic", OLD_ITALIC),
+    ("Old_North_Arabian", OLD_NORTH_ARABIAN),
+    ("Old_Permic", OLD_PERMIC),
+    ("Old_Persian", OLD_PERSIAN),
+    ("Old_Sogdian", OLD_SOGDIAN),
+    ("Old_South_Arabian", OLD_SOUTH_ARABIAN),
+    ("Old_Turkic", OLD_TURKIC),
+    ("Old_Uyghur", OLD_UYGHUR),
+    ("Oriya", ORIYA),
+    ("Osage", OSAGE),
+    ("Osmanya", OSMANYA),
+    ("Pahawh_Hmong", PAHAWH_HMONG),
+    ("Palmyrene", PALMYRENE),
+    ("Pau_Cin_Hau", PAU_CIN_HAU),
+    ("Phags_Pa", PHAGS_PA),
+    ("Phoenician", PHOENICIAN),
+    ("Psalter_Pahlavi", PSALTER_PAHLAVI),
+    ("Rejang", REJANG),
+    ("Runic", RUNIC),
+    ("Samaritan", SAMARITAN),
+    ("Saurashtra", SAURASHTRA),
+    ("Sharada", SHARADA),
+    ("Shavian", SHAVIAN),
+    ("Siddham", SIDDHAM),
+    ("SignWriting", SIGNWRITING),
+    ("Sinhala", SINHALA),
+    ("Sogdian", SOGDIAN),
+    ("Sora_Sompeng", SORA_SOMPENG),
+    ("Soyombo", SOYOMBO),
+    ("Sundanese", SUNDANESE),
+    ("Syloti_Nagri", SYLOTI_NAGRI),
+    ("Syriac", SYRIAC),
+    ("Tagalog", TAGALOG),
+    ("Tagbanwa", TAGBANWA),
+    ("Tai_Le", TAI_LE),
+    ("Tai_Tham", TAI_THAM),
+    ("Tai_Viet", TAI_VIET),
+    ("Takri", TAKRI),
+    ("Tamil", TAMIL),
+    ("Tangsa", TANGSA),
+    ("Tangut", TANGUT),
+    ("Telugu", TELUGU),
+    ("Thaana", THAANA),
+    ("Thai", THAI),
+    ("Tibetan", TIBETAN),
+    ("Tifinagh", TIFINAGH),
+    ("Tirhuta", TIRHUTA),
+    ("Toto", TOTO),
+    ("Ugaritic", UGARITIC),
+    ("Vai", VAI),
+    ("Vithkuqi", VITHKUQI),
+    ("Wancho", WANCHO),
+    ("Warang_Citi", WARANG_CITI),
+    ("Yezidi", YEZIDI),
+    ("Yi", YI),
+    ("Zanabazar_Square", ZANABAZAR_SQUARE),
+];
+
+pub const ADLAM: &'static [(char, char)] =
+    &[('؟', '؟'), ('ـ', 'ـ'), ('𞤀', '𞥋'), ('𞥐', '𞥙'), ('𞥞', '𞥟')];
+
+pub const AHOM: &'static [(char, char)] =
+    &[('𑜀', '𑜚'), ('\u{1171d}', '\u{1172b}'), ('𑜰', '𑝆')];
+
+pub const ANATOLIAN_HIEROGLYPHS: &'static [(char, char)] = &[('𔐀', '𔙆')];
+
+pub const ARABIC: &'static [(char, char)] = &[
+    ('\u{600}', '\u{604}'),
+    ('؆', '\u{6dc}'),
+    ('۞', 'ۿ'),
+    ('ݐ', 'ݿ'),
+    ('ࡰ', 'ࢎ'),
+    ('\u{890}', '\u{891}'),
+    ('\u{898}', '\u{8e1}'),
+    ('\u{8e3}', '\u{8ff}'),
+    ('ﭐ', '﯂'),
+    ('ﯓ', 'ﶏ'),
+    ('ﶒ', 'ﷇ'),
+    ('﷏', '﷏'),
+    ('ﷰ', '﷿'),
+    ('ﹰ', 'ﹴ'),
+    ('ﹶ', 'ﻼ'),
+    ('\u{102e0}', '𐋻'),
+    ('𐹠', '𐹾'),
+    ('\u{10efd}', '\u{10eff}'),
+    ('𞸀', '𞸃'),
+    ('𞸅', '𞸟'),
+    ('𞸡', '𞸢'),
+    ('𞸤', '𞸤'),
+    ('𞸧', '𞸧'),
+    ('𞸩', '𞸲'),
+    ('𞸴', '𞸷'),
+    ('𞸹', '𞸹'),
+    ('𞸻', '𞸻'),
+    ('𞹂', '𞹂'),
+    ('𞹇', '𞹇'),
+    ('𞹉', '𞹉'),
+    ('𞹋', '𞹋'),
+    ('𞹍', '𞹏'),
+    ('𞹑', '𞹒'),
+    ('𞹔', '𞹔'),
+    ('𞹗', '𞹗'),
+    ('𞹙', '𞹙'),
+    ('𞹛', '𞹛'),
+    ('𞹝', '𞹝'),
+    ('𞹟', '𞹟'),
+    ('𞹡', '𞹢'),
+    ('𞹤', '𞹤'),
+    ('𞹧', '𞹪'),
+    ('𞹬', '𞹲'),
+    ('𞹴', '𞹷'),
+    ('𞹹', '𞹼'),
+    ('𞹾', '𞹾'),
+    ('𞺀', '𞺉'),
+    ('𞺋', '𞺛'),
+    ('𞺡', '𞺣'),
+    ('𞺥', '𞺩'),
+    ('𞺫', '𞺻'),
+    ('𞻰', '𞻱'),
+];
+
+pub const ARMENIAN: &'static [(char, char)] =
+    &[('Ա', 'Ֆ'), ('ՙ', '֊'), ('֍', '֏'), ('ﬓ', 'ﬗ')];
+
+pub const AVESTAN: &'static [(char, char)] = &[('𐬀', '𐬵'), ('𐬹', '𐬿')];
+
+pub const BALINESE: &'static [(char, char)] = &[('\u{1b00}', 'ᭌ'), ('᭐', '᭾')];
+
+pub const BAMUM: &'static [(char, char)] = &[('ꚠ', '꛷'), ('𖠀', '𖨸')];
+
+pub const BASSA_VAH: &'static [(char, char)] =
+    &[('𖫐', '𖫭'), ('\u{16af0}', '𖫵')];
+
+pub const BATAK: &'static [(char, char)] = &[('ᯀ', '᯳'), ('᯼', '᯿')];
+
+pub const BENGALI: &'static [(char, char)] = &[
+    ('\u{951}', '\u{952}'),
+    ('।', '॥'),
+    ('ঀ', 'ঃ'),
+    ('অ', 'ঌ'),
+    ('এ', 'ঐ'),
+    ('ও', 'ন'),
+    ('প', 'র'),
+    ('ল', 'ল'),
+    ('শ', 'হ'),
+    ('\u{9bc}', '\u{9c4}'),
+    ('ে', 'ৈ'),
+    ('ো', 'ৎ'),
+    ('\u{9d7}', '\u{9d7}'),
+    ('ড়', 'ঢ়'),
+    ('য়', '\u{9e3}'),
+    ('০', '\u{9fe}'),
+    ('\u{1cd0}', '\u{1cd0}'),
+    ('\u{1cd2}', '\u{1cd2}'),
+    ('\u{1cd5}', '\u{1cd6}'),
+    ('\u{1cd8}', '\u{1cd8}'),
+    ('᳡', '᳡'),
+    ('ᳪ', 'ᳪ'),
+    ('\u{1ced}', '\u{1ced}'),
+    ('ᳲ', 'ᳲ'),
+    ('ᳵ', '᳷'),
+    ('\u{a8f1}', '\u{a8f1}'),
+];
+
+pub const BHAIKSUKI: &'static [(char, char)] =
+    &[('𑰀', '𑰈'), ('𑰊', '\u{11c36}'), ('\u{11c38}', '𑱅'), ('𑱐', '𑱬')];
+
+pub const BOPOMOFO: &'static [(char, char)] = &[
+    ('˪', '˫'),
+    ('、', '〃'),
+    ('〈', '】'),
+    ('〓', '〟'),
+    ('\u{302a}', '\u{302d}'),
+    ('〰', '〰'),
+    ('〷', '〷'),
+    ('・', '・'),
+    ('ㄅ', 'ㄯ'),
+    ('ㆠ', 'ㆿ'),
+    ('﹅', '﹆'),
+    ('｡', '･'),
+];
+
+pub const BRAHMI: &'static [(char, char)] =
+    &[('𑀀', '𑁍'), ('𑁒', '𑁵'), ('\u{1107f}', '\u{1107f}')];
+
+pub const BRAILLE: &'static [(char, char)] = &[('⠀', '⣿')];
+
+pub const BUGINESE: &'static [(char, char)] =
+    &[('ᨀ', '\u{1a1b}'), ('᨞', '᨟'), ('ꧏ', 'ꧏ')];
+
+pub const BUHID: &'static [(char, char)] = &[('᜵', '᜶'), ('ᝀ', '\u{1753}')];
+
+pub const CANADIAN_ABORIGINAL: &'static [(char, char)] =
+    &[('᐀', 'ᙿ'), ('ᢰ', 'ᣵ'), ('𑪰', '𑪿')];
+
+pub const CARIAN: &'static [(char, char)] = &[('𐊠', '𐋐')];
+
+pub const CAUCASIAN_ALBANIAN: &'static [(char, char)] =
+    &[('𐔰', '𐕣'), ('𐕯', '𐕯')];
+
+pub const CHAKMA: &'static [(char, char)] =
+    &[('০', '৯'), ('၀', '၉'), ('\u{11100}', '\u{11134}'), ('𑄶', '𑅇')];
+
+pub const CHAM: &'static [(char, char)] =
+    &[('ꨀ', '\u{aa36}'), ('ꩀ', 'ꩍ'), ('꩐', '꩙'), ('꩜', '꩟')];
+
+pub const CHEROKEE: &'static [(char, char)] =
+    &[('Ꭰ', 'Ᏽ'), ('ᏸ', 'ᏽ'), ('ꭰ', 'ꮿ')];
+
+pub const CHORASMIAN: &'static [(char, char)] = &[('𐾰', '𐿋')];
+
+pub const COMMON: &'static [(char, char)] = &[
+    ('\0', '@'),
+    ('[', '`'),
+    ('{', '©'),
+    ('«', '¹'),
+    ('»', '¿'),
+    ('×', '×'),
+    ('÷', '÷'),
+    ('ʹ', '˟'),
+    ('˥', '˩'),
+    ('ˬ', '˿'),
+    ('ʹ', 'ʹ'),
+    (';', ';'),
+    ('΅', '΅'),
+    ('·', '·'),
+    ('\u{605}', '\u{605}'),
+    ('\u{6dd}', '\u{6dd}'),
+    ('\u{8e2}', '\u{8e2}'),
+    ('฿', '฿'),
+    ('࿕', '࿘'),
+    ('᛫', '᛭'),
+    ('\u{2000}', '\u{200b}'),
+    ('\u{200e}', '\u{202e}'),
+    ('‰', '\u{2064}'),
+    ('\u{2066}', '⁰'),
+    ('⁴', '⁾'),
+    ('₀', '₎'),
+    ('₠', '⃀'),
+    ('℀', '℥'),
+    ('℧', '℩'),
+    ('ℬ', 'ℱ'),
+    ('ℳ', '⅍'),
+    ('⅏', '⅟'),
+    ('↉', '↋'),
+    ('←', '␦'),
+    ('⑀', '⑊'),
+    ('①', '⟿'),
+    ('⤀', '⭳'),
+    ('⭶', '⮕'),
+    ('⮗', '⯿'),
+    ('⸀', '⹂'),
+    ('⹄', '⹝'),
+    ('⿰', '⿻'),
+    ('\u{3000}', '\u{3000}'),
+    ('〄', '〄'),
+    ('〒', '〒'),
+    ('〠', '〠'),
+    ('〶', '〶'),
+    ('㉈', '㉟'),
+    ('㉿', '㉿'),
+    ('㊱', '㊿'),
+    ('㋌', '㋏'),
+    ('㍱', '㍺'),
+    ('㎀', '㏟'),
+    ('㏿', '㏿'),
+    ('䷀', '䷿'),
+    ('꜈', '꜡'),
+    ('ꞈ', '꞊'),
+    ('꭛', '꭛'),
+    ('꭪', '꭫'),
+    ('︐', '︙'),
+    ('︰', '﹄'),
+    ('﹇', '﹒'),
+    ('﹔', '﹦'),
+    ('﹨', '﹫'),
+    ('\u{feff}', '\u{feff}'),
+    ('！', '＠'),
+    ('［', '｀'),
+    ('｛', '｠'),
+    ('￠', '￦'),
+    ('￨', '￮'),
+    ('\u{fff9}', '�'),
+    ('𐆐', '𐆜'),
+    ('𐇐', '𐇼'),
+    ('𜽐', '𜿃'),
+    ('𝀀', '𝃵'),
+    ('𝄀', '𝄦'),
+    ('𝄩', '𝅦'),
+    ('𝅪', '\u{1d17a}'),
+    ('𝆃', '𝆄'),
+    ('𝆌', '𝆩'),
+    ('𝆮', '𝇪'),
+    ('𝋀', '𝋓'),
+    ('𝋠', '𝋳'),
+    ('𝌀', '𝍖'),
+    ('𝍲', '𝍸'),
+    ('𝐀', '𝑔'),
+    ('𝑖', '𝒜'),
+    ('𝒞', '𝒟'),
+    ('𝒢', '𝒢'),
+    ('𝒥', '𝒦'),
+    ('𝒩', '𝒬'),
+    ('𝒮', '𝒹'),
+    ('𝒻', '𝒻'),
+    ('𝒽', '𝓃'),
+    ('𝓅', '𝔅'),
+    ('𝔇', '𝔊'),
+    ('𝔍', '𝔔'),
+    ('𝔖', '𝔜'),
+    ('𝔞', '𝔹'),
+    ('𝔻', '𝔾'),
+    ('𝕀', '𝕄'),
+    ('𝕆', '𝕆'),
+    ('𝕊', '𝕐'),
+    ('𝕒', '𝚥'),
+    ('𝚨', '𝟋'),
+    ('𝟎', '𝟿'),
+    ('𞱱', '𞲴'),
+    ('𞴁', '𞴽'),
+    ('🀀', '🀫'),
+    ('🀰', '🂓'),
+    ('🂠', '🂮'),
+    ('🂱', '🂿'),
+    ('🃁', '🃏'),
+    ('🃑', '🃵'),
+    ('🄀', '🆭'),
+    ('🇦', '🇿'),
+    ('🈁', '🈂'),
+    ('🈐', '🈻'),
+    ('🉀', '🉈'),
+    ('🉠', '🉥'),
+    ('🌀', '🛗'),
+    ('🛜', '🛬'),
+    ('🛰', '🛼'),
+    ('🜀', '🝶'),
+    ('🝻', '🟙'),
+    ('🟠', '🟫'),
+    ('🟰', '🟰'),
+    ('🠀', '🠋'),
+    ('🠐', '🡇'),
+    ('🡐', '🡙'),
+    ('🡠', '🢇'),
+    ('🢐', '🢭'),
+    ('🢰', '🢱'),
+    ('🤀', '🩓'),
+    ('🩠', '🩭'),
+    ('🩰', '🩼'),
+    ('🪀', '🪈'),
+    ('🪐', '🪽'),
+    ('🪿', '🫅'),
+    ('🫎', '🫛'),
+    ('🫠', '🫨'),
+    ('🫰', '🫸'),
+    ('🬀', '🮒'),
+    ('🮔', '🯊'),
+    ('🯰', '🯹'),
+    ('\u{e0001}', '\u{e0001}'),
+    ('\u{e0020}', '\u{e007f}'),
+];
+
+pub const COPTIC: &'static [(char, char)] =
+    &[('Ϣ', 'ϯ'), ('Ⲁ', 'ⳳ'), ('⳹', '⳿'), ('\u{102e0}', '𐋻')];
+
+pub const CUNEIFORM: &'static [(char, char)] =
+    &[('𒀀', '𒎙'), ('𒐀', '𒑮'), ('𒑰', '𒑴'), ('𒒀', '𒕃')];
+
+pub const CYPRIOT: &'static [(char, char)] = &[
+    ('𐄀', '𐄂'),
+    ('𐄇', '𐄳'),
+    ('𐄷', '𐄿'),
+    ('𐠀', '𐠅'),
+    ('𐠈', '𐠈'),
+    ('𐠊', '𐠵'),
+    ('𐠷', '𐠸'),
+    ('𐠼', '𐠼'),
+    ('𐠿', '𐠿'),
+];
+
+pub const CYPRO_MINOAN: &'static [(char, char)] = &[('𐄀', '𐄁'), ('𒾐', '𒿲')];
+
+pub const CYRILLIC: &'static [(char, char)] = &[
+    ('Ѐ', 'ԯ'),
+    ('ᲀ', 'ᲈ'),
+    ('ᴫ', 'ᴫ'),
+    ('ᵸ', 'ᵸ'),
+    ('\u{1df8}', '\u{1df8}'),
+    ('\u{2de0}', '\u{2dff}'),
+    ('⹃', '⹃'),
+    ('Ꙁ', '\u{a69f}'),
+    ('\u{fe2e}', '\u{fe2f}'),
+    ('𞀰', '𞁭'),
+    ('\u{1e08f}', '\u{1e08f}'),
+];
+
+pub const DESERET: &'static [(char, char)] = &[('𐐀', '𐑏')];
+
+pub const DEVANAGARI: &'static [(char, char)] = &[
+    ('\u{900}', '\u{952}'),
+    ('\u{955}', 'ॿ'),
+    ('\u{1cd0}', 'ᳶ'),
+    ('\u{1cf8}', '\u{1cf9}'),
+    ('\u{20f0}', '\u{20f0}'),
+    ('꠰', '꠹'),
+    ('\u{a8e0}', '\u{a8ff}'),
+    ('𑬀', '𑬉'),
+];
+
+pub const DIVES_AKURU: &'static [(char, char)] = &[
+    ('𑤀', '𑤆'),
+    ('𑤉', '𑤉'),
+    ('𑤌', '𑤓'),
+    ('𑤕', '𑤖'),
+    ('𑤘', '𑤵'),
+    ('𑤷', '𑤸'),
+    ('\u{1193b}', '𑥆'),
+    ('𑥐', '𑥙'),
+];
+
+pub const DOGRA: &'static [(char, char)] =
+    &[('।', '९'), ('꠰', '꠹'), ('𑠀', '𑠻')];
+
+pub const DUPLOYAN: &'static [(char, char)] =
+    &[('𛰀', '𛱪'), ('𛱰', '𛱼'), ('𛲀', '𛲈'), ('𛲐', '𛲙'), ('𛲜', '\u{1bca3}')];
+
+pub const EGYPTIAN_HIEROGLYPHS: &'static [(char, char)] =
+    &[('𓀀', '\u{13455}')];
+
+pub const ELBASAN: &'static [(char, char)] = &[('𐔀', '𐔧')];
+
+pub const ELYMAIC: &'static [(char, char)] = &[('𐿠', '𐿶')];
+
+pub const ETHIOPIC: &'static [(char, char)] = &[
+    ('ሀ', 'ቈ'),
+    ('ቊ', 'ቍ'),
+    ('ቐ', 'ቖ'),
+    ('ቘ', 'ቘ'),
+    ('ቚ', 'ቝ'),
+    ('በ', 'ኈ'),
+    ('ኊ', 'ኍ'),
+    ('ነ', 'ኰ'),
+    ('ኲ', 'ኵ'),
+    ('ኸ', 'ኾ'),
+    ('ዀ', 'ዀ'),
+    ('ዂ', 'ዅ'),
+    ('ወ', 'ዖ'),
+    ('ዘ', 'ጐ'),
+    ('ጒ', 'ጕ'),
+    ('ጘ', 'ፚ'),
+    ('\u{135d}', '፼'),
+    ('ᎀ', '᎙'),
+    ('ⶀ', 'ⶖ'),
+    ('ⶠ', 'ⶦ'),
+    ('ⶨ', 'ⶮ'),
+    ('ⶰ', 'ⶶ'),
+    ('ⶸ', 'ⶾ'),
+    ('ⷀ', 'ⷆ'),
+    ('ⷈ', 'ⷎ'),
+    ('ⷐ', 'ⷖ'),
+    ('ⷘ', 'ⷞ'),
+    ('ꬁ', 'ꬆ'),
+    ('ꬉ', 'ꬎ'),
+    ('ꬑ', 'ꬖ'),
+    ('ꬠ', 'ꬦ'),
+    ('ꬨ', 'ꬮ'),
+    ('𞟠', '𞟦'),
+    ('𞟨', '𞟫'),
+    ('𞟭', '𞟮'),
+    ('𞟰', '𞟾'),
+];
+
+pub const GEORGIAN: &'static [(char, char)] = &[
+    ('Ⴀ', 'Ⴥ'),
+    ('Ⴧ', 'Ⴧ'),
+    ('Ⴭ', 'Ⴭ'),
+    ('ა', 'ჿ'),
+    ('Ა', 'Ჺ'),
+    ('Ჽ', 'Ჿ'),
+    ('ⴀ', 'ⴥ'),
+    ('ⴧ', 'ⴧ'),
+    ('ⴭ', 'ⴭ'),
+];
+
+pub const GLAGOLITIC: &'static [(char, char)] = &[
+    ('\u{484}', '\u{484}'),
+    ('\u{487}', '\u{487}'),
+    ('Ⰰ', 'ⱟ'),
+    ('⹃', '⹃'),
+    ('\u{a66f}', '\u{a66f}'),
+    ('\u{1e000}', '\u{1e006}'),
+    ('\u{1e008}', '\u{1e018}'),
+    ('\u{1e01b}', '\u{1e021}'),
+    ('\u{1e023}', '\u{1e024}'),
+    ('\u{1e026}', '\u{1e02a}'),
+];
+
+pub const GOTHIC: &'static [(char, char)] = &[('𐌰', '𐍊')];
+
+pub const GRANTHA: &'static [(char, char)] = &[
+    ('\u{951}', '\u{952}'),
+    ('।', '॥'),
+    ('௦', '௳'),
+    ('\u{1cd0}', '\u{1cd0}'),
+    ('\u{1cd2}', '᳓'),
+    ('ᳲ', '\u{1cf4}'),
+    ('\u{1cf8}', '\u{1cf9}'),
+    ('\u{20f0}', '\u{20f0}'),
+    ('\u{11300}', '𑌃'),
+    ('𑌅', '𑌌'),
+    ('𑌏', '𑌐'),
+    ('𑌓', '𑌨'),
+    ('𑌪', '𑌰'),
+    ('𑌲', '𑌳'),
+    ('𑌵', '𑌹'),
+    ('\u{1133b}', '𑍄'),
+    ('𑍇', '𑍈'),
+    ('𑍋', '𑍍'),
+    ('𑍐', '𑍐'),
+    ('\u{11357}', '\u{11357}'),
+    ('𑍝', '𑍣'),
+    ('\u{11366}', '\u{1136c}'),
+    ('\u{11370}', '\u{11374}'),
+    ('𑿐', '𑿑'),
+    ('𑿓', '𑿓'),
+];
+
+pub const GREEK: &'static [(char, char)] = &[
+    ('\u{342}', '\u{342}'),
+    ('\u{345}', '\u{345}'),
+    ('Ͱ', 'ͳ'),
+    ('͵', 'ͷ'),
+    ('ͺ', 'ͽ'),
+    ('Ϳ', 'Ϳ'),
+    ('΄', '΄'),
+    ('Ά', 'Ά'),
+    ('Έ', 'Ί'),
+    ('Ό', 'Ό'),
+    ('Ύ', 'Ρ'),
+    ('Σ', 'ϡ'),
+    ('ϰ', 'Ͽ'),
+    ('ᴦ', 'ᴪ'),
+    ('ᵝ', 'ᵡ'),
+    ('ᵦ', 'ᵪ'),
+    ('ᶿ', '\u{1dc1}'),
+    ('ἀ', 'ἕ'),
+    ('Ἐ', 'Ἕ'),
+    ('ἠ', 'ὅ'),
+    ('Ὀ', 'Ὅ'),
+    ('ὐ', 'ὗ'),
+    ('Ὑ', 'Ὑ'),
+    ('Ὓ', 'Ὓ'),
+    ('Ὕ', 'Ὕ'),
+    ('Ὗ', 'ώ'),
+    ('ᾀ', 'ᾴ'),
+    ('ᾶ', 'ῄ'),
+    ('ῆ', 'ΐ'),
+    ('ῖ', 'Ί'),
+    ('῝', '`'),
+    ('ῲ', 'ῴ'),
+    ('ῶ', '῾'),
+    ('Ω', 'Ω'),
+    ('ꭥ', 'ꭥ'),
+    ('𐅀', '𐆎'),
+    ('𐆠', '𐆠'),
+    ('𝈀', '𝉅'),
+];
+
+pub const GUJARATI: &'static [(char, char)] = &[
+    ('\u{951}', '\u{952}'),
+    ('।', '॥'),
+    ('\u{a81}', 'ઃ'),
+    ('અ', 'ઍ'),
+    ('એ', 'ઑ'),
+    ('ઓ', 'ન'),
+    ('પ', 'ર'),
+    ('લ', 'ળ'),
+    ('વ', 'હ'),
+    ('\u{abc}', '\u{ac5}'),
+    ('\u{ac7}', 'ૉ'),
+    ('ો', '\u{acd}'),
+    ('ૐ', 'ૐ'),
+    ('ૠ', '\u{ae3}'),
+    ('૦', '૱'),
+    ('ૹ', '\u{aff}'),
+    ('꠰', '꠹'),
+];
+
+pub const GUNJALA_GONDI: &'static [(char, char)] = &[
+    ('।', '॥'),
+    ('𑵠', '𑵥'),
+    ('𑵧', '𑵨'),
+    ('𑵪', '𑶎'),
+    ('\u{11d90}', '\u{11d91}'),
+    ('𑶓', '𑶘'),
+    ('𑶠', '𑶩'),
+];
+
+pub const GURMUKHI: &'static [(char, char)] = &[
+    ('\u{951}', '\u{952}'),
+    ('।', '॥'),
+    ('\u{a01}', 'ਃ'),
+    ('ਅ', 'ਊ'),
+    ('ਏ', 'ਐ'),
+    ('ਓ', 'ਨ'),
+    ('ਪ', 'ਰ'),
+    ('ਲ', 'ਲ਼'),
+    ('ਵ', 'ਸ਼'),
+    ('ਸ', 'ਹ'),
+    ('\u{a3c}', '\u{a3c}'),
+    ('ਾ', '\u{a42}'),
+    ('\u{a47}', '\u{a48}'),
+    ('\u{a4b}', '\u{a4d}'),
+    ('\u{a51}', '\u{a51}'),
+    ('ਖ਼', 'ੜ'),
+    ('ਫ਼', 'ਫ਼'),
+    ('੦', '੶'),
+    ('꠰', '꠹'),
+];
+
+pub const HAN: &'static [(char, char)] = &[
+    ('⺀', '⺙'),
+    ('⺛', '⻳'),
+    ('⼀', '⿕'),
+    ('、', '〃'),
+    ('々', '】'),
+    ('〓', '〟'),
+    ('〡', '\u{302d}'),
+    ('〰', '〰'),
+    ('〷', '〿'),
+    ('・', '・'),
+    ('㆐', '㆟'),
+    ('㇀', '㇣'),
+    ('㈠', '㉇'),
+    ('㊀', '㊰'),
+    ('㋀', '㋋'),
+    ('㋿', '㋿'),
+    ('㍘', '㍰'),
+    ('㍻', '㍿'),
+    ('㏠', '㏾'),
+    ('㐀', '䶿'),
+    ('一', '鿿'),
+    ('꜀', '꜇'),
+    ('豈', '舘'),
+    ('並', '龎'),
+    ('﹅', '﹆'),
+    ('｡', '･'),
+    ('𖿢', '𖿣'),
+    ('𖿰', '𖿱'),
+    ('𝍠', '𝍱'),
+    ('🉐', '🉑'),
+    ('𠀀', '𪛟'),
+    ('𪜀', '𫜹'),
+    ('𫝀', '𫠝'),
+    ('𫠠', '𬺡'),
+    ('𬺰', '𮯠'),
+    ('丽', '𪘀'),
+    ('𰀀', '𱍊'),
+    ('𱍐', '𲎯'),
+];
+
+pub const HANGUL: &'static [(char, char)] = &[
+    ('ᄀ', 'ᇿ'),
+    ('、', '〃'),
+    ('〈', '】'),
+    ('〓', '〟'),
+    ('\u{302e}', '〰'),
+    ('〷', '〷'),
+    ('・', '・'),
+    ('ㄱ', 'ㆎ'),
+    ('㈀', '㈞'),
+    ('㉠', '㉾'),
+    ('ꥠ', 'ꥼ'),
+    ('가', '힣'),
+    ('ힰ', 'ퟆ'),
+    ('ퟋ', 'ퟻ'),
+    ('﹅', '﹆'),
+    ('｡', '･'),
+    ('ﾠ', 'ﾾ'),
+    ('ￂ', 'ￇ'),
+    ('ￊ', 'ￏ'),
+    ('ￒ', 'ￗ'),
+    ('ￚ', 'ￜ'),
+];
+
+pub const HANIFI_ROHINGYA: &'static [(char, char)] = &[
+    ('،', '،'),
+    ('؛', '؛'),
+    ('؟', '؟'),
+    ('ـ', 'ـ'),
+    ('۔', '۔'),
+    ('𐴀', '\u{10d27}'),
+    ('𐴰', '𐴹'),
+];
+
+pub const HANUNOO: &'static [(char, char)] = &[('ᜠ', '᜶')];
+
+pub const HATRAN: &'static [(char, char)] =
+    &[('𐣠', '𐣲'), ('𐣴', '𐣵'), ('𐣻', '𐣿')];
+
+pub const HEBREW: &'static [(char, char)] = &[
+    ('\u{591}', '\u{5c7}'),
+    ('א', 'ת'),
+    ('ׯ', '״'),
+    ('יִ', 'זּ'),
+    ('טּ', 'לּ'),
+    ('מּ', 'מּ'),
+    ('נּ', 'סּ'),
+    ('ףּ', 'פּ'),
+    ('צּ', 'ﭏ'),
+];
+
+pub const HIRAGANA: &'static [(char, char)] = &[
+    ('、', '〃'),
+    ('〈', '】'),
+    ('〓', '〟'),
+    ('〰', '〵'),
+    ('〷', '〷'),
+    ('〼', '〽'),
+    ('ぁ', 'ゖ'),
+    ('\u{3099}', '゠'),
+    ('・', 'ー'),
+    ('﹅', '﹆'),
+    ('｡', '･'),
+    ('ｰ', 'ｰ'),
+    ('\u{ff9e}', '\u{ff9f}'),
+    ('𛀁', '𛄟'),
+    ('𛄲', '𛄲'),
+    ('𛅐', '𛅒'),
+    ('🈀', '🈀'),
+];
+
+pub const IMPERIAL_ARAMAIC: &'static [(char, char)] =
+    &[('𐡀', '𐡕'), ('𐡗', '𐡟')];
+
+pub const INHERITED: &'static [(char, char)] = &[
+    ('\u{300}', '\u{341}'),
+    ('\u{343}', '\u{344}'),
+    ('\u{346}', '\u{362}'),
+    ('\u{953}', '\u{954}'),
+    ('\u{1ab0}', '\u{1ace}'),
+    ('\u{1dc2}', '\u{1df7}'),
+    ('\u{1df9}', '\u{1df9}'),
+    ('\u{1dfb}', '\u{1dff}'),
+    ('\u{200c}', '\u{200d}'),
+    ('\u{20d0}', '\u{20ef}'),
+    ('\u{fe00}', '\u{fe0f}'),
+    ('\u{fe20}', '\u{fe2d}'),
+    ('\u{101fd}', '\u{101fd}'),
+    ('\u{1cf00}', '\u{1cf2d}'),
+    ('\u{1cf30}', '\u{1cf46}'),
+    ('\u{1d167}', '\u{1d169}'),
+    ('\u{1d17b}', '\u{1d182}'),
+    ('\u{1d185}', '\u{1d18b}'),
+    ('\u{1d1aa}', '\u{1d1ad}'),
+    ('\u{e0100}', '\u{e01ef}'),
+];
+
+pub const INSCRIPTIONAL_PAHLAVI: &'static [(char, char)] =
+    &[('𐭠', '𐭲'), ('𐭸', '𐭿')];
+
+pub const INSCRIPTIONAL_PARTHIAN: &'static [(char, char)] =
+    &[('𐭀', '𐭕'), ('𐭘', '𐭟')];
+
+pub const JAVANESE: &'static [(char, char)] =
+    &[('\u{a980}', '꧍'), ('ꧏ', '꧙'), ('꧞', '꧟')];
+
+pub const KAITHI: &'static [(char, char)] = &[
+    ('०', '९'),
+    ('꠰', '꠹'),
+    ('\u{11080}', '\u{110c2}'),
+    ('\u{110cd}', '\u{110cd}'),
+];
+
+pub const KANNADA: &'static [(char, char)] = &[
+    ('\u{951}', '\u{952}'),
+    ('।', '॥'),
+    ('ಀ', 'ಌ'),
+    ('ಎ', 'ಐ'),
+    ('ಒ', 'ನ'),
+    ('ಪ', 'ಳ'),
+    ('ವ', 'ಹ'),
+    ('\u{cbc}', 'ೄ'),
+    ('\u{cc6}', 'ೈ'),
+    ('ೊ', '\u{ccd}'),
+    ('\u{cd5}', '\u{cd6}'),
+    ('ೝ', 'ೞ'),
+    ('ೠ', '\u{ce3}'),
+    ('೦', '೯'),
+    ('ೱ', 'ೳ'),
+    ('\u{1cd0}', '\u{1cd0}'),
+    ('\u{1cd2}', '\u{1cd2}'),
+    ('\u{1cda}', '\u{1cda}'),
+    ('ᳲ', 'ᳲ'),
+    ('\u{1cf4}', '\u{1cf4}'),
+    ('꠰', '꠵'),
+];
+
+pub const KATAKANA: &'static [(char, char)] = &[
+    ('、', '〃'),
+    ('〈', '】'),
+    ('〓', '〟'),
+    ('〰', '〵'),
+    ('〷', '〷'),
+    ('〼', '〽'),
+    ('\u{3099}', '゜'),
+    ('゠', 'ヿ'),
+    ('ㇰ', 'ㇿ'),
+    ('㋐', '㋾'),
+    ('㌀', '㍗'),
+    ('﹅', '﹆'),
+    ('｡', '\u{ff9f}'),
+    ('𚿰', '𚿳'),
+    ('𚿵', '𚿻'),
+    ('𚿽', '𚿾'),
+    ('𛀀', '𛀀'),
+    ('𛄠', '𛄢'),
+    ('𛅕', '𛅕'),
+    ('𛅤', '𛅧'),
+];
+
+pub const KAWI: &'static [(char, char)] =
+    &[('\u{11f00}', '𑼐'), ('𑼒', '\u{11f3a}'), ('𑼾', '𑽙')];
+
+pub const KAYAH_LI: &'static [(char, char)] = &[('꤀', '꤯')];
+
+pub const KHAROSHTHI: &'static [(char, char)] = &[
+    ('𐨀', '\u{10a03}'),
+    ('\u{10a05}', '\u{10a06}'),
+    ('\u{10a0c}', '𐨓'),
+    ('𐨕', '𐨗'),
+    ('𐨙', '𐨵'),
+    ('\u{10a38}', '\u{10a3a}'),
+    ('\u{10a3f}', '𐩈'),
+    ('𐩐', '𐩘'),
+];
+
+pub const KHITAN_SMALL_SCRIPT: &'static [(char, char)] =
+    &[('\u{16fe4}', '\u{16fe4}'), ('𘬀', '𘳕')];
+
+pub const KHMER: &'static [(char, char)] =
+    &[('ក', '\u{17dd}'), ('០', '៩'), ('៰', '៹'), ('᧠', '᧿')];
+
+pub const KHOJKI: &'static [(char, char)] =
+    &[('૦', '૯'), ('꠰', '꠹'), ('𑈀', '𑈑'), ('𑈓', '\u{11241}')];
+
+pub const KHUDAWADI: &'static [(char, char)] =
+    &[('।', '॥'), ('꠰', '꠹'), ('𑊰', '\u{112ea}'), ('𑋰', '𑋹')];
+
+pub const LAO: &'static [(char, char)] = &[
+    ('ກ', 'ຂ'),
+    ('ຄ', 'ຄ'),
+    ('ຆ', 'ຊ'),
+    ('ຌ', 'ຣ'),
+    ('ລ', 'ລ'),
+    ('ວ', 'ຽ'),
+    ('ເ', 'ໄ'),
+    ('ໆ', 'ໆ'),
+    ('\u{ec8}', '\u{ece}'),
+    ('໐', '໙'),
+    ('ໜ', 'ໟ'),
+];
+
+pub const LATIN: &'static [(char, char)] = &[
+    ('A', 'Z'),
+    ('a', 'z'),
+    ('ª', 'ª'),
+    ('º', 'º'),
+    ('À', 'Ö'),
+    ('Ø', 'ö'),
+    ('ø', 'ʸ'),
+    ('ˠ', 'ˤ'),
+    ('\u{363}', '\u{36f}'),
+    ('\u{485}', '\u{486}'),
+    ('\u{951}', '\u{952}'),
+    ('჻', '჻'),
+    ('ᴀ', 'ᴥ'),
+    ('ᴬ', 'ᵜ'),
+    ('ᵢ', 'ᵥ'),
+    ('ᵫ', 'ᵷ'),
+    ('ᵹ', 'ᶾ'),
+    ('Ḁ', 'ỿ'),
+    ('\u{202f}', '\u{202f}'),
+    ('ⁱ', 'ⁱ'),
+    ('ⁿ', 'ⁿ'),
+    ('ₐ', 'ₜ'),
+    ('\u{20f0}', '\u{20f0}'),
+    ('K', 'Å'),
+    ('Ⅎ', 'Ⅎ'),
+    ('ⅎ', 'ⅎ'),
+    ('Ⅰ', 'ↈ'),
+    ('Ⱡ', 'Ɀ'),
+    ('꜀', '꜇'),
+    ('Ꜣ', 'ꞇ'),
+    ('Ꞌ', 'ꟊ'),
+    ('Ꟑ', 'ꟑ'),
+    ('ꟓ', 'ꟓ'),
+    ('ꟕ', 'ꟙ'),
+    ('ꟲ', 'ꟿ'),
+    ('꤮', '꤮'),
+    ('ꬰ', 'ꭚ'),
+    ('ꭜ', 'ꭤ'),
+    ('ꭦ', 'ꭩ'),
+    ('ﬀ', 'ﬆ'),
+    ('Ａ', 'Ｚ'),
+    ('ａ', 'ｚ'),
+    ('𐞀', '𐞅'),
+    ('𐞇', '𐞰'),
+    ('𐞲', '𐞺'),
+    ('𝼀', '𝼞'),
+    ('𝼥', '𝼪'),
+];
+
+pub const LEPCHA: &'static [(char, char)] =
+    &[('ᰀ', '\u{1c37}'), ('᰻', '᱉'), ('ᱍ', 'ᱏ')];
+
+pub const LIMBU: &'static [(char, char)] = &[
+    ('॥', '॥'),
+    ('ᤀ', 'ᤞ'),
+    ('\u{1920}', 'ᤫ'),
+    ('ᤰ', '\u{193b}'),
+    ('᥀', '᥀'),
+    ('᥄', '᥏'),
+];
+
+pub const LINEAR_A: &'static [(char, char)] =
+    &[('𐄇', '𐄳'), ('𐘀', '𐜶'), ('𐝀', '𐝕'), ('𐝠', '𐝧')];
+
+pub const LINEAR_B: &'static [(char, char)] = &[
+    ('𐀀', '𐀋'),
+    ('𐀍', '𐀦'),
+    ('𐀨', '𐀺'),
+    ('𐀼', '𐀽'),
+    ('𐀿', '𐁍'),
+    ('𐁐', '𐁝'),
+    ('𐂀', '𐃺'),
+    ('𐄀', '𐄂'),
+    ('𐄇', '𐄳'),
+    ('𐄷', '𐄿'),
+];
+
+pub const LISU: &'static [(char, char)] = &[('ꓐ', '꓿'), ('𑾰', '𑾰')];
+
+pub const LYCIAN: &'static [(char, char)] = &[('𐊀', '𐊜')];
+
+pub const LYDIAN: &'static [(char, char)] = &[('𐤠', '𐤹'), ('𐤿', '𐤿')];
+
+pub const MAHAJANI: &'static [(char, char)] =
+    &[('।', '९'), ('꠰', '꠹'), ('𑅐', '𑅶')];
+
+pub const MAKASAR: &'static [(char, char)] = &[('𑻠', '𑻸')];
+
+pub const MALAYALAM: &'static [(char, char)] = &[
+    ('\u{951}', '\u{952}'),
+    ('।', '॥'),
+    ('\u{d00}', 'ഌ'),
+    ('എ', 'ഐ'),
+    ('ഒ', '\u{d44}'),
+    ('െ', 'ൈ'),
+    ('ൊ', '൏'),
+    ('ൔ', '\u{d63}'),
+    ('൦', 'ൿ'),
+    ('\u{1cda}', '\u{1cda}'),
+    ('꠰', '꠲'),
+];
+
+pub const MANDAIC: &'static [(char, char)] =
+    &[('ـ', 'ـ'), ('ࡀ', '\u{85b}'), ('࡞', '࡞')];
+
+pub const MANICHAEAN: &'static [(char, char)] =
+    &[('ـ', 'ـ'), ('𐫀', '\u{10ae6}'), ('𐫫', '𐫶')];
+
+pub const MARCHEN: &'static [(char, char)] =
+    &[('𑱰', '𑲏'), ('\u{11c92}', '\u{11ca7}'), ('𑲩', '\u{11cb6}')];
+
+pub const MASARAM_GONDI: &'static [(char, char)] = &[
+    ('।', '॥'),
+    ('𑴀', '𑴆'),
+    ('𑴈', '𑴉'),
+    ('𑴋', '\u{11d36}'),
+    ('\u{11d3a}', '\u{11d3a}'),
+    ('\u{11d3c}', '\u{11d3d}'),
+    ('\u{11d3f}', '\u{11d47}'),
+    ('𑵐', '𑵙'),
+];
+
+pub const MEDEFAIDRIN: &'static [(char, char)] = &[('𖹀', '𖺚')];
+
+pub const MEETEI_MAYEK: &'static [(char, char)] =
+    &[('ꫠ', '\u{aaf6}'), ('ꯀ', '\u{abed}'), ('꯰', '꯹')];
+
+pub const MENDE_KIKAKUI: &'static [(char, char)] =
+    &[('𞠀', '𞣄'), ('𞣇', '\u{1e8d6}')];
+
+pub const MEROITIC_CURSIVE: &'static [(char, char)] =
+    &[('𐦠', '𐦷'), ('𐦼', '𐧏'), ('𐧒', '𐧿')];
+
+pub const MEROITIC_HIEROGLYPHS: &'static [(char, char)] = &[('𐦀', '𐦟')];
+
+pub const MIAO: &'static [(char, char)] =
+    &[('𖼀', '𖽊'), ('\u{16f4f}', '𖾇'), ('\u{16f8f}', '𖾟')];
+
+pub const MODI: &'static [(char, char)] =
+    &[('꠰', '꠹'), ('𑘀', '𑙄'), ('𑙐', '𑙙')];
+
+pub const MONGOLIAN: &'static [(char, char)] = &[
+    ('᠀', '᠙'),
+    ('ᠠ', 'ᡸ'),
+    ('ᢀ', 'ᢪ'),
+    ('\u{202f}', '\u{202f}'),
+    ('𑙠', '𑙬'),
+];
+
+pub const MRO: &'static [(char, char)] = &[('𖩀', '𖩞'), ('𖩠', '𖩩'), ('𖩮', '𖩯')];
+
+pub const MULTANI: &'static [(char, char)] =
+    &[('੦', '੯'), ('𑊀', '𑊆'), ('𑊈', '𑊈'), ('𑊊', '𑊍'), ('𑊏', '𑊝'), ('𑊟', '𑊩')];
+
+pub const MYANMAR: &'static [(char, char)] =
+    &[('က', '႟'), ('꤮', '꤮'), ('ꧠ', 'ꧾ'), ('ꩠ', 'ꩿ')];
+
+pub const NABATAEAN: &'static [(char, char)] = &[('𐢀', '𐢞'), ('𐢧', '𐢯')];
+
+pub const NAG_MUNDARI: &'static [(char, char)] = &[('𞓐', '𞓹')];
+
+pub const NANDINAGARI: &'static [(char, char)] = &[
+    ('।', '॥'),
+    ('೦', '೯'),
+    ('ᳩ', 'ᳩ'),
+    ('ᳲ', 'ᳲ'),
+    ('ᳺ', 'ᳺ'),
+    ('꠰', '꠵'),
+    ('𑦠', '𑦧'),
+    ('𑦪', '\u{119d7}'),
+    ('\u{119da}', '𑧤'),
+];
+
+pub const NEW_TAI_LUE: &'static [(char, char)] =
+    &[('ᦀ', 'ᦫ'), ('ᦰ', 'ᧉ'), ('᧐', '᧚'), ('᧞', '᧟')];
+
+pub const NEWA: &'static [(char, char)] = &[('𑐀', '𑑛'), ('𑑝', '𑑡')];
+
+pub const NKO: &'static [(char, char)] = &[
+    ('،', '،'),
+    ('؛', '؛'),
+    ('؟', '؟'),
+    ('߀', 'ߺ'),
+    ('\u{7fd}', '߿'),
+    ('﴾', '﴿'),
+];
+
+pub const NUSHU: &'static [(char, char)] = &[('𖿡', '𖿡'), ('𛅰', '𛋻')];
+
+pub const NYIAKENG_PUACHUE_HMONG: &'static [(char, char)] =
+    &[('𞄀', '𞄬'), ('\u{1e130}', '𞄽'), ('𞅀', '𞅉'), ('𞅎', '𞅏')];
+
+pub const OGHAM: &'static [(char, char)] = &[('\u{1680}', '᚜')];
+
+pub const OL_CHIKI: &'static [(char, char)] = &[('᱐', '᱿')];
+
+pub const OLD_HUNGARIAN: &'static [(char, char)] =
+    &[('𐲀', '𐲲'), ('𐳀', '𐳲'), ('𐳺', '𐳿')];
+
+pub const OLD_ITALIC: &'static [(char, char)] = &[('𐌀', '𐌣'), ('𐌭', '𐌯')];
+
+pub const OLD_NORTH_ARABIAN: &'static [(char, char)] = &[('𐪀', '𐪟')];
+
+pub const OLD_PERMIC: &'static [(char, char)] =
+    &[('\u{483}', '\u{483}'), ('𐍐', '\u{1037a}')];
+
+pub const OLD_PERSIAN: &'static [(char, char)] = &[('𐎠', '𐏃'), ('𐏈', '𐏕')];
+
+pub const OLD_SOGDIAN: &'static [(char, char)] = &[('𐼀', '𐼧')];
+
+pub const OLD_SOUTH_ARABIAN: &'static [(char, char)] = &[('𐩠', '𐩿')];
+
+pub const OLD_TURKIC: &'static [(char, char)] = &[('𐰀', '𐱈')];
+
+pub const OLD_UYGHUR: &'static [(char, char)] =
+    &[('ـ', 'ـ'), ('𐫲', '𐫲'), ('𐽰', '𐾉')];
+
+pub const ORIYA: &'static [(char, char)] = &[
+    ('\u{951}', '\u{952}'),
+    ('।', '॥'),
+    ('\u{b01}', 'ଃ'),
+    ('ଅ', 'ଌ'),
+    ('ଏ', 'ଐ'),
+    ('ଓ', 'ନ'),
+    ('ପ', 'ର'),
+    ('ଲ', 'ଳ'),
+    ('ଵ', 'ହ'),
+    ('\u{b3c}', '\u{b44}'),
+    ('େ', 'ୈ'),
+    ('ୋ', '\u{b4d}'),
+    ('\u{b55}', '\u{b57}'),
+    ('ଡ଼', 'ଢ଼'),
+    ('ୟ', '\u{b63}'),
+    ('୦', '୷'),
+    ('\u{1cda}', '\u{1cda}'),
+    ('ᳲ', 'ᳲ'),
+];
+
+pub const OSAGE: &'static [(char, char)] = &[('𐒰', '𐓓'), ('𐓘', '𐓻')];
+
+pub const OSMANYA: &'static [(char, char)] = &[('𐒀', '𐒝'), ('𐒠', '𐒩')];
+
+pub const PAHAWH_HMONG: &'static [(char, char)] =
+    &[('𖬀', '𖭅'), ('𖭐', '𖭙'), ('𖭛', '𖭡'), ('𖭣', '𖭷'), ('𖭽', '𖮏')];
+
+pub const PALMYRENE: &'static [(char, char)] = &[('𐡠', '𐡿')];
+
+pub const PAU_CIN_HAU: &'static [(char, char)] = &[('𑫀', '𑫸')];
+
+pub const PHAGS_PA: &'static [(char, char)] =
+    &[('᠂', '᠃'), ('᠅', '᠅'), ('ꡀ', '꡷')];
+
+pub const PHOENICIAN: &'static [(char, char)] = &[('𐤀', '𐤛'), ('𐤟', '𐤟')];
+
+pub const PSALTER_PAHLAVI: &'static [(char, char)] =
+    &[('ـ', 'ـ'), ('𐮀', '𐮑'), ('𐮙', '𐮜'), ('𐮩', '𐮯')];
+
+pub const REJANG: &'static [(char, char)] = &[('ꤰ', '꥓'), ('꥟', '꥟')];
+
+pub const RUNIC: &'static [(char, char)] = &[('ᚠ', 'ᛪ'), ('ᛮ', 'ᛸ')];
+
+pub const SAMARITAN: &'static [(char, char)] = &[('ࠀ', '\u{82d}'), ('࠰', '࠾')];
+
+pub const SAURASHTRA: &'static [(char, char)] =
+    &[('ꢀ', '\u{a8c5}'), ('꣎', '꣙')];
+
+pub const SHARADA: &'static [(char, char)] = &[
+    ('\u{951}', '\u{951}'),
+    ('\u{1cd7}', '\u{1cd7}'),
+    ('\u{1cd9}', '\u{1cd9}'),
+    ('\u{1cdc}', '\u{1cdd}'),
+    ('\u{1ce0}', '\u{1ce0}'),
+    ('\u{11180}', '𑇟'),
+];
+
+pub const SHAVIAN: &'static [(char, char)] = &[('𐑐', '𐑿')];
+
+pub const SIDDHAM: &'static [(char, char)] =
+    &[('𑖀', '\u{115b5}'), ('𑖸', '\u{115dd}')];
+
+pub const SIGNWRITING: &'static [(char, char)] =
+    &[('𝠀', '𝪋'), ('\u{1da9b}', '\u{1da9f}'), ('\u{1daa1}', '\u{1daaf}')];
+
+pub const SINHALA: &'static [(char, char)] = &[
+    ('।', '॥'),
+    ('\u{d81}', 'ඃ'),
+    ('අ', 'ඖ'),
+    ('ක', 'න'),
+    ('ඳ', 'ර'),
+    ('ල', 'ල'),
+    ('ව', 'ෆ'),
+    ('\u{dca}', '\u{dca}'),
+    ('\u{dcf}', '\u{dd4}'),
+    ('\u{dd6}', '\u{dd6}'),
+    ('ෘ', '\u{ddf}'),
+    ('෦', '෯'),
+    ('ෲ', '෴'),
+    ('𑇡', '𑇴'),
+];
+
+pub const SOGDIAN: &'static [(char, char)] = &[('ـ', 'ـ'), ('𐼰', '𐽙')];
+
+pub const SORA_SOMPENG: &'static [(char, char)] = &[('𑃐', '𑃨'), ('𑃰', '𑃹')];
+
+pub const SOYOMBO: &'static [(char, char)] = &[('𑩐', '𑪢')];
+
+pub const SUNDANESE: &'static [(char, char)] =
+    &[('\u{1b80}', 'ᮿ'), ('᳀', '᳇')];
+
+pub const SYLOTI_NAGRI: &'static [(char, char)] =
+    &[('।', '॥'), ('০', '৯'), ('ꠀ', '\u{a82c}')];
+
+pub const SYRIAC: &'static [(char, char)] = &[
+    ('،', '،'),
+    ('؛', '\u{61c}'),
+    ('؟', '؟'),
+    ('ـ', 'ـ'),
+    ('\u{64b}', '\u{655}'),
+    ('\u{670}', '\u{670}'),
+    ('܀', '܍'),
+    ('\u{70f}', '\u{74a}'),
+    ('ݍ', 'ݏ'),
+    ('ࡠ', 'ࡪ'),
+    ('\u{1df8}', '\u{1df8}'),
+    ('\u{1dfa}', '\u{1dfa}'),
+];
+
+pub const TAGALOG: &'static [(char, char)] =
+    &[('ᜀ', '᜕'), ('ᜟ', 'ᜟ'), ('᜵', '᜶')];
+
+pub const TAGBANWA: &'static [(char, char)] =
+    &[('᜵', '᜶'), ('ᝠ', 'ᝬ'), ('ᝮ', 'ᝰ'), ('\u{1772}', '\u{1773}')];
+
+pub const TAI_LE: &'static [(char, char)] =
+    &[('၀', '၉'), ('ᥐ', 'ᥭ'), ('ᥰ', 'ᥴ')];
+
+pub const TAI_THAM: &'static [(char, char)] = &[
+    ('ᨠ', '\u{1a5e}'),
+    ('\u{1a60}', '\u{1a7c}'),
+    ('\u{1a7f}', '᪉'),
+    ('᪐', '᪙'),
+    ('᪠', '᪭'),
+];
+
+pub const TAI_VIET: &'static [(char, char)] = &[('ꪀ', 'ꫂ'), ('ꫛ', '꫟')];
+
+pub const TAKRI: &'static [(char, char)] =
+    &[('।', '॥'), ('꠰', '꠹'), ('𑚀', '𑚹'), ('𑛀', '𑛉')];
+
+pub const TAMIL: &'static [(char, char)] = &[
+    ('\u{951}', '\u{952}'),
+    ('।', '॥'),
+    ('\u{b82}', 'ஃ'),
+    ('அ', 'ஊ'),
+    ('எ', 'ஐ'),
+    ('ஒ', 'க'),
+    ('ங', 'ச'),
+    ('ஜ', 'ஜ'),
+    ('ஞ', 'ட'),
+    ('ண', 'த'),
+    ('ந', 'ப'),
+    ('ம', 'ஹ'),
+    ('\u{bbe}', 'ூ'),
+    ('ெ', 'ை'),
+    ('ொ', '\u{bcd}'),
+    ('ௐ', 'ௐ'),
+    ('\u{bd7}', '\u{bd7}'),
+    ('௦', '௺'),
+    ('\u{1cda}', '\u{1cda}'),
+    ('ꣳ', 'ꣳ'),
+    ('\u{11301}', '\u{11301}'),
+    ('𑌃', '𑌃'),
+    ('\u{1133b}', '\u{1133c}'),
+    ('𑿀', '𑿱'),
+    ('𑿿', '𑿿'),
+];
+
+pub const TANGSA: &'static [(char, char)] = &[('𖩰', '𖪾'), ('𖫀', '𖫉')];
+
+pub const TANGUT: &'static [(char, char)] =
+    &[('𖿠', '𖿠'), ('𗀀', '𘟷'), ('𘠀', '𘫿'), ('𘴀', '𘴈')];
+
+pub const TELUGU: &'static [(char, char)] = &[
+    ('\u{951}', '\u{952}'),
+    ('।', '॥'),
+    ('\u{c00}', 'ఌ'),
+    ('ఎ', 'ఐ'),
+    ('ఒ', 'న'),
+    ('ప', 'హ'),
+    ('\u{c3c}', 'ౄ'),
+    ('\u{c46}', '\u{c48}'),
+    ('\u{c4a}', '\u{c4d}'),
+    ('\u{c55}', '\u{c56}'),
+    ('ౘ', 'ౚ'),
+    ('ౝ', 'ౝ'),
+    ('ౠ', '\u{c63}'),
+    ('౦', '౯'),
+    ('౷', '౿'),
+    ('\u{1cda}', '\u{1cda}'),
+    ('ᳲ', 'ᳲ'),
+];
+
+pub const THAANA: &'static [(char, char)] = &[
+    ('،', '،'),
+    ('؛', '\u{61c}'),
+    ('؟', '؟'),
+    ('٠', '٩'),
+    ('ހ', 'ޱ'),
+    ('ﷲ', 'ﷲ'),
+    ('﷽', '﷽'),
+];
+
+pub const THAI: &'static [(char, char)] = &[('ก', '\u{e3a}'), ('เ', '๛')];
+
+pub const TIBETAN: &'static [(char, char)] = &[
+    ('ༀ', 'ཇ'),
+    ('ཉ', 'ཬ'),
+    ('\u{f71}', '\u{f97}'),
+    ('\u{f99}', '\u{fbc}'),
+    ('྾', '࿌'),
+    ('࿎', '࿔'),
+    ('࿙', '࿚'),
+];
+
+pub const TIFINAGH: &'static [(char, char)] =
+    &[('ⴰ', 'ⵧ'), ('ⵯ', '⵰'), ('\u{2d7f}', '\u{2d7f}')];
+
+pub const TIRHUTA: &'static [(char, char)] = &[
+    ('\u{951}', '\u{952}'),
+    ('।', '॥'),
+    ('ᳲ', 'ᳲ'),
+    ('꠰', '꠹'),
+    ('𑒀', '𑓇'),
+    ('𑓐', '𑓙'),
+];
+
+pub const TOTO: &'static [(char, char)] = &[('𞊐', '\u{1e2ae}')];
+
+pub const UGARITIC: &'static [(char, char)] = &[('𐎀', '𐎝'), ('𐎟', '𐎟')];
+
+pub const VAI: &'static [(char, char)] = &[('ꔀ', 'ꘫ')];
+
+pub const VITHKUQI: &'static [(char, char)] = &[
+    ('𐕰', '𐕺'),
+    ('𐕼', '𐖊'),
+    ('𐖌', '𐖒'),
+    ('𐖔', '𐖕'),
+    ('𐖗', '𐖡'),
+    ('𐖣', '𐖱'),
+    ('𐖳', '𐖹'),
+    ('𐖻', '𐖼'),
+];
+
+pub const WANCHO: &'static [(char, char)] = &[('𞋀', '𞋹'), ('𞋿', '𞋿')];
+
+pub const WARANG_CITI: &'static [(char, char)] = &[('𑢠', '𑣲'), ('𑣿', '𑣿')];
+
+pub const YEZIDI: &'static [(char, char)] = &[
+    ('،', '،'),
+    ('؛', '؛'),
+    ('؟', '؟'),
+    ('٠', '٩'),
+    ('𐺀', '𐺩'),
+    ('\u{10eab}', '𐺭'),
+    ('𐺰', '𐺱'),
+];
+
+pub const YI: &'static [(char, char)] = &[
+    ('、', '。'),
+    ('〈', '】'),
+    ('〔', '〛'),
+    ('・', '・'),
+    ('ꀀ', 'ꒌ'),
+    ('꒐', '꓆'),
+    ('｡', '･'),
+];
+
+pub const ZANABAZAR_SQUARE: &'static [(char, char)] = &[('𑨀', '\u{11a47}')];
diff --git a/crates/regex-syntax/src/unicode_tables/sentence_break.rs b/crates/regex-syntax/src/unicode_tables/sentence_break.rs
new file mode 100644
index 0000000..2434873
--- /dev/null
+++ b/crates/regex-syntax/src/unicode_tables/sentence_break.rs
@@ -0,0 +1,2477 @@
+// DO NOT EDIT THIS FILE. IT WAS AUTOMATICALLY GENERATED BY:
+//
+//   ucd-generate sentence-break ucd-15.0.0 --chars
+//
+// Unicode version: 15.0.0.
+//
+// ucd-generate 0.2.14 is available on crates.io.
+
+pub const BY_NAME: &'static [(&'static str, &'static [(char, char)])] = &[
+    ("ATerm", ATERM),
+    ("CR", CR),
+    ("Close", CLOSE),
+    ("Extend", EXTEND),
+    ("Format", FORMAT),
+    ("LF", LF),
+    ("Lower", LOWER),
+    ("Numeric", NUMERIC),
+    ("OLetter", OLETTER),
+    ("SContinue", SCONTINUE),
+    ("STerm", STERM),
+    ("Sep", SEP),
+    ("Sp", SP),
+    ("Upper", UPPER),
+];
+
+pub const ATERM: &'static [(char, char)] =
+    &[('.', '.'), ('․', '․'), ('﹒', '﹒'), ('．', '．')];
+
+pub const CR: &'static [(char, char)] = &[('\r', '\r')];
+
+pub const CLOSE: &'static [(char, char)] = &[
+    ('"', '"'),
+    ('\'', ')'),
+    ('[', '['),
+    (']', ']'),
+    ('{', '{'),
+    ('}', '}'),
+    ('«', '«'),
+    ('»', '»'),
+    ('༺', '༽'),
+    ('᚛', '᚜'),
+    ('‘', '‟'),
+    ('‹', '›'),
+    ('⁅', '⁆'),
+    ('⁽', '⁾'),
+    ('₍', '₎'),
+    ('⌈', '⌋'),
+    ('〈', '〉'),
+    ('❛', '❠'),
+    ('❨', '❵'),
+    ('⟅', '⟆'),
+    ('⟦', '⟯'),
+    ('⦃', '⦘'),
+    ('⧘', '⧛'),
+    ('⧼', '⧽'),
+    ('⸀', '⸍'),
+    ('⸜', '⸝'),
+    ('⸠', '⸩'),
+    ('⹂', '⹂'),
+    ('⹕', '⹜'),
+    ('〈', '】'),
+    ('〔', '〛'),
+    ('〝', '〟'),
+    ('﴾', '﴿'),
+    ('︗', '︘'),
+    ('︵', '﹄'),
+    ('﹇', '﹈'),
+    ('﹙', '﹞'),
+    ('（', '）'),
+    ('［', '［'),
+    ('］', '］'),
+    ('｛', '｛'),
+    ('｝', '｝'),
+    ('｟', '｠'),
+    ('｢', '｣'),
+    ('🙶', '🙸'),
+];
+
+pub const EXTEND: &'static [(char, char)] = &[
+    ('\u{300}', '\u{36f}'),
+    ('\u{483}', '\u{489}'),
+    ('\u{591}', '\u{5bd}'),
+    ('\u{5bf}', '\u{5bf}'),
+    ('\u{5c1}', '\u{5c2}'),
+    ('\u{5c4}', '\u{5c5}'),
+    ('\u{5c7}', '\u{5c7}'),
+    ('\u{610}', '\u{61a}'),
+    ('\u{64b}', '\u{65f}'),
+    ('\u{670}', '\u{670}'),
+    ('\u{6d6}', '\u{6dc}'),
+    ('\u{6df}', '\u{6e4}'),
+    ('\u{6e7}', '\u{6e8}'),
+    ('\u{6ea}', '\u{6ed}'),
+    ('\u{711}', '\u{711}'),
+    ('\u{730}', '\u{74a}'),
+    ('\u{7a6}', '\u{7b0}'),
+    ('\u{7eb}', '\u{7f3}'),
+    ('\u{7fd}', '\u{7fd}'),
+    ('\u{816}', '\u{819}'),
+    ('\u{81b}', '\u{823}'),
+    ('\u{825}', '\u{827}'),
+    ('\u{829}', '\u{82d}'),
+    ('\u{859}', '\u{85b}'),
+    ('\u{898}', '\u{89f}'),
+    ('\u{8ca}', '\u{8e1}'),
+    ('\u{8e3}', 'ः'),
+    ('\u{93a}', '\u{93c}'),
+    ('ा', 'ॏ'),
+    ('\u{951}', '\u{957}'),
+    ('\u{962}', '\u{963}'),
+    ('\u{981}', 'ঃ'),
+    ('\u{9bc}', '\u{9bc}'),
+    ('\u{9be}', '\u{9c4}'),
+    ('ে', 'ৈ'),
+    ('ো', '\u{9cd}'),
+    ('\u{9d7}', '\u{9d7}'),
+    ('\u{9e2}', '\u{9e3}'),
+    ('\u{9fe}', '\u{9fe}'),
+    ('\u{a01}', 'ਃ'),
+    ('\u{a3c}', '\u{a3c}'),
+    ('ਾ', '\u{a42}'),
+    ('\u{a47}', '\u{a48}'),
+    ('\u{a4b}', '\u{a4d}'),
+    ('\u{a51}', '\u{a51}'),
+    ('\u{a70}', '\u{a71}'),
+    ('\u{a75}', '\u{a75}'),
+    ('\u{a81}', 'ઃ'),
+    ('\u{abc}', '\u{abc}'),
+    ('ા', '\u{ac5}'),
+    ('\u{ac7}', 'ૉ'),
+    ('ો', '\u{acd}'),
+    ('\u{ae2}', '\u{ae3}'),
+    ('\u{afa}', '\u{aff}'),
+    ('\u{b01}', 'ଃ'),
+    ('\u{b3c}', '\u{b3c}'),
+    ('\u{b3e}', '\u{b44}'),
+    ('େ', 'ୈ'),
+    ('ୋ', '\u{b4d}'),
+    ('\u{b55}', '\u{b57}'),
+    ('\u{b62}', '\u{b63}'),
+    ('\u{b82}', '\u{b82}'),
+    ('\u{bbe}', 'ூ'),
+    ('ெ', 'ை'),
+    ('ொ', '\u{bcd}'),
+    ('\u{bd7}', '\u{bd7}'),
+    ('\u{c00}', '\u{c04}'),
+    ('\u{c3c}', '\u{c3c}'),
+    ('\u{c3e}', 'ౄ'),
+    ('\u{c46}', '\u{c48}'),
+    ('\u{c4a}', '\u{c4d}'),
+    ('\u{c55}', '\u{c56}'),
+    ('\u{c62}', '\u{c63}'),
+    ('\u{c81}', 'ಃ'),
+    ('\u{cbc}', '\u{cbc}'),
+    ('ಾ', 'ೄ'),
+    ('\u{cc6}', 'ೈ'),
+    ('ೊ', '\u{ccd}'),
+    ('\u{cd5}', '\u{cd6}'),
+    ('\u{ce2}', '\u{ce3}'),
+    ('ೳ', 'ೳ'),
+    ('\u{d00}', 'ഃ'),
+    ('\u{d3b}', '\u{d3c}'),
+    ('\u{d3e}', '\u{d44}'),
+    ('െ', 'ൈ'),
+    ('ൊ', '\u{d4d}'),
+    ('\u{d57}', '\u{d57}'),
+    ('\u{d62}', '\u{d63}'),
+    ('\u{d81}', 'ඃ'),
+    ('\u{dca}', '\u{dca}'),
+    ('\u{dcf}', '\u{dd4}'),
+    ('\u{dd6}', '\u{dd6}'),
+    ('ෘ', '\u{ddf}'),
+    ('ෲ', 'ෳ'),
+    ('\u{e31}', '\u{e31}'),
+    ('\u{e34}', '\u{e3a}'),
+    ('\u{e47}', '\u{e4e}'),
+    ('\u{eb1}', '\u{eb1}'),
+    ('\u{eb4}', '\u{ebc}'),
+    ('\u{ec8}', '\u{ece}'),
+    ('\u{f18}', '\u{f19}'),
+    ('\u{f35}', '\u{f35}'),
+    ('\u{f37}', '\u{f37}'),
+    ('\u{f39}', '\u{f39}'),
+    ('༾', '༿'),
+    ('\u{f71}', '\u{f84}'),
+    ('\u{f86}', '\u{f87}'),
+    ('\u{f8d}', '\u{f97}'),
+    ('\u{f99}', '\u{fbc}'),
+    ('\u{fc6}', '\u{fc6}'),
+    ('ါ', '\u{103e}'),
+    ('ၖ', '\u{1059}'),
+    ('\u{105e}', '\u{1060}'),
+    ('ၢ', 'ၤ'),
+    ('ၧ', 'ၭ'),
+    ('\u{1071}', '\u{1074}'),
+    ('\u{1082}', '\u{108d}'),
+    ('ႏ', 'ႏ'),
+    ('ႚ', '\u{109d}'),
+    ('\u{135d}', '\u{135f}'),
+    ('\u{1712}', '᜕'),
+    ('\u{1732}', '᜴'),
+    ('\u{1752}', '\u{1753}'),
+    ('\u{1772}', '\u{1773}'),
+    ('\u{17b4}', '\u{17d3}'),
+    ('\u{17dd}', '\u{17dd}'),
+    ('\u{180b}', '\u{180d}'),
+    ('\u{180f}', '\u{180f}'),
+    ('\u{1885}', '\u{1886}'),
+    ('\u{18a9}', '\u{18a9}'),
+    ('\u{1920}', 'ᤫ'),
+    ('ᤰ', '\u{193b}'),
+    ('\u{1a17}', '\u{1a1b}'),
+    ('ᩕ', '\u{1a5e}'),
+    ('\u{1a60}', '\u{1a7c}'),
+    ('\u{1a7f}', '\u{1a7f}'),
+    ('\u{1ab0}', '\u{1ace}'),
+    ('\u{1b00}', 'ᬄ'),
+    ('\u{1b34}', '᭄'),
+    ('\u{1b6b}', '\u{1b73}'),
+    ('\u{1b80}', 'ᮂ'),
+    ('ᮡ', '\u{1bad}'),
+    ('\u{1be6}', '᯳'),
+    ('ᰤ', '\u{1c37}'),
+    ('\u{1cd0}', '\u{1cd2}'),
+    ('\u{1cd4}', '\u{1ce8}'),
+    ('\u{1ced}', '\u{1ced}'),
+    ('\u{1cf4}', '\u{1cf4}'),
+    ('᳷', '\u{1cf9}'),
+    ('\u{1dc0}', '\u{1dff}'),
+    ('\u{200c}', '\u{200d}'),
+    ('\u{20d0}', '\u{20f0}'),
+    ('\u{2cef}', '\u{2cf1}'),
+    ('\u{2d7f}', '\u{2d7f}'),
+    ('\u{2de0}', '\u{2dff}'),
+    ('\u{302a}', '\u{302f}'),
+    ('\u{3099}', '\u{309a}'),
+    ('\u{a66f}', '\u{a672}'),
+    ('\u{a674}', '\u{a67d}'),
+    ('\u{a69e}', '\u{a69f}'),
+    ('\u{a6f0}', '\u{a6f1}'),
+    ('\u{a802}', '\u{a802}'),
+    ('\u{a806}', '\u{a806}'),
+    ('\u{a80b}', '\u{a80b}'),
+    ('ꠣ', 'ꠧ'),
+    ('\u{a82c}', '\u{a82c}'),
+    ('ꢀ', 'ꢁ'),
+    ('ꢴ', '\u{a8c5}'),
+    ('\u{a8e0}', '\u{a8f1}'),
+    ('\u{a8ff}', '\u{a8ff}'),
+    ('\u{a926}', '\u{a92d}'),
+    ('\u{a947}', '꥓'),
+    ('\u{a980}', 'ꦃ'),
+    ('\u{a9b3}', '꧀'),
+    ('\u{a9e5}', '\u{a9e5}'),
+    ('\u{aa29}', '\u{aa36}'),
+    ('\u{aa43}', '\u{aa43}'),
+    ('\u{aa4c}', 'ꩍ'),
+    ('ꩻ', 'ꩽ'),
+    ('\u{aab0}', '\u{aab0}'),
+    ('\u{aab2}', '\u{aab4}'),
+    ('\u{aab7}', '\u{aab8}'),
+    ('\u{aabe}', '\u{aabf}'),
+    ('\u{aac1}', '\u{aac1}'),
+    ('ꫫ', 'ꫯ'),
+    ('ꫵ', '\u{aaf6}'),
+    ('ꯣ', 'ꯪ'),
+    ('꯬', '\u{abed}'),
+    ('\u{fb1e}', '\u{fb1e}'),
+    ('\u{fe00}', '\u{fe0f}'),
+    ('\u{fe20}', '\u{fe2f}'),
+    ('\u{ff9e}', '\u{ff9f}'),
+    ('\u{101fd}', '\u{101fd}'),
+    ('\u{102e0}', '\u{102e0}'),
+    ('\u{10376}', '\u{1037a}'),
+    ('\u{10a01}', '\u{10a03}'),
+    ('\u{10a05}', '\u{10a06}'),
+    ('\u{10a0c}', '\u{10a0f}'),
+    ('\u{10a38}', '\u{10a3a}'),
+    ('\u{10a3f}', '\u{10a3f}'),
+    ('\u{10ae5}', '\u{10ae6}'),
+    ('\u{10d24}', '\u{10d27}'),
+    ('\u{10eab}', '\u{10eac}'),
+    ('\u{10efd}', '\u{10eff}'),
+    ('\u{10f46}', '\u{10f50}'),
+    ('\u{10f82}', '\u{10f85}'),
+    ('𑀀', '𑀂'),
+    ('\u{11038}', '\u{11046}'),
+    ('\u{11070}', '\u{11070}'),
+    ('\u{11073}', '\u{11074}'),
+    ('\u{1107f}', '𑂂'),
+    ('𑂰', '\u{110ba}'),
+    ('\u{110c2}', '\u{110c2}'),
+    ('\u{11100}', '\u{11102}'),
+    ('\u{11127}', '\u{11134}'),
+    ('𑅅', '𑅆'),
+    ('\u{11173}', '\u{11173}'),
+    ('\u{11180}', '𑆂'),
+    ('𑆳', '𑇀'),
+    ('\u{111c9}', '\u{111cc}'),
+    ('𑇎', '\u{111cf}'),
+    ('𑈬', '\u{11237}'),
+    ('\u{1123e}', '\u{1123e}'),
+    ('\u{11241}', '\u{11241}'),
+    ('\u{112df}', '\u{112ea}'),
+    ('\u{11300}', '𑌃'),
+    ('\u{1133b}', '\u{1133c}'),
+    ('\u{1133e}', '𑍄'),
+    ('𑍇', '𑍈'),
+    ('𑍋', '𑍍'),
+    ('\u{11357}', '\u{11357}'),
+    ('𑍢', '𑍣'),
+    ('\u{11366}', '\u{1136c}'),
+    ('\u{11370}', '\u{11374}'),
+    ('𑐵', '\u{11446}'),
+    ('\u{1145e}', '\u{1145e}'),
+    ('\u{114b0}', '\u{114c3}'),
+    ('\u{115af}', '\u{115b5}'),
+    ('𑖸', '\u{115c0}'),
+    ('\u{115dc}', '\u{115dd}'),
+    ('𑘰', '\u{11640}'),
+    ('\u{116ab}', '\u{116b7}'),
+    ('\u{1171d}', '\u{1172b}'),
+    ('𑠬', '\u{1183a}'),
+    ('\u{11930}', '𑤵'),
+    ('𑤷', '𑤸'),
+    ('\u{1193b}', '\u{1193e}'),
+    ('𑥀', '𑥀'),
+    ('𑥂', '\u{11943}'),
+    ('𑧑', '\u{119d7}'),
+    ('\u{119da}', '\u{119e0}'),
+    ('𑧤', '𑧤'),
+    ('\u{11a01}', '\u{11a0a}'),
+    ('\u{11a33}', '𑨹'),
+    ('\u{11a3b}', '\u{11a3e}'),
+    ('\u{11a47}', '\u{11a47}'),
+    ('\u{11a51}', '\u{11a5b}'),
+    ('\u{11a8a}', '\u{11a99}'),
+    ('𑰯', '\u{11c36}'),
+    ('\u{11c38}', '\u{11c3f}'),
+    ('\u{11c92}', '\u{11ca7}'),
+    ('𑲩', '\u{11cb6}'),
+    ('\u{11d31}', '\u{11d36}'),
+    ('\u{11d3a}', '\u{11d3a}'),
+    ('\u{11d3c}', '\u{11d3d}'),
+    ('\u{11d3f}', '\u{11d45}'),
+    ('\u{11d47}', '\u{11d47}'),
+    ('𑶊', '𑶎'),
+    ('\u{11d90}', '\u{11d91}'),
+    ('𑶓', '\u{11d97}'),
+    ('\u{11ef3}', '𑻶'),
+    ('\u{11f00}', '\u{11f01}'),
+    ('𑼃', '𑼃'),
+    ('𑼴', '\u{11f3a}'),
+    ('𑼾', '\u{11f42}'),
+    ('\u{13440}', '\u{13440}'),
+    ('\u{13447}', '\u{13455}'),
+    ('\u{16af0}', '\u{16af4}'),
+    ('\u{16b30}', '\u{16b36}'),
+    ('\u{16f4f}', '\u{16f4f}'),
+    ('𖽑', '𖾇'),
+    ('\u{16f8f}', '\u{16f92}'),
+    ('\u{16fe4}', '\u{16fe4}'),
+    ('𖿰', '𖿱'),
+    ('\u{1bc9d}', '\u{1bc9e}'),
+    ('\u{1cf00}', '\u{1cf2d}'),
+    ('\u{1cf30}', '\u{1cf46}'),
+    ('\u{1d165}', '\u{1d169}'),
+    ('𝅭', '\u{1d172}'),
+    ('\u{1d17b}', '\u{1d182}'),
+    ('\u{1d185}', '\u{1d18b}'),
+    ('\u{1d1aa}', '\u{1d1ad}'),
+    ('\u{1d242}', '\u{1d244}'),
+    ('\u{1da00}', '\u{1da36}'),
+    ('\u{1da3b}', '\u{1da6c}'),
+    ('\u{1da75}', '\u{1da75}'),
+    ('\u{1da84}', '\u{1da84}'),
+    ('\u{1da9b}', '\u{1da9f}'),
+    ('\u{1daa1}', '\u{1daaf}'),
+    ('\u{1e000}', '\u{1e006}'),
+    ('\u{1e008}', '\u{1e018}'),
+    ('\u{1e01b}', '\u{1e021}'),
+    ('\u{1e023}', '\u{1e024}'),
+    ('\u{1e026}', '\u{1e02a}'),
+    ('\u{1e08f}', '\u{1e08f}'),
+    ('\u{1e130}', '\u{1e136}'),
+    ('\u{1e2ae}', '\u{1e2ae}'),
+    ('\u{1e2ec}', '\u{1e2ef}'),
+    ('\u{1e4ec}', '\u{1e4ef}'),
+    ('\u{1e8d0}', '\u{1e8d6}'),
+    ('\u{1e944}', '\u{1e94a}'),
+    ('\u{e0020}', '\u{e007f}'),
+    ('\u{e0100}', '\u{e01ef}'),
+];
+
+pub const FORMAT: &'static [(char, char)] = &[
+    ('\u{ad}', '\u{ad}'),
+    ('\u{600}', '\u{605}'),
+    ('\u{61c}', '\u{61c}'),
+    ('\u{6dd}', '\u{6dd}'),
+    ('\u{70f}', '\u{70f}'),
+    ('\u{890}', '\u{891}'),
+    ('\u{8e2}', '\u{8e2}'),
+    ('\u{180e}', '\u{180e}'),
+    ('\u{200b}', '\u{200b}'),
+    ('\u{200e}', '\u{200f}'),
+    ('\u{202a}', '\u{202e}'),
+    ('\u{2060}', '\u{2064}'),
+    ('\u{2066}', '\u{206f}'),
+    ('\u{feff}', '\u{feff}'),
+    ('\u{fff9}', '\u{fffb}'),
+    ('\u{110bd}', '\u{110bd}'),
+    ('\u{110cd}', '\u{110cd}'),
+    ('\u{13430}', '\u{1343f}'),
+    ('\u{1bca0}', '\u{1bca3}'),
+    ('\u{1d173}', '\u{1d17a}'),
+    ('\u{e0001}', '\u{e0001}'),
+];
+
+pub const LF: &'static [(char, char)] = &[('\n', '\n')];
+
+pub const LOWER: &'static [(char, char)] = &[
+    ('a', 'z'),
+    ('ª', 'ª'),
+    ('µ', 'µ'),
+    ('º', 'º'),
+    ('ß', 'ö'),
+    ('ø', 'ÿ'),
+    ('ā', 'ā'),
+    ('ă', 'ă'),
+    ('ą', 'ą'),
+    ('ć', 'ć'),
+    ('ĉ', 'ĉ'),
+    ('ċ', 'ċ'),
+    ('č', 'č'),
+    ('ď', 'ď'),
+    ('đ', 'đ'),
+    ('ē', 'ē'),
+    ('ĕ', 'ĕ'),
+    ('ė', 'ė'),
+    ('ę', 'ę'),
+    ('ě', 'ě'),
+    ('ĝ', 'ĝ'),
+    ('ğ', 'ğ'),
+    ('ġ', 'ġ'),
+    ('ģ', 'ģ'),
+    ('ĥ', 'ĥ'),
+    ('ħ', 'ħ'),
+    ('ĩ', 'ĩ'),
+    ('ī', 'ī'),
+    ('ĭ', 'ĭ'),
+    ('į', 'į'),
+    ('ı', 'ı'),
+    ('ĳ', 'ĳ'),
+    ('ĵ', 'ĵ'),
+    ('ķ', 'ĸ'),
+    ('ĺ', 'ĺ'),
+    ('ļ', 'ļ'),
+    ('ľ', 'ľ'),
+    ('ŀ', 'ŀ'),
+    ('ł', 'ł'),
+    ('ń', 'ń'),
+    ('ņ', 'ņ'),
+    ('ň', 'ŉ'),
+    ('ŋ', 'ŋ'),
+    ('ō', 'ō'),
+    ('ŏ', 'ŏ'),
+    ('ő', 'ő'),
+    ('œ', 'œ'),
+    ('ŕ', 'ŕ'),
+    ('ŗ', 'ŗ'),
+    ('ř', 'ř'),
+    ('ś', 'ś'),
+    ('ŝ', 'ŝ'),
+    ('ş', 'ş'),
+    ('š', 'š'),
+    ('ţ', 'ţ'),
+    ('ť', 'ť'),
+    ('ŧ', 'ŧ'),
+    ('ũ', 'ũ'),
+    ('ū', 'ū'),
+    ('ŭ', 'ŭ'),
+    ('ů', 'ů'),
+    ('ű', 'ű'),
+    ('ų', 'ų'),
+    ('ŵ', 'ŵ'),
+    ('ŷ', 'ŷ'),
+    ('ź', 'ź'),
+    ('ż', 'ż'),
+    ('ž', 'ƀ'),
+    ('ƃ', 'ƃ'),
+    ('ƅ', 'ƅ'),
+    ('ƈ', 'ƈ'),
+    ('ƌ', 'ƍ'),
+    ('ƒ', 'ƒ'),
+    ('ƕ', 'ƕ'),
+    ('ƙ', 'ƛ'),
+    ('ƞ', 'ƞ'),
+    ('ơ', 'ơ'),
+    ('ƣ', 'ƣ'),
+    ('ƥ', 'ƥ'),
+    ('ƨ', 'ƨ'),
+    ('ƪ', 'ƫ'),
+    ('ƭ', 'ƭ'),
+    ('ư', 'ư'),
+    ('ƴ', 'ƴ'),
+    ('ƶ', 'ƶ'),
+    ('ƹ', 'ƺ'),
+    ('ƽ', 'ƿ'),
+    ('ǆ', 'ǆ'),
+    ('ǉ', 'ǉ'),
+    ('ǌ', 'ǌ'),
+    ('ǎ', 'ǎ'),
+    ('ǐ', 'ǐ'),
+    ('ǒ', 'ǒ'),
+    ('ǔ', 'ǔ'),
+    ('ǖ', 'ǖ'),
+    ('ǘ', 'ǘ'),
+    ('ǚ', 'ǚ'),
+    ('ǜ', 'ǝ'),
+    ('ǟ', 'ǟ'),
+    ('ǡ', 'ǡ'),
+    ('ǣ', 'ǣ'),
+    ('ǥ', 'ǥ'),
+    ('ǧ', 'ǧ'),
+    ('ǩ', 'ǩ'),
+    ('ǫ', 'ǫ'),
+    ('ǭ', 'ǭ'),
+    ('ǯ', 'ǰ'),
+    ('ǳ', 'ǳ'),
+    ('ǵ', 'ǵ'),
+    ('ǹ', 'ǹ'),
+    ('ǻ', 'ǻ'),
+    ('ǽ', 'ǽ'),
+    ('ǿ', 'ǿ'),
+    ('ȁ', 'ȁ'),
+    ('ȃ', 'ȃ'),
+    ('ȅ', 'ȅ'),
+    ('ȇ', 'ȇ'),
+    ('ȉ', 'ȉ'),
+    ('ȋ', 'ȋ'),
+    ('ȍ', 'ȍ'),
+    ('ȏ', 'ȏ'),
+    ('ȑ', 'ȑ'),
+    ('ȓ', 'ȓ'),
+    ('ȕ', 'ȕ'),
+    ('ȗ', 'ȗ'),
+    ('ș', 'ș'),
+    ('ț', 'ț'),
+    ('ȝ', 'ȝ'),
+    ('ȟ', 'ȟ'),
+    ('ȡ', 'ȡ'),
+    ('ȣ', 'ȣ'),
+    ('ȥ', 'ȥ'),
+    ('ȧ', 'ȧ'),
+    ('ȩ', 'ȩ'),
+    ('ȫ', 'ȫ'),
+    ('ȭ', 'ȭ'),
+    ('ȯ', 'ȯ'),
+    ('ȱ', 'ȱ'),
+    ('ȳ', 'ȹ'),
+    ('ȼ', 'ȼ'),
+    ('ȿ', 'ɀ'),
+    ('ɂ', 'ɂ'),
+    ('ɇ', 'ɇ'),
+    ('ɉ', 'ɉ'),
+    ('ɋ', 'ɋ'),
+    ('ɍ', 'ɍ'),
+    ('ɏ', 'ʓ'),
+    ('ʕ', 'ʸ'),
+    ('ˀ', 'ˁ'),
+    ('ˠ', 'ˤ'),
+    ('ͱ', 'ͱ'),
+    ('ͳ', 'ͳ'),
+    ('ͷ', 'ͷ'),
+    ('ͺ', 'ͽ'),
+    ('ΐ', 'ΐ'),
+    ('ά', 'ώ'),
+    ('ϐ', 'ϑ'),
+    ('ϕ', 'ϗ'),
+    ('ϙ', 'ϙ'),
+    ('ϛ', 'ϛ'),
+    ('ϝ', 'ϝ'),
+    ('ϟ', 'ϟ'),
+    ('ϡ', 'ϡ'),
+    ('ϣ', 'ϣ'),
+    ('ϥ', 'ϥ'),
+    ('ϧ', 'ϧ'),
+    ('ϩ', 'ϩ'),
+    ('ϫ', 'ϫ'),
+    ('ϭ', 'ϭ'),
+    ('ϯ', 'ϳ'),
+    ('ϵ', 'ϵ'),
+    ('ϸ', 'ϸ'),
+    ('ϻ', 'ϼ'),
+    ('а', 'џ'),
+    ('ѡ', 'ѡ'),
+    ('ѣ', 'ѣ'),
+    ('ѥ', 'ѥ'),
+    ('ѧ', 'ѧ'),
+    ('ѩ', 'ѩ'),
+    ('ѫ', 'ѫ'),
+    ('ѭ', 'ѭ'),
+    ('ѯ', 'ѯ'),
+    ('ѱ', 'ѱ'),
+    ('ѳ', 'ѳ'),
+    ('ѵ', 'ѵ'),
+    ('ѷ', 'ѷ'),
+    ('ѹ', 'ѹ'),
+    ('ѻ', 'ѻ'),
+    ('ѽ', 'ѽ'),
+    ('ѿ', 'ѿ'),
+    ('ҁ', 'ҁ'),
+    ('ҋ', 'ҋ'),
+    ('ҍ', 'ҍ'),
+    ('ҏ', 'ҏ'),
+    ('ґ', 'ґ'),
+    ('ғ', 'ғ'),
+    ('ҕ', 'ҕ'),
+    ('җ', 'җ'),
+    ('ҙ', 'ҙ'),
+    ('қ', 'қ'),
+    ('ҝ', 'ҝ'),
+    ('ҟ', 'ҟ'),
+    ('ҡ', 'ҡ'),
+    ('ң', 'ң'),
+    ('ҥ', 'ҥ'),
+    ('ҧ', 'ҧ'),
+    ('ҩ', 'ҩ'),
+    ('ҫ', 'ҫ'),
+    ('ҭ', 'ҭ'),
+    ('ү', 'ү'),
+    ('ұ', 'ұ'),
+    ('ҳ', 'ҳ'),
+    ('ҵ', 'ҵ'),
+    ('ҷ', 'ҷ'),
+    ('ҹ', 'ҹ'),
+    ('һ', 'һ'),
+    ('ҽ', 'ҽ'),
+    ('ҿ', 'ҿ'),
+    ('ӂ', 'ӂ'),
+    ('ӄ', 'ӄ'),
+    ('ӆ', 'ӆ'),
+    ('ӈ', 'ӈ'),
+    ('ӊ', 'ӊ'),
+    ('ӌ', 'ӌ'),
+    ('ӎ', 'ӏ'),
+    ('ӑ', 'ӑ'),
+    ('ӓ', 'ӓ'),
+    ('ӕ', 'ӕ'),
+    ('ӗ', 'ӗ'),
+    ('ә', 'ә'),
+    ('ӛ', 'ӛ'),
+    ('ӝ', 'ӝ'),
+    ('ӟ', 'ӟ'),
+    ('ӡ', 'ӡ'),
+    ('ӣ', 'ӣ'),
+    ('ӥ', 'ӥ'),
+    ('ӧ', 'ӧ'),
+    ('ө', 'ө'),
+    ('ӫ', 'ӫ'),
+    ('ӭ', 'ӭ'),
+    ('ӯ', 'ӯ'),
+    ('ӱ', 'ӱ'),
+    ('ӳ', 'ӳ'),
+    ('ӵ', 'ӵ'),
+    ('ӷ', 'ӷ'),
+    ('ӹ', 'ӹ'),
+    ('ӻ', 'ӻ'),
+    ('ӽ', 'ӽ'),
+    ('ӿ', 'ӿ'),
+    ('ԁ', 'ԁ'),
+    ('ԃ', 'ԃ'),
+    ('ԅ', 'ԅ'),
+    ('ԇ', 'ԇ'),
+    ('ԉ', 'ԉ'),
+    ('ԋ', 'ԋ'),
+    ('ԍ', 'ԍ'),
+    ('ԏ', 'ԏ'),
+    ('ԑ', 'ԑ'),
+    ('ԓ', 'ԓ'),
+    ('ԕ', 'ԕ'),
+    ('ԗ', 'ԗ'),
+    ('ԙ', 'ԙ'),
+    ('ԛ', 'ԛ'),
+    ('ԝ', 'ԝ'),
+    ('ԟ', 'ԟ'),
+    ('ԡ', 'ԡ'),
+    ('ԣ', 'ԣ'),
+    ('ԥ', 'ԥ'),
+    ('ԧ', 'ԧ'),
+    ('ԩ', 'ԩ'),
+    ('ԫ', 'ԫ'),
+    ('ԭ', 'ԭ'),
+    ('ԯ', 'ԯ'),
+    ('ՠ', 'ֈ'),
+    ('ჼ', 'ჼ'),
+    ('ᏸ', 'ᏽ'),
+    ('ᲀ', 'ᲈ'),
+    ('ᴀ', 'ᶿ'),
+    ('ḁ', 'ḁ'),
+    ('ḃ', 'ḃ'),
+    ('ḅ', 'ḅ'),
+    ('ḇ', 'ḇ'),
+    ('ḉ', 'ḉ'),
+    ('ḋ', 'ḋ'),
+    ('ḍ', 'ḍ'),
+    ('ḏ', 'ḏ'),
+    ('ḑ', 'ḑ'),
+    ('ḓ', 'ḓ'),
+    ('ḕ', 'ḕ'),
+    ('ḗ', 'ḗ'),
+    ('ḙ', 'ḙ'),
+    ('ḛ', 'ḛ'),
+    ('ḝ', 'ḝ'),
+    ('ḟ', 'ḟ'),
+    ('ḡ', 'ḡ'),
+    ('ḣ', 'ḣ'),
+    ('ḥ', 'ḥ'),
+    ('ḧ', 'ḧ'),
+    ('ḩ', 'ḩ'),
+    ('ḫ', 'ḫ'),
+    ('ḭ', 'ḭ'),
+    ('ḯ', 'ḯ'),
+    ('ḱ', 'ḱ'),
+    ('ḳ', 'ḳ'),
+    ('ḵ', 'ḵ'),
+    ('ḷ', 'ḷ'),
+    ('ḹ', 'ḹ'),
+    ('ḻ', 'ḻ'),
+    ('ḽ', 'ḽ'),
+    ('ḿ', 'ḿ'),
+    ('ṁ', 'ṁ'),
+    ('ṃ', 'ṃ'),
+    ('ṅ', 'ṅ'),
+    ('ṇ', 'ṇ'),
+    ('ṉ', 'ṉ'),
+    ('ṋ', 'ṋ'),
+    ('ṍ', 'ṍ'),
+    ('ṏ', 'ṏ'),
+    ('ṑ', 'ṑ'),
+    ('ṓ', 'ṓ'),
+    ('ṕ', 'ṕ'),
+    ('ṗ', 'ṗ'),
+    ('ṙ', 'ṙ'),
+    ('ṛ', 'ṛ'),
+    ('ṝ', 'ṝ'),
+    ('ṟ', 'ṟ'),
+    ('ṡ', 'ṡ'),
+    ('ṣ', 'ṣ'),
+    ('ṥ', 'ṥ'),
+    ('ṧ', 'ṧ'),
+    ('ṩ', 'ṩ'),
+    ('ṫ', 'ṫ'),
+    ('ṭ', 'ṭ'),
+    ('ṯ', 'ṯ'),
+    ('ṱ', 'ṱ'),
+    ('ṳ', 'ṳ'),
+    ('ṵ', 'ṵ'),
+    ('ṷ', 'ṷ'),
+    ('ṹ', 'ṹ'),
+    ('ṻ', 'ṻ'),
+    ('ṽ', 'ṽ'),
+    ('ṿ', 'ṿ'),
+    ('ẁ', 'ẁ'),
+    ('ẃ', 'ẃ'),
+    ('ẅ', 'ẅ'),
+    ('ẇ', 'ẇ'),
+    ('ẉ', 'ẉ'),
+    ('ẋ', 'ẋ'),
+    ('ẍ', 'ẍ'),
+    ('ẏ', 'ẏ'),
+    ('ẑ', 'ẑ'),
+    ('ẓ', 'ẓ'),
+    ('ẕ', 'ẝ'),
+    ('ẟ', 'ẟ'),
+    ('ạ', 'ạ'),
+    ('ả', 'ả'),
+    ('ấ', 'ấ'),
+    ('ầ', 'ầ'),
+    ('ẩ', 'ẩ'),
+    ('ẫ', 'ẫ'),
+    ('ậ', 'ậ'),
+    ('ắ', 'ắ'),
+    ('ằ', 'ằ'),
+    ('ẳ', 'ẳ'),
+    ('ẵ', 'ẵ'),
+    ('ặ', 'ặ'),
+    ('ẹ', 'ẹ'),
+    ('ẻ', 'ẻ'),
+    ('ẽ', 'ẽ'),
+    ('ế', 'ế'),
+    ('ề', 'ề'),
+    ('ể', 'ể'),
+    ('ễ', 'ễ'),
+    ('ệ', 'ệ'),
+    ('ỉ', 'ỉ'),
+    ('ị', 'ị'),
+    ('ọ', 'ọ'),
+    ('ỏ', 'ỏ'),
+    ('ố', 'ố'),
+    ('ồ', 'ồ'),
+    ('ổ', 'ổ'),
+    ('ỗ', 'ỗ'),
+    ('ộ', 'ộ'),
+    ('ớ', 'ớ'),
+    ('ờ', 'ờ'),
+    ('ở', 'ở'),
+    ('ỡ', 'ỡ'),
+    ('ợ', 'ợ'),
+    ('ụ', 'ụ'),
+    ('ủ', 'ủ'),
+    ('ứ', 'ứ'),
+    ('ừ', 'ừ'),
+    ('ử', 'ử'),
+    ('ữ', 'ữ'),
+    ('ự', 'ự'),
+    ('ỳ', 'ỳ'),
+    ('ỵ', 'ỵ'),
+    ('ỷ', 'ỷ'),
+    ('ỹ', 'ỹ'),
+    ('ỻ', 'ỻ'),
+    ('ỽ', 'ỽ'),
+    ('ỿ', 'ἇ'),
+    ('ἐ', 'ἕ'),
+    ('ἠ', 'ἧ'),
+    ('ἰ', 'ἷ'),
+    ('ὀ', 'ὅ'),
+    ('ὐ', 'ὗ'),
+    ('ὠ', 'ὧ'),
+    ('ὰ', 'ώ'),
+    ('ᾀ', 'ᾇ'),
+    ('ᾐ', 'ᾗ'),
+    ('ᾠ', 'ᾧ'),
+    ('ᾰ', 'ᾴ'),
+    ('ᾶ', 'ᾷ'),
+    ('ι', 'ι'),
+    ('ῂ', 'ῄ'),
+    ('ῆ', 'ῇ'),
+    ('ῐ', 'ΐ'),
+    ('ῖ', 'ῗ'),
+    ('ῠ', 'ῧ'),
+    ('ῲ', 'ῴ'),
+    ('ῶ', 'ῷ'),
+    ('ⁱ', 'ⁱ'),
+    ('ⁿ', 'ⁿ'),
+    ('ₐ', 'ₜ'),
+    ('ℊ', 'ℊ'),
+    ('ℎ', 'ℏ'),
+    ('ℓ', 'ℓ'),
+    ('ℯ', 'ℯ'),
+    ('ℴ', 'ℴ'),
+    ('ℹ', 'ℹ'),
+    ('ℼ', 'ℽ'),
+    ('ⅆ', 'ⅉ'),
+    ('ⅎ', 'ⅎ'),
+    ('ⅰ', 'ⅿ'),
+    ('ↄ', 'ↄ'),
+    ('ⓐ', 'ⓩ'),
+    ('ⰰ', 'ⱟ'),
+    ('ⱡ', 'ⱡ'),
+    ('ⱥ', 'ⱦ'),
+    ('ⱨ', 'ⱨ'),
+    ('ⱪ', 'ⱪ'),
+    ('ⱬ', 'ⱬ'),
+    ('ⱱ', 'ⱱ'),
+    ('ⱳ', 'ⱴ'),
+    ('ⱶ', 'ⱽ'),
+    ('ⲁ', 'ⲁ'),
+    ('ⲃ', 'ⲃ'),
+    ('ⲅ', 'ⲅ'),
+    ('ⲇ', 'ⲇ'),
+    ('ⲉ', 'ⲉ'),
+    ('ⲋ', 'ⲋ'),
+    ('ⲍ', 'ⲍ'),
+    ('ⲏ', 'ⲏ'),
+    ('ⲑ', 'ⲑ'),
+    ('ⲓ', 'ⲓ'),
+    ('ⲕ', 'ⲕ'),
+    ('ⲗ', 'ⲗ'),
+    ('ⲙ', 'ⲙ'),
+    ('ⲛ', 'ⲛ'),
+    ('ⲝ', 'ⲝ'),
+    ('ⲟ', 'ⲟ'),
+    ('ⲡ', 'ⲡ'),
+    ('ⲣ', 'ⲣ'),
+    ('ⲥ', 'ⲥ'),
+    ('ⲧ', 'ⲧ'),
+    ('ⲩ', 'ⲩ'),
+    ('ⲫ', 'ⲫ'),
+    ('ⲭ', 'ⲭ'),
+    ('ⲯ', 'ⲯ'),
+    ('ⲱ', 'ⲱ'),
+    ('ⲳ', 'ⲳ'),
+    ('ⲵ', 'ⲵ'),
+    ('ⲷ', 'ⲷ'),
+    ('ⲹ', 'ⲹ'),
+    ('ⲻ', 'ⲻ'),
+    ('ⲽ', 'ⲽ'),
+    ('ⲿ', 'ⲿ'),
+    ('ⳁ', 'ⳁ'),
+    ('ⳃ', 'ⳃ'),
+    ('ⳅ', 'ⳅ'),
+    ('ⳇ', 'ⳇ'),
+    ('ⳉ', 'ⳉ'),
+    ('ⳋ', 'ⳋ'),
+    ('ⳍ', 'ⳍ'),
+    ('ⳏ', 'ⳏ'),
+    ('ⳑ', 'ⳑ'),
+    ('ⳓ', 'ⳓ'),
+    ('ⳕ', 'ⳕ'),
+    ('ⳗ', 'ⳗ'),
+    ('ⳙ', 'ⳙ'),
+    ('ⳛ', 'ⳛ'),
+    ('ⳝ', 'ⳝ'),
+    ('ⳟ', 'ⳟ'),
+    ('ⳡ', 'ⳡ'),
+    ('ⳣ', 'ⳤ'),
+    ('ⳬ', 'ⳬ'),
+    ('ⳮ', 'ⳮ'),
+    ('ⳳ', 'ⳳ'),
+    ('ⴀ', 'ⴥ'),
+    ('ⴧ', 'ⴧ'),
+    ('ⴭ', 'ⴭ'),
+    ('ꙁ', 'ꙁ'),
+    ('ꙃ', 'ꙃ'),
+    ('ꙅ', 'ꙅ'),
+    ('ꙇ', 'ꙇ'),
+    ('ꙉ', 'ꙉ'),
+    ('ꙋ', 'ꙋ'),
+    ('ꙍ', 'ꙍ'),
+    ('ꙏ', 'ꙏ'),
+    ('ꙑ', 'ꙑ'),
+    ('ꙓ', 'ꙓ'),
+    ('ꙕ', 'ꙕ'),
+    ('ꙗ', 'ꙗ'),
+    ('ꙙ', 'ꙙ'),
+    ('ꙛ', 'ꙛ'),
+    ('ꙝ', 'ꙝ'),
+    ('ꙟ', 'ꙟ'),
+    ('ꙡ', 'ꙡ'),
+    ('ꙣ', 'ꙣ'),
+    ('ꙥ', 'ꙥ'),
+    ('ꙧ', 'ꙧ'),
+    ('ꙩ', 'ꙩ'),
+    ('ꙫ', 'ꙫ'),
+    ('ꙭ', 'ꙭ'),
+    ('ꚁ', 'ꚁ'),
+    ('ꚃ', 'ꚃ'),
+    ('ꚅ', 'ꚅ'),
+    ('ꚇ', 'ꚇ'),
+    ('ꚉ', 'ꚉ'),
+    ('ꚋ', 'ꚋ'),
+    ('ꚍ', 'ꚍ'),
+    ('ꚏ', 'ꚏ'),
+    ('ꚑ', 'ꚑ'),
+    ('ꚓ', 'ꚓ'),
+    ('ꚕ', 'ꚕ'),
+    ('ꚗ', 'ꚗ'),
+    ('ꚙ', 'ꚙ'),
+    ('ꚛ', 'ꚝ'),
+    ('ꜣ', 'ꜣ'),
+    ('ꜥ', 'ꜥ'),
+    ('ꜧ', 'ꜧ'),
+    ('ꜩ', 'ꜩ'),
+    ('ꜫ', 'ꜫ'),
+    ('ꜭ', 'ꜭ'),
+    ('ꜯ', 'ꜱ'),
+    ('ꜳ', 'ꜳ'),
+    ('ꜵ', 'ꜵ'),
+    ('ꜷ', 'ꜷ'),
+    ('ꜹ', 'ꜹ'),
+    ('ꜻ', 'ꜻ'),
+    ('ꜽ', 'ꜽ'),
+    ('ꜿ', 'ꜿ'),
+    ('ꝁ', 'ꝁ'),
+    ('ꝃ', 'ꝃ'),
+    ('ꝅ', 'ꝅ'),
+    ('ꝇ', 'ꝇ'),
+    ('ꝉ', 'ꝉ'),
+    ('ꝋ', 'ꝋ'),
+    ('ꝍ', 'ꝍ'),
+    ('ꝏ', 'ꝏ'),
+    ('ꝑ', 'ꝑ'),
+    ('ꝓ', 'ꝓ'),
+    ('ꝕ', 'ꝕ'),
+    ('ꝗ', 'ꝗ'),
+    ('ꝙ', 'ꝙ'),
+    ('ꝛ', 'ꝛ'),
+    ('ꝝ', 'ꝝ'),
+    ('ꝟ', 'ꝟ'),
+    ('ꝡ', 'ꝡ'),
+    ('ꝣ', 'ꝣ'),
+    ('ꝥ', 'ꝥ'),
+    ('ꝧ', 'ꝧ'),
+    ('ꝩ', 'ꝩ'),
+    ('ꝫ', 'ꝫ'),
+    ('ꝭ', 'ꝭ'),
+    ('ꝯ', 'ꝸ'),
+    ('ꝺ', 'ꝺ'),
+    ('ꝼ', 'ꝼ'),
+    ('ꝿ', 'ꝿ'),
+    ('ꞁ', 'ꞁ'),
+    ('ꞃ', 'ꞃ'),
+    ('ꞅ', 'ꞅ'),
+    ('ꞇ', 'ꞇ'),
+    ('ꞌ', 'ꞌ'),
+    ('ꞎ', 'ꞎ'),
+    ('ꞑ', 'ꞑ'),
+    ('ꞓ', 'ꞕ'),
+    ('ꞗ', 'ꞗ'),
+    ('ꞙ', 'ꞙ'),
+    ('ꞛ', 'ꞛ'),
+    ('ꞝ', 'ꞝ'),
+    ('ꞟ', 'ꞟ'),
+    ('ꞡ', 'ꞡ'),
+    ('ꞣ', 'ꞣ'),
+    ('ꞥ', 'ꞥ'),
+    ('ꞧ', 'ꞧ'),
+    ('ꞩ', 'ꞩ'),
+    ('ꞯ', 'ꞯ'),
+    ('ꞵ', 'ꞵ'),
+    ('ꞷ', 'ꞷ'),
+    ('ꞹ', 'ꞹ'),
+    ('ꞻ', 'ꞻ'),
+    ('ꞽ', 'ꞽ'),
+    ('ꞿ', 'ꞿ'),
+    ('ꟁ', 'ꟁ'),
+    ('ꟃ', 'ꟃ'),
+    ('ꟈ', 'ꟈ'),
+    ('ꟊ', 'ꟊ'),
+    ('ꟑ', 'ꟑ'),
+    ('ꟓ', 'ꟓ'),
+    ('ꟕ', 'ꟕ'),
+    ('ꟗ', 'ꟗ'),
+    ('ꟙ', 'ꟙ'),
+    ('ꟲ', 'ꟴ'),
+    ('ꟶ', 'ꟶ'),
+    ('ꟸ', 'ꟺ'),
+    ('ꬰ', 'ꭚ'),
+    ('ꭜ', 'ꭩ'),
+    ('ꭰ', 'ꮿ'),
+    ('ﬀ', 'ﬆ'),
+    ('ﬓ', 'ﬗ'),
+    ('ａ', 'ｚ'),
+    ('𐐨', '𐑏'),
+    ('𐓘', '𐓻'),
+    ('𐖗', '𐖡'),
+    ('𐖣', '𐖱'),
+    ('𐖳', '𐖹'),
+    ('𐖻', '𐖼'),
+    ('𐞀', '𐞀'),
+    ('𐞃', '𐞅'),
+    ('𐞇', '𐞰'),
+    ('𐞲', '𐞺'),
+    ('𐳀', '𐳲'),
+    ('𑣀', '𑣟'),
+    ('𖹠', '𖹿'),
+    ('𝐚', '𝐳'),
+    ('𝑎', '𝑔'),
+    ('𝑖', '𝑧'),
+    ('𝒂', '𝒛'),
+    ('𝒶', '𝒹'),
+    ('𝒻', '𝒻'),
+    ('𝒽', '𝓃'),
+    ('𝓅', '𝓏'),
+    ('𝓪', '𝔃'),
+    ('𝔞', '𝔷'),
+    ('𝕒', '𝕫'),
+    ('𝖆', '𝖟'),
+    ('𝖺', '𝗓'),
+    ('𝗮', '𝘇'),
+    ('𝘢', '𝘻'),
+    ('𝙖', '𝙯'),
+    ('𝚊', '𝚥'),
+    ('𝛂', '𝛚'),
+    ('𝛜', '𝛡'),
+    ('𝛼', '𝜔'),
+    ('𝜖', '𝜛'),
+    ('𝜶', '𝝎'),
+    ('𝝐', '𝝕'),
+    ('𝝰', '𝞈'),
+    ('𝞊', '𝞏'),
+    ('𝞪', '𝟂'),
+    ('𝟄', '𝟉'),
+    ('𝟋', '𝟋'),
+    ('𝼀', '𝼉'),
+    ('𝼋', '𝼞'),
+    ('𝼥', '𝼪'),
+    ('𞀰', '𞁭'),
+    ('𞤢', '𞥃'),
+];
+
+pub const NUMERIC: &'static [(char, char)] = &[
+    ('0', '9'),
+    ('٠', '٩'),
+    ('٫', '٬'),
+    ('۰', '۹'),
+    ('߀', '߉'),
+    ('०', '९'),
+    ('০', '৯'),
+    ('੦', '੯'),
+    ('૦', '૯'),
+    ('୦', '୯'),
+    ('௦', '௯'),
+    ('౦', '౯'),
+    ('೦', '೯'),
+    ('൦', '൯'),
+    ('෦', '෯'),
+    ('๐', '๙'),
+    ('໐', '໙'),
+    ('༠', '༩'),
+    ('၀', '၉'),
+    ('႐', '႙'),
+    ('០', '៩'),
+    ('᠐', '᠙'),
+    ('᥆', '᥏'),
+    ('᧐', '᧙'),
+    ('᪀', '᪉'),
+    ('᪐', '᪙'),
+    ('᭐', '᭙'),
+    ('᮰', '᮹'),
+    ('᱀', '᱉'),
+    ('᱐', '᱙'),
+    ('꘠', '꘩'),
+    ('꣐', '꣙'),
+    ('꤀', '꤉'),
+    ('꧐', '꧙'),
+    ('꧰', '꧹'),
+    ('꩐', '꩙'),
+    ('꯰', '꯹'),
+    ('０', '９'),
+    ('𐒠', '𐒩'),
+    ('𐴰', '𐴹'),
+    ('𑁦', '𑁯'),
+    ('𑃰', '𑃹'),
+    ('𑄶', '𑄿'),
+    ('𑇐', '𑇙'),
+    ('𑋰', '𑋹'),
+    ('𑑐', '𑑙'),
+    ('𑓐', '𑓙'),
+    ('𑙐', '𑙙'),
+    ('𑛀', '𑛉'),
+    ('𑜰', '𑜹'),
+    ('𑣠', '𑣩'),
+    ('𑥐', '𑥙'),
+    ('𑱐', '𑱙'),
+    ('𑵐', '𑵙'),
+    ('𑶠', '𑶩'),
+    ('𑽐', '𑽙'),
+    ('𖩠', '𖩩'),
+    ('𖫀', '𖫉'),
+    ('𖭐', '𖭙'),
+    ('𝟎', '𝟿'),
+    ('𞅀', '𞅉'),
+    ('𞋰', '𞋹'),
+    ('𞓰', '𞓹'),
+    ('𞥐', '𞥙'),
+    ('🯰', '🯹'),
+];
+
+pub const OLETTER: &'static [(char, char)] = &[
+    ('ƻ', 'ƻ'),
+    ('ǀ', 'ǃ'),
+    ('ʔ', 'ʔ'),
+    ('ʹ', 'ʿ'),
+    ('ˆ', 'ˑ'),
+    ('ˬ', 'ˬ'),
+    ('ˮ', 'ˮ'),
+    ('ʹ', 'ʹ'),
+    ('ՙ', 'ՙ'),
+    ('א', 'ת'),
+    ('ׯ', '׳'),
+    ('ؠ', 'ي'),
+    ('ٮ', 'ٯ'),
+    ('ٱ', 'ۓ'),
+    ('ە', 'ە'),
+    ('ۥ', 'ۦ'),
+    ('ۮ', 'ۯ'),
+    ('ۺ', 'ۼ'),
+    ('ۿ', 'ۿ'),
+    ('ܐ', 'ܐ'),
+    ('ܒ', 'ܯ'),
+    ('ݍ', 'ޥ'),
+    ('ޱ', 'ޱ'),
+    ('ߊ', 'ߪ'),
+    ('ߴ', 'ߵ'),
+    ('ߺ', 'ߺ'),
+    ('ࠀ', 'ࠕ'),
+    ('ࠚ', 'ࠚ'),
+    ('ࠤ', 'ࠤ'),
+    ('ࠨ', 'ࠨ'),
+    ('ࡀ', 'ࡘ'),
+    ('ࡠ', 'ࡪ'),
+    ('ࡰ', 'ࢇ'),
+    ('ࢉ', 'ࢎ'),
+    ('ࢠ', 'ࣉ'),
+    ('ऄ', 'ह'),
+    ('ऽ', 'ऽ'),
+    ('ॐ', 'ॐ'),
+    ('क़', 'ॡ'),
+    ('ॱ', 'ঀ'),
+    ('অ', 'ঌ'),
+    ('এ', 'ঐ'),
+    ('ও', 'ন'),
+    ('প', 'র'),
+    ('ল', 'ল'),
+    ('শ', 'হ'),
+    ('ঽ', 'ঽ'),
+    ('ৎ', 'ৎ'),
+    ('ড়', 'ঢ়'),
+    ('য়', 'ৡ'),
+    ('ৰ', 'ৱ'),
+    ('ৼ', 'ৼ'),
+    ('ਅ', 'ਊ'),
+    ('ਏ', 'ਐ'),
+    ('ਓ', 'ਨ'),
+    ('ਪ', 'ਰ'),
+    ('ਲ', 'ਲ਼'),
+    ('ਵ', 'ਸ਼'),
+    ('ਸ', 'ਹ'),
+    ('ਖ਼', 'ੜ'),
+    ('ਫ਼', 'ਫ਼'),
+    ('ੲ', 'ੴ'),
+    ('અ', 'ઍ'),
+    ('એ', 'ઑ'),
+    ('ઓ', 'ન'),
+    ('પ', 'ર'),
+    ('લ', 'ળ'),
+    ('વ', 'હ'),
+    ('ઽ', 'ઽ'),
+    ('ૐ', 'ૐ'),
+    ('ૠ', 'ૡ'),
+    ('ૹ', 'ૹ'),
+    ('ଅ', 'ଌ'),
+    ('ଏ', 'ଐ'),
+    ('ଓ', 'ନ'),
+    ('ପ', 'ର'),
+    ('ଲ', 'ଳ'),
+    ('ଵ', 'ହ'),
+    ('ଽ', 'ଽ'),
+    ('ଡ଼', 'ଢ଼'),
+    ('ୟ', 'ୡ'),
+    ('ୱ', 'ୱ'),
+    ('ஃ', 'ஃ'),
+    ('அ', 'ஊ'),
+    ('எ', 'ஐ'),
+    ('ஒ', 'க'),
+    ('ங', 'ச'),
+    ('ஜ', 'ஜ'),
+    ('ஞ', 'ட'),
+    ('ண', 'த'),
+    ('ந', 'ப'),
+    ('ம', 'ஹ'),
+    ('ௐ', 'ௐ'),
+    ('అ', 'ఌ'),
+    ('ఎ', 'ఐ'),
+    ('ఒ', 'న'),
+    ('ప', 'హ'),
+    ('ఽ', 'ఽ'),
+    ('ౘ', 'ౚ'),
+    ('ౝ', 'ౝ'),
+    ('ౠ', 'ౡ'),
+    ('ಀ', 'ಀ'),
+    ('ಅ', 'ಌ'),
+    ('ಎ', 'ಐ'),
+    ('ಒ', 'ನ'),
+    ('ಪ', 'ಳ'),
+    ('ವ', 'ಹ'),
+    ('ಽ', 'ಽ'),
+    ('ೝ', 'ೞ'),
+    ('ೠ', 'ೡ'),
+    ('ೱ', 'ೲ'),
+    ('ഄ', 'ഌ'),
+    ('എ', 'ഐ'),
+    ('ഒ', 'ഺ'),
+    ('ഽ', 'ഽ'),
+    ('ൎ', 'ൎ'),
+    ('ൔ', 'ൖ'),
+    ('ൟ', 'ൡ'),
+    ('ൺ', 'ൿ'),
+    ('අ', 'ඖ'),
+    ('ක', 'න'),
+    ('ඳ', 'ර'),
+    ('ල', 'ල'),
+    ('ව', 'ෆ'),
+    ('ก', 'ะ'),
+    ('า', 'ำ'),
+    ('เ', 'ๆ'),
+    ('ກ', 'ຂ'),
+    ('ຄ', 'ຄ'),
+    ('ຆ', 'ຊ'),
+    ('ຌ', 'ຣ'),
+    ('ລ', 'ລ'),
+    ('ວ', 'ະ'),
+    ('າ', 'ຳ'),
+    ('ຽ', 'ຽ'),
+    ('ເ', 'ໄ'),
+    ('ໆ', 'ໆ'),
+    ('ໜ', 'ໟ'),
+    ('ༀ', 'ༀ'),
+    ('ཀ', 'ཇ'),
+    ('ཉ', 'ཬ'),
+    ('ྈ', 'ྌ'),
+    ('က', 'ဪ'),
+    ('ဿ', 'ဿ'),
+    ('ၐ', 'ၕ'),
+    ('ၚ', 'ၝ'),
+    ('ၡ', 'ၡ'),
+    ('ၥ', 'ၦ'),
+    ('ၮ', 'ၰ'),
+    ('ၵ', 'ႁ'),
+    ('ႎ', 'ႎ'),
+    ('ა', 'ჺ'),
+    ('ჽ', 'ቈ'),
+    ('ቊ', 'ቍ'),
+    ('ቐ', 'ቖ'),
+    ('ቘ', 'ቘ'),
+    ('ቚ', 'ቝ'),
+    ('በ', 'ኈ'),
+    ('ኊ', 'ኍ'),
+    ('ነ', 'ኰ'),
+    ('ኲ', 'ኵ'),
+    ('ኸ', 'ኾ'),
+    ('ዀ', 'ዀ'),
+    ('ዂ', 'ዅ'),
+    ('ወ', 'ዖ'),
+    ('ዘ', 'ጐ'),
+    ('ጒ', 'ጕ'),
+    ('ጘ', 'ፚ'),
+    ('ᎀ', 'ᎏ'),
+    ('ᐁ', 'ᙬ'),
+    ('ᙯ', 'ᙿ'),
+    ('ᚁ', 'ᚚ'),
+    ('ᚠ', 'ᛪ'),
+    ('ᛮ', 'ᛸ'),
+    ('ᜀ', 'ᜑ'),
+    ('ᜟ', 'ᜱ'),
+    ('ᝀ', 'ᝑ'),
+    ('ᝠ', 'ᝬ'),
+    ('ᝮ', 'ᝰ'),
+    ('ក', 'ឳ'),
+    ('ៗ', 'ៗ'),
+    ('ៜ', 'ៜ'),
+    ('ᠠ', 'ᡸ'),
+    ('ᢀ', 'ᢄ'),
+    ('ᢇ', 'ᢨ'),
+    ('ᢪ', 'ᢪ'),
+    ('ᢰ', 'ᣵ'),
+    ('ᤀ', 'ᤞ'),
+    ('ᥐ', 'ᥭ'),
+    ('ᥰ', 'ᥴ'),
+    ('ᦀ', 'ᦫ'),
+    ('ᦰ', 'ᧉ'),
+    ('ᨀ', 'ᨖ'),
+    ('ᨠ', 'ᩔ'),
+    ('ᪧ', 'ᪧ'),
+    ('ᬅ', 'ᬳ'),
+    ('ᭅ', 'ᭌ'),
+    ('ᮃ', 'ᮠ'),
+    ('ᮮ', 'ᮯ'),
+    ('ᮺ', 'ᯥ'),
+    ('ᰀ', 'ᰣ'),
+    ('ᱍ', 'ᱏ'),
+    ('ᱚ', 'ᱽ'),
+    ('Ა', 'Ჺ'),
+    ('Ჽ', 'Ჿ'),
+    ('ᳩ', 'ᳬ'),
+    ('ᳮ', 'ᳳ'),
+    ('ᳵ', 'ᳶ'),
+    ('ᳺ', 'ᳺ'),
+    ('ℵ', 'ℸ'),
+    ('ↀ', 'ↂ'),
+    ('ↅ', 'ↈ'),
+    ('ⴰ', 'ⵧ'),
+    ('ⵯ', 'ⵯ'),
+    ('ⶀ', 'ⶖ'),
+    ('ⶠ', 'ⶦ'),
+    ('ⶨ', 'ⶮ'),
+    ('ⶰ', 'ⶶ'),
+    ('ⶸ', 'ⶾ'),
+    ('ⷀ', 'ⷆ'),
+    ('ⷈ', 'ⷎ'),
+    ('ⷐ', 'ⷖ'),
+    ('ⷘ', 'ⷞ'),
+    ('ⸯ', 'ⸯ'),
+    ('々', '〇'),
+    ('〡', '〩'),
+    ('〱', '〵'),
+    ('〸', '〼'),
+    ('ぁ', 'ゖ'),
+    ('ゝ', 'ゟ'),
+    ('ァ', 'ヺ'),
+    ('ー', 'ヿ'),
+    ('ㄅ', 'ㄯ'),
+    ('ㄱ', 'ㆎ'),
+    ('ㆠ', 'ㆿ'),
+    ('ㇰ', 'ㇿ'),
+    ('㐀', '䶿'),
+    ('一', 'ꒌ'),
+    ('ꓐ', 'ꓽ'),
+    ('ꔀ', 'ꘌ'),
+    ('ꘐ', 'ꘟ'),
+    ('ꘪ', 'ꘫ'),
+    ('ꙮ', 'ꙮ'),
+    ('ꙿ', 'ꙿ'),
+    ('ꚠ', 'ꛯ'),
+    ('ꜗ', 'ꜟ'),
+    ('ꞈ', 'ꞈ'),
+    ('ꞏ', 'ꞏ'),
+    ('ꟷ', 'ꟷ'),
+    ('ꟻ', 'ꠁ'),
+    ('ꠃ', 'ꠅ'),
+    ('ꠇ', 'ꠊ'),
+    ('ꠌ', 'ꠢ'),
+    ('ꡀ', 'ꡳ'),
+    ('ꢂ', 'ꢳ'),
+    ('ꣲ', 'ꣷ'),
+    ('ꣻ', 'ꣻ'),
+    ('ꣽ', 'ꣾ'),
+    ('ꤊ', 'ꤥ'),
+    ('ꤰ', 'ꥆ'),
+    ('ꥠ', 'ꥼ'),
+    ('ꦄ', 'ꦲ'),
+    ('ꧏ', 'ꧏ'),
+    ('ꧠ', 'ꧤ'),
+    ('ꧦ', 'ꧯ'),
+    ('ꧺ', 'ꧾ'),
+    ('ꨀ', 'ꨨ'),
+    ('ꩀ', 'ꩂ'),
+    ('ꩄ', 'ꩋ'),
+    ('ꩠ', 'ꩶ'),
+    ('ꩺ', 'ꩺ'),
+    ('ꩾ', 'ꪯ'),
+    ('ꪱ', 'ꪱ'),
+    ('ꪵ', 'ꪶ'),
+    ('ꪹ', 'ꪽ'),
+    ('ꫀ', 'ꫀ'),
+    ('ꫂ', 'ꫂ'),
+    ('ꫛ', 'ꫝ'),
+    ('ꫠ', 'ꫪ'),
+    ('ꫲ', 'ꫴ'),
+    ('ꬁ', 'ꬆ'),
+    ('ꬉ', 'ꬎ'),
+    ('ꬑ', 'ꬖ'),
+    ('ꬠ', 'ꬦ'),
+    ('ꬨ', 'ꬮ'),
+    ('ꯀ', 'ꯢ'),
+    ('가', '힣'),
+    ('ힰ', 'ퟆ'),
+    ('ퟋ', 'ퟻ'),
+    ('豈', '舘'),
+    ('並', '龎'),
+    ('יִ', 'יִ'),
+    ('ײַ', 'ﬨ'),
+    ('שׁ', 'זּ'),
+    ('טּ', 'לּ'),
+    ('מּ', 'מּ'),
+    ('נּ', 'סּ'),
+    ('ףּ', 'פּ'),
+    ('צּ', 'ﮱ'),
+    ('ﯓ', 'ﴽ'),
+    ('ﵐ', 'ﶏ'),
+    ('ﶒ', 'ﷇ'),
+    ('ﷰ', 'ﷻ'),
+    ('ﹰ', 'ﹴ'),
+    ('ﹶ', 'ﻼ'),
+    ('ｦ', 'ﾝ'),
+    ('ﾠ', 'ﾾ'),
+    ('ￂ', 'ￇ'),
+    ('ￊ', 'ￏ'),
+    ('ￒ', 'ￗ'),
+    ('ￚ', 'ￜ'),
+    ('𐀀', '𐀋'),
+    ('𐀍', '𐀦'),
+    ('𐀨', '𐀺'),
+    ('𐀼', '𐀽'),
+    ('𐀿', '𐁍'),
+    ('𐁐', '𐁝'),
+    ('𐂀', '𐃺'),
+    ('𐅀', '𐅴'),
+    ('𐊀', '𐊜'),
+    ('𐊠', '𐋐'),
+    ('𐌀', '𐌟'),
+    ('𐌭', '𐍊'),
+    ('𐍐', '𐍵'),
+    ('𐎀', '𐎝'),
+    ('𐎠', '𐏃'),
+    ('𐏈', '𐏏'),
+    ('𐏑', '𐏕'),
+    ('𐑐', '𐒝'),
+    ('𐔀', '𐔧'),
+    ('𐔰', '𐕣'),
+    ('𐘀', '𐜶'),
+    ('𐝀', '𐝕'),
+    ('𐝠', '𐝧'),
+    ('𐞁', '𐞂'),
+    ('𐠀', '𐠅'),
+    ('𐠈', '𐠈'),
+    ('𐠊', '𐠵'),
+    ('𐠷', '𐠸'),
+    ('𐠼', '𐠼'),
+    ('𐠿', '𐡕'),
+    ('𐡠', '𐡶'),
+    ('𐢀', '𐢞'),
+    ('𐣠', '𐣲'),
+    ('𐣴', '𐣵'),
+    ('𐤀', '𐤕'),
+    ('𐤠', '𐤹'),
+    ('𐦀', '𐦷'),
+    ('𐦾', '𐦿'),
+    ('𐨀', '𐨀'),
+    ('𐨐', '𐨓'),
+    ('𐨕', '𐨗'),
+    ('𐨙', '𐨵'),
+    ('𐩠', '𐩼'),
+    ('𐪀', '𐪜'),
+    ('𐫀', '𐫇'),
+    ('𐫉', '𐫤'),
+    ('𐬀', '𐬵'),
+    ('𐭀', '𐭕'),
+    ('𐭠', '𐭲'),
+    ('𐮀', '𐮑'),
+    ('𐰀', '𐱈'),
+    ('𐴀', '𐴣'),
+    ('𐺀', '𐺩'),
+    ('𐺰', '𐺱'),
+    ('𐼀', '𐼜'),
+    ('𐼧', '𐼧'),
+    ('𐼰', '𐽅'),
+    ('𐽰', '𐾁'),
+    ('𐾰', '𐿄'),
+    ('𐿠', '𐿶'),
+    ('𑀃', '𑀷'),
+    ('𑁱', '𑁲'),
+    ('𑁵', '𑁵'),
+    ('𑂃', '𑂯'),
+    ('𑃐', '𑃨'),
+    ('𑄃', '𑄦'),
+    ('𑅄', '𑅄'),
+    ('𑅇', '𑅇'),
+    ('𑅐', '𑅲'),
+    ('𑅶', '𑅶'),
+    ('𑆃', '𑆲'),
+    ('𑇁', '𑇄'),
+    ('𑇚', '𑇚'),
+    ('𑇜', '𑇜'),
+    ('𑈀', '𑈑'),
+    ('𑈓', '𑈫'),
+    ('𑈿', '𑉀'),
+    ('𑊀', '𑊆'),
+    ('𑊈', '𑊈'),
+    ('𑊊', '𑊍'),
+    ('𑊏', '𑊝'),
+    ('𑊟', '𑊨'),
+    ('𑊰', '𑋞'),
+    ('𑌅', '𑌌'),
+    ('𑌏', '𑌐'),
+    ('𑌓', '𑌨'),
+    ('𑌪', '𑌰'),
+    ('𑌲', '𑌳'),
+    ('𑌵', '𑌹'),
+    ('𑌽', '𑌽'),
+    ('𑍐', '𑍐'),
+    ('𑍝', '𑍡'),
+    ('𑐀', '𑐴'),
+    ('𑑇', '𑑊'),
+    ('𑑟', '𑑡'),
+    ('𑒀', '𑒯'),
+    ('𑓄', '𑓅'),
+    ('𑓇', '𑓇'),
+    ('𑖀', '𑖮'),
+    ('𑗘', '𑗛'),
+    ('𑘀', '𑘯'),
+    ('𑙄', '𑙄'),
+    ('𑚀', '𑚪'),
+    ('𑚸', '𑚸'),
+    ('𑜀', '𑜚'),
+    ('𑝀', '𑝆'),
+    ('𑠀', '𑠫'),
+    ('𑣿', '𑤆'),
+    ('𑤉', '𑤉'),
+    ('𑤌', '𑤓'),
+    ('𑤕', '𑤖'),
+    ('𑤘', '𑤯'),
+    ('𑤿', '𑤿'),
+    ('𑥁', '𑥁'),
+    ('𑦠', '𑦧'),
+    ('𑦪', '𑧐'),
+    ('𑧡', '𑧡'),
+    ('𑧣', '𑧣'),
+    ('𑨀', '𑨀'),
+    ('𑨋', '𑨲'),
+    ('𑨺', '𑨺'),
+    ('𑩐', '𑩐'),
+    ('𑩜', '𑪉'),
+    ('𑪝', '𑪝'),
+    ('𑪰', '𑫸'),
+    ('𑰀', '𑰈'),
+    ('𑰊', '𑰮'),
+    ('𑱀', '𑱀'),
+    ('𑱲', '𑲏'),
+    ('𑴀', '𑴆'),
+    ('𑴈', '𑴉'),
+    ('𑴋', '𑴰'),
+    ('𑵆', '𑵆'),
+    ('𑵠', '𑵥'),
+    ('𑵧', '𑵨'),
+    ('𑵪', '𑶉'),
+    ('𑶘', '𑶘'),
+    ('𑻠', '𑻲'),
+    ('𑼂', '𑼂'),
+    ('𑼄', '𑼐'),
+    ('𑼒', '𑼳'),
+    ('𑾰', '𑾰'),
+    ('𒀀', '𒎙'),
+    ('𒐀', '𒑮'),
+    ('𒒀', '𒕃'),
+    ('𒾐', '𒿰'),
+    ('𓀀', '𓐯'),
+    ('𓑁', '𓑆'),
+    ('𔐀', '𔙆'),
+    ('𖠀', '𖨸'),
+    ('𖩀', '𖩞'),
+    ('𖩰', '𖪾'),
+    ('𖫐', '𖫭'),
+    ('𖬀', '𖬯'),
+    ('𖭀', '𖭃'),
+    ('𖭣', '𖭷'),
+    ('𖭽', '𖮏'),
+    ('𖼀', '𖽊'),
+    ('𖽐', '𖽐'),
+    ('𖾓', '𖾟'),
+    ('𖿠', '𖿡'),
+    ('𖿣', '𖿣'),
+    ('𗀀', '𘟷'),
+    ('𘠀', '𘳕'),
+    ('𘴀', '𘴈'),
+    ('𚿰', '𚿳'),
+    ('𚿵', '𚿻'),
+    ('𚿽', '𚿾'),
+    ('𛀀', '𛄢'),
+    ('𛄲', '𛄲'),
+    ('𛅐', '𛅒'),
+    ('𛅕', '𛅕'),
+    ('𛅤', '𛅧'),
+    ('𛅰', '𛋻'),
+    ('𛰀', '𛱪'),
+    ('𛱰', '𛱼'),
+    ('𛲀', '𛲈'),
+    ('𛲐', '𛲙'),
+    ('𝼊', '𝼊'),
+    ('𞄀', '𞄬'),
+    ('𞄷', '𞄽'),
+    ('𞅎', '𞅎'),
+    ('𞊐', '𞊭'),
+    ('𞋀', '𞋫'),
+    ('𞓐', '𞓫'),
+    ('𞟠', '𞟦'),
+    ('𞟨', '𞟫'),
+    ('𞟭', '𞟮'),
+    ('𞟰', '𞟾'),
+    ('𞠀', '𞣄'),
+    ('𞥋', '𞥋'),
+    ('𞸀', '𞸃'),
+    ('𞸅', '𞸟'),
+    ('𞸡', '𞸢'),
+    ('𞸤', '𞸤'),
+    ('𞸧', '𞸧'),
+    ('𞸩', '𞸲'),
+    ('𞸴', '𞸷'),
+    ('𞸹', '𞸹'),
+    ('𞸻', '𞸻'),
+    ('𞹂', '𞹂'),
+    ('𞹇', '𞹇'),
+    ('𞹉', '𞹉'),
+    ('𞹋', '𞹋'),
+    ('𞹍', '𞹏'),
+    ('𞹑', '𞹒'),
+    ('𞹔', '𞹔'),
+    ('𞹗', '𞹗'),
+    ('𞹙', '𞹙'),
+    ('𞹛', '𞹛'),
+    ('𞹝', '𞹝'),
+    ('𞹟', '𞹟'),
+    ('𞹡', '𞹢'),
+    ('𞹤', '𞹤'),
+    ('𞹧', '𞹪'),
+    ('𞹬', '𞹲'),
+    ('𞹴', '𞹷'),
+    ('𞹹', '𞹼'),
+    ('𞹾', '𞹾'),
+    ('𞺀', '𞺉'),
+    ('𞺋', '𞺛'),
+    ('𞺡', '𞺣'),
+    ('𞺥', '𞺩'),
+    ('𞺫', '𞺻'),
+    ('𠀀', '𪛟'),
+    ('𪜀', '𫜹'),
+    ('𫝀', '𫠝'),
+    ('𫠠', '𬺡'),
+    ('𬺰', '𮯠'),
+    ('丽', '𪘀'),
+    ('𰀀', '𱍊'),
+    ('𱍐', '𲎯'),
+];
+
+pub const SCONTINUE: &'static [(char, char)] = &[
+    (',', '-'),
+    (':', ':'),
+    ('՝', '՝'),
+    ('،', '؍'),
+    ('߸', '߸'),
+    ('᠂', '᠂'),
+    ('᠈', '᠈'),
+    ('–', '—'),
+    ('、', '、'),
+    ('︐', '︑'),
+    ('︓', '︓'),
+    ('︱', '︲'),
+    ('﹐', '﹑'),
+    ('﹕', '﹕'),
+    ('﹘', '﹘'),
+    ('﹣', '﹣'),
+    ('，', '－'),
+    ('：', '：'),
+    ('､', '､'),
+];
+
+pub const STERM: &'static [(char, char)] = &[
+    ('!', '!'),
+    ('?', '?'),
+    ('։', '։'),
+    ('؝', '؟'),
+    ('۔', '۔'),
+    ('܀', '܂'),
+    ('߹', '߹'),
+    ('࠷', '࠷'),
+    ('࠹', '࠹'),
+    ('࠽', '࠾'),
+    ('।', '॥'),
+    ('၊', '။'),
+    ('።', '።'),
+    ('፧', '፨'),
+    ('᙮', '᙮'),
+    ('᜵', '᜶'),
+    ('᠃', '᠃'),
+    ('᠉', '᠉'),
+    ('᥄', '᥅'),
+    ('᪨', '᪫'),
+    ('᭚', '᭛'),
+    ('᭞', '᭟'),
+    ('᭽', '᭾'),
+    ('᰻', '᰼'),
+    ('᱾', '᱿'),
+    ('‼', '‽'),
+    ('⁇', '⁉'),
+    ('⸮', '⸮'),
+    ('⸼', '⸼'),
+    ('⹓', '⹔'),
+    ('。', '。'),
+    ('꓿', '꓿'),
+    ('꘎', '꘏'),
+    ('꛳', '꛳'),
+    ('꛷', '꛷'),
+    ('꡶', '꡷'),
+    ('꣎', '꣏'),
+    ('꤯', '꤯'),
+    ('꧈', '꧉'),
+    ('꩝', '꩟'),
+    ('꫰', '꫱'),
+    ('꯫', '꯫'),
+    ('﹖', '﹗'),
+    ('！', '！'),
+    ('？', '？'),
+    ('｡', '｡'),
+    ('𐩖', '𐩗'),
+    ('𐽕', '𐽙'),
+    ('𐾆', '𐾉'),
+    ('𑁇', '𑁈'),
+    ('𑂾', '𑃁'),
+    ('𑅁', '𑅃'),
+    ('𑇅', '𑇆'),
+    ('𑇍', '𑇍'),
+    ('𑇞', '𑇟'),
+    ('𑈸', '𑈹'),
+    ('𑈻', '𑈼'),
+    ('𑊩', '𑊩'),
+    ('𑑋', '𑑌'),
+    ('𑗂', '𑗃'),
+    ('𑗉', '𑗗'),
+    ('𑙁', '𑙂'),
+    ('𑜼', '𑜾'),
+    ('𑥄', '𑥄'),
+    ('𑥆', '𑥆'),
+    ('𑩂', '𑩃'),
+    ('𑪛', '𑪜'),
+    ('𑱁', '𑱂'),
+    ('𑻷', '𑻸'),
+    ('𑽃', '𑽄'),
+    ('𖩮', '𖩯'),
+    ('𖫵', '𖫵'),
+    ('𖬷', '𖬸'),
+    ('𖭄', '𖭄'),
+    ('𖺘', '𖺘'),
+    ('𛲟', '𛲟'),
+    ('𝪈', '𝪈'),
+];
+
+pub const SEP: &'static [(char, char)] =
+    &[('\u{85}', '\u{85}'), ('\u{2028}', '\u{2029}')];
+
+pub const SP: &'static [(char, char)] = &[
+    ('\t', '\t'),
+    ('\u{b}', '\u{c}'),
+    (' ', ' '),
+    ('\u{a0}', '\u{a0}'),
+    ('\u{1680}', '\u{1680}'),
+    ('\u{2000}', '\u{200a}'),
+    ('\u{202f}', '\u{202f}'),
+    ('\u{205f}', '\u{205f}'),
+    ('\u{3000}', '\u{3000}'),
+];
+
+pub const UPPER: &'static [(char, char)] = &[
+    ('A', 'Z'),
+    ('À', 'Ö'),
+    ('Ø', 'Þ'),
+    ('Ā', 'Ā'),
+    ('Ă', 'Ă'),
+    ('Ą', 'Ą'),
+    ('Ć', 'Ć'),
+    ('Ĉ', 'Ĉ'),
+    ('Ċ', 'Ċ'),
+    ('Č', 'Č'),
+    ('Ď', 'Ď'),
+    ('Đ', 'Đ'),
+    ('Ē', 'Ē'),
+    ('Ĕ', 'Ĕ'),
+    ('Ė', 'Ė'),
+    ('Ę', 'Ę'),
+    ('Ě', 'Ě'),
+    ('Ĝ', 'Ĝ'),
+    ('Ğ', 'Ğ'),
+    ('Ġ', 'Ġ'),
+    ('Ģ', 'Ģ'),
+    ('Ĥ', 'Ĥ'),
+    ('Ħ', 'Ħ'),
+    ('Ĩ', 'Ĩ'),
+    ('Ī', 'Ī'),
+    ('Ĭ', 'Ĭ'),
+    ('Į', 'Į'),
+    ('İ', 'İ'),
+    ('Ĳ', 'Ĳ'),
+    ('Ĵ', 'Ĵ'),
+    ('Ķ', 'Ķ'),
+    ('Ĺ', 'Ĺ'),
+    ('Ļ', 'Ļ'),
+    ('Ľ', 'Ľ'),
+    ('Ŀ', 'Ŀ'),
+    ('Ł', 'Ł'),
+    ('Ń', 'Ń'),
+    ('Ņ', 'Ņ'),
+    ('Ň', 'Ň'),
+    ('Ŋ', 'Ŋ'),
+    ('Ō', 'Ō'),
+    ('Ŏ', 'Ŏ'),
+    ('Ő', 'Ő'),
+    ('Œ', 'Œ'),
+    ('Ŕ', 'Ŕ'),
+    ('Ŗ', 'Ŗ'),
+    ('Ř', 'Ř'),
+    ('Ś', 'Ś'),
+    ('Ŝ', 'Ŝ'),
+    ('Ş', 'Ş'),
+    ('Š', 'Š'),
+    ('Ţ', 'Ţ'),
+    ('Ť', 'Ť'),
+    ('Ŧ', 'Ŧ'),
+    ('Ũ', 'Ũ'),
+    ('Ū', 'Ū'),
+    ('Ŭ', 'Ŭ'),
+    ('Ů', 'Ů'),
+    ('Ű', 'Ű'),
+    ('Ų', 'Ų'),
+    ('Ŵ', 'Ŵ'),
+    ('Ŷ', 'Ŷ'),
+    ('Ÿ', 'Ź'),
+    ('Ż', 'Ż'),
+    ('Ž', 'Ž'),
+    ('Ɓ', 'Ƃ'),
+    ('Ƅ', 'Ƅ'),
+    ('Ɔ', 'Ƈ'),
+    ('Ɖ', 'Ƌ'),
+    ('Ǝ', 'Ƒ'),
+    ('Ɠ', 'Ɣ'),
+    ('Ɩ', 'Ƙ'),
+    ('Ɯ', 'Ɲ'),
+    ('Ɵ', 'Ơ'),
+    ('Ƣ', 'Ƣ'),
+    ('Ƥ', 'Ƥ'),
+    ('Ʀ', 'Ƨ'),
+    ('Ʃ', 'Ʃ'),
+    ('Ƭ', 'Ƭ'),
+    ('Ʈ', 'Ư'),
+    ('Ʊ', 'Ƴ'),
+    ('Ƶ', 'Ƶ'),
+    ('Ʒ', 'Ƹ'),
+    ('Ƽ', 'Ƽ'),
+    ('Ǆ', 'ǅ'),
+    ('Ǉ', 'ǈ'),
+    ('Ǌ', 'ǋ'),
+    ('Ǎ', 'Ǎ'),
+    ('Ǐ', 'Ǐ'),
+    ('Ǒ', 'Ǒ'),
+    ('Ǔ', 'Ǔ'),
+    ('Ǖ', 'Ǖ'),
+    ('Ǘ', 'Ǘ'),
+    ('Ǚ', 'Ǚ'),
+    ('Ǜ', 'Ǜ'),
+    ('Ǟ', 'Ǟ'),
+    ('Ǡ', 'Ǡ'),
+    ('Ǣ', 'Ǣ'),
+    ('Ǥ', 'Ǥ'),
+    ('Ǧ', 'Ǧ'),
+    ('Ǩ', 'Ǩ'),
+    ('Ǫ', 'Ǫ'),
+    ('Ǭ', 'Ǭ'),
+    ('Ǯ', 'Ǯ'),
+    ('Ǳ', 'ǲ'),
+    ('Ǵ', 'Ǵ'),
+    ('Ƕ', 'Ǹ'),
+    ('Ǻ', 'Ǻ'),
+    ('Ǽ', 'Ǽ'),
+    ('Ǿ', 'Ǿ'),
+    ('Ȁ', 'Ȁ'),
+    ('Ȃ', 'Ȃ'),
+    ('Ȅ', 'Ȅ'),
+    ('Ȇ', 'Ȇ'),
+    ('Ȉ', 'Ȉ'),
+    ('Ȋ', 'Ȋ'),
+    ('Ȍ', 'Ȍ'),
+    ('Ȏ', 'Ȏ'),
+    ('Ȑ', 'Ȑ'),
+    ('Ȓ', 'Ȓ'),
+    ('Ȕ', 'Ȕ'),
+    ('Ȗ', 'Ȗ'),
+    ('Ș', 'Ș'),
+    ('Ț', 'Ț'),
+    ('Ȝ', 'Ȝ'),
+    ('Ȟ', 'Ȟ'),
+    ('Ƞ', 'Ƞ'),
+    ('Ȣ', 'Ȣ'),
+    ('Ȥ', 'Ȥ'),
+    ('Ȧ', 'Ȧ'),
+    ('Ȩ', 'Ȩ'),
+    ('Ȫ', 'Ȫ'),
+    ('Ȭ', 'Ȭ'),
+    ('Ȯ', 'Ȯ'),
+    ('Ȱ', 'Ȱ'),
+    ('Ȳ', 'Ȳ'),
+    ('Ⱥ', 'Ȼ'),
+    ('Ƚ', 'Ⱦ'),
+    ('Ɂ', 'Ɂ'),
+    ('Ƀ', 'Ɇ'),
+    ('Ɉ', 'Ɉ'),
+    ('Ɋ', 'Ɋ'),
+    ('Ɍ', 'Ɍ'),
+    ('Ɏ', 'Ɏ'),
+    ('Ͱ', 'Ͱ'),
+    ('Ͳ', 'Ͳ'),
+    ('Ͷ', 'Ͷ'),
+    ('Ϳ', 'Ϳ'),
+    ('Ά', 'Ά'),
+    ('Έ', 'Ί'),
+    ('Ό', 'Ό'),
+    ('Ύ', 'Ώ'),
+    ('Α', 'Ρ'),
+    ('Σ', 'Ϋ'),
+    ('Ϗ', 'Ϗ'),
+    ('ϒ', 'ϔ'),
+    ('Ϙ', 'Ϙ'),
+    ('Ϛ', 'Ϛ'),
+    ('Ϝ', 'Ϝ'),
+    ('Ϟ', 'Ϟ'),
+    ('Ϡ', 'Ϡ'),
+    ('Ϣ', 'Ϣ'),
+    ('Ϥ', 'Ϥ'),
+    ('Ϧ', 'Ϧ'),
+    ('Ϩ', 'Ϩ'),
+    ('Ϫ', 'Ϫ'),
+    ('Ϭ', 'Ϭ'),
+    ('Ϯ', 'Ϯ'),
+    ('ϴ', 'ϴ'),
+    ('Ϸ', 'Ϸ'),
+    ('Ϲ', 'Ϻ'),
+    ('Ͻ', 'Я'),
+    ('Ѡ', 'Ѡ'),
+    ('Ѣ', 'Ѣ'),
+    ('Ѥ', 'Ѥ'),
+    ('Ѧ', 'Ѧ'),
+    ('Ѩ', 'Ѩ'),
+    ('Ѫ', 'Ѫ'),
+    ('Ѭ', 'Ѭ'),
+    ('Ѯ', 'Ѯ'),
+    ('Ѱ', 'Ѱ'),
+    ('Ѳ', 'Ѳ'),
+    ('Ѵ', 'Ѵ'),
+    ('Ѷ', 'Ѷ'),
+    ('Ѹ', 'Ѹ'),
+    ('Ѻ', 'Ѻ'),
+    ('Ѽ', 'Ѽ'),
+    ('Ѿ', 'Ѿ'),
+    ('Ҁ', 'Ҁ'),
+    ('Ҋ', 'Ҋ'),
+    ('Ҍ', 'Ҍ'),
+    ('Ҏ', 'Ҏ'),
+    ('Ґ', 'Ґ'),
+    ('Ғ', 'Ғ'),
+    ('Ҕ', 'Ҕ'),
+    ('Җ', 'Җ'),
+    ('Ҙ', 'Ҙ'),
+    ('Қ', 'Қ'),
+    ('Ҝ', 'Ҝ'),
+    ('Ҟ', 'Ҟ'),
+    ('Ҡ', 'Ҡ'),
+    ('Ң', 'Ң'),
+    ('Ҥ', 'Ҥ'),
+    ('Ҧ', 'Ҧ'),
+    ('Ҩ', 'Ҩ'),
+    ('Ҫ', 'Ҫ'),
+    ('Ҭ', 'Ҭ'),
+    ('Ү', 'Ү'),
+    ('Ұ', 'Ұ'),
+    ('Ҳ', 'Ҳ'),
+    ('Ҵ', 'Ҵ'),
+    ('Ҷ', 'Ҷ'),
+    ('Ҹ', 'Ҹ'),
+    ('Һ', 'Һ'),
+    ('Ҽ', 'Ҽ'),
+    ('Ҿ', 'Ҿ'),
+    ('Ӏ', 'Ӂ'),
+    ('Ӄ', 'Ӄ'),
+    ('Ӆ', 'Ӆ'),
+    ('Ӈ', 'Ӈ'),
+    ('Ӊ', 'Ӊ'),
+    ('Ӌ', 'Ӌ'),
+    ('Ӎ', 'Ӎ'),
+    ('Ӑ', 'Ӑ'),
+    ('Ӓ', 'Ӓ'),
+    ('Ӕ', 'Ӕ'),
+    ('Ӗ', 'Ӗ'),
+    ('Ә', 'Ә'),
+    ('Ӛ', 'Ӛ'),
+    ('Ӝ', 'Ӝ'),
+    ('Ӟ', 'Ӟ'),
+    ('Ӡ', 'Ӡ'),
+    ('Ӣ', 'Ӣ'),
+    ('Ӥ', 'Ӥ'),
+    ('Ӧ', 'Ӧ'),
+    ('Ө', 'Ө'),
+    ('Ӫ', 'Ӫ'),
+    ('Ӭ', 'Ӭ'),
+    ('Ӯ', 'Ӯ'),
+    ('Ӱ', 'Ӱ'),
+    ('Ӳ', 'Ӳ'),
+    ('Ӵ', 'Ӵ'),
+    ('Ӷ', 'Ӷ'),
+    ('Ӹ', 'Ӹ'),
+    ('Ӻ', 'Ӻ'),
+    ('Ӽ', 'Ӽ'),
+    ('Ӿ', 'Ӿ'),
+    ('Ԁ', 'Ԁ'),
+    ('Ԃ', 'Ԃ'),
+    ('Ԅ', 'Ԅ'),
+    ('Ԇ', 'Ԇ'),
+    ('Ԉ', 'Ԉ'),
+    ('Ԋ', 'Ԋ'),
+    ('Ԍ', 'Ԍ'),
+    ('Ԏ', 'Ԏ'),
+    ('Ԑ', 'Ԑ'),
+    ('Ԓ', 'Ԓ'),
+    ('Ԕ', 'Ԕ'),
+    ('Ԗ', 'Ԗ'),
+    ('Ԙ', 'Ԙ'),
+    ('Ԛ', 'Ԛ'),
+    ('Ԝ', 'Ԝ'),
+    ('Ԟ', 'Ԟ'),
+    ('Ԡ', 'Ԡ'),
+    ('Ԣ', 'Ԣ'),
+    ('Ԥ', 'Ԥ'),
+    ('Ԧ', 'Ԧ'),
+    ('Ԩ', 'Ԩ'),
+    ('Ԫ', 'Ԫ'),
+    ('Ԭ', 'Ԭ'),
+    ('Ԯ', 'Ԯ'),
+    ('Ա', 'Ֆ'),
+    ('Ⴀ', 'Ⴥ'),
+    ('Ⴧ', 'Ⴧ'),
+    ('Ⴭ', 'Ⴭ'),
+    ('Ꭰ', 'Ᏽ'),
+    ('Ḁ', 'Ḁ'),
+    ('Ḃ', 'Ḃ'),
+    ('Ḅ', 'Ḅ'),
+    ('Ḇ', 'Ḇ'),
+    ('Ḉ', 'Ḉ'),
+    ('Ḋ', 'Ḋ'),
+    ('Ḍ', 'Ḍ'),
+    ('Ḏ', 'Ḏ'),
+    ('Ḑ', 'Ḑ'),
+    ('Ḓ', 'Ḓ'),
+    ('Ḕ', 'Ḕ'),
+    ('Ḗ', 'Ḗ'),
+    ('Ḙ', 'Ḙ'),
+    ('Ḛ', 'Ḛ'),
+    ('Ḝ', 'Ḝ'),
+    ('Ḟ', 'Ḟ'),
+    ('Ḡ', 'Ḡ'),
+    ('Ḣ', 'Ḣ'),
+    ('Ḥ', 'Ḥ'),
+    ('Ḧ', 'Ḧ'),
+    ('Ḩ', 'Ḩ'),
+    ('Ḫ', 'Ḫ'),
+    ('Ḭ', 'Ḭ'),
+    ('Ḯ', 'Ḯ'),
+    ('Ḱ', 'Ḱ'),
+    ('Ḳ', 'Ḳ'),
+    ('Ḵ', 'Ḵ'),
+    ('Ḷ', 'Ḷ'),
+    ('Ḹ', 'Ḹ'),
+    ('Ḻ', 'Ḻ'),
+    ('Ḽ', 'Ḽ'),
+    ('Ḿ', 'Ḿ'),
+    ('Ṁ', 'Ṁ'),
+    ('Ṃ', 'Ṃ'),
+    ('Ṅ', 'Ṅ'),
+    ('Ṇ', 'Ṇ'),
+    ('Ṉ', 'Ṉ'),
+    ('Ṋ', 'Ṋ'),
+    ('Ṍ', 'Ṍ'),
+    ('Ṏ', 'Ṏ'),
+    ('Ṑ', 'Ṑ'),
+    ('Ṓ', 'Ṓ'),
+    ('Ṕ', 'Ṕ'),
+    ('Ṗ', 'Ṗ'),
+    ('Ṙ', 'Ṙ'),
+    ('Ṛ', 'Ṛ'),
+    ('Ṝ', 'Ṝ'),
+    ('Ṟ', 'Ṟ'),
+    ('Ṡ', 'Ṡ'),
+    ('Ṣ', 'Ṣ'),
+    ('Ṥ', 'Ṥ'),
+    ('Ṧ', 'Ṧ'),
+    ('Ṩ', 'Ṩ'),
+    ('Ṫ', 'Ṫ'),
+    ('Ṭ', 'Ṭ'),
+    ('Ṯ', 'Ṯ'),
+    ('Ṱ', 'Ṱ'),
+    ('Ṳ', 'Ṳ'),
+    ('Ṵ', 'Ṵ'),
+    ('Ṷ', 'Ṷ'),
+    ('Ṹ', 'Ṹ'),
+    ('Ṻ', 'Ṻ'),
+    ('Ṽ', 'Ṽ'),
+    ('Ṿ', 'Ṿ'),
+    ('Ẁ', 'Ẁ'),
+    ('Ẃ', 'Ẃ'),
+    ('Ẅ', 'Ẅ'),
+    ('Ẇ', 'Ẇ'),
+    ('Ẉ', 'Ẉ'),
+    ('Ẋ', 'Ẋ'),
+    ('Ẍ', 'Ẍ'),
+    ('Ẏ', 'Ẏ'),
+    ('Ẑ', 'Ẑ'),
+    ('Ẓ', 'Ẓ'),
+    ('Ẕ', 'Ẕ'),
+    ('ẞ', 'ẞ'),
+    ('Ạ', 'Ạ'),
+    ('Ả', 'Ả'),
+    ('Ấ', 'Ấ'),
+    ('Ầ', 'Ầ'),
+    ('Ẩ', 'Ẩ'),
+    ('Ẫ', 'Ẫ'),
+    ('Ậ', 'Ậ'),
+    ('Ắ', 'Ắ'),
+    ('Ằ', 'Ằ'),
+    ('Ẳ', 'Ẳ'),
+    ('Ẵ', 'Ẵ'),
+    ('Ặ', 'Ặ'),
+    ('Ẹ', 'Ẹ'),
+    ('Ẻ', 'Ẻ'),
+    ('Ẽ', 'Ẽ'),
+    ('Ế', 'Ế'),
+    ('Ề', 'Ề'),
+    ('Ể', 'Ể'),
+    ('Ễ', 'Ễ'),
+    ('Ệ', 'Ệ'),
+    ('Ỉ', 'Ỉ'),
+    ('Ị', 'Ị'),
+    ('Ọ', 'Ọ'),
+    ('Ỏ', 'Ỏ'),
+    ('Ố', 'Ố'),
+    ('Ồ', 'Ồ'),
+    ('Ổ', 'Ổ'),
+    ('Ỗ', 'Ỗ'),
+    ('Ộ', 'Ộ'),
+    ('Ớ', 'Ớ'),
+    ('Ờ', 'Ờ'),
+    ('Ở', 'Ở'),
+    ('Ỡ', 'Ỡ'),
+    ('Ợ', 'Ợ'),
+    ('Ụ', 'Ụ'),
+    ('Ủ', 'Ủ'),
+    ('Ứ', 'Ứ'),
+    ('Ừ', 'Ừ'),
+    ('Ử', 'Ử'),
+    ('Ữ', 'Ữ'),
+    ('Ự', 'Ự'),
+    ('Ỳ', 'Ỳ'),
+    ('Ỵ', 'Ỵ'),
+    ('Ỷ', 'Ỷ'),
+    ('Ỹ', 'Ỹ'),
+    ('Ỻ', 'Ỻ'),
+    ('Ỽ', 'Ỽ'),
+    ('Ỿ', 'Ỿ'),
+    ('Ἀ', 'Ἇ'),
+    ('Ἐ', 'Ἕ'),
+    ('Ἠ', 'Ἧ'),
+    ('Ἰ', 'Ἷ'),
+    ('Ὀ', 'Ὅ'),
+    ('Ὑ', 'Ὑ'),
+    ('Ὓ', 'Ὓ'),
+    ('Ὕ', 'Ὕ'),
+    ('Ὗ', 'Ὗ'),
+    ('Ὠ', 'Ὧ'),
+    ('ᾈ', 'ᾏ'),
+    ('ᾘ', 'ᾟ'),
+    ('ᾨ', 'ᾯ'),
+    ('Ᾰ', 'ᾼ'),
+    ('Ὲ', 'ῌ'),
+    ('Ῐ', 'Ί'),
+    ('Ῠ', 'Ῥ'),
+    ('Ὸ', 'ῼ'),
+    ('ℂ', 'ℂ'),
+    ('ℇ', 'ℇ'),
+    ('ℋ', 'ℍ'),
+    ('ℐ', 'ℒ'),
+    ('ℕ', 'ℕ'),
+    ('ℙ', 'ℝ'),
+    ('ℤ', 'ℤ'),
+    ('Ω', 'Ω'),
+    ('ℨ', 'ℨ'),
+    ('K', 'ℭ'),
+    ('ℰ', 'ℳ'),
+    ('ℾ', 'ℿ'),
+    ('ⅅ', 'ⅅ'),
+    ('Ⅰ', 'Ⅿ'),
+    ('Ↄ', 'Ↄ'),
+    ('Ⓐ', 'Ⓩ'),
+    ('Ⰰ', 'Ⱟ'),
+    ('Ⱡ', 'Ⱡ'),
+    ('Ɫ', 'Ɽ'),
+    ('Ⱨ', 'Ⱨ'),
+    ('Ⱪ', 'Ⱪ'),
+    ('Ⱬ', 'Ⱬ'),
+    ('Ɑ', 'Ɒ'),
+    ('Ⱳ', 'Ⱳ'),
+    ('Ⱶ', 'Ⱶ'),
+    ('Ȿ', 'Ⲁ'),
+    ('Ⲃ', 'Ⲃ'),
+    ('Ⲅ', 'Ⲅ'),
+    ('Ⲇ', 'Ⲇ'),
+    ('Ⲉ', 'Ⲉ'),
+    ('Ⲋ', 'Ⲋ'),
+    ('Ⲍ', 'Ⲍ'),
+    ('Ⲏ', 'Ⲏ'),
+    ('Ⲑ', 'Ⲑ'),
+    ('Ⲓ', 'Ⲓ'),
+    ('Ⲕ', 'Ⲕ'),
+    ('Ⲗ', 'Ⲗ'),
+    ('Ⲙ', 'Ⲙ'),
+    ('Ⲛ', 'Ⲛ'),
+    ('Ⲝ', 'Ⲝ'),
+    ('Ⲟ', 'Ⲟ'),
+    ('Ⲡ', 'Ⲡ'),
+    ('Ⲣ', 'Ⲣ'),
+    ('Ⲥ', 'Ⲥ'),
+    ('Ⲧ', 'Ⲧ'),
+    ('Ⲩ', 'Ⲩ'),
+    ('Ⲫ', 'Ⲫ'),
+    ('Ⲭ', 'Ⲭ'),
+    ('Ⲯ', 'Ⲯ'),
+    ('Ⲱ', 'Ⲱ'),
+    ('Ⲳ', 'Ⲳ'),
+    ('Ⲵ', 'Ⲵ'),
+    ('Ⲷ', 'Ⲷ'),
+    ('Ⲹ', 'Ⲹ'),
+    ('Ⲻ', 'Ⲻ'),
+    ('Ⲽ', 'Ⲽ'),
+    ('Ⲿ', 'Ⲿ'),
+    ('Ⳁ', 'Ⳁ'),
+    ('Ⳃ', 'Ⳃ'),
+    ('Ⳅ', 'Ⳅ'),
+    ('Ⳇ', 'Ⳇ'),
+    ('Ⳉ', 'Ⳉ'),
+    ('Ⳋ', 'Ⳋ'),
+    ('Ⳍ', 'Ⳍ'),
+    ('Ⳏ', 'Ⳏ'),
+    ('Ⳑ', 'Ⳑ'),
+    ('Ⳓ', 'Ⳓ'),
+    ('Ⳕ', 'Ⳕ'),
+    ('Ⳗ', 'Ⳗ'),
+    ('Ⳙ', 'Ⳙ'),
+    ('Ⳛ', 'Ⳛ'),
+    ('Ⳝ', 'Ⳝ'),
+    ('Ⳟ', 'Ⳟ'),
+    ('Ⳡ', 'Ⳡ'),
+    ('Ⳣ', 'Ⳣ'),
+    ('Ⳬ', 'Ⳬ'),
+    ('Ⳮ', 'Ⳮ'),
+    ('Ⳳ', 'Ⳳ'),
+    ('Ꙁ', 'Ꙁ'),
+    ('Ꙃ', 'Ꙃ'),
+    ('Ꙅ', 'Ꙅ'),
+    ('Ꙇ', 'Ꙇ'),
+    ('Ꙉ', 'Ꙉ'),
+    ('Ꙋ', 'Ꙋ'),
+    ('Ꙍ', 'Ꙍ'),
+    ('Ꙏ', 'Ꙏ'),
+    ('Ꙑ', 'Ꙑ'),
+    ('Ꙓ', 'Ꙓ'),
+    ('Ꙕ', 'Ꙕ'),
+    ('Ꙗ', 'Ꙗ'),
+    ('Ꙙ', 'Ꙙ'),
+    ('Ꙛ', 'Ꙛ'),
+    ('Ꙝ', 'Ꙝ'),
+    ('Ꙟ', 'Ꙟ'),
+    ('Ꙡ', 'Ꙡ'),
+    ('Ꙣ', 'Ꙣ'),
+    ('Ꙥ', 'Ꙥ'),
+    ('Ꙧ', 'Ꙧ'),
+    ('Ꙩ', 'Ꙩ'),
+    ('Ꙫ', 'Ꙫ'),
+    ('Ꙭ', 'Ꙭ'),
+    ('Ꚁ', 'Ꚁ'),
+    ('Ꚃ', 'Ꚃ'),
+    ('Ꚅ', 'Ꚅ'),
+    ('Ꚇ', 'Ꚇ'),
+    ('Ꚉ', 'Ꚉ'),
+    ('Ꚋ', 'Ꚋ'),
+    ('Ꚍ', 'Ꚍ'),
+    ('Ꚏ', 'Ꚏ'),
+    ('Ꚑ', 'Ꚑ'),
+    ('Ꚓ', 'Ꚓ'),
+    ('Ꚕ', 'Ꚕ'),
+    ('Ꚗ', 'Ꚗ'),
+    ('Ꚙ', 'Ꚙ'),
+    ('Ꚛ', 'Ꚛ'),
+    ('Ꜣ', 'Ꜣ'),
+    ('Ꜥ', 'Ꜥ'),
+    ('Ꜧ', 'Ꜧ'),
+    ('Ꜩ', 'Ꜩ'),
+    ('Ꜫ', 'Ꜫ'),
+    ('Ꜭ', 'Ꜭ'),
+    ('Ꜯ', 'Ꜯ'),
+    ('Ꜳ', 'Ꜳ'),
+    ('Ꜵ', 'Ꜵ'),
+    ('Ꜷ', 'Ꜷ'),
+    ('Ꜹ', 'Ꜹ'),
+    ('Ꜻ', 'Ꜻ'),
+    ('Ꜽ', 'Ꜽ'),
+    ('Ꜿ', 'Ꜿ'),
+    ('Ꝁ', 'Ꝁ'),
+    ('Ꝃ', 'Ꝃ'),
+    ('Ꝅ', 'Ꝅ'),
+    ('Ꝇ', 'Ꝇ'),
+    ('Ꝉ', 'Ꝉ'),
+    ('Ꝋ', 'Ꝋ'),
+    ('Ꝍ', 'Ꝍ'),
+    ('Ꝏ', 'Ꝏ'),
+    ('Ꝑ', 'Ꝑ'),
+    ('Ꝓ', 'Ꝓ'),
+    ('Ꝕ', 'Ꝕ'),
+    ('Ꝗ', 'Ꝗ'),
+    ('Ꝙ', 'Ꝙ'),
+    ('Ꝛ', 'Ꝛ'),
+    ('Ꝝ', 'Ꝝ'),
+    ('Ꝟ', 'Ꝟ'),
+    ('Ꝡ', 'Ꝡ'),
+    ('Ꝣ', 'Ꝣ'),
+    ('Ꝥ', 'Ꝥ'),
+    ('Ꝧ', 'Ꝧ'),
+    ('Ꝩ', 'Ꝩ'),
+    ('Ꝫ', 'Ꝫ'),
+    ('Ꝭ', 'Ꝭ'),
+    ('Ꝯ', 'Ꝯ'),
+    ('Ꝺ', 'Ꝺ'),
+    ('Ꝼ', 'Ꝼ'),
+    ('Ᵹ', 'Ꝿ'),
+    ('Ꞁ', 'Ꞁ'),
+    ('Ꞃ', 'Ꞃ'),
+    ('Ꞅ', 'Ꞅ'),
+    ('Ꞇ', 'Ꞇ'),
+    ('Ꞌ', 'Ꞌ'),
+    ('Ɥ', 'Ɥ'),
+    ('Ꞑ', 'Ꞑ'),
+    ('Ꞓ', 'Ꞓ'),
+    ('Ꞗ', 'Ꞗ'),
+    ('Ꞙ', 'Ꞙ'),
+    ('Ꞛ', 'Ꞛ'),
+    ('Ꞝ', 'Ꞝ'),
+    ('Ꞟ', 'Ꞟ'),
+    ('Ꞡ', 'Ꞡ'),
+    ('Ꞣ', 'Ꞣ'),
+    ('Ꞥ', 'Ꞥ'),
+    ('Ꞧ', 'Ꞧ'),
+    ('Ꞩ', 'Ꞩ'),
+    ('Ɦ', 'Ɪ'),
+    ('Ʞ', 'Ꞵ'),
+    ('Ꞷ', 'Ꞷ'),
+    ('Ꞹ', 'Ꞹ'),
+    ('Ꞻ', 'Ꞻ'),
+    ('Ꞽ', 'Ꞽ'),
+    ('Ꞿ', 'Ꞿ'),
+    ('Ꟁ', 'Ꟁ'),
+    ('Ꟃ', 'Ꟃ'),
+    ('Ꞔ', 'Ꟈ'),
+    ('Ꟊ', 'Ꟊ'),
+    ('Ꟑ', 'Ꟑ'),
+    ('Ꟗ', 'Ꟗ'),
+    ('Ꟙ', 'Ꟙ'),
+    ('Ꟶ', 'Ꟶ'),
+    ('Ａ', 'Ｚ'),
+    ('𐐀', '𐐧'),
+    ('𐒰', '𐓓'),
+    ('𐕰', '𐕺'),
+    ('𐕼', '𐖊'),
+    ('𐖌', '𐖒'),
+    ('𐖔', '𐖕'),
+    ('𐲀', '𐲲'),
+    ('𑢠', '𑢿'),
+    ('𖹀', '𖹟'),
+    ('𝐀', '𝐙'),
+    ('𝐴', '𝑍'),
+    ('𝑨', '𝒁'),
+    ('𝒜', '𝒜'),
+    ('𝒞', '𝒟'),
+    ('𝒢', '𝒢'),
+    ('𝒥', '𝒦'),
+    ('𝒩', '𝒬'),
+    ('𝒮', '𝒵'),
+    ('𝓐', '𝓩'),
+    ('𝔄', '𝔅'),
+    ('𝔇', '𝔊'),
+    ('𝔍', '𝔔'),
+    ('𝔖', '𝔜'),
+    ('𝔸', '𝔹'),
+    ('𝔻', '𝔾'),
+    ('𝕀', '𝕄'),
+    ('𝕆', '𝕆'),
+    ('𝕊', '𝕐'),
+    ('𝕬', '𝖅'),
+    ('𝖠', '𝖹'),
+    ('𝗔', '𝗭'),
+    ('𝘈', '𝘡'),
+    ('𝘼', '𝙕'),
+    ('𝙰', '𝚉'),
+    ('𝚨', '𝛀'),
+    ('𝛢', '𝛺'),
+    ('𝜜', '𝜴'),
+    ('𝝖', '𝝮'),
+    ('𝞐', '𝞨'),
+    ('𝟊', '𝟊'),
+    ('𞤀', '𞤡'),
+    ('🄰', '🅉'),
+    ('🅐', '🅩'),
+    ('🅰', '🆉'),
+];
diff --git a/crates/regex-syntax/src/unicode_tables/word_break.rs b/crates/regex-syntax/src/unicode_tables/word_break.rs
new file mode 100644
index 0000000..c071495
--- /dev/null
+++ b/crates/regex-syntax/src/unicode_tables/word_break.rs
@@ -0,0 +1,1120 @@
+// DO NOT EDIT THIS FILE. IT WAS AUTOMATICALLY GENERATED BY:
+//
+//   ucd-generate word-break ucd-15.0.0 --chars
+//
+// Unicode version: 15.0.0.
+//
+// ucd-generate 0.2.14 is available on crates.io.
+
+pub const BY_NAME: &'static [(&'static str, &'static [(char, char)])] = &[
+    ("ALetter", ALETTER),
+    ("CR", CR),
+    ("Double_Quote", DOUBLE_QUOTE),
+    ("Extend", EXTEND),
+    ("ExtendNumLet", EXTENDNUMLET),
+    ("Format", FORMAT),
+    ("Hebrew_Letter", HEBREW_LETTER),
+    ("Katakana", KATAKANA),
+    ("LF", LF),
+    ("MidLetter", MIDLETTER),
+    ("MidNum", MIDNUM),
+    ("MidNumLet", MIDNUMLET),
+    ("Newline", NEWLINE),
+    ("Numeric", NUMERIC),
+    ("Regional_Indicator", REGIONAL_INDICATOR),
+    ("Single_Quote", SINGLE_QUOTE),
+    ("WSegSpace", WSEGSPACE),
+    ("ZWJ", ZWJ),
+];
+
+pub const ALETTER: &'static [(char, char)] = &[
+    ('A', 'Z'),
+    ('a', 'z'),
+    ('ª', 'ª'),
+    ('µ', 'µ'),
+    ('º', 'º'),
+    ('À', 'Ö'),
+    ('Ø', 'ö'),
+    ('ø', '˗'),
+    ('˞', '˿'),
+    ('Ͱ', 'ʹ'),
+    ('Ͷ', 'ͷ'),
+    ('ͺ', 'ͽ'),
+    ('Ϳ', 'Ϳ'),
+    ('Ά', 'Ά'),
+    ('Έ', 'Ί'),
+    ('Ό', 'Ό'),
+    ('Ύ', 'Ρ'),
+    ('Σ', 'ϵ'),
+    ('Ϸ', 'ҁ'),
+    ('Ҋ', 'ԯ'),
+    ('Ա', 'Ֆ'),
+    ('ՙ', '՜'),
+    ('՞', '՞'),
+    ('ՠ', 'ֈ'),
+    ('֊', '֊'),
+    ('׳', '׳'),
+    ('ؠ', 'ي'),
+    ('ٮ', 'ٯ'),
+    ('ٱ', 'ۓ'),
+    ('ە', 'ە'),
+    ('ۥ', 'ۦ'),
+    ('ۮ', 'ۯ'),
+    ('ۺ', 'ۼ'),
+    ('ۿ', 'ۿ'),
+    ('ܐ', 'ܐ'),
+    ('ܒ', 'ܯ'),
+    ('ݍ', 'ޥ'),
+    ('ޱ', 'ޱ'),
+    ('ߊ', 'ߪ'),
+    ('ߴ', 'ߵ'),
+    ('ߺ', 'ߺ'),
+    ('ࠀ', 'ࠕ'),
+    ('ࠚ', 'ࠚ'),
+    ('ࠤ', 'ࠤ'),
+    ('ࠨ', 'ࠨ'),
+    ('ࡀ', 'ࡘ'),
+    ('ࡠ', 'ࡪ'),
+    ('ࡰ', 'ࢇ'),
+    ('ࢉ', 'ࢎ'),
+    ('ࢠ', 'ࣉ'),
+    ('ऄ', 'ह'),
+    ('ऽ', 'ऽ'),
+    ('ॐ', 'ॐ'),
+    ('क़', 'ॡ'),
+    ('ॱ', 'ঀ'),
+    ('অ', 'ঌ'),
+    ('এ', 'ঐ'),
+    ('ও', 'ন'),
+    ('প', 'র'),
+    ('ল', 'ল'),
+    ('শ', 'হ'),
+    ('ঽ', 'ঽ'),
+    ('ৎ', 'ৎ'),
+    ('ড়', 'ঢ়'),
+    ('য়', 'ৡ'),
+    ('ৰ', 'ৱ'),
+    ('ৼ', 'ৼ'),
+    ('ਅ', 'ਊ'),
+    ('ਏ', 'ਐ'),
+    ('ਓ', 'ਨ'),
+    ('ਪ', 'ਰ'),
+    ('ਲ', 'ਲ਼'),
+    ('ਵ', 'ਸ਼'),
+    ('ਸ', 'ਹ'),
+    ('ਖ਼', 'ੜ'),
+    ('ਫ਼', 'ਫ਼'),
+    ('ੲ', 'ੴ'),
+    ('અ', 'ઍ'),
+    ('એ', 'ઑ'),
+    ('ઓ', 'ન'),
+    ('પ', 'ર'),
+    ('લ', 'ળ'),
+    ('વ', 'હ'),
+    ('ઽ', 'ઽ'),
+    ('ૐ', 'ૐ'),
+    ('ૠ', 'ૡ'),
+    ('ૹ', 'ૹ'),
+    ('ଅ', 'ଌ'),
+    ('ଏ', 'ଐ'),
+    ('ଓ', 'ନ'),
+    ('ପ', 'ର'),
+    ('ଲ', 'ଳ'),
+    ('ଵ', 'ହ'),
+    ('ଽ', 'ଽ'),
+    ('ଡ଼', 'ଢ଼'),
+    ('ୟ', 'ୡ'),
+    ('ୱ', 'ୱ'),
+    ('ஃ', 'ஃ'),
+    ('அ', 'ஊ'),
+    ('எ', 'ஐ'),
+    ('ஒ', 'க'),
+    ('ங', 'ச'),
+    ('ஜ', 'ஜ'),
+    ('ஞ', 'ட'),
+    ('ண', 'த'),
+    ('ந', 'ப'),
+    ('ம', 'ஹ'),
+    ('ௐ', 'ௐ'),
+    ('అ', 'ఌ'),
+    ('ఎ', 'ఐ'),
+    ('ఒ', 'న'),
+    ('ప', 'హ'),
+    ('ఽ', 'ఽ'),
+    ('ౘ', 'ౚ'),
+    ('ౝ', 'ౝ'),
+    ('ౠ', 'ౡ'),
+    ('ಀ', 'ಀ'),
+    ('ಅ', 'ಌ'),
+    ('ಎ', 'ಐ'),
+    ('ಒ', 'ನ'),
+    ('ಪ', 'ಳ'),
+    ('ವ', 'ಹ'),
+    ('ಽ', 'ಽ'),
+    ('ೝ', 'ೞ'),
+    ('ೠ', 'ೡ'),
+    ('ೱ', 'ೲ'),
+    ('ഄ', 'ഌ'),
+    ('എ', 'ഐ'),
+    ('ഒ', 'ഺ'),
+    ('ഽ', 'ഽ'),
+    ('ൎ', 'ൎ'),
+    ('ൔ', 'ൖ'),
+    ('ൟ', 'ൡ'),
+    ('ൺ', 'ൿ'),
+    ('අ', 'ඖ'),
+    ('ක', 'න'),
+    ('ඳ', 'ර'),
+    ('ල', 'ල'),
+    ('ව', 'ෆ'),
+    ('ༀ', 'ༀ'),
+    ('ཀ', 'ཇ'),
+    ('ཉ', 'ཬ'),
+    ('ྈ', 'ྌ'),
+    ('Ⴀ', 'Ⴥ'),
+    ('Ⴧ', 'Ⴧ'),
+    ('Ⴭ', 'Ⴭ'),
+    ('ა', 'ჺ'),
+    ('ჼ', 'ቈ'),
+    ('ቊ', 'ቍ'),
+    ('ቐ', 'ቖ'),
+    ('ቘ', 'ቘ'),
+    ('ቚ', 'ቝ'),
+    ('በ', 'ኈ'),
+    ('ኊ', 'ኍ'),
+    ('ነ', 'ኰ'),
+    ('ኲ', 'ኵ'),
+    ('ኸ', 'ኾ'),
+    ('ዀ', 'ዀ'),
+    ('ዂ', 'ዅ'),
+    ('ወ', 'ዖ'),
+    ('ዘ', 'ጐ'),
+    ('ጒ', 'ጕ'),
+    ('ጘ', 'ፚ'),
+    ('ᎀ', 'ᎏ'),
+    ('Ꭰ', 'Ᏽ'),
+    ('ᏸ', 'ᏽ'),
+    ('ᐁ', 'ᙬ'),
+    ('ᙯ', 'ᙿ'),
+    ('ᚁ', 'ᚚ'),
+    ('ᚠ', 'ᛪ'),
+    ('ᛮ', 'ᛸ'),
+    ('ᜀ', 'ᜑ'),
+    ('ᜟ', 'ᜱ'),
+    ('ᝀ', 'ᝑ'),
+    ('ᝠ', 'ᝬ'),
+    ('ᝮ', 'ᝰ'),
+    ('ᠠ', 'ᡸ'),
+    ('ᢀ', 'ᢄ'),
+    ('ᢇ', 'ᢨ'),
+    ('ᢪ', 'ᢪ'),
+    ('ᢰ', 'ᣵ'),
+    ('ᤀ', 'ᤞ'),
+    ('ᨀ', 'ᨖ'),
+    ('ᬅ', 'ᬳ'),
+    ('ᭅ', 'ᭌ'),
+    ('ᮃ', 'ᮠ'),
+    ('ᮮ', 'ᮯ'),
+    ('ᮺ', 'ᯥ'),
+    ('ᰀ', 'ᰣ'),
+    ('ᱍ', 'ᱏ'),
+    ('ᱚ', 'ᱽ'),
+    ('ᲀ', 'ᲈ'),
+    ('Ა', 'Ჺ'),
+    ('Ჽ', 'Ჿ'),
+    ('ᳩ', 'ᳬ'),
+    ('ᳮ', 'ᳳ'),
+    ('ᳵ', 'ᳶ'),
+    ('ᳺ', 'ᳺ'),
+    ('ᴀ', 'ᶿ'),
+    ('Ḁ', 'ἕ'),
+    ('Ἐ', 'Ἕ'),
+    ('ἠ', 'ὅ'),
+    ('Ὀ', 'Ὅ'),
+    ('ὐ', 'ὗ'),
+    ('Ὑ', 'Ὑ'),
+    ('Ὓ', 'Ὓ'),
+    ('Ὕ', 'Ὕ'),
+    ('Ὗ', 'ώ'),
+    ('ᾀ', 'ᾴ'),
+    ('ᾶ', 'ᾼ'),
+    ('ι', 'ι'),
+    ('ῂ', 'ῄ'),
+    ('ῆ', 'ῌ'),
+    ('ῐ', 'ΐ'),
+    ('ῖ', 'Ί'),
+    ('ῠ', 'Ῥ'),
+    ('ῲ', 'ῴ'),
+    ('ῶ', 'ῼ'),
+    ('ⁱ', 'ⁱ'),
+    ('ⁿ', 'ⁿ'),
+    ('ₐ', 'ₜ'),
+    ('ℂ', 'ℂ'),
+    ('ℇ', 'ℇ'),
+    ('ℊ', 'ℓ'),
+    ('ℕ', 'ℕ'),
+    ('ℙ', 'ℝ'),
+    ('ℤ', 'ℤ'),
+    ('Ω', 'Ω'),
+    ('ℨ', 'ℨ'),
+    ('K', 'ℭ'),
+    ('ℯ', 'ℹ'),
+    ('ℼ', 'ℿ'),
+    ('ⅅ', 'ⅉ'),
+    ('ⅎ', 'ⅎ'),
+    ('Ⅰ', 'ↈ'),
+    ('Ⓐ', 'ⓩ'),
+    ('Ⰰ', 'ⳤ'),
+    ('Ⳬ', 'ⳮ'),
+    ('Ⳳ', 'ⳳ'),
+    ('ⴀ', 'ⴥ'),
+    ('ⴧ', 'ⴧ'),
+    ('ⴭ', 'ⴭ'),
+    ('ⴰ', 'ⵧ'),
+    ('ⵯ', 'ⵯ'),
+    ('ⶀ', 'ⶖ'),
+    ('ⶠ', 'ⶦ'),
+    ('ⶨ', 'ⶮ'),
+    ('ⶰ', 'ⶶ'),
+    ('ⶸ', 'ⶾ'),
+    ('ⷀ', 'ⷆ'),
+    ('ⷈ', 'ⷎ'),
+    ('ⷐ', 'ⷖ'),
+    ('ⷘ', 'ⷞ'),
+    ('ⸯ', 'ⸯ'),
+    ('々', '々'),
+    ('〻', '〼'),
+    ('ㄅ', 'ㄯ'),
+    ('ㄱ', 'ㆎ'),
+    ('ㆠ', 'ㆿ'),
+    ('ꀀ', 'ꒌ'),
+    ('ꓐ', 'ꓽ'),
+    ('ꔀ', 'ꘌ'),
+    ('ꘐ', 'ꘟ'),
+    ('ꘪ', 'ꘫ'),
+    ('Ꙁ', 'ꙮ'),
+    ('ꙿ', 'ꚝ'),
+    ('ꚠ', 'ꛯ'),
+    ('꜈', 'ꟊ'),
+    ('Ꟑ', 'ꟑ'),
+    ('ꟓ', 'ꟓ'),
+    ('ꟕ', 'ꟙ'),
+    ('ꟲ', 'ꠁ'),
+    ('ꠃ', 'ꠅ'),
+    ('ꠇ', 'ꠊ'),
+    ('ꠌ', 'ꠢ'),
+    ('ꡀ', 'ꡳ'),
+    ('ꢂ', 'ꢳ'),
+    ('ꣲ', 'ꣷ'),
+    ('ꣻ', 'ꣻ'),
+    ('ꣽ', 'ꣾ'),
+    ('ꤊ', 'ꤥ'),
+    ('ꤰ', 'ꥆ'),
+    ('ꥠ', 'ꥼ'),
+    ('ꦄ', 'ꦲ'),
+    ('ꧏ', 'ꧏ'),
+    ('ꨀ', 'ꨨ'),
+    ('ꩀ', 'ꩂ'),
+    ('ꩄ', 'ꩋ'),
+    ('ꫠ', 'ꫪ'),
+    ('ꫲ', 'ꫴ'),
+    ('ꬁ', 'ꬆ'),
+    ('ꬉ', 'ꬎ'),
+    ('ꬑ', 'ꬖ'),
+    ('ꬠ', 'ꬦ'),
+    ('ꬨ', 'ꬮ'),
+    ('ꬰ', 'ꭩ'),
+    ('ꭰ', 'ꯢ'),
+    ('가', '힣'),
+    ('ힰ', 'ퟆ'),
+    ('ퟋ', 'ퟻ'),
+    ('ﬀ', 'ﬆ'),
+    ('ﬓ', 'ﬗ'),
+    ('ﭐ', 'ﮱ'),
+    ('ﯓ', 'ﴽ'),
+    ('ﵐ', 'ﶏ'),
+    ('ﶒ', 'ﷇ'),
+    ('ﷰ', 'ﷻ'),
+    ('ﹰ', 'ﹴ'),
+    ('ﹶ', 'ﻼ'),
+    ('Ａ', 'Ｚ'),
+    ('ａ', 'ｚ'),
+    ('ﾠ', 'ﾾ'),
+    ('ￂ', 'ￇ'),
+    ('ￊ', 'ￏ'),
+    ('ￒ', 'ￗ'),
+    ('ￚ', 'ￜ'),
+    ('𐀀', '𐀋'),
+    ('𐀍', '𐀦'),
+    ('𐀨', '𐀺'),
+    ('𐀼', '𐀽'),
+    ('𐀿', '𐁍'),
+    ('𐁐', '𐁝'),
+    ('𐂀', '𐃺'),
+    ('𐅀', '𐅴'),
+    ('𐊀', '𐊜'),
+    ('𐊠', '𐋐'),
+    ('𐌀', '𐌟'),
+    ('𐌭', '𐍊'),
+    ('𐍐', '𐍵'),
+    ('𐎀', '𐎝'),
+    ('𐎠', '𐏃'),
+    ('𐏈', '𐏏'),
+    ('𐏑', '𐏕'),
+    ('𐐀', '𐒝'),
+    ('𐒰', '𐓓'),
+    ('𐓘', '𐓻'),
+    ('𐔀', '𐔧'),
+    ('𐔰', '𐕣'),
+    ('𐕰', '𐕺'),
+    ('𐕼', '𐖊'),
+    ('𐖌', '𐖒'),
+    ('𐖔', '𐖕'),
+    ('𐖗', '𐖡'),
+    ('𐖣', '𐖱'),
+    ('𐖳', '𐖹'),
+    ('𐖻', '𐖼'),
+    ('𐘀', '𐜶'),
+    ('𐝀', '𐝕'),
+    ('𐝠', '𐝧'),
+    ('𐞀', '𐞅'),
+    ('𐞇', '𐞰'),
+    ('𐞲', '𐞺'),
+    ('𐠀', '𐠅'),
+    ('𐠈', '𐠈'),
+    ('𐠊', '𐠵'),
+    ('𐠷', '𐠸'),
+    ('𐠼', '𐠼'),
+    ('𐠿', '𐡕'),
+    ('𐡠', '𐡶'),
+    ('𐢀', '𐢞'),
+    ('𐣠', '𐣲'),
+    ('𐣴', '𐣵'),
+    ('𐤀', '𐤕'),
+    ('𐤠', '𐤹'),
+    ('𐦀', '𐦷'),
+    ('𐦾', '𐦿'),
+    ('𐨀', '𐨀'),
+    ('𐨐', '𐨓'),
+    ('𐨕', '𐨗'),
+    ('𐨙', '𐨵'),
+    ('𐩠', '𐩼'),
+    ('𐪀', '𐪜'),
+    ('𐫀', '𐫇'),
+    ('𐫉', '𐫤'),
+    ('𐬀', '𐬵'),
+    ('𐭀', '𐭕'),
+    ('𐭠', '𐭲'),
+    ('𐮀', '𐮑'),
+    ('𐰀', '𐱈'),
+    ('𐲀', '𐲲'),
+    ('𐳀', '𐳲'),
+    ('𐴀', '𐴣'),
+    ('𐺀', '𐺩'),
+    ('𐺰', '𐺱'),
+    ('𐼀', '𐼜'),
+    ('𐼧', '𐼧'),
+    ('𐼰', '𐽅'),
+    ('𐽰', '𐾁'),
+    ('𐾰', '𐿄'),
+    ('𐿠', '𐿶'),
+    ('𑀃', '𑀷'),
+    ('𑁱', '𑁲'),
+    ('𑁵', '𑁵'),
+    ('𑂃', '𑂯'),
+    ('𑃐', '𑃨'),
+    ('𑄃', '𑄦'),
+    ('𑅄', '𑅄'),
+    ('𑅇', '𑅇'),
+    ('𑅐', '𑅲'),
+    ('𑅶', '𑅶'),
+    ('𑆃', '𑆲'),
+    ('𑇁', '𑇄'),
+    ('𑇚', '𑇚'),
+    ('𑇜', '𑇜'),
+    ('𑈀', '𑈑'),
+    ('𑈓', '𑈫'),
+    ('𑈿', '𑉀'),
+    ('𑊀', '𑊆'),
+    ('𑊈', '𑊈'),
+    ('𑊊', '𑊍'),
+    ('𑊏', '𑊝'),
+    ('𑊟', '𑊨'),
+    ('𑊰', '𑋞'),
+    ('𑌅', '𑌌'),
+    ('𑌏', '𑌐'),
+    ('𑌓', '𑌨'),
+    ('𑌪', '𑌰'),
+    ('𑌲', '𑌳'),
+    ('𑌵', '𑌹'),
+    ('𑌽', '𑌽'),
+    ('𑍐', '𑍐'),
+    ('𑍝', '𑍡'),
+    ('𑐀', '𑐴'),
+    ('𑑇', '𑑊'),
+    ('𑑟', '𑑡'),
+    ('𑒀', '𑒯'),
+    ('𑓄', '𑓅'),
+    ('𑓇', '𑓇'),
+    ('𑖀', '𑖮'),
+    ('𑗘', '𑗛'),
+    ('𑘀', '𑘯'),
+    ('𑙄', '𑙄'),
+    ('𑚀', '𑚪'),
+    ('𑚸', '𑚸'),
+    ('𑠀', '𑠫'),
+    ('𑢠', '𑣟'),
+    ('𑣿', '𑤆'),
+    ('𑤉', '𑤉'),
+    ('𑤌', '𑤓'),
+    ('𑤕', '𑤖'),
+    ('𑤘', '𑤯'),
+    ('𑤿', '𑤿'),
+    ('𑥁', '𑥁'),
+    ('𑦠', '𑦧'),
+    ('𑦪', '𑧐'),
+    ('𑧡', '𑧡'),
+    ('𑧣', '𑧣'),
+    ('𑨀', '𑨀'),
+    ('𑨋', '𑨲'),
+    ('𑨺', '𑨺'),
+    ('𑩐', '𑩐'),
+    ('𑩜', '𑪉'),
+    ('𑪝', '𑪝'),
+    ('𑪰', '𑫸'),
+    ('𑰀', '𑰈'),
+    ('𑰊', '𑰮'),
+    ('𑱀', '𑱀'),
+    ('𑱲', '𑲏'),
+    ('𑴀', '𑴆'),
+    ('𑴈', '𑴉'),
+    ('𑴋', '𑴰'),
+    ('𑵆', '𑵆'),
+    ('𑵠', '𑵥'),
+    ('𑵧', '𑵨'),
+    ('𑵪', '𑶉'),
+    ('𑶘', '𑶘'),
+    ('𑻠', '𑻲'),
+    ('𑼂', '𑼂'),
+    ('𑼄', '𑼐'),
+    ('𑼒', '𑼳'),
+    ('𑾰', '𑾰'),
+    ('𒀀', '𒎙'),
+    ('𒐀', '𒑮'),
+    ('𒒀', '𒕃'),
+    ('𒾐', '𒿰'),
+    ('𓀀', '𓐯'),
+    ('𓑁', '𓑆'),
+    ('𔐀', '𔙆'),
+    ('𖠀', '𖨸'),
+    ('𖩀', '𖩞'),
+    ('𖩰', '𖪾'),
+    ('𖫐', '𖫭'),
+    ('𖬀', '𖬯'),
+    ('𖭀', '𖭃'),
+    ('𖭣', '𖭷'),
+    ('𖭽', '𖮏'),
+    ('𖹀', '𖹿'),
+    ('𖼀', '𖽊'),
+    ('𖽐', '𖽐'),
+    ('𖾓', '𖾟'),
+    ('𖿠', '𖿡'),
+    ('𖿣', '𖿣'),
+    ('𛰀', '𛱪'),
+    ('𛱰', '𛱼'),
+    ('𛲀', '𛲈'),
+    ('𛲐', '𛲙'),
+    ('𝐀', '𝑔'),
+    ('𝑖', '𝒜'),
+    ('𝒞', '𝒟'),
+    ('𝒢', '𝒢'),
+    ('𝒥', '𝒦'),
+    ('𝒩', '𝒬'),
+    ('𝒮', '𝒹'),
+    ('𝒻', '𝒻'),
+    ('𝒽', '𝓃'),
+    ('𝓅', '𝔅'),
+    ('𝔇', '𝔊'),
+    ('𝔍', '𝔔'),
+    ('𝔖', '𝔜'),
+    ('𝔞', '𝔹'),
+    ('𝔻', '𝔾'),
+    ('𝕀', '𝕄'),
+    ('𝕆', '𝕆'),
+    ('𝕊', '𝕐'),
+    ('𝕒', '𝚥'),
+    ('𝚨', '𝛀'),
+    ('𝛂', '𝛚'),
+    ('𝛜', '𝛺'),
+    ('𝛼', '𝜔'),
+    ('𝜖', '𝜴'),
+    ('𝜶', '𝝎'),
+    ('𝝐', '𝝮'),
+    ('𝝰', '𝞈'),
+    ('𝞊', '𝞨'),
+    ('𝞪', '𝟂'),
+    ('𝟄', '𝟋'),
+    ('𝼀', '𝼞'),
+    ('𝼥', '𝼪'),
+    ('𞀰', '𞁭'),
+    ('𞄀', '𞄬'),
+    ('𞄷', '𞄽'),
+    ('𞅎', '𞅎'),
+    ('𞊐', '𞊭'),
+    ('𞋀', '𞋫'),
+    ('𞓐', '𞓫'),
+    ('𞟠', '𞟦'),
+    ('𞟨', '𞟫'),
+    ('𞟭', '𞟮'),
+    ('𞟰', '𞟾'),
+    ('𞠀', '𞣄'),
+    ('𞤀', '𞥃'),
+    ('𞥋', '𞥋'),
+    ('𞸀', '𞸃'),
+    ('𞸅', '𞸟'),
+    ('𞸡', '𞸢'),
+    ('𞸤', '𞸤'),
+    ('𞸧', '𞸧'),
+    ('𞸩', '𞸲'),
+    ('𞸴', '𞸷'),
+    ('𞸹', '𞸹'),
+    ('𞸻', '𞸻'),
+    ('𞹂', '𞹂'),
+    ('𞹇', '𞹇'),
+    ('𞹉', '𞹉'),
+    ('𞹋', '𞹋'),
+    ('𞹍', '𞹏'),
+    ('𞹑', '𞹒'),
+    ('𞹔', '𞹔'),
+    ('𞹗', '𞹗'),
+    ('𞹙', '𞹙'),
+    ('𞹛', '𞹛'),
+    ('𞹝', '𞹝'),
+    ('𞹟', '𞹟'),
+    ('𞹡', '𞹢'),
+    ('𞹤', '𞹤'),
+    ('𞹧', '𞹪'),
+    ('𞹬', '𞹲'),
+    ('𞹴', '𞹷'),
+    ('𞹹', '𞹼'),
+    ('𞹾', '𞹾'),
+    ('𞺀', '𞺉'),
+    ('𞺋', '𞺛'),
+    ('𞺡', '𞺣'),
+    ('𞺥', '𞺩'),
+    ('𞺫', '𞺻'),
+    ('🄰', '🅉'),
+    ('🅐', '🅩'),
+    ('🅰', '🆉'),
+];
+
+pub const CR: &'static [(char, char)] = &[('\r', '\r')];
+
+pub const DOUBLE_QUOTE: &'static [(char, char)] = &[('"', '"')];
+
+pub const EXTEND: &'static [(char, char)] = &[
+    ('\u{300}', '\u{36f}'),
+    ('\u{483}', '\u{489}'),
+    ('\u{591}', '\u{5bd}'),
+    ('\u{5bf}', '\u{5bf}'),
+    ('\u{5c1}', '\u{5c2}'),
+    ('\u{5c4}', '\u{5c5}'),
+    ('\u{5c7}', '\u{5c7}'),
+    ('\u{610}', '\u{61a}'),
+    ('\u{64b}', '\u{65f}'),
+    ('\u{670}', '\u{670}'),
+    ('\u{6d6}', '\u{6dc}'),
+    ('\u{6df}', '\u{6e4}'),
+    ('\u{6e7}', '\u{6e8}'),
+    ('\u{6ea}', '\u{6ed}'),
+    ('\u{711}', '\u{711}'),
+    ('\u{730}', '\u{74a}'),
+    ('\u{7a6}', '\u{7b0}'),
+    ('\u{7eb}', '\u{7f3}'),
+    ('\u{7fd}', '\u{7fd}'),
+    ('\u{816}', '\u{819}'),
+    ('\u{81b}', '\u{823}'),
+    ('\u{825}', '\u{827}'),
+    ('\u{829}', '\u{82d}'),
+    ('\u{859}', '\u{85b}'),
+    ('\u{898}', '\u{89f}'),
+    ('\u{8ca}', '\u{8e1}'),
+    ('\u{8e3}', 'ः'),
+    ('\u{93a}', '\u{93c}'),
+    ('ा', 'ॏ'),
+    ('\u{951}', '\u{957}'),
+    ('\u{962}', '\u{963}'),
+    ('\u{981}', 'ঃ'),
+    ('\u{9bc}', '\u{9bc}'),
+    ('\u{9be}', '\u{9c4}'),
+    ('ে', 'ৈ'),
+    ('ো', '\u{9cd}'),
+    ('\u{9d7}', '\u{9d7}'),
+    ('\u{9e2}', '\u{9e3}'),
+    ('\u{9fe}', '\u{9fe}'),
+    ('\u{a01}', 'ਃ'),
+    ('\u{a3c}', '\u{a3c}'),
+    ('ਾ', '\u{a42}'),
+    ('\u{a47}', '\u{a48}'),
+    ('\u{a4b}', '\u{a4d}'),
+    ('\u{a51}', '\u{a51}'),
+    ('\u{a70}', '\u{a71}'),
+    ('\u{a75}', '\u{a75}'),
+    ('\u{a81}', 'ઃ'),
+    ('\u{abc}', '\u{abc}'),
+    ('ા', '\u{ac5}'),
+    ('\u{ac7}', 'ૉ'),
+    ('ો', '\u{acd}'),
+    ('\u{ae2}', '\u{ae3}'),
+    ('\u{afa}', '\u{aff}'),
+    ('\u{b01}', 'ଃ'),
+    ('\u{b3c}', '\u{b3c}'),
+    ('\u{b3e}', '\u{b44}'),
+    ('େ', 'ୈ'),
+    ('ୋ', '\u{b4d}'),
+    ('\u{b55}', '\u{b57}'),
+    ('\u{b62}', '\u{b63}'),
+    ('\u{b82}', '\u{b82}'),
+    ('\u{bbe}', 'ூ'),
+    ('ெ', 'ை'),
+    ('ொ', '\u{bcd}'),
+    ('\u{bd7}', '\u{bd7}'),
+    ('\u{c00}', '\u{c04}'),
+    ('\u{c3c}', '\u{c3c}'),
+    ('\u{c3e}', 'ౄ'),
+    ('\u{c46}', '\u{c48}'),
+    ('\u{c4a}', '\u{c4d}'),
+    ('\u{c55}', '\u{c56}'),
+    ('\u{c62}', '\u{c63}'),
+    ('\u{c81}', 'ಃ'),
+    ('\u{cbc}', '\u{cbc}'),
+    ('ಾ', 'ೄ'),
+    ('\u{cc6}', 'ೈ'),
+    ('ೊ', '\u{ccd}'),
+    ('\u{cd5}', '\u{cd6}'),
+    ('\u{ce2}', '\u{ce3}'),
+    ('ೳ', 'ೳ'),
+    ('\u{d00}', 'ഃ'),
+    ('\u{d3b}', '\u{d3c}'),
+    ('\u{d3e}', '\u{d44}'),
+    ('െ', 'ൈ'),
+    ('ൊ', '\u{d4d}'),
+    ('\u{d57}', '\u{d57}'),
+    ('\u{d62}', '\u{d63}'),
+    ('\u{d81}', 'ඃ'),
+    ('\u{dca}', '\u{dca}'),
+    ('\u{dcf}', '\u{dd4}'),
+    ('\u{dd6}', '\u{dd6}'),
+    ('ෘ', '\u{ddf}'),
+    ('ෲ', 'ෳ'),
+    ('\u{e31}', '\u{e31}'),
+    ('\u{e34}', '\u{e3a}'),
+    ('\u{e47}', '\u{e4e}'),
+    ('\u{eb1}', '\u{eb1}'),
+    ('\u{eb4}', '\u{ebc}'),
+    ('\u{ec8}', '\u{ece}'),
+    ('\u{f18}', '\u{f19}'),
+    ('\u{f35}', '\u{f35}'),
+    ('\u{f37}', '\u{f37}'),
+    ('\u{f39}', '\u{f39}'),
+    ('༾', '༿'),
+    ('\u{f71}', '\u{f84}'),
+    ('\u{f86}', '\u{f87}'),
+    ('\u{f8d}', '\u{f97}'),
+    ('\u{f99}', '\u{fbc}'),
+    ('\u{fc6}', '\u{fc6}'),
+    ('ါ', '\u{103e}'),
+    ('ၖ', '\u{1059}'),
+    ('\u{105e}', '\u{1060}'),
+    ('ၢ', 'ၤ'),
+    ('ၧ', 'ၭ'),
+    ('\u{1071}', '\u{1074}'),
+    ('\u{1082}', '\u{108d}'),
+    ('ႏ', 'ႏ'),
+    ('ႚ', '\u{109d}'),
+    ('\u{135d}', '\u{135f}'),
+    ('\u{1712}', '᜕'),
+    ('\u{1732}', '᜴'),
+    ('\u{1752}', '\u{1753}'),
+    ('\u{1772}', '\u{1773}'),
+    ('\u{17b4}', '\u{17d3}'),
+    ('\u{17dd}', '\u{17dd}'),
+    ('\u{180b}', '\u{180d}'),
+    ('\u{180f}', '\u{180f}'),
+    ('\u{1885}', '\u{1886}'),
+    ('\u{18a9}', '\u{18a9}'),
+    ('\u{1920}', 'ᤫ'),
+    ('ᤰ', '\u{193b}'),
+    ('\u{1a17}', '\u{1a1b}'),
+    ('ᩕ', '\u{1a5e}'),
+    ('\u{1a60}', '\u{1a7c}'),
+    ('\u{1a7f}', '\u{1a7f}'),
+    ('\u{1ab0}', '\u{1ace}'),
+    ('\u{1b00}', 'ᬄ'),
+    ('\u{1b34}', '᭄'),
+    ('\u{1b6b}', '\u{1b73}'),
+    ('\u{1b80}', 'ᮂ'),
+    ('ᮡ', '\u{1bad}'),
+    ('\u{1be6}', '᯳'),
+    ('ᰤ', '\u{1c37}'),
+    ('\u{1cd0}', '\u{1cd2}'),
+    ('\u{1cd4}', '\u{1ce8}'),
+    ('\u{1ced}', '\u{1ced}'),
+    ('\u{1cf4}', '\u{1cf4}'),
+    ('᳷', '\u{1cf9}'),
+    ('\u{1dc0}', '\u{1dff}'),
+    ('\u{200c}', '\u{200c}'),
+    ('\u{20d0}', '\u{20f0}'),
+    ('\u{2cef}', '\u{2cf1}'),
+    ('\u{2d7f}', '\u{2d7f}'),
+    ('\u{2de0}', '\u{2dff}'),
+    ('\u{302a}', '\u{302f}'),
+    ('\u{3099}', '\u{309a}'),
+    ('\u{a66f}', '\u{a672}'),
+    ('\u{a674}', '\u{a67d}'),
+    ('\u{a69e}', '\u{a69f}'),
+    ('\u{a6f0}', '\u{a6f1}'),
+    ('\u{a802}', '\u{a802}'),
+    ('\u{a806}', '\u{a806}'),
+    ('\u{a80b}', '\u{a80b}'),
+    ('ꠣ', 'ꠧ'),
+    ('\u{a82c}', '\u{a82c}'),
+    ('ꢀ', 'ꢁ'),
+    ('ꢴ', '\u{a8c5}'),
+    ('\u{a8e0}', '\u{a8f1}'),
+    ('\u{a8ff}', '\u{a8ff}'),
+    ('\u{a926}', '\u{a92d}'),
+    ('\u{a947}', '꥓'),
+    ('\u{a980}', 'ꦃ'),
+    ('\u{a9b3}', '꧀'),
+    ('\u{a9e5}', '\u{a9e5}'),
+    ('\u{aa29}', '\u{aa36}'),
+    ('\u{aa43}', '\u{aa43}'),
+    ('\u{aa4c}', 'ꩍ'),
+    ('ꩻ', 'ꩽ'),
+    ('\u{aab0}', '\u{aab0}'),
+    ('\u{aab2}', '\u{aab4}'),
+    ('\u{aab7}', '\u{aab8}'),
+    ('\u{aabe}', '\u{aabf}'),
+    ('\u{aac1}', '\u{aac1}'),
+    ('ꫫ', 'ꫯ'),
+    ('ꫵ', '\u{aaf6}'),
+    ('ꯣ', 'ꯪ'),
+    ('꯬', '\u{abed}'),
+    ('\u{fb1e}', '\u{fb1e}'),
+    ('\u{fe00}', '\u{fe0f}'),
+    ('\u{fe20}', '\u{fe2f}'),
+    ('\u{ff9e}', '\u{ff9f}'),
+    ('\u{101fd}', '\u{101fd}'),
+    ('\u{102e0}', '\u{102e0}'),
+    ('\u{10376}', '\u{1037a}'),
+    ('\u{10a01}', '\u{10a03}'),
+    ('\u{10a05}', '\u{10a06}'),
+    ('\u{10a0c}', '\u{10a0f}'),
+    ('\u{10a38}', '\u{10a3a}'),
+    ('\u{10a3f}', '\u{10a3f}'),
+    ('\u{10ae5}', '\u{10ae6}'),
+    ('\u{10d24}', '\u{10d27}'),
+    ('\u{10eab}', '\u{10eac}'),
+    ('\u{10efd}', '\u{10eff}'),
+    ('\u{10f46}', '\u{10f50}'),
+    ('\u{10f82}', '\u{10f85}'),
+    ('𑀀', '𑀂'),
+    ('\u{11038}', '\u{11046}'),
+    ('\u{11070}', '\u{11070}'),
+    ('\u{11073}', '\u{11074}'),
+    ('\u{1107f}', '𑂂'),
+    ('𑂰', '\u{110ba}'),
+    ('\u{110c2}', '\u{110c2}'),
+    ('\u{11100}', '\u{11102}'),
+    ('\u{11127}', '\u{11134}'),
+    ('𑅅', '𑅆'),
+    ('\u{11173}', '\u{11173}'),
+    ('\u{11180}', '𑆂'),
+    ('𑆳', '𑇀'),
+    ('\u{111c9}', '\u{111cc}'),
+    ('𑇎', '\u{111cf}'),
+    ('𑈬', '\u{11237}'),
+    ('\u{1123e}', '\u{1123e}'),
+    ('\u{11241}', '\u{11241}'),
+    ('\u{112df}', '\u{112ea}'),
+    ('\u{11300}', '𑌃'),
+    ('\u{1133b}', '\u{1133c}'),
+    ('\u{1133e}', '𑍄'),
+    ('𑍇', '𑍈'),
+    ('𑍋', '𑍍'),
+    ('\u{11357}', '\u{11357}'),
+    ('𑍢', '𑍣'),
+    ('\u{11366}', '\u{1136c}'),
+    ('\u{11370}', '\u{11374}'),
+    ('𑐵', '\u{11446}'),
+    ('\u{1145e}', '\u{1145e}'),
+    ('\u{114b0}', '\u{114c3}'),
+    ('\u{115af}', '\u{115b5}'),
+    ('𑖸', '\u{115c0}'),
+    ('\u{115dc}', '\u{115dd}'),
+    ('𑘰', '\u{11640}'),
+    ('\u{116ab}', '\u{116b7}'),
+    ('\u{1171d}', '\u{1172b}'),
+    ('𑠬', '\u{1183a}'),
+    ('\u{11930}', '𑤵'),
+    ('𑤷', '𑤸'),
+    ('\u{1193b}', '\u{1193e}'),
+    ('𑥀', '𑥀'),
+    ('𑥂', '\u{11943}'),
+    ('𑧑', '\u{119d7}'),
+    ('\u{119da}', '\u{119e0}'),
+    ('𑧤', '𑧤'),
+    ('\u{11a01}', '\u{11a0a}'),
+    ('\u{11a33}', '𑨹'),
+    ('\u{11a3b}', '\u{11a3e}'),
+    ('\u{11a47}', '\u{11a47}'),
+    ('\u{11a51}', '\u{11a5b}'),
+    ('\u{11a8a}', '\u{11a99}'),
+    ('𑰯', '\u{11c36}'),
+    ('\u{11c38}', '\u{11c3f}'),
+    ('\u{11c92}', '\u{11ca7}'),
+    ('𑲩', '\u{11cb6}'),
+    ('\u{11d31}', '\u{11d36}'),
+    ('\u{11d3a}', '\u{11d3a}'),
+    ('\u{11d3c}', '\u{11d3d}'),
+    ('\u{11d3f}', '\u{11d45}'),
+    ('\u{11d47}', '\u{11d47}'),
+    ('𑶊', '𑶎'),
+    ('\u{11d90}', '\u{11d91}'),
+    ('𑶓', '\u{11d97}'),
+    ('\u{11ef3}', '𑻶'),
+    ('\u{11f00}', '\u{11f01}'),
+    ('𑼃', '𑼃'),
+    ('𑼴', '\u{11f3a}'),
+    ('𑼾', '\u{11f42}'),
+    ('\u{13440}', '\u{13440}'),
+    ('\u{13447}', '\u{13455}'),
+    ('\u{16af0}', '\u{16af4}'),
+    ('\u{16b30}', '\u{16b36}'),
+    ('\u{16f4f}', '\u{16f4f}'),
+    ('𖽑', '𖾇'),
+    ('\u{16f8f}', '\u{16f92}'),
+    ('\u{16fe4}', '\u{16fe4}'),
+    ('𖿰', '𖿱'),
+    ('\u{1bc9d}', '\u{1bc9e}'),
+    ('\u{1cf00}', '\u{1cf2d}'),
+    ('\u{1cf30}', '\u{1cf46}'),
+    ('\u{1d165}', '\u{1d169}'),
+    ('𝅭', '\u{1d172}'),
+    ('\u{1d17b}', '\u{1d182}'),
+    ('\u{1d185}', '\u{1d18b}'),
+    ('\u{1d1aa}', '\u{1d1ad}'),
+    ('\u{1d242}', '\u{1d244}'),
+    ('\u{1da00}', '\u{1da36}'),
+    ('\u{1da3b}', '\u{1da6c}'),
+    ('\u{1da75}', '\u{1da75}'),
+    ('\u{1da84}', '\u{1da84}'),
+    ('\u{1da9b}', '\u{1da9f}'),
+    ('\u{1daa1}', '\u{1daaf}'),
+    ('\u{1e000}', '\u{1e006}'),
+    ('\u{1e008}', '\u{1e018}'),
+    ('\u{1e01b}', '\u{1e021}'),
+    ('\u{1e023}', '\u{1e024}'),
+    ('\u{1e026}', '\u{1e02a}'),
+    ('\u{1e08f}', '\u{1e08f}'),
+    ('\u{1e130}', '\u{1e136}'),
+    ('\u{1e2ae}', '\u{1e2ae}'),
+    ('\u{1e2ec}', '\u{1e2ef}'),
+    ('\u{1e4ec}', '\u{1e4ef}'),
+    ('\u{1e8d0}', '\u{1e8d6}'),
+    ('\u{1e944}', '\u{1e94a}'),
+    ('🏻', '🏿'),
+    ('\u{e0020}', '\u{e007f}'),
+    ('\u{e0100}', '\u{e01ef}'),
+];
+
+pub const EXTENDNUMLET: &'static [(char, char)] = &[
+    ('_', '_'),
+    ('\u{202f}', '\u{202f}'),
+    ('‿', '⁀'),
+    ('⁔', '⁔'),
+    ('︳', '︴'),
+    ('﹍', '﹏'),
+    ('＿', '＿'),
+];
+
+pub const FORMAT: &'static [(char, char)] = &[
+    ('\u{ad}', '\u{ad}'),
+    ('\u{600}', '\u{605}'),
+    ('\u{61c}', '\u{61c}'),
+    ('\u{6dd}', '\u{6dd}'),
+    ('\u{70f}', '\u{70f}'),
+    ('\u{890}', '\u{891}'),
+    ('\u{8e2}', '\u{8e2}'),
+    ('\u{180e}', '\u{180e}'),
+    ('\u{200e}', '\u{200f}'),
+    ('\u{202a}', '\u{202e}'),
+    ('\u{2060}', '\u{2064}'),
+    ('\u{2066}', '\u{206f}'),
+    ('\u{feff}', '\u{feff}'),
+    ('\u{fff9}', '\u{fffb}'),
+    ('\u{110bd}', '\u{110bd}'),
+    ('\u{110cd}', '\u{110cd}'),
+    ('\u{13430}', '\u{1343f}'),
+    ('\u{1bca0}', '\u{1bca3}'),
+    ('\u{1d173}', '\u{1d17a}'),
+    ('\u{e0001}', '\u{e0001}'),
+];
+
+pub const HEBREW_LETTER: &'static [(char, char)] = &[
+    ('א', 'ת'),
+    ('ׯ', 'ײ'),
+    ('יִ', 'יִ'),
+    ('ײַ', 'ﬨ'),
+    ('שׁ', 'זּ'),
+    ('טּ', 'לּ'),
+    ('מּ', 'מּ'),
+    ('נּ', 'סּ'),
+    ('ףּ', 'פּ'),
+    ('צּ', 'ﭏ'),
+];
+
+pub const KATAKANA: &'static [(char, char)] = &[
+    ('〱', '〵'),
+    ('゛', '゜'),
+    ('゠', 'ヺ'),
+    ('ー', 'ヿ'),
+    ('ㇰ', 'ㇿ'),
+    ('㋐', '㋾'),
+    ('㌀', '㍗'),
+    ('ｦ', 'ﾝ'),
+    ('𚿰', '𚿳'),
+    ('𚿵', '𚿻'),
+    ('𚿽', '𚿾'),
+    ('𛀀', '𛀀'),
+    ('𛄠', '𛄢'),
+    ('𛅕', '𛅕'),
+    ('𛅤', '𛅧'),
+];
+
+pub const LF: &'static [(char, char)] = &[('\n', '\n')];
+
+pub const MIDLETTER: &'static [(char, char)] = &[
+    (':', ':'),
+    ('·', '·'),
+    ('·', '·'),
+    ('՟', '՟'),
+    ('״', '״'),
+    ('‧', '‧'),
+    ('︓', '︓'),
+    ('﹕', '﹕'),
+    ('：', '：'),
+];
+
+pub const MIDNUM: &'static [(char, char)] = &[
+    (',', ','),
+    (';', ';'),
+    (';', ';'),
+    ('։', '։'),
+    ('،', '؍'),
+    ('٬', '٬'),
+    ('߸', '߸'),
+    ('⁄', '⁄'),
+    ('︐', '︐'),
+    ('︔', '︔'),
+    ('﹐', '﹐'),
+    ('﹔', '﹔'),
+    ('，', '，'),
+    ('；', '；'),
+];
+
+pub const MIDNUMLET: &'static [(char, char)] = &[
+    ('.', '.'),
+    ('‘', '’'),
+    ('․', '․'),
+    ('﹒', '﹒'),
+    ('＇', '＇'),
+    ('．', '．'),
+];
+
+pub const NEWLINE: &'static [(char, char)] =
+    &[('\u{b}', '\u{c}'), ('\u{85}', '\u{85}'), ('\u{2028}', '\u{2029}')];
+
+pub const NUMERIC: &'static [(char, char)] = &[
+    ('0', '9'),
+    ('٠', '٩'),
+    ('٫', '٫'),
+    ('۰', '۹'),
+    ('߀', '߉'),
+    ('०', '९'),
+    ('০', '৯'),
+    ('੦', '੯'),
+    ('૦', '૯'),
+    ('୦', '୯'),
+    ('௦', '௯'),
+    ('౦', '౯'),
+    ('೦', '೯'),
+    ('൦', '൯'),
+    ('෦', '෯'),
+    ('๐', '๙'),
+    ('໐', '໙'),
+    ('༠', '༩'),
+    ('၀', '၉'),
+    ('႐', '႙'),
+    ('០', '៩'),
+    ('᠐', '᠙'),
+    ('᥆', '᥏'),
+    ('᧐', '᧙'),
+    ('᪀', '᪉'),
+    ('᪐', '᪙'),
+    ('᭐', '᭙'),
+    ('᮰', '᮹'),
+    ('᱀', '᱉'),
+    ('᱐', '᱙'),
+    ('꘠', '꘩'),
+    ('꣐', '꣙'),
+    ('꤀', '꤉'),
+    ('꧐', '꧙'),
+    ('꧰', '꧹'),
+    ('꩐', '꩙'),
+    ('꯰', '꯹'),
+    ('０', '９'),
+    ('𐒠', '𐒩'),
+    ('𐴰', '𐴹'),
+    ('𑁦', '𑁯'),
+    ('𑃰', '𑃹'),
+    ('𑄶', '𑄿'),
+    ('𑇐', '𑇙'),
+    ('𑋰', '𑋹'),
+    ('𑑐', '𑑙'),
+    ('𑓐', '𑓙'),
+    ('𑙐', '𑙙'),
+    ('𑛀', '𑛉'),
+    ('𑜰', '𑜹'),
+    ('𑣠', '𑣩'),
+    ('𑥐', '𑥙'),
+    ('𑱐', '𑱙'),
+    ('𑵐', '𑵙'),
+    ('𑶠', '𑶩'),
+    ('𑽐', '𑽙'),
+    ('𖩠', '𖩩'),
+    ('𖫀', '𖫉'),
+    ('𖭐', '𖭙'),
+    ('𝟎', '𝟿'),
+    ('𞅀', '𞅉'),
+    ('𞋰', '𞋹'),
+    ('𞓰', '𞓹'),
+    ('𞥐', '𞥙'),
+    ('🯰', '🯹'),
+];
+
+pub const REGIONAL_INDICATOR: &'static [(char, char)] = &[('🇦', '🇿')];
+
+pub const SINGLE_QUOTE: &'static [(char, char)] = &[('\'', '\'')];
+
+pub const WSEGSPACE: &'static [(char, char)] = &[
+    (' ', ' '),
+    ('\u{1680}', '\u{1680}'),
+    ('\u{2000}', '\u{2006}'),
+    ('\u{2008}', '\u{200a}'),
+    ('\u{205f}', '\u{205f}'),
+    ('\u{3000}', '\u{3000}'),
+];
+
+pub const ZWJ: &'static [(char, char)] = &[('\u{200d}', '\u{200d}')];
diff --git a/crates/regex-syntax/src/utf8.rs b/crates/regex-syntax/src/utf8.rs
new file mode 100644
index 0000000..b9c8655
--- /dev/null
+++ b/crates/regex-syntax/src/utf8.rs
@@ -0,0 +1,587 @@
+/*!
+Converts ranges of Unicode scalar values to equivalent ranges of UTF-8 bytes.
+
+This is sub-module is useful for constructing byte based automatons that need
+to embed UTF-8 decoding. The most common use of this module is in conjunction
+with the [`hir::ClassUnicodeRange`](../hir/struct.ClassUnicodeRange.html) type.
+
+See the documentation on the `Utf8Sequences` iterator for more details and
+an example.
+
+# Wait, what is this?
+
+This is simplest to explain with an example. Let's say you wanted to test
+whether a particular byte sequence was a Cyrillic character. One possible
+scalar value range is `[0400-04FF]`. The set of allowed bytes for this
+range can be expressed as a sequence of byte ranges:
+
+```text
+[D0-D3][80-BF]
+```
+
+This is simple enough: simply encode the boundaries, `0400` encodes to
+`D0 80` and `04FF` encodes to `D3 BF`, and create ranges from each
+corresponding pair of bytes: `D0` to `D3` and `80` to `BF`.
+
+However, what if you wanted to add the Cyrillic Supplementary characters to
+your range? Your range might then become `[0400-052F]`. The same procedure
+as above doesn't quite work because `052F` encodes to `D4 AF`. The byte ranges
+you'd get from the previous transformation would be `[D0-D4][80-AF]`. However,
+this isn't quite correct because this range doesn't capture many characters,
+for example, `04FF` (because its last byte, `BF` isn't in the range `80-AF`).
+
+Instead, you need multiple sequences of byte ranges:
+
+```text
+[D0-D3][80-BF]  # matches codepoints 0400-04FF
+[D4][80-AF]     # matches codepoints 0500-052F
+```
+
+This gets even more complicated if you want bigger ranges, particularly if
+they naively contain surrogate codepoints. For example, the sequence of byte
+ranges for the basic multilingual plane (`[0000-FFFF]`) look like this:
+
+```text
+[0-7F]
+[C2-DF][80-BF]
+[E0][A0-BF][80-BF]
+[E1-EC][80-BF][80-BF]
+[ED][80-9F][80-BF]
+[EE-EF][80-BF][80-BF]
+```
+
+Note that the byte ranges above will *not* match any erroneous encoding of
+UTF-8, including encodings of surrogate codepoints.
+
+And, of course, for all of Unicode (`[000000-10FFFF]`):
+
+```text
+[0-7F]
+[C2-DF][80-BF]
+[E0][A0-BF][80-BF]
+[E1-EC][80-BF][80-BF]
+[ED][80-9F][80-BF]
+[EE-EF][80-BF][80-BF]
+[F0][90-BF][80-BF][80-BF]
+[F1-F3][80-BF][80-BF][80-BF]
+[F4][80-8F][80-BF][80-BF]
+```
+
+This module automates the process of creating these byte ranges from ranges of
+Unicode scalar values.
+
+# Lineage
+
+I got the idea and general implementation strategy from Russ Cox in his
+[article on regexps](https://web.archive.org/web/20160404141123/https://swtch.com/~rsc/regexp/regexp3.html) and RE2.
+Russ Cox got it from Ken Thompson's `grep` (no source, folk lore?).
+I also got the idea from
+[Lucene](https://github.com/apache/lucene-solr/blob/ae93f4e7ac6a3908046391de35d4f50a0d3c59ca/lucene/core/src/java/org/apache/lucene/util/automaton/UTF32ToUTF8.java),
+which uses it for executing automata on their term index.
+*/
+
+#![deny(missing_docs)]
+
+use std::char;
+use std::fmt;
+use std::iter::FusedIterator;
+use std::slice;
+
+const MAX_UTF8_BYTES: usize = 4;
+
+/// Utf8Sequence represents a sequence of byte ranges.
+///
+/// To match a Utf8Sequence, a candidate byte sequence must match each
+/// successive range.
+///
+/// For example, if there are two ranges, `[C2-DF][80-BF]`, then the byte
+/// sequence `\xDD\x61` would not match because `0x61 < 0x80`.
+#[derive(Copy, Clone, Eq, PartialEq, PartialOrd, Ord)]
+pub enum Utf8Sequence {
+    /// One byte range.
+    One(Utf8Range),
+    /// Two successive byte ranges.
+    Two([Utf8Range; 2]),
+    /// Three successive byte ranges.
+    Three([Utf8Range; 3]),
+    /// Four successive byte ranges.
+    Four([Utf8Range; 4]),
+}
+
+impl Utf8Sequence {
+    /// Creates a new UTF-8 sequence from the encoded bytes of a scalar value
+    /// range.
+    ///
+    /// This assumes that `start` and `end` have the same length.
+    fn from_encoded_range(start: &[u8], end: &[u8]) -> Self {
+        assert_eq!(start.len(), end.len());
+        match start.len() {
+            2 => Utf8Sequence::Two([
+                Utf8Range::new(start[0], end[0]),
+                Utf8Range::new(start[1], end[1]),
+            ]),
+            3 => Utf8Sequence::Three([
+                Utf8Range::new(start[0], end[0]),
+                Utf8Range::new(start[1], end[1]),
+                Utf8Range::new(start[2], end[2]),
+            ]),
+            4 => Utf8Sequence::Four([
+                Utf8Range::new(start[0], end[0]),
+                Utf8Range::new(start[1], end[1]),
+                Utf8Range::new(start[2], end[2]),
+                Utf8Range::new(start[3], end[3]),
+            ]),
+            n => unreachable!("invalid encoded length: {}", n),
+        }
+    }
+
+    /// Returns the underlying sequence of byte ranges as a slice.
+    pub fn as_slice(&self) -> &[Utf8Range] {
+        use self::Utf8Sequence::*;
+        match *self {
+            One(ref r) => slice::from_ref(r),
+            Two(ref r) => &r[..],
+            Three(ref r) => &r[..],
+            Four(ref r) => &r[..],
+        }
+    }
+
+    /// Returns the number of byte ranges in this sequence.
+    ///
+    /// The length is guaranteed to be in the closed interval `[1, 4]`.
+    pub fn len(&self) -> usize {
+        self.as_slice().len()
+    }
+
+    /// Reverses the ranges in this sequence.
+    ///
+    /// For example, if this corresponds to the following sequence:
+    ///
+    /// ```text
+    /// [D0-D3][80-BF]
+    /// ```
+    ///
+    /// Then after reversal, it will be
+    ///
+    /// ```text
+    /// [80-BF][D0-D3]
+    /// ```
+    ///
+    /// This is useful when one is constructing a UTF-8 automaton to match
+    /// character classes in reverse.
+    pub fn reverse(&mut self) {
+        match *self {
+            Utf8Sequence::One(_) => {}
+            Utf8Sequence::Two(ref mut x) => x.reverse(),
+            Utf8Sequence::Three(ref mut x) => x.reverse(),
+            Utf8Sequence::Four(ref mut x) => x.reverse(),
+        }
+    }
+
+    /// Returns true if and only if a prefix of `bytes` matches this sequence
+    /// of byte ranges.
+    pub fn matches(&self, bytes: &[u8]) -> bool {
+        if bytes.len() < self.len() {
+            return false;
+        }
+        for (&b, r) in bytes.iter().zip(self) {
+            if !r.matches(b) {
+                return false;
+            }
+        }
+        true
+    }
+}
+
+impl<'a> IntoIterator for &'a Utf8Sequence {
+    type IntoIter = slice::Iter<'a, Utf8Range>;
+    type Item = &'a Utf8Range;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.as_slice().iter()
+    }
+}
+
+impl fmt::Debug for Utf8Sequence {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use self::Utf8Sequence::*;
+        match *self {
+            One(ref r) => write!(f, "{:?}", r),
+            Two(ref r) => write!(f, "{:?}{:?}", r[0], r[1]),
+            Three(ref r) => write!(f, "{:?}{:?}{:?}", r[0], r[1], r[2]),
+            Four(ref r) => {
+                write!(f, "{:?}{:?}{:?}{:?}", r[0], r[1], r[2], r[3])
+            }
+        }
+    }
+}
+
+/// A single inclusive range of UTF-8 bytes.
+#[derive(Clone, Copy, Eq, PartialEq, PartialOrd, Ord)]
+pub struct Utf8Range {
+    /// Start of byte range (inclusive).
+    pub start: u8,
+    /// End of byte range (inclusive).
+    pub end: u8,
+}
+
+impl Utf8Range {
+    fn new(start: u8, end: u8) -> Self {
+        Utf8Range { start, end }
+    }
+
+    /// Returns true if and only if the given byte is in this range.
+    pub fn matches(&self, b: u8) -> bool {
+        self.start <= b && b <= self.end
+    }
+}
+
+impl fmt::Debug for Utf8Range {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if self.start == self.end {
+            write!(f, "[{:X}]", self.start)
+        } else {
+            write!(f, "[{:X}-{:X}]", self.start, self.end)
+        }
+    }
+}
+
+/// An iterator over ranges of matching UTF-8 byte sequences.
+///
+/// The iteration represents an alternation of comprehensive byte sequences
+/// that match precisely the set of UTF-8 encoded scalar values.
+///
+/// A byte sequence corresponds to one of the scalar values in the range given
+/// if and only if it completely matches exactly one of the sequences of byte
+/// ranges produced by this iterator.
+///
+/// Each sequence of byte ranges matches a unique set of bytes. That is, no two
+/// sequences will match the same bytes.
+///
+/// # Example
+///
+/// This shows how to match an arbitrary byte sequence against a range of
+/// scalar values.
+///
+/// ```rust
+/// use regex_syntax::utf8::{Utf8Sequences, Utf8Sequence};
+///
+/// fn matches(seqs: &[Utf8Sequence], bytes: &[u8]) -> bool {
+///     for range in seqs {
+///         if range.matches(bytes) {
+///             return true;
+///         }
+///     }
+///     false
+/// }
+///
+/// // Test the basic multilingual plane.
+/// let seqs: Vec<_> = Utf8Sequences::new('\u{0}', '\u{FFFF}').collect();
+///
+/// // UTF-8 encoding of 'a'.
+/// assert!(matches(&seqs, &[0x61]));
+/// // UTF-8 encoding of '☃' (`\u{2603}`).
+/// assert!(matches(&seqs, &[0xE2, 0x98, 0x83]));
+/// // UTF-8 encoding of `\u{10348}` (outside the BMP).
+/// assert!(!matches(&seqs, &[0xF0, 0x90, 0x8D, 0x88]));
+/// // Tries to match against a UTF-8 encoding of a surrogate codepoint,
+/// // which is invalid UTF-8, and therefore fails, despite the fact that
+/// // the corresponding codepoint (0xD800) falls in the range given.
+/// assert!(!matches(&seqs, &[0xED, 0xA0, 0x80]));
+/// // And fails against plain old invalid UTF-8.
+/// assert!(!matches(&seqs, &[0xFF, 0xFF]));
+/// ```
+///
+/// If this example seems circuitous, that's because it is! It's meant to be
+/// illustrative. In practice, you could just try to decode your byte sequence
+/// and compare it with the scalar value range directly. However, this is not
+/// always possible (for example, in a byte based automaton).
+#[derive(Debug)]
+pub struct Utf8Sequences {
+    range_stack: Vec<ScalarRange>,
+}
+
+impl Utf8Sequences {
+    /// Create a new iterator over UTF-8 byte ranges for the scalar value range
+    /// given.
+    pub fn new(start: char, end: char) -> Self {
+        let mut it = Utf8Sequences { range_stack: vec![] };
+        it.push(start as u32, end as u32);
+        it
+    }
+
+    /// reset resets the scalar value range.
+    /// Any existing state is cleared, but resources may be reused.
+    ///
+    /// N.B. Benchmarks say that this method is dubious.
+    #[doc(hidden)]
+    pub fn reset(&mut self, start: char, end: char) {
+        self.range_stack.clear();
+        self.push(start as u32, end as u32);
+    }
+
+    fn push(&mut self, start: u32, end: u32) {
+        self.range_stack.push(ScalarRange { start, end });
+    }
+}
+
+struct ScalarRange {
+    start: u32,
+    end: u32,
+}
+
+impl fmt::Debug for ScalarRange {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "ScalarRange({:X}, {:X})", self.start, self.end)
+    }
+}
+
+impl Iterator for Utf8Sequences {
+    type Item = Utf8Sequence;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        'TOP: while let Some(mut r) = self.range_stack.pop() {
+            'INNER: loop {
+                if let Some((r1, r2)) = r.split() {
+                    self.push(r2.start, r2.end);
+                    r.start = r1.start;
+                    r.end = r1.end;
+                    continue 'INNER;
+                }
+                if !r.is_valid() {
+                    continue 'TOP;
+                }
+                for i in 1..MAX_UTF8_BYTES {
+                    let max = max_scalar_value(i);
+                    if r.start <= max && max < r.end {
+                        self.push(max + 1, r.end);
+                        r.end = max;
+                        continue 'INNER;
+                    }
+                }
+                if let Some(ascii_range) = r.as_ascii() {
+                    return Some(Utf8Sequence::One(ascii_range));
+                }
+                for i in 1..MAX_UTF8_BYTES {
+                    let m = (1 << (6 * i)) - 1;
+                    if (r.start & !m) != (r.end & !m) {
+                        if (r.start & m) != 0 {
+                            self.push((r.start | m) + 1, r.end);
+                            r.end = r.start | m;
+                            continue 'INNER;
+                        }
+                        if (r.end & m) != m {
+                            self.push(r.end & !m, r.end);
+                            r.end = (r.end & !m) - 1;
+                            continue 'INNER;
+                        }
+                    }
+                }
+                let mut start = [0; MAX_UTF8_BYTES];
+                let mut end = [0; MAX_UTF8_BYTES];
+                let n = r.encode(&mut start, &mut end);
+                return Some(Utf8Sequence::from_encoded_range(
+                    &start[0..n],
+                    &end[0..n],
+                ));
+            }
+        }
+        None
+    }
+}
+
+impl FusedIterator for Utf8Sequences {}
+
+impl ScalarRange {
+    /// split splits this range if it overlaps with a surrogate codepoint.
+    ///
+    /// Either or both ranges may be invalid.
+    fn split(&self) -> Option<(ScalarRange, ScalarRange)> {
+        if self.start < 0xE000 && self.end > 0xD7FF {
+            Some((
+                ScalarRange { start: self.start, end: 0xD7FF },
+                ScalarRange { start: 0xE000, end: self.end },
+            ))
+        } else {
+            None
+        }
+    }
+
+    /// is_valid returns true if and only if start <= end.
+    fn is_valid(&self) -> bool {
+        self.start <= self.end
+    }
+
+    /// as_ascii returns this range as a Utf8Range if and only if all scalar
+    /// values in this range can be encoded as a single byte.
+    fn as_ascii(&self) -> Option<Utf8Range> {
+        if self.is_ascii() {
+            Some(Utf8Range::new(self.start as u8, self.end as u8))
+        } else {
+            None
+        }
+    }
+
+    /// is_ascii returns true if the range is ASCII only (i.e., takes a single
+    /// byte to encode any scalar value).
+    fn is_ascii(&self) -> bool {
+        self.is_valid() && self.end <= 0x7f
+    }
+
+    /// encode writes the UTF-8 encoding of the start and end of this range
+    /// to the corresponding destination slices, and returns the number of
+    /// bytes written.
+    ///
+    /// The slices should have room for at least `MAX_UTF8_BYTES`.
+    fn encode(&self, start: &mut [u8], end: &mut [u8]) -> usize {
+        let cs = char::from_u32(self.start).unwrap();
+        let ce = char::from_u32(self.end).unwrap();
+        let ss = cs.encode_utf8(start);
+        let se = ce.encode_utf8(end);
+        assert_eq!(ss.len(), se.len());
+        ss.len()
+    }
+}
+
+fn max_scalar_value(nbytes: usize) -> u32 {
+    match nbytes {
+        1 => 0x007F,
+        2 => 0x07FF,
+        3 => 0xFFFF,
+        4 => 0x0010_FFFF,
+        _ => unreachable!("invalid UTF-8 byte sequence size"),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::char;
+
+    use crate::utf8::{Utf8Range, Utf8Sequences};
+
+    fn rutf8(s: u8, e: u8) -> Utf8Range {
+        Utf8Range::new(s, e)
+    }
+
+    fn never_accepts_surrogate_codepoints(start: char, end: char) {
+        for cp in 0xD800..0xE000 {
+            let buf = encode_surrogate(cp);
+            for r in Utf8Sequences::new(start, end) {
+                if r.matches(&buf) {
+                    panic!(
+                        "Sequence ({:X}, {:X}) contains range {:?}, \
+                         which matches surrogate code point {:X} \
+                         with encoded bytes {:?}",
+                        start as u32, end as u32, r, cp, buf,
+                    );
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn codepoints_no_surrogates() {
+        never_accepts_surrogate_codepoints('\u{0}', '\u{FFFF}');
+        never_accepts_surrogate_codepoints('\u{0}', '\u{10FFFF}');
+        never_accepts_surrogate_codepoints('\u{0}', '\u{10FFFE}');
+        never_accepts_surrogate_codepoints('\u{80}', '\u{10FFFF}');
+        never_accepts_surrogate_codepoints('\u{D7FF}', '\u{E000}');
+    }
+
+    #[test]
+    fn single_codepoint_one_sequence() {
+        // Tests that every range of scalar values that contains a single
+        // scalar value is recognized by one sequence of byte ranges.
+        for i in 0x0..=0x0010_FFFF {
+            let c = match char::from_u32(i) {
+                None => continue,
+                Some(c) => c,
+            };
+            let seqs: Vec<_> = Utf8Sequences::new(c, c).collect();
+            assert_eq!(seqs.len(), 1);
+        }
+    }
+
+    #[test]
+    fn bmp() {
+        use crate::utf8::Utf8Sequence::*;
+
+        let seqs = Utf8Sequences::new('\u{0}', '\u{FFFF}').collect::<Vec<_>>();
+        assert_eq!(
+            seqs,
+            vec![
+                One(rutf8(0x0, 0x7F)),
+                Two([rutf8(0xC2, 0xDF), rutf8(0x80, 0xBF)]),
+                Three([
+                    rutf8(0xE0, 0xE0),
+                    rutf8(0xA0, 0xBF),
+                    rutf8(0x80, 0xBF)
+                ]),
+                Three([
+                    rutf8(0xE1, 0xEC),
+                    rutf8(0x80, 0xBF),
+                    rutf8(0x80, 0xBF)
+                ]),
+                Three([
+                    rutf8(0xED, 0xED),
+                    rutf8(0x80, 0x9F),
+                    rutf8(0x80, 0xBF)
+                ]),
+                Three([
+                    rutf8(0xEE, 0xEF),
+                    rutf8(0x80, 0xBF),
+                    rutf8(0x80, 0xBF)
+                ]),
+            ]
+        );
+    }
+
+    #[test]
+    fn reverse() {
+        use crate::utf8::Utf8Sequence::*;
+
+        let mut s = One(rutf8(0xA, 0xB));
+        s.reverse();
+        assert_eq!(s.as_slice(), &[rutf8(0xA, 0xB)]);
+
+        let mut s = Two([rutf8(0xA, 0xB), rutf8(0xB, 0xC)]);
+        s.reverse();
+        assert_eq!(s.as_slice(), &[rutf8(0xB, 0xC), rutf8(0xA, 0xB)]);
+
+        let mut s = Three([rutf8(0xA, 0xB), rutf8(0xB, 0xC), rutf8(0xC, 0xD)]);
+        s.reverse();
+        assert_eq!(
+            s.as_slice(),
+            &[rutf8(0xC, 0xD), rutf8(0xB, 0xC), rutf8(0xA, 0xB)]
+        );
+
+        let mut s = Four([
+            rutf8(0xA, 0xB),
+            rutf8(0xB, 0xC),
+            rutf8(0xC, 0xD),
+            rutf8(0xD, 0xE),
+        ]);
+        s.reverse();
+        assert_eq!(
+            s.as_slice(),
+            &[
+                rutf8(0xD, 0xE),
+                rutf8(0xC, 0xD),
+                rutf8(0xB, 0xC),
+                rutf8(0xA, 0xB)
+            ]
+        );
+    }
+
+    fn encode_surrogate(cp: u32) -> [u8; 3] {
+        const TAG_CONT: u8 = 0b1000_0000;
+        const TAG_THREE_B: u8 = 0b1110_0000;
+
+        assert!(0xD800 <= cp && cp < 0xE000);
+        let mut dst = [0; 3];
+        dst[0] = (cp >> 12 & 0x0F) as u8 | TAG_THREE_B;
+        dst[1] = (cp >> 6 & 0x3F) as u8 | TAG_CONT;
+        dst[2] = (cp & 0x3F) as u8 | TAG_CONT;
+        dst
+    }
+}
diff --git a/crates/regex-syntax/test b/crates/regex-syntax/test
new file mode 100755
index 0000000..4b1b9fb
--- /dev/null
+++ b/crates/regex-syntax/test
@@ -0,0 +1,22 @@
+#!/bin/bash
+
+set -e
+
+# This is a convenience script for running a broad swath of the syntax tests.
+echo "===== DEFAULT FEATURES ==="
+cargo test
+
+features=(
+    unicode
+    unicode-age
+    unicode-bool
+    unicode-case
+    unicode-gencat
+    unicode-perl
+    unicode-script
+    unicode-segment
+)
+for f in "${features[@]}"; do
+    echo "===== FEATURE: $f ==="
+    cargo test --no-default-features --features "$f"
+done
diff --git a/crates/regex/.cargo-checksum.json b/crates/regex/.cargo-checksum.json
new file mode 100644
index 0000000..d6ea1df
--- /dev/null
+++ b/crates/regex/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"CHANGELOG.md":"c66cc76a297a1068a3aa81d08326175be887b60fb6330c4b7922f4ad286bd144","Cargo.lock":"fa78ce7955999185e017ef812db215124b65ae8aef67b4ea9ca5bd18c50b0d35","Cargo.toml":"566dca60827f0cbafd1d920457d6d7fad9bd5b85630832207de8cc9c35cab274","HACKING.md":"17818f7a17723608f6bdbe6388ad0a913d4f96f76a16649aaf4e274b1fa0ea97","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"6485b8ed310d3f0340bf1ad1f47645069ce4069dcc6bb46c7d5c6faf41de1fdb","PERFORMANCE.md":"0d5ef3866386918dfdefb1aa9a28cfe33cb3c8ceeb79f3f8ba5b88253dd95991","README.md":"f69204a0f446047d8f4d1f3d84b75f235adb5c26477f3a37b671411bc954d14c","UNICODE.md":"a8a8399540eed000d19420135a527f400247a04572e44d124c786b870f518776","examples/regexdna-input.txt":"156a49710bb3e1ed4bc2bbb0af0f383b747b3d0281453cfff39c296124c598f8","examples/regexdna-output.txt":"35e85b19b70a893d752fd43e54e1e9da08bac43559191cea85b33387c24c4cc1","examples/shootout-regex-dna-bytes.rs":"fa2daedb4e0a05f64f33f4af62fbb0176db998e3676f8637ab684b725367a7b4","examples/shootout-regex-dna-cheat.rs":"1f871a6eaaf8372299fa3c762051112fa89a14235b03f734fc50ebd51ecaee72","examples/shootout-regex-dna-replace.rs":"32ffdf13ac6c4ce3fc32116a048e9cc682aa34cdb8e5beaf565a22addbdcd9ab","examples/shootout-regex-dna-single-cheat.rs":"809f75bf1e1917a53623eb6f1a3ce3b7d2ed98a6a1dbc0bd4853bec49a0c6f94","examples/shootout-regex-dna-single.rs":"1ab14f5703cd4be2e75a2e792e0ba1d322b9e4b14535d396805a4316d577f5bb","examples/shootout-regex-dna.rs":"20ea46ab63f91e3ac6a64e997eadd436a9cbc2f1bdade28e4512052f0e25bc34","rustfmt.toml":"1ca600239a27401c4a43f363cf3f38183a212affc1f31bff3ae93234bbaec228","src/backtrack.rs":"52987d80448f3d7f5d4e3545ddfc09f1f30de7602d9b5489961db4b215a377fd","src/compile.rs":"79a59be2d2db650b5a322e15e9bf1d3227944410bc780fc6089da8f4d2609b77","src/dfa.rs":"10273980d1f08aaff495e11efa240249a2b2c08a4db7c49c8d6759bc65a3b174","src/error.rs":"71c85db839514f26ee024a689061743ea94a34eb7a3291e6c2b69b45a9682d09","src/exec.rs":"4726e2c210c6adb91b25390cbc864ab71deabb17ca87a46e83acef26a194bfc2","src/expand.rs":"71220309a3bac797f55129f49e79c03e96efec894ea338c735b78695367e04ca","src/find_byte.rs":"b387247b77e3269f057c3399aefe5a815032c3af918c876f80eb4b282e4eb95e","src/freqs.rs":"255555f3d95b08a5bb3bc2f38d5a06cc100a39c0f0127fe4f50c33afa1cadc65","src/input.rs":"13f49c1bce2fadd04a45b421d374cd0f8b72bef83f7e8fda958962aaccbe799a","src/lib.rs":"982fadba415c4c5b93f4d7d4a73a23ec88e2d96daaa03b679d14490ea0f63197","src/literal/imp.rs":"b7f63a861c299bea4baaab17353a420ee339c2cf76d3858c95f39342bd4463e7","src/literal/mod.rs":"533f1d68af088e9485170145e27518368e541a0337fdb44f63249ebf97310300","src/pattern.rs":"993d8b6b4bcea5e02bee3c76e17c356a5a47f8fc53c5555edfd1ebb71c0878bf","src/pikevm.rs":"6c0eaa7e878c945ac4c3c545c98f5706ad04846fc432a5086c8ee78eb030dfa7","src/pool.rs":"942e991ae31ef349bd76efd78b2a712c01166dec965bf93742977ed0870d5a10","src/prog.rs":"bebb3e50745bbc05d6c8240d972ba55a1818c51b1161dc1c21f3fe13c11d4884","src/re_builder.rs":"943344bf6e2fc90902ee04b11b741c32418ac6814b21b7982cc0a3a817713f3e","src/re_bytes.rs":"63ee1db1637a3764addb10e27248129acffaf78bb0a69624add4d9d6f1e97040","src/re_set.rs":"7921ac4a919b7a5deffe82d099a9ccaf5487aebd890dfb7a661e602c6ad3f1a9","src/re_trait.rs":"d237121b6f6b606836c72305cbcb3bbdbc54d1f6827d19a19cd0fbb4372e0145","src/re_unicode.rs":"4ca66d6e835df7c0f570c8cde52667ef90ba1687d5285f12fedef2e38ae925b4","src/sparse.rs":"0da3ddb7972109869248a764dbb10254555f4bb51c375e89fb3fab9cafa47320","src/testdata/LICENSE":"58cf078acc03da3e280a938c2bd9943f554fc9b6ced89ad93ba35ca436872899","src/testdata/README":"45f869e37f798905c773bfbe0ef19a5fb7e585cbf0b7c21b5b5a784e8cec3c14","src/testdata/basic.dat":"b5b33aa89d48a61cd67cb1fbfd8f70e62c83e30b86256f9f915a5190dd38ff06","src/testdata/nullsubexpr.dat":"496ac0278eec3b6d9170faace14554569032dd3d909618364d9326156de39ecf","src/testdata/repetition.dat":"1f7959063015b284b18a4a2c1c8b416d438a2d6c4b1a362da43406b865f50e69","src/utf8.rs":"f85a356ff5d5b19e417b73ce1dd84581b21d283f6dddd195547c30af9c60bd1a","test":"0d62fdca7da12fc19ea5306b5de1d83e68d9365a029c043d524334da138b0304","tests/api.rs":"7b2a0ef75e99b9776094967bd66e9cdeaa8e11359f5f0a12bd08ef0e8d0c11fc","tests/api_str.rs":"2ae38c04e7e8fac008b609a820d0b1561ba75f39b0edc0987d6d3d06132da77f","tests/bytes.rs":"edc50f526c5fee43df89d639ef18b237e4eb91e9d533bfc43f3cbab7417d38ba","tests/consistent.rs":"d69435154c09478076497216e43081a835ac65147181a4fbddad7bff469605b2","tests/crates_regex.rs":"91a59d470e0700b4bcb3ff735d06799f3107b8ef4875a2e9904607b164be0326","tests/crazy.rs":"c0d56380dff19bdd5d7a3eb731d0e2dc564e169a1b73c81e1879b1e87f5f5f77","tests/flags.rs":"05caace2c81a99d2168037f3a38035d4dffe9f85ef3ebd7ef18b1bc6612f1ea8","tests/fowler.rs":"d78cf914de40b1e125cc92b65ccb444d462586bd07b5e05de4e4a1b5de16aa76","tests/macros.rs":"6db70c16fc90df13e6b30d2b606f8b6dd4dc976697967f6ee001b15aab6d0b19","tests/macros_bytes.rs":"a049f528a93173a1bb176cd46932dce1880679f4a1752e099be920f0e4546fd0","tests/macros_str.rs":"e585b1461374c45a2eca44ca045bc3c1fe984b2b4212e432b0c695b420e708b7","tests/misc.rs":"395f52793fa022e4cdda78675b6a6fba1a3106b4b99c834c39f7801574054bd1","tests/multiline.rs":"1b1a3326ed976437c1357f01d81833ece7ea244f38826246eab55cacd5d0862a","tests/noparse.rs":"12b6be0eff3d80779d33c6459396c74c0f6ebf4ddc9f1d33c3e747ea9e3bf268","tests/regression.rs":"1c965fefb8c7a2b1dfdab3e3fdeebaf47846555c50c8005e5537f96a52a3e252","tests/regression_fuzz.rs":"a504ec563e0d23bd2039493b7b1767fe1f831d7d668f6f4b2ecd124fc7899bcd","tests/replace.rs":"66f97532e40697934e2a77605b9002dfd22c46b6033ccb755e7660d855229f41","tests/searcher.rs":"ce35e47b0a276a7e8c9060c6a0b225ffba163aebc61fbc15555a6897fa0e552c","tests/set.rs":"f1e2af6baeeaed3cc99ed347ff516fe7b2eb0027ef64b891502e1486598eaf8a","tests/shortest_match.rs":"a2c94390c0d61bc24796b4c1288c924e90c8c9c6156fdebb858175177a194a42","tests/suffix_reverse.rs":"b95f89397404871227d9efe6df23b9ded147f183db81597e608f693955c668b5","tests/test_backtrack.rs":"b70c5e5f1241efd76dd9f9dd4a4df8a7b38113bd407d1f5f56867f1176177a59","tests/test_backtrack_bytes.rs":"b8a111d4b4109c8bba7e2afb650572c495a14d357fb1f743c1076fb001f704b5","tests/test_backtrack_utf8bytes.rs":"c0c279785d18beac2b4e178e7bf6c14ed235d65f00ca467cfd9c333d79487649","tests/test_crates_regex.rs":"fd9525c2eef0e2f8cb7f787bc2b721bcd0b5d84f3bca49adfe48d657a99c721a","tests/test_default.rs":"b32c11a43da4379a3717dd7a5f152c811257c7d6595c9d3c51f2de102e320c87","tests/test_default_bytes.rs":"831d3e6bfb882feb15f700e30304bd34328f888fb4c15c7169371e25024ce9a7","tests/test_nfa.rs":"f119fc43a018249c39c813d57096b0654ff69f337345f2bbd9b0e61cc9137285","tests/test_nfa_bytes.rs":"89eae3bef6a1d0bcea6b5de5be35ad72f613f2ceb8b58fe82a6c6ef2ccdc07d0","tests/test_nfa_utf8bytes.rs":"7d830b4aa401887d7cf098b62fed4cd8017ef8b61f625c7c9a2159a6b4cfeb71","tests/unicode.rs":"1af9db7f09a6b0113b8a64733e06c8415fef720b2fdef227ae398d94332287cd","tests/word_boundary.rs":"7081317ddcec1e82dd4a2090a571c6abf2ff4bbfa8cd10395e1eb3f386157fae","tests/word_boundary_ascii.rs":"cd0be5b5b485de0ba7994b42e2864585556c3d2d8bf5eab05b58931d9aaf4b87","tests/word_boundary_unicode.rs":"75dbcc35d3abc0f9795c2ea99e216dc227b0a5b58e9ca5eef767815ff0513921"},"package":"8b1f693b24f6ac912f4893ef08244d70b6067480d2f1a46e950c9691e6749d1d"}
\ No newline at end of file
diff --git a/crates/regex/Android.bp b/crates/regex/Android.bp
new file mode 100644
index 0000000..2948216
--- /dev/null
+++ b/crates/regex/Android.bp
@@ -0,0 +1,483 @@
+// This file is generated by cargo_embargo.
+// Do not modify this file because the changes will be overridden on upgrade.
+
+package {
+    default_applicable_licenses: ["external_rust_crates_regex_license"],
+    default_team: "trendy_team_android_rust",
+}
+
+license {
+    name: "external_rust_crates_regex_license",
+    visibility: [":__subpackages__"],
+    license_kinds: ["SPDX-license-identifier-Apache-2.0"],
+    license_text: ["LICENSE"],
+}
+
+rust_library {
+    name: "libregex",
+    host_supported: true,
+    crate_name: "regex",
+    cargo_env_compat: true,
+    cargo_pkg_version: "1.7.3",
+    crate_root: "src/lib.rs",
+    edition: "2018",
+    features: [
+        "aho-corasick",
+        "default",
+        "memchr",
+        "perf",
+        "perf-cache",
+        "perf-dfa",
+        "perf-inline",
+        "perf-literal",
+        "std",
+        "unicode",
+        "unicode-age",
+        "unicode-bool",
+        "unicode-case",
+        "unicode-gencat",
+        "unicode-perl",
+        "unicode-script",
+        "unicode-segment",
+    ],
+    rustlibs: [
+        "libaho_corasick",
+        "libmemchr",
+        "libregex_syntax",
+    ],
+    apex_available: [
+        "//apex_available:anyapex",
+        "//apex_available:platform",
+    ],
+    product_available: true,
+    vendor_available: true,
+}
+
+rust_test {
+    name: "regex_test_src_lib",
+    host_supported: true,
+    crate_name: "regex",
+    cargo_env_compat: true,
+    cargo_pkg_version: "1.7.3",
+    crate_root: "src/lib.rs",
+    test_suites: ["general-tests"],
+    auto_gen_config: true,
+    test_options: {
+        unit_test: true,
+    },
+    edition: "2018",
+    features: [
+        "aho-corasick",
+        "default",
+        "memchr",
+        "perf",
+        "perf-cache",
+        "perf-dfa",
+        "perf-inline",
+        "perf-literal",
+        "std",
+        "unicode",
+        "unicode-age",
+        "unicode-bool",
+        "unicode-case",
+        "unicode-gencat",
+        "unicode-perl",
+        "unicode-script",
+        "unicode-segment",
+    ],
+    rustlibs: [
+        "libaho_corasick",
+        "liblazy_static",
+        "libmemchr",
+        "libquickcheck",
+        "librand",
+        "libregex_syntax",
+    ],
+}
+
+rust_test {
+    name: "regex_test_tests_test_backtrack",
+    host_supported: true,
+    crate_name: "backtrack",
+    cargo_env_compat: true,
+    cargo_pkg_version: "1.7.3",
+    crate_root: "tests/test_backtrack.rs",
+    test_suites: ["general-tests"],
+    auto_gen_config: true,
+    test_options: {
+        unit_test: true,
+    },
+    edition: "2018",
+    features: [
+        "aho-corasick",
+        "default",
+        "memchr",
+        "perf",
+        "perf-cache",
+        "perf-dfa",
+        "perf-inline",
+        "perf-literal",
+        "std",
+        "unicode",
+        "unicode-age",
+        "unicode-bool",
+        "unicode-case",
+        "unicode-gencat",
+        "unicode-perl",
+        "unicode-script",
+        "unicode-segment",
+    ],
+    rustlibs: [
+        "libaho_corasick",
+        "liblazy_static",
+        "libmemchr",
+        "libquickcheck",
+        "librand",
+        "libregex",
+        "libregex_syntax",
+    ],
+}
+
+rust_test {
+    name: "regex_test_tests_test_backtrack_bytes",
+    host_supported: true,
+    crate_name: "backtrack_bytes",
+    cargo_env_compat: true,
+    cargo_pkg_version: "1.7.3",
+    crate_root: "tests/test_backtrack_bytes.rs",
+    test_suites: ["general-tests"],
+    auto_gen_config: true,
+    test_options: {
+        unit_test: true,
+    },
+    edition: "2018",
+    features: [
+        "aho-corasick",
+        "default",
+        "memchr",
+        "perf",
+        "perf-cache",
+        "perf-dfa",
+        "perf-inline",
+        "perf-literal",
+        "std",
+        "unicode",
+        "unicode-age",
+        "unicode-bool",
+        "unicode-case",
+        "unicode-gencat",
+        "unicode-perl",
+        "unicode-script",
+        "unicode-segment",
+    ],
+    rustlibs: [
+        "libaho_corasick",
+        "liblazy_static",
+        "libmemchr",
+        "libquickcheck",
+        "librand",
+        "libregex",
+        "libregex_syntax",
+    ],
+}
+
+rust_test {
+    name: "regex_test_tests_test_backtrack_utf8bytes",
+    host_supported: true,
+    crate_name: "backtrack_utf8bytes",
+    cargo_env_compat: true,
+    cargo_pkg_version: "1.7.3",
+    crate_root: "tests/test_backtrack_utf8bytes.rs",
+    test_suites: ["general-tests"],
+    auto_gen_config: true,
+    test_options: {
+        unit_test: true,
+    },
+    edition: "2018",
+    features: [
+        "aho-corasick",
+        "default",
+        "memchr",
+        "perf",
+        "perf-cache",
+        "perf-dfa",
+        "perf-inline",
+        "perf-literal",
+        "std",
+        "unicode",
+        "unicode-age",
+        "unicode-bool",
+        "unicode-case",
+        "unicode-gencat",
+        "unicode-perl",
+        "unicode-script",
+        "unicode-segment",
+    ],
+    rustlibs: [
+        "libaho_corasick",
+        "liblazy_static",
+        "libmemchr",
+        "libquickcheck",
+        "librand",
+        "libregex",
+        "libregex_syntax",
+    ],
+}
+
+rust_test {
+    name: "regex_test_tests_test_crates_regex",
+    host_supported: true,
+    crate_name: "crates_regex",
+    cargo_env_compat: true,
+    cargo_pkg_version: "1.7.3",
+    crate_root: "tests/test_crates_regex.rs",
+    test_suites: ["general-tests"],
+    auto_gen_config: true,
+    test_options: {
+        unit_test: true,
+    },
+    edition: "2018",
+    features: [
+        "aho-corasick",
+        "default",
+        "memchr",
+        "perf",
+        "perf-cache",
+        "perf-dfa",
+        "perf-inline",
+        "perf-literal",
+        "std",
+        "unicode",
+        "unicode-age",
+        "unicode-bool",
+        "unicode-case",
+        "unicode-gencat",
+        "unicode-perl",
+        "unicode-script",
+        "unicode-segment",
+    ],
+    rustlibs: [
+        "libaho_corasick",
+        "liblazy_static",
+        "libmemchr",
+        "libquickcheck",
+        "librand",
+        "libregex",
+        "libregex_syntax",
+    ],
+}
+
+rust_test {
+    name: "regex_test_tests_test_default",
+    host_supported: true,
+    crate_name: "default",
+    cargo_env_compat: true,
+    cargo_pkg_version: "1.7.3",
+    crate_root: "tests/test_default.rs",
+    test_suites: ["general-tests"],
+    auto_gen_config: true,
+    test_options: {
+        unit_test: true,
+    },
+    edition: "2018",
+    features: [
+        "aho-corasick",
+        "default",
+        "memchr",
+        "perf",
+        "perf-cache",
+        "perf-dfa",
+        "perf-inline",
+        "perf-literal",
+        "std",
+        "unicode",
+        "unicode-age",
+        "unicode-bool",
+        "unicode-case",
+        "unicode-gencat",
+        "unicode-perl",
+        "unicode-script",
+        "unicode-segment",
+    ],
+    rustlibs: [
+        "libaho_corasick",
+        "liblazy_static",
+        "libmemchr",
+        "libquickcheck",
+        "librand",
+        "libregex",
+        "libregex_syntax",
+    ],
+}
+
+rust_test {
+    name: "regex_test_tests_test_default_bytes",
+    host_supported: true,
+    crate_name: "default_bytes",
+    cargo_env_compat: true,
+    cargo_pkg_version: "1.7.3",
+    crate_root: "tests/test_default_bytes.rs",
+    test_suites: ["general-tests"],
+    auto_gen_config: true,
+    test_options: {
+        unit_test: true,
+    },
+    edition: "2018",
+    features: [
+        "aho-corasick",
+        "default",
+        "memchr",
+        "perf",
+        "perf-cache",
+        "perf-dfa",
+        "perf-inline",
+        "perf-literal",
+        "std",
+        "unicode",
+        "unicode-age",
+        "unicode-bool",
+        "unicode-case",
+        "unicode-gencat",
+        "unicode-perl",
+        "unicode-script",
+        "unicode-segment",
+    ],
+    rustlibs: [
+        "libaho_corasick",
+        "liblazy_static",
+        "libmemchr",
+        "libquickcheck",
+        "librand",
+        "libregex",
+        "libregex_syntax",
+    ],
+}
+
+rust_test {
+    name: "regex_test_tests_test_nfa",
+    host_supported: true,
+    crate_name: "nfa",
+    cargo_env_compat: true,
+    cargo_pkg_version: "1.7.3",
+    crate_root: "tests/test_nfa.rs",
+    test_suites: ["general-tests"],
+    auto_gen_config: true,
+    test_options: {
+        unit_test: true,
+    },
+    edition: "2018",
+    features: [
+        "aho-corasick",
+        "default",
+        "memchr",
+        "perf",
+        "perf-cache",
+        "perf-dfa",
+        "perf-inline",
+        "perf-literal",
+        "std",
+        "unicode",
+        "unicode-age",
+        "unicode-bool",
+        "unicode-case",
+        "unicode-gencat",
+        "unicode-perl",
+        "unicode-script",
+        "unicode-segment",
+    ],
+    rustlibs: [
+        "libaho_corasick",
+        "liblazy_static",
+        "libmemchr",
+        "libquickcheck",
+        "librand",
+        "libregex",
+        "libregex_syntax",
+    ],
+}
+
+rust_test {
+    name: "regex_test_tests_test_nfa_bytes",
+    host_supported: true,
+    crate_name: "nfa_bytes",
+    cargo_env_compat: true,
+    cargo_pkg_version: "1.7.3",
+    crate_root: "tests/test_nfa_bytes.rs",
+    test_suites: ["general-tests"],
+    auto_gen_config: true,
+    test_options: {
+        unit_test: true,
+    },
+    edition: "2018",
+    features: [
+        "aho-corasick",
+        "default",
+        "memchr",
+        "perf",
+        "perf-cache",
+        "perf-dfa",
+        "perf-inline",
+        "perf-literal",
+        "std",
+        "unicode",
+        "unicode-age",
+        "unicode-bool",
+        "unicode-case",
+        "unicode-gencat",
+        "unicode-perl",
+        "unicode-script",
+        "unicode-segment",
+    ],
+    rustlibs: [
+        "libaho_corasick",
+        "liblazy_static",
+        "libmemchr",
+        "libquickcheck",
+        "librand",
+        "libregex",
+        "libregex_syntax",
+    ],
+}
+
+rust_test {
+    name: "regex_test_tests_test_nfa_utf8bytes",
+    host_supported: true,
+    crate_name: "nfa_utf8bytes",
+    cargo_env_compat: true,
+    cargo_pkg_version: "1.7.3",
+    crate_root: "tests/test_nfa_utf8bytes.rs",
+    test_suites: ["general-tests"],
+    auto_gen_config: true,
+    test_options: {
+        unit_test: true,
+    },
+    edition: "2018",
+    features: [
+        "aho-corasick",
+        "default",
+        "memchr",
+        "perf",
+        "perf-cache",
+        "perf-dfa",
+        "perf-inline",
+        "perf-literal",
+        "std",
+        "unicode",
+        "unicode-age",
+        "unicode-bool",
+        "unicode-case",
+        "unicode-gencat",
+        "unicode-perl",
+        "unicode-script",
+        "unicode-segment",
+    ],
+    rustlibs: [
+        "libaho_corasick",
+        "liblazy_static",
+        "libmemchr",
+        "libquickcheck",
+        "librand",
+        "libregex",
+        "libregex_syntax",
+    ],
+}
diff --git a/crates/regex/CHANGELOG.md b/crates/regex/CHANGELOG.md
new file mode 100644
index 0000000..44274ac
--- /dev/null
+++ b/crates/regex/CHANGELOG.md
@@ -0,0 +1,1116 @@
+1.7.3 (2023-03-24)
+==================
+This is a small release that fixes a bug in `Regex::shortest_match_at` that
+could cause it to panic, even when the offset given is valid.
+
+Bug fixes:
+
+* [BUG #969](https://github.com/rust-lang/regex/issues/969):
+  Fix a bug in how the reverse DFA was called for `Regex::shortest_match_at`.
+
+
+1.7.2 (2023-03-21)
+==================
+This is a small release that fixes a failing test on FreeBSD.
+
+Bug fixes:
+
+* [BUG #967](https://github.com/rust-lang/regex/issues/967):
+  Fix "no stack overflow" test which can fail due to the small stack size.
+
+
+1.7.1 (2023-01-09)
+==================
+This release was done principally to try and fix the doc.rs rendering for the
+regex crate.
+
+Performance improvements:
+
+* [PERF #930](https://github.com/rust-lang/regex/pull/930):
+  Optimize `replacen`. This also applies to `replace`, but not `replace_all`.
+
+Bug fixes:
+
+* [BUG #945](https://github.com/rust-lang/regex/issues/945):
+  Maybe fix rustdoc rendering by just bumping a new release?
+
+
+1.7.0 (2022-11-05)
+==================
+This release principally includes an upgrade to Unicode 15.
+
+New features:
+
+* [FEATURE #832](https://github.com/rust-lang/regex/issues/916):
+  Upgrade to Unicode 15.
+
+
+1.6.0 (2022-07-05)
+==================
+This release principally includes an upgrade to Unicode 14.
+
+New features:
+
+* [FEATURE #832](https://github.com/rust-lang/regex/pull/832):
+  Clarify that `Captures::len` includes all groups, not just matching groups.
+* [FEATURE #857](https://github.com/rust-lang/regex/pull/857):
+  Add an `ExactSizeIterator` impl for `SubCaptureMatches`.
+* [FEATURE #861](https://github.com/rust-lang/regex/pull/861):
+  Improve `RegexSet` documentation examples.
+* [FEATURE #877](https://github.com/rust-lang/regex/issues/877):
+  Upgrade to Unicode 14.
+
+Bug fixes:
+
+* [BUG #792](https://github.com/rust-lang/regex/issues/792):
+  Fix error message rendering bug.
+
+
+1.5.6 (2022-05-20)
+==================
+This release includes a few bug fixes, including a bug that produced incorrect
+matches when a non-greedy `?` operator was used.
+
+* [BUG #680](https://github.com/rust-lang/regex/issues/680):
+  Fixes a bug where `[[:alnum:][:^ascii:]]` dropped `[:alnum:]` from the class.
+* [BUG #859](https://github.com/rust-lang/regex/issues/859):
+  Fixes a bug where `Hir::is_match_empty` returned `false` for `\b`.
+* [BUG #862](https://github.com/rust-lang/regex/issues/862):
+  Fixes a bug where 'ab??' matches 'ab' instead of 'a' in 'ab'.
+
+
+1.5.5 (2022-03-08)
+==================
+This releases fixes a security bug in the regex compiler. This bug permits a
+vector for a denial-of-service attack in cases where the regex being compiled
+is untrusted. There are no known problems where the regex is itself trusted,
+including in cases of untrusted haystacks.
+
+* [SECURITY #GHSA-m5pq-gvj9-9vr8](https://github.com/rust-lang/regex/security/advisories/GHSA-m5pq-gvj9-9vr8):
+  Fixes a bug in the regex compiler where empty sub-expressions subverted the
+  existing mitigations in place to enforce a size limit on compiled regexes.
+  The Rust Security Response WG published an advisory about this:
+  https://groups.google.com/g/rustlang-security-announcements/c/NcNNL1Jq7Yw
+
+
+1.5.4 (2021-05-06)
+==================
+This release fixes another compilation failure when building regex. This time,
+the fix is for when the `pattern` feature is enabled, which only works on
+nightly Rust. CI has been updated to test this case.
+
+* [BUG #772](https://github.com/rust-lang/regex/pull/772):
+  Fix build when `pattern` feature is enabled.
+
+
+1.5.3 (2021-05-01)
+==================
+This releases fixes a bug when building regex with only the `unicode-perl`
+feature. It turns out that while CI was building this configuration, it wasn't
+actually failing the overall build on a failed compilation.
+
+* [BUG #769](https://github.com/rust-lang/regex/issues/769):
+  Fix build in `regex-syntax` when only the `unicode-perl` feature is enabled.
+
+
+1.5.2 (2021-05-01)
+==================
+This release fixes a performance bug when Unicode word boundaries are used.
+Namely, for certain regexes on certain inputs, it's possible for the lazy DFA
+to stop searching (causing a fallback to a slower engine) when it doesn't
+actually need to.
+
+[PR #768](https://github.com/rust-lang/regex/pull/768) fixes the bug, which was
+originally reported in
+[ripgrep#1860](https://github.com/BurntSushi/ripgrep/issues/1860).
+
+
+1.5.1 (2021-04-30)
+==================
+This is a patch release that fixes a compilation error when the `perf-literal`
+feature is not enabled.
+
+
+1.5.0 (2021-04-30)
+==================
+This release primarily updates to Rust 2018 (finally) and bumps the MSRV to
+Rust 1.41 (from Rust 1.28). Rust 1.41 was chosen because it's still reasonably
+old, and is what's in Debian stable at the time of writing.
+
+This release also drops this crate's own bespoke substring search algorithms
+in favor of a new
+[`memmem` implementation provided by the `memchr` crate](https://docs.rs/memchr/2.4.0/memchr/memmem/index.html).
+This will change the performance profile of some regexes, sometimes getting a
+little worse, and hopefully more frequently, getting a lot better. Please
+report any serious performance regressions if you find them.
+
+
+1.4.6 (2021-04-22)
+==================
+This is a small patch release that fixes the compiler's size check on how much
+heap memory a regex uses. Previously, the compiler did not account for the
+heap usage of Unicode character classes. Now it does. It's possible that this
+may make some regexes fail to compile that previously did compile. If that
+happens, please file an issue.
+
+* [BUG OSS-fuzz#33579](https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=33579):
+  Some regexes can use more heap memory than one would expect.
+
+
+1.4.5 (2021-03-14)
+==================
+This is a small patch release that fixes a regression in the size of a `Regex`
+in the 1.4.4 release. Prior to 1.4.4, a `Regex` was 552 bytes. In the 1.4.4
+release, it was 856 bytes due to internal changes. In this release, a `Regex`
+is now 16 bytes. In general, the size of a `Regex` was never something that was
+on my radar, but this increased size in the 1.4.4 release seems to have crossed
+a threshold and resulted in stack overflows in some programs.
+
+* [BUG #750](https://github.com/rust-lang/regex/pull/750):
+  Fixes stack overflows seemingly caused by a large `Regex` size by decreasing
+  its size.
+
+
+1.4.4 (2021-03-11)
+==================
+This is a small patch release that contains some bug fixes. Notably, it also
+drops the `thread_local` (and `lazy_static`, via transitivity) dependencies.
+
+Bug fixes:
+
+* [BUG #362](https://github.com/rust-lang/regex/pull/362):
+  Memory leaks caused by an internal caching strategy should now be fixed.
+* [BUG #576](https://github.com/rust-lang/regex/pull/576):
+  All regex types now implement `UnwindSafe` and `RefUnwindSafe`.
+* [BUG #728](https://github.com/rust-lang/regex/pull/749):
+  Add missing `Replacer` impls for `Vec<u8>`, `String`, `Cow`, etc.
+
+
+1.4.3 (2021-01-08)
+==================
+This is a small patch release that adds some missing standard trait
+implementations for some types in the public API.
+
+Bug fixes:
+
+* [BUG #734](https://github.com/rust-lang/regex/pull/734):
+  Add `FusedIterator` and `ExactSizeIterator` impls to iterator types.
+* [BUG #735](https://github.com/rust-lang/regex/pull/735):
+  Add missing `Debug` impls to public API types.
+
+
+1.4.2 (2020-11-01)
+==================
+This is a small bug fix release that bans `\P{any}`. We previously banned empty
+classes like `[^\w\W]`, but missed the `\P{any}` case. In the future, we hope
+to permit empty classes.
+
+* [BUG #722](https://github.com/rust-lang/regex/issues/722):
+  Ban `\P{any}` to avoid a panic in the regex compiler. Found by OSS-Fuzz.
+
+
+1.4.1 (2020-10-13)
+==================
+This is a small bug fix release that makes `\p{cf}` work. Previously, it would
+report "property not found" even though `cf` is a valid abbreviation for the
+`Format` general category.
+
+* [BUG #719](https://github.com/rust-lang/regex/issues/719):
+  Fixes bug that prevented `\p{cf}` from working.
+
+
+1.4.0 (2020-10-11)
+==================
+This releases has a few minor documentation fixes as well as some very minor
+API additions. The MSRV remains at Rust 1.28 for now, but this is intended to
+increase to at least Rust 1.41.1 soon.
+
+This release also adds support for OSS-Fuzz. Kudos to
+[@DavidKorczynski](https://github.com/DavidKorczynski)
+for doing the heavy lifting for that!
+
+New features:
+
+* [FEATURE #649](https://github.com/rust-lang/regex/issues/649):
+  Support `[`, `]` and `.` in capture group names.
+* [FEATURE #687](https://github.com/rust-lang/regex/issues/687):
+  Add `is_empty` predicate to `RegexSet`.
+* [FEATURE #689](https://github.com/rust-lang/regex/issues/689):
+  Implement `Clone` for `SubCaptureMatches`.
+* [FEATURE #715](https://github.com/rust-lang/regex/issues/715):
+  Add `empty` constructor to `RegexSet` for convenience.
+
+Bug fixes:
+
+* [BUG #694](https://github.com/rust-lang/regex/issues/694):
+  Fix doc example for `Replacer::replace_append`.
+* [BUG #698](https://github.com/rust-lang/regex/issues/698):
+  Clarify docs for `s` flag when using a `bytes::Regex`.
+* [BUG #711](https://github.com/rust-lang/regex/issues/711):
+  Clarify `is_match` docs to indicate that it can match anywhere in string.
+
+
+1.3.9 (2020-05-28)
+==================
+This release fixes a MSRV (Minimum Support Rust Version) regression in the
+1.3.8 release. Namely, while 1.3.8 compiles on Rust 1.28, it actually does not
+compile on other Rust versions, such as Rust 1.39.
+
+Bug fixes:
+
+* [BUG #685](https://github.com/rust-lang/regex/issues/685):
+  Remove use of `doc_comment` crate, which cannot be used before Rust 1.43.
+
+
+1.3.8 (2020-05-28)
+==================
+This release contains a couple of important bug fixes driven
+by better support for empty-subexpressions in regexes. For
+example, regexes like `b|` are now allowed. Major thanks to
+[@sliquister](https://github.com/sliquister) for implementing support for this
+in [#677](https://github.com/rust-lang/regex/pull/677).
+
+Bug fixes:
+
+* [BUG #523](https://github.com/rust-lang/regex/pull/523):
+  Add note to documentation that spaces can be escaped in `x` mode.
+* [BUG #524](https://github.com/rust-lang/regex/issues/524):
+  Add support for empty sub-expressions, including empty alternations.
+* [BUG #659](https://github.com/rust-lang/regex/issues/659):
+  Fix match bug caused by an empty sub-expression miscompilation.
+
+
+1.3.7 (2020-04-17)
+==================
+This release contains a small bug fix that fixes how `regex` forwards crate
+features to `regex-syntax`. In particular, this will reduce recompilations in
+some cases.
+
+Bug fixes:
+
+* [BUG #665](https://github.com/rust-lang/regex/pull/665):
+  Fix feature forwarding to `regex-syntax`.
+
+
+1.3.6 (2020-03-24)
+==================
+This release contains a sizable (~30%) performance improvement when compiling
+some kinds of large regular expressions.
+
+Performance improvements:
+
+* [PERF #657](https://github.com/rust-lang/regex/pull/657):
+  Improvement performance of compiling large regular expressions.
+
+
+1.3.5 (2020-03-12)
+==================
+This release updates this crate to Unicode 13.
+
+New features:
+
+* [FEATURE #653](https://github.com/rust-lang/regex/pull/653):
+  Update `regex-syntax` to Unicode 13.
+
+
+1.3.4 (2020-01-30)
+==================
+This is a small bug fix release that fixes a bug related to the scoping of
+flags in a regex. Namely, before this fix, a regex like `((?i)a)b)` would
+match `aB` despite the fact that `b` should not be matched case insensitively.
+
+Bug fixes:
+
+* [BUG #640](https://github.com/rust-lang/regex/issues/640):
+  Fix bug related to the scoping of flags in a regex.
+
+
+1.3.3 (2020-01-09)
+==================
+This is a small maintenance release that upgrades the dependency on
+`thread_local` from `0.3` to `1.0`. The minimum supported Rust version remains
+at Rust 1.28.
+
+
+1.3.2 (2020-01-09)
+==================
+This is a small maintenance release with some house cleaning and bug fixes.
+
+New features:
+
+* [FEATURE #631](https://github.com/rust-lang/regex/issues/631):
+  Add a `Match::range` method an a `From<Match> for Range` impl.
+
+Bug fixes:
+
+* [BUG #521](https://github.com/rust-lang/regex/issues/521):
+  Corrects `/-/.splitn("a", 2)` to return `["a"]` instead of `["a", ""]`.
+* [BUG #594](https://github.com/rust-lang/regex/pull/594):
+  Improve error reporting when writing `\p\`.
+* [BUG #627](https://github.com/rust-lang/regex/issues/627):
+  Corrects `/-/.split("a-")` to return `["a", ""]` instead of `["a"]`.
+* [BUG #633](https://github.com/rust-lang/regex/pull/633):
+  Squash deprecation warnings for the `std::error::Error::description` method.
+
+
+1.3.1 (2019-09-04)
+==================
+This is a maintenance release with no changes in order to try to work-around
+a [docs.rs/Cargo issue](https://github.com/rust-lang/docs.rs/issues/400).
+
+
+1.3.0 (2019-09-03)
+==================
+This release adds a plethora of new crate features that permit users of regex
+to shrink its size considerably, in exchange for giving up either functionality
+(such as Unicode support) or runtime performance. When all such features are
+disabled, the dependency tree for `regex` shrinks to exactly 1 crate
+(`regex-syntax`). More information about the new crate features can be
+[found in the docs](https://docs.rs/regex/*/#crate-features).
+
+Note that while this is a new minor version release, the minimum supported
+Rust version for this crate remains at `1.28.0`.
+
+New features:
+
+* [FEATURE #474](https://github.com/rust-lang/regex/issues/474):
+  The `use_std` feature has been deprecated in favor of the `std` feature.
+  The `use_std` feature will be removed in regex 2. Until then, `use_std` will
+  remain as an alias for the `std` feature.
+* [FEATURE #583](https://github.com/rust-lang/regex/issues/583):
+  Add a substantial number of crate features shrinking `regex`.
+
+
+1.2.1 (2019-08-03)
+==================
+This release does a bit of house cleaning. Namely:
+
+* This repository is now using rustfmt.
+* License headers have been removed from all files, in following suit with the
+  Rust project.
+* Teddy has been removed from the `regex` crate, and is now part of the
+  `aho-corasick` crate.
+  [See `aho-corasick`'s new `packed` sub-module for details](https://docs.rs/aho-corasick/0.7.6/aho_corasick/packed/index.html).
+* The `utf8-ranges` crate has been deprecated, with its functionality moving
+  into the
+  [`utf8` sub-module of `regex-syntax`](https://docs.rs/regex-syntax/0.6.11/regex_syntax/utf8/index.html).
+* The `ucd-util` dependency has been dropped, in favor of implementing what
+  little we need inside of `regex-syntax` itself.
+
+In general, this is part of an ongoing (long term) effort to make optimizations
+in the regex engine easier to reason about. The current code is too convoluted
+and thus it is very easy to introduce new bugs. This simplification effort is
+the primary motivation behind re-working the `aho-corasick` crate to not only
+bundle algorithms like Teddy, but to also provide regex-like match semantics
+automatically.
+
+Moving forward, the plan is to join up with the `bstr` and `regex-automata`
+crates, with the former providing more sophisticated substring search
+algorithms (thereby deleting existing code in `regex`) and the latter providing
+ahead-of-time compiled DFAs for cases where they are inexpensive to compute.
+
+
+1.2.0 (2019-07-20)
+==================
+This release updates regex's minimum supported Rust version to 1.28, which was
+release almost 1 year ago. This release also updates regex's Unicode data
+tables to 12.1.0.
+
+
+1.1.9 (2019-07-06)
+==================
+This release contains a bug fix that caused regex's tests to fail, due to a
+dependency on an unreleased behavior in regex-syntax.
+
+* [BUG #593](https://github.com/rust-lang/regex/issues/593):
+  Move an integration-style test on error messages into regex-syntax.
+
+
+1.1.8 (2019-07-04)
+==================
+This release contains a few small internal refactorings. One of which fixes
+an instance of undefined behavior in a part of the SIMD code.
+
+Bug fixes:
+
+* [BUG #545](https://github.com/rust-lang/regex/issues/545):
+  Improves error messages when a repetition operator is used without a number.
+* [BUG #588](https://github.com/rust-lang/regex/issues/588):
+  Removes use of a repr(Rust) union used for type punning in the Teddy matcher.
+* [BUG #591](https://github.com/rust-lang/regex/issues/591):
+  Update docs for running benchmarks and improve failure modes.
+
+
+1.1.7 (2019-06-09)
+==================
+This release fixes up a few warnings as a result of recent deprecations.
+
+
+1.1.6 (2019-04-16)
+==================
+This release fixes a regression introduced by a bug fix (for
+[BUG #557](https://github.com/rust-lang/regex/issues/557)) which could cause
+the regex engine to enter an infinite loop. This bug was originally
+[reported against ripgrep](https://github.com/BurntSushi/ripgrep/issues/1247).
+
+
+1.1.5 (2019-04-01)
+==================
+This release fixes a bug in regex's dependency specification where it requires
+a newer version of regex-syntax, but this wasn't communicated correctly in the
+Cargo.toml. This would have been caught by a minimal version check, but this
+check was disabled because the `rand` crate itself advertises incorrect
+dependency specifications.
+
+Bug fixes:
+
+* [BUG #570](https://github.com/rust-lang/regex/pull/570):
+  Fix regex-syntax minimal version.
+
+
+1.1.4 (2019-03-31)
+==================
+This release fixes a backwards compatibility regression where Regex was no
+longer UnwindSafe. This was caused by the upgrade to aho-corasick 0.7, whose
+AhoCorasick type was itself not UnwindSafe. This has been fixed in aho-corasick
+0.7.4, which we now require.
+
+Bug fixes:
+
+* [BUG #568](https://github.com/rust-lang/regex/pull/568):
+  Fix an API regression where Regex was no longer UnwindSafe.
+
+
+1.1.3 (2019-03-30)
+==================
+This releases fixes a few bugs and adds a performance improvement when a regex
+is a simple alternation of literals.
+
+Performance improvements:
+
+* [OPT #566](https://github.com/rust-lang/regex/pull/566):
+  Upgrades `aho-corasick` to 0.7 and uses it for `foo|bar|...|quux` regexes.
+
+Bug fixes:
+
+* [BUG #527](https://github.com/rust-lang/regex/issues/527):
+  Fix a bug where the parser would panic on patterns like `((?x))`.
+* [BUG #555](https://github.com/rust-lang/regex/issues/555):
+  Fix a bug where the parser would panic on patterns like `(?m){1,1}`.
+* [BUG #557](https://github.com/rust-lang/regex/issues/557):
+  Fix a bug where captures could lead to an incorrect match.
+
+
+1.1.2 (2019-02-27)
+==================
+This release fixes a bug found in the fix introduced in 1.1.1.
+
+Bug fixes:
+
+* [BUG edf45e6f](https://github.com/rust-lang/regex/commit/edf45e6f):
+  Fix bug introduced in reverse suffix literal matcher in the 1.1.1 release.
+
+
+1.1.1 (2019-02-27)
+==================
+This is a small release with one fix for a bug caused by literal optimizations.
+
+Bug fixes:
+
+* [BUG 661bf53d](https://github.com/rust-lang/regex/commit/661bf53d):
+  Fixes a bug in the reverse suffix literal optimization. This was originally
+  reported
+  [against ripgrep](https://github.com/BurntSushi/ripgrep/issues/1203).
+
+
+1.1.0 (2018-11-30)
+==================
+This is a small release with a couple small enhancements. This release also
+increases the minimal supported Rust version (MSRV) to 1.24.1 (from 1.20.0). In
+accordance with this crate's MSRV policy, this release bumps the minor version
+number.
+
+Performance improvements:
+
+* [OPT #511](https://github.com/rust-lang/regex/pull/511),
+  [OPT #540](https://github.com/rust-lang/regex/pull/540):
+  Improve lazy DFA construction for large regex sets.
+
+New features:
+
+* [FEATURE #538](https://github.com/rust-lang/regex/pull/538):
+  Add Emoji and "break" Unicode properties. See [UNICODE.md](UNICODE.md).
+
+Bug fixes:
+
+* [BUG #530](https://github.com/rust-lang/regex/pull/530):
+  Add Unicode license (for data tables).
+* Various typo/doc fixups.
+
+
+1.0.6 (2018-11-06)
+==================
+This is a small release.
+
+Performance improvements:
+
+* [OPT #513](https://github.com/rust-lang/regex/pull/513):
+  Improve performance of compiling large Unicode classes by 8-10%.
+
+Bug fixes:
+
+* [BUG #533](https://github.com/rust-lang/regex/issues/533):
+  Fix definition of `[[:blank:]]` class that regressed in `regex-syntax 0.5`.
+
+
+1.0.5 (2018-09-06)
+==================
+This is a small release with an API enhancement.
+
+New features:
+
+* [FEATURE #509](https://github.com/rust-lang/regex/pull/509):
+  Generalize impls of the `Replacer` trait.
+
+
+1.0.4 (2018-08-25)
+==================
+This is a small release that bumps the quickcheck dependency.
+
+
+1.0.3 (2018-08-24)
+==================
+This is a small bug fix release.
+
+Bug fixes:
+
+* [BUG #504](https://github.com/rust-lang/regex/pull/504):
+  Fix for Cargo's "minimal version" support.
+* [BUG 1e39165f](https://github.com/rust-lang/regex/commit/1e39165f):
+  Fix doc examples for byte regexes.
+
+
+1.0.2 (2018-07-18)
+==================
+This release exposes some new lower level APIs on `Regex` that permit
+amortizing allocation and controlling the location at which a search is
+performed in a more granular way. Most users of the regex crate will not
+need or want to use these APIs.
+
+New features:
+
+* [FEATURE #493](https://github.com/rust-lang/regex/pull/493):
+  Add a few lower level APIs for amortizing allocation and more fine grained
+  searching.
+
+Bug fixes:
+
+* [BUG 3981d2ad](https://github.com/rust-lang/regex/commit/3981d2ad):
+  Correct outdated documentation on `RegexBuilder::dot_matches_new_line`.
+* [BUG 7ebe4ae0](https://github.com/rust-lang/regex/commit/7ebe4ae0):
+  Correct outdated documentation on `Parser::allow_invalid_utf8` in the
+  `regex-syntax` crate.
+* [BUG 24c7770b](https://github.com/rust-lang/regex/commit/24c7770b):
+  Fix a bug in the HIR printer where it wouldn't correctly escape meta
+  characters in character classes.
+
+
+1.0.1 (2018-06-19)
+==================
+This release upgrades regex's Unicode tables to Unicode 11, and enables SIMD
+optimizations automatically on Rust stable (1.27 or newer).
+
+New features:
+
+* [FEATURE #486](https://github.com/rust-lang/regex/pull/486):
+  Implement `size_hint` on `RegexSet` match iterators.
+* [FEATURE #488](https://github.com/rust-lang/regex/pull/488):
+  Update Unicode tables for Unicode 11.
+* [FEATURE #490](https://github.com/rust-lang/regex/pull/490):
+  SIMD optimizations are now enabled automatically in Rust stable, for versions
+  1.27 and up. No compilation flags or features need to be set. CPU support
+  SIMD is detected automatically at runtime.
+
+Bug fixes:
+
+* [BUG #482](https://github.com/rust-lang/regex/pull/482):
+  Present a better compilation error when the `use_std` feature isn't used.
+
+
+1.0.0 (2018-05-01)
+==================
+This release marks the 1.0 release of regex.
+
+While this release includes some breaking changes, most users of older versions
+of the regex library should be able to migrate to 1.0 by simply bumping the
+version number. The important changes are as follows:
+
+* We adopt Rust 1.20 as the new minimum supported version of Rust for regex.
+  We also tentativley adopt a policy that permits bumping the minimum supported
+  version of Rust in minor version releases of regex, but no patch releases.
+  That is, with respect to semver, we do not strictly consider bumping the
+  minimum version of Rust to be a breaking change, but adopt a conservative
+  stance as a compromise.
+* Octal syntax in regular expressions has been disabled by default. This
+  permits better error messages that inform users that backreferences aren't
+  available. Octal syntax can be re-enabled via the corresponding option on
+  `RegexBuilder`.
+* `(?-u:\B)` is no longer allowed in Unicode regexes since it can match at
+  invalid UTF-8 code unit boundaries. `(?-u:\b)` is still allowed in Unicode
+  regexes.
+* The `From<regex_syntax::Error>` impl has been removed. This formally removes
+  the public dependency on `regex-syntax`.
+* A new feature, `use_std`, has been added and enabled by default. Disabling
+  the feature will result in a compilation error. In the future, this may
+  permit us to support `no_std` environments (w/ `alloc`) in a backwards
+  compatible way.
+
+For more information and discussion, please see
+[1.0 release tracking issue](https://github.com/rust-lang/regex/issues/457).
+
+
+0.2.11 (2018-05-01)
+===================
+This release primarily contains bug fixes. Some of them resolve bugs where
+the parser could panic.
+
+New features:
+
+* [FEATURE #459](https://github.com/rust-lang/regex/pull/459):
+  Include C++'s standard regex library and Boost's regex library in the
+  benchmark harness. We now include D/libphobos, C++/std, C++/boost, Oniguruma,
+  PCRE1, PCRE2, RE2 and Tcl in the harness.
+
+Bug fixes:
+
+* [BUG #445](https://github.com/rust-lang/regex/issues/445):
+  Clarify order of indices returned by RegexSet match iterator.
+* [BUG #461](https://github.com/rust-lang/regex/issues/461):
+  Improve error messages for invalid regexes like `[\d-a]`.
+* [BUG #464](https://github.com/rust-lang/regex/issues/464):
+  Fix a bug in the error message pretty printer that could cause a panic when
+  a regex contained a literal `\n` character.
+* [BUG #465](https://github.com/rust-lang/regex/issues/465):
+  Fix a panic in the parser that was caused by applying a repetition operator
+  to `(?flags)`.
+* [BUG #466](https://github.com/rust-lang/regex/issues/466):
+  Fix a bug where `\pC` was not recognized as an alias for `\p{Other}`.
+* [BUG #470](https://github.com/rust-lang/regex/pull/470):
+  Fix a bug where literal searches did more work than necessary for anchored
+  regexes.
+
+
+0.2.10 (2018-03-16)
+===================
+This release primarily updates the regex crate to changes made in `std::arch`
+on nightly Rust.
+
+New features:
+
+* [FEATURE #458](https://github.com/rust-lang/regex/pull/458):
+  The `Hir` type in `regex-syntax` now has a printer.
+
+
+0.2.9 (2018-03-12)
+==================
+This release introduces a new nightly only feature, `unstable`, which enables
+SIMD optimizations for certain types of regexes. No additional compile time
+options are necessary, and the regex crate will automatically choose the
+best CPU features at run time. As a result, the `simd` (nightly only) crate
+dependency has been dropped.
+
+New features:
+
+* [FEATURE #456](https://github.com/rust-lang/regex/pull/456):
+  The regex crate now includes AVX2 optimizations in addition to the extant
+  SSSE3 optimization.
+
+Bug fixes:
+
+* [BUG #455](https://github.com/rust-lang/regex/pull/455):
+  Fix a bug where `(?x)[ / - ]` failed to parse.
+
+
+0.2.8 (2018-03-12)
+==================
+Bug gixes:
+
+* [BUG #454](https://github.com/rust-lang/regex/pull/454):
+  Fix a bug in the nest limit checker being too aggressive.
+
+
+0.2.7 (2018-03-07)
+==================
+This release includes a ground-up rewrite of the regex-syntax crate, which has
+been in development for over a year.
+
+New features:
+
+* Error messages for invalid regexes have been greatly improved. You get these
+  automatically; you don't need to do anything. In addition to better
+  formatting, error messages will now explicitly call out the use of look
+  around. When regex 1.0 is released, this will happen for backreferences as
+  well.
+* Full support for intersection, difference and symmetric difference of
+  character classes. These can be used via the `&&`, `--` and `~~` binary
+  operators within classes.
+* A Unicode Level 1 conformat implementation of `\p{..}` character classes.
+  Things like `\p{scx:Hira}`, `\p{age:3.2}` or `\p{Changes_When_Casefolded}`
+  now work. All property name and value aliases are supported, and properties
+  are selected via loose matching. e.g., `\p{Greek}` is the same as
+  `\p{G r E e K}`.
+* A new `UNICODE.md` document has been added to this repository that
+  exhaustively documents support for UTS#18.
+* Empty sub-expressions are now permitted in most places. That is, `()+` is
+  now a valid regex.
+* Almost everything in regex-syntax now uses constant stack space, even when
+  performing analysis that requires structural induction. This reduces the risk
+  of a user provided regular expression causing a stack overflow.
+* [FEATURE #174](https://github.com/rust-lang/regex/issues/174):
+  The `Ast` type in `regex-syntax` now contains span information.
+* [FEATURE #424](https://github.com/rust-lang/regex/issues/424):
+  Support `\u`, `\u{...}`, `\U` and `\U{...}` syntax for specifying code points
+  in a regular expression.
+* [FEATURE #449](https://github.com/rust-lang/regex/pull/449):
+  Add a `Replace::by_ref` adapter for use of a replacer without consuming it.
+
+Bug fixes:
+
+* [BUG #446](https://github.com/rust-lang/regex/issues/446):
+  We re-enable the Boyer-Moore literal matcher.
+
+
+0.2.6 (2018-02-08)
+==================
+Bug fixes:
+
+* [BUG #446](https://github.com/rust-lang/regex/issues/446):
+  Fixes a bug in the new Boyer-Moore searcher that results in a match failure.
+  We fix this bug by temporarily disabling Boyer-Moore.
+
+
+0.2.5 (2017-12-30)
+==================
+Bug fixes:
+
+* [BUG #437](https://github.com/rust-lang/regex/issues/437):
+  Fixes a bug in the new Boyer-Moore searcher that results in a panic.
+
+
+0.2.4 (2017-12-30)
+==================
+New features:
+
+* [FEATURE #348](https://github.com/rust-lang/regex/pull/348):
+  Improve performance for capture searches on anchored regex.
+  (Contributed by @ethanpailes. Nice work!)
+* [FEATURE #419](https://github.com/rust-lang/regex/pull/419):
+  Expand literal searching to include Tuned Boyer-Moore in some cases.
+  (Contributed by @ethanpailes. Nice work!)
+
+Bug fixes:
+
+* [BUG](https://github.com/rust-lang/regex/pull/436):
+  The regex compiler plugin has been removed.
+* [BUG](https://github.com/rust-lang/regex/pull/436):
+  `simd` has been bumped to `0.2.1`, which fixes a Rust nightly build error.
+* [BUG](https://github.com/rust-lang/regex/pull/436):
+  Bring the benchmark harness up to date.
+
+
+0.2.3 (2017-11-30)
+==================
+New features:
+
+* [FEATURE #374](https://github.com/rust-lang/regex/pull/374):
+  Add `impl From<Match> for &str`.
+* [FEATURE #380](https://github.com/rust-lang/regex/pull/380):
+  Derive `Clone` and `PartialEq` on `Error`.
+* [FEATURE #400](https://github.com/rust-lang/regex/pull/400):
+  Update to Unicode 10.
+
+Bug fixes:
+
+* [BUG #375](https://github.com/rust-lang/regex/issues/375):
+  Fix a bug that prevented the bounded backtracker from terminating.
+* [BUG #393](https://github.com/rust-lang/regex/issues/393),
+  [BUG #394](https://github.com/rust-lang/regex/issues/394):
+  Fix bug with `replace` methods for empty matches.
+
+
+0.2.2 (2017-05-21)
+==================
+New features:
+
+* [FEATURE #341](https://github.com/rust-lang/regex/issues/341):
+  Support nested character classes and intersection operation.
+  For example, `[\p{Greek}&&\pL]` matches greek letters and
+  `[[0-9]&&[^4]]` matches every decimal digit except `4`.
+  (Much thanks to @robinst, who contributed this awesome feature.)
+
+Bug fixes:
+
+* [BUG #321](https://github.com/rust-lang/regex/issues/321):
+  Fix bug in literal extraction and UTF-8 decoding.
+* [BUG #326](https://github.com/rust-lang/regex/issues/326):
+  Add documentation tip about the `(?x)` flag.
+* [BUG #333](https://github.com/rust-lang/regex/issues/333):
+  Show additional replacement example using curly braces.
+* [BUG #334](https://github.com/rust-lang/regex/issues/334):
+  Fix bug when resolving captures after a match.
+* [BUG #338](https://github.com/rust-lang/regex/issues/338):
+  Add example that uses `Captures::get` to API documentation.
+* [BUG #353](https://github.com/rust-lang/regex/issues/353):
+  Fix RegexSet bug that caused match failure in some cases.
+* [BUG #354](https://github.com/rust-lang/regex/pull/354):
+  Fix panic in parser when `(?x)` is used.
+* [BUG #358](https://github.com/rust-lang/regex/issues/358):
+  Fix literal optimization bug with RegexSet.
+* [BUG #359](https://github.com/rust-lang/regex/issues/359):
+  Fix example code in README.
+* [BUG #365](https://github.com/rust-lang/regex/pull/365):
+  Fix bug in `rure_captures_len` in the C binding.
+* [BUG #367](https://github.com/rust-lang/regex/issues/367):
+  Fix byte class bug that caused a panic.
+
+
+0.2.1
+=====
+One major bug with `replace_all` has been fixed along with a couple of other
+touchups.
+
+* [BUG #312](https://github.com/rust-lang/regex/issues/312):
+  Fix documentation for `NoExpand` to reference correct lifetime parameter.
+* [BUG #314](https://github.com/rust-lang/regex/issues/314):
+  Fix a bug with `replace_all` when replacing a match with the empty string.
+* [BUG #316](https://github.com/rust-lang/regex/issues/316):
+  Note a missing breaking change from the `0.2.0` CHANGELOG entry.
+  (`RegexBuilder::compile` was renamed to `RegexBuilder::build`.)
+* [BUG #324](https://github.com/rust-lang/regex/issues/324):
+  Compiling `regex` should only require one version of `memchr` crate.
+
+
+0.2.0
+=====
+This is a new major release of the regex crate, and is an implementation of the
+[regex 1.0 RFC](https://github.com/rust-lang/rfcs/blob/master/text/1620-regex-1.0.md).
+We are releasing a `0.2` first, and if there are no major problems, we will
+release a `1.0` shortly. For `0.2`, the minimum *supported* Rust version is
+1.12.
+
+There are a number of **breaking changes** in `0.2`. They are split into two
+types. The first type correspond to breaking changes in regular expression
+syntax. The second type correspond to breaking changes in the API.
+
+Breaking changes for regex syntax:
+
+* POSIX character classes now require double bracketing. Previously, the regex
+  `[:upper:]` would parse as the `upper` POSIX character class. Now it parses
+  as the character class containing the characters `:upper:`. The fix to this
+  change is to use `[[:upper:]]` instead. Note that variants like
+  `[[:upper:][:blank:]]` continue to work.
+* The character `[` must always be escaped inside a character class.
+* The characters `&`, `-` and `~` must be escaped if any one of them are
+  repeated consecutively. For example, `[&]`, `[\&]`, `[\&\&]`, `[&-&]` are all
+  equivalent while `[&&]` is illegal. (The motivation for this and the prior
+  change is to provide a backwards compatible path for adding character class
+  set notation.)
+* A `bytes::Regex` now has Unicode mode enabled by default (like the main
+  `Regex` type). This means regexes compiled with `bytes::Regex::new` that
+  don't have the Unicode flag set should add `(?-u)` to recover the original
+  behavior.
+
+Breaking changes for the regex API:
+
+* `find` and `find_iter` now **return `Match` values instead of
+  `(usize, usize)`.** `Match` values have `start` and `end` methods, which
+  return the match offsets. `Match` values also have an `as_str` method,
+  which returns the text of the match itself.
+* The `Captures` type now only provides a single iterator over all capturing
+  matches, which should replace uses of `iter` and `iter_pos`. Uses of
+  `iter_named` should use the `capture_names` method on `Regex`.
+* The `at` method on the `Captures` type has been renamed to `get`, and it
+  now returns a `Match`. Similarly, the `name` method on `Captures` now returns
+  a `Match`.
+* The `replace` methods now return `Cow` values. The `Cow::Borrowed` variant
+  is returned when no replacements are made.
+* The `Replacer` trait has been completely overhauled. This should only
+  impact clients that implement this trait explicitly. Standard uses of
+  the `replace` methods should continue to work unchanged. If you implement
+  the `Replacer` trait, please consult the new documentation.
+* The `quote` free function has been renamed to `escape`.
+* The `Regex::with_size_limit` method has been removed. It is replaced by
+  `RegexBuilder::size_limit`.
+* The `RegexBuilder` type has switched from owned `self` method receivers to
+  `&mut self` method receivers. Most uses will continue to work unchanged, but
+  some code may require naming an intermediate variable to hold the builder.
+* The `compile` method on `RegexBuilder` has been renamed to `build`.
+* The free `is_match` function has been removed. It is replaced by compiling
+  a `Regex` and calling its `is_match` method.
+* The `PartialEq` and `Eq` impls on `Regex` have been dropped. If you relied
+  on these impls, the fix is to define a wrapper type around `Regex`, impl
+  `Deref` on it and provide the necessary impls.
+* The `is_empty` method on `Captures` has been removed. This always returns
+  `false`, so its use is superfluous.
+* The `Syntax` variant of the `Error` type now contains a string instead of
+  a `regex_syntax::Error`. If you were examining syntax errors more closely,
+  you'll need to explicitly use the `regex_syntax` crate to re-parse the regex.
+* The `InvalidSet` variant of the `Error` type has been removed since it is
+  no longer used.
+* Most of the iterator types have been renamed to match conventions. If you
+  were using these iterator types explicitly, please consult the documentation
+  for its new name. For example, `RegexSplits` has been renamed to `Split`.
+
+A number of bugs have been fixed:
+
+* [BUG #151](https://github.com/rust-lang/regex/issues/151):
+  The `Replacer` trait has been changed to permit the caller to control
+  allocation.
+* [BUG #165](https://github.com/rust-lang/regex/issues/165):
+  Remove the free `is_match` function.
+* [BUG #166](https://github.com/rust-lang/regex/issues/166):
+  Expose more knobs (available in `0.1`) and remove `with_size_limit`.
+* [BUG #168](https://github.com/rust-lang/regex/issues/168):
+  Iterators produced by `Captures` now have the correct lifetime parameters.
+* [BUG #175](https://github.com/rust-lang/regex/issues/175):
+  Fix a corner case in the parsing of POSIX character classes.
+* [BUG #178](https://github.com/rust-lang/regex/issues/178):
+  Drop the `PartialEq` and `Eq` impls on `Regex`.
+* [BUG #179](https://github.com/rust-lang/regex/issues/179):
+  Remove `is_empty` from `Captures` since it always returns false.
+* [BUG #276](https://github.com/rust-lang/regex/issues/276):
+  Position of named capture can now be retrieved from a `Captures`.
+* [BUG #296](https://github.com/rust-lang/regex/issues/296):
+  Remove winapi/kernel32-sys dependency on UNIX.
+* [BUG #307](https://github.com/rust-lang/regex/issues/307):
+  Fix error on emscripten.
+
+
+0.1.80
+======
+* [PR #292](https://github.com/rust-lang/regex/pull/292):
+  Fixes bug #291, which was introduced by PR #290.
+
+0.1.79
+======
+* Require regex-syntax 0.3.8.
+
+0.1.78
+======
+* [PR #290](https://github.com/rust-lang/regex/pull/290):
+  Fixes bug #289, which caused some regexes with a certain combination
+  of literals to match incorrectly.
+
+0.1.77
+======
+* [PR #281](https://github.com/rust-lang/regex/pull/281):
+  Fixes bug #280 by disabling all literal optimizations when a pattern
+  is partially anchored.
+
+0.1.76
+======
+* Tweak criteria for using the Teddy literal matcher.
+
+0.1.75
+======
+* [PR #275](https://github.com/rust-lang/regex/pull/275):
+  Improves match verification performance in the Teddy SIMD searcher.
+* [PR #278](https://github.com/rust-lang/regex/pull/278):
+  Replaces slow substring loop in the Teddy SIMD searcher with Aho-Corasick.
+* Implemented DoubleEndedIterator on regex set match iterators.
+
+0.1.74
+======
+* Release regex-syntax 0.3.5 with a minor bug fix.
+* Fix bug #272.
+* Fix bug #277.
+* [PR #270](https://github.com/rust-lang/regex/pull/270):
+  Fixes bugs #264, #268 and an unreported where the DFA cache size could be
+  drastically under estimated in some cases (leading to high unexpected memory
+  usage).
+
+0.1.73
+======
+* Release `regex-syntax 0.3.4`.
+* Bump `regex-syntax` dependency version for `regex` to `0.3.4`.
+
+0.1.72
+======
+* [PR #262](https://github.com/rust-lang/regex/pull/262):
+  Fixes a number of small bugs caught by fuzz testing (AFL).
+
+0.1.71
+======
+* [PR #236](https://github.com/rust-lang/regex/pull/236):
+  Fix a bug in how suffix literals were extracted, which could lead
+  to invalid match behavior in some cases.
+
+0.1.70
+======
+* [PR #231](https://github.com/rust-lang/regex/pull/231):
+  Add SIMD accelerated multiple pattern search.
+* [PR #228](https://github.com/rust-lang/regex/pull/228):
+  Reintroduce the reverse suffix literal optimization.
+* [PR #226](https://github.com/rust-lang/regex/pull/226):
+  Implements NFA state compression in the lazy DFA.
+* [PR #223](https://github.com/rust-lang/regex/pull/223):
+  A fully anchored RegexSet can now short-circuit.
+
+0.1.69
+======
+* [PR #216](https://github.com/rust-lang/regex/pull/216):
+  Tweak the threshold for running backtracking.
+* [PR #217](https://github.com/rust-lang/regex/pull/217):
+  Add upper limit (from the DFA) to capture search (for the NFA).
+* [PR #218](https://github.com/rust-lang/regex/pull/218):
+  Add rure, a C API.
+
+0.1.68
+======
+* [PR #210](https://github.com/rust-lang/regex/pull/210):
+  Fixed a performance bug in `bytes::Regex::replace` where `extend` was used
+  instead of `extend_from_slice`.
+* [PR #211](https://github.com/rust-lang/regex/pull/211):
+  Fixed a bug in the handling of word boundaries in the DFA.
+* [PR #213](https://github.com/rust-lang/pull/213):
+  Added RE2 and Tcl to the benchmark harness. Also added a CLI utility from
+  running regexes using any of the following regex engines: PCRE1, PCRE2,
+  Oniguruma, RE2, Tcl and of course Rust's own regexes.
+
+0.1.67
+======
+* [PR #201](https://github.com/rust-lang/regex/pull/201):
+  Fix undefined behavior in the `regex!` compiler plugin macro.
+* [PR #205](https://github.com/rust-lang/regex/pull/205):
+  More improvements to DFA performance. Competitive with RE2. See PR for
+  benchmarks.
+* [PR #209](https://github.com/rust-lang/regex/pull/209):
+  Release 0.1.66 was semver incompatible since it required a newer version
+  of Rust than previous releases. This PR fixes that. (And `0.1.66` was
+  yanked.)
+
+0.1.66
+======
+* Speculative support for Unicode word boundaries was added to the DFA. This
+  should remove the last common case that disqualified use of the DFA.
+* An optimization that scanned for suffix literals and then matched the regular
+  expression in reverse was removed because it had worst case quadratic time
+  complexity. It was replaced with a more limited optimization where, given any
+  regex of the form `re$`, it will be matched in reverse from the end of the
+  haystack.
+* [PR #202](https://github.com/rust-lang/regex/pull/202):
+  The inner loop of the DFA was heavily optimized to improve cache locality
+  and reduce the overall number of instructions run on each iteration. This
+  represents the first use of `unsafe` in `regex` (to elide bounds checks).
+* [PR #200](https://github.com/rust-lang/regex/pull/200):
+  Use of the `mempool` crate (which used thread local storage) was replaced
+  with a faster version of a similar API in @Amanieu's `thread_local` crate.
+  It should reduce contention when using a regex from multiple threads
+  simultaneously.
+* PCRE2 JIT benchmarks were added. A benchmark comparison can be found
+  [here](https://gist.github.com/anonymous/14683c01993e91689f7206a18675901b).
+  (Includes a comparison with PCRE1's JIT and Oniguruma.)
+* A bug where word boundaries weren't being matched correctly in the DFA was
+  fixed. This only affected use of `bytes::Regex`.
+* [#160](https://github.com/rust-lang/regex/issues/160):
+  `Captures` now has a `Debug` impl.
diff --git a/crates/regex/Cargo.lock b/crates/regex/Cargo.lock
new file mode 100644
index 0000000..f91c887
--- /dev/null
+++ b/crates/regex/Cargo.lock
@@ -0,0 +1,98 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "aho-corasick"
+version = "0.7.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc936419f96fa211c1b9166887b38e5e40b19958e5b895be7c1f93adec7071ac"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "getrandom"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+
+[[package]]
+name = "libc"
+version = "0.2.139"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "201de327520df007757c1f0adce6e827fe8562fbc28bfd9c15571c66ca1f5f79"
+
+[[package]]
+name = "memchr"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
+
+[[package]]
+name = "quickcheck"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "588f6378e4dd99458b60ec275b4477add41ce4fa9f64dcba6f15adccb19b50d6"
+dependencies = [
+ "rand",
+]
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "regex"
+version = "1.7.3"
+dependencies = [
+ "aho-corasick",
+ "lazy_static",
+ "memchr",
+ "quickcheck",
+ "rand",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.6.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"
+
+[[package]]
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
diff --git a/crates/regex/Cargo.toml b/crates/regex/Cargo.toml
new file mode 100644
index 0000000..37e44fb
--- /dev/null
+++ b/crates/regex/Cargo.toml
@@ -0,0 +1,149 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2018"
+name = "regex"
+version = "1.7.3"
+authors = ["The Rust Project Developers"]
+exclude = [
+    "/scripts/*",
+    "/.github/*",
+]
+autotests = false
+description = """
+An implementation of regular expressions for Rust. This implementation uses
+finite automata and guarantees linear time matching on all inputs.
+"""
+homepage = "https://github.com/rust-lang/regex"
+documentation = "https://docs.rs/regex"
+readme = "README.md"
+categories = ["text-processing"]
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/rust-lang/regex"
+
+[profile.bench]
+debug = true
+
+[profile.release]
+debug = true
+
+[profile.test]
+debug = true
+
+[lib]
+doctest = false
+bench = false
+
+[[test]]
+name = "default"
+path = "tests/test_default.rs"
+
+[[test]]
+name = "default-bytes"
+path = "tests/test_default_bytes.rs"
+
+[[test]]
+name = "nfa"
+path = "tests/test_nfa.rs"
+
+[[test]]
+name = "nfa-utf8bytes"
+path = "tests/test_nfa_utf8bytes.rs"
+
+[[test]]
+name = "nfa-bytes"
+path = "tests/test_nfa_bytes.rs"
+
+[[test]]
+name = "backtrack"
+path = "tests/test_backtrack.rs"
+
+[[test]]
+name = "backtrack-utf8bytes"
+path = "tests/test_backtrack_utf8bytes.rs"
+
+[[test]]
+name = "backtrack-bytes"
+path = "tests/test_backtrack_bytes.rs"
+
+[[test]]
+name = "crates-regex"
+path = "tests/test_crates_regex.rs"
+
+[dependencies.aho-corasick]
+version = "0.7.18"
+optional = true
+
+[dependencies.memchr]
+version = "2.4.0"
+optional = true
+
+[dependencies.regex-syntax]
+version = "0.6.29"
+default-features = false
+
+[dev-dependencies.lazy_static]
+version = "1"
+
+[dev-dependencies.quickcheck]
+version = "1.0.3"
+default-features = false
+
+[dev-dependencies.rand]
+version = "0.8.3"
+features = [
+    "getrandom",
+    "small_rng",
+]
+default-features = false
+
+[features]
+default = [
+    "std",
+    "perf",
+    "unicode",
+    "regex-syntax/default",
+]
+pattern = []
+perf = [
+    "perf-cache",
+    "perf-dfa",
+    "perf-inline",
+    "perf-literal",
+]
+perf-cache = []
+perf-dfa = []
+perf-inline = []
+perf-literal = [
+    "aho-corasick",
+    "memchr",
+]
+std = []
+unicode = [
+    "unicode-age",
+    "unicode-bool",
+    "unicode-case",
+    "unicode-gencat",
+    "unicode-perl",
+    "unicode-script",
+    "unicode-segment",
+    "regex-syntax/unicode",
+]
+unicode-age = ["regex-syntax/unicode-age"]
+unicode-bool = ["regex-syntax/unicode-bool"]
+unicode-case = ["regex-syntax/unicode-case"]
+unicode-gencat = ["regex-syntax/unicode-gencat"]
+unicode-perl = ["regex-syntax/unicode-perl"]
+unicode-script = ["regex-syntax/unicode-script"]
+unicode-segment = ["regex-syntax/unicode-segment"]
+unstable = ["pattern"]
+use_std = ["std"]
diff --git a/crates/regex/HACKING.md b/crates/regex/HACKING.md
new file mode 100644
index 0000000..34af5b5
--- /dev/null
+++ b/crates/regex/HACKING.md
@@ -0,0 +1,341 @@
+Your friendly guide to hacking and navigating the regex library.
+
+This guide assumes familiarity with Rust and Cargo, and at least a perusal of
+the user facing documentation for this crate.
+
+If you're looking for background on the implementation in this library, then
+you can do no better than Russ Cox's article series on implementing regular
+expressions using finite automata: https://swtch.com/~rsc/regexp/
+
+
+## Architecture overview
+
+As you probably already know, this library executes regular expressions using
+finite automata. In particular, a design goal is to make searching linear
+with respect to both the regular expression and the text being searched.
+Meeting that design goal on its own is not so hard and can be done with an
+implementation of the Pike VM (similar to Thompson's construction, but supports
+capturing groups), as described in: https://swtch.com/~rsc/regexp/regexp2.html
+--- This library contains such an implementation in src/pikevm.rs.
+
+Making it fast is harder. One of the key problems with the Pike VM is that it
+can be in more than one state at any point in time, and must shuffle capture
+positions between them. The Pike VM also spends a lot of time following the
+same epsilon transitions over and over again. We can employ one trick to
+speed up the Pike VM: extract one or more literal prefixes from the regular
+expression and execute specialized code to quickly find matches of those
+prefixes in the search text. The Pike VM can then be avoided for most the
+search, and instead only executed when a prefix is found. The code to find
+prefixes is in the regex-syntax crate (in this repository). The code to search
+for literals is in src/literals.rs. When more than one literal prefix is found,
+we fall back to an Aho-Corasick DFA using the aho-corasick crate. For one
+literal, we use a variant of the Boyer-Moore algorithm. Both Aho-Corasick and
+Boyer-Moore use `memchr` when appropriate. The Boyer-Moore variant in this
+library also uses elementary frequency analysis to choose the right byte to run
+`memchr` with.
+
+Of course, detecting prefix literals can only take us so far. Not all regular
+expressions have literal prefixes. To remedy this, we try another approach
+to executing the Pike VM: backtracking, whose implementation can be found in
+src/backtrack.rs. One reason why backtracking can be faster is that it avoids
+excessive shuffling of capture groups. Of course, backtracking is susceptible
+to exponential runtimes, so we keep track of every state we've visited to make
+sure we never visit it again. This guarantees linear time execution, but we
+pay for it with the memory required to track visited states. Because of the
+memory requirement, we only use this engine on small search strings *and* small
+regular expressions.
+
+Lastly, the real workhorse of this library is the "lazy" DFA in src/dfa.rs.
+It is distinct from the Pike VM in that the DFA is explicitly represented in
+memory and is only ever in one state at a time. It is said to be "lazy" because
+the DFA is computed as text is searched, where each byte in the search text
+results in at most one new DFA state. It is made fast by caching states. DFAs
+are susceptible to exponential state blow up (where the worst case is computing
+a new state for every input byte, regardless of what's in the state cache). To
+avoid using a lot of memory, the lazy DFA uses a bounded cache. Once the cache
+is full, it is wiped and state computation starts over again. If the cache is
+wiped too frequently, then the DFA gives up and searching falls back to one of
+the aforementioned algorithms.
+
+All of the above matching engines expose precisely the same matching semantics.
+This is indeed tested. (See the section below about testing.)
+
+The following sub-sections describe the rest of the library and how each of the
+matching engines are actually used.
+
+### Parsing
+
+Regular expressions are parsed using the regex-syntax crate, which is
+maintained in this repository. The regex-syntax crate defines an abstract
+syntax and provides very detailed error messages when a parse error is
+encountered. Parsing is done in a separate crate so that others may benefit
+from its existence, and because it is relatively divorced from the rest of the
+regex library.
+
+The regex-syntax crate also provides sophisticated support for extracting
+prefix and suffix literals from regular expressions.
+
+### Compilation
+
+The compiler is in src/compile.rs. The input to the compiler is some abstract
+syntax for a regular expression and the output is a sequence of opcodes that
+matching engines use to execute a search. (One can think of matching engines as
+mini virtual machines.) The sequence of opcodes is a particular encoding of a
+non-deterministic finite automaton. In particular, the opcodes explicitly rely
+on epsilon transitions.
+
+Consider a simple regular expression like `a|b`. Its compiled form looks like
+this:
+
+    000 Save(0)
+    001 Split(2, 3)
+    002 'a' (goto: 4)
+    003 'b'
+    004 Save(1)
+    005 Match
+
+The first column is the instruction pointer and the second column is the
+instruction. Save instructions indicate that the current position in the input
+should be stored in a captured location. Split instructions represent a binary
+branch in the program (i.e., epsilon transitions). The instructions `'a'` and
+`'b'` indicate that the literal bytes `'a'` or `'b'` should match.
+
+In older versions of this library, the compilation looked like this:
+
+    000 Save(0)
+    001 Split(2, 3)
+    002 'a'
+    003 Jump(5)
+    004 'b'
+    005 Save(1)
+    006 Match
+
+In particular, empty instructions that merely served to move execution from one
+point in the program to another were removed. Instead, every instruction has a
+`goto` pointer embedded into it. This resulted in a small performance boost for
+the Pike VM, because it was one fewer epsilon transition that it had to follow.
+
+There exist more instructions and they are defined and documented in
+src/prog.rs.
+
+Compilation has several knobs and a few unfortunately complicated invariants.
+Namely, the output of compilation can be one of two types of programs: a
+program that executes on Unicode scalar values or a program that executes
+on raw bytes. In the former case, the matching engine is responsible for
+performing UTF-8 decoding and executing instructions using Unicode codepoints.
+In the latter case, the program handles UTF-8 decoding implicitly, so that the
+matching engine can execute on raw bytes. All matching engines can execute
+either Unicode or byte based programs except for the lazy DFA, which requires
+byte based programs. In general, both representations were kept because (1) the
+lazy DFA requires byte based programs so that states can be encoded in a memory
+efficient manner and (2) the Pike VM benefits greatly from inlining Unicode
+character classes into fewer instructions as it results in fewer epsilon
+transitions.
+
+N.B. UTF-8 decoding is built into the compiled program by making use of the
+utf8-ranges crate. The compiler in this library factors out common suffixes to
+reduce the size of huge character classes (e.g., `\pL`).
+
+A regrettable consequence of this split in instruction sets is we generally
+need to compile two programs; one for NFA execution and one for the lazy DFA.
+
+In fact, it is worse than that: the lazy DFA is not capable of finding the
+starting location of a match in a single scan, and must instead execute a
+backwards search after finding the end location. To execute a backwards search,
+we must have compiled the regular expression *in reverse*.
+
+This means that every compilation of a regular expression generally results in
+three distinct programs. It would be possible to lazily compile the Unicode
+program, since it is never needed if (1) the regular expression uses no word
+boundary assertions and (2) the caller never asks for sub-capture locations.
+
+### Execution
+
+At the time of writing, there are four matching engines in this library:
+
+1. The Pike VM (supports captures).
+2. Bounded backtracking (supports captures).
+3. Literal substring or multi-substring search.
+4. Lazy DFA (no support for Unicode word boundary assertions).
+
+Only the first two matching engines are capable of executing every regular
+expression program. They also happen to be the slowest, which means we need
+some logic that (1) knows various facts about the regular expression and (2)
+knows what the caller wants. Using this information, we can determine which
+engine (or engines) to use.
+
+The logic for choosing which engine to execute is in src/exec.rs and is
+documented on the Exec type. Exec values contain regular expression Programs
+(defined in src/prog.rs), which contain all the necessary tidbits for actually
+executing a regular expression on search text.
+
+For the most part, the execution logic is straight-forward and follows the
+limitations of each engine described above pretty faithfully. The hairiest
+part of src/exec.rs by far is the execution of the lazy DFA, since it requires
+a forwards and backwards search, and then falls back to either the Pike VM or
+backtracking if the caller requested capture locations.
+
+The Exec type also contains mutable scratch space for each type of matching
+engine. This scratch space is used during search (for example, for the lazy
+DFA, it contains compiled states that are reused on subsequent searches).
+
+### Programs
+
+A regular expression program is essentially a sequence of opcodes produced by
+the compiler plus various facts about the regular expression (such as whether
+it is anchored, its capture names, etc.).
+
+### The regex! macro
+
+The `regex!` macro no longer exists. It was developed in a bygone era as a
+compiler plugin during the infancy of the regex crate. Back then, then only
+matching engine in the crate was the Pike VM. The `regex!` macro was, itself,
+also a Pike VM. The only advantages it offered over the dynamic Pike VM that
+was built at runtime were the following:
+
+  1. Syntax checking was done at compile time. Your Rust program wouldn't
+     compile if your regex didn't compile.
+  2. Reduction of overhead that was proportional to the size of the regex.
+     For the most part, this overhead consisted of heap allocation, which
+     was nearly eliminated in the compiler plugin.
+
+The main takeaway here is that the compiler plugin was a marginally faster
+version of a slow regex engine. As the regex crate evolved, it grew other regex
+engines (DFA, bounded backtracker) and sophisticated literal optimizations.
+The regex macro didn't keep pace, and it therefore became (dramatically) slower
+than the dynamic engines. The only reason left to use it was for the compile
+time guarantee that your regex is correct. Fortunately, Clippy (the Rust lint
+tool) has a lint that checks your regular expression validity, which mostly
+replaces that use case.
+
+Additionally, the regex compiler plugin stopped receiving maintenance. Nobody
+complained. At that point, it seemed prudent to just remove it.
+
+Will a compiler plugin be brought back? The future is murky, but there is
+definitely an opportunity there to build something that is faster than the
+dynamic engines in some cases. But it will be challenging! As of now, there
+are no plans to work on this.
+
+
+## Testing
+
+A key aspect of any mature regex library is its test suite. A subset of the
+tests in this library come from Glenn Fowler's AT&T test suite (its online
+presence seems gone at the time of writing). The source of the test suite is
+located in src/testdata. The scripts/regex-match-tests.py takes the test suite
+in src/testdata and generates tests/matches.rs.
+
+There are also many other manually crafted tests and regression tests in
+tests/tests.rs. Some of these tests were taken from RE2.
+
+The biggest source of complexity in the tests is related to answering this
+question: how can we reuse the tests to check all of our matching engines? One
+approach would have been to encode every test into some kind of format (like
+the AT&T test suite) and code generate tests for each matching engine. The
+approach we use in this library is to create a Cargo.toml entry point for each
+matching engine we want to test. The entry points are:
+
+* `tests/test_default.rs` - tests `Regex::new`
+* `tests/test_default_bytes.rs` - tests `bytes::Regex::new`
+* `tests/test_nfa.rs` - tests `Regex::new`, forced to use the NFA
+  algorithm on every regex.
+* `tests/test_nfa_bytes.rs` - tests `Regex::new`, forced to use the NFA
+  algorithm on every regex and use *arbitrary* byte based programs.
+* `tests/test_nfa_utf8bytes.rs` - tests `Regex::new`, forced to use the NFA
+  algorithm on every regex and use *UTF-8* byte based programs.
+* `tests/test_backtrack.rs` - tests `Regex::new`, forced to use
+  backtracking on every regex.
+* `tests/test_backtrack_bytes.rs` - tests `Regex::new`, forced to use
+  backtracking on every regex and use *arbitrary* byte based programs.
+* `tests/test_backtrack_utf8bytes.rs` - tests `Regex::new`, forced to use
+  backtracking on every regex and use *UTF-8* byte based programs.
+* `tests/test_crates_regex.rs` - tests to make sure that all of the
+  backends behave in the same way against a number of quickcheck
+  generated random inputs. These tests need to be enabled through
+  the `RUST_REGEX_RANDOM_TEST` environment variable (see
+  below).
+
+The lazy DFA and pure literal engines are absent from this list because
+they cannot be used on every regular expression. Instead, we rely on
+`tests/test_dynamic.rs` to test the lazy DFA and literal engines when possible.
+
+Since the tests are repeated several times, and because `cargo test` runs all
+entry points, it can take a while to compile everything. To reduce compile
+times slightly, try using `cargo test --test default`, which will only use the
+`tests/test_default.rs` entry point.
+
+The random testing takes quite a while, so it is not enabled by default.
+In order to run the random testing you can set the
+`RUST_REGEX_RANDOM_TEST` environment variable to anything before
+invoking `cargo test`. Note that this variable is inspected at compile
+time, so if the tests don't seem to be running, you may need to run
+`cargo clean`.
+
+## Benchmarking
+
+The benchmarking in this crate is made up of many micro-benchmarks. Currently,
+there are two primary sets of benchmarks: the benchmarks that were adopted
+at this library's inception (in `bench/src/misc.rs`) and a newer set of
+benchmarks meant to test various optimizations. Specifically, the latter set
+contain some analysis and are in `bench/src/sherlock.rs`. Also, the latter
+set are all executed on the same lengthy input whereas the former benchmarks
+are executed on strings of varying length.
+
+There is also a smattering of benchmarks for parsing and compilation.
+
+Benchmarks are in a separate crate so that its dependencies can be managed
+separately from the main regex crate.
+
+Benchmarking follows a similarly wonky setup as tests. There are multiple entry
+points:
+
+* `bench_rust.rs` - benchmarks `Regex::new`
+* `bench_rust_bytes.rs` benchmarks `bytes::Regex::new`
+* `bench_pcre.rs` - benchmarks PCRE
+* `bench_onig.rs` - benchmarks Oniguruma
+
+The PCRE and Oniguruma benchmarks exist as a comparison point to a mature
+regular expression library. In general, this regex library compares favorably
+(there are even a few benchmarks that PCRE simply runs too slowly on or
+outright can't execute at all). I would love to add other regular expression
+library benchmarks (especially RE2).
+
+If you're hacking on one of the matching engines and just want to see
+benchmarks, then all you need to run is:
+
+    $ (cd bench && ./run rust)
+
+If you want to compare your results with older benchmarks, then try:
+
+    $ (cd bench && ./run rust | tee old)
+    $ ... make it faster
+    $ (cd bench && ./run rust | tee new)
+    $ cargo benchcmp old new --improvements
+
+The `cargo-benchcmp` utility is available here:
+https://github.com/BurntSushi/cargo-benchcmp
+
+The `./bench/run` utility can run benchmarks for PCRE and Oniguruma too. See
+`./bench/bench --help`.
+
+## Dev Docs
+
+When digging your teeth into the codebase for the first time, the
+crate documentation can be a great resource. By default `rustdoc`
+will strip out all documentation of private crate members in an
+effort to help consumers of the crate focus on the *interface*
+without having to concern themselves with the *implementation*.
+Normally this is a great thing, but if you want to start hacking
+on regex internals it is not what you want. Many of the private members
+of this crate are well documented with rustdoc style comments, and
+it would be a shame to miss out on the opportunity that presents.
+You can generate the private docs with:
+
+```
+$ rustdoc --crate-name docs src/lib.rs -o target/doc -L target/debug/deps --no-defaults --passes collapse-docs --passes unindent-comments
+```
+
+Then just point your browser at `target/doc/regex/index.html`.
+
+See https://github.com/rust-lang/rust/issues/15347 for more info
+about generating developer docs for internal use.
diff --git a/crates/regex/LICENSE b/crates/regex/LICENSE
new file mode 120000
index 0000000..6b579aa
--- /dev/null
+++ b/crates/regex/LICENSE
@@ -0,0 +1 @@
+LICENSE-APACHE
\ No newline at end of file
diff --git a/crates/regex/LICENSE-APACHE b/crates/regex/LICENSE-APACHE
new file mode 100644
index 0000000..16fe87b
--- /dev/null
+++ b/crates/regex/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/crates/regex/LICENSE-MIT b/crates/regex/LICENSE-MIT
new file mode 100644
index 0000000..39d4bdb
--- /dev/null
+++ b/crates/regex/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2014 The Rust Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/crates/regex/METADATA b/crates/regex/METADATA
new file mode 100644
index 0000000..f8d1a17
--- /dev/null
+++ b/crates/regex/METADATA
@@ -0,0 +1,23 @@
+# This project was upgraded with external_updater.
+# Usage: tools/external_updater/updater.sh update rust/crates/regex
+# For more info, check https://cs.android.com/android/platform/superproject/+/master:tools/external_updater/README.md
+
+name: "regex"
+description: "An implementation of regular expressions for Rust. This implementation uses finite automata and guarantees linear time matching on all inputs."
+third_party {
+  url {
+    type: HOMEPAGE
+    value: "https://crates.io/crates/regex"
+  }
+  url {
+    type: ARCHIVE
+    value: "https://static.crates.io/crates/regex/regex-1.7.3.crate"
+  }
+  version: "1.7.3"
+  license_type: NOTICE
+  last_upgrade_date {
+    year: 2023
+    month: 4
+    day: 3
+  }
+}
diff --git a/crates/regex/MODULE_LICENSE_APACHE2 b/crates/regex/MODULE_LICENSE_APACHE2
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/crates/regex/MODULE_LICENSE_APACHE2
diff --git a/crates/regex/PERFORMANCE.md b/crates/regex/PERFORMANCE.md
new file mode 100644
index 0000000..8cd0d9c
--- /dev/null
+++ b/crates/regex/PERFORMANCE.md
@@ -0,0 +1,277 @@
+Your friendly guide to understanding the performance characteristics of this
+crate.
+
+This guide assumes some familiarity with the public API of this crate, which
+can be found here: https://docs.rs/regex
+
+## Theory vs. Practice
+
+One of the design goals of this crate is to provide worst case linear time
+behavior with respect to the text searched using finite state automata. This
+means that, *in theory*, the performance of this crate is much better than most
+regex implementations, which typically use backtracking which has worst case
+exponential time.
+
+For example, try opening a Python interpreter and typing this:
+
+    >>> import re
+    >>> re.search('(a*)*c', 'a' * 30).span()
+
+I'll wait.
+
+At some point, you'll figure out that it won't terminate any time soon. ^C it.
+
+The promise of this crate is that *this pathological behavior can't happen*.
+
+With that said, just because we have protected ourselves against worst case
+exponential behavior doesn't mean we are immune from large constant factors
+or places where the current regex engine isn't quite optimal. This guide will
+detail those cases and provide guidance on how to avoid them, among other
+bits of general advice.
+
+## Thou Shalt Not Compile Regular Expressions In A Loop
+
+**Advice**: Use `lazy_static` to amortize the cost of `Regex` compilation.
+
+Don't do it unless you really don't mind paying for it. Compiling a regular
+expression in this crate is quite expensive. It is conceivable that it may get
+faster some day, but I wouldn't hold out hope for, say, an order of magnitude
+improvement. In particular, compilation can take any where from a few dozen
+microseconds to a few dozen milliseconds. Yes, milliseconds. Unicode character
+classes, in particular, have the largest impact on compilation performance. At
+the time of writing, for example, `\pL{100}` takes around 44ms to compile. This
+is because `\pL` corresponds to every letter in Unicode and compilation must
+turn it into a proper automaton that decodes a subset of UTF-8 which
+corresponds to those letters. Compilation also spends some cycles shrinking the
+size of the automaton.
+
+This means that in order to realize efficient regex matching, one must
+*amortize the cost of compilation*. Trivially, if a call to `is_match` is
+inside a loop, then make sure your call to `Regex::new` is *outside* that loop.
+
+In many programming languages, regular expressions can be conveniently defined
+and compiled in a global scope, and code can reach out and use them as if
+they were global static variables. In Rust, there is really no concept of
+life-before-main, and therefore, one cannot utter this:
+
+    static MY_REGEX: Regex = Regex::new("...").unwrap();
+
+Unfortunately, this would seem to imply that one must pass `Regex` objects
+around to everywhere they are used, which can be especially painful depending
+on how your program is structured. Thankfully, the
+[`lazy_static`](https://crates.io/crates/lazy_static)
+crate provides an answer that works well:
+
+    use lazy_static::lazy_static;
+    use regex::Regex;
+
+    fn some_helper_function(text: &str) -> bool {
+        lazy_static! {
+            static ref MY_REGEX: Regex = Regex::new("...").unwrap();
+        }
+        MY_REGEX.is_match(text)
+    }
+
+In other words, the `lazy_static!` macro enables us to define a `Regex` *as if*
+it were a global static value. What is actually happening under the covers is
+that the code inside the macro (i.e., `Regex::new(...)`) is run on *first use*
+of `MY_REGEX` via a `Deref` impl. The implementation is admittedly magical, but
+it's self contained and everything works exactly as you expect. In particular,
+`MY_REGEX` can be used from multiple threads without wrapping it in an `Arc` or
+a `Mutex`. On that note...
+
+## Using a regex from multiple threads
+
+**Advice**: The performance impact from using a `Regex` from multiple threads
+is likely negligible. If necessary, clone the `Regex` so that each thread gets
+its own copy. Cloning a regex does not incur any additional memory overhead
+than what would be used by using a `Regex` from multiple threads
+simultaneously. *Its only cost is ergonomics.*
+
+It is supported and encouraged to define your regexes using `lazy_static!` as
+if they were global static values, and then use them to search text from
+multiple threads simultaneously.
+
+One might imagine that this is possible because a `Regex` represents a
+*compiled* program, so that any allocation or mutation is already done, and is
+therefore read-only. Unfortunately, this is not true. Each type of search
+strategy in this crate requires some kind of mutable scratch space to use
+*during search*. For example, when executing a DFA, its states are computed
+lazily and reused on subsequent searches. Those states go into that mutable
+scratch space.
+
+The mutable scratch space is an implementation detail, and in general, its
+mutation should not be observable from users of this crate. Therefore, it uses
+interior mutability. This implies that `Regex` can either only be used from one
+thread, or it must do some sort of synchronization. Either choice is
+reasonable, but this crate chooses the latter, in particular because it is
+ergonomic and makes use with `lazy_static!` straight forward.
+
+Synchronization implies *some* amount of overhead. When a `Regex` is used from
+a single thread, this overhead is negligible. When a `Regex` is used from
+multiple threads simultaneously, it is possible for the overhead of
+synchronization from contention to impact performance. The specific cases where
+contention may happen is if you are calling any of these methods repeatedly
+from multiple threads simultaneously:
+
+* shortest_match
+* is_match
+* find
+* captures
+
+In particular, every invocation of one of these methods must synchronize with
+other threads to retrieve its mutable scratch space before searching can start.
+If, however, you are using one of these methods:
+
+* find_iter
+* captures_iter
+
+Then you may not suffer from contention since the cost of synchronization is
+amortized on *construction of the iterator*. That is, the mutable scratch space
+is obtained when the iterator is created and retained throughout its lifetime.
+
+## Only ask for what you need
+
+**Advice**: Prefer in this order: `is_match`, `find`, `captures`.
+
+There are three primary search methods on a `Regex`:
+
+* is_match
+* find
+* captures
+
+In general, these are ordered from fastest to slowest.
+
+`is_match` is fastest because it doesn't actually need to find the start or the
+end of the leftmost-first match. It can quit immediately after it knows there
+is a match. For example, given the regex `a+` and the haystack, `aaaaa`, the
+search will quit after examining the first byte.
+
+In contrast, `find` must return both the start and end location of the
+leftmost-first match. It can use the DFA matcher for this, but must run it
+forwards once to find the end of the match *and then run it backwards* to find
+the start of the match. The two scans and the cost of finding the real end of
+the leftmost-first match make this more expensive than `is_match`.
+
+`captures` is the most expensive of them all because it must do what `find`
+does, and then run either the bounded backtracker or the Pike VM to fill in the
+capture group locations. Both of these are simulations of an NFA, which must
+spend a lot of time shuffling states around. The DFA limits the performance hit
+somewhat by restricting the amount of text that must be searched via an NFA
+simulation.
+
+One other method not mentioned is `shortest_match`. This method has precisely
+the same performance characteristics as `is_match`, except it will return the
+end location of when it discovered a match. For example, given the regex `a+`
+and the haystack `aaaaa`, `shortest_match` may return `1` as opposed to `5`,
+the latter of which being the correct end location of the leftmost-first match.
+
+## Literals in your regex may make it faster
+
+**Advice**: Literals can reduce the work that the regex engine needs to do. Use
+them if you can, especially as prefixes.
+
+In particular, if your regex starts with a prefix literal, the prefix is
+quickly searched before entering the (much slower) regex engine. For example,
+given the regex `foo\w+`, the literal `foo` will be searched for using
+Boyer-Moore. If there's no match, then no regex engine is ever used. Only when
+there's a match is the regex engine invoked at the location of the match, which
+effectively permits the regex engine to skip large portions of a haystack.
+If a regex is comprised entirely of literals (possibly more than one), then
+it's possible that the regex engine can be avoided entirely even when there's a
+match.
+
+When one literal is found, Boyer-Moore is used. When multiple literals are
+found, then an optimized version of Aho-Corasick is used.
+
+This optimization is in particular extended quite a bit in this crate. Here are
+a few examples of regexes that get literal prefixes detected:
+
+* `(foo|bar)` detects `foo` and `bar`
+* `(a|b)c` detects `ac` and `bc`
+* `[ab]foo[yz]` detects `afooy`, `afooz`, `bfooy` and `bfooz`
+* `a?b` detects `a` and `b`
+* `a*b` detects `a` and `b`
+* `(ab){3,6}` detects `ababab`
+
+Literals in anchored regexes can also be used for detecting non-matches very
+quickly. For example, `^foo\w+` and `\w+foo$` may be able to detect a non-match
+just by examining the first (or last) three bytes of the haystack.
+
+## Unicode word boundaries may prevent the DFA from being used
+
+**Advice**: In most cases, `\b` should work well. If not, use `(?-u:\b)`
+instead of `\b` if you care about consistent performance more than correctness.
+
+It's a sad state of the current implementation. At the moment, the DFA will try
+to interpret Unicode word boundaries as if they were ASCII word boundaries.
+If the DFA comes across any non-ASCII byte, it will quit and fall back to an
+alternative matching engine that can handle Unicode word boundaries correctly.
+The alternate matching engine is generally quite a bit slower (perhaps by an
+order of magnitude). If necessary, this can be ameliorated in two ways.
+
+The first way is to add some number of literal prefixes to your regular
+expression. Even though the DFA may not be used, specialized routines will
+still kick in to find prefix literals quickly, which limits how much work the
+NFA simulation will need to do.
+
+The second way is to give up on Unicode and use an ASCII word boundary instead.
+One can use an ASCII word boundary by disabling Unicode support. That is,
+instead of using `\b`, use `(?-u:\b)`.  Namely, given the regex `\b.+\b`, it
+can be transformed into a regex that uses the DFA with `(?-u:\b).+(?-u:\b)`. It
+is important to limit the scope of disabling the `u` flag, since it might lead
+to a syntax error if the regex could match arbitrary bytes. For example, if one
+wrote `(?-u)\b.+\b`, then a syntax error would be returned because `.` matches
+any *byte* when the Unicode flag is disabled.
+
+The second way isn't appreciably different than just using a Unicode word
+boundary in the first place, since the DFA will speculatively interpret it as
+an ASCII word boundary anyway. The key difference is that if an ASCII word
+boundary is used explicitly, then the DFA won't quit in the presence of
+non-ASCII UTF-8 bytes. This results in giving up correctness in exchange for
+more consistent performance.
+
+N.B. When using `bytes::Regex`, Unicode support is disabled by default, so one
+can simply write `\b` to get an ASCII word boundary.
+
+## Excessive counting can lead to exponential state blow up in the DFA
+
+**Advice**: Don't write regexes that cause DFA state blow up if you care about
+match performance.
+
+Wait, didn't I say that this crate guards against exponential worst cases?
+Well, it turns out that the process of converting an NFA to a DFA can lead to
+an exponential blow up in the number of states. This crate specifically guards
+against exponential blow up by doing two things:
+
+1. The DFA is computed lazily. That is, a state in the DFA only exists in
+   memory if it is visited. In particular, the lazy DFA guarantees that *at
+   most* one state is created for every byte of input. This, on its own,
+   guarantees linear time complexity.
+2. Of course, creating a new state for *every* byte of input means that search
+   will go incredibly slow because of very large constant factors. On top of
+   that, creating a state for every byte in a large haystack could result in
+   exorbitant memory usage. To ameliorate this, the DFA bounds the number of
+   states it can store. Once it reaches its limit, it flushes its cache. This
+   prevents reuse of states that it already computed. If the cache is flushed
+   too frequently, then the DFA will give up and execution will fall back to
+   one of the NFA simulations.
+
+In effect, this crate will detect exponential state blow up and fall back to
+a search routine with fixed memory requirements. This does, however, mean that
+searching will be much slower than one might expect. Regexes that rely on
+counting in particular are strong aggravators of this behavior. For example,
+matching `[01]*1[01]{20}$` against a random sequence of `0`s and `1`s.
+
+In the future, it may be possible to increase the bound that the DFA uses,
+which would allow the caller to choose how much memory they're willing to
+spend.
+
+## Resist the temptation to "optimize" regexes
+
+**Advice**: This ain't a backtracking engine.
+
+An entire book was written on how to optimize Perl-style regular expressions.
+Most of those techniques are not applicable for this library. For example,
+there is no problem with using non-greedy matching or having lots of
+alternations in your regex.
diff --git a/crates/regex/README.md b/crates/regex/README.md
new file mode 100644
index 0000000..861417d
--- /dev/null
+++ b/crates/regex/README.md
@@ -0,0 +1,246 @@
+regex
+=====
+A Rust library for parsing, compiling, and executing regular expressions. Its
+syntax is similar to Perl-style regular expressions, but lacks a few features
+like look around and backreferences. In exchange, all searches execute in
+linear time with respect to the size of the regular expression and search text.
+Much of the syntax and implementation is inspired
+by [RE2](https://github.com/google/re2).
+
+[![Build status](https://github.com/rust-lang/regex/workflows/ci/badge.svg)](https://github.com/rust-lang/regex/actions)
+[![Crates.io](https://img.shields.io/crates/v/regex.svg)](https://crates.io/crates/regex)
+[![Rust](https://img.shields.io/badge/rust-1.41.1%2B-blue.svg?maxAge=3600)](https://github.com/rust-lang/regex)
+
+### Documentation
+
+[Module documentation with examples](https://docs.rs/regex).
+The module documentation also includes a comprehensive description of the
+syntax supported.
+
+Documentation with examples for the various matching functions and iterators
+can be found on the
+[`Regex` type](https://docs.rs/regex/*/regex/struct.Regex.html).
+
+### Usage
+
+To bring this crate into your repository, either add `regex` to your
+`Cargo.toml`, or run `cargo add regex`.
+
+Here's a simple example that matches a date in YYYY-MM-DD format and prints the
+year, month and day:
+
+```rust
+use regex::Regex;
+
+fn main() {
+    let re = Regex::new(r"(?x)
+(?P<year>\d{4})  # the year
+-
+(?P<month>\d{2}) # the month
+-
+(?P<day>\d{2})   # the day
+").unwrap();
+    let caps = re.captures("2010-03-14").unwrap();
+
+    assert_eq!("2010", &caps["year"]);
+    assert_eq!("03", &caps["month"]);
+    assert_eq!("14", &caps["day"]);
+}
+```
+
+If you have lots of dates in text that you'd like to iterate over, then it's
+easy to adapt the above example with an iterator:
+
+```rust
+use regex::Regex;
+
+const TO_SEARCH: &'static str = "
+On 2010-03-14, foo happened. On 2014-10-14, bar happened.
+";
+
+fn main() {
+    let re = Regex::new(r"(\d{4})-(\d{2})-(\d{2})").unwrap();
+
+    for caps in re.captures_iter(TO_SEARCH) {
+        // Note that all of the unwraps are actually OK for this regex
+        // because the only way for the regex to match is if all of the
+        // capture groups match. This is not true in general though!
+        println!("year: {}, month: {}, day: {}",
+                 caps.get(1).unwrap().as_str(),
+                 caps.get(2).unwrap().as_str(),
+                 caps.get(3).unwrap().as_str());
+    }
+}
+```
+
+This example outputs:
+
+```text
+year: 2010, month: 03, day: 14
+year: 2014, month: 10, day: 14
+```
+
+### Usage: Avoid compiling the same regex in a loop
+
+It is an anti-pattern to compile the same regular expression in a loop since
+compilation is typically expensive. (It takes anywhere from a few microseconds
+to a few **milliseconds** depending on the size of the regex.) Not only is
+compilation itself expensive, but this also prevents optimizations that reuse
+allocations internally to the matching engines.
+
+In Rust, it can sometimes be a pain to pass regular expressions around if
+they're used from inside a helper function. Instead, we recommend using the
+[`lazy_static`](https://crates.io/crates/lazy_static) crate to ensure that
+regular expressions are compiled exactly once.
+
+For example:
+
+```rust,ignore
+use regex::Regex;
+
+fn some_helper_function(text: &str) -> bool {
+    lazy_static! {
+        static ref RE: Regex = Regex::new("...").unwrap();
+    }
+    RE.is_match(text)
+}
+```
+
+Specifically, in this example, the regex will be compiled when it is used for
+the first time. On subsequent uses, it will reuse the previous compilation.
+
+### Usage: match regular expressions on `&[u8]`
+
+The main API of this crate (`regex::Regex`) requires the caller to pass a
+`&str` for searching. In Rust, an `&str` is required to be valid UTF-8, which
+means the main API can't be used for searching arbitrary bytes.
+
+To match on arbitrary bytes, use the `regex::bytes::Regex` API. The API
+is identical to the main API, except that it takes an `&[u8]` to search
+on instead of an `&str`. By default, `.` will match any *byte* using
+`regex::bytes::Regex`, while `.` will match any *UTF-8 encoded Unicode scalar
+value* using the main API.
+
+This example shows how to find all null-terminated strings in a slice of bytes:
+
+```rust
+use regex::bytes::Regex;
+
+let re = Regex::new(r"(?P<cstr>[^\x00]+)\x00").unwrap();
+let text = b"foo\x00bar\x00baz\x00";
+
+// Extract all of the strings without the null terminator from each match.
+// The unwrap is OK here since a match requires the `cstr` capture to match.
+let cstrs: Vec<&[u8]> =
+    re.captures_iter(text)
+      .map(|c| c.name("cstr").unwrap().as_bytes())
+      .collect();
+assert_eq!(vec![&b"foo"[..], &b"bar"[..], &b"baz"[..]], cstrs);
+```
+
+Notice here that the `[^\x00]+` will match any *byte* except for `NUL`. When
+using the main API, `[^\x00]+` would instead match any valid UTF-8 sequence
+except for `NUL`.
+
+### Usage: match multiple regular expressions simultaneously
+
+This demonstrates how to use a `RegexSet` to match multiple (possibly
+overlapping) regular expressions in a single scan of the search text:
+
+```rust
+use regex::RegexSet;
+
+let set = RegexSet::new(&[
+    r"\w+",
+    r"\d+",
+    r"\pL+",
+    r"foo",
+    r"bar",
+    r"barfoo",
+    r"foobar",
+]).unwrap();
+
+// Iterate over and collect all of the matches.
+let matches: Vec<_> = set.matches("foobar").into_iter().collect();
+assert_eq!(matches, vec![0, 2, 3, 4, 6]);
+
+// You can also test whether a particular regex matched:
+let matches = set.matches("foobar");
+assert!(!matches.matched(5));
+assert!(matches.matched(6));
+```
+
+### Usage: enable SIMD optimizations
+
+SIMD optimizations are enabled automatically on Rust stable 1.27 and newer.
+For nightly versions of Rust, this requires a recent version with the SIMD
+features stabilized.
+
+
+### Usage: a regular expression parser
+
+This repository contains a crate that provides a well tested regular expression
+parser, abstract syntax and a high-level intermediate representation for
+convenient analysis. It provides no facilities for compilation or execution.
+This may be useful if you're implementing your own regex engine or otherwise
+need to do analysis on the syntax of a regular expression. It is otherwise not
+recommended for general use.
+
+[Documentation `regex-syntax`.](https://docs.rs/regex-syntax)
+
+
+### Crate features
+
+This crate comes with several features that permit tweaking the trade off
+between binary size, compilation time and runtime performance. Users of this
+crate can selectively disable Unicode tables, or choose from a variety of
+optimizations performed by this crate to disable.
+
+When all of these features are disabled, runtime match performance may be much
+worse, but if you're matching on short strings, or if high performance isn't
+necessary, then such a configuration is perfectly serviceable. To disable
+all such features, use the following `Cargo.toml` dependency configuration:
+
+```toml
+[dependencies.regex]
+version = "1.3"
+default-features = false
+# regex currently requires the standard library, you must re-enable it.
+features = ["std"]
+```
+
+This will reduce the dependency tree of `regex` down to a single crate
+(`regex-syntax`).
+
+The full set of features one can disable are
+[in the "Crate features" section of the documentation](https://docs.rs/regex/*/#crate-features).
+
+
+### Minimum Rust version policy
+
+This crate's minimum supported `rustc` version is `1.41.1`.
+
+The current **tentative** policy is that the minimum Rust version required
+to use this crate can be increased in minor version updates. For example, if
+regex 1.0 requires Rust 1.20.0, then regex 1.0.z for all values of `z` will
+also require Rust 1.20.0 or newer. However, regex 1.y for `y > 0` may require a
+newer minimum version of Rust.
+
+In general, this crate will be conservative with respect to the minimum
+supported version of Rust.
+
+
+### License
+
+This project is licensed under either of
+
+ * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
+   https://www.apache.org/licenses/LICENSE-2.0)
+ * MIT license ([LICENSE-MIT](LICENSE-MIT) or
+   https://opensource.org/licenses/MIT)
+
+at your option.
+
+The data in `regex-syntax/src/unicode_tables/` is licensed under the Unicode
+License Agreement
+([LICENSE-UNICODE](https://www.unicode.org/copyright.html#License)).
diff --git a/crates/regex/TEST_MAPPING b/crates/regex/TEST_MAPPING
new file mode 100644
index 0000000..c99af76
--- /dev/null
+++ b/crates/regex/TEST_MAPPING
@@ -0,0 +1,102 @@
+// Generated by update_crate_tests.py for tests that depend on this crate.
+{
+  "imports": [
+    {
+      "path": "external/rust/crates/base64"
+    },
+    {
+      "path": "external/rust/crates/clap/2.33.3"
+    },
+    {
+      "path": "external/rust/crates/libsqlite3-sys"
+    },
+    {
+      "path": "external/rust/crates/once_cell"
+    },
+    {
+      "path": "external/rust/crates/tinytemplate"
+    },
+    {
+      "path": "external/rust/crates/tinyvec"
+    },
+    {
+      "path": "external/rust/crates/unicode-xid"
+    },
+    {
+      "path": "packages/modules/Virtualization/virtualizationmanager"
+    },
+    {
+      "path": "system/keymint/hal"
+    },
+    {
+      "path": "system/security/keystore2"
+    },
+    {
+      "path": "system/security/keystore2/legacykeystore"
+    }
+  ],
+  "presubmit": [
+    {
+      "name": "regex_test_src_lib"
+    },
+    {
+      "name": "regex_test_tests_test_backtrack"
+    },
+    {
+      "name": "regex_test_tests_test_backtrack_bytes"
+    },
+    {
+      "name": "regex_test_tests_test_backtrack_utf8bytes"
+    },
+    {
+      "name": "regex_test_tests_test_crates_regex"
+    },
+    {
+      "name": "regex_test_tests_test_default"
+    },
+    {
+      "name": "regex_test_tests_test_default_bytes"
+    },
+    {
+      "name": "regex_test_tests_test_nfa"
+    },
+    {
+      "name": "regex_test_tests_test_nfa_bytes"
+    },
+    {
+      "name": "regex_test_tests_test_nfa_utf8bytes"
+    }
+  ],
+  "presubmit-rust": [
+    {
+      "name": "regex_test_src_lib"
+    },
+    {
+      "name": "regex_test_tests_test_backtrack"
+    },
+    {
+      "name": "regex_test_tests_test_backtrack_bytes"
+    },
+    {
+      "name": "regex_test_tests_test_backtrack_utf8bytes"
+    },
+    {
+      "name": "regex_test_tests_test_crates_regex"
+    },
+    {
+      "name": "regex_test_tests_test_default"
+    },
+    {
+      "name": "regex_test_tests_test_default_bytes"
+    },
+    {
+      "name": "regex_test_tests_test_nfa"
+    },
+    {
+      "name": "regex_test_tests_test_nfa_bytes"
+    },
+    {
+      "name": "regex_test_tests_test_nfa_utf8bytes"
+    }
+  ]
+}
diff --git a/crates/regex/UNICODE.md b/crates/regex/UNICODE.md
new file mode 100644
index 0000000..df7d21e
--- /dev/null
+++ b/crates/regex/UNICODE.md
@@ -0,0 +1,259 @@
+# Unicode conformance
+
+This document describes the regex crate's conformance to Unicode's
+[UTS#18](https://unicode.org/reports/tr18/)
+report, which lays out 3 levels of support: Basic, Extended and Tailored.
+
+Full support for Level 1 ("Basic Unicode Support") is provided with two
+exceptions:
+
+1. Line boundaries are not Unicode aware. Namely, only the `\n`
+   (`END OF LINE`) character is recognized as a line boundary.
+2. The compatibility properties specified by
+   [RL1.2a](https://unicode.org/reports/tr18/#RL1.2a)
+   are ASCII-only definitions.
+
+Little to no support is provided for either Level 2 or Level 3. For the most
+part, this is because the features are either complex/hard to implement, or at
+the very least, very difficult to implement without sacrificing performance.
+For example, tackling canonical equivalence such that matching worked as one
+would expect regardless of normalization form would be a significant
+undertaking. This is at least partially a result of the fact that this regex
+engine is based on finite automata, which admits less flexibility normally
+associated with backtracking implementations.
+
+
+## RL1.1 Hex Notation
+
+[UTS#18 RL1.1](https://unicode.org/reports/tr18/#Hex_notation)
+
+Hex Notation refers to the ability to specify a Unicode code point in a regular
+expression via its hexadecimal code point representation. This is useful in
+environments that have poor Unicode font rendering or if you need to express a
+code point that is not normally displayable. All forms of hexadecimal notation
+are supported
+
+    \x7F        hex character code (exactly two digits)
+    \x{10FFFF}  any hex character code corresponding to a Unicode code point
+    \u007F      hex character code (exactly four digits)
+    \u{7F}      any hex character code corresponding to a Unicode code point
+    \U0000007F  hex character code (exactly eight digits)
+    \U{7F}      any hex character code corresponding to a Unicode code point
+
+Briefly, the `\x{...}`, `\u{...}` and `\U{...}` are all exactly equivalent ways
+of expressing hexadecimal code points. Any number of digits can be written
+within the brackets. In contrast, `\xNN`, `\uNNNN`, `\UNNNNNNNN` are all
+fixed-width variants of the same idea.
+
+Note that when Unicode mode is disabled, any non-ASCII Unicode codepoint is
+banned. Additionally, the `\xNN` syntax represents arbitrary bytes when Unicode
+mode is disabled. That is, the regex `\xFF` matches the Unicode codepoint
+U+00FF (encoded as `\xC3\xBF` in UTF-8) while the regex `(?-u)\xFF` matches
+the literal byte `\xFF`.
+
+
+## RL1.2 Properties
+
+[UTS#18 RL1.2](https://unicode.org/reports/tr18/#Categories)
+
+Full support for Unicode property syntax is provided. Unicode properties
+provide a convenient way to construct character classes of groups of code
+points specified by Unicode. The regex crate does not provide exhaustive
+support, but covers a useful subset. In particular:
+
+* [General categories](https://unicode.org/reports/tr18/#General_Category_Property)
+* [Scripts and Script Extensions](https://unicode.org/reports/tr18/#Script_Property)
+* [Age](https://unicode.org/reports/tr18/#Age)
+* A smattering of boolean properties, including all of those specified by
+  [RL1.2](https://unicode.org/reports/tr18/#RL1.2) explicitly.
+
+In all cases, property name and value abbreviations are supported, and all
+names/values are matched loosely without regard for case, whitespace or
+underscores. Property name aliases can be found in Unicode's
+[`PropertyAliases.txt`](https://www.unicode.org/Public/UCD/latest/ucd/PropertyAliases.txt)
+file, while property value aliases can be found in Unicode's
+[`PropertyValueAliases.txt`](https://www.unicode.org/Public/UCD/latest/ucd/PropertyValueAliases.txt)
+file.
+
+The syntax supported is also consistent with the UTS#18 recommendation:
+
+* `\p{Greek}` selects the `Greek` script. Equivalent expressions follow:
+  `\p{sc:Greek}`, `\p{Script:Greek}`, `\p{Sc=Greek}`, `\p{script=Greek}`,
+  `\P{sc!=Greek}`. Similarly for `General_Category` (or `gc` for short) and
+  `Script_Extensions` (or `scx` for short).
+* `\p{age:3.2}` selects all code points in Unicode 3.2.
+* `\p{Alphabetic}` selects the "alphabetic" property and can be abbreviated
+  via `\p{alpha}` (for example).
+* Single letter variants for properties with single letter abbreviations.
+  For example, `\p{Letter}` can be equivalently written as `\pL`.
+
+The following is a list of all properties supported by the regex crate (starred
+properties correspond to properties required by RL1.2):
+
+* `General_Category` \* (including `Any`, `ASCII` and `Assigned`)
+* `Script` \*
+* `Script_Extensions` \*
+* `Age`
+* `ASCII_Hex_Digit`
+* `Alphabetic` \*
+* `Bidi_Control`
+* `Case_Ignorable`
+* `Cased`
+* `Changes_When_Casefolded`
+* `Changes_When_Casemapped`
+* `Changes_When_Lowercased`
+* `Changes_When_Titlecased`
+* `Changes_When_Uppercased`
+* `Dash`
+* `Default_Ignorable_Code_Point` \*
+* `Deprecated`
+* `Diacritic`
+* `Emoji`
+* `Emoji_Presentation`
+* `Emoji_Modifier`
+* `Emoji_Modifier_Base`
+* `Emoji_Component`
+* `Extended_Pictographic`
+* `Extender`
+* `Grapheme_Base`
+* `Grapheme_Cluster_Break`
+* `Grapheme_Extend`
+* `Hex_Digit`
+* `IDS_Binary_Operator`
+* `IDS_Trinary_Operator`
+* `ID_Continue`
+* `ID_Start`
+* `Join_Control`
+* `Logical_Order_Exception`
+* `Lowercase` \*
+* `Math`
+* `Noncharacter_Code_Point` \*
+* `Pattern_Syntax`
+* `Pattern_White_Space`
+* `Prepended_Concatenation_Mark`
+* `Quotation_Mark`
+* `Radical`
+* `Regional_Indicator`
+* `Sentence_Break`
+* `Sentence_Terminal`
+* `Soft_Dotted`
+* `Terminal_Punctuation`
+* `Unified_Ideograph`
+* `Uppercase` \*
+* `Variation_Selector`
+* `White_Space` \*
+* `Word_Break`
+* `XID_Continue`
+* `XID_Start`
+
+
+## RL1.2a Compatibility Properties
+
+[UTS#18 RL1.2a](https://unicode.org/reports/tr18/#RL1.2a)
+
+The regex crate only provides ASCII definitions of the
+[compatibility properties documented in UTS#18 Annex C](https://unicode.org/reports/tr18/#Compatibility_Properties)
+(sans the `\X` class, for matching grapheme clusters, which isn't provided
+at all). This is because it seems to be consistent with most other regular
+expression engines, and in particular, because these are often referred to as
+"ASCII" or "POSIX" character classes.
+
+Note that the `\w`, `\s` and `\d` character classes **are** Unicode aware.
+Their traditional ASCII definition can be used by disabling Unicode. That is,
+`[[:word:]]` and `(?-u)\w` are equivalent.
+
+
+## RL1.3 Subtraction and Intersection
+
+[UTS#18 RL1.3](https://unicode.org/reports/tr18/#Subtraction_and_Intersection)
+
+The regex crate provides full support for nested character classes, along with
+union, intersection (`&&`), difference (`--`) and symmetric difference (`~~`)
+operations on arbitrary character classes.
+
+For example, to match all non-ASCII letters, you could use either
+`[\p{Letter}--\p{Ascii}]` (difference) or `[\p{Letter}&&[^\p{Ascii}]]`
+(intersecting the negation).
+
+
+## RL1.4 Simple Word Boundaries
+
+[UTS#18 RL1.4](https://unicode.org/reports/tr18/#Simple_Word_Boundaries)
+
+The regex crate provides basic Unicode aware word boundary assertions. A word
+boundary assertion can be written as `\b`, or `\B` as its negation. A word
+boundary negation corresponds to a zero-width match, where its adjacent
+characters correspond to word and non-word, or non-word and word characters.
+
+Conformance in this case chooses to define word character in the same way that
+the `\w` character class is defined: a code point that is a member of one of
+the following classes:
+
+* `\p{Alphabetic}`
+* `\p{Join_Control}`
+* `\p{gc:Mark}`
+* `\p{gc:Decimal_Number}`
+* `\p{gc:Connector_Punctuation}`
+
+In particular, this differs slightly from the
+[prescription given in RL1.4](https://unicode.org/reports/tr18/#Simple_Word_Boundaries)
+but is permissible according to
+[UTS#18 Annex C](https://unicode.org/reports/tr18/#Compatibility_Properties).
+Namely, it is convenient and simpler to have `\w` and `\b` be in sync with
+one another.
+
+Finally, Unicode word boundaries can be disabled, which will cause ASCII word
+boundaries to be used instead. That is, `\b` is a Unicode word boundary while
+`(?-u)\b` is an ASCII-only word boundary. This can occasionally be beneficial
+if performance is important, since the implementation of Unicode word
+boundaries is currently sub-optimal on non-ASCII text.
+
+
+## RL1.5 Simple Loose Matches
+
+[UTS#18 RL1.5](https://unicode.org/reports/tr18/#Simple_Loose_Matches)
+
+The regex crate provides full support for case insensitive matching in
+accordance with RL1.5. That is, it uses the "simple" case folding mapping. The
+"simple" mapping was chosen because of a key convenient property: every
+"simple" mapping is a mapping from exactly one code point to exactly one other
+code point. This makes case insensitive matching of character classes, for
+example, straight-forward to implement.
+
+When case insensitive mode is enabled (e.g., `(?i)[a]` is equivalent to `a|A`),
+then all characters classes are case folded as well.
+
+
+## RL1.6 Line Boundaries
+
+[UTS#18 RL1.6](https://unicode.org/reports/tr18/#Line_Boundaries)
+
+The regex crate only provides support for recognizing the `\n` (`END OF LINE`)
+character as a line boundary. This choice was made mostly for implementation
+convenience, and to avoid performance cliffs that Unicode word boundaries are
+subject to.
+
+Ideally, it would be nice to at least support `\r\n` as a line boundary as
+well, and in theory, this could be done efficiently.
+
+
+## RL1.7 Code Points
+
+[UTS#18 RL1.7](https://unicode.org/reports/tr18/#Supplementary_Characters)
+
+The regex crate provides full support for Unicode code point matching. Namely,
+the fundamental atom of any match is always a single code point.
+
+Given Rust's strong ties to UTF-8, the following guarantees are also provided:
+
+* All matches are reported on valid UTF-8 code unit boundaries. That is, any
+  match range returned by the public regex API is guaranteed to successfully
+  slice the string that was searched.
+* By consequence of the above, it is impossible to match surrogode code points.
+  No support for UTF-16 is provided, so this is never necessary.
+
+Note that when Unicode mode is disabled, the fundamental atom of matching is
+no longer a code point but a single byte. When Unicode mode is disabled, many
+Unicode features are disabled as well. For example, `(?-u)\pL` is not a valid
+regex but `\pL(?-u)\xFF` (matches any Unicode `Letter` followed by the literal
+byte `\xFF`) is, for example.
diff --git a/crates/regex/cargo_embargo.json b/crates/regex/cargo_embargo.json
new file mode 100644
index 0000000..5b612a5
--- /dev/null
+++ b/crates/regex/cargo_embargo.json
@@ -0,0 +1,8 @@
+{
+  "apex_available": [
+    "//apex_available:anyapex",
+    "//apex_available:platform"
+  ],
+  "run_cargo": false,
+  "tests": true
+}
diff --git a/crates/regex/examples/regexdna-input.txt b/crates/regex/examples/regexdna-input.txt
new file mode 100644
index 0000000..fb23263
--- /dev/null
+++ b/crates/regex/examples/regexdna-input.txt
@@ -0,0 +1,1671 @@
+>ONE Homo sapiens alu
+GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
+TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
+AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
+GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
+CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
+GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
+GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
+TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
+AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
+GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
+AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
+AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
+GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
+CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
+AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
+TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
+TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
+GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
+TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
+CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
+CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
+TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
+CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
+AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
+GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
+TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
+TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
+GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
+GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
+ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
+TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
+CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
+CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
+GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
+CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
+GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
+GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
+GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
+GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
+GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
+AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
+CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
+GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
+AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
+GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
+ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
+GAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATC
+GCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGC
+GGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG
+TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAA
+AAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAG
+GAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACT
+CCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCC
+TGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAG
+ACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGC
+GTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGA
+ACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGA
+CAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCA
+CTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCA
+ACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCG
+CCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGG
+AGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTC
+CGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCG
+AGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACC
+CCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAG
+CTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAG
+CCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGG
+CCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATC
+ACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAA
+AAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGC
+TGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCC
+ACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGG
+CTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGG
+AGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATT
+AGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAA
+TCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGC
+CTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAA
+TCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAG
+CCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGT
+GGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCG
+GGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAG
+CGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG
+GGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATG
+GTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGT
+AATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTT
+GCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCT
+CAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCG
+GGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTC
+TCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACT
+CGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAG
+ATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGG
+CGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTG
+AGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATA
+CAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGG
+CAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGC
+ACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCAC
+GCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTC
+GAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCG
+GGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCT
+TGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGG
+CGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCA
+GCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGG
+CCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGC
+GCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGG
+CGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGA
+CTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGG
+CCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAA
+ACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCC
+CAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGT
+GAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAA
+AGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGG
+ATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTAC
+TAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGA
+GGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGC
+GCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGG
+TGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTC
+AGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAA
+ATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGA
+GAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC
+AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTG
+TAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGAC
+CAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGT
+GGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAAC
+CCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACA
+GAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACT
+TTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAAC
+ATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCC
+TGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAG
+GTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCG
+TCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAG
+GCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCC
+GTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCT
+ACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCC
+GAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCC
+GGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCAC
+CTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAA
+ATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTG
+AGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCAC
+TGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCT
+CACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAG
+TTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAG
+CCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATC
+GCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCT
+GGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATC
+CCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCC
+TGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGG
+CGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG
+AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCG
+AGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGG
+AGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGT
+GAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAA
+TCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGC
+AGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCA
+AAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGG
+CGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTC
+TACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCG
+GGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGAT
+CGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCG
+CGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAG
+GTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACA
+AAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCA
+GGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCAC
+TCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGC
+CTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGA
+GACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG
+CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTG
+AACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCG
+ACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGC
+ACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCC
+AACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGC
+GCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCG
+GAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACT
+CCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCC
+GAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAAC
+CCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA
+GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGA
+GCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
+GCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGAT
+CACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTA
+AAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGG
+CTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGC
+CACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTG
+GCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAG
+GAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAAT
+TAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGA
+ATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAG
+CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTA
+ATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCA
+GCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGG
+TGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCC
+GGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGA
+GCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTT
+GGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACAT
+GGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTG
+TAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGT
+TGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTC
+TCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGC
+GGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGT
+CTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTAC
+TCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGA
+GATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGG
+GCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCT
+GAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT
+ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAG
+GCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTG
+CACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCA
+CGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTT
+CGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCC
+GGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGC
+TTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGG
+GCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCC
+AGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTG
+GCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCG
+CGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAG
+GCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAG
+ACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAG
+GCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGA
+AACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATC
+CCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAG
+TGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
+AAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCG
+GATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTA
+CTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGG
+AGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCG
+CGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCG
+GTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGT
+CAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAA
+AATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGG
+AGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTC
+CAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCT
+GTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA
+CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCG
+TGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAA
+CCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGAC
+AGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCAC
+TTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAA
+CATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGC
+CTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGA
+GGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCC
+GTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGA
+GGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCC
+CGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGC
+TACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGC
+CGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGC
+CGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCA
+CCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAA
+AATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCT
+GAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCA
+CTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGC
+TCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGA
+GTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTA
+GCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAAT
+CGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCC
+TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAAT
+CCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGC
+CTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTG
+GCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGG
+GAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGC
+GAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG
+GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGG
+TGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTA
+ATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTG
+CAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTC
+AAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGG
+GCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCT
+CTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTC
+GGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGA
+TCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGC
+GCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGA
+GGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATAC
+AAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGC
+AGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCA
+CTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACG
+CCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCG
+AGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGG
+GCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTT
+GAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGC
+GACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAG
+CACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGC
+CAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCG
+CGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC
+GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGAC
+TCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGC
+CGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAA
+CCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCC
+AGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTG
+AGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA
+GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
+TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
+AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
+GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
+CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
+GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
+GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
+TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
+AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
+GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
+AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
+AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
+GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
+CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
+AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
+TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
+TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
+GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
+TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
+CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
+CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
+TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
+CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
+AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
+GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
+TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
+TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
+GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
+GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
+ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
+TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
+CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
+CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
+GGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCC
+CAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCT
+GGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGC
+GCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGA
+GGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGA
+GACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGA
+GGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTG
+AAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAAT
+CCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCA
+GTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAA
+AAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGC
+GGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCT
+ACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGG
+GAGGCTGAGGCAGGAGAATC
+>TWO IUB ambiguity codes
+cttBtatcatatgctaKggNcataaaSatgtaaaDcDRtBggDtctttataattcBgtcg
+tactDtDagcctatttSVHtHttKtgtHMaSattgWaHKHttttagacatWatgtRgaaa
+NtactMcSMtYtcMgRtacttctWBacgaaatatagScDtttgaagacacatagtVgYgt
+cattHWtMMWcStgttaggKtSgaYaaccWStcgBttgcgaMttBYatcWtgacaYcaga
+gtaBDtRacttttcWatMttDBcatWtatcttactaBgaYtcttgttttttttYaaScYa
+HgtgttNtSatcMtcVaaaStccRcctDaataataStcYtRDSaMtDttgttSagtRRca
+tttHatSttMtWgtcgtatSSagactYaaattcaMtWatttaSgYttaRgKaRtccactt
+tattRggaMcDaWaWagttttgacatgttctacaaaRaatataataaMttcgDacgaSSt
+acaStYRctVaNMtMgtaggcKatcttttattaaaaagVWaHKYagtttttatttaacct
+tacgtVtcVaattVMBcttaMtttaStgacttagattWWacVtgWYagWVRctDattBYt
+gtttaagaagattattgacVatMaacattVctgtBSgaVtgWWggaKHaatKWcBScSWa
+accRVacacaaactaccScattRatatKVtactatatttHttaagtttSKtRtacaaagt
+RDttcaaaaWgcacatWaDgtDKacgaacaattacaRNWaatHtttStgttattaaMtgt
+tgDcgtMgcatBtgcttcgcgaDWgagctgcgaggggVtaaScNatttacttaatgacag
+cccccacatYScaMgtaggtYaNgttctgaMaacNaMRaacaaacaKctacatagYWctg
+ttWaaataaaataRattagHacacaagcgKatacBttRttaagtatttccgatctHSaat
+actcNttMaagtattMtgRtgaMgcataatHcMtaBSaRattagttgatHtMttaaKagg
+YtaaBataSaVatactWtataVWgKgttaaaacagtgcgRatatacatVtHRtVYataSa
+KtWaStVcNKHKttactatccctcatgWHatWaRcttactaggatctataDtDHBttata
+aaaHgtacVtagaYttYaKcctattcttcttaataNDaaggaaaDYgcggctaaWSctBa
+aNtgctggMBaKctaMVKagBaactaWaDaMaccYVtNtaHtVWtKgRtcaaNtYaNacg
+gtttNattgVtttctgtBaWgtaattcaagtcaVWtactNggattctttaYtaaagccgc
+tcttagHVggaYtgtNcDaVagctctctKgacgtatagYcctRYHDtgBattDaaDgccK
+tcHaaStttMcctagtattgcRgWBaVatHaaaataYtgtttagMDMRtaataaggatMt
+ttctWgtNtgtgaaaaMaatatRtttMtDgHHtgtcattttcWattRSHcVagaagtacg
+ggtaKVattKYagactNaatgtttgKMMgYNtcccgSKttctaStatatNVataYHgtNa
+BKRgNacaactgatttcctttaNcgatttctctataScaHtataRagtcRVttacDSDtt
+aRtSatacHgtSKacYagttMHtWataggatgactNtatSaNctataVtttRNKtgRacc
+tttYtatgttactttttcctttaaacatacaHactMacacggtWataMtBVacRaSaatc
+cgtaBVttccagccBcttaRKtgtgcctttttRtgtcagcRttKtaaacKtaaatctcac
+aattgcaNtSBaaccgggttattaaBcKatDagttactcttcattVtttHaaggctKKga
+tacatcBggScagtVcacattttgaHaDSgHatRMaHWggtatatRgccDttcgtatcga
+aacaHtaagttaRatgaVacttagattVKtaaYttaaatcaNatccRttRRaMScNaaaD
+gttVHWgtcHaaHgacVaWtgttScactaagSgttatcttagggDtaccagWattWtRtg
+ttHWHacgattBtgVcaYatcggttgagKcWtKKcaVtgaYgWctgYggVctgtHgaNcV
+taBtWaaYatcDRaaRtSctgaHaYRttagatMatgcatttNattaDttaattgttctaa
+ccctcccctagaWBtttHtBccttagaVaatMcBHagaVcWcagBVttcBtaYMccagat
+gaaaaHctctaacgttagNWRtcggattNatcRaNHttcagtKttttgWatWttcSaNgg
+gaWtactKKMaacatKatacNattgctWtatctaVgagctatgtRaHtYcWcttagccaa
+tYttWttaWSSttaHcaaaaagVacVgtaVaRMgattaVcDactttcHHggHRtgNcctt
+tYatcatKgctcctctatVcaaaaKaaaagtatatctgMtWtaaaacaStttMtcgactt
+taSatcgDataaactaaacaagtaaVctaggaSccaatMVtaaSKNVattttgHccatca
+cBVctgcaVatVttRtactgtVcaattHgtaaattaaattttYtatattaaRSgYtgBag
+aHSBDgtagcacRHtYcBgtcacttacactaYcgctWtattgSHtSatcataaatataHt
+cgtYaaMNgBaatttaRgaMaatatttBtttaaaHHKaatctgatWatYaacttMctctt
+ttVctagctDaaagtaVaKaKRtaacBgtatccaaccactHHaagaagaaggaNaaatBW
+attccgStaMSaMatBttgcatgRSacgttVVtaaDMtcSgVatWcaSatcttttVatag
+ttactttacgatcaccNtaDVgSRcgVcgtgaacgaNtaNatatagtHtMgtHcMtagaa
+attBgtataRaaaacaYKgtRccYtatgaagtaataKgtaaMttgaaRVatgcagaKStc
+tHNaaatctBBtcttaYaBWHgtVtgacagcaRcataWctcaBcYacYgatDgtDHccta
+aagacYRcaggattHaYgtKtaatgcVcaataMYacccatatcacgWDBtgaatcBaata
+cKcttRaRtgatgaBDacggtaattaaYtataStgVHDtDctgactcaaatKtacaatgc
+gYatBtRaDatHaactgtttatatDttttaaaKVccYcaaccNcBcgHaaVcattHctcg
+attaaatBtatgcaaaaatYMctSactHatacgaWacattacMBgHttcgaatVaaaaca
+BatatVtctgaaaaWtctRacgBMaatSgRgtgtcgactatcRtattaScctaStagKga
+DcWgtYtDDWKRgRtHatRtggtcgaHgggcgtattaMgtcagccaBggWVcWctVaaat
+tcgNaatcKWagcNaHtgaaaSaaagctcYctttRVtaaaatNtataaccKtaRgtttaM
+tgtKaBtRtNaggaSattHatatWactcagtgtactaKctatttgRYYatKatgtccgtR
+tttttatttaatatVgKtttgtatgtNtataRatWYNgtRtHggtaaKaYtKSDcatcKg
+taaYatcSRctaVtSMWtVtRWHatttagataDtVggacagVcgKWagBgatBtaaagNc
+aRtagcataBggactaacacRctKgttaatcctHgDgttKHHagttgttaatgHBtatHc
+DaagtVaBaRccctVgtgDtacRHSctaagagcggWYaBtSaKtHBtaaactYacgNKBa
+VYgtaacttagtVttcttaatgtBtatMtMtttaattaatBWccatRtttcatagVgMMt
+agctStKctaMactacDNYgKYHgaWcgaHgagattacVgtttgtRaSttaWaVgataat
+gtgtYtaStattattMtNgWtgttKaccaatagNYttattcgtatHcWtctaaaNVYKKt
+tWtggcDtcgaagtNcagatacgcattaagaccWctgcagcttggNSgaNcHggatgtVt
+catNtRaaBNcHVagagaaBtaaSggDaatWaatRccaVgggStctDaacataKttKatt
+tggacYtattcSatcttagcaatgaVBMcttDattctYaaRgatgcattttNgVHtKcYR
+aatRKctgtaaacRatVSagctgtWacBtKVatctgttttKcgtctaaDcaagtatcSat
+aWVgcKKataWaYttcccSaatgaaaacccWgcRctWatNcWtBRttYaattataaNgac
+acaatagtttVNtataNaYtaatRaVWKtBatKagtaatataDaNaaaaataMtaagaaS
+tccBcaatNgaataWtHaNactgtcDtRcYaaVaaaaaDgtttRatctatgHtgttKtga
+aNSgatactttcgagWaaatctKaaDaRttgtggKKagcDgataaattgSaacWaVtaNM
+acKtcaDaaatttctRaaVcagNacaScRBatatctRatcctaNatWgRtcDcSaWSgtt
+RtKaRtMtKaatgttBHcYaaBtgatSgaSWaScMgatNtctcctatttctYtatMatMt
+RRtSaattaMtagaaaaStcgVgRttSVaScagtgDtttatcatcatacRcatatDctta
+tcatVRtttataaHtattcYtcaaaatactttgVctagtaaYttagatagtSYacKaaac
+gaaKtaaatagataatSatatgaaatSgKtaatVtttatcctgKHaatHattagaaccgt
+YaaHactRcggSBNgtgctaaBagBttgtRttaaattYtVRaaaattgtaatVatttctc
+ttcatgBcVgtgKgaHaaatattYatagWacNctgaaMcgaattStagWaSgtaaKagtt
+ttaagaDgatKcctgtaHtcatggKttVDatcaaggtYcgccagNgtgcVttttagagat
+gctaccacggggtNttttaSHaNtatNcctcatSaaVgtactgBHtagcaYggYVKNgta
+KBcRttgaWatgaatVtagtcgattYgatgtaatttacDacSctgctaaaStttaWMagD
+aaatcaVYctccgggcgaVtaaWtStaKMgDtttcaaMtVgBaatccagNaaatcYRMBg
+gttWtaaScKttMWtYataRaDBMaDataatHBcacDaaKDactaMgagttDattaHatH
+taYatDtattDcRNStgaatattSDttggtattaaNSYacttcDMgYgBatWtaMagact
+VWttctttgYMaYaacRgHWaattgRtaagcattctMKVStatactacHVtatgatcBtV
+NataaBttYtSttacKgggWgYDtgaVtYgatDaacattYgatggtRDaVDttNactaSa
+MtgNttaacaaSaBStcDctaccacagacgcaHatMataWKYtaYattMcaMtgSttDag
+cHacgatcaHttYaKHggagttccgatYcaatgatRaVRcaagatcagtatggScctata
+ttaNtagcgacgtgKaaWaactSgagtMYtcttccaKtStaacggMtaagNttattatcg
+tctaRcactctctDtaacWYtgaYaSaagaWtNtatttRacatgNaatgttattgWDDcN
+aHcctgaaHacSgaataaRaataMHttatMtgaSDSKatatHHaNtacagtccaYatWtc
+actaactatKDacSaStcggataHgYatagKtaatKagStaNgtatactatggRHacttg
+tattatgtDVagDVaRctacMYattDgtttYgtctatggtKaRSttRccRtaaccttaga
+gRatagSaaMaacgcaNtatgaaatcaRaagataatagatactcHaaYKBctccaagaRa
+BaStNagataggcgaatgaMtagaatgtcaKttaaatgtaWcaBttaatRcggtgNcaca
+aKtttScRtWtgcatagtttWYaagBttDKgcctttatMggNttattBtctagVtacata
+aaYttacacaaRttcYtWttgHcaYYtaMgBaBatctNgcDtNttacgacDcgataaSat
+YaSttWtcctatKaatgcagHaVaacgctgcatDtgttaSataaaaYSNttatagtaNYt
+aDaaaNtggggacttaBggcHgcgtNtaaMcctggtVtaKcgNacNtatVaSWctWtgaW
+cggNaBagctctgaYataMgaagatBSttctatacttgtgtKtaattttRagtDtacata
+tatatgatNHVgBMtKtaKaNttDHaagatactHaccHtcatttaaagttVaMcNgHata
+tKtaNtgYMccttatcaaNagctggacStttcNtggcaVtattactHaSttatgNMVatt
+MMDtMactattattgWMSgtHBttStStgatatRaDaagattttctatMtaaaaaggtac
+taaVttaSacNaatactgMttgacHaHRttgMacaaaatagttaatatWKRgacDgaRta
+tatttattatcYttaWtgtBRtWatgHaaattHataagtVaDtWaVaWtgStcgtMSgaS
+RgMKtaaataVacataatgtaSaatttagtcgaaHtaKaatgcacatcggRaggSKctDc
+agtcSttcccStYtccRtctctYtcaaKcgagtaMttttcRaYDttgttatctaatcata
+NctctgctatcaMatactataggDaHaaSttMtaDtcNatataattctMcStaaBYtaNa
+gatgtaatHagagSttgWHVcttatKaYgDctcttggtgttMcRaVgSgggtagacaata
+aDtaattSaDaNaHaBctattgNtaccaaRgaVtKNtaaYggHtaKKgHcatctWtctDt
+ttctttggSDtNtaStagttataaacaattgcaBaBWggHgcaaaBtYgctaatgaaatW
+cDcttHtcMtWWattBHatcatcaaatctKMagtDNatttWaBtHaaaNgMttaaStagt
+tctctaatDtcRVaYttgttMtRtgtcaSaaYVgSWDRtaatagctcagDgcWWaaaBaa
+RaBctgVgggNgDWStNaNBKcBctaaKtttDcttBaaggBttgaccatgaaaNgttttt
+tttatctatgttataccaaDRaaSagtaVtDtcaWatBtacattaWacttaSgtattggD
+gKaaatScaattacgWcagKHaaccaYcRcaRttaDttRtttHgaHVggcttBaRgtccc
+tDatKaVtKtcRgYtaKttacgtatBtStaagcaattaagaRgBagSaattccSWYttta
+ttVaataNctgHgttaaNBgcVYgtRtcccagWNaaaacaDNaBcaaaaRVtcWMgBagM
+tttattacgDacttBtactatcattggaaatVccggttRttcatagttVYcatYaSHaHc
+ttaaagcNWaHataaaRWtctVtRYtagHtaaaYMataHYtNBctNtKaatattStgaMc
+BtRgctaKtgcScSttDgYatcVtggaaKtaagatWccHccgKYctaNNctacaWctttt
+gcRtgtVcgaKttcMRHgctaHtVaataaDtatgKDcttatBtDttggNtacttttMtga
+acRattaaNagaactcaaaBBVtcDtcgaStaDctgaaaSgttMaDtcgttcaccaaaag
+gWtcKcgSMtcDtatgtttStaaBtatagDcatYatWtaaaBacaKgcaDatgRggaaYc
+taRtccagattDaWtttggacBaVcHtHtaacDacYgtaatataMagaatgHMatcttat
+acgtatttttatattacHactgttataMgStYaattYaccaattgagtcaaattaYtgta
+tcatgMcaDcgggtcttDtKgcatgWRtataatatRacacNRBttcHtBgcRttgtgcgt
+catacMtttBctatctBaatcattMttMYgattaaVYatgDaatVagtattDacaacDMa
+tcMtHcccataagatgBggaccattVWtRtSacatgctcaaggggYtttDtaaNgNtaaB
+atggaatgtctRtaBgBtcNYatatNRtagaacMgagSaSDDSaDcctRagtVWSHtVSR
+ggaacaBVaccgtttaStagaacaMtactccagtttVctaaRaaHttNcttagcaattta
+ttaatRtaaaatctaacDaBttggSagagctacHtaaRWgattcaaBtctRtSHaNtgta
+cattVcaHaNaagtataccacaWtaRtaaVKgMYaWgttaKggKMtKcgWatcaDatYtK
+SttgtacgaccNctSaattcDcatcttcaaaDKttacHtggttHggRRaRcaWacaMtBW
+VHSHgaaMcKattgtaRWttScNattBBatYtaNRgcggaagacHSaattRtttcYgacc
+BRccMacccKgatgaacttcgDgHcaaaaaRtatatDtatYVtttttHgSHaSaatagct
+NYtaHYaVYttattNtttgaaaYtaKttWtctaNtgagaaaNctNDctaaHgttagDcRt
+tatagccBaacgcaRBtRctRtggtaMYYttWtgataatcgaataattattataVaaaaa
+ttacNRVYcaaMacNatRttcKatMctgaagactaattataaYgcKcaSYaatMNctcaa
+cgtgatttttBacNtgatDccaattattKWWcattttatatatgatBcDtaaaagttgaa
+VtaHtaHHtBtataRBgtgDtaataMttRtDgDcttattNtggtctatctaaBcatctaR
+atgNacWtaatgaagtcMNaacNgHttatactaWgcNtaStaRgttaaHacccgaYStac
+aaaatWggaYaWgaattattcMaactcBKaaaRVNcaNRDcYcgaBctKaacaaaaaSgc
+tccYBBHYaVagaatagaaaacagYtctVccaMtcgtttVatcaatttDRtgWctagtac
+RttMctgtDctttcKtWttttataaatgVttgBKtgtKWDaWagMtaaagaaattDVtag
+gttacatcatttatgtcgMHaVcttaBtVRtcgtaYgBRHatttHgaBcKaYWaatcNSc
+tagtaaaaatttacaatcactSWacgtaatgKttWattagttttNaggtctcaagtcact
+attcttctaagKggaataMgtttcataagataaaaatagattatDgcBVHWgaBKttDgc
+atRHaagcaYcRaattattatgtMatatattgHDtcaDtcaaaHctStattaatHaccga
+cNattgatatattttgtgtDtRatagSacaMtcRtcattcccgacacSattgttKaWatt
+NHcaacttccgtttSRtgtctgDcgctcaaMagVtBctBMcMcWtgtaacgactctcttR
+ggRKSttgYtYatDccagttDgaKccacgVatWcataVaaagaataMgtgataaKYaaat
+cHDaacgataYctRtcYatcgcaMgtNttaBttttgatttaRtStgcaacaaaataccVg
+aaDgtVgDcStctatatttattaaaaRKDatagaaagaKaaYYcaYSgKStctccSttac
+agtcNactttDVttagaaagMHttRaNcSaRaMgBttattggtttaRMggatggcKDgWR
+tNaataataWKKacttcKWaaagNaBttaBatMHtccattaacttccccYtcBcYRtaga
+ttaagctaaYBDttaNtgaaaccHcaRMtKtaaHMcNBttaNaNcVcgVttWNtDaBatg
+ataaVtcWKcttRggWatcattgaRagHgaattNtatttctctattaattaatgaDaaMa
+tacgttgggcHaYVaaNaDDttHtcaaHtcVVDgBVagcMacgtgttaaBRNtatRtcag
+taagaggtttaagacaVaaggttaWatctccgtVtaDtcDatttccVatgtacNtttccg
+tHttatKgScBatgtVgHtYcWagcaKtaMYaaHgtaattaSaHcgcagtWNaatNccNN
+YcacgVaagaRacttctcattcccRtgtgtaattagcSttaaStWaMtctNNcSMacatt
+ataaactaDgtatWgtagtttaagaaaattgtagtNagtcaataaatttgatMMYactaa
+tatcggBWDtVcYttcDHtVttatacYaRgaMaacaStaatcRttttVtagaDtcacWat
+ttWtgaaaagaaagNRacDtttStVatBaDNtaactatatcBSMcccaSttccggaMatg
+attaaWatKMaBaBatttgataNctgttKtVaagtcagScgaaaDggaWgtgttttKtWt
+atttHaatgtagttcactaaKMagttSYBtKtaYgaactcagagRtatagtVtatcaaaW
+YagcgNtaDagtacNSaaYDgatBgtcgataacYDtaaactacagWDcYKaagtttatta
+gcatcgagttKcatDaattgattatDtcagRtWSKtcgNtMaaaaacaMttKcaWcaaSV
+MaaaccagMVtaMaDtMaHaBgaacataBBVtaatVYaNSWcSgNtDNaaKacacBttta
+tKtgtttcaaHaMctcagtaacgtcgYtactDcgcctaNgagagcYgatattttaaattt
+ccattttacatttDaaRctattttWctttacgtDatYtttcagacgcaaVttagtaaKaa
+aRtgVtccataBggacttatttgtttaWNtgttVWtaWNVDaattgtatttBaagcBtaa
+BttaaVatcHcaVgacattccNggtcgacKttaaaRtagRtctWagaYggtgMtataatM
+tgaaRttattttgWcttNtDRRgMDKacagaaaaggaaaRStcccagtYccVattaNaaK
+StNWtgacaVtagaagcttSaaDtcacaacgDYacWDYtgtttKatcVtgcMaDaSKStV
+cgtagaaWaKaagtttcHaHgMgMtctataagBtKaaaKKcactggagRRttaagaBaaN
+atVVcgRcKSttDaactagtSttSattgttgaaRYatggttVttaataaHttccaagDtg
+atNWtaagHtgcYtaactRgcaatgMgtgtRaatRaNaacHKtagactactggaatttcg
+ccataacgMctRgatgttaccctaHgtgWaYcactcacYaattcttaBtgacttaaacct
+gYgaWatgBttcttVttcgttWttMcNYgtaaaatctYgMgaaattacNgaHgaacDVVM
+tttggtHtctaaRgtacagacgHtVtaBMNBgattagcttaRcttacaHcRctgttcaaD
+BggttKaacatgKtttYataVaNattccgMcgcgtagtRaVVaattaKaatggttRgaMc
+agtatcWBttNtHagctaatctagaaNaaacaYBctatcgcVctBtgcaaagDgttVtga
+HtactSNYtaaNccatgtgDacgaVtDcgKaRtacDcttgctaagggcagMDagggtBWR
+tttSgccttttttaacgtcHctaVtVDtagatcaNMaVtcVacatHctDWNaataRgcgt
+aVHaggtaaaaSgtttMtattDgBtctgatSgtRagagYtctSaKWaataMgattRKtaa
+catttYcgtaacacattRWtBtcggtaaatMtaaacBatttctKagtcDtttgcBtKYYB
+aKttctVttgttaDtgattttcttccacttgSaaacggaaaNDaattcYNNaWcgaaYat
+tttMgcBtcatRtgtaaagatgaWtgaccaYBHgaatagataVVtHtttVgYBtMctaMt
+cctgaDcYttgtccaaaRNtacagcMctKaaaggatttacatgtttaaWSaYaKttBtag
+DacactagctMtttNaKtctttcNcSattNacttggaacaatDagtattRtgSHaataat
+gccVgacccgatactatccctgtRctttgagaSgatcatatcgDcagWaaHSgctYYWta
+tHttggttctttatVattatcgactaagtgtagcatVgtgHMtttgtttcgttaKattcM
+atttgtttWcaaStNatgtHcaaaDtaagBaKBtRgaBgDtSagtatMtaacYaatYtVc
+KatgtgcaacVaaaatactKcRgtaYtgtNgBBNcKtcttaccttKgaRaYcaNKtactt
+tgagSBtgtRagaNgcaaaNcacagtVtttHWatgttaNatBgtttaatNgVtctgaata
+tcaRtattcttttttttRaaKcRStctcggDgKagattaMaaaKtcaHacttaataataK
+taRgDtKVBttttcgtKaggHHcatgttagHggttNctcgtatKKagVagRaaaggaaBt
+NatttVKcRttaHctaHtcaaatgtaggHccaBataNaNaggttgcWaatctgatYcaaa
+HaatWtaVgaaBttagtaagaKKtaaaKtRHatMaDBtBctagcatWtatttgWttVaaa
+ScMNattRactttgtYtttaaaagtaagtMtaMaSttMBtatgaBtttaKtgaatgagYg
+tNNacMtcNRacMMHcttWtgtRtctttaacaacattattcYaMagBaacYttMatcttK
+cRMtgMNccattaRttNatHaHNaSaaHMacacaVaatacaKaSttHatattMtVatWga
+ttttttaYctttKttHgScWaacgHtttcaVaaMgaacagNatcgttaacaaaaagtaca
+HBNaattgttKtcttVttaaBtctgctacgBgcWtttcaggacacatMgacatcccagcg
+gMgaVKaBattgacttaatgacacacaaaaaatRKaaBctacgtRaDcgtagcVBaacDS
+BHaaaaSacatatacagacRNatcttNaaVtaaaataHattagtaaaaSWccgtatWatg
+gDttaactattgcccatcttHaSgYataBttBaactattBtcHtgatcaataSttaBtat
+KSHYttWggtcYtttBttaataccRgVatStaHaKagaatNtagRMNgtcttYaaSaact
+cagDSgagaaYtMttDtMRVgWKWtgMaKtKaDttttgactatacataatcNtatNaHat
+tVagacgYgatatatttttgtStWaaatctWaMgagaRttRatacgStgattcttaagaD
+taWccaaatRcagcagaaNKagtaaDggcgccBtYtagSBMtactaaataMataBSacRM
+gDgattMMgtcHtcaYDtRaDaacggttDaggcMtttatgttaNctaattaVacgaaMMt
+aatDccSgtattgaRtWWaccaccgagtactMcgVNgctDctaMScatagcgtcaactat
+acRacgHRttgctatttaatgaattataYKttgtaagWgtYttgcHgMtaMattWaWVta
+RgcttgYgttBHtYataSccStBtgtagMgtDtggcVaaSBaatagDttgBgtctttctc
+attttaNagtHKtaMWcYactVcgcgtatMVtttRacVagDaatcttgctBBcRDgcaac
+KttgatSKtYtagBMagaRtcgBattHcBWcaactgatttaatttWDccatttatcgagS
+KaWttataHactaHMttaatHtggaHtHagaatgtKtaaRactgtttMatacgatcaagD
+gatKaDctataMggtHDtggHacctttRtatcttYattttgacttgaaSaataaatYcgB
+aaaaccgNatVBttMacHaKaataagtatKgtcaagactcttaHttcggaattgttDtct
+aaccHttttWaaatgaaatataaaWattccYDtKtaaaacggtgaggWVtctattagtga
+ctattaagtMgtttaagcatttgSgaaatatccHaaggMaaaattttcWtatKctagDtY
+tMcctagagHcactttactatacaaacattaacttaHatcVMYattYgVgtMttaaRtga
+aataaDatcaHgtHHatKcDYaatcttMtNcgatYatgSaMaNtcttKcWataScKggta
+tcttacgcttWaaagNatgMgHtctttNtaacVtgttcMaaRatccggggactcMtttaY
+MtcWRgNctgNccKatcttgYDcMgattNYaRagatHaaHgKctcataRDttacatBatc
+cattgDWttatttaWgtcggagaaaaatacaatacSNtgggtttccttacSMaagBatta
+caMaNcactMttatgaRBacYcYtcaaaWtagctSaacttWgDMHgaggatgBVgcHaDt
+ggaactttggtcNatNgtaKaBcccaNtaagttBaacagtatacDYttcctNgWgcgSMc
+acatStctHatgRcNcgtacacaatRttMggaNKKggataaaSaYcMVcMgtaMaHtgat
+tYMatYcggtcttcctHtcDccgtgRatcattgcgccgatatMaaYaataaYSggatagc
+gcBtNtaaaScaKgttBgagVagttaKagagtatVaactaSacWactSaKatWccaKaaa
+atBKgaaKtDMattttgtaaatcRctMatcaaMagMttDgVatggMaaWgttcgaWatga
+aatttgRtYtattaWHKcRgctacatKttctaccaaHttRatctaYattaaWatVNccat
+NgagtcKttKataStRaatatattcctRWatDctVagttYDgSBaatYgttttgtVaatt
+taatagcagMatRaacttBctattgtMagagattaaactaMatVtHtaaatctRgaaaaa
+aaatttWacaacaYccYDSaattMatgaccKtaBKWBattgtcaagcHKaagttMMtaat
+ttcKcMagNaaKagattggMagaggtaatttYacatcWaaDgatMgKHacMacgcVaaca
+DtaDatatYggttBcgtatgWgaSatttgtagaHYRVacaRtctHaaRtatgaactaata
+tctSSBgggaaHMWtcaagatKgagtDaSatagttgattVRatNtctMtcSaagaSHaat
+aNataataRaaRgattctttaataaagWaRHcYgcatgtWRcttgaaggaMcaataBRaa
+ccagStaaacNtttcaatataYtaatatgHaDgcStcWttaacctaRgtYaRtataKtgM
+ttttatgactaaaatttacYatcccRWtttHRtattaaatgtttatatttgttYaatMca
+RcSVaaDatcgtaYMcatgtagacatgaaattgRtcaaYaaYtRBatKacttataccaNa
+aattVaBtctggacaagKaaYaaatatWtMtatcYaaVNtcgHaactBaagKcHgtctac
+aatWtaDtSgtaHcataHtactgataNctRgttMtDcDttatHtcgtacatcccaggStt
+aBgtcacacWtccNMcNatMVaVgtccDYStatMaccDatggYaRKaaagataRatttHK
+tSaaatDgataaacttaHgttgVBtcttVttHgDacgaKatgtatatNYataactctSat
+atatattgcHRRYttStggaactHgttttYtttaWtatMcttttctatctDtagVHYgMR
+BgtHttcctaatYRttKtaagatggaVRataKDctaMtKBNtMtHNtWtttYcVtattMc
+gRaacMcctNSctcatttaaagDcaHtYccSgatgcaatYaaaaDcttcgtaWtaattct
+cgttttScttggtaatctttYgtctaactKataHacctMctcttacHtKataacacagcN
+RatgKatttttSaaatRYcgDttaMRcgaaattactMtgcgtaagcgttatBtttttaat
+taagtNacatHgttcRgacKcBBtVgatKttcgaBaatactDRgtRtgaNacWtcacYtt
+aaKcgttctHaKttaNaMgWgWaggtctRgaKgWttSttBtDcNtgtttacaaatYcDRt
+gVtgcctattcNtctaaaDMNttttNtggctgagaVctDaacVtWccaagtaacacaNct
+gaScattccDHcVBatcgatgtMtaatBgHaatDctMYgagaatgYWKcctaatNaStHa
+aaKccgHgcgtYaaYtattgtStgtgcaaRtattaKatattagaWVtcaMtBagttatta
+gNaWHcVgcaattttDcMtgtaRHVYtHtctgtaaaaHVtMKacatcgNaatttMatatg
+ttgttactagWYtaRacgataKagYNKcattataNaRtgaacKaYgcaaYYacaNccHat
+MatDcNgtHttRaWttagaaDcaaaaaatagggtKDtStaDaRtaVtHWKNtgtattVct
+SVgRgataDaRaWataBgaagaaKtaataaYgDcaStaNgtaDaaggtattHaRaWMYaY
+aWtggttHYgagVtgtgcttttcaaDKcagVcgttagacNaaWtagtaataDttctggtt
+VcatcataaagtgKaaaNaMtaBBaattaatWaattgctHaVKaSgDaaVKaHtatatat
+HatcatSBagNgHtatcHYMHgttDgtaHtBttWatcgtttaRaattgStKgSKNWKatc
+agDtctcagatttctRtYtBatBgHHtKaWtgYBgacVVWaKtacKcDttKMaKaVcggt
+gttataagaataaHaatattagtataatMHgttYgaRttagtaRtcaaVatacggtcMcg
+agtaaRttacWgactKRYataaaagSattYaWgagatYagKagatgSaagKgttaatMgg
+tataatgttWYttatgagaaacctNVataatHcccKtDctcctaatactggctHggaSag
+gRtKHaWaattcgSatMatttagaggcYtctaMcgctcataSatatgRagacNaaDagga
+VBagaYttKtacNaKgtSYtagttggaWcatcWttaatctatgaVtcgtgtMtatcaYcg
+tRccaaYgDctgcMgtgtWgacWtgataacacgcgctBtgttaKtYDtatDcatcagKaV
+MctaatcttgVcaaRgcRMtDcgattaHttcaNatgaatMtactacVgtRgatggaWttt
+actaaKatgagSaaKggtaNtactVaYtaaKRagaacccacaMtaaMtKtatBcttgtaa
+WBtMctaataaVcDaaYtcRHBtcgttNtaaHatttBNgRStVDattBatVtaagttaYa
+tVattaagaBcacggtSgtVtatttaRattgatgtaHDKgcaatattKtggcctatgaWD
+KRYcggattgRctatNgatacaatMNttctgtcRBYRaaaHctNYattcHtaWcaattct
+BtMKtVgYataatMgYtcagcttMDataVtggRtKtgaatgccNcRttcaMtRgattaac
+attRcagcctHtWMtgtDRagaKaBtgDttYaaaaKatKgatctVaaYaacWcgcatagB
+VtaNtRtYRaggBaaBtgKgttacataagagcatgtRattccacttaccatRaaatgWgD
+aMHaYVgVtaSctatcgKaatatattaDgacccYagtgtaYNaaatKcagtBRgagtcca
+tgKgaaaccBgaagBtgSttWtacgatWHaYatcgatttRaaNRgcaNaKVacaNtDgat
+tgHVaatcDaagcgtatgcNttaDataatcSataaKcaataaHWataBtttatBtcaKtK
+tatagttaDgSaYctacaRatNtaWctSaatatttYaKaKtaccWtatcRagacttaYtt
+VcKgSDcgagaagatccHtaattctSttatggtKYgtMaHagVaBRatttctgtRgtcta
+tgggtaHKgtHacHtSYacgtacacHatacKaaBaVaccaDtatcSaataaHaagagaat
+ScagactataaRttagcaaVcaHataKgDacatWccccaagcaBgagWatctaYttgaaa
+tctVNcYtttWagHcgcgcDcVaaatgttKcHtNtcaatagtgtNRaactttttcaatgg
+WgBcgDtgVgtttctacMtaaataaaRggaaacWaHttaRtNtgctaaRRtVBctYtVta
+tDcattDtgaccYatagatYRKatNYKttNgcctagtaWtgaactaMVaacctgaStttc
+tgaKVtaaVaRKDttVtVctaDNtataaaDtccccaagtWtcgatcactDgYaBcatcct
+MtVtacDaaBtYtMaKNatNtcaNacgDatYcatcgcaRatWBgaacWttKttagYtaat
+tcggttgSWttttDWctttacYtatatWtcatDtMgtBttgRtVDggttaacYtacgtac
+atgaattgaaWcttMStaDgtatattgaDtcRBcattSgaaVBRgagccaaKtttcDgcg
+aSMtatgWattaKttWtgDBMaggBBttBaatWttRtgcNtHcgttttHtKtcWtagHSt
+aacagttgatatBtaWSaWggtaataaMttaKacDaatactcBttcaatatHttcBaaSa
+aatYggtaRtatNtHcaatcaHtagVtgtattataNggaMtcttHtNagctaaaggtaga
+YctMattNaMVNtcKtactBKcaHHcBttaSagaKacataYgctaKaYgttYcgacWVtt
+WtSagcaacatcccHaccKtcttaacgaKttcacKtNtacHtatatRtaaatacactaBt
+ttgaHaRttggttWtatYagcatYDatcggagagcWBataagRtacctataRKgtBgatg
+aDatataSttagBaHtaatNtaDWcWtgtaattacagKttcNtMagtattaNgtctcgtc
+ctcttBaHaKcKccgtRcaaYagSattaagtKataDatatatagtcDtaacaWHcaKttD
+gaaRcgtgYttgtcatatNtatttttatggccHtgDtYHtWgttatYaacaattcaWtat
+NgctcaaaSttRgctaatcaaatNatcgtttaBtNNVtgttataagcaaagattBacgtD
+atttNatttaaaDcBgtaSKgacgtagataatttcHMVNttgttBtDtgtaWKaaRMcKM
+tHtaVtagataWctccNNaSWtVaHatctcMgggDgtNHtDaDttatatVWttgttattt
+aacctttcacaaggaSaDcggttttttatatVtctgVtaacaStDVaKactaMtttaSNa
+gtgaaattaNacttSKctattcctctaSagKcaVttaagNaVcttaVaaRNaHaaHttat
+gtHttgtgatMccaggtaDcgaccgtWgtWMtttaHcRtattgScctatttKtaaccaag
+tYagaHgtWcHaatgccKNRtttagtMYSgaDatctgtgaWDtccMNcgHgcaaacNDaa
+aRaStDWtcaaaaHKtaNBctagBtgtattaactaattttVctagaatggcWSatMaccc
+ttHttaSgSgtgMRcatRVKtatctgaaaccDNatYgaaVHNgatMgHRtacttaaaRta
+tStRtDtatDttYatattHggaBcttHgcgattgaKcKtttcRataMtcgaVttWacatN
+catacctRataDDatVaWNcggttgaHtgtMacVtttaBHtgagVttMaataattatgtt
+cttagtttgtgcDtSatttgBtcaacHattaaBagVWcgcaSYttMgcttacYKtVtatc
+aYaKctgBatgcgggcYcaaaaacgNtctagKBtattatctttKtaVttatagtaYtRag
+NtaYataaVtgaatatcHgcaaRataHtacacatgtaNtgtcgYatWMatttgaactacR
+ctaWtWtatacaatctBatatgYtaagtatgtgtatSttactVatcttYtaBcKgRaSgg
+RaaaaatgcagtaaaWgtaRgcgataatcBaataccgtatttttccatcNHtatWYgatH
+SaaaDHttgctgtccHtggggcctaataatttttctatattYWtcattBtgBRcVttaVM
+RSgctaatMagtYtttaaaaatBRtcBttcaaVtaacagctccSaaSttKNtHtKYcagc
+agaaaccccRtttttaaDcDtaStatccaagcgctHtatcttaDRYgatDHtWcaaaBcW
+gKWHttHataagHacgMNKttMKHccaYcatMVaacgttaKgYcaVaaBtacgcaacttt
+MctaaHaatgtBatgagaSatgtatgSRgHgWaVWgataaatatttccKagVgataattW
+aHNcYggaaatgctHtKtaDtctaaagtMaatVDVactWtSaaWaaMtaHtaSKtcBRaN
+cttStggtBttacNagcatagRgtKtgcgaacaacBcgKaatgataagatgaaaattgta
+ctgcgggtccHHWHaaNacaBttNKtKtcaaBatatgctaHNgtKcDWgtttatNgVDHg
+accaacWctKaaggHttgaRgYaatHcaBacaatgagcaaattactgtaVaaYaDtagat
+tgagNKggtggtgKtWKaatacagDRtatRaMRtgattDggtcaaYRtatttNtagaDtc
+acaaSDctDtataatcgtactaHttatacaatYaacaaHttHatHtgcgatRRttNgcat
+SVtacWWgaaggagtatVMaVaaattScDDKNcaYBYaDatHgtctatBagcaacaagaa
+tgagaaRcataaKNaRtBDatcaaacgcattttttaaBtcSgtacaRggatgtMNaattg
+gatatWtgagtattaaaVctgcaYMtatgatttttYgaHtgtcttaagWBttHttgtctt
+attDtcgtatWtataataSgctaHagcDVcNtaatcaagtaBDaWaDgtttagYctaNcc
+DtaKtaHcttaataacccaRKtacaVaatNgcWRaMgaattatgaBaaagattVYaHMDc
+aDHtcRcgYtcttaaaWaaaVKgatacRtttRRKYgaatacaWVacVcRtatMacaBtac
+tggMataaattttHggNagSctacHgtBagcgtcgtgattNtttgatSaaggMttctttc
+ttNtYNagBtaaacaaatttMgaccttacataattgYtcgacBtVMctgStgMDtagtaR
+ctHtatgttcatatVRNWataDKatWcgaaaaagttaaaagcacgHNacgtaatctttMR
+tgacttttDacctataaacgaaatatgattagaactccSYtaBctttaataacWgaaaYa
+tagatgWttcatKtNgatttttcaagHtaYgaaRaDaagtaggagcttatVtagtctttc
+attaaaatcgKtattaRttacagVaDatgcatVgattgggtctttHVtagKaaRBtaHta
+aggccccaaaaKatggtttaMWgtBtaaacttcactttKHtcgatctccctaYaBacMgt
+cttBaBaNgcgaaacaatctagtHccHtKttcRtRVttccVctttcatacYagMVtMcag
+aMaaacaataBctgYtaatRaaagattaaccatVRatHtaRagcgcaBcgDttStttttc
+VtttaDtKgcaaWaaaaatSccMcVatgtKgtaKgcgatatgtagtSaaaDttatacaaa
+catYaRRcVRHctKtcgacKttaaVctaDaatgttMggRcWaacttttHaDaKaDaBctg
+taggcgtttaHBccatccattcNHtDaYtaataMttacggctNVaacDattgatatttta
+cVttSaattacaaRtataNDgacVtgaacataVRttttaDtcaaacataYDBtttaatBa
+DtttYDaDaMccMttNBttatatgagaaMgaNtattHccNataattcaHagtgaaggDga
+tgtatatatgYatgaStcataaBStWacgtcccataRMaaDattggttaaattcMKtctM
+acaBSactcggaatDDgatDgcWctaacaccgggaVcacWKVacggtaNatatacctMta
+tgatagtgcaKagggVaDtgtaacttggagtcKatatcgMcttRaMagcattaBRaStct
+YSggaHYtacaactMBaagDcaBDRaaacMYacaHaattagcattaaaHgcgctaaggSc
+cKtgaaKtNaBtatDDcKBSaVtgatVYaagVtctSgMctacgttaacWaaattctSgtD
+actaaStaaattgcagBBRVctaatatacctNttMcRggctttMttagacRaHcaBaacV
+KgaataHttttMgYgattcYaNRgttMgcVaaacaVVcDHaatttgKtMYgtatBtVVct
+WgVtatHtacaaHttcacgatagcagtaaNattBatatatttcVgaDagcggttMaagtc
+ScHagaaatgcYNggcgtttttMtStggtRatctacttaaatVVtBacttHNttttaRca
+aatcacagHgagagtMgatcSWaNRacagDtatactaaDKaSRtgattctccatSaaRtt
+aaYctacacNtaRtaactggatgaccYtacactttaattaattgattYgttcagDtNKtt
+agDttaaaaaaaBtttaaNaYWKMBaaaacVcBMtatWtgBatatgaacVtattMtYatM
+NYDKNcKgDttDaVtaaaatgggatttctgtaaatWtctcWgtVVagtcgRgacttcccc
+taDcacagcRcagagtgtWSatgtacatgttaaSttgtaaHcgatgggMagtgaacttat
+RtttaVcaccaWaMgtactaatSSaHtcMgaaYtatcgaaggYgggcgtgaNDtgttMNg
+aNDMtaattcgVttttaacatgVatgtWVMatatcaKgaaattcaBcctccWcttgaaWH
+tWgHtcgNWgaRgctcBgSgaattgcaaHtgattgtgNagtDttHHgBttaaWcaaWagc
+aSaHHtaaaVctRaaMagtaDaatHtDMtcVaWMtagSagcttHSattaacaaagtRacM
+tRtctgttagcMtcaBatVKtKtKacgagaSNatSactgtatatcBctgagVtYactgta
+aattaaaggcYgDHgtaacatSRDatMMccHatKgttaacgactKtgKagtcttcaaHRV
+tccttKgtSataatttacaactggatDNgaacttcaRtVaagDcaWatcBctctHYatHa
+DaaatttagYatSatccaWtttagaaatVaacBatHcatcgtacaatatcgcNYRcaata
+YaRaYtgattVttgaatgaVaactcRcaNStgtgtattMtgaggtNttBaDRcgaaaagc
+tNgBcWaWgtSaDcVtgVaatMKBtttcgtttctaaHctaaagYactgMtatBDtcStga
+ccgtSDattYaataHctgggaYYttcggttaWaatctggtRagWMaDagtaacBccacta
+cgHWMKaatgatWatcctgHcaBaSctVtcMtgtDttacctaVgatYcWaDRaaaaRtag
+atcgaMagtggaRaWctctgMgcWttaagKBRtaaDaaWtctgtaagYMttactaHtaat
+cttcataacggcacBtSgcgttNHtgtHccatgttttaaagtatcgaKtMttVcataYBB
+aKtaMVaVgtattNDSataHcagtWMtaggtaSaaKgttgBtVtttgttatcatKcgHac
+acRtctHatNVagSBgatgHtgaRaSgttRcctaacaaattDNttgacctaaYtBgaaaa
+tagttattactcttttgatgtNNtVtgtatMgtcttRttcatttgatgacacttcHSaaa
+ccaWWDtWagtaRDDVNacVaRatgttBccttaatHtgtaaacStcVNtcacaSRttcYa
+gacagaMMttttgMcNttBcgWBtactgVtaRttctccaaYHBtaaagaBattaYacgat
+ttacatctgtaaMKaRYtttttactaaVatWgctBtttDVttctggcDaHaggDaagtcg
+aWcaagtagtWttHtgKtVataStccaMcWcaagataagatcactctHatgtcYgaKcat
+cagatactaagNSStHcctRRNtattgtccttagttagMVgtatagactaactctVcaat
+MctgtttgtgttgccttatWgtaBVtttctggMcaaKgDWtcgtaaYStgSactatttHg
+atctgKagtagBtVacRaagRtMctatgggcaaaKaaaatacttcHctaRtgtDcttDat
+taggaaatttcYHaRaaBttaatggcacKtgctHVcaDcaaaVDaaaVcgMttgtNagcg
+taDWgtcgttaatDgKgagcSatatcSHtagtagttggtgtHaWtaHKtatagctgtVga
+ttaBVaatgaataagtaatVatSttaHctttKtttgtagttaccttaatcgtagtcctgB
+cgactatttVcMacHaaaggaatgDatggKtaHtgStatattaaSagctWcctccRtata
+BaDYcgttgcNaagaggatRaaaYtaWgNtSMcaatttactaacatttaaWttHtatBat
+tgtcgacaatNgattgcNgtMaaaKaBDattHacttggtRtttaYaacgVactBtaBaKt
+gBttatgVttgtVttcaatcWcNctDBaaBgaDHacBttattNtgtDtatttVSaaacag
+gatgcRatSgtaSaNtgBatagttcHBgcBBaaattaHgtDattatDaKaatBaaYaaMa
+ataaataKtttYtagtBgMatNcatgtttgaNagtgttgtgKaNaSagtttgaSMaYBca
+aaacDStagttVacaaaaactaaWttBaagtctgtgcgtMgtaattctcctacctcaNtt
+taaccaaaaVtBcacataacaccccBcWMtatVtggaatgaWtcaaWaaaaaaaaWtDta
+atatRcctDWtcctaccMtVVatKttaWaaKaaatataaagScHBagaggBaSMtaWaVt
+atattactSaaaKNaactatNatccttgaYctattcaaaVgatttYHcRagattttaSat
+aggttattcVtaaagaKgtattattKtRttNcggcRgtgtgtWYtaacHgKatKgatYta
+cYagDtWcHBDctctgRaYKaYagcactKcacSaRtBttttBHKcMtNtcBatttatttt
+tgSatVgaaagaWtcDtagDatatgMacaacRgatatatgtttgtKtNRaatatNatgYc
+aHtgHataacKtgagtagtaacYttaNccaaatHcacaacaVDtagtaYtccagcattNt
+acKtBtactaaagaBatVtKaaHBctgStgtBgtatgaSNtgDataaccctgtagcaBgt
+gatcttaDataStgaMaccaSBBgWagtacKcgattgaDgNNaaaacacagtSatBacKD
+gcgtataBKcatacactaSaatYtYcDaactHttcatRtttaatcaattataRtttgtaa
+gMcgNttcatcBtYBagtNWNMtSHcattcRctttttRWgaKacKttgggagBcgttcgc
+MaWHtaatactgtctctatttataVgtttaBScttttaBMaNaatMacactYtBMggtHa
+cMagtaRtctgcatttaHtcaaaatttgagKtgNtactBacaHtcgtatttctMaSRagc
+agttaatgtNtaaattgagagWcKtaNttagVtacgatttgaatttcgRtgtWcVatcgt
+taaDVctgtttBWgaccagaaagtcSgtVtatagaBccttttcctaaattgHtatcggRa
+ttttcaaggcYSKaagWaWtRactaaaacccBatMtttBaatYtaagaactSttcgaaSc
+aatagtattgaccaagtgttttctaacatgtttNVaatcaaagagaaaNattaaRtttta
+VaaaccgcaggNMtatattVctcaagaggaacgBgtttaacaagttcKcYaatatactaa
+ccBaaaSggttcNtattctagttRtBacgScVctcaatttaatYtaaaaaaatgSaatga
+tagaMBRatgRcMcgttgaWHtcaVYgaatYtaatctttYttatRaWtctgBtDcgatNa
+tcKaBaDgatgtaNatWKctccgatattaacattNaaacDatgBgttctgtDtaaaMggt
+gaBaSHataacgccSctaBtttaRBtcNHcDatcDcctagagtcRtaBgWttDRVHagat
+tYatgtatcWtaHtttYcattWtaaagtctNgtStggRNcgcggagSSaaagaaaatYcH
+DtcgctttaatgYcKBVSgtattRaYBaDaaatBgtatgaHtaaRaRgcaSWNtagatHa
+acttNctBtcaccatctMcatattccaSatttgcgaDagDgtatYtaaaVDtaagtttWV
+aagtagYatRttaagDcNgacKBcScagHtattatcDaDactaaaaaYgHttBcgaDttg
+gataaaKSRcBMaBcgaBSttcWtgNBatRaccgattcatttataacggHVtaattcaca
+agagVttaaRaatVVRKcgWtVgacctgDgYaaHaWtctttcacMagggatVgactagMa
+aataKaaNWagKatagNaaWtaaaatttgaattttatttgctaaVgaHatBatcaaBWcB
+gttcMatcgBaaNgttcgSNaggSaRtttgHtRtattaNttcDcatSaVttttcgaaaaa
+ttgHatctaRaggSaNatMDaaatDcacgattttagaHgHaWtYgattaatHNSttatMS
+gggNtcKtYatRggtttgtMWVtttaYtagcagBagHaYagttatatggtBacYcattaR
+SataBatMtttaaatctHcaaaSaaaagttNSaaWcWRccRtKaagtBWtcaaattSttM
+tattggaaaccttaacgttBtWatttatatWcDaatagattcctScacctaagggRaaYt
+aNaatgVtBcttaaBaacaMVaaattatStYgRcctgtactatcMcVKatttcgSgatRH
+MaaaHtagtaaHtVgcaaataatatcgKKtgccaatBNgaaWcVttgagttaKatagttc
+aggKDatDtattgaKaVcaKtaataDataataHSaHcattagttaatRVYcNaHtaRcaa
+ggtNHcgtcaaccaBaaagYtHWaaaRcKgaYaaDttgcWYtataRgaatatgtYtgcKt
+aNttWacatYHctRaDtYtattcBttttatcSataYaYgttWaRagcacHMgtttHtYtt
+YaatcggtatStttcgtRSattaaDaKMaatatactaNBaWgctacacYtgaYVgtgHta
+aaRaaRgHtagtWattataaaSDaaWtgMattatcgaaaagtaYRSaWtSgNtBgagcRY
+aMDtactaacttaWgtatctagacaagNtattHggataatYttYatcataDcgHgttBtt
+ctttVttgccgaaWtaaaacgKgtatctaaaaaNtccDtaDatBMaMggaatNKtatBaa
+atVtccRaHtaSacataHattgtttKVYattcataVaattWtcgtgMttcttKtgtctaa
+cVtatctatatBRataactcgKatStatattcatHHRttKtccaacgtgggtgRgtgaMt
+attattggctatcgtgacMtRcBDtcttgtactaatRHttttaagatcgVMDStattatY
+BtttDttgtBtNttgRcMtYtgBacHaWaBaatDKctaagtgaaactaatgRaaKgatcc
+aagNaaaatattaggWNtaagtatacttttKcgtcggSYtcttgRctataYcttatataa
+agtatattaatttataVaacacaDHatctatttttKYVatHRactttaBHccaWagtact
+BtcacgaVgcgttRtttttttSVgtSagtBaaattctgaHgactcttgMcattttagVta
+agaattHctHtcaDaaNtaacRggWatagttcgtSttgaDatcNgNagctagDgatcNtt
+KgttgtaDtctttRaaYStRatDtgMggactSttaDtagSaVtBDttgtDgccatcacaM
+attaaaMtNacaVcgSWcVaaDatcaHaatgaattaMtatccVtctBtaattgtWattat
+BRcWcaatgNNtactWYtDaKttaaatcactcagtRaaRgatggtKgcgccaaHgaggat
+StattYcaNMtcaBttacttatgagDaNtaMgaaWtgtttcttctaHtMNgttatctaWW
+atMtBtaaatagDVatgtBYtatcggcttaagacMRtaHScgatatYgRDtcattatSDa
+HggaaataNgaWSRRaaaBaatagBattaDctttgHWNttacaataaaaaaatacggttt
+gHgVtaHtWMttNtBtctagtMcgKMgHgYtataHaNagWtcaacYattaataYRgtaWK
+gaBctataaccgatttaHaNBRaRaMtccggtNgacMtctcatttgcaattcWgMactta
+caaDaaNtactWatVtttagccttMaatcagVaagtctVaaDaBtattaattaYtNaYtg
+gattaKtaKctYaMtattYgatattataatKtVgDcttatatNBtcgttgtStttttMag
+aggttaHYSttcKgtcKtDNtataagttataagSgttatDtRttattgttttSNggRtca
+aKMNatgaatattgtBWtaMacctgggYgaSgaagYataagattacgagaatBtggtRcV
+HtgYggaDgaYaKagWagctatagacgaaHgtWaNgacttHRatVaWacKYtgRVNgVcS
+gRWctacatcKSactctgWYtBggtataagcttNRttVtgRcaWaaatDMatYattaact
+ttcgaagRatSctgccttgcRKaccHtttSNVagtagHagBagttagaccaRtataBcca
+taatSHatRtcHagacBWatagcaMtacaRtgtgaaBatctKRtScttccaNaatcNgta
+atatWtcaMgactctBtWtaaNactHaaaaRctcgcatggctMcaaNtcagaaaaacaca
+gtggggWttRttagtaagaVctVMtcgaatcttcMaaaHcaHBttcgattatgtcaDagc
+YRtBtYcgacMgtDcagcgaNgttaataatagcagKYYtcgtaBtYctMaRtaRtDagaa
+aacacatgYaBttgattattcgaaNttBctSataaMataWRgaHtttccgtDgaYtatgg
+tDgHKgMtatttVtMtVagttaRatMattRagataaccctKctMtSttgaHagtcStcta
+tttccSagatgttccacgaggYNttHRacgattcDatatDcataaaatBBttatcgaHtN
+HaaatatDNaggctgaNcaaggagttBttMgRagVatBcRtaWgatgBtSgaKtcgHttt
+gaatcaaDaHttcSBgHcagtVaaSttDcagccgttNBtgttHagYtattctttRWaaVt
+SttcatatKaaRaaaNacaVtVctMtSDtDtRHRcgtaatgctcttaaatSacacaatcg
+HattcaWcttaaaatHaaatcNctWttaNMcMtaKctVtcctaagYgatgatcYaaaRac
+tctaRDaYagtaacgtDgaggaaatctcaaacatcaScttcKttNtaccatNtaNataca
+tttHaaDHgcaDatMWaaBttcRggctMaagctVYcacgatcaDttatYtaatcKatWat
+caatVYtNagatttgattgaYttttYgacttVtcKaRagaaaHVgDtaMatKYagagttN
+atWttaccNtYtcDWgSatgaRgtMatgKtcgacaagWtacttaagtcgKtgatccttNc
+ttatagMatHVggtagcgHctatagccctYttggtaattKNaacgaaYatatVctaataM
+aaaYtgVtcKaYtaataacagaatHcacVagatYWHttagaaSMaatWtYtgtaaagNaa
+acaVgaWtcacNWgataNttcaSagctMDaRttgNactaccgataMaaatgtttattDtc
+aagacgctDHYYatggttcaagccNctccttcMctttagacBtaaWtaWVHggaaaaNat
+ttaDtDtgctaaHHtMtatNtMtagtcatttgcaaaRatacagRHtatDNtgtDgaatVg
+tVNtcaaatYBMaaaagcaKgtgatgatMgWWMaHttttMgMagatDtataaattaacca
+actMtacataaattgRataatacgBtKtaataattRgtatDagDtcRDacctatRcagag
+cSHatNtcaScNtttggacNtaaggaccgtgKNttgttNcttgaaRgYgRtNtcagttBc
+ttttcHtKtgcttYaaNgYagtaaatgaatggWaMattBHtatctatSgtcYtgcHtaat
+tHgaaMtHcagaaSatggtatgccaHBtYtcNattWtgtNgctttaggtttgtWatNtgH
+tgcDttactttttttgcNtactKtWRaVcttcatagtgSNKaNccgaataaBttataata
+YtSagctttaaatSttggctaaKSaatRccgWHgagDttaaatcatgagMtcgagtVtaD
+ggaBtatttgDacataaacgtagYRagBWtgDStKDgatgaagttcattatttaKWcata
+aatWRgatataRgttRacaaNKttNtKagaaYaStaactScattattaacgatttaaatg
+DtaattagatHgaYataaactatggggatVHtgccgtNgatNYcaStRtagaccacWcaM
+tatRagHgVactYtWHtcttcatgatWgagaKggagtatgaWtDtVtNaNtcgYYgtaaa
+ctttaDtBactagtaDctatagtaatatttatatataacgHaaaRagKattSagttYtSt
+>THREE Homo sapiens frequency
+agagagacgatgaaaattaatcgtcaatacgctggcgaacactgagggggacccaatgct
+cttctcggtctaaaaaggaatgtgtcagaaattggtcagttcaaaagtagaccggatctt
+tgcggagaacaattcacggaacgtagcgttgggaaatatcctttctaccacacatcggat
+tttcgccctctcccattatttattgtgttctcacatagaattattgtttagacatccctc
+gttgtatggagagttgcccgagcgtaaaggcataatccatataccgccgggtgagtgacc
+tgaaattgtttttagttgggatttcgctatggattagcttacacgaagagattctaatgg
+tactataggataattataatgctgcgtggcgcagtacaccgttacaaacgtcgttcgcat
+atgtggctaacacggtgaaaatacctacatcgtatttgcaatttcggtcgtttcatagag
+cgcattgaattactcaaaaattatatatgttgattatttgattagactgcgtggaaagaa
+ggggtactcaagccatttgtaaaagctgcatctcgcttaagtttgagagcttacattagt
+ctatttcagtcttctaggaaatgtctgtgtgagtggttgtcgtccataggtcactggcat
+atgcgattcatgacatgctaaactaagaaagtagattactattaccggcatgcctaatgc
+gattgcactgctatgaaggtgcggacgtcgcgcccatgtagccctgataataccaatact
+tacatttggtcagcaattctgacattatacctagcacccataaatttactcagacttgag
+gacaggctcttggagtcgatcttctgtttgtatgcatgtgatcatatagatgaataagcg
+atgcgactagttagggcatagtatagatctgtgtatacagttcagctgaacgtccgcgag
+tggaagtacagctgagatctatcctaaaatgcaaccatatcgttcacacatgatatgaac
+ccagggggaaacattgagttcagttaaattggcagcgaatcccccaagaagaaggcggag
+tgacgttgaacgggcttatggtttttcagtacttcctccgtataagttgagcgaaatgta
+aacagaataatcgttgtgttaacaacattaaaatcgcggaatatgatgagaatacacagt
+gtgagcatttcacttgtaaaatatctttggtagaacttactttgctttaaatatgttaaa
+ccgatctaataatctacaaaacggtagattttgcctagcacattgcgtccttctctattc
+agatagaggcaatactcagaaggttttatccaaagcactgtgttgactaacctaagtttt
+agtctaataatcatgattgattataggtgccgtggactacatgactcgtccacaaataat
+acttagcagatcagcaattggccaagcacccgacttttatttaatggttgtgcaatagtc
+cagattcgtattcgggactctttcaaataatagtttcctggcatctaagtaagaaaagct
+cataaggaagcgatattatgacacgctcttccgccgctgttttgaaacttgagtattgct
+cgtccgaaattgagggtcacttcaaaatttactgagaagacgaagatcgactaaagttaa
+aatgctagtccacagttggtcaagttgaattcatccacgagttatatagctattttaatt
+tatagtcgagtgtacaaaaaacatccacaataagatttatcttagaataacaacccccgt
+atcatcgaaatcctccgttatggcctgactcctcgagcttatagcatttgtgctggcgct
+cttgccaggaacttgctcgcgaggtggtgacgagtgagatgatcagtttcattatgatga
+tacgattttatcgcgactagttaatcatcatagcaagtaaaatttgaattatgtcattat
+catgctccattaacaggttatttaattgatactgacgaaattttttcacaatgggttttc
+tagaatttaatatcagtaattgaagccttcataggggtcctactagtatcctacacgacg
+caggtccgcagtatcctggagggacgtgttactgattaaaagggtcaaaggaatgaaggc
+tcacaatgttacctgcttcaccatagtgagccgatgagttttacattagtactaaatccc
+aaatcatactttacgatgaggcttgctagcgctaaagagaatacatacaccaccacatag
+aattgttagcgatgatatcaaatagactcctggaagtgtcagggggaaactgttcaatat
+ttcgtccacaggactgaccaggcatggaaaagactgacgttggaaactataccatctcac
+gcccgacgcttcactaattgatgatccaaaaaatatagcccggattcctgattagcaaag
+ggttcacagagaaagatattatcgacgtatatcccaaaaaacagacgtaatgtgcatctt
+cgaatcgggatgaatacttgtatcataaaaatgtgacctctagtatacaggttaatgtta
+gtgatacacaatactcgtgggccatgggttctcaaataaaatgtaatattgcgtcgatca
+ctcacccacgtatttggtctaattatgttttatttagtgacaatccaatagataaccggt
+cctattaagggctatatttttagcgaccacgcgtttaaacaaaggattgtatgtagatgg
+taccagtttaattgccagtgggcaatcctaagcaaaatgagattctatcctaaagtttgg
+gcttgatataagatttcggatgtatgggttttataatcgttggagagctcaatcatgagc
+taatacatggatttcgctacctcaccgagagaccttgcatgaagaattctaaccaaaagt
+ttaataggccggattggattgagttaattaagaccttgttcagtcatagtaaaaaccctt
+aaattttaccgattgacaaagtgagcagtcgcaataccctatgcgaaacgcctcgatagt
+gactaggtatacaaggtttttgagttcctttgaaatagttaactaatttaaaattaatta
+acgacatggaaatcacagaacctaatgctttgtaggagttatttatgctgtttactgcct
+ctacaaccctaataaagcagtcctaagaatgaaacgcatcttttagttcagaaagtggta
+tccagggtggtcaatttaataaattcaacatcgggtctcaggatattcggtcatataatt
+tattaagggctcttcgagtcttactctgagtgaaattggaaacagtcatccttttcgttg
+tgaggcatcttacaccgctatcgatatacaatgcattccaccgcggtgtcccgtacacaa
+ggaaacttgttaccttggggatataagaaaactcacacgtctcattattaaactgagtac
+aatttttgcacgagaaagtaatgcaatacaatatgatgaaagccagctaatgaaaaggga
+tggaacgcacctcggatctgttgcactggattaaaatccgattatttttaaaaatattca
+gtgctagagcatatcaggtctacttttttatctggtatgtaaagcccacggagcgatagt
+gagatccttacgactcaacgaaaagttataacataactcccgttagccaaagcccaatcc
+cgattactgccctaccctaacgtctgccatctaaatatcgaacttgttatgatcaatgtg
+actacctcccaccctttccccttcatttgttccactggggataagctagcgttttcagaa
+tcaatgcaataagaatagccaattgtctcacttcatcagagctcttggcaattccaggcg
+ctacgtggttctggaatatattcatttttcaaatagtaatacgtttagtgttgctattgt
+ctacacgtttggatattacgttatgtgagcggacatcaatagttgtctaactctttagta
+agccagagatagcactcttagcgaatggataccatcttccataagtttagttaatagtcc
+gaaacaactgcttcgagcatatttgaacctccttgtaggcaaatagcctcttcaaagcaa
+tcttactaatagatagagtttgttttaagggactactagaaatgggacaatcttaatagt
+atgacctaaactgacatttaaagatatatccaggtggcaagcataaagatcattgcgcca
+cctccaccgtgggattacttatcagtcgatatcctatatgctaagtttgcgacggcagaa
+tacaaactaagctgagttgatgctaaccttacctatgataccccattggaccggttaaca
+gccctacttattccaaataaaagaacttttatgctgtagaagctattatagtgatgcctg
+gtaacttcagtatattaaaatgacacacatacgccatatagagctcctggaactttgaat
+aatgagcgaacttcgaagttgaagagcaagaaaccatatgtcacggttgcctaaagcccg
+gtaaccagacatgtgctatcattgatcattatcgaggttttcataaccttgacccattat
+cggctgtgcgcggacaagtacttaaatcactagtttcttcacctgcttatcggtaagaaa
+taaggttggcaaagaatcgcataagacggacgtagagccgcagcgttgtgcgagtccagg
+tgcatgcgcagcaataggattttaaattttgttccatttttaatttagccgtaaggatgt
+ccgtaaatgattgaaaattggattcaatctttgggcctatgctactggaacctgatcgac
+aaaatttcaaacatacgttaactccgaaagaccgtatttttgcggctagaatagtcagtc
+gcttggagccatataccttaccacttaaacgacgtgctcctgtagttgaaatataaacag
+aacacaaagactaccgatcatatcaactgaagatctttgtaactttgaggcgaagcaccc
+tcttcgagacaactaagagtaaagtaccgggcgccgcaaggagtcgattgggaccctaaa
+tcttgacgaattgctaagaggctcagagctaccactgtaatttctctagagcccataata
+aatgaacgatacatccgtaggtagcacctaagggattataatggaagccaaatgcagtta
+ataatattatatactggcgtacacgattcgacggatctctcacatagtgattcacgaccc
+ccccctttgattgacacagcgtcagcattttgcaagaacgatcttctgcatagggtgcgc
+caccgtaaggatgacgtcgaagctacaactgggtataatttaccatgcttccctgatgct
+gagtgcaatacactaagaatgagtttttaccccatatcaccagtatttgttctgttattg
+cgaagaaatggctatgctgagttggcgactaaagtcacccatcctttttattaggtaacc
+ccctcccttaaactaactgatttgctggagctgccctgcatacatatactttatcattta
+tggacgtccgtgacgcttattatccaccatagtcgatatgctacacggattcattaatgg
+atcgtaggagtttaagttatatttactaagatcggtctcggctactatcccgccttaccc
+ggcgctatttacggccatttttaatatattgacggtaattattcctatggtttcgaccgc
+acgtccttggacaagaaagaatggcaaaaaaaatgtaaaagaaaaaaaatattgagtccc
+taccatcatataaaaaatatgtgatgagtaacttgacgaaatgttagtggttattaaaga
+ctatctattacaccttttgttttctgtcgtagtatattaaagtctagaagccttacagga
+aaatcagggttatacagccgatactccgcagcatgaatcatcgaggaggtgtcctaccat
+cgcgccttgtaatcttgtctgtgtatactgtatttagaccttttatacaaagtaaatatc
+tcggctttatgtgattgggaggggcctactcaaacatgatgacttgacctaataatcact
+gtgcgggcgtcttatgactagctattccttgaaatccaccaccaaatggttaatatgtaa
+aaactttgacgatgaaacaaggtgaatgtgtagttactttgtgtaattagctgcgtcgag
+cattgcttgtaaaaccgtcaatcgcacacgttacttccataaaatttctacgaatacacc
+cttcttaaaaaaaacgtaggaattcacgagtttaacaaacgataactgtataaagtggaa
+gtccgaagaaagcagatgcccgaactactcgaagatgtttcgttttcttaaccatagggg
+cttcttaatggcccactacgcacattttgttcaagcccgagagggacatccccattacgg
+gagtattactaaaactgttccgtaatacgttcagcaagggatgaaaaaggccactgctca
+agttattgacgtgggagtattacatcggaagcctgaatcccacactatgatggtctgtac
+aggcctagggactgcgtctagacggtattaccggcttctaatcatacgatcgtgagtctt
+aacgggaagtaaggctcacacctaccccaaaccatttatctatgtaagtataaaattgtg
+cgtaagtgttcaaagtggacaataaagacgtggcaaaaacccccgcacataagccgcttt
+agatttcacaaataccaatgcggttaaaaacatccttgagtcgtacatacaccatactcg
+cgttaaacggatataacagaagataataaatccggatgtggagtcggtgtaactatagaa
+agccaagtgaaataatgcttaccagtcatttagctatacggctttcatttcatgtcaaga
+gggtggagtttgacctgtacagttgatatatcaccgatacttagaactcacctaaagcta
+aaattgctcgcagcgtgtaatccgcatattacaaacaatagatgggattcattatacata
+agacacgatgatctgctttttcaggttgcgagatgttgcctatcgtcaatcgagtcctgc
+cttacaccacttaaacaaaagtattgacagggaacctattttcgaggtattatatagtcc
+agcttgaatatcaatttgacagttaacctagtgaaaatcagtaagaggaaatacgccaca
+ttctccagtgaaattctacgggttatcgtctagtccaactatcaattataactcacgaga
+tataagtaaattctcgtacttggcctgatttttattatactttggatccttagtaaacag
+gaagggagaaaccttcaacgaaaaacactggattttgttttactctcaaagctcttatat
+gacggaaataccctgtcaagtcttaactttattactagactaatgaaatgggcttggggt
+ggccagaatcatagtacaatttagcggatacactattcggactttcctatcggctgtctg
+gttggataagtatggggactaataggctagacatacctatacttaaactatacaggcgtc
+atctatctctgcaactttggagttccctgatgttctcccgccctttgggttcacatcttc
+tataccgacacccctaataacgattagtttgtgggttagagtaaattaatacggttaata
+ttaatgtatcgttgaaaagctggtgtcgccaataaggtaaccggctaggcagagtatatg
+tcacgaagtataactaccctaatgataagctgtaggaataaaattaatgctgtctctaag
+cgaagagatatttccgactctgttttaatgacgaatctcattacttctgacttgcaaatg
+ttcaatatggcacggtttcacggcacctttgtgacgcatataatgaacttagaagattat
+aacgacggaactttatatgataatccgttacgattaaagaatctgttaaatatcataatg
+gcattcagttctagaccgtgcatcatggtaaacttactttctctgcatggcgacatacat
+ttcgctattcaaattcgcgtgtggttacacccactcgcacctttggaatattaagagaag
+atgatcagaaaatccattcgctcaatttttctgacgtacgtctaatttatcctaggagac
+aaatcgttttatgtctctcacatttttgaagaaaggttcgagagacaatactcaggtcct
+gaactgctagaagatactcggtggagcgtggcaacaatgaaaaactcgtgacataaatga
+atgatacttttccaagttcagttaagtgaatatgtttaacatacccggcttttcgatctt
+aagctgacgctggacgtgcgagtaatgtcagtctcttacatacactagtgactccaagtt
+tcgtcaaaaacgccccctcccttctcgagcccactcacgctatgtattgacgcgaacttg
+ttcgggatcagacttttcaggagttcggtcgcgtgtccctatgtgctaatatataagtta
+gatcgcattagatgctaatctgaatacttatagacgaccttcaacgagaacgggtaccac
+cttgaggctagagttaggtgtgaaacgacaggtagggacatataaaatttgagtgcggct
+ttagttaagggtttaattacctactcaaacatcacgctcgcgcccttcgtacgtaatcga
+ccatctagaggctaaggggactgtactaggtagtgattaatgatatcctagacgcacgtg
+ccttagatcttcagactctgatggtccgcgatcaccgtaattgtagtcctccaactcgat
+cactttgttggcgtcaaagaaattacgatatctaaatacttataatacaataaccaagga
+tgagaatgactcatcgcgttggagttatattgcttgaagttctatggaatgaaagcacgt
+tatctgccgtcccaatatctccagtgagctaattcattggacggtccactttgatcaatc
+cccgaggagatgttcggacactttagtctgtaacacttagcgttgagaccacgaacaatt
+gattactcagtcttgaaggtgttttccaaagttcattttaaataagactacgataggcct
+ttcctattgatataaactacccggctctgttgttcgtgtgagtcgtacttctctgtgttt
+ttctgattatagcaagattcgattcttagtgtaaacagcgatttttatttgacccgtcaa
+tgagaagcgcataggatctaagcaaaattatcaagttgtgccacaaggtaagatctttcc
+agttattgcaggtaggatgtatcccacgttgatagtatgaggtctgacgtcaactgtcta
+ggagagttgaccgcgtgcgggtacaccggatttgcatcgatgttgagaacgcagaactcc
+cactgtcgtggcggcgttcctgatatttagcaagaggcgttgataaagccctcatcatct
+agatctcgacctcatctgccctcttgctccatcattttctacacagactactttcctatc
+tacgttagtataattgctttctatcttagtatcatttagagcttctccgtcaacaggttc
+gtgctattaaagttagtacgaaagggacaacttgtagcaacgcatttaatcggttttcga
+ctacttcgcacaaaatcagataaagaagtttgtcattctattagacattgaattgcgcaa
+ttgacttgtaccacttatgatcgaacactgaatcaagactgtgattaactaaaatagaca
+agccactatatcaactaataaaaacgcccctggtggtcgaacatagttgactacaggata
+attaattggactggagccattacattctctacaatcgtatcacttcccaagtagacaact
+ttgaccttgtagtttcatgtacaaaaaaatgctttcgcaggagcacattggtagttcaat
+agtttcatgggaacctcttgagccgtcttctgtgggtgtgttcggatagtaggtactgat
+aaagtcgtgtcgctttcgatgagagggaattcaccggaaaacaccttggttaacaggata
+gtctatgtaaacttcgagacatgtttaagagttaccagcttaatccacggtgctctacta
+gtatcatcagctgtcttgcctcgcctagaaatatgcattctatcgttatcctatcaacgg
+ttgccgtactgagcagccttattgtggaagagtaatatataaatgtagtcttgtctttac
+gaagcagacgtaagtaataatgacttggaataccaaaactaaacatagtggattatcata
+ctcaagaactctccagataaataacagtttttacgatacgtcaccaatgagcttaaagat
+taggatcctcaaaactgatacaaacgctaattcatttgttattggatccagtatcagtta
+aactgaatggagtgaagattgtagaatgttgttctggcctcgcatggggtctaggtgata
+tacaatttctcatacttacacggtagtggaaatctgattctagcttcgtagctgactata
+ctcaaggaaccactgctcaaggtaggagactagttccgaccctacagtcaaagtggccga
+agcttaaactatagactagttgttaaatgctgatttcaagatatcatctatatacagttt
+ggacaattatgtgtgcgaaactaaaattcatgctattcagatggatttcacttatgcctt
+agaaacagatattgcccgagctcaatcaacagttttagccggaaacaatcgaagcatagg
+gacaatgtatcttttcctaaattgccatgtgcagatttctgagtgtcacgaagcgcataa
+tagaatcttgtgttgcctcaactcgttgaaaagtttaaaacaatcgcagcagtctttttg
+gggtctactgtgtgtttgcaaaataactgaaagaaacgcttgaacaactctgaagtagct
+cgagtactcattaaagtgtaacacattagtgaatatcggccaatgaaccaaacgcttccc
+ggtacgctatctctctcatcgggaggcgatgtgcaggttatctacgaaagcatcccttta
+cgttgagagtgtcgatgcatgaacctcattgtaacaatagcccagcaaattctcatacgt
+gcctcagggtccgggcgtactcctccatggaagggcgcgcatctagtgttataccaactc
+gctttttaactactatgctgtagttctacaggcatagtggccagtattttctaacttctc
+tggatagatgctctcactcctcatccatcacggcttcagtttacgtcttacttgcttgtt
+cagcaacggatggaggcattaagtatcttcactgttccctaaaattgctgttcaatatca
+aagtaaggacgatacagggaaagctcaagcacactcattgaatactgccccagttgcaac
+ctcacttaatctgacaaaaataatgactactctaagtgttgcggaagcagtctcttccac
+gagcttgtctgtatcacttcgtataggcatgtaactcgatagacacgaacaccgagtgag
+aaactatattcttgcttccgtgtgtgtgacaccaggtaattgatgcggatataagctgga
+gatcactcacgcccacacaaggcgctgctacctctttattccaatgtgtaagaatttgct
+aacttcatttctagaccgcagctttgcggtcataatttcacggtacggacccttgggtta
+gagacttgataacacacttcgcagtttccaccgcgcacatgttttagtggcttctaacat
+agaatttttgttgtgacataaagagtgcgtgggagacttgcccgaccgttaagccataat
+caattgaaagccccgtgagtcacatctaattggttgtactgcgcatttagctatccttta
+gctgactcgaagagattcgattcctaatataggttaattagatggctgccgcgcgaagta
+aaacgtgaaaaacgtagtgcgcagatctgcataactcgcgcttaattacttatgagtagt
+tccaagttcgctacgttatgagagagattggaattaagcaaatatgttttatggtgattt
+tgggatgagaaggactgctaagtacggctactaaacaaatttctaaaaccgccatctacc
+ttatcttggagacatttaagttgtatatgtcactagtctagcttttgtctgtgggacgcg
+ttctcggaatgagggaaatgcaagagccgattcatcaaatgcttatctaagaaagtagtg
+gactattacaccaagcacgaatgccagggaactgctttcttgctcaggacctcgcgacaa
+ggtaccccgcataagtcctagaattacatttggtcagcaatgctgacatttgaccgtgaa
+aacataattttaatcagaaggcagctcacccgcttgctctagatcttatctttgtatgaa
+tgtcagaatttactgcaatatccgttccgaatagtgagggcttagtatagttctctgtat
+acaggtcacatcaaactccccctgtcctagtacagctctgagctttaattaattgcatac
+atttccttcaatcatcagatgaaaacaccgcgaatcatgctcttctcgtatagggcaaga
+gaagcaacaaacaactagcccgactcacgttcatccgccgtatccttgttcagttcttac
+tccgtattaggtcagcgaaatctaatcagaataatcggtcgcgtatcaaaattaaaatcc
+cgcttgaggttgacaattaaaacgctgagcagttatcggctattagatagtggggtgaaa
+gtaattggctggaattatgttaaaacgtgatattaagctaaaatacgctacttgttgccg
+acctaattcagtcattcgatattcagttagagccaagaataacaagcttgtataaattga
+acggggtgcactaaacgatgtgttactctaatattcagcttggagtatacctgaaggcga
+attcatgtatcggccaataataagacgttgaagatcacaatttggactagcaaaagaagg
+tgatttatgcgtggggattgagtccactgtacgagtacggtctctggaaaattataggtt
+cagggaatataaggaagtaaagataattaccaagagatttttggtatcgctatgacccag
+aggtgttctaacgtctgttttgatccgcagaatttctgcctcaatgcatatttgacggac
+ttgaactagagcctctaaagttaaatggcgacgcaactgttcctaaacttcaattattac
+tactctttttttcctagggtattgtagaggccagtggacaaaataaatcaaatttaagat
+gtttcggacattaacatcccccgtagcatagaaatcatcagttatccaatctctcatcga
+gcttttacaatttctgctggcgctatggacagcatatgccgcgagacctccgcaagactc
+acttgatcactgtaagtatcttcattagaggttagagcctatagttaagctgctgaccta
+gtaaaattggtattttctaattttattgctcaagttaaaggttagtgaagggataatgac
+gttatttttgaacaatgggttgtattcaattttatatcacgaatggaacccttcattccc
+ggcataatactagacgacacgaacaagctccgatctatcagccaggcacgtgttaaggtt
+taattccggcaaaccaatgaagcatcaaaaggtgacctgatgcaacttagggtcacgatg
+agtttttcaggactacttattacctattaataagttaacatgagccttcataccccgtaa
+gacaatacatactccaccaattagaattctgagccatcttatctttttgtatcatcgaag
+ggtatggccgaataggttaattagttactcctaacgtctctacaggcatgcatttgacgc
+accttcgaaaatagtcaatctctcgccacacgcgtctagtatgcagcatcaaaaatatag
+tccacggtttccggattaccaaacgcggcaaagagaaacattgtatcgacggagataact
+taatacagaaggaaggggcatcttcgaatacggatgaataattctatctgtttattctga
+catcttgttttcaggttaatcttacgcattcaaatgacgcctgccccatgcgtgcgcaat
+tattttctaatattgacgagagcaatctcactccttttgggtctatttatgttttattga
+ggcacaagcctatacagaacaggtactattaaggccgtgagtgtgagactcaaaccgtgg
+aaacaaaggatgggttgttcttggtacaagttttagtgcatgtgggcaatccttaccaaa
+atcagatgctatccttaactttgggctgcatttaagatggcggttggaggcctgtgagaa
+tcctgcgtgtcatctttaatgaccgaattcatccatgtagattcagatcacacactcatt
+ccttgatgttgtctaaacaaaagttgttgtggacgcattggagggagttaagtaacaact
+tgggatcgcatacttataaaaattatatgttaaactttcacaaacgctgaagtccaaagt
+aactagcccaaacgcctcgagagtcactaggtattaatggtgtttgagttcctgtgaaat
+agtgttcgaaggtaaaatttatgtaccaaatcgaaagaacacttaataaggcttgcttgc
+acggaggtatgatgtttactgactctacaaccctaattttccagtacgtacattcattcc
+aataggttagttctcaaagtgctatacaggctcctcaattgatgatatgcttcagccgct
+ctatggatattagctcattttatttaggaagcccgcttagaggcttactatgagggaaat
+gccaaaatgtcatacttttcggtgtgtcccatatgacaccgctttacatagaatttgaat
+taaaacgcgctctcccgttcactaccatacttggtaccgtgcgcatattacatatagata
+taggatcattttttaaagctgtactaggtttgatcgacaatcttatgctatactatatga
+tgtaaccctcataatcaataccgatcgtacgatcctagcataggtggcaagcgattttat
+gccgattattgtgttaaatagtctgtgagtgtgattatcagggctacgttggtagagggg
+ttgtatagacctcgcacacattgtgacatacttaacaatatacgaaaactgatataataa
+atccccttacccaaacaccaatcccgttgaatcaactaccataacgtctcccatataaat
+tgcctacttgtttgcataaatctgaatacataacaccattgcaccttcttgtgttccaat
+cccgttaagattgccttgtcagatgatatgcaagaacaatagcatttgctagcaattatt
+aacagctcttcgaattgcctccacataacgcgggagggtatattttaatttggcaaatac
+taagtactgttggcgtcatatgctattaacggttggatattaagttatgtcagccgtaag
+caagagtgggcgaaatattttgttacccagtgagagcactcttagagtttggatacaata
+ggccatatgttgacttaagaggacgtaactacgccgtacaccattgttcaaccgacttct
+tggcaaatagaatcgtattagcaatcttaagaatagagacacgttcgtgttagggtatac
+tacaaatccgaaaatcttaagaggatcacctaaactgaaatttatacatatttcaacgtg
+gatagatttaacataattcagccacctccaacctgggagtaattttcagtagatttacta
+gatgattagtggcccaacgcacttgactatataagatctggggatcctaacctgacctat
+gagacaaaattggaaacgttaacagcccttatgtgtacaaagaaaagtaagttgttgctg
+ttcaacagatgatagtcatgacgcgtaacttcactatagtaaattgaaacaaatacgcaa
+tttagacagaatggtacggtcatgaatgacagtaattcgaagtgctagaccaacttaaaa
+taggtaaacgtgcccgaaaccccccttaacagaaagctgctatcatggtgcagtatcgac
+gtgttcagaaacttgtaacttttgagcaggtccgagcacatggaagtatatcacgtgttt
+ctgaaccggcttatccctaagatatatccgtcgcaaactttcgatttagtcccacgtaga
+gcccaagcgttgtgcgactccacgtgcatgcccagaaatacgagtttaaatttggttaca
+tggttaattttgaccgaagcatcgcactttatgattgataattggattcaatatgtcgcc
+ctatgcgaatgcaacatgatccacaatttggctataagacgtttaatccgtatcacactt
+tgtttgcggctagtatagtaacgcccgtgcaccaagagtcagtaacaattataagtactc
+cgcaggtacttcaaatataaaaactaatcaaacacgacccatatgatcatctgaagatat
+ttggaactttctcgacaaccaccctcgtactcaatacttacactaatcgacaggcacacg
+caacgtgtacagtcgcaccatattgagtcaagatttgcttagtggcgatgagcgtacacg
+cttatttctctagtcacaattagttatctacgagacatcacgagggagcaaataagcgat
+gttatggctacacataggcacgtatgaatatgatataagccagttaaacagtcgaaccat
+cgagcaaattctcatgcaccaacccacacgttgaggcacaaagagtaagctgtttgaatg
+taacttcttctgctgagcgggccccaacgtaaggatcaactagaagagaaaactcggtat
+tagtttaaatgcgtcacggagcatgagtgcatttcactaagaatgtctgtgtaaccaata
+taacatctatttgttatctgattgcctacttatggctttgcggtcgtggcgactaatgtc
+tccaatccttttgaggtcggtaccaactccctttaaattacgctgtgcaggctcatgcac
+tgcatacatatacggtagcaggtagggacctcacgcacccttattataatcaatagtagt
+tatcagtcaacgaggcaggaatgctgaggtcgaggtgttggtatattttctatgtgccgt
+ctaggcgactatcacgcattaccaggcgagatttaagccaattttgaatatagtcaacgt
+aatttttactatgggttccaccgaaacgccttgcacaactaagaatcccataaaatatcg
+atatcaaataaaagattgtgtcaataccttcatatatattttttcggttgactaacgtga
+actaaggttaggggttttgtatgtctatataggaaacagtttcttttctgtcctacttta
+gtaaagtcttcaagccttactccaaaatcacggtgattaagccgttactcagcagcatga
+ttctgcctgctcgggtcctaaaatccagccttgtaagagtcgctgtgtattagctaggga
+gacctttgttaaaaaggatatatcgcggcgggatgtgagtgcgtggcgcatactcaatct
+tcagctcgtgtcattataatatctctcccccacgcttttcactagatatgccgtgtaagc
+aaacaccttatgcttaatttcgaaaatattggtacttgaaaaaagctgtaggggtactta
+atgtctggtaggagatcaggagagaattgagtgtaaaaccgtaaagccctcacctgactt
+catgtaaatggcttagaagactccatgatttaataaatactacgaaggaaagactggatc
+taaagataactctagtaaggccaactcccttcaatgctgttgccagttataatccaagag
+ctgtccttttctgaaccatagcggcttctgaagcgaactagaagcaaagttggttctagc
+cagacagccacataccctgtacgggtgtattactaaaactggtccggtattagttcacca
+agggaggaattaggcaaaggatctaggtatgcaagtcggagtattacatccctaccctga
+atccatcaataggttcctctgtactggccttcgcaatgagtattcaaggttgtacagccg
+tataataataagatagtgactatgaacgggaagtaacccgctcaccttccccaaaacatt
+gttatatctaagtattaaagtctgccgtagtgttaatactcgaaaataaacaactggcaa
+attacaccgcacttaagccgcttttgatttatatttttccaatgcgcttttaaaaataat
+tcagtcctacatactaattaagacccttaaacggagatatcacaagttaagttttaacca
+tctcgactaggtggaactatagatacccaactcaatttatcattacctgtaatgttccta
+gaaggattgcatttcatgtcaagacggtggagtttcacagcgaaacttcagtgtgaacag
+attctgagaaatcacctaaacctattagtcagagcacccggttagaaccagttgtcaaaa
+aatagagcggttgcatgagacagaagtaacgatgagatccgttgtaacgttgagacatct
+ggcctatcgtcaatacagtcctcccttaaaaatatttttaaatactaggcaaacccaaca
+taggttagtcctatgtgatacgccacatggtatatcattttgtaacgttacctagggata
+atcaggaagtggaattacgcaaaagtagacagtgaaatgcttagggttatagtctagtcc
+aaagataaaggataaagcacgtcagagaactatattagccgaatgggaatcattgttagg
+agactgtggatcatgtctaaaaagcaacgcagaaacagtcatcgaaaaaatctcgttttt
+gtttgaatctaaaagagctttgatgaccgatagtacctgtatactagttactgtattacg
+tgtctaatgatttcggattggggtccccagaatcagacgtcattgtagacgattcaagtt
+taccaatttaatttcccagctctccttggagaactatcgccaataattgcagtcactttc
+cttttctgaaacgataaagccgtcagagttctctgcaacgttggacttacctgaggttct
+aacccactttcggttctaatagtagttaacgacacaacgaataacctttactgtggggct
+ttcacgatattttttcgcttattattaatggttacgtcataagctggtgtccaaattaag
+gttaccggcttcgcagagtagttgtatccaagtataacttccctaatcataagatcgagg
+tagaaaattaatgctgtctctaaccgaacagatatgtcccactatgtggtatggacgttg
+ctaattacttctgaagggaaattggtcattatggatacgtgtctaccatcaggtcggacg
+cagatatggttctgtcttcagttgatccaccgttctttataggataataactgacgatta
+aagattatggtaaatagattaagccaattctcttcttgtcagtgaagcatccttaactga
+cttgctctgcagcccctcatacatttagctattcaaagtaccggctcgtttcaaactctc
+ccacctttggaagaggttgtcaacttgataagtatatcatttacagcattttttcggacg
+tacctctaatgtttcattgcagaaaattagttttttctatcgcacattttgcaagtaacg
+ttagagacacaattatctgcgaatgaactgctagatctgacgaccgggagcctcgcaaat
+atcaaaaaagactgacatatatcaaggagtcgttgacaagtgctggtaagtcaattggtt
+tatctgtcccggcgtttcgatcttaagctgaccatgcacggcagagtaatgtcactctcg
+ttcttacaagtctgtctccaagggtcggcaaaaaagacccctccattctcgagcccactc
+acgatatgtagggacgacaacttgtgcggcttatgaattgtctggactgcgggcgagggt
+ccatatctccgaagttagaagggacatacctttagatgataagatcaattcttattgacg
+aaattcatccacaacggggaacaacttcaccctagacttacgtctgaaaagacacctagc
+gtcttataaaaggtcagtgccccgtttcgtaaggctggaattacctacgcaaacttaaac
+ctcgcgcccttccttacgtatcgacaagatagaggctatcgcgaatgtactacggaggca
+tgaatcatatactagaaccaagtgcctgtgatattaacaagatgatccgacgcgagcacc
+gtaattctaggcataaaactccagcaatttgggggccgaaaacaaatgacgttagctaat
+taattatatgacatgatcaaaggaggtcaatcacgcatcgagttcgacgtatattcattg
+aacttcgtgcgtttgaaagaaacttttatgaaggcaaaattgatcctgtctcctatttca
+tgcgtacctcctagttgataattccccgagcagtggttaggacacttttgtcggtatcaa
+gttccggtctcaaaacgtaaaattctgtaatctgtatggatggtctgtgaattagttaat
+ttttatgaagtcgtcgagacgcagttcctattgatttattctaaacggagatgtgcttcg
+tgggactcggaagtagatctgtgtttatgattattgctactttagatgctgactgttaac
+tccgtgttgtttttcaaccgtatatcacaaccgaattggatagaacctatagtttcaagt
+tctgccacaaggtatcatatttacagttagtgctggttgcttctttcaaacgtggtgagt
+ttgtgctatcacgtcaacggtagagctcagtggaccgagtgcgcgttcaaccctgttcca
+gagagggtgtgatagcacatataccacgctcgtcgaggcgttcatgatagtttgcaagag
+ccggtgttaaacacatattattattgttatccaactaatcggacctatgcataaagcatt
+gtctaaacagaataattgcctatatacggtagttttagtgatttatatcttagtatcagt
+tagagcttcgaactcttcaggttcctcatatttaacgttcttcgaaagcgaaaacttcta
+caaacgaatgtaagcggttttccaagtagtacctataaatcacagaaagatctgtctcag
+tatagttgaaatggtattcagctagtgacgtgtaccaattatcatagttcactcaagcaa
+gacgctcattaacgaatatagacaagacactatatcatataataaaaaagaacatggtgc
+tcgaacatagttgaattcaccatattgaaggggaatgctgacatgtaattcgctactaga
+cgatcaattccctacttgtcaaagttgaactggtacgttcttggaattaaatatgattgc
+gctggaccaaattgcgacttcttgagtttcagggcaaacgattgagccggaggatgtccg
+tctcttacctttcttgcttatgataaacgacggtccctgtacatcactgggaattctcag
+caaaaataattgggtaaatcgagactcgatgtattcggccacaaaggtgttagacgttaa
+agattattcaacggggcgataataggatcataaccggtatgcaagcgcattgaaagagcc
+atgagatccttatccgataaacgctgcacggtatgtgcagccttattgtcgatcacgaat
+ttataaatgtagtctgggctgtaagttgaagacctaagttataatgaagtgcaataccaa
+atcgattcatagtggattatcagactcaagatatctcctgataaattacagttgttaaga
+tacggataaaatgagatttaagattagcagcctctaatctgtttcaatcccgttggaatg
+tggtatgcgatcaaggttaagttaaaatcaagcctgtcttcagtcttgattcttgttctg
+ccatcgcatgcggtctacgtgagttaatatgtagcttacgttctagcttgtgctaatctg
+agtatagattcgtagaggaatattatcaagcttccacgcctcaacgtacgtgtattggtc
+acacaagacactaaaagtggaagtagcgtaaactatagtctagttgttaaatgctcagtt
+cttgttatattcgatatactcttggctaatttatgtctgagtatataaaattaatgatat
+taacttgcatttcacggatcccttagaaaaagattttgaccgagcgcattataaacggtt
+acaccgaatcaatagaagcatacccaatagctttctttgaatttattgcctgcgcaactt
+ggctgactctctagatccgaataattctatatggtcgtgacgaaactagttcattactgt
+ttaaaatgccaacatgtcttttgggccgataatggctctttgcaaaattactcaatgata
+cgattgatcaaagcggtagttgctagtggtagcatgtaagtctatcaaatgtctgattat
+ccgaaaatcttccaaaagagtccacgtaccatatctatctcatagcgacgcgaggggaac
+cttatctaactatcattccatttaccgggtgactctcgatgcaggatccgattgggataa
+attgcccagaaatggctcattcctgactaagggtaaggccgttctcagcaagggaacccc
+gcgaatctaggcttataccatctagattgttaactacttgcctgtagttctacagccata
+ctggacagttgtttctaaatgatcgggattcatgctagcactcctctgaatgcaccgcgt
+aagtttaactattacgtccgtgggcagataaggatggaggctgtatgtatcttaactgtt
+acctaatatggctggtaattatcaaagtaaggaccttaatgccatagcgctagcaatcgc
+tttgtatactgaccatgtgccaacctctcttaatctgtaaaatataatgtcttagctaac
+tgtggacgatcatgtctctgcctagagcttcgctgtatcaattcctatagccagcgtact
+agtgacacaacaacaccgtgtgagaaaagatattagtccttacgtctgtctctctacagc
+ttattgatgaggattgaacatggacatatagctccccctcaaaagcagatgctacctctt
+tattccattctcgaacatttgccgaacttaatttcgacaaacctgaggtcacgtcttaat
+ttatcggtaacgtcacgtccctttgagactggataaatatattaccaggggccaacgagc
+aattgttggaggcgcttctataatacaaggtgtcttgtcaaagaaagacggcgtgcgtct
+cgtgcaactcacttaaccaatattaatgtgaaacccccctctctcacatcttatgcggtg
+tactgccctggtacatttcctgtacaggactccaacagtgtagattcctaagatagctgt
+tggagttgcctcacgccagatcgaaaaactgaataaactagtgagctgagctgcagaaat
+accgcttaattacttatgactagttcaaagggacctacgtgatgtcagacattgcaagga
+agaaattaggtttgtgcgtcattttggctggactagcactccttacttcccctactattc
+aaatgtcgtaaacagcatgagacaggatcgtgctgacatttaaggtctattgggaacgag
+gctacctttggtcgcgcgctcgcgttctccgaatgaccgaaatgcatgagcacagtatgc
+aattgcttatagatctaaggtctggtcgttgaaaccaagcacgtaggcctgggaaatcag
+ttcttcctcagcaactacacaaaagcgtccaagcattagtacttgtagtaaatgtccgaa
+cctatgcgctcatttgaaagtcaaaaaatatttttaagcagtaggcacctaacccgattc
+ctctacttagtagctttctttgattctcagaattgactgcaatatcactgcacaattctg
+tgccattactagacttctctgtattaacgtctcatcttactaacactcgcctaggacaca
+tctgagagtgaagtatttcaatacatttactgaaatcttcagttctaaaatccccgaata
+aggctcttatcggtttggccaacacaagaaaaaaacttcttgcaccactcaccttcatac
+gcaggagcctggggaacttagtaataactatttcggcagacaaagcttataacaagttgc
+cggcgcgtataatatttaaaagaccccttgagctgctcaattaaaacgctcacctggtat
+aggctattagatagtgccgtcttagtaaggggcgggaattatcggataaactgatatttt
+gataaaataaccgacttgttcacgacataagtcactaaggagattttatctttctccaaa
+gtatatcttccttggataatttcaaagcgctgcaatttaagttctgttactagtttatgc
+tgctgggaggtgaccggaaggcgtagtaatctagaggcaaattataagaagttcatcata
+tcattttcgactacaaaaacaaggtgttgtatgccggcgcattgtgtaaactggacgagt
+accctagatggaaaattatacgttaagccaagatttcgatgtaatgataattacctacac
+atttttgctatccataggaacaagagctgttctataggctcgtggcatacgaacatttgc
+tgccgctatgaatattggaagctcttcaactacagactctattcttaattgccgtcgaaa
+atgggccgaatcggctattattaatactcggtttttccgaggggattgttgtcgacagtc
+gtaattattattaatattgatgttggtgaggtcatttaaatacaaccttgcagacaatga
+ataagggatccaatctctcatactccttttacaattgctcatgcccctatgcaaacctta
+tgccgccacacctccgcaactctctcttctgaactgtaagtagcttcattactggtttga
+gactatactgaagctgatgacattctaaaatggctattttcgaatgtgattcataatgtt
+tatcgtttgggatggcagaatcacgttatttttgatatagcccgggtattctattgtata
+gaacgtatgctacaagtcattccccgaagaagactagaagtaaacaacatgcgaccatcg
+ttaagccacgcaaggctgtagctttatttcccgataacctatcttccataaatagcggac
+agcaggatactgacgctcaacatcagtggttatggtctaatttttaacttttaataaggt
+aacttcagcaggcatacacagtaactctttaatttataatcaaattagaagtctgacact
+tcttatatttttctatcatccaacgcgatcgcccattagcttattgtgttactaataacg
+tatctaaaccaatccttttcaagctactgcctatattgtcaatatatacaaacaacagga
+tagtaggctgcttaaaaaatattgtcaaccgtgtacgctttacaatacccggaaatcaca
+aactttgtagacaacgagtgaaatttatacactacgaagggccagcgtacaagacccatg
+aattaggcgatatgtttattctgacatattggtttatccttaatctgtcgctgtaaaatg
+aagccgcccccatccctgcgaattttttttcgaagattcacgactgaaatataaatacgt
+ttggctatatttatgttggagggaggcaatagcctttactgttaaccgaagatttagcca
+gtgagtgtgacactaaaacactggaataaatgcaggcgttcttctgggtaaaaggtttag
+tcaatctcgcctataagttcatatagctctggatataattatctggcccatgcatttatc
+atggcgcttggtgccctgtgtgaagccggcctctcatattgaaggtccgaagtattccat
+gtacattaagatcactctctcattcatgcatcttggcttaacaaatctggttgtccaagc
+tttccaggcacgtatggtacaaattcggatcgaatacttataaaaatgatatgttaaact
+gtctaaaacgctcatctacaaagtaaagtgcactaaccaatagagtctcaagaccgtgta
+atgctggtgcactgaatgtgtaatacggttagaagggattagttatgttacaaatccatt
+gaaaacttaagaagcattgcgtgctcggagggtgcatcttttatcaagagactaacatta
+ttttcaacgacgtacatgctttacaatagggtacttatcaaacgccgagaaacgcgccta
+tagtgatgttatgattatgacccgatatccattggaccgaattttatgtaggttcccagc
+gtactcgcgtaatatctcggtattgccataatgtaatacttgtcggtctctcccagatga
+aaaagcgttacagagtatttcaatgaaaaacagcgcgcaacgtcaatacctttaggggta
+acggccgctgatttcatatagatatacgataagttggtatagctctactaggtggcatcc
+acaatcgttgcatttactatagctggttacaatcataatctataccgttccttacatact
+accatagcgggatagcgtttttttgccgttgattgggtttaagaggatgtcagtctcatt
+atatccgattcggtgggagagccgttgttttcaaatcgcacactttgtgacataatgtac
+aagataacaaaactgatataagatataaactgtcaatatcaccttgacacttgaatcaaa
+gtaaattaactcgcaaatataatttgactaattgggtgcagatttctcaattaataaaaa
+aatggcaccggatgggcttacaagccccttatcattcacttgtatcatgatttccaagaa
+caatagaatttgctagcaagtatgaacagagattcgaattgcatccacagtacgccggag
+cgtttattttaatgtggatatgacgatgtactgttggcggcatttgctagtaaccggtcc
+ttatttacgtagcgcacacgtaagcatgtctgggagaaatatggtggtacaatctcagag
+aaagattacagtttggtttaaataggacttatcgggtcggaagtggaacttaataagcag
+tacacaattgggcaacagacgtcttgcctattacaataggattacaatgcgttagatttc
+agacacgttcgtgtttggctattcgtcaattccctaaatagttagacgatcaactattat
+caaagtgattctttgttcatcctccattcatgtaacagatggcacactacgcataacgcc
+gaggaattttaacgagatttaagagagcagttcgggcacaacccacttgactttataaca
+gctcggcagcataaacggtaatatgtgacaaatttccaaacgttataagaacgtatgtgt
+acttagaaaactaagtggttcatgttcaacagatgtgacgcagcaagcctaacttatcta
+ttggttttgctataaaagaacaaagttacacagaatcctaagggcttgtttcacacttat
+gcctagtgcttcaccatcttaaaatagcgaaaccggcacgaatcaaaccttaaaacaatg
+cgcagatattggtgatggtgactccgggtatgataatggtaactgttgaccagcgcccac
+ctcatcgaagtatagaaagtggttaggataaggatgagaccgaacttatttccggccata
+actttagattttctacctagtacacaacatcagggcggacacgaaaccgccatcacatca
+tataccaggtttaatttgcttaatgggggaagtgtcaacgaaccttcgaactttagcagg
+catatggccattatatatggccccagagcagaatgctacagcagacaaaatttggattta
+tgtagtttaatacctatcaaacttggtgtgaccatacttgtctaacgacagtgcacaaag
+tgtaagttacaattattactactcagcagcttctgcaatgataaaatcttatcatacacg
+tcacatatgataatatctacttagggggaacgggctccacaacctacatagtactcaata
+cttacactattcgacaggcacaccaaacctgtacagtcccaaaagattgagtcaactttg
+cagtactgcagatcacagtaatagcttagttagcgagtcaaaattagttttctacgagac
+tgcacgaccgtgcaaatttccgatgtgttggctacaaatagcaacgtatgaatttgtttg
+aagccacgtaaactgtacaaccttagagataagtctcaggctactaaaaacacgttgtgg
+cactaacaggatcatggttgattcttacttattcggctgaccggcccaataagtaacctt
+caactagaacagaataatcgggagtagtttaattcagtcaaggtgcaggtctcattgtaa
+ctaacaagctctgtgtaaccaagttaaaatcgttttcttagcggattccctacttatgga
+tttgagctcgtccacaatattcgatacaagaagtttgtggtccgtaacaacgaaatttta
+attacgctgtgcagcctcatccaaggaattaatagaaggttgatggtaggctccgaacgc
+tccatgattataatcaagtggactgtgcagtaaacgaggaaggtatcctgacgtcgtggt
+gttcgtttttgttatttgtgccctatacgagtagataaaccatgaacagcacagtgtgaa
+cccatggttgattttaggctaccttatttttaatttccgttacacagaaacgaattccac
+aactaacatgccattaatttttcgatatcttataaaagatggtcgaaattcattcattta
+ttttttttcggttctcgaaagtcaactaagctgtcgcgttttgtttctctttagaggtaa
+aagtggctttgatctcctacgtttggatactagtcaaccattactccatttgatccgtga
+gtatcacctgtctaacatccagcattatgactcctcggcgaagaaaagacacacttctta
+gagtcgatgtgtattagctagggacacagttgtttaatacgatagtgagcccagggaggg
+cagtgcgtcccccagtagatttattcagctagtgtaagtataagatatctcacccacgag
+gttcaagtgatatgcagtcttagaataatacttatcctgaatttcgatattatgggtact
+tcaataatccgctagcgctactttatgtctcgttggacagcaggacacatggcagtctta
+aacactaaagacatcacctgaatgaatgtaatgggattacaagaatcaatgaggtattat
+atacgacgtaggaaactctggatatatacagtaatctagttacgccatcgcacttcattc
+ctctggaaacttagaagacatcagctgtacgtggaggaaccagacccccgtatgtagcca
+aatagaaccaaagttgcttatacaaacacacccaatgacaatggaccgctggagttcgta
+aactcggaacgtagtactgcacaaacccagcatttagcaataggagctacgtatgcaact
+cccacgtggtaataccttcaagctatcaatatataggtgcctagctaatcgcattcgcaa
+gcagtattcaagcttgtaaaccagtataataattacagaggctctatgaaacccaacttt
+ccagctaaaagtcccaattaaatggttatttcgtacttttaaagtcgcccgttctgttat
+tacgcgaattgattctactccaaaattaaacacaaattatcaaccgtttcatttatattt
+gtcaatgcagctgtttaaaataaggctctactaaattataattaagacacttattaccag
+atttctctagttaagtttgaaccagctcgactaccgcgaaagatacattcccttctctat
+ttttcagttcatctatgggtcagagaagcattgaatttattctattcaccctcgtcgttc
+acagcgaatcgtcagtgtgatcagtgtatgagaaatatcctaaaccgtttagtcagacca
+cacgcttagaacaagtggtctaaaaagactgccctggaaggagtaagaagtatacagctg
+atccggtgtatccttcagtcatctgccctatactaattacacgacgcaaggaaaaatagg
+tttattttctaggcaaacccttcataggtgactccgatgtgttacgaatcatgcttgaga
+atgtgctatcgttaccgacggataataacgatctccaatgaaccaaatgtagaatgtcta
+ttgattacccttttactattcgacttagagataggagatagaacctcagtgtactttttt
+agccgaatgggaatctttgggaggtgaatggccataaggtcgtaaatccaaccctcttaa
+agtcttccatattatatcgttgttcgtggaatcgataacagatttgttgacccatagtaa
+atgtatactagtttatgttgtaagtgtagattgttttccgattgccgtccaaactttatg
+tcgtaattgtagaccagtaaagttgaccaaggtaagtgcccagcgatcctgcgagatcga
+tcgccaatttttccagtcactgtaagtgtaggtttagataaagccgtatgagttatatca
+taagggcctcggaaagcagcttcgaaccaaagttcccttataatagtagtttaactataa
+aagtatatactggtctgtcgccctttcacgatttgttttaccggtttatgaagcgttacg
+tcattagagcggctccaatttaaggttaacggcttccatgtgtagttgtatacaaggata
+acttaaagtatctgttcagcgagctagttaagttatcctcgatagaacacaactcagagg
+tcccaagatcgggtttgcaacttgctaatttattctcaaggcaaattgggaattatcgat
+acctgtataccataaggtcgctcgatgtgatgcttatgtcttctggtgatcctaccttag
+ttagtgctgattaacggaacattaatgtttatcgttttgagatttagccaattctctgat
+tctaactcaagatgccttatctgacgtgctatgcagcccctaagtattttacattgtaat
+aggacacgctcctttaaaactcgccaaaaggtcgttgtggttctctactggttaactata
+taatttacagctttgttgagctagttcctctttggtttaagtcctcaatattagttggtt
+cgagcgataagttggctagttaccttagtcactatattagatccgaatgttatgcttcat
+ctgaagaccgccaccctccaaaatttcttttaagactcacttattgcaaggtgtaggtga
+attcggctcgtttctcaagtggtgtatctgtacacgagtttccatattttcatcaacagc
+caccgcacacttatgtcactctaggtattaaaagtcgctctacaaggggacgcaattaag
+aaacagacatgctagtcaaaaataaacatagcgaggcaccactaattcggccgcttatca
+atgggatgctctgcgcgagacgcgccagagctcagtagttagttcggacatacatttact
+tcagatgatcaattagttttctacaaatgcttactctaccccgaaaaaagtcaccagact
+cttacgtctctttagtatccttccgtcttatataaggtcagtcccccgtttcggtaccct
+ggaatttactaagaataatgaaacagcccccaaggacgtacgtttacaaatgatagacca
+gatcgcctagcttattccgacgcatgttgcatagaattgaaccaacggaatgtgagagta
+actagatgagccgaccacagcacccgtttgcgtcgcagaatacgcctgatagttcggcca
+cgaaatcatatgtcctttgagtattaagtatttgtaatgatcaatcgagctcaagcaagc
+ttacacttcctcggatattcagggaacttagtgcctttgaaagatacgttgatcaacgaa
+aaattgataatggctcatatggaatgcctacctcatagtgctgaattaacacagcactgc
+ggacctaacttttcgaggtttcaagttcacgtctcaaaacctaataggctggaatatgta
+gggatcctcggtgaatttgtgattgggtttgttgtagtactgaccaagtgaatattcttt
+ttttctaaaagcagatctgctgccgggcactacgaaggagatctctgtgtatcattattg
+cttcttgacatgatgactcttaaatcactgtgggtgtgcaaaacgatagcacaacccaat
+tcgatagtacatattgttgatacttcgcactaaaccgttcatatttaaaggttgtgctcc
+ttccttcgttaaatactggtgacttggtcctatctactattagctagacctctggggaac
+cacgcccccgtaaaacctgtgcaagagagggggtcatacatcttagacatcgcgcctcca
+ccagggaagcattgggtgattgaccaggtgtgtaacaaatatgattattcttatactaat
+attagcaaagatgcataatgatttgtattaaatgtataattgaattgataagggtctttt
+agtcagtgatagagtagtataaggtagacattagaactcttaaccggacgcagatttttc
+ggtcttagtaagccaattagtcgacaaaacaaggtaagagcggttactagtagtacctat
+aatgcactgaatcttcggtcgaagtatagttctaatgctatgcagattgtgacggcgaca
+aatgttcagacttatatcatgaaacaagctcttgtaagtattgacaaatgaaaagattga
+atatttttaaatacaaaatgcgcctacttattaggggaattaaccagattgaaggccaat
+cctcacatgtaatgagataatagacgataaatgaaattcttgtaatagttgaactgctac
+gtgatgggtattatatatgattgagatcctccaattgccgacgtcttgtcttgatgccca
+aaagattgtcaacgaggagctccctcgcgtacctgtcgtccgtatcataaacgacgcgac
+atgtacagcactccgaagtataagcaataataatgcgggtaatccagactagatcttttc
+ggactcaatgcggtttcacggtaaacatgattaataccggagagtagtcgagcttatcag
+cgatgcaagcgaattcattgtgccaggagatacgttgcagataaaaccggcaacgtatgt
+caacaagttttggcgatctcgttgtttgtattcgacgaggcgcgggaacttcaagaacta
+tcgtatattcaagtccattaccttttagtttcagactggtggagctgactaaagttatat
+catcattttgtacactggtttagttaacgataatttcagatttaacatgaccagacgata
+atcgctgtatatccagttggaatgtggtttgccagaaaggttaacttataatcaagcctc
+tcttcagtcttgattcgtcgtatcccatccattgcgctatacctcagtgtatttggagct
+gtagttataccgtgtgctaagatcagtagacatgacgagagcaatattatctaccttaca
+agcatcaacggacgtctagtcggaacaaaagactctaaaactcgaacttcaggttaatat
+actatagttctgtattcagcagttattcttatattcgatattatcttgcctattggatgt
+ctgactttagtatattaatcatagtatctgccatgtaaaggtgccagtactaaatctgtt
+tcacagtgcgaattataaacggttacaaccattaaagacaacaagaccctatagctttat
+ttgaattttgtcaatgcgcaacttggagctcgcgatacatcccaattagtctatagggtc
+gggacgattctacggcatttctggttataatgacaacatggattgtggcccgagaatcgc
+tctttcattaattaagcaatcattacagtcttataagcgctacttccgagtggtagcagg
+taactcgatataaggtcgcatgagccgaatagcttaaaaaacaggccaccgaacattgat
+agagaataccgaccacagcgcaacctttgattactttcattaaattgtacggctcactcg
+acatcaagcttaagattgcgataatgtgaactcaaatggatcagtactgaagaaccgtaa
+cccacttcgcagaaagcgtacccagagaagatacgctgttacaatatacagggtgaaatt
+attgcctgttcttcgtaaccatttcgccaaacttggttagaaatgatagccattcatgat
+agaaataagctgaatgataccagtatctttaactatgtagtcagggggaagataacgatg
+gtccatgtatgtttctgatatgtgacagtattggccgcgtaatttgctaacgaagctact
+taatgcctttgagcttcatatagatttctttaatcaaaatcggcaaaaagatagtatgag
+ctataatatatgctagtagagaactctggaccatcatctatatgaatactgattcgagcg
+tgcaattactttagcctgcgtactactgactctacaaaacactctgagataagtttgtag
+tcagtaagtcgctctctataaaccttttggatgaccattgtacagccacttatagatccc
+aataaatagcacaggagacagagtttttcaatgctcgatcatttgccgatagtattttcg
+tctaacctcagggcacctattatttgatacctaacctaacggccctttcacaatggagaa
+atatatgacatcgggacaaacacaaatggtgggtggccaggagatatgacatggtggcgt
+ctctaagaaacacggactccctctaggcaaactcacgtaaccaattttaatgtcaaacaa
+aacgctcgaaaagattttgccgtgtaatgacctggtacattgactggtcaggaatacatc
+actgtagttgccgtagtgtcctgttggtgttccatcaagacacatcgtataacgcaattt
+acgacggacatcagatcaagttatacagattatttaagtatcacgtgtgcattgggacat
+aagggatctcacacatgccttggaacatttttgctttgtgccgctttttcgctgcactac
+caatccttacttaccagtatattcaaaggtcgttaacagaatgagaaaggttagggctct
+aagttatcgtcgattgggatagacgagacatttgcgagcgccctccacggatacgaatct
+cccatatcaatgtgaactggatgctatgcagtttagttcttacgtctcctagtggtaaaa
+atcaaagtagcactcgcatagcagttattcagaacctaatacacaaaaccgtcaaacatt
+ttctaattctaggtatgggccgatcataggagctaaggtgaaactcataaatgttttgtt
+agatctagcatcctaaaaagatgcatatactgagtagctggcgtgcattctctcaattgt
+atcctttttaactgaactagtcggtcccatttcgtgactgagatctattaaccgataaga
+ttaataacactcgcattcgtatcagctcagagtgaagtttttcaataatttgactgatat
+attaacttctaaaataaccctttaagcctcggatccgtttcccaatcacatcaaaaattc
+ttattccaactatctacggattaacaacgtgcatggggatcgtagtaagaacttgttccg
+atcactttgagtatatcaagttgacggcccggttattattgaatagaaacattcacctgc
+taaattaaataccgcacatcggatacccgatttcagagggccgtcttactaagggcaggc
+tttgttcggtttaactgagatgttcattattttacagtatgcttcaactaatatgtaacg
+aaggacagtggatctgtctccatagtagatcttcagtcgtgaatttcataccgctcctat
+ttaagttcgcgttcgagttgttgatcatggcacgtgaaagcaacccctagtattctagac
+gaaaattttttctagttcatctgataatttgccaattcaaaaacaaccgctggtttcccg
+gcgcattctctaaaatggaagtcgaacctagagccattatttgtcggtaacccatgagtt
+ccttcttttcagaagttaatacactgtggtcctatacagaggaaaaacagcggttatata
+cgatcgtggcataacaacattggatcaagatagcaatttggctacctattctaattctca
+ctagattcggtattccactacaatatcggcagattaggattggatgaataatcggtgttt
+aagtccggttgcgtctccaatctcctaatttttattaatattgatcttggtgacctattg
+taaataaaaacttcaagactttgaataacggtgaaaagatagaagactcatttgaaaatg
+gatcatccacagatccaaacattagcaagacactaatccccaactagctattctgatcgc
+gatcgtgctgcagtactcctgtcacaatagtctgttcatgatctaattctttttgggctt
+tgttcgatggtgattcagaatctttatccggtcgcttccctgtagctactttgtggggat
+attgcccggggattatagggttgagatcgtttcctaaaagtatttaaaccaagtagactt
+caactaaactacatcagaacatcgtgaagacaccatacgcggtacctttatttaccgata
+acatttcttcaagaaataccggtaagcagcataatgaccctaaacagctcggggtatcgt
+cgtagttttaaattttatttaggttactgctcaaggaataaaaactaactatttaattta
+taataatattacaaggctcacactgattagatttgtctataagacttcgcgatcccccat
+taccggattgtcttaagaataaactagataaaccatgcattttctagataaggcctttag
+tctaattagatacaaaaaacacgatagttgcatccttaatttattgtgtcaaacctggaa
+ccttttaattacccgcaaatcactttatgtcgagactacctctgaaatttattatctacc
+taccgcatgaggacttgaaccatcttgtaggagttatgtttattagctaagattcgttta
+tcctgtagcggtccatgtatattcaacaagcaaaaagcactcagaattgtttttagttga
+gtcaagactgatatataaataagtttccctagttttttcgtggtgggacgatattgaatt
+gaatcttaaccgaagagtttcccactctgtcgcacaataatacacgccaatatttccagc
+cctgcttatgccttaatcggttactcaatctcccattgaagttcattttgatctgcatag
+aagtttcgggcccagccttttttctgccaccttcctccaagctctgtagacgcactctaa
+gattgatgctcacatgtattaattctacattaacataaatatataagtcatgcatcttcg
+agtaaaatatctggttctccaacatgtcctggcacgtatcgttataatgcccatacatgt
+agtattaaaatgattgggttaactggatattaagatcatcgaaattgtaaagtcaaatta
+acaatactgtctcaagaccgtgtattcctcgtgctcggaagggctattacgcttacttcc
+gttttggtatcttaatatgactttcaaaaattaagttgcagtgagtcctacctgcgtgca
+tcggttagcaagagtataaaagttgtttaaacgaactacttgctttacaataccggtcgt
+atatatcgccgtgaatccagaagattgtcttctttggattatcaaccgagatcctgtgga
+ccgatgttttgggaccttcacagaggactccaggtagagctcgcttttgcattaatctaa
+gaattgtacctctctaaaagatctaaaacagtgaatgtgtatttcatggaaaaacacaga
+gaaacgtaaattactttaggccgaaaggcacatgagttattatacatatacgagatggtg
+gtatacatcgaattcggggcatacactatagttgcattgtatttagctgctttaaataat
+atgatattaccttccttacataagacattaccggcataccctggttttcaacttgtgggg
+ctttttgacgatcgcactctcatttgatccgagtagggcggtgacccctgcttttcaaat
+acaaaaatttcgctatgaaggtaatagattacttttcgctgttatgatagaaacggtaaa
+tttaaaattgaaacttctagaaaagtaaagtaacgagaaatgattttgtgaataatgcgg
+tcatgattgcgcaagtaagaaaaaaaggcaaaaggatgcgcggaatagaaacttatcagt
+cacgggtatcttgatttcattcttcttgtcaattgccgacataggatgaaatcagattcc
+aatgcaatacacagtaacccccacccttgattgtaatgtcgatttgaagttgtacgcgtc
+gacgaagtggatagtatacgggccttttgtacggtgcgatcaactatgaatctcggcgag
+ttagatggtcgtacaatctcacacatagaggtcacttgcctgtaatgacgaattttcggc
+taggtactcgaactttattagaagtaaaaatgtgggcaaaagaaggattccattttacaa
+gacgattacaatgagttacatgtctctcaacgtagtctttccctagtagtctttgaacta
+tttaggtactccagaaaattttagcaaagggtttctgtgtgaatccgccattcatgttta
+tgatggaacaataagaataacgccctcgtatgttatcgacagtgaagtcagcagttcggc
+caaaaacatattcaatttagtacagatccccagaagttaagctaagtgctctaaaatggc
+ctaaacggttatcaaagtaggtctaattactatactaacgggtgcatcgtaataactgct
+gtcgatgcaacactatatgatagtgtcgttttgctatatatgtacaatgtgacaaagaag
+ccttagcgattcttgcaaacttaggacttcggattctcaatcttaaatgtccgaaaacgc
+aaagattcaaaaatttaatctatgagcagatatgcctgatggtgactacgcgtatgttaa
+ggctaaatgttgacaaccgcacacataatcgaactattgatagtcgggagcataaccagg
+tgaacgtactttgttcacgacatttattgacatgttctaaatacgtctcaaaatcacggc
+gcactagaaaacgcaatcaaatcattgtcctggtttaagggccgtaatgccggtagtgtc
+aaacttcatgagaactttagctggcttttggccagtatttagggaccaagagcactagcc
+ttaagctgaatattttgccatttatctactgttataactttaaaacttggtggcaccaga
+cttgtcgatacacacgcatcaatctgtaacgtaaaaggtttactaagaacaagcgtagga
+attgagtttatattatatttaaactaaaagatgatattagcttctgagggcgatagggct
+ccaaatcataaagaggaatatattattacacgattagaaacccacaacatacctcgaatc
+gcccaaaagtttgacgaaacttggcagtactccacatctcagtaatacagttgggagagt
+ctcaaatgttgttttattactcaatgaaccaccctcataatttcactgctgttccattaa
+atttgcaaacgatcatttgctttgaagaaacgtaaaatcgacaaaattacagataagtag
+atgcataataaaaaaaactgctcgctataacacgatcatcgtgcattcttacttaggagc
+atcacccgcacaataacgtaccttaaactacaacactattagaccgagtactgtaattca
+cgaaagctcaagctcgcattgtaaagaacttgctctctcgtaaaatgtgataatagtttg
+cggagaggattcaattattttccattgcacctactccactagattcgataaaagaaggtg
+gtcctcccttaaaaagaaatgttaagtaacatcggaaccataagcaaagcatgtaagtga
+accgtcatccttccctaagaaacataaaggtttttaataatgtcgactgtgaactataac
+tgcatcctttcctgacctactccggttccttgttgttatttctgaacgagaccagtagat
+aaacaatgtaaaccacagtgggtaccaatggtgcatgtgacgctaccgttgttttaagtg
+cccgtacaaacataagaagtcataatcttacttgaaattaattttgccttttattttttt
+tcaggctcgaaattaatgatttgttttttttgaccttctagttacgctaatatgcggtcg
+cctgtggtttctattgagtcctataacgggatgggatctaatacgtttggttactagtaa
+acaaggtataaatttgataccggagtatcaactgtataacatcaagctttatgactcata
+cgcgaagtaatgacacaaggctttcaggagatcgcgagtacagagccactaaggggtgta
+ttacgatagtgacaccaccgagcgcactcactccccaagtagatttatgatcctacgcta
+agtattagatatataaccaaagaggttctagtcagtgcaactcttagaataataattagc
+cggttttgcctttttaggcctaatgcaatattcagctagcccttatgtatctcgcgttcc
+acagcaccactcatggcacgcgtttaaactaatcaaatataatctatgaatgttatgcca
+gtacttgaataaatcaggttttttataagtccttgcatactctcgttatatactgttaga
+gtcttaccccatagaaattctttcatctgcaaacttagaagaattctcagctacggggag
+cataaagtccccaggatgttgacaaatacaacaaatgtggcttatacaaacactccatat
+gaaaatcgaaccctcgtggtagttttagccgaaccttgtacggataaatccctccatttt
+ccaatagcagatacctatcctactacctcgtggtattaaattaaagcttgaaatatagag
+ctgcatagcttatccaattcccaagcacgagtctaccgtcgtaaccacgatttgatttac
+agacgctagagcaaacccatctttaaacatataagtaaaaattaaagggtgagtgcgtac
+gtgtttactagcaacttcgcttattaagacaattgtttataagccataattaaaaacata
+tgttcaacaggttcattgatatttgtaattgcacaggtttttaataaggatctacgtaag
+tataatgaacaaactttttaccagagttatattctgtactttgaaaatgctcctctaccg
+ccttagagactttcaattagattttttgcagttaatctatgcgtaagtgaaccatgcaag
+ggatgcgattcaaccgcctcgtgctaaccctatcgtctgtctcataactgtaggtctaat
+ataattttcagttttcgaacacataaccctttgaaaatctgctatttaatgtctcacctg
+catgcactatcttctatactgctcagaacggctatacgtcactatgctccaagtgacgat
+ttaaacgaagcaaggaataataggtttattttagtgcaaaacaattaagtgcggactacg
+tgctctttacaataagccttgtgattgggctataggttaagtcccatattaacgatctcc
+aatgtacaaaatcgacaatcgctttgcattacccggttactagtcgaattacagatagct
+gttagatactcactctaattttggacaacaatcccaatcttggggtcgtctatcgcctga
+agctcgtaaatccttccatcttaaacgattacatattatagacttgttcggggtagagat
+atcacagttgtgcaaacattgtaaatcgatactagtttatgttggtagtctagttgcttt
+taccattccccgaaaaacttgatctactatttcgacaacagtaaacttgaactaggtaag
+tgaaaacagagaatgcctcatagtgccactatttgtccactatatgtaagtgtagcttta
+cataatccactatgactgagatcattacggcctaggaaagcagcgtagaaaaaaagggcc
+cggatattacgactgtaactataaaactagttactggtagcgcgccatgtatagatttgt
+tttaccggttgtggttgcgttaacgaatttcagccgcgaaaattgatccgttaaccagtc
+catctcgacttctataaaacgataaagtaaagttgatgttcagcctccttcttatggttg
+catcgagagtacactactcagtgggaaatagatcggggttcctacttcagattgtattat
+ctaggcaattgccgattgtgccatacctggataaaataagctacctacatgtgatgctta
+tctattatcgtcatactaccttagggtgtcctgttgaacgctacattaatctttagccgt
+ttgagatgttccaatggataggagtctaacgcatgatgaagtttaggaaggcagagcatc
+ccactaagtatgtgacagtgtatttcgaaacgagacgttataaatagaaaaaaggtcctt
+ctggttctattctgctgaactattgaatggaaagattggttgacctacgtactatttgct
+tgaagtcatcaatttgacggggtgagagacatatggtgcatactttacggactctatatt
+ttagatcagaagcttagcagtcttctctacaccccctcacgacataattgcttttaagaa
+tctatgtttgattcctctacgggaattcggatccgttcgcatgtgcggtttatctaaacc
+aggggacatatgttcagctaaagcatacgaacactttgctaactagacgtatgtatagta
+gctataaatcccgacgatatttacaaaaagaaatgagactcaaatatatacatagcgacc
+ctacacttattcgcaccctgatctaggcgatcctagcacccacacccgaaagtgagcact
+agtgtcttccgtattaaatttactgcagttgagattttagttgtctactaaggattactc
+taacccgtaataaggatcaagactcggtactagctttactatcattccctatgtgttttc
+ctaactcacaagggtacgtaccagcctatgtaattacaataatgataaagacacaaagga
+agtaactttacaaatgagtctccagttacactagcttagtccctcccatcttgctttgaa
+gtctaaatacgcaatctctgaggatatacagcagaagaacactcataacgttggagtcca
+agaattagactcatagggcccccaacatttaatatgtactgtgagtttgaaggtgttcta
+ttgttaattcctgctcttgatacatgacacgtactccgtgtttaaggcttcggactgact
+ttctttcataagttgagcaacgaaaatttcagaatcgataagttggattcactaactaat
+acggctgattgaaaactccactccggacctatatggtcgacctttatacgtaaccgatat
+aaaacttataggctggtatatcgagccttcctagcgcaatttcggatggggtttcttcta
+ctactcaacaacggaatagtctttgtttagtaaaccagagctcaggacgcccaatacgta
+ggagagcgctgtggagcatgtgtcattatggactggagcactcttaaatcactctgcgtg
+tgctaaacgatagatcataacatgtcctgagtaaattttcttgatacgtcgcaatatacc
+gttattagttaaacgttctcatccgtcatgcgtgaaatacggctgtcgtgctcagatata
+ctattagcgactcatctcgcctaacacgcacacgtataaactcggaatgactgccgctct
+tacatattagaaatacagactacaccacggaagcattgggtcattctcaaccgctgtata
+aaagatgattagtcttataataagattaccaaagaggcagaatcatgggtagtaaatcta
+ttattcaagtgattaccgtcgtgtaggcagggagtgaggacgagatggtactcaggacaa
+atattaaccggacgaagtggtttacgtcgtactttcactattagtagtaaatacaaggta
+acaccggggaatagtactaaatataatgatatctatcttcgggagaacgagtcgtctatt
+gctttgaacattctcaaggcgtaaaatgtgctgacttatagcatgatacaaccgattgtt
+acttttgtctattcaaaagattgaatagttttttatacaaaagccgcatacttatgacgg
+ctagtatacagtttcatcccctagcatcaatgctatggacagtattgaacttataggaaa
+ttcttctaatagggcaaatccgtcgtgatgcctattttttttcagtcacatcctcaaatg
+gcactagtattgtcgggatcccattaacaggctcaaccacgagctcacgcgaggacatgt
+agtccgtatctttaacgaagcgacagcgacagaactcccatggataaccaattataaggc
+ccgtaatcctctagacatcgtttaccaataaatccgctttctccgtaatcatgttgaata
+ccccagagtagtccagatgataaccgatgaaacacaagtctttctcaatgcacttacggt
+gaacttattaccgccaacgtagctcatcaaggttgcgacatctagttgtgtgtttgcgac
+gagcccagcgaacttcatcaactttcgtatattcaacgccttgtaattttactttaagac
+gcctggtgatgtagattcttagataatcagtttgttatcggctgtactttaccataattt
+cacaggtttcaggtcaagaagattatagctgtatatacagttccatgctcggtgcacaga
+aacgtgatcggataataatcaatcgcttatgtcgtctttaggcgtatccaatacatgccc
+cgataccgcagtgtatttcgacatgtaggtataccgtcgcatttgagctcgagtcaggac
+gtcagctagattagattccttaatagaatataccgacctctagtccgaactaaactatag
+ataacgccaacttcaggttaattgtctagtcgtctgtttgcagatgggattcttagatga
+gtgagtatcggccatattggttcgagcactttagtttttgatgcataggatatgcaatgt
+atagctgaaagtactttatctgtttcaaactcacattgattaaaccggtaaacctttaaa
+gactacaagaaaatattcagtgagggcaattttgtcaatcacaatcttccagctagagat
+acttcacaatttgtcttgaggctacgcaacattagacggattttcgcgttttattgaaat
+aatcgaggggcccaagagtatccatagttcattttgtaagatttctttacaggcttatta
+cagcttcttcagactcctacatgcttacgagttatatgctagcatgtgaacaatagatta
+atatacaggaaaacgtacattgagagagatgaccctacacagcgcaaccgttgagtactt
+tcattaaagggtaacgctctcgagacagcatccttaagatggccttattgtcaaatcatt
+tgcagaagtacgcaagatccctaaccaacgtagaagaatccctacaaacacatgagacgc
+ggtgaaaatagacagggtgttagtattcaatcttcggagtatcaatttcgccaatcttgg
+tgagaaagcataccctttcttcagagaaagaagatcaatcataacactatctttaacgag
+gtacgcacgcgcatcattacctgcctccatggatctttaggatagcggaaagtattggca
+gcgtattgtgatttcgttcctactttatcaatttcacattcatatacatgtcttttatca
+aaatcgccaataagataggatgagctatattagatgctagtagagttcgcgccaacatca
+tcgataggaatactcaggacagcgtgataggacttttcaatccctaatactctctataat
+tataactctctcttaagtttggaggcagtaacgcgctctatataatcagtttgctgcacc
+attcttcagcctctgatacatacaaataaattccacagcagtaagagggtttaattgaga
+catcttgggaacttaggattttactctaacatcaccgaaacgattattggataccgtacc
+taaacgaactttctcaaggcagtaatataggacatccgcaataacacaaatgctgcctcc
+ccaggagttatgtcttcctggaggctatatcttacacccactcactataggcaaactaaa
+gtttaaatgttgattgtctaaaaaaaagatagataagagttggccggcgtagcacatgcg
+aaagtgaatcgtaagctataattctctggacttgaagttctgtcctgttcctctgcaaga
+aacaaacttcctttaaagctatttacgacgcacatctcagcaagttataaacatgttgga
+agtttctagtcggaattcccaaagaacggatctatctaatgcattcctacatttttcctg
+tctgccgatggtgccatcctattcaaagaatttcttaaaagtagattaaatgggactttt
+aacaatgagtaaccttacgcctctaagggttcctcgagtgccatacaccagtcaggtccg
+agccacatacacggagaacattctaacatagcattctcaactcgatcatttgcaggttac
+ttctttcctatcctagtgctaaaaatcatacttgcaatcccatagcacggattaagaacc
+taagaaacaattcagtaaaacatgttcgaattcttggtatgggaacatcattgcagctat
+ggtctaacgcattaatgtttgggtacatcttccatcatataaacaggaagagtctgacga
+cagggagtgcttgcgatcatgtctatcattgtgaaatcaaattgtagctcacatgtcgtc
+tatgagagcgtgtatccgataagatttagaaaaatagaagtcgtataagatctcactgaa
+cttttgaatgaatgtgaagcatatatgatctgctttaataaaactttatccataggatac
+gtttccaaatcaattcaataattattagtcaaaatagataaggatgaacaacctgaaggc
+cgatcggacgtagaaagtggtcccatcactttgagttgatattgttgaaccacacgttat
+tatggttttcaaacagtctcaggatattgtatatacagataatccgataccagttgtctg
+acgcccctcttacgtaccccaccctttgtgacgtttaaagcagttgttcagtattttaaa
+ctaggcggcaactaatttggaaagaagcacagtggatatgtctaaattcttgttattcag
+gcctgaatttaatacaccgcatagttaacttcgcggtagagttgttcatcatgcctcctc
+taagctaccacttctatgatacaccaatagttgttctacggaatctgataattggccaag
+tcataaacttccgctgcgttcaacccccttgctcgaatatccaactcgaaaagacagcct
+tttggtgtccggaacaaatcagttacttcttttctgatgttaattctctgtggtcagata
+cagaccaaaaactccgcggatttaccatcctccaagaacaaatttgcatcaacatagcat
+tttggctacatattctaagtctcaatagtttaggttttcaactacattatcccaacatta
+ggattggaggaataatagctgggtaagtccccttgcgtctacaatcgactattttttatg
+aatatgcttctgccgcacctatggttattaaaaaagtcatgactttgaagaaccctgaaa
+agatagatgaatcaggtgtaatggcagcagccaaagagcatataattagcaacactctaa
+gaacattatagatatgatgatagcgatcgtcatgatgttatccggtcacaatagtagctt
+catcagctaattcgttttgccagtggtgacttgcgctggaagaatcgttatacggtccct
+tccctcttgatacggtgggggcttattcaaccgcgtggattgggttgtcatacttgcatt
+aaacgatgtaaaccatctagtagtcaactatactaaatcacaaaatagtgatcaatacat
+acccgcttcatggttttaaccatttaattgattaaagatattccgctaagaaccattatc
+tacctaaactgatcgccgtatcctagtagtttgaaatttgatgtaccgtaatgatcaacg
+aagtaaaacgttatattgtatgtagaataataggtcttggagctaaatgatgtgattggt
+agtgaagacttacccttacaactttaccggtttctcggaagaatatactagagaatcaat
+gcatgggctacataagcactttagtctaatgagataaaaaatacacgagtcttccatcat
+gaattttttgtcgaaaaactcgaacctggtaatttaaaccatatatctttatgtcgtcaa
+taactctcatatgttttatataacttcccaatcacgacttgtaactgcttgttcgactga
+gctgtttgagctatgaggccgggatccggttgagctacatctatttgctacaagaaaaat
+gaaagcacatttgttgggagttctggctacactcatagagaaataagtggcccgagtggg
+tgcggcctgcctccatattcaagtgtatcttaaaccaagtggttccaacgctcgcgctaa
+agaattaaagcctttatttcctccacggagtagcccgtaatccggttcgaaagagaccat
+tgaagttaattttcatatccagtgaagtttaggcacaagcatgtgttctgccacatgcct
+caaagcgctcttcaaccaagatatgattcatcctaacttcgatgaatgcgtctgtaacat
+aaatatagaaggaatgattcggcgagttaattttcgccttctccaacatggcatccctac
+gttcgttataaggaccatacatgtaggttttaaaggtttgcggttaatcgatatttacat
+catagaaattctatagtcaaatttacaagactctagatactcactcgttgcagccggcta
+ggaagcgctttgtaccttacttcccttttcgttgcgtaatatgaatttcatatagtaagt
+tcaaggcactcatacctccgtgaagagggtagatagactattaaagttgtttaatagtac
+gtattgatggaaatgacccgtaggagatttaccactcaatccacaagattcgctgctgtg
+cattatcaaaacagtgcatgtcgaaacatgggttgggtccttcaaacacgaatccaggta
+gagatacctttgcaattttt
diff --git a/crates/regex/examples/regexdna-output.txt b/crates/regex/examples/regexdna-output.txt
new file mode 100644
index 0000000..d36baa5
--- /dev/null
+++ b/crates/regex/examples/regexdna-output.txt
@@ -0,0 +1,13 @@
+agggtaaa|tttaccct 0
+[cgt]gggtaaa|tttaccc[acg] 3
+a[act]ggtaaa|tttacc[agt]t 9
+ag[act]gtaaa|tttac[agt]ct 8
+agg[act]taaa|ttta[agt]cct 10
+aggg[acg]aaa|ttt[cgt]ccct 3
+agggt[cgt]aa|tt[acg]accct 4
+agggta[cgt]a|t[acg]taccct 3
+agggtaa[cgt]|[acg]ttaccct 5
+
+101745
+100000
+133640
diff --git a/crates/regex/examples/shootout-regex-dna-bytes.rs b/crates/regex/examples/shootout-regex-dna-bytes.rs
new file mode 100644
index 0000000..773fd9b
--- /dev/null
+++ b/crates/regex/examples/shootout-regex-dna-bytes.rs
@@ -0,0 +1,68 @@
+// The Computer Language Benchmarks Game
+// https://benchmarksgame-team.pages.debian.net/benchmarksgame/
+//
+// contributed by the Rust Project Developers
+// contributed by TeXitoi
+// contributed by BurntSushi
+
+use std::io::{self, Read};
+use std::sync::Arc;
+use std::thread;
+
+macro_rules! regex {
+    ($re:expr) => {
+        ::regex::bytes::Regex::new($re).unwrap()
+    };
+}
+
+fn main() {
+    let mut seq = Vec::with_capacity(51 * (1 << 20));
+    io::stdin().read_to_end(&mut seq).unwrap();
+    let ilen = seq.len();
+
+    seq = regex!(">[^\n]*\n|\n").replace_all(&seq, &b""[..]).into_owned();
+    let clen = seq.len();
+    let seq_arc = Arc::new(seq.clone());
+
+    let variants = vec![
+        regex!("agggtaaa|tttaccct"),
+        regex!("[cgt]gggtaaa|tttaccc[acg]"),
+        regex!("a[act]ggtaaa|tttacc[agt]t"),
+        regex!("ag[act]gtaaa|tttac[agt]ct"),
+        regex!("agg[act]taaa|ttta[agt]cct"),
+        regex!("aggg[acg]aaa|ttt[cgt]ccct"),
+        regex!("agggt[cgt]aa|tt[acg]accct"),
+        regex!("agggta[cgt]a|t[acg]taccct"),
+        regex!("agggtaa[cgt]|[acg]ttaccct"),
+    ];
+    let mut counts = vec![];
+    for variant in variants {
+        let seq = seq_arc.clone();
+        let restr = variant.to_string();
+        let future = thread::spawn(move || variant.find_iter(&seq).count());
+        counts.push((restr, future));
+    }
+
+    let substs = vec![
+        (regex!("B"), &b"(c|g|t)"[..]),
+        (regex!("D"), &b"(a|g|t)"[..]),
+        (regex!("H"), &b"(a|c|t)"[..]),
+        (regex!("K"), &b"(g|t)"[..]),
+        (regex!("M"), &b"(a|c)"[..]),
+        (regex!("N"), &b"(a|c|g|t)"[..]),
+        (regex!("R"), &b"(a|g)"[..]),
+        (regex!("S"), &b"(c|g)"[..]),
+        (regex!("V"), &b"(a|c|g)"[..]),
+        (regex!("W"), &b"(a|t)"[..]),
+        (regex!("Y"), &b"(c|t)"[..]),
+    ];
+    let mut seq = seq;
+    for (re, replacement) in substs {
+        seq = re.replace_all(&seq, replacement).into_owned();
+    }
+
+    for (variant, count) in counts {
+        println!("{} {}", variant, count.join().unwrap());
+    }
+    println!("\n{}\n{}\n{}", ilen, clen, seq.len());
+}
diff --git a/crates/regex/examples/shootout-regex-dna-cheat.rs b/crates/regex/examples/shootout-regex-dna-cheat.rs
new file mode 100644
index 0000000..1bde7ab
--- /dev/null
+++ b/crates/regex/examples/shootout-regex-dna-cheat.rs
@@ -0,0 +1,90 @@
+// The Computer Language Benchmarks Game
+// https://benchmarksgame-team.pages.debian.net/benchmarksgame/
+//
+// contributed by the Rust Project Developers
+// contributed by TeXitoi
+// contributed by BurntSushi
+
+// This technically solves the problem posed in the `regex-dna` benchmark, but
+// it cheats by combining all of the replacements into a single regex and
+// replacing them with a single linear scan. i.e., it re-implements
+// `replace_all`. As a result, this is around 25% faster. ---AG
+
+use std::io::{self, Read};
+use std::sync::Arc;
+use std::thread;
+
+macro_rules! regex {
+    ($re:expr) => {
+        ::regex::Regex::new($re).unwrap()
+    };
+}
+
+fn main() {
+    let mut seq = String::with_capacity(50 * (1 << 20));
+    io::stdin().read_to_string(&mut seq).unwrap();
+    let ilen = seq.len();
+
+    seq = regex!(">[^\n]*\n|\n").replace_all(&seq, "").into_owned();
+    let clen = seq.len();
+    let seq_arc = Arc::new(seq.clone());
+
+    let variants = vec![
+        regex!("agggtaaa|tttaccct"),
+        regex!("[cgt]gggtaaa|tttaccc[acg]"),
+        regex!("a[act]ggtaaa|tttacc[agt]t"),
+        regex!("ag[act]gtaaa|tttac[agt]ct"),
+        regex!("agg[act]taaa|ttta[agt]cct"),
+        regex!("aggg[acg]aaa|ttt[cgt]ccct"),
+        regex!("agggt[cgt]aa|tt[acg]accct"),
+        regex!("agggta[cgt]a|t[acg]taccct"),
+        regex!("agggtaa[cgt]|[acg]ttaccct"),
+    ];
+    let mut counts = vec![];
+    for variant in variants {
+        let seq = seq_arc.clone();
+        let restr = variant.to_string();
+        let future = thread::spawn(move || variant.find_iter(&seq).count());
+        counts.push((restr, future));
+    }
+
+    let substs = vec![
+        (b'B', "(c|g|t)"),
+        (b'D', "(a|g|t)"),
+        (b'H', "(a|c|t)"),
+        (b'K', "(g|t)"),
+        (b'M', "(a|c)"),
+        (b'N', "(a|c|g|t)"),
+        (b'R', "(a|g)"),
+        (b'S', "(c|g)"),
+        (b'V', "(a|c|g)"),
+        (b'W', "(a|t)"),
+        (b'Y', "(c|t)"),
+    ]; // combined into one regex in `replace_all`
+    let seq = replace_all(&seq, substs);
+
+    for (variant, count) in counts {
+        println!("{} {}", variant, count.join().unwrap());
+    }
+    println!("\n{}\n{}\n{}", ilen, clen, seq.len());
+}
+
+fn replace_all(text: &str, substs: Vec<(u8, &str)>) -> String {
+    let mut replacements = vec![""; 256];
+    let mut alternates = vec![];
+    for (re, replacement) in substs {
+        replacements[re as usize] = replacement;
+        alternates.push((re as char).to_string());
+    }
+
+    let re = regex!(&alternates.join("|"));
+    let mut new = String::with_capacity(text.len());
+    let mut last_match = 0;
+    for m in re.find_iter(text) {
+        new.push_str(&text[last_match..m.start()]);
+        new.push_str(replacements[text.as_bytes()[m.start()] as usize]);
+        last_match = m.end();
+    }
+    new.push_str(&text[last_match..]);
+    new
+}
diff --git a/crates/regex/examples/shootout-regex-dna-replace.rs b/crates/regex/examples/shootout-regex-dna-replace.rs
new file mode 100644
index 0000000..20694e0
--- /dev/null
+++ b/crates/regex/examples/shootout-regex-dna-replace.rs
@@ -0,0 +1,17 @@
+use std::io::{self, Read};
+
+macro_rules! regex {
+    ($re:expr) => {{
+        use regex::internal::ExecBuilder;
+        ExecBuilder::new($re).build().unwrap().into_regex()
+    }};
+}
+
+fn main() {
+    let mut seq = String::with_capacity(50 * (1 << 20));
+    io::stdin().read_to_string(&mut seq).unwrap();
+    let ilen = seq.len();
+
+    seq = regex!(">[^\n]*\n|\n").replace_all(&seq, "").into_owned();
+    println!("original: {}, replaced: {}", ilen, seq.len());
+}
diff --git a/crates/regex/examples/shootout-regex-dna-single-cheat.rs b/crates/regex/examples/shootout-regex-dna-single-cheat.rs
new file mode 100644
index 0000000..70a979c
--- /dev/null
+++ b/crates/regex/examples/shootout-regex-dna-single-cheat.rs
@@ -0,0 +1,75 @@
+// The Computer Language Benchmarks Game
+// https://benchmarksgame-team.pages.debian.net/benchmarksgame/
+//
+// contributed by the Rust Project Developers
+// contributed by TeXitoi
+// contributed by BurntSushi
+
+use std::io::{self, Read};
+
+macro_rules! regex {
+    ($re:expr) => {
+        ::regex::Regex::new($re).unwrap()
+    };
+}
+
+fn main() {
+    let mut seq = String::with_capacity(50 * (1 << 20));
+    io::stdin().read_to_string(&mut seq).unwrap();
+    let ilen = seq.len();
+
+    seq = regex!(">[^\n]*\n|\n").replace_all(&seq, "").into_owned();
+    let clen = seq.len();
+
+    let variants = vec![
+        regex!("agggtaaa|tttaccct"),
+        regex!("[cgt]gggtaaa|tttaccc[acg]"),
+        regex!("a[act]ggtaaa|tttacc[agt]t"),
+        regex!("ag[act]gtaaa|tttac[agt]ct"),
+        regex!("agg[act]taaa|ttta[agt]cct"),
+        regex!("aggg[acg]aaa|ttt[cgt]ccct"),
+        regex!("agggt[cgt]aa|tt[acg]accct"),
+        regex!("agggta[cgt]a|t[acg]taccct"),
+        regex!("agggtaa[cgt]|[acg]ttaccct"),
+    ];
+    for re in variants {
+        println!("{} {}", re.to_string(), re.find_iter(&seq).count());
+    }
+
+    let substs = vec![
+        (b'B', "(c|g|t)"),
+        (b'D', "(a|g|t)"),
+        (b'H', "(a|c|t)"),
+        (b'K', "(g|t)"),
+        (b'M', "(a|c)"),
+        (b'N', "(a|c|g|t)"),
+        (b'R', "(a|g)"),
+        (b'S', "(c|g)"),
+        (b'V', "(a|c|g)"),
+        (b'W', "(a|t)"),
+        (b'Y', "(c|t)"),
+    ]; // combined into one regex in `replace_all`
+    let seq = replace_all(&seq, substs);
+
+    println!("\n{}\n{}\n{}", ilen, clen, seq.len());
+}
+
+fn replace_all(text: &str, substs: Vec<(u8, &str)>) -> String {
+    let mut replacements = vec![""; 256];
+    let mut alternates = vec![];
+    for (re, replacement) in substs {
+        replacements[re as usize] = replacement;
+        alternates.push((re as char).to_string());
+    }
+
+    let re = regex!(&alternates.join("|"));
+    let mut new = String::with_capacity(text.len());
+    let mut last_match = 0;
+    for m in re.find_iter(text) {
+        new.push_str(&text[last_match..m.start()]);
+        new.push_str(replacements[text.as_bytes()[m.start()] as usize]);
+        last_match = m.end();
+    }
+    new.push_str(&text[last_match..]);
+    new
+}
diff --git a/crates/regex/examples/shootout-regex-dna-single.rs b/crates/regex/examples/shootout-regex-dna-single.rs
new file mode 100644
index 0000000..b474059
--- /dev/null
+++ b/crates/regex/examples/shootout-regex-dna-single.rs
@@ -0,0 +1,57 @@
+// The Computer Language Benchmarks Game
+// https://benchmarksgame-team.pages.debian.net/benchmarksgame/
+//
+// contributed by the Rust Project Developers
+// contributed by TeXitoi
+// contributed by BurntSushi
+
+use std::io::{self, Read};
+
+macro_rules! regex {
+    ($re:expr) => {
+        ::regex::Regex::new($re).unwrap()
+    };
+}
+
+fn main() {
+    let mut seq = String::with_capacity(50 * (1 << 20));
+    io::stdin().read_to_string(&mut seq).unwrap();
+    let ilen = seq.len();
+
+    seq = regex!(">[^\n]*\n|\n").replace_all(&seq, "").into_owned();
+    let clen = seq.len();
+
+    let variants = vec![
+        regex!("agggtaaa|tttaccct"),
+        regex!("[cgt]gggtaaa|tttaccc[acg]"),
+        regex!("a[act]ggtaaa|tttacc[agt]t"),
+        regex!("ag[act]gtaaa|tttac[agt]ct"),
+        regex!("agg[act]taaa|ttta[agt]cct"),
+        regex!("aggg[acg]aaa|ttt[cgt]ccct"),
+        regex!("agggt[cgt]aa|tt[acg]accct"),
+        regex!("agggta[cgt]a|t[acg]taccct"),
+        regex!("agggtaa[cgt]|[acg]ttaccct"),
+    ];
+    for re in variants {
+        println!("{} {}", re.to_string(), re.find_iter(&seq).count());
+    }
+
+    let substs = vec![
+        (regex!("B"), "(c|g|t)"),
+        (regex!("D"), "(a|g|t)"),
+        (regex!("H"), "(a|c|t)"),
+        (regex!("K"), "(g|t)"),
+        (regex!("M"), "(a|c)"),
+        (regex!("N"), "(a|c|g|t)"),
+        (regex!("R"), "(a|g)"),
+        (regex!("S"), "(c|g)"),
+        (regex!("V"), "(a|c|g)"),
+        (regex!("W"), "(a|t)"),
+        (regex!("Y"), "(c|t)"),
+    ];
+    let mut seq = seq;
+    for (re, replacement) in substs {
+        seq = re.replace_all(&seq, replacement).into_owned();
+    }
+    println!("\n{}\n{}\n{}", ilen, clen, seq.len());
+}
diff --git a/crates/regex/examples/shootout-regex-dna.rs b/crates/regex/examples/shootout-regex-dna.rs
new file mode 100644
index 0000000..b96518e
--- /dev/null
+++ b/crates/regex/examples/shootout-regex-dna.rs
@@ -0,0 +1,68 @@
+// The Computer Language Benchmarks Game
+// https://benchmarksgame-team.pages.debian.net/benchmarksgame/
+//
+// contributed by the Rust Project Developers
+// contributed by TeXitoi
+// contributed by BurntSushi
+
+use std::io::{self, Read};
+use std::sync::Arc;
+use std::thread;
+
+macro_rules! regex {
+    ($re:expr) => {
+        ::regex::Regex::new($re).unwrap()
+    };
+}
+
+fn main() {
+    let mut seq = String::with_capacity(51 * (1 << 20));
+    io::stdin().read_to_string(&mut seq).unwrap();
+    let ilen = seq.len();
+
+    seq = regex!(">[^\n]*\n|\n").replace_all(&seq, "").into_owned();
+    let clen = seq.len();
+    let seq_arc = Arc::new(seq.clone());
+
+    let variants = vec![
+        regex!("agggtaaa|tttaccct"),
+        regex!("[cgt]gggtaaa|tttaccc[acg]"),
+        regex!("a[act]ggtaaa|tttacc[agt]t"),
+        regex!("ag[act]gtaaa|tttac[agt]ct"),
+        regex!("agg[act]taaa|ttta[agt]cct"),
+        regex!("aggg[acg]aaa|ttt[cgt]ccct"),
+        regex!("agggt[cgt]aa|tt[acg]accct"),
+        regex!("agggta[cgt]a|t[acg]taccct"),
+        regex!("agggtaa[cgt]|[acg]ttaccct"),
+    ];
+    let mut counts = vec![];
+    for variant in variants {
+        let seq = seq_arc.clone();
+        let restr = variant.to_string();
+        let future = thread::spawn(move || variant.find_iter(&seq).count());
+        counts.push((restr, future));
+    }
+
+    let substs = vec![
+        (regex!("B"), "(c|g|t)"),
+        (regex!("D"), "(a|g|t)"),
+        (regex!("H"), "(a|c|t)"),
+        (regex!("K"), "(g|t)"),
+        (regex!("M"), "(a|c)"),
+        (regex!("N"), "(a|c|g|t)"),
+        (regex!("R"), "(a|g)"),
+        (regex!("S"), "(c|g)"),
+        (regex!("V"), "(a|c|g)"),
+        (regex!("W"), "(a|t)"),
+        (regex!("Y"), "(c|t)"),
+    ];
+    let mut seq = seq;
+    for (re, replacement) in substs {
+        seq = re.replace_all(&seq, replacement).into_owned();
+    }
+
+    for (variant, count) in counts {
+        println!("{} {}", variant, count.join().unwrap());
+    }
+    println!("\n{}\n{}\n{}", ilen, clen, seq.len());
+}
diff --git a/crates/regex/rustfmt.toml b/crates/regex/rustfmt.toml
new file mode 100644
index 0000000..aa37a21
--- /dev/null
+++ b/crates/regex/rustfmt.toml
@@ -0,0 +1,2 @@
+max_width = 79
+use_small_heuristics = "max"
diff --git a/crates/regex/src/backtrack.rs b/crates/regex/src/backtrack.rs
new file mode 100644
index 0000000..4d83856
--- /dev/null
+++ b/crates/regex/src/backtrack.rs
@@ -0,0 +1,282 @@
+// This is the backtracking matching engine. It has the same exact capability
+// as the full NFA simulation, except it is artificially restricted to small
+// regexes on small inputs because of its memory requirements.
+//
+// In particular, this is a *bounded* backtracking engine. It retains worst
+// case linear time by keeping track of the states that it has visited (using a
+// bitmap). Namely, once a state is visited, it is never visited again. Since a
+// state is keyed by `(instruction index, input index)`, we have that its time
+// complexity is `O(mn)` (i.e., linear in the size of the search text).
+//
+// The backtracking engine can beat out the NFA simulation on small
+// regexes/inputs because it doesn't have to keep track of multiple copies of
+// the capture groups. In benchmarks, the backtracking engine is roughly twice
+// as fast as the full NFA simulation. Note though that its performance doesn't
+// scale, even if you're willing to live with the memory requirements. Namely,
+// the bitset has to be zeroed on each execution, which becomes quite expensive
+// on large bitsets.
+
+use crate::exec::ProgramCache;
+use crate::input::{Input, InputAt};
+use crate::prog::{InstPtr, Program};
+use crate::re_trait::Slot;
+
+type Bits = u32;
+
+const BIT_SIZE: usize = 32;
+const MAX_SIZE_BYTES: usize = 256 * (1 << 10); // 256 KB
+
+/// Returns true iff the given regex and input should be executed by this
+/// engine with reasonable memory usage.
+pub fn should_exec(num_insts: usize, text_len: usize) -> bool {
+    // Total memory usage in bytes is determined by:
+    //
+    //   ((len(insts) * (len(input) + 1) + bits - 1) / bits) * (size_of(u32))
+    //
+    // The actual limit picked is pretty much a heuristic.
+    // See: https://github.com/rust-lang/regex/issues/215
+    let size = ((num_insts * (text_len + 1) + BIT_SIZE - 1) / BIT_SIZE) * 4;
+    size <= MAX_SIZE_BYTES
+}
+
+/// A backtracking matching engine.
+#[derive(Debug)]
+pub struct Bounded<'a, 'm, 'r, 's, I> {
+    prog: &'r Program,
+    input: I,
+    matches: &'m mut [bool],
+    slots: &'s mut [Slot],
+    m: &'a mut Cache,
+}
+
+/// Shared cached state between multiple invocations of a backtracking engine
+/// in the same thread.
+#[derive(Clone, Debug)]
+pub struct Cache {
+    jobs: Vec<Job>,
+    visited: Vec<Bits>,
+}
+
+impl Cache {
+    /// Create new empty cache for the backtracking engine.
+    pub fn new(_prog: &Program) -> Self {
+        Cache { jobs: vec![], visited: vec![] }
+    }
+}
+
+/// A job is an explicit unit of stack space in the backtracking engine.
+///
+/// The "normal" representation is a single state transition, which corresponds
+/// to an NFA state and a character in the input. However, the backtracking
+/// engine must keep track of old capture group values. We use the explicit
+/// stack to do it.
+#[derive(Clone, Copy, Debug)]
+enum Job {
+    Inst { ip: InstPtr, at: InputAt },
+    SaveRestore { slot: usize, old_pos: Option<usize> },
+}
+
+impl<'a, 'm, 'r, 's, I: Input> Bounded<'a, 'm, 'r, 's, I> {
+    /// Execute the backtracking matching engine.
+    ///
+    /// If there's a match, `exec` returns `true` and populates the given
+    /// captures accordingly.
+    pub fn exec(
+        prog: &'r Program,
+        cache: &ProgramCache,
+        matches: &'m mut [bool],
+        slots: &'s mut [Slot],
+        input: I,
+        start: usize,
+        end: usize,
+    ) -> bool {
+        let mut cache = cache.borrow_mut();
+        let cache = &mut cache.backtrack;
+        let start = input.at(start);
+        let mut b = Bounded { prog, input, matches, slots, m: cache };
+        b.exec_(start, end)
+    }
+
+    /// Clears the cache such that the backtracking engine can be executed
+    /// on some input of fixed length.
+    fn clear(&mut self) {
+        // Reset the job memory so that we start fresh.
+        self.m.jobs.clear();
+
+        // Now we need to clear the bit state set.
+        // We do this by figuring out how much space we need to keep track
+        // of the states we've visited.
+        // Then we reset all existing allocated space to 0.
+        // Finally, we request more space if we need it.
+        //
+        // This is all a little circuitous, but doing this using unchecked
+        // operations doesn't seem to have a measurable impact on performance.
+        // (Probably because backtracking is limited to such small
+        // inputs/regexes in the first place.)
+        let visited_len =
+            (self.prog.len() * (self.input.len() + 1) + BIT_SIZE - 1)
+                / BIT_SIZE;
+        self.m.visited.truncate(visited_len);
+        for v in &mut self.m.visited {
+            *v = 0;
+        }
+        if visited_len > self.m.visited.len() {
+            let len = self.m.visited.len();
+            self.m.visited.reserve_exact(visited_len - len);
+            for _ in 0..(visited_len - len) {
+                self.m.visited.push(0);
+            }
+        }
+    }
+
+    /// Start backtracking at the given position in the input, but also look
+    /// for literal prefixes.
+    fn exec_(&mut self, mut at: InputAt, end: usize) -> bool {
+        self.clear();
+        // If this is an anchored regex at the beginning of the input, then
+        // we're either already done or we only need to try backtracking once.
+        if self.prog.is_anchored_start {
+            return if !at.is_start() { false } else { self.backtrack(at) };
+        }
+        let mut matched = false;
+        loop {
+            if !self.prog.prefixes.is_empty() {
+                at = match self.input.prefix_at(&self.prog.prefixes, at) {
+                    None => break,
+                    Some(at) => at,
+                };
+            }
+            matched = self.backtrack(at) || matched;
+            if matched && self.prog.matches.len() == 1 {
+                return true;
+            }
+            if at.pos() >= end {
+                break;
+            }
+            at = self.input.at(at.next_pos());
+        }
+        matched
+    }
+
+    /// The main backtracking loop starting at the given input position.
+    fn backtrack(&mut self, start: InputAt) -> bool {
+        // N.B. We use an explicit stack to avoid recursion.
+        // To avoid excessive pushing and popping, most transitions are handled
+        // in the `step` helper function, which only pushes to the stack when
+        // there's a capture or a branch.
+        let mut matched = false;
+        self.m.jobs.push(Job::Inst { ip: 0, at: start });
+        while let Some(job) = self.m.jobs.pop() {
+            match job {
+                Job::Inst { ip, at } => {
+                    if self.step(ip, at) {
+                        // Only quit if we're matching one regex.
+                        // If we're matching a regex set, then mush on and
+                        // try to find other matches (if we want them).
+                        if self.prog.matches.len() == 1 {
+                            return true;
+                        }
+                        matched = true;
+                    }
+                }
+                Job::SaveRestore { slot, old_pos } => {
+                    if slot < self.slots.len() {
+                        self.slots[slot] = old_pos;
+                    }
+                }
+            }
+        }
+        matched
+    }
+
+    fn step(&mut self, mut ip: InstPtr, mut at: InputAt) -> bool {
+        use crate::prog::Inst::*;
+        loop {
+            // This loop is an optimization to avoid constantly pushing/popping
+            // from the stack. Namely, if we're pushing a job only to run it
+            // next, avoid the push and just mutate `ip` (and possibly `at`)
+            // in place.
+            if self.has_visited(ip, at) {
+                return false;
+            }
+            match self.prog[ip] {
+                Match(slot) => {
+                    if slot < self.matches.len() {
+                        self.matches[slot] = true;
+                    }
+                    return true;
+                }
+                Save(ref inst) => {
+                    if let Some(&old_pos) = self.slots.get(inst.slot) {
+                        // If this path doesn't work out, then we save the old
+                        // capture index (if one exists) in an alternate
+                        // job. If the next path fails, then the alternate
+                        // job is popped and the old capture index is restored.
+                        self.m.jobs.push(Job::SaveRestore {
+                            slot: inst.slot,
+                            old_pos,
+                        });
+                        self.slots[inst.slot] = Some(at.pos());
+                    }
+                    ip = inst.goto;
+                }
+                Split(ref inst) => {
+                    self.m.jobs.push(Job::Inst { ip: inst.goto2, at });
+                    ip = inst.goto1;
+                }
+                EmptyLook(ref inst) => {
+                    if self.input.is_empty_match(at, inst) {
+                        ip = inst.goto;
+                    } else {
+                        return false;
+                    }
+                }
+                Char(ref inst) => {
+                    if inst.c == at.char() {
+                        ip = inst.goto;
+                        at = self.input.at(at.next_pos());
+                    } else {
+                        return false;
+                    }
+                }
+                Ranges(ref inst) => {
+                    if inst.matches(at.char()) {
+                        ip = inst.goto;
+                        at = self.input.at(at.next_pos());
+                    } else {
+                        return false;
+                    }
+                }
+                Bytes(ref inst) => {
+                    if let Some(b) = at.byte() {
+                        if inst.matches(b) {
+                            ip = inst.goto;
+                            at = self.input.at(at.next_pos());
+                            continue;
+                        }
+                    }
+                    return false;
+                }
+            }
+        }
+    }
+
+    fn has_visited(&mut self, ip: InstPtr, at: InputAt) -> bool {
+        let k = ip * (self.input.len() + 1) + at.pos();
+        let k1 = k / BIT_SIZE;
+        let k2 = usize_to_u32(1 << (k & (BIT_SIZE - 1)));
+        if self.m.visited[k1] & k2 == 0 {
+            self.m.visited[k1] |= k2;
+            false
+        } else {
+            true
+        }
+    }
+}
+
+fn usize_to_u32(n: usize) -> u32 {
+    if (n as u64) > (::std::u32::MAX as u64) {
+        panic!("BUG: {} is too big to fit into u32", n)
+    }
+    n as u32
+}
diff --git a/crates/regex/src/compile.rs b/crates/regex/src/compile.rs
new file mode 100644
index 0000000..90ca250
--- /dev/null
+++ b/crates/regex/src/compile.rs
@@ -0,0 +1,1264 @@
+use std::collections::HashMap;
+use std::fmt;
+use std::iter;
+use std::result;
+use std::sync::Arc;
+
+use regex_syntax::hir::{self, Hir};
+use regex_syntax::is_word_byte;
+use regex_syntax::utf8::{Utf8Range, Utf8Sequence, Utf8Sequences};
+
+use crate::prog::{
+    EmptyLook, Inst, InstBytes, InstChar, InstEmptyLook, InstPtr, InstRanges,
+    InstSave, InstSplit, Program,
+};
+
+use crate::Error;
+
+type Result = result::Result<Patch, Error>;
+type ResultOrEmpty = result::Result<Option<Patch>, Error>;
+
+#[derive(Debug)]
+struct Patch {
+    hole: Hole,
+    entry: InstPtr,
+}
+
+/// A compiler translates a regular expression AST to a sequence of
+/// instructions. The sequence of instructions represents an NFA.
+// `Compiler` is only public via the `internal` module, so avoid deriving
+// `Debug`.
+#[allow(missing_debug_implementations)]
+pub struct Compiler {
+    insts: Vec<MaybeInst>,
+    compiled: Program,
+    capture_name_idx: HashMap<String, usize>,
+    num_exprs: usize,
+    size_limit: usize,
+    suffix_cache: SuffixCache,
+    utf8_seqs: Option<Utf8Sequences>,
+    byte_classes: ByteClassSet,
+    // This keeps track of extra bytes allocated while compiling the regex
+    // program. Currently, this corresponds to two things. First is the heap
+    // memory allocated by Unicode character classes ('InstRanges'). Second is
+    // a "fake" amount of memory used by empty sub-expressions, so that enough
+    // empty sub-expressions will ultimately trigger the compiler to bail
+    // because of a size limit restriction. (That empty sub-expressions don't
+    // add to heap memory usage is more-or-less an implementation detail.) In
+    // the second case, if we don't bail, then an excessively large repetition
+    // on an empty sub-expression can result in the compiler using a very large
+    // amount of CPU time.
+    extra_inst_bytes: usize,
+}
+
+impl Compiler {
+    /// Create a new regular expression compiler.
+    ///
+    /// Various options can be set before calling `compile` on an expression.
+    pub fn new() -> Self {
+        Compiler {
+            insts: vec![],
+            compiled: Program::new(),
+            capture_name_idx: HashMap::new(),
+            num_exprs: 0,
+            size_limit: 10 * (1 << 20),
+            suffix_cache: SuffixCache::new(1000),
+            utf8_seqs: Some(Utf8Sequences::new('\x00', '\x00')),
+            byte_classes: ByteClassSet::new(),
+            extra_inst_bytes: 0,
+        }
+    }
+
+    /// The size of the resulting program is limited by size_limit. If
+    /// the program approximately exceeds the given size (in bytes), then
+    /// compilation will stop and return an error.
+    pub fn size_limit(mut self, size_limit: usize) -> Self {
+        self.size_limit = size_limit;
+        self
+    }
+
+    /// If bytes is true, then the program is compiled as a byte based
+    /// automaton, which incorporates UTF-8 decoding into the machine. If it's
+    /// false, then the automaton is Unicode scalar value based, e.g., an
+    /// engine utilizing such an automaton is responsible for UTF-8 decoding.
+    ///
+    /// The specific invariant is that when returning a byte based machine,
+    /// the neither the `Char` nor `Ranges` instructions are produced.
+    /// Conversely, when producing a Unicode scalar value machine, the `Bytes`
+    /// instruction is never produced.
+    ///
+    /// Note that `dfa(true)` implies `bytes(true)`.
+    pub fn bytes(mut self, yes: bool) -> Self {
+        self.compiled.is_bytes = yes;
+        self
+    }
+
+    /// When disabled, the program compiled may match arbitrary bytes.
+    ///
+    /// When enabled (the default), all compiled programs exclusively match
+    /// valid UTF-8 bytes.
+    pub fn only_utf8(mut self, yes: bool) -> Self {
+        self.compiled.only_utf8 = yes;
+        self
+    }
+
+    /// When set, the machine returned is suitable for use in the DFA matching
+    /// engine.
+    ///
+    /// In particular, this ensures that if the regex is not anchored in the
+    /// beginning, then a preceding `.*?` is included in the program. (The NFA
+    /// based engines handle the preceding `.*?` explicitly, which is difficult
+    /// or impossible in the DFA engine.)
+    pub fn dfa(mut self, yes: bool) -> Self {
+        self.compiled.is_dfa = yes;
+        self
+    }
+
+    /// When set, the machine returned is suitable for matching text in
+    /// reverse. In particular, all concatenations are flipped.
+    pub fn reverse(mut self, yes: bool) -> Self {
+        self.compiled.is_reverse = yes;
+        self
+    }
+
+    /// Compile a regular expression given its AST.
+    ///
+    /// The compiler is guaranteed to succeed unless the program exceeds the
+    /// specified size limit. If the size limit is exceeded, then compilation
+    /// stops and returns an error.
+    pub fn compile(mut self, exprs: &[Hir]) -> result::Result<Program, Error> {
+        debug_assert!(!exprs.is_empty());
+        self.num_exprs = exprs.len();
+        if exprs.len() == 1 {
+            self.compile_one(&exprs[0])
+        } else {
+            self.compile_many(exprs)
+        }
+    }
+
+    fn compile_one(mut self, expr: &Hir) -> result::Result<Program, Error> {
+        // If we're compiling a forward DFA and we aren't anchored, then
+        // add a `.*?` before the first capture group.
+        // Other matching engines handle this by baking the logic into the
+        // matching engine itself.
+        let mut dotstar_patch = Patch { hole: Hole::None, entry: 0 };
+        self.compiled.is_anchored_start = expr.is_anchored_start();
+        self.compiled.is_anchored_end = expr.is_anchored_end();
+        if self.compiled.needs_dotstar() {
+            dotstar_patch = self.c_dotstar()?;
+            self.compiled.start = dotstar_patch.entry;
+        }
+        self.compiled.captures = vec![None];
+        let patch =
+            self.c_capture(0, expr)?.unwrap_or_else(|| self.next_inst());
+        if self.compiled.needs_dotstar() {
+            self.fill(dotstar_patch.hole, patch.entry);
+        } else {
+            self.compiled.start = patch.entry;
+        }
+        self.fill_to_next(patch.hole);
+        self.compiled.matches = vec![self.insts.len()];
+        self.push_compiled(Inst::Match(0));
+        self.compile_finish()
+    }
+
+    fn compile_many(
+        mut self,
+        exprs: &[Hir],
+    ) -> result::Result<Program, Error> {
+        debug_assert!(exprs.len() > 1);
+
+        self.compiled.is_anchored_start =
+            exprs.iter().all(|e| e.is_anchored_start());
+        self.compiled.is_anchored_end =
+            exprs.iter().all(|e| e.is_anchored_end());
+        let mut dotstar_patch = Patch { hole: Hole::None, entry: 0 };
+        if self.compiled.needs_dotstar() {
+            dotstar_patch = self.c_dotstar()?;
+            self.compiled.start = dotstar_patch.entry;
+        } else {
+            self.compiled.start = 0; // first instruction is always split
+        }
+        self.fill_to_next(dotstar_patch.hole);
+
+        let mut prev_hole = Hole::None;
+        for (i, expr) in exprs[0..exprs.len() - 1].iter().enumerate() {
+            self.fill_to_next(prev_hole);
+            let split = self.push_split_hole();
+            let Patch { hole, entry } =
+                self.c_capture(0, expr)?.unwrap_or_else(|| self.next_inst());
+            self.fill_to_next(hole);
+            self.compiled.matches.push(self.insts.len());
+            self.push_compiled(Inst::Match(i));
+            prev_hole = self.fill_split(split, Some(entry), None);
+        }
+        let i = exprs.len() - 1;
+        let Patch { hole, entry } =
+            self.c_capture(0, &exprs[i])?.unwrap_or_else(|| self.next_inst());
+        self.fill(prev_hole, entry);
+        self.fill_to_next(hole);
+        self.compiled.matches.push(self.insts.len());
+        self.push_compiled(Inst::Match(i));
+        self.compile_finish()
+    }
+
+    fn compile_finish(mut self) -> result::Result<Program, Error> {
+        self.compiled.insts =
+            self.insts.into_iter().map(|inst| inst.unwrap()).collect();
+        self.compiled.byte_classes = self.byte_classes.byte_classes();
+        self.compiled.capture_name_idx = Arc::new(self.capture_name_idx);
+        Ok(self.compiled)
+    }
+
+    /// Compile expr into self.insts, returning a patch on success,
+    /// or an error if we run out of memory.
+    ///
+    /// All of the c_* methods of the compiler share the contract outlined
+    /// here.
+    ///
+    /// The main thing that a c_* method does is mutate `self.insts`
+    /// to add a list of mostly compiled instructions required to execute
+    /// the given expression. `self.insts` contains MaybeInsts rather than
+    /// Insts because there is some backpatching required.
+    ///
+    /// The `Patch` value returned by each c_* method provides metadata
+    /// about the compiled instructions emitted to `self.insts`. The
+    /// `entry` member of the patch refers to the first instruction
+    /// (the entry point), while the `hole` member contains zero or
+    /// more offsets to partial instructions that need to be backpatched.
+    /// The c_* routine can't know where its list of instructions are going to
+    /// jump to after execution, so it is up to the caller to patch
+    /// these jumps to point to the right place. So compiling some
+    /// expression, e, we would end up with a situation that looked like:
+    ///
+    /// ```text
+    /// self.insts = [ ..., i1, i2, ..., iexit1, ..., iexitn, ...]
+    ///                     ^              ^             ^
+    ///                     |                \         /
+    ///                   entry                \     /
+    ///                                         hole
+    /// ```
+    ///
+    /// To compile two expressions, e1 and e2, concatenated together we
+    /// would do:
+    ///
+    /// ```ignore
+    /// let patch1 = self.c(e1);
+    /// let patch2 = self.c(e2);
+    /// ```
+    ///
+    /// while leaves us with a situation that looks like
+    ///
+    /// ```text
+    /// self.insts = [ ..., i1, ..., iexit1, ..., i2, ..., iexit2 ]
+    ///                     ^        ^            ^        ^
+    ///                     |        |            |        |
+    ///                entry1        hole1   entry2        hole2
+    /// ```
+    ///
+    /// Then to merge the two patches together into one we would backpatch
+    /// hole1 with entry2 and return a new patch that enters at entry1
+    /// and has hole2 for a hole. In fact, if you look at the c_concat
+    /// method you will see that it does exactly this, though it handles
+    /// a list of expressions rather than just the two that we use for
+    /// an example.
+    ///
+    /// Ok(None) is returned when an expression is compiled to no
+    /// instruction, and so no patch.entry value makes sense.
+    fn c(&mut self, expr: &Hir) -> ResultOrEmpty {
+        use crate::prog;
+        use regex_syntax::hir::HirKind::*;
+
+        self.check_size()?;
+        match *expr.kind() {
+            Empty => self.c_empty(),
+            Literal(hir::Literal::Unicode(c)) => self.c_char(c),
+            Literal(hir::Literal::Byte(b)) => {
+                assert!(self.compiled.uses_bytes());
+                self.c_byte(b)
+            }
+            Class(hir::Class::Unicode(ref cls)) => self.c_class(cls.ranges()),
+            Class(hir::Class::Bytes(ref cls)) => {
+                if self.compiled.uses_bytes() {
+                    self.c_class_bytes(cls.ranges())
+                } else {
+                    assert!(cls.is_all_ascii());
+                    let mut char_ranges = vec![];
+                    for r in cls.iter() {
+                        let (s, e) = (r.start() as char, r.end() as char);
+                        char_ranges.push(hir::ClassUnicodeRange::new(s, e));
+                    }
+                    self.c_class(&char_ranges)
+                }
+            }
+            Anchor(hir::Anchor::StartLine) if self.compiled.is_reverse => {
+                self.byte_classes.set_range(b'\n', b'\n');
+                self.c_empty_look(prog::EmptyLook::EndLine)
+            }
+            Anchor(hir::Anchor::StartLine) => {
+                self.byte_classes.set_range(b'\n', b'\n');
+                self.c_empty_look(prog::EmptyLook::StartLine)
+            }
+            Anchor(hir::Anchor::EndLine) if self.compiled.is_reverse => {
+                self.byte_classes.set_range(b'\n', b'\n');
+                self.c_empty_look(prog::EmptyLook::StartLine)
+            }
+            Anchor(hir::Anchor::EndLine) => {
+                self.byte_classes.set_range(b'\n', b'\n');
+                self.c_empty_look(prog::EmptyLook::EndLine)
+            }
+            Anchor(hir::Anchor::StartText) if self.compiled.is_reverse => {
+                self.c_empty_look(prog::EmptyLook::EndText)
+            }
+            Anchor(hir::Anchor::StartText) => {
+                self.c_empty_look(prog::EmptyLook::StartText)
+            }
+            Anchor(hir::Anchor::EndText) if self.compiled.is_reverse => {
+                self.c_empty_look(prog::EmptyLook::StartText)
+            }
+            Anchor(hir::Anchor::EndText) => {
+                self.c_empty_look(prog::EmptyLook::EndText)
+            }
+            WordBoundary(hir::WordBoundary::Unicode) => {
+                if !cfg!(feature = "unicode-perl") {
+                    return Err(Error::Syntax(
+                        "Unicode word boundaries are unavailable when \
+                         the unicode-perl feature is disabled"
+                            .to_string(),
+                    ));
+                }
+                self.compiled.has_unicode_word_boundary = true;
+                self.byte_classes.set_word_boundary();
+                // We also make sure that all ASCII bytes are in a different
+                // class from non-ASCII bytes. Otherwise, it's possible for
+                // ASCII bytes to get lumped into the same class as non-ASCII
+                // bytes. This in turn may cause the lazy DFA to falsely start
+                // when it sees an ASCII byte that maps to a byte class with
+                // non-ASCII bytes. This ensures that never happens.
+                self.byte_classes.set_range(0, 0x7F);
+                self.c_empty_look(prog::EmptyLook::WordBoundary)
+            }
+            WordBoundary(hir::WordBoundary::UnicodeNegate) => {
+                if !cfg!(feature = "unicode-perl") {
+                    return Err(Error::Syntax(
+                        "Unicode word boundaries are unavailable when \
+                         the unicode-perl feature is disabled"
+                            .to_string(),
+                    ));
+                }
+                self.compiled.has_unicode_word_boundary = true;
+                self.byte_classes.set_word_boundary();
+                // See comments above for why we set the ASCII range here.
+                self.byte_classes.set_range(0, 0x7F);
+                self.c_empty_look(prog::EmptyLook::NotWordBoundary)
+            }
+            WordBoundary(hir::WordBoundary::Ascii) => {
+                self.byte_classes.set_word_boundary();
+                self.c_empty_look(prog::EmptyLook::WordBoundaryAscii)
+            }
+            WordBoundary(hir::WordBoundary::AsciiNegate) => {
+                self.byte_classes.set_word_boundary();
+                self.c_empty_look(prog::EmptyLook::NotWordBoundaryAscii)
+            }
+            Group(ref g) => match g.kind {
+                hir::GroupKind::NonCapturing => self.c(&g.hir),
+                hir::GroupKind::CaptureIndex(index) => {
+                    if index as usize >= self.compiled.captures.len() {
+                        self.compiled.captures.push(None);
+                    }
+                    self.c_capture(2 * index as usize, &g.hir)
+                }
+                hir::GroupKind::CaptureName { index, ref name } => {
+                    if index as usize >= self.compiled.captures.len() {
+                        let n = name.to_string();
+                        self.compiled.captures.push(Some(n.clone()));
+                        self.capture_name_idx.insert(n, index as usize);
+                    }
+                    self.c_capture(2 * index as usize, &g.hir)
+                }
+            },
+            Concat(ref es) => {
+                if self.compiled.is_reverse {
+                    self.c_concat(es.iter().rev())
+                } else {
+                    self.c_concat(es)
+                }
+            }
+            Alternation(ref es) => self.c_alternate(&**es),
+            Repetition(ref rep) => self.c_repeat(rep),
+        }
+    }
+
+    fn c_empty(&mut self) -> ResultOrEmpty {
+        // See: https://github.com/rust-lang/regex/security/advisories/GHSA-m5pq-gvj9-9vr8
+        // See: CVE-2022-24713
+        //
+        // Since 'empty' sub-expressions don't increase the size of
+        // the actual compiled object, we "fake" an increase in its
+        // size so that our 'check_size_limit' routine will eventually
+        // stop compilation if there are too many empty sub-expressions
+        // (e.g., via a large repetition).
+        self.extra_inst_bytes += std::mem::size_of::<Inst>();
+        Ok(None)
+    }
+
+    fn c_capture(&mut self, first_slot: usize, expr: &Hir) -> ResultOrEmpty {
+        if self.num_exprs > 1 || self.compiled.is_dfa {
+            // Don't ever compile Save instructions for regex sets because
+            // they are never used. They are also never used in DFA programs
+            // because DFAs can't handle captures.
+            self.c(expr)
+        } else {
+            let entry = self.insts.len();
+            let hole = self.push_hole(InstHole::Save { slot: first_slot });
+            let patch = self.c(expr)?.unwrap_or_else(|| self.next_inst());
+            self.fill(hole, patch.entry);
+            self.fill_to_next(patch.hole);
+            let hole = self.push_hole(InstHole::Save { slot: first_slot + 1 });
+            Ok(Some(Patch { hole, entry }))
+        }
+    }
+
+    fn c_dotstar(&mut self) -> Result {
+        Ok(if !self.compiled.only_utf8() {
+            self.c(&Hir::repetition(hir::Repetition {
+                kind: hir::RepetitionKind::ZeroOrMore,
+                greedy: false,
+                hir: Box::new(Hir::any(true)),
+            }))?
+            .unwrap()
+        } else {
+            self.c(&Hir::repetition(hir::Repetition {
+                kind: hir::RepetitionKind::ZeroOrMore,
+                greedy: false,
+                hir: Box::new(Hir::any(false)),
+            }))?
+            .unwrap()
+        })
+    }
+
+    fn c_char(&mut self, c: char) -> ResultOrEmpty {
+        if self.compiled.uses_bytes() {
+            if c.is_ascii() {
+                let b = c as u8;
+                let hole =
+                    self.push_hole(InstHole::Bytes { start: b, end: b });
+                self.byte_classes.set_range(b, b);
+                Ok(Some(Patch { hole, entry: self.insts.len() - 1 }))
+            } else {
+                self.c_class(&[hir::ClassUnicodeRange::new(c, c)])
+            }
+        } else {
+            let hole = self.push_hole(InstHole::Char { c });
+            Ok(Some(Patch { hole, entry: self.insts.len() - 1 }))
+        }
+    }
+
+    fn c_class(&mut self, ranges: &[hir::ClassUnicodeRange]) -> ResultOrEmpty {
+        use std::mem::size_of;
+
+        assert!(!ranges.is_empty());
+        if self.compiled.uses_bytes() {
+            Ok(Some(CompileClass { c: self, ranges }.compile()?))
+        } else {
+            let ranges: Vec<(char, char)> =
+                ranges.iter().map(|r| (r.start(), r.end())).collect();
+            let hole = if ranges.len() == 1 && ranges[0].0 == ranges[0].1 {
+                self.push_hole(InstHole::Char { c: ranges[0].0 })
+            } else {
+                self.extra_inst_bytes +=
+                    ranges.len() * (size_of::<char>() * 2);
+                self.push_hole(InstHole::Ranges { ranges })
+            };
+            Ok(Some(Patch { hole, entry: self.insts.len() - 1 }))
+        }
+    }
+
+    fn c_byte(&mut self, b: u8) -> ResultOrEmpty {
+        self.c_class_bytes(&[hir::ClassBytesRange::new(b, b)])
+    }
+
+    fn c_class_bytes(
+        &mut self,
+        ranges: &[hir::ClassBytesRange],
+    ) -> ResultOrEmpty {
+        debug_assert!(!ranges.is_empty());
+
+        let first_split_entry = self.insts.len();
+        let mut holes = vec![];
+        let mut prev_hole = Hole::None;
+        for r in &ranges[0..ranges.len() - 1] {
+            self.fill_to_next(prev_hole);
+            let split = self.push_split_hole();
+            let next = self.insts.len();
+            self.byte_classes.set_range(r.start(), r.end());
+            holes.push(self.push_hole(InstHole::Bytes {
+                start: r.start(),
+                end: r.end(),
+            }));
+            prev_hole = self.fill_split(split, Some(next), None);
+        }
+        let next = self.insts.len();
+        let r = &ranges[ranges.len() - 1];
+        self.byte_classes.set_range(r.start(), r.end());
+        holes.push(
+            self.push_hole(InstHole::Bytes { start: r.start(), end: r.end() }),
+        );
+        self.fill(prev_hole, next);
+        Ok(Some(Patch { hole: Hole::Many(holes), entry: first_split_entry }))
+    }
+
+    fn c_empty_look(&mut self, look: EmptyLook) -> ResultOrEmpty {
+        let hole = self.push_hole(InstHole::EmptyLook { look });
+        Ok(Some(Patch { hole, entry: self.insts.len() - 1 }))
+    }
+
+    fn c_concat<'a, I>(&mut self, exprs: I) -> ResultOrEmpty
+    where
+        I: IntoIterator<Item = &'a Hir>,
+    {
+        let mut exprs = exprs.into_iter();
+        let Patch { mut hole, entry } = loop {
+            match exprs.next() {
+                None => return self.c_empty(),
+                Some(e) => {
+                    if let Some(p) = self.c(e)? {
+                        break p;
+                    }
+                }
+            }
+        };
+        for e in exprs {
+            if let Some(p) = self.c(e)? {
+                self.fill(hole, p.entry);
+                hole = p.hole;
+            }
+        }
+        Ok(Some(Patch { hole, entry }))
+    }
+
+    fn c_alternate(&mut self, exprs: &[Hir]) -> ResultOrEmpty {
+        debug_assert!(
+            exprs.len() >= 2,
+            "alternates must have at least 2 exprs"
+        );
+
+        // Initial entry point is always the first split.
+        let first_split_entry = self.insts.len();
+
+        // Save up all of the holes from each alternate. They will all get
+        // patched to point to the same location.
+        let mut holes = vec![];
+
+        // true indicates that the hole is a split where we want to fill
+        // the second branch.
+        let mut prev_hole = (Hole::None, false);
+        for e in &exprs[0..exprs.len() - 1] {
+            if prev_hole.1 {
+                let next = self.insts.len();
+                self.fill_split(prev_hole.0, None, Some(next));
+            } else {
+                self.fill_to_next(prev_hole.0);
+            }
+            let split = self.push_split_hole();
+            if let Some(Patch { hole, entry }) = self.c(e)? {
+                holes.push(hole);
+                prev_hole = (self.fill_split(split, Some(entry), None), false);
+            } else {
+                let (split1, split2) = split.dup_one();
+                holes.push(split1);
+                prev_hole = (split2, true);
+            }
+        }
+        if let Some(Patch { hole, entry }) = self.c(&exprs[exprs.len() - 1])? {
+            holes.push(hole);
+            if prev_hole.1 {
+                self.fill_split(prev_hole.0, None, Some(entry));
+            } else {
+                self.fill(prev_hole.0, entry);
+            }
+        } else {
+            // We ignore prev_hole.1. When it's true, it means we have two
+            // empty branches both pushing prev_hole.0 into holes, so both
+            // branches will go to the same place anyway.
+            holes.push(prev_hole.0);
+        }
+        Ok(Some(Patch { hole: Hole::Many(holes), entry: first_split_entry }))
+    }
+
+    fn c_repeat(&mut self, rep: &hir::Repetition) -> ResultOrEmpty {
+        use regex_syntax::hir::RepetitionKind::*;
+        match rep.kind {
+            ZeroOrOne => self.c_repeat_zero_or_one(&rep.hir, rep.greedy),
+            ZeroOrMore => self.c_repeat_zero_or_more(&rep.hir, rep.greedy),
+            OneOrMore => self.c_repeat_one_or_more(&rep.hir, rep.greedy),
+            Range(hir::RepetitionRange::Exactly(min_max)) => {
+                self.c_repeat_range(&rep.hir, rep.greedy, min_max, min_max)
+            }
+            Range(hir::RepetitionRange::AtLeast(min)) => {
+                self.c_repeat_range_min_or_more(&rep.hir, rep.greedy, min)
+            }
+            Range(hir::RepetitionRange::Bounded(min, max)) => {
+                self.c_repeat_range(&rep.hir, rep.greedy, min, max)
+            }
+        }
+    }
+
+    fn c_repeat_zero_or_one(
+        &mut self,
+        expr: &Hir,
+        greedy: bool,
+    ) -> ResultOrEmpty {
+        let split_entry = self.insts.len();
+        let split = self.push_split_hole();
+        let Patch { hole: hole_rep, entry: entry_rep } = match self.c(expr)? {
+            Some(p) => p,
+            None => return self.pop_split_hole(),
+        };
+        let split_hole = if greedy {
+            self.fill_split(split, Some(entry_rep), None)
+        } else {
+            self.fill_split(split, None, Some(entry_rep))
+        };
+        let holes = vec![hole_rep, split_hole];
+        Ok(Some(Patch { hole: Hole::Many(holes), entry: split_entry }))
+    }
+
+    fn c_repeat_zero_or_more(
+        &mut self,
+        expr: &Hir,
+        greedy: bool,
+    ) -> ResultOrEmpty {
+        let split_entry = self.insts.len();
+        let split = self.push_split_hole();
+        let Patch { hole: hole_rep, entry: entry_rep } = match self.c(expr)? {
+            Some(p) => p,
+            None => return self.pop_split_hole(),
+        };
+
+        self.fill(hole_rep, split_entry);
+        let split_hole = if greedy {
+            self.fill_split(split, Some(entry_rep), None)
+        } else {
+            self.fill_split(split, None, Some(entry_rep))
+        };
+        Ok(Some(Patch { hole: split_hole, entry: split_entry }))
+    }
+
+    fn c_repeat_one_or_more(
+        &mut self,
+        expr: &Hir,
+        greedy: bool,
+    ) -> ResultOrEmpty {
+        let Patch { hole: hole_rep, entry: entry_rep } = match self.c(expr)? {
+            Some(p) => p,
+            None => return Ok(None),
+        };
+        self.fill_to_next(hole_rep);
+        let split = self.push_split_hole();
+
+        let split_hole = if greedy {
+            self.fill_split(split, Some(entry_rep), None)
+        } else {
+            self.fill_split(split, None, Some(entry_rep))
+        };
+        Ok(Some(Patch { hole: split_hole, entry: entry_rep }))
+    }
+
+    fn c_repeat_range_min_or_more(
+        &mut self,
+        expr: &Hir,
+        greedy: bool,
+        min: u32,
+    ) -> ResultOrEmpty {
+        let min = u32_to_usize(min);
+        // Using next_inst() is ok, because we can't return it (concat would
+        // have to return Some(_) while c_repeat_range_min_or_more returns
+        // None).
+        let patch_concat = self
+            .c_concat(iter::repeat(expr).take(min))?
+            .unwrap_or_else(|| self.next_inst());
+        if let Some(patch_rep) = self.c_repeat_zero_or_more(expr, greedy)? {
+            self.fill(patch_concat.hole, patch_rep.entry);
+            Ok(Some(Patch { hole: patch_rep.hole, entry: patch_concat.entry }))
+        } else {
+            Ok(None)
+        }
+    }
+
+    fn c_repeat_range(
+        &mut self,
+        expr: &Hir,
+        greedy: bool,
+        min: u32,
+        max: u32,
+    ) -> ResultOrEmpty {
+        let (min, max) = (u32_to_usize(min), u32_to_usize(max));
+        debug_assert!(min <= max);
+        let patch_concat = self.c_concat(iter::repeat(expr).take(min))?;
+        if min == max {
+            return Ok(patch_concat);
+        }
+        // Same reasoning as in c_repeat_range_min_or_more (we know that min <
+        // max at this point).
+        let patch_concat = patch_concat.unwrap_or_else(|| self.next_inst());
+        let initial_entry = patch_concat.entry;
+        // It is much simpler to compile, e.g., `a{2,5}` as:
+        //
+        //     aaa?a?a?
+        //
+        // But you end up with a sequence of instructions like this:
+        //
+        //     0: 'a'
+        //     1: 'a',
+        //     2: split(3, 4)
+        //     3: 'a'
+        //     4: split(5, 6)
+        //     5: 'a'
+        //     6: split(7, 8)
+        //     7: 'a'
+        //     8: MATCH
+        //
+        // This is *incredibly* inefficient because the splits end
+        // up forming a chain, which has to be resolved everything a
+        // transition is followed.
+        let mut holes = vec![];
+        let mut prev_hole = patch_concat.hole;
+        for _ in min..max {
+            self.fill_to_next(prev_hole);
+            let split = self.push_split_hole();
+            let Patch { hole, entry } = match self.c(expr)? {
+                Some(p) => p,
+                None => return self.pop_split_hole(),
+            };
+            prev_hole = hole;
+            if greedy {
+                holes.push(self.fill_split(split, Some(entry), None));
+            } else {
+                holes.push(self.fill_split(split, None, Some(entry)));
+            }
+        }
+        holes.push(prev_hole);
+        Ok(Some(Patch { hole: Hole::Many(holes), entry: initial_entry }))
+    }
+
+    /// Can be used as a default value for the c_* functions when the call to
+    /// c_function is followed by inserting at least one instruction that is
+    /// always executed after the ones written by the c* function.
+    fn next_inst(&self) -> Patch {
+        Patch { hole: Hole::None, entry: self.insts.len() }
+    }
+
+    fn fill(&mut self, hole: Hole, goto: InstPtr) {
+        match hole {
+            Hole::None => {}
+            Hole::One(pc) => {
+                self.insts[pc].fill(goto);
+            }
+            Hole::Many(holes) => {
+                for hole in holes {
+                    self.fill(hole, goto);
+                }
+            }
+        }
+    }
+
+    fn fill_to_next(&mut self, hole: Hole) {
+        let next = self.insts.len();
+        self.fill(hole, next);
+    }
+
+    fn fill_split(
+        &mut self,
+        hole: Hole,
+        goto1: Option<InstPtr>,
+        goto2: Option<InstPtr>,
+    ) -> Hole {
+        match hole {
+            Hole::None => Hole::None,
+            Hole::One(pc) => match (goto1, goto2) {
+                (Some(goto1), Some(goto2)) => {
+                    self.insts[pc].fill_split(goto1, goto2);
+                    Hole::None
+                }
+                (Some(goto1), None) => {
+                    self.insts[pc].half_fill_split_goto1(goto1);
+                    Hole::One(pc)
+                }
+                (None, Some(goto2)) => {
+                    self.insts[pc].half_fill_split_goto2(goto2);
+                    Hole::One(pc)
+                }
+                (None, None) => unreachable!(
+                    "at least one of the split \
+                     holes must be filled"
+                ),
+            },
+            Hole::Many(holes) => {
+                let mut new_holes = vec![];
+                for hole in holes {
+                    new_holes.push(self.fill_split(hole, goto1, goto2));
+                }
+                if new_holes.is_empty() {
+                    Hole::None
+                } else if new_holes.len() == 1 {
+                    new_holes.pop().unwrap()
+                } else {
+                    Hole::Many(new_holes)
+                }
+            }
+        }
+    }
+
+    fn push_compiled(&mut self, inst: Inst) {
+        self.insts.push(MaybeInst::Compiled(inst));
+    }
+
+    fn push_hole(&mut self, inst: InstHole) -> Hole {
+        let hole = self.insts.len();
+        self.insts.push(MaybeInst::Uncompiled(inst));
+        Hole::One(hole)
+    }
+
+    fn push_split_hole(&mut self) -> Hole {
+        let hole = self.insts.len();
+        self.insts.push(MaybeInst::Split);
+        Hole::One(hole)
+    }
+
+    fn pop_split_hole(&mut self) -> ResultOrEmpty {
+        self.insts.pop();
+        Ok(None)
+    }
+
+    fn check_size(&self) -> result::Result<(), Error> {
+        use std::mem::size_of;
+
+        let size =
+            self.extra_inst_bytes + (self.insts.len() * size_of::<Inst>());
+        if size > self.size_limit {
+            Err(Error::CompiledTooBig(self.size_limit))
+        } else {
+            Ok(())
+        }
+    }
+}
+
+#[derive(Debug)]
+enum Hole {
+    None,
+    One(InstPtr),
+    Many(Vec<Hole>),
+}
+
+impl Hole {
+    fn dup_one(self) -> (Self, Self) {
+        match self {
+            Hole::One(pc) => (Hole::One(pc), Hole::One(pc)),
+            Hole::None | Hole::Many(_) => {
+                unreachable!("must be called on single hole")
+            }
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+enum MaybeInst {
+    Compiled(Inst),
+    Uncompiled(InstHole),
+    Split,
+    Split1(InstPtr),
+    Split2(InstPtr),
+}
+
+impl MaybeInst {
+    fn fill(&mut self, goto: InstPtr) {
+        let maybeinst = match *self {
+            MaybeInst::Split => MaybeInst::Split1(goto),
+            MaybeInst::Uncompiled(ref inst) => {
+                MaybeInst::Compiled(inst.fill(goto))
+            }
+            MaybeInst::Split1(goto1) => {
+                MaybeInst::Compiled(Inst::Split(InstSplit {
+                    goto1,
+                    goto2: goto,
+                }))
+            }
+            MaybeInst::Split2(goto2) => {
+                MaybeInst::Compiled(Inst::Split(InstSplit {
+                    goto1: goto,
+                    goto2,
+                }))
+            }
+            _ => unreachable!(
+                "not all instructions were compiled! \
+                 found uncompiled instruction: {:?}",
+                self
+            ),
+        };
+        *self = maybeinst;
+    }
+
+    fn fill_split(&mut self, goto1: InstPtr, goto2: InstPtr) {
+        let filled = match *self {
+            MaybeInst::Split => Inst::Split(InstSplit { goto1, goto2 }),
+            _ => unreachable!(
+                "must be called on Split instruction, \
+                 instead it was called on: {:?}",
+                self
+            ),
+        };
+        *self = MaybeInst::Compiled(filled);
+    }
+
+    fn half_fill_split_goto1(&mut self, goto1: InstPtr) {
+        let half_filled = match *self {
+            MaybeInst::Split => goto1,
+            _ => unreachable!(
+                "must be called on Split instruction, \
+                 instead it was called on: {:?}",
+                self
+            ),
+        };
+        *self = MaybeInst::Split1(half_filled);
+    }
+
+    fn half_fill_split_goto2(&mut self, goto2: InstPtr) {
+        let half_filled = match *self {
+            MaybeInst::Split => goto2,
+            _ => unreachable!(
+                "must be called on Split instruction, \
+                 instead it was called on: {:?}",
+                self
+            ),
+        };
+        *self = MaybeInst::Split2(half_filled);
+    }
+
+    fn unwrap(self) -> Inst {
+        match self {
+            MaybeInst::Compiled(inst) => inst,
+            _ => unreachable!(
+                "must be called on a compiled instruction, \
+                 instead it was called on: {:?}",
+                self
+            ),
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+enum InstHole {
+    Save { slot: usize },
+    EmptyLook { look: EmptyLook },
+    Char { c: char },
+    Ranges { ranges: Vec<(char, char)> },
+    Bytes { start: u8, end: u8 },
+}
+
+impl InstHole {
+    fn fill(&self, goto: InstPtr) -> Inst {
+        match *self {
+            InstHole::Save { slot } => Inst::Save(InstSave { goto, slot }),
+            InstHole::EmptyLook { look } => {
+                Inst::EmptyLook(InstEmptyLook { goto, look })
+            }
+            InstHole::Char { c } => Inst::Char(InstChar { goto, c }),
+            InstHole::Ranges { ref ranges } => Inst::Ranges(InstRanges {
+                goto,
+                ranges: ranges.clone().into_boxed_slice(),
+            }),
+            InstHole::Bytes { start, end } => {
+                Inst::Bytes(InstBytes { goto, start, end })
+            }
+        }
+    }
+}
+
+struct CompileClass<'a, 'b> {
+    c: &'a mut Compiler,
+    ranges: &'b [hir::ClassUnicodeRange],
+}
+
+impl<'a, 'b> CompileClass<'a, 'b> {
+    fn compile(mut self) -> Result {
+        let mut holes = vec![];
+        let mut initial_entry = None;
+        let mut last_split = Hole::None;
+        let mut utf8_seqs = self.c.utf8_seqs.take().unwrap();
+        self.c.suffix_cache.clear();
+
+        for (i, range) in self.ranges.iter().enumerate() {
+            let is_last_range = i + 1 == self.ranges.len();
+            utf8_seqs.reset(range.start(), range.end());
+            let mut it = (&mut utf8_seqs).peekable();
+            loop {
+                let utf8_seq = match it.next() {
+                    None => break,
+                    Some(utf8_seq) => utf8_seq,
+                };
+                if is_last_range && it.peek().is_none() {
+                    let Patch { hole, entry } = self.c_utf8_seq(&utf8_seq)?;
+                    holes.push(hole);
+                    self.c.fill(last_split, entry);
+                    last_split = Hole::None;
+                    if initial_entry.is_none() {
+                        initial_entry = Some(entry);
+                    }
+                } else {
+                    if initial_entry.is_none() {
+                        initial_entry = Some(self.c.insts.len());
+                    }
+                    self.c.fill_to_next(last_split);
+                    last_split = self.c.push_split_hole();
+                    let Patch { hole, entry } = self.c_utf8_seq(&utf8_seq)?;
+                    holes.push(hole);
+                    last_split =
+                        self.c.fill_split(last_split, Some(entry), None);
+                }
+            }
+        }
+        self.c.utf8_seqs = Some(utf8_seqs);
+        Ok(Patch { hole: Hole::Many(holes), entry: initial_entry.unwrap() })
+    }
+
+    fn c_utf8_seq(&mut self, seq: &Utf8Sequence) -> Result {
+        if self.c.compiled.is_reverse {
+            self.c_utf8_seq_(seq)
+        } else {
+            self.c_utf8_seq_(seq.into_iter().rev())
+        }
+    }
+
+    fn c_utf8_seq_<'r, I>(&mut self, seq: I) -> Result
+    where
+        I: IntoIterator<Item = &'r Utf8Range>,
+    {
+        // The initial instruction for each UTF-8 sequence should be the same.
+        let mut from_inst = ::std::usize::MAX;
+        let mut last_hole = Hole::None;
+        for byte_range in seq {
+            let key = SuffixCacheKey {
+                from_inst,
+                start: byte_range.start,
+                end: byte_range.end,
+            };
+            {
+                let pc = self.c.insts.len();
+                if let Some(cached_pc) = self.c.suffix_cache.get(key, pc) {
+                    from_inst = cached_pc;
+                    continue;
+                }
+            }
+            self.c.byte_classes.set_range(byte_range.start, byte_range.end);
+            if from_inst == ::std::usize::MAX {
+                last_hole = self.c.push_hole(InstHole::Bytes {
+                    start: byte_range.start,
+                    end: byte_range.end,
+                });
+            } else {
+                self.c.push_compiled(Inst::Bytes(InstBytes {
+                    goto: from_inst,
+                    start: byte_range.start,
+                    end: byte_range.end,
+                }));
+            }
+            from_inst = self.c.insts.len().checked_sub(1).unwrap();
+            debug_assert!(from_inst < ::std::usize::MAX);
+        }
+        debug_assert!(from_inst < ::std::usize::MAX);
+        Ok(Patch { hole: last_hole, entry: from_inst })
+    }
+}
+
+/// `SuffixCache` is a simple bounded hash map for caching suffix entries in
+/// UTF-8 automata. For example, consider the Unicode range \u{0}-\u{FFFF}.
+/// The set of byte ranges looks like this:
+///
+/// [0-7F]
+/// [C2-DF][80-BF]
+/// [E0][A0-BF][80-BF]
+/// [E1-EC][80-BF][80-BF]
+/// [ED][80-9F][80-BF]
+/// [EE-EF][80-BF][80-BF]
+///
+/// Each line above translates to one alternate in the compiled regex program.
+/// However, all but one of the alternates end in the same suffix, which is
+/// a waste of an instruction. The suffix cache facilitates reusing them across
+/// alternates.
+///
+/// Note that a HashMap could be trivially used for this, but we don't need its
+/// overhead. Some small bounded space (LRU style) is more than enough.
+///
+/// This uses similar idea to [`SparseSet`](../sparse/struct.SparseSet.html),
+/// except it uses hashes as original indices and then compares full keys for
+/// validation against `dense` array.
+#[derive(Debug)]
+struct SuffixCache {
+    sparse: Box<[usize]>,
+    dense: Vec<SuffixCacheEntry>,
+}
+
+#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
+struct SuffixCacheEntry {
+    key: SuffixCacheKey,
+    pc: InstPtr,
+}
+
+#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
+struct SuffixCacheKey {
+    from_inst: InstPtr,
+    start: u8,
+    end: u8,
+}
+
+impl SuffixCache {
+    fn new(size: usize) -> Self {
+        SuffixCache {
+            sparse: vec![0usize; size].into(),
+            dense: Vec::with_capacity(size),
+        }
+    }
+
+    fn get(&mut self, key: SuffixCacheKey, pc: InstPtr) -> Option<InstPtr> {
+        let hash = self.hash(&key);
+        let pos = &mut self.sparse[hash];
+        if let Some(entry) = self.dense.get(*pos) {
+            if entry.key == key {
+                return Some(entry.pc);
+            }
+        }
+        *pos = self.dense.len();
+        self.dense.push(SuffixCacheEntry { key, pc });
+        None
+    }
+
+    fn clear(&mut self) {
+        self.dense.clear();
+    }
+
+    fn hash(&self, suffix: &SuffixCacheKey) -> usize {
+        // Basic FNV-1a hash as described:
+        // https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function
+        const FNV_PRIME: u64 = 1_099_511_628_211;
+        let mut h = 14_695_981_039_346_656_037;
+        h = (h ^ (suffix.from_inst as u64)).wrapping_mul(FNV_PRIME);
+        h = (h ^ (suffix.start as u64)).wrapping_mul(FNV_PRIME);
+        h = (h ^ (suffix.end as u64)).wrapping_mul(FNV_PRIME);
+        (h as usize) % self.sparse.len()
+    }
+}
+
+struct ByteClassSet([bool; 256]);
+
+impl ByteClassSet {
+    fn new() -> Self {
+        ByteClassSet([false; 256])
+    }
+
+    fn set_range(&mut self, start: u8, end: u8) {
+        debug_assert!(start <= end);
+        if start > 0 {
+            self.0[start as usize - 1] = true;
+        }
+        self.0[end as usize] = true;
+    }
+
+    fn set_word_boundary(&mut self) {
+        // We need to mark all ranges of bytes whose pairs result in
+        // evaluating \b differently.
+        let iswb = is_word_byte;
+        let mut b1: u16 = 0;
+        let mut b2: u16;
+        while b1 <= 255 {
+            b2 = b1 + 1;
+            while b2 <= 255 && iswb(b1 as u8) == iswb(b2 as u8) {
+                b2 += 1;
+            }
+            self.set_range(b1 as u8, (b2 - 1) as u8);
+            b1 = b2;
+        }
+    }
+
+    fn byte_classes(&self) -> Vec<u8> {
+        // N.B. If you're debugging the DFA, it's useful to simply return
+        // `(0..256).collect()`, which effectively removes the byte classes
+        // and makes the transitions easier to read.
+        // (0usize..256).map(|x| x as u8).collect()
+        let mut byte_classes = vec![0; 256];
+        let mut class = 0u8;
+        let mut i = 0;
+        loop {
+            byte_classes[i] = class as u8;
+            if i >= 255 {
+                break;
+            }
+            if self.0[i] {
+                class = class.checked_add(1).unwrap();
+            }
+            i += 1;
+        }
+        byte_classes
+    }
+}
+
+impl fmt::Debug for ByteClassSet {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_tuple("ByteClassSet").field(&&self.0[..]).finish()
+    }
+}
+
+fn u32_to_usize(n: u32) -> usize {
+    // In case usize is less than 32 bits, we need to guard against overflow.
+    // On most platforms this compiles to nothing.
+    // TODO Use `std::convert::TryFrom` once it's stable.
+    if (n as u64) > (::std::usize::MAX as u64) {
+        panic!("BUG: {} is too big to be pointer sized", n)
+    }
+    n as usize
+}
+
+#[cfg(test)]
+mod tests {
+    use super::ByteClassSet;
+
+    #[test]
+    fn byte_classes() {
+        let mut set = ByteClassSet::new();
+        set.set_range(b'a', b'z');
+        let classes = set.byte_classes();
+        assert_eq!(classes[0], 0);
+        assert_eq!(classes[1], 0);
+        assert_eq!(classes[2], 0);
+        assert_eq!(classes[b'a' as usize - 1], 0);
+        assert_eq!(classes[b'a' as usize], 1);
+        assert_eq!(classes[b'm' as usize], 1);
+        assert_eq!(classes[b'z' as usize], 1);
+        assert_eq!(classes[b'z' as usize + 1], 2);
+        assert_eq!(classes[254], 2);
+        assert_eq!(classes[255], 2);
+
+        let mut set = ByteClassSet::new();
+        set.set_range(0, 2);
+        set.set_range(4, 6);
+        let classes = set.byte_classes();
+        assert_eq!(classes[0], 0);
+        assert_eq!(classes[1], 0);
+        assert_eq!(classes[2], 0);
+        assert_eq!(classes[3], 1);
+        assert_eq!(classes[4], 2);
+        assert_eq!(classes[5], 2);
+        assert_eq!(classes[6], 2);
+        assert_eq!(classes[7], 3);
+        assert_eq!(classes[255], 3);
+    }
+
+    #[test]
+    fn full_byte_classes() {
+        let mut set = ByteClassSet::new();
+        for i in 0..256u16 {
+            set.set_range(i as u8, i as u8);
+        }
+        assert_eq!(set.byte_classes().len(), 256);
+    }
+}
diff --git a/crates/regex/src/dfa.rs b/crates/regex/src/dfa.rs
new file mode 100644
index 0000000..dc99521
--- /dev/null
+++ b/crates/regex/src/dfa.rs
@@ -0,0 +1,1945 @@
+/*!
+The DFA matching engine.
+
+A DFA provides faster matching because the engine is in exactly one state at
+any point in time. In the NFA, there may be multiple active states, and
+considerable CPU cycles are spent shuffling them around. In finite automata
+speak, the DFA follows epsilon transitions in the regex far less than the NFA.
+
+A DFA is a classic trade off between time and space. The NFA is slower, but
+its memory requirements are typically small and predictable. The DFA is faster,
+but given the right regex and the right input, the number of states in the
+DFA can grow exponentially. To mitigate this space problem, we do two things:
+
+1. We implement an *online* DFA. That is, the DFA is constructed from the NFA
+   during a search. When a new state is computed, it is stored in a cache so
+   that it may be reused. An important consequence of this implementation
+   is that states that are never reached for a particular input are never
+   computed. (This is impossible in an "offline" DFA which needs to compute
+   all possible states up front.)
+2. If the cache gets too big, we wipe it and continue matching.
+
+In pathological cases, a new state can be created for every byte of input.
+(e.g., The regex `(a|b)*a(a|b){20}` on a long sequence of a's and b's.)
+In this case, performance regresses to slightly slower than the full NFA
+simulation, in large part because the cache becomes useless. If the cache
+is wiped too frequently, the DFA quits and control falls back to one of the
+NFA simulations.
+
+Because of the "lazy" nature of this DFA, the inner matching loop is
+considerably more complex than one might expect out of a DFA. A number of
+tricks are employed to make it fast. Tread carefully.
+
+N.B. While this implementation is heavily commented, Russ Cox's series of
+articles on regexes is strongly recommended: <https://swtch.com/~rsc/regexp/>
+(As is the DFA implementation in RE2, which heavily influenced this
+implementation.)
+*/
+
+use std::collections::HashMap;
+use std::fmt;
+use std::iter::repeat;
+use std::mem;
+use std::sync::Arc;
+
+use crate::exec::ProgramCache;
+use crate::prog::{Inst, Program};
+use crate::sparse::SparseSet;
+
+/// Return true if and only if the given program can be executed by a DFA.
+///
+/// Generally, a DFA is always possible. A pathological case where it is not
+/// possible is if the number of NFA states exceeds `u32::MAX`, in which case,
+/// this function will return false.
+///
+/// This function will also return false if the given program has any Unicode
+/// instructions (Char or Ranges) since the DFA operates on bytes only.
+pub fn can_exec(insts: &Program) -> bool {
+    use crate::prog::Inst::*;
+    // If for some reason we manage to allocate a regex program with more
+    // than i32::MAX instructions, then we can't execute the DFA because we
+    // use 32 bit instruction pointer deltas for memory savings.
+    // If i32::MAX is the largest positive delta,
+    // then -i32::MAX == i32::MIN + 1 is the largest negative delta,
+    // and we are OK to use 32 bits.
+    if insts.dfa_size_limit == 0 || insts.len() > ::std::i32::MAX as usize {
+        return false;
+    }
+    for inst in insts {
+        match *inst {
+            Char(_) | Ranges(_) => return false,
+            EmptyLook(_) | Match(_) | Save(_) | Split(_) | Bytes(_) => {}
+        }
+    }
+    true
+}
+
+/// A reusable cache of DFA states.
+///
+/// This cache is reused between multiple invocations of the same regex
+/// program. (It is not shared simultaneously between threads. If there is
+/// contention, then new caches are created.)
+#[derive(Debug)]
+pub struct Cache {
+    /// Group persistent DFA related cache state together. The sparse sets
+    /// listed below are used as scratch space while computing uncached states.
+    inner: CacheInner,
+    /// qcur and qnext are ordered sets with constant time
+    /// addition/membership/clearing-whole-set and linear time iteration. They
+    /// are used to manage the sets of NFA states in DFA states when computing
+    /// cached DFA states. In particular, the order of the NFA states matters
+    /// for leftmost-first style matching. Namely, when computing a cached
+    /// state, the set of NFA states stops growing as soon as the first Match
+    /// instruction is observed.
+    qcur: SparseSet,
+    qnext: SparseSet,
+}
+
+/// `CacheInner` is logically just a part of Cache, but groups together fields
+/// that aren't passed as function parameters throughout search. (This split
+/// is mostly an artifact of the borrow checker. It is happily paid.)
+#[derive(Debug)]
+struct CacheInner {
+    /// A cache of pre-compiled DFA states, keyed by the set of NFA states
+    /// and the set of empty-width flags set at the byte in the input when the
+    /// state was observed.
+    ///
+    /// A StatePtr is effectively a `*State`, but to avoid various inconvenient
+    /// things, we just pass indexes around manually. The performance impact of
+    /// this is probably an instruction or two in the inner loop. However, on
+    /// 64 bit, each StatePtr is half the size of a *State.
+    compiled: StateMap,
+    /// The transition table.
+    ///
+    /// The transition table is laid out in row-major order, where states are
+    /// rows and the transitions for each state are columns. At a high level,
+    /// given state `s` and byte `b`, the next state can be found at index
+    /// `s * 256 + b`.
+    ///
+    /// This is, of course, a lie. A StatePtr is actually a pointer to the
+    /// *start* of a row in this table. When indexing in the DFA's inner loop,
+    /// this removes the need to multiply the StatePtr by the stride. Yes, it
+    /// matters. This reduces the number of states we can store, but: the
+    /// stride is rarely 256 since we define transitions in terms of
+    /// *equivalence classes* of bytes. Each class corresponds to a set of
+    /// bytes that never discriminate a distinct path through the DFA from each
+    /// other.
+    trans: Transitions,
+    /// A set of cached start states, which are limited to the number of
+    /// permutations of flags set just before the initial byte of input. (The
+    /// index into this vec is a `EmptyFlags`.)
+    ///
+    /// N.B. A start state can be "dead" (i.e., no possible match), so we
+    /// represent it with a StatePtr.
+    start_states: Vec<StatePtr>,
+    /// Stack scratch space used to follow epsilon transitions in the NFA.
+    /// (This permits us to avoid recursion.)
+    ///
+    /// The maximum stack size is the number of NFA states.
+    stack: Vec<InstPtr>,
+    /// The total number of times this cache has been flushed by the DFA
+    /// because of space constraints.
+    flush_count: u64,
+    /// The total heap size of the DFA's cache. We use this to determine when
+    /// we should flush the cache.
+    size: usize,
+    /// Scratch space used when building instruction pointer lists for new
+    /// states. This helps amortize allocation.
+    insts_scratch_space: Vec<u8>,
+}
+
+/// The transition table.
+///
+/// It is laid out in row-major order, with states as rows and byte class
+/// transitions as columns.
+///
+/// The transition table is responsible for producing valid `StatePtrs`. A
+/// `StatePtr` points to the start of a particular row in this table. When
+/// indexing to find the next state this allows us to avoid a multiplication
+/// when computing an index into the table.
+#[derive(Clone)]
+struct Transitions {
+    /// The table.
+    table: Vec<StatePtr>,
+    /// The stride.
+    num_byte_classes: usize,
+}
+
+/// Fsm encapsulates the actual execution of the DFA.
+#[derive(Debug)]
+pub struct Fsm<'a> {
+    /// prog contains the NFA instruction opcodes. DFA execution uses either
+    /// the `dfa` instructions or the `dfa_reverse` instructions from
+    /// `exec::ExecReadOnly`. (It never uses `ExecReadOnly.nfa`, which may have
+    /// Unicode opcodes that cannot be executed by the DFA.)
+    prog: &'a Program,
+    /// The start state. We record it here because the pointer may change
+    /// when the cache is wiped.
+    start: StatePtr,
+    /// The current position in the input.
+    at: usize,
+    /// Should we quit after seeing the first match? e.g., When the caller
+    /// uses `is_match` or `shortest_match`.
+    quit_after_match: bool,
+    /// The last state that matched.
+    ///
+    /// When no match has occurred, this is set to STATE_UNKNOWN.
+    ///
+    /// This is only useful when matching regex sets. The last match state
+    /// is useful because it contains all of the match instructions seen,
+    /// thereby allowing us to enumerate which regexes in the set matched.
+    last_match_si: StatePtr,
+    /// The input position of the last cache flush. We use this to determine
+    /// if we're thrashing in the cache too often. If so, the DFA quits so
+    /// that we can fall back to the NFA algorithm.
+    last_cache_flush: usize,
+    /// All cached DFA information that is persisted between searches.
+    cache: &'a mut CacheInner,
+}
+
+/// The result of running the DFA.
+///
+/// Generally, the result is either a match or not a match, but sometimes the
+/// DFA runs too slowly because the cache size is too small. In that case, it
+/// gives up with the intent of falling back to the NFA algorithm.
+///
+/// The DFA can also give up if it runs out of room to create new states, or if
+/// it sees non-ASCII bytes in the presence of a Unicode word boundary.
+#[derive(Clone, Debug)]
+pub enum Result<T> {
+    Match(T),
+    NoMatch(usize),
+    Quit,
+}
+
+impl<T> Result<T> {
+    /// Returns true if this result corresponds to a match.
+    pub fn is_match(&self) -> bool {
+        match *self {
+            Result::Match(_) => true,
+            Result::NoMatch(_) | Result::Quit => false,
+        }
+    }
+
+    /// Maps the given function onto T and returns the result.
+    ///
+    /// If this isn't a match, then this is a no-op.
+    #[cfg(feature = "perf-literal")]
+    pub fn map<U, F: FnMut(T) -> U>(self, mut f: F) -> Result<U> {
+        match self {
+            Result::Match(t) => Result::Match(f(t)),
+            Result::NoMatch(x) => Result::NoMatch(x),
+            Result::Quit => Result::Quit,
+        }
+    }
+
+    /// Sets the non-match position.
+    ///
+    /// If this isn't a non-match, then this is a no-op.
+    fn set_non_match(self, at: usize) -> Result<T> {
+        match self {
+            Result::NoMatch(_) => Result::NoMatch(at),
+            r => r,
+        }
+    }
+}
+
+/// `State` is a DFA state. It contains an ordered set of NFA states (not
+/// necessarily complete) and a smattering of flags.
+///
+/// The flags are packed into the first byte of data.
+///
+/// States don't carry their transitions. Instead, transitions are stored in
+/// a single row-major table.
+///
+/// Delta encoding is used to store the instruction pointers.
+/// The first instruction pointer is stored directly starting
+/// at data[1], and each following pointer is stored as an offset
+/// to the previous one. If a delta is in the range -127..127,
+/// it is packed into a single byte; Otherwise the byte 128 (-128 as an i8)
+/// is coded as a flag, followed by 4 bytes encoding the delta.
+#[derive(Clone, Eq, Hash, PartialEq)]
+struct State {
+    data: Arc<[u8]>,
+}
+
+/// `InstPtr` is a 32 bit pointer into a sequence of opcodes (i.e., it indexes
+/// an NFA state).
+///
+/// Throughout this library, this is usually set to `usize`, but we force a
+/// `u32` here for the DFA to save on space.
+type InstPtr = u32;
+
+/// Adds ip to data using delta encoding with respect to prev.
+///
+/// After completion, `data` will contain `ip` and `prev` will be set to `ip`.
+fn push_inst_ptr(data: &mut Vec<u8>, prev: &mut InstPtr, ip: InstPtr) {
+    let delta = (ip as i32) - (*prev as i32);
+    write_vari32(data, delta);
+    *prev = ip;
+}
+
+struct InstPtrs<'a> {
+    base: usize,
+    data: &'a [u8],
+}
+
+impl<'a> Iterator for InstPtrs<'a> {
+    type Item = usize;
+
+    fn next(&mut self) -> Option<usize> {
+        if self.data.is_empty() {
+            return None;
+        }
+        let (delta, nread) = read_vari32(self.data);
+        let base = self.base as i32 + delta;
+        debug_assert!(base >= 0);
+        debug_assert!(nread > 0);
+        self.data = &self.data[nread..];
+        self.base = base as usize;
+        Some(self.base)
+    }
+}
+
+impl State {
+    fn flags(&self) -> StateFlags {
+        StateFlags(self.data[0])
+    }
+
+    fn inst_ptrs(&self) -> InstPtrs<'_> {
+        InstPtrs { base: 0, data: &self.data[1..] }
+    }
+}
+
+/// `StatePtr` is a 32 bit pointer to the start of a row in the transition
+/// table.
+///
+/// It has many special values. There are two types of special values:
+/// sentinels and flags.
+///
+/// Sentinels corresponds to special states that carry some kind of
+/// significance. There are three such states: unknown, dead and quit states.
+///
+/// Unknown states are states that haven't been computed yet. They indicate
+/// that a transition should be filled in that points to either an existing
+/// cached state or a new state altogether. In general, an unknown state means
+/// "follow the NFA's epsilon transitions."
+///
+/// Dead states are states that can never lead to a match, no matter what
+/// subsequent input is observed. This means that the DFA should quit
+/// immediately and return the longest match it has found thus far.
+///
+/// Quit states are states that imply the DFA is not capable of matching the
+/// regex correctly. Currently, this is only used when a Unicode word boundary
+/// exists in the regex *and* a non-ASCII byte is observed.
+///
+/// The other type of state pointer is a state pointer with special flag bits.
+/// There are two flags: a start flag and a match flag. The lower bits of both
+/// kinds always contain a "valid" `StatePtr` (indicated by the `STATE_MAX`
+/// mask).
+///
+/// The start flag means that the state is a start state, and therefore may be
+/// subject to special prefix scanning optimizations.
+///
+/// The match flag means that the state is a match state, and therefore the
+/// current position in the input (while searching) should be recorded.
+///
+/// The above exists mostly in the service of making the inner loop fast.
+/// In particular, the inner *inner* loop looks something like this:
+///
+/// ```ignore
+/// while state <= STATE_MAX and i < len(text):
+///     state = state.next[i]
+/// ```
+///
+/// This is nice because it lets us execute a lazy DFA as if it were an
+/// entirely offline DFA (i.e., with very few instructions). The loop will
+/// quit only when we need to examine a case that needs special attention.
+type StatePtr = u32;
+
+/// An unknown state means that the state has not been computed yet, and that
+/// the only way to progress is to compute it.
+const STATE_UNKNOWN: StatePtr = 1 << 31;
+
+/// A dead state means that the state has been computed and it is known that
+/// once it is entered, no future match can ever occur.
+const STATE_DEAD: StatePtr = STATE_UNKNOWN + 1;
+
+/// A quit state means that the DFA came across some input that it doesn't
+/// know how to process correctly. The DFA should quit and another matching
+/// engine should be run in its place.
+const STATE_QUIT: StatePtr = STATE_DEAD + 1;
+
+/// A start state is a state that the DFA can start in.
+///
+/// Note that start states have their lower bits set to a state pointer.
+const STATE_START: StatePtr = 1 << 30;
+
+/// A match state means that the regex has successfully matched.
+///
+/// Note that match states have their lower bits set to a state pointer.
+const STATE_MATCH: StatePtr = 1 << 29;
+
+/// The maximum state pointer. This is useful to mask out the "valid" state
+/// pointer from a state with the "start" or "match" bits set.
+///
+/// It doesn't make sense to use this with unknown, dead or quit state
+/// pointers, since those pointers are sentinels and never have their lower
+/// bits set to anything meaningful.
+const STATE_MAX: StatePtr = STATE_MATCH - 1;
+
+/// Byte is a u8 in spirit, but a u16 in practice so that we can represent the
+/// special EOF sentinel value.
+#[derive(Copy, Clone, Debug)]
+struct Byte(u16);
+
+/// A set of flags for zero-width assertions.
+#[derive(Clone, Copy, Eq, Debug, Default, Hash, PartialEq)]
+struct EmptyFlags {
+    start: bool,
+    end: bool,
+    start_line: bool,
+    end_line: bool,
+    word_boundary: bool,
+    not_word_boundary: bool,
+}
+
+/// A set of flags describing various configurations of a DFA state. This is
+/// represented by a `u8` so that it is compact.
+#[derive(Clone, Copy, Eq, Default, Hash, PartialEq)]
+struct StateFlags(u8);
+
+impl Cache {
+    /// Create new empty cache for the DFA engine.
+    pub fn new(prog: &Program) -> Self {
+        // We add 1 to account for the special EOF byte.
+        let num_byte_classes = (prog.byte_classes[255] as usize + 1) + 1;
+        let starts = vec![STATE_UNKNOWN; 256];
+        let mut cache = Cache {
+            inner: CacheInner {
+                compiled: StateMap::new(num_byte_classes),
+                trans: Transitions::new(num_byte_classes),
+                start_states: starts,
+                stack: vec![],
+                flush_count: 0,
+                size: 0,
+                insts_scratch_space: vec![],
+            },
+            qcur: SparseSet::new(prog.insts.len()),
+            qnext: SparseSet::new(prog.insts.len()),
+        };
+        cache.inner.reset_size();
+        cache
+    }
+}
+
+impl CacheInner {
+    /// Resets the cache size to account for fixed costs, such as the program
+    /// and stack sizes.
+    fn reset_size(&mut self) {
+        self.size = (self.start_states.len() * mem::size_of::<StatePtr>())
+            + (self.stack.len() * mem::size_of::<InstPtr>());
+    }
+}
+
+impl<'a> Fsm<'a> {
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub fn forward(
+        prog: &'a Program,
+        cache: &ProgramCache,
+        quit_after_match: bool,
+        text: &[u8],
+        at: usize,
+    ) -> Result<usize> {
+        let mut cache = cache.borrow_mut();
+        let cache = &mut cache.dfa;
+        let mut dfa = Fsm {
+            prog,
+            start: 0, // filled in below
+            at,
+            quit_after_match,
+            last_match_si: STATE_UNKNOWN,
+            last_cache_flush: at,
+            cache: &mut cache.inner,
+        };
+        let (empty_flags, state_flags) = dfa.start_flags(text, at);
+        dfa.start =
+            match dfa.start_state(&mut cache.qcur, empty_flags, state_flags) {
+                None => return Result::Quit,
+                Some(STATE_DEAD) => return Result::NoMatch(at),
+                Some(si) => si,
+            };
+        debug_assert!(dfa.start != STATE_UNKNOWN);
+        dfa.exec_at(&mut cache.qcur, &mut cache.qnext, text)
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub fn reverse(
+        prog: &'a Program,
+        cache: &ProgramCache,
+        quit_after_match: bool,
+        text: &[u8],
+        at: usize,
+    ) -> Result<usize> {
+        let mut cache = cache.borrow_mut();
+        let cache = &mut cache.dfa_reverse;
+        let mut dfa = Fsm {
+            prog,
+            start: 0, // filled in below
+            at,
+            quit_after_match,
+            last_match_si: STATE_UNKNOWN,
+            last_cache_flush: at,
+            cache: &mut cache.inner,
+        };
+        let (empty_flags, state_flags) = dfa.start_flags_reverse(text, at);
+        dfa.start =
+            match dfa.start_state(&mut cache.qcur, empty_flags, state_flags) {
+                None => return Result::Quit,
+                Some(STATE_DEAD) => return Result::NoMatch(at),
+                Some(si) => si,
+            };
+        debug_assert!(dfa.start != STATE_UNKNOWN);
+        dfa.exec_at_reverse(&mut cache.qcur, &mut cache.qnext, text)
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub fn forward_many(
+        prog: &'a Program,
+        cache: &ProgramCache,
+        matches: &mut [bool],
+        text: &[u8],
+        at: usize,
+    ) -> Result<usize> {
+        debug_assert!(matches.len() == prog.matches.len());
+        let mut cache = cache.borrow_mut();
+        let cache = &mut cache.dfa;
+        let mut dfa = Fsm {
+            prog,
+            start: 0, // filled in below
+            at,
+            quit_after_match: false,
+            last_match_si: STATE_UNKNOWN,
+            last_cache_flush: at,
+            cache: &mut cache.inner,
+        };
+        let (empty_flags, state_flags) = dfa.start_flags(text, at);
+        dfa.start =
+            match dfa.start_state(&mut cache.qcur, empty_flags, state_flags) {
+                None => return Result::Quit,
+                Some(STATE_DEAD) => return Result::NoMatch(at),
+                Some(si) => si,
+            };
+        debug_assert!(dfa.start != STATE_UNKNOWN);
+        let result = dfa.exec_at(&mut cache.qcur, &mut cache.qnext, text);
+        if result.is_match() {
+            if matches.len() == 1 {
+                matches[0] = true;
+            } else {
+                debug_assert!(dfa.last_match_si != STATE_UNKNOWN);
+                debug_assert!(dfa.last_match_si != STATE_DEAD);
+                for ip in dfa.state(dfa.last_match_si).inst_ptrs() {
+                    if let Inst::Match(slot) = dfa.prog[ip] {
+                        matches[slot] = true;
+                    }
+                }
+            }
+        }
+        result
+    }
+
+    /// Executes the DFA on a forward NFA.
+    ///
+    /// {qcur,qnext} are scratch ordered sets which may be non-empty.
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn exec_at(
+        &mut self,
+        qcur: &mut SparseSet,
+        qnext: &mut SparseSet,
+        text: &[u8],
+    ) -> Result<usize> {
+        // For the most part, the DFA is basically:
+        //
+        //   last_match = null
+        //   while current_byte != EOF:
+        //     si = current_state.next[current_byte]
+        //     if si is match
+        //       last_match = si
+        //   return last_match
+        //
+        // However, we need to deal with a few things:
+        //
+        //   1. This is an *online* DFA, so the current state's next list
+        //      may not point to anywhere yet, so we must go out and compute
+        //      them. (They are then cached into the current state's next list
+        //      to avoid re-computation.)
+        //   2. If we come across a state that is known to be dead (i.e., never
+        //      leads to a match), then we can quit early.
+        //   3. If the caller just wants to know if a match occurs, then we
+        //      can quit as soon as we know we have a match. (Full leftmost
+        //      first semantics require continuing on.)
+        //   4. If we're in the start state, then we can use a pre-computed set
+        //      of prefix literals to skip quickly along the input.
+        //   5. After the input is exhausted, we run the DFA on one symbol
+        //      that stands for EOF. This is useful for handling empty width
+        //      assertions.
+        //   6. We can't actually do state.next[byte]. Instead, we have to do
+        //      state.next[byte_classes[byte]], which permits us to keep the
+        //      'next' list very small.
+        //
+        // Since there's a bunch of extra stuff we need to consider, we do some
+        // pretty hairy tricks to get the inner loop to run as fast as
+        // possible.
+        debug_assert!(!self.prog.is_reverse);
+
+        // The last match is the currently known ending match position. It is
+        // reported as an index to the most recent byte that resulted in a
+        // transition to a match state and is always stored in capture slot `1`
+        // when searching forwards. Its maximum value is `text.len()`.
+        let mut result = Result::NoMatch(self.at);
+        let (mut prev_si, mut next_si) = (self.start, self.start);
+        let mut at = self.at;
+        while at < text.len() {
+            // This is the real inner loop. We take advantage of special bits
+            // set in the state pointer to determine whether a state is in the
+            // "common" case or not. Specifically, the common case is a
+            // non-match non-start non-dead state that has already been
+            // computed. So long as we remain in the common case, this inner
+            // loop will chew through the input.
+            //
+            // We also unroll the loop 4 times to amortize the cost of checking
+            // whether we've consumed the entire input. We are also careful
+            // to make sure that `prev_si` always represents the previous state
+            // and `next_si` always represents the next state after the loop
+            // exits, even if it isn't always true inside the loop.
+            while next_si <= STATE_MAX && at < text.len() {
+                // Argument for safety is in the definition of next_si.
+                prev_si = unsafe { self.next_si(next_si, text, at) };
+                at += 1;
+                if prev_si > STATE_MAX || at + 2 >= text.len() {
+                    mem::swap(&mut prev_si, &mut next_si);
+                    break;
+                }
+                next_si = unsafe { self.next_si(prev_si, text, at) };
+                at += 1;
+                if next_si > STATE_MAX {
+                    break;
+                }
+                prev_si = unsafe { self.next_si(next_si, text, at) };
+                at += 1;
+                if prev_si > STATE_MAX {
+                    mem::swap(&mut prev_si, &mut next_si);
+                    break;
+                }
+                next_si = unsafe { self.next_si(prev_si, text, at) };
+                at += 1;
+            }
+            if next_si & STATE_MATCH > 0 {
+                // A match state is outside of the common case because it needs
+                // special case analysis. In particular, we need to record the
+                // last position as having matched and possibly quit the DFA if
+                // we don't need to keep matching.
+                next_si &= !STATE_MATCH;
+                result = Result::Match(at - 1);
+                if self.quit_after_match {
+                    return result;
+                }
+                self.last_match_si = next_si;
+                prev_si = next_si;
+
+                // This permits short-circuiting when matching a regex set.
+                // In particular, if this DFA state contains only match states,
+                // then it's impossible to extend the set of matches since
+                // match states are final. Therefore, we can quit.
+                if self.prog.matches.len() > 1 {
+                    let state = self.state(next_si);
+                    let just_matches =
+                        state.inst_ptrs().all(|ip| self.prog[ip].is_match());
+                    if just_matches {
+                        return result;
+                    }
+                }
+
+                // Another inner loop! If the DFA stays in this particular
+                // match state, then we can rip through all of the input
+                // very quickly, and only recording the match location once
+                // we've left this particular state.
+                let cur = at;
+                while (next_si & !STATE_MATCH) == prev_si
+                    && at + 2 < text.len()
+                {
+                    // Argument for safety is in the definition of next_si.
+                    next_si = unsafe {
+                        self.next_si(next_si & !STATE_MATCH, text, at)
+                    };
+                    at += 1;
+                }
+                if at > cur {
+                    result = Result::Match(at - 2);
+                }
+            } else if next_si & STATE_START > 0 {
+                // A start state isn't in the common case because we may
+                // want to do quick prefix scanning. If the program doesn't
+                // have a detected prefix, then start states are actually
+                // considered common and this case is never reached.
+                debug_assert!(self.has_prefix());
+                next_si &= !STATE_START;
+                prev_si = next_si;
+                at = match self.prefix_at(text, at) {
+                    None => return Result::NoMatch(text.len()),
+                    Some(i) => i,
+                };
+            } else if next_si >= STATE_UNKNOWN {
+                if next_si == STATE_QUIT {
+                    return Result::Quit;
+                }
+                // Finally, this corresponds to the case where the transition
+                // entered a state that can never lead to a match or a state
+                // that hasn't been computed yet. The latter being the "slow"
+                // path.
+                let byte = Byte::byte(text[at - 1]);
+                // We no longer care about the special bits in the state
+                // pointer.
+                prev_si &= STATE_MAX;
+                // Record where we are. This is used to track progress for
+                // determining whether we should quit if we've flushed the
+                // cache too much.
+                self.at = at;
+                next_si = match self.next_state(qcur, qnext, prev_si, byte) {
+                    None => return Result::Quit,
+                    Some(STATE_DEAD) => return result.set_non_match(at),
+                    Some(si) => si,
+                };
+                debug_assert!(next_si != STATE_UNKNOWN);
+                if next_si & STATE_MATCH > 0 {
+                    next_si &= !STATE_MATCH;
+                    result = Result::Match(at - 1);
+                    if self.quit_after_match {
+                        return result;
+                    }
+                    self.last_match_si = next_si;
+                }
+                prev_si = next_si;
+            } else {
+                prev_si = next_si;
+            }
+        }
+
+        // Run the DFA once more on the special EOF sentinel value.
+        // We don't care about the special bits in the state pointer any more,
+        // so get rid of them.
+        prev_si &= STATE_MAX;
+        prev_si = match self.next_state(qcur, qnext, prev_si, Byte::eof()) {
+            None => return Result::Quit,
+            Some(STATE_DEAD) => return result.set_non_match(text.len()),
+            Some(si) => si & !STATE_START,
+        };
+        debug_assert!(prev_si != STATE_UNKNOWN);
+        if prev_si & STATE_MATCH > 0 {
+            prev_si &= !STATE_MATCH;
+            self.last_match_si = prev_si;
+            result = Result::Match(text.len());
+        }
+        result
+    }
+
+    /// Executes the DFA on a reverse NFA.
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn exec_at_reverse(
+        &mut self,
+        qcur: &mut SparseSet,
+        qnext: &mut SparseSet,
+        text: &[u8],
+    ) -> Result<usize> {
+        // The comments in `exec_at` above mostly apply here too. The main
+        // difference is that we move backwards over the input and we look for
+        // the longest possible match instead of the leftmost-first match.
+        //
+        // N.B. The code duplication here is regrettable. Efforts to improve
+        // it without sacrificing performance are welcome. ---AG
+        debug_assert!(self.prog.is_reverse);
+        let mut result = Result::NoMatch(self.at);
+        let (mut prev_si, mut next_si) = (self.start, self.start);
+        let mut at = self.at;
+        while at > 0 {
+            while next_si <= STATE_MAX && at > 0 {
+                // Argument for safety is in the definition of next_si.
+                at -= 1;
+                prev_si = unsafe { self.next_si(next_si, text, at) };
+                if prev_si > STATE_MAX || at <= 4 {
+                    mem::swap(&mut prev_si, &mut next_si);
+                    break;
+                }
+                at -= 1;
+                next_si = unsafe { self.next_si(prev_si, text, at) };
+                if next_si > STATE_MAX {
+                    break;
+                }
+                at -= 1;
+                prev_si = unsafe { self.next_si(next_si, text, at) };
+                if prev_si > STATE_MAX {
+                    mem::swap(&mut prev_si, &mut next_si);
+                    break;
+                }
+                at -= 1;
+                next_si = unsafe { self.next_si(prev_si, text, at) };
+            }
+            if next_si & STATE_MATCH > 0 {
+                next_si &= !STATE_MATCH;
+                result = Result::Match(at + 1);
+                if self.quit_after_match {
+                    return result;
+                }
+                self.last_match_si = next_si;
+                prev_si = next_si;
+                let cur = at;
+                while (next_si & !STATE_MATCH) == prev_si && at >= 2 {
+                    // Argument for safety is in the definition of next_si.
+                    at -= 1;
+                    next_si = unsafe {
+                        self.next_si(next_si & !STATE_MATCH, text, at)
+                    };
+                }
+                if at < cur {
+                    result = Result::Match(at + 2);
+                }
+            } else if next_si >= STATE_UNKNOWN {
+                if next_si == STATE_QUIT {
+                    return Result::Quit;
+                }
+                let byte = Byte::byte(text[at]);
+                prev_si &= STATE_MAX;
+                self.at = at;
+                next_si = match self.next_state(qcur, qnext, prev_si, byte) {
+                    None => return Result::Quit,
+                    Some(STATE_DEAD) => return result.set_non_match(at),
+                    Some(si) => si,
+                };
+                debug_assert!(next_si != STATE_UNKNOWN);
+                if next_si & STATE_MATCH > 0 {
+                    next_si &= !STATE_MATCH;
+                    result = Result::Match(at + 1);
+                    if self.quit_after_match {
+                        return result;
+                    }
+                    self.last_match_si = next_si;
+                }
+                prev_si = next_si;
+            } else {
+                prev_si = next_si;
+            }
+        }
+
+        // Run the DFA once more on the special EOF sentinel value.
+        prev_si = match self.next_state(qcur, qnext, prev_si, Byte::eof()) {
+            None => return Result::Quit,
+            Some(STATE_DEAD) => return result.set_non_match(0),
+            Some(si) => si,
+        };
+        debug_assert!(prev_si != STATE_UNKNOWN);
+        if prev_si & STATE_MATCH > 0 {
+            prev_si &= !STATE_MATCH;
+            self.last_match_si = prev_si;
+            result = Result::Match(0);
+        }
+        result
+    }
+
+    /// next_si transitions to the next state, where the transition input
+    /// corresponds to text[i].
+    ///
+    /// This elides bounds checks, and is therefore not safe.
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    unsafe fn next_si(&self, si: StatePtr, text: &[u8], i: usize) -> StatePtr {
+        // What is the argument for safety here?
+        // We have three unchecked accesses that could possibly violate safety:
+        //
+        //   1. The given byte of input (`text[i]`).
+        //   2. The class of the byte of input (`classes[text[i]]`).
+        //   3. The transition for the class (`trans[si + cls]`).
+        //
+        // (1) is only safe when calling next_si is guarded by
+        // `i < text.len()`.
+        //
+        // (2) is the easiest case to guarantee since `text[i]` is always a
+        // `u8` and `self.prog.byte_classes` always has length `u8::MAX`.
+        // (See `ByteClassSet.byte_classes` in `compile.rs`.)
+        //
+        // (3) is only safe if (1)+(2) are safe. Namely, the transitions
+        // of every state are defined to have length equal to the number of
+        // byte classes in the program. Therefore, a valid class leads to a
+        // valid transition. (All possible transitions are valid lookups, even
+        // if it points to a state that hasn't been computed yet.) (3) also
+        // relies on `si` being correct, but StatePtrs should only ever be
+        // retrieved from the transition table, which ensures they are correct.
+        debug_assert!(i < text.len());
+        let b = *text.get_unchecked(i);
+        debug_assert!((b as usize) < self.prog.byte_classes.len());
+        let cls = *self.prog.byte_classes.get_unchecked(b as usize);
+        self.cache.trans.next_unchecked(si, cls as usize)
+    }
+
+    /// Computes the next state given the current state and the current input
+    /// byte (which may be EOF).
+    ///
+    /// If STATE_DEAD is returned, then there is no valid state transition.
+    /// This implies that no permutation of future input can lead to a match
+    /// state.
+    ///
+    /// STATE_UNKNOWN can never be returned.
+    fn exec_byte(
+        &mut self,
+        qcur: &mut SparseSet,
+        qnext: &mut SparseSet,
+        mut si: StatePtr,
+        b: Byte,
+    ) -> Option<StatePtr> {
+        use crate::prog::Inst::*;
+
+        // Initialize a queue with the current DFA state's NFA states.
+        qcur.clear();
+        for ip in self.state(si).inst_ptrs() {
+            qcur.insert(ip);
+        }
+
+        // Before inspecting the current byte, we may need to also inspect
+        // whether the position immediately preceding the current byte
+        // satisfies the empty assertions found in the current state.
+        //
+        // We only need to do this step if there are any empty assertions in
+        // the current state.
+        let is_word_last = self.state(si).flags().is_word();
+        let is_word = b.is_ascii_word();
+        if self.state(si).flags().has_empty() {
+            // Compute the flags immediately preceding the current byte.
+            // This means we only care about the "end" or "end line" flags.
+            // (The "start" flags are computed immediately following the
+            // current byte and are handled below.)
+            let mut flags = EmptyFlags::default();
+            if b.is_eof() {
+                flags.end = true;
+                flags.end_line = true;
+            } else if b.as_byte().map_or(false, |b| b == b'\n') {
+                flags.end_line = true;
+            }
+            if is_word_last == is_word {
+                flags.not_word_boundary = true;
+            } else {
+                flags.word_boundary = true;
+            }
+            // Now follow epsilon transitions from every NFA state, but make
+            // sure we only follow transitions that satisfy our flags.
+            qnext.clear();
+            for &ip in &*qcur {
+                self.follow_epsilons(usize_to_u32(ip), qnext, flags);
+            }
+            mem::swap(qcur, qnext);
+        }
+
+        // Now we set flags for immediately after the current byte. Since start
+        // states are processed separately, and are the only states that can
+        // have the StartText flag set, we therefore only need to worry about
+        // the StartLine flag here.
+        //
+        // We do also keep track of whether this DFA state contains a NFA state
+        // that is a matching state. This is precisely how we delay the DFA
+        // matching by one byte in order to process the special EOF sentinel
+        // byte. Namely, if this DFA state containing a matching NFA state,
+        // then it is the *next* DFA state that is marked as a match.
+        let mut empty_flags = EmptyFlags::default();
+        let mut state_flags = StateFlags::default();
+        empty_flags.start_line = b.as_byte().map_or(false, |b| b == b'\n');
+        if b.is_ascii_word() {
+            state_flags.set_word();
+        }
+        // Now follow all epsilon transitions again, but only after consuming
+        // the current byte.
+        qnext.clear();
+        for &ip in &*qcur {
+            match self.prog[ip as usize] {
+                // These states never happen in a byte-based program.
+                Char(_) | Ranges(_) => unreachable!(),
+                // These states are handled when following epsilon transitions.
+                Save(_) | Split(_) | EmptyLook(_) => {}
+                Match(_) => {
+                    state_flags.set_match();
+                    if !self.continue_past_first_match() {
+                        break;
+                    } else if self.prog.matches.len() > 1
+                        && !qnext.contains(ip as usize)
+                    {
+                        // If we are continuing on to find other matches,
+                        // then keep a record of the match states we've seen.
+                        qnext.insert(ip);
+                    }
+                }
+                Bytes(ref inst) => {
+                    if b.as_byte().map_or(false, |b| inst.matches(b)) {
+                        self.follow_epsilons(
+                            inst.goto as InstPtr,
+                            qnext,
+                            empty_flags,
+                        );
+                    }
+                }
+            }
+        }
+
+        let cache = if b.is_eof() && self.prog.matches.len() > 1 {
+            // If we're processing the last byte of the input and we're
+            // matching a regex set, then make the next state contain the
+            // previous states transitions. We do this so that the main
+            // matching loop can extract all of the match instructions.
+            mem::swap(qcur, qnext);
+            // And don't cache this state because it's totally bunk.
+            false
+        } else {
+            true
+        };
+
+        // We've now built up the set of NFA states that ought to comprise the
+        // next DFA state, so try to find it in the cache, and if it doesn't
+        // exist, cache it.
+        //
+        // N.B. We pass `&mut si` here because the cache may clear itself if
+        // it has gotten too full. When that happens, the location of the
+        // current state may change.
+        let mut next =
+            match self.cached_state(qnext, state_flags, Some(&mut si)) {
+                None => return None,
+                Some(next) => next,
+            };
+        if (self.start & !STATE_START) == next {
+            // Start states can never be match states since all matches are
+            // delayed by one byte.
+            debug_assert!(!self.state(next).flags().is_match());
+            next = self.start_ptr(next);
+        }
+        if next <= STATE_MAX && self.state(next).flags().is_match() {
+            next |= STATE_MATCH;
+        }
+        debug_assert!(next != STATE_UNKNOWN);
+        // And now store our state in the current state's next list.
+        if cache {
+            let cls = self.byte_class(b);
+            self.cache.trans.set_next(si, cls, next);
+        }
+        Some(next)
+    }
+
+    /// Follows the epsilon transitions starting at (and including) `ip`. The
+    /// resulting states are inserted into the ordered set `q`.
+    ///
+    /// Conditional epsilon transitions (i.e., empty width assertions) are only
+    /// followed if they are satisfied by the given flags, which should
+    /// represent the flags set at the current location in the input.
+    ///
+    /// If the current location corresponds to the empty string, then only the
+    /// end line and/or end text flags may be set. If the current location
+    /// corresponds to a real byte in the input, then only the start line
+    /// and/or start text flags may be set.
+    ///
+    /// As an exception to the above, when finding the initial state, any of
+    /// the above flags may be set:
+    ///
+    /// If matching starts at the beginning of the input, then start text and
+    /// start line should be set. If the input is empty, then end text and end
+    /// line should also be set.
+    ///
+    /// If matching starts after the beginning of the input, then only start
+    /// line should be set if the preceding byte is `\n`. End line should never
+    /// be set in this case. (Even if the following byte is a `\n`, it will
+    /// be handled in a subsequent DFA state.)
+    fn follow_epsilons(
+        &mut self,
+        ip: InstPtr,
+        q: &mut SparseSet,
+        flags: EmptyFlags,
+    ) {
+        use crate::prog::EmptyLook::*;
+        use crate::prog::Inst::*;
+
+        // We need to traverse the NFA to follow epsilon transitions, so avoid
+        // recursion with an explicit stack.
+        self.cache.stack.push(ip);
+        while let Some(mut ip) = self.cache.stack.pop() {
+            // Try to munch through as many states as possible without
+            // pushes/pops to the stack.
+            loop {
+                // Don't visit states we've already added.
+                if q.contains(ip as usize) {
+                    break;
+                }
+                q.insert(ip as usize);
+                match self.prog[ip as usize] {
+                    Char(_) | Ranges(_) => unreachable!(),
+                    Match(_) | Bytes(_) => {
+                        break;
+                    }
+                    EmptyLook(ref inst) => {
+                        // Only follow empty assertion states if our flags
+                        // satisfy the assertion.
+                        match inst.look {
+                            StartLine if flags.start_line => {
+                                ip = inst.goto as InstPtr;
+                            }
+                            EndLine if flags.end_line => {
+                                ip = inst.goto as InstPtr;
+                            }
+                            StartText if flags.start => {
+                                ip = inst.goto as InstPtr;
+                            }
+                            EndText if flags.end => {
+                                ip = inst.goto as InstPtr;
+                            }
+                            WordBoundaryAscii if flags.word_boundary => {
+                                ip = inst.goto as InstPtr;
+                            }
+                            NotWordBoundaryAscii
+                                if flags.not_word_boundary =>
+                            {
+                                ip = inst.goto as InstPtr;
+                            }
+                            WordBoundary if flags.word_boundary => {
+                                ip = inst.goto as InstPtr;
+                            }
+                            NotWordBoundary if flags.not_word_boundary => {
+                                ip = inst.goto as InstPtr;
+                            }
+                            StartLine | EndLine | StartText | EndText
+                            | WordBoundaryAscii | NotWordBoundaryAscii
+                            | WordBoundary | NotWordBoundary => {
+                                break;
+                            }
+                        }
+                    }
+                    Save(ref inst) => {
+                        ip = inst.goto as InstPtr;
+                    }
+                    Split(ref inst) => {
+                        self.cache.stack.push(inst.goto2 as InstPtr);
+                        ip = inst.goto1 as InstPtr;
+                    }
+                }
+            }
+        }
+    }
+
+    /// Find a previously computed state matching the given set of instructions
+    /// and is_match bool.
+    ///
+    /// The given set of instructions should represent a single state in the
+    /// NFA along with all states reachable without consuming any input.
+    ///
+    /// The is_match bool should be true if and only if the preceding DFA state
+    /// contains an NFA matching state. The cached state produced here will
+    /// then signify a match. (This enables us to delay a match by one byte,
+    /// in order to account for the EOF sentinel byte.)
+    ///
+    /// If the cache is full, then it is wiped before caching a new state.
+    ///
+    /// The current state should be specified if it exists, since it will need
+    /// to be preserved if the cache clears itself. (Start states are
+    /// always saved, so they should not be passed here.) It takes a mutable
+    /// pointer to the index because if the cache is cleared, the state's
+    /// location may change.
+    fn cached_state(
+        &mut self,
+        q: &SparseSet,
+        mut state_flags: StateFlags,
+        current_state: Option<&mut StatePtr>,
+    ) -> Option<StatePtr> {
+        // If we couldn't come up with a non-empty key to represent this state,
+        // then it is dead and can never lead to a match.
+        //
+        // Note that inst_flags represent the set of empty width assertions
+        // in q. We use this as an optimization in exec_byte to determine when
+        // we should follow epsilon transitions at the empty string preceding
+        // the current byte.
+        let key = match self.cached_state_key(q, &mut state_flags) {
+            None => return Some(STATE_DEAD),
+            Some(v) => v,
+        };
+        // In the cache? Cool. Done.
+        if let Some(si) = self.cache.compiled.get_ptr(&key) {
+            return Some(si);
+        }
+        // If the cache has gotten too big, wipe it.
+        if self.approximate_size() > self.prog.dfa_size_limit
+            && !self.clear_cache_and_save(current_state)
+        {
+            // Ooops. DFA is giving up.
+            return None;
+        }
+        // Allocate room for our state and add it.
+        self.add_state(key)
+    }
+
+    /// Produces a key suitable for describing a state in the DFA cache.
+    ///
+    /// The key invariant here is that equivalent keys are produced for any two
+    /// sets of ordered NFA states (and toggling of whether the previous NFA
+    /// states contain a match state) that do not discriminate a match for any
+    /// input.
+    ///
+    /// Specifically, q should be an ordered set of NFA states and is_match
+    /// should be true if and only if the previous NFA states contained a match
+    /// state.
+    fn cached_state_key(
+        &mut self,
+        q: &SparseSet,
+        state_flags: &mut StateFlags,
+    ) -> Option<State> {
+        use crate::prog::Inst::*;
+
+        // We need to build up enough information to recognize pre-built states
+        // in the DFA. Generally speaking, this includes every instruction
+        // except for those which are purely epsilon transitions, e.g., the
+        // Save and Split instructions.
+        //
+        // Empty width assertions are also epsilon transitions, but since they
+        // are conditional, we need to make them part of a state's key in the
+        // cache.
+
+        let mut insts =
+            mem::replace(&mut self.cache.insts_scratch_space, vec![]);
+        insts.clear();
+        // Reserve 1 byte for flags.
+        insts.push(0);
+
+        let mut prev = 0;
+        for &ip in q {
+            let ip = usize_to_u32(ip);
+            match self.prog[ip as usize] {
+                Char(_) | Ranges(_) => unreachable!(),
+                Save(_) | Split(_) => {}
+                Bytes(_) => push_inst_ptr(&mut insts, &mut prev, ip),
+                EmptyLook(_) => {
+                    state_flags.set_empty();
+                    push_inst_ptr(&mut insts, &mut prev, ip)
+                }
+                Match(_) => {
+                    push_inst_ptr(&mut insts, &mut prev, ip);
+                    if !self.continue_past_first_match() {
+                        break;
+                    }
+                }
+            }
+        }
+        // If we couldn't transition to any other instructions and we didn't
+        // see a match when expanding NFA states previously, then this is a
+        // dead state and no amount of additional input can transition out
+        // of this state.
+        let opt_state = if insts.len() == 1 && !state_flags.is_match() {
+            None
+        } else {
+            let StateFlags(f) = *state_flags;
+            insts[0] = f;
+            Some(State { data: Arc::from(&*insts) })
+        };
+        self.cache.insts_scratch_space = insts;
+        opt_state
+    }
+
+    /// Clears the cache, but saves and restores current_state if it is not
+    /// none.
+    ///
+    /// The current state must be provided here in case its location in the
+    /// cache changes.
+    ///
+    /// This returns false if the cache is not cleared and the DFA should
+    /// give up.
+    fn clear_cache_and_save(
+        &mut self,
+        current_state: Option<&mut StatePtr>,
+    ) -> bool {
+        if self.cache.compiled.is_empty() {
+            // Nothing to clear...
+            return true;
+        }
+        match current_state {
+            None => self.clear_cache(),
+            Some(si) => {
+                let cur = self.state(*si).clone();
+                if !self.clear_cache() {
+                    return false;
+                }
+                // The unwrap is OK because we just cleared the cache and
+                // therefore know that the next state pointer won't exceed
+                // STATE_MAX.
+                *si = self.restore_state(cur).unwrap();
+                true
+            }
+        }
+    }
+
+    /// Wipes the state cache, but saves and restores the current start state.
+    ///
+    /// This returns false if the cache is not cleared and the DFA should
+    /// give up.
+    fn clear_cache(&mut self) -> bool {
+        // Bail out of the DFA if we're moving too "slowly."
+        // A heuristic from RE2: assume the DFA is too slow if it is processing
+        // 10 or fewer bytes per state.
+        // Additionally, we permit the cache to be flushed a few times before
+        // caling it quits.
+        let nstates = self.cache.compiled.len();
+        if self.cache.flush_count >= 3
+            && self.at >= self.last_cache_flush
+            && (self.at - self.last_cache_flush) <= 10 * nstates
+        {
+            return false;
+        }
+        // Update statistics tracking cache flushes.
+        self.last_cache_flush = self.at;
+        self.cache.flush_count += 1;
+
+        // OK, actually flush the cache.
+        let start = self.state(self.start & !STATE_START).clone();
+        let last_match = if self.last_match_si <= STATE_MAX {
+            Some(self.state(self.last_match_si).clone())
+        } else {
+            None
+        };
+        self.cache.reset_size();
+        self.cache.trans.clear();
+        self.cache.compiled.clear();
+        for s in &mut self.cache.start_states {
+            *s = STATE_UNKNOWN;
+        }
+        // The unwraps are OK because we just cleared the cache and therefore
+        // know that the next state pointer won't exceed STATE_MAX.
+        let start_ptr = self.restore_state(start).unwrap();
+        self.start = self.start_ptr(start_ptr);
+        if let Some(last_match) = last_match {
+            self.last_match_si = self.restore_state(last_match).unwrap();
+        }
+        true
+    }
+
+    /// Restores the given state back into the cache, and returns a pointer
+    /// to it.
+    fn restore_state(&mut self, state: State) -> Option<StatePtr> {
+        // If we've already stored this state, just return a pointer to it.
+        // None will be the wiser.
+        if let Some(si) = self.cache.compiled.get_ptr(&state) {
+            return Some(si);
+        }
+        self.add_state(state)
+    }
+
+    /// Returns the next state given the current state si and current byte
+    /// b. {qcur,qnext} are used as scratch space for storing ordered NFA
+    /// states.
+    ///
+    /// This tries to fetch the next state from the cache, but if that fails,
+    /// it computes the next state, caches it and returns a pointer to it.
+    ///
+    /// The pointer can be to a real state, or it can be STATE_DEAD.
+    /// STATE_UNKNOWN cannot be returned.
+    ///
+    /// None is returned if a new state could not be allocated (i.e., the DFA
+    /// ran out of space and thinks it's running too slowly).
+    fn next_state(
+        &mut self,
+        qcur: &mut SparseSet,
+        qnext: &mut SparseSet,
+        si: StatePtr,
+        b: Byte,
+    ) -> Option<StatePtr> {
+        if si == STATE_DEAD {
+            return Some(STATE_DEAD);
+        }
+        match self.cache.trans.next(si, self.byte_class(b)) {
+            STATE_UNKNOWN => self.exec_byte(qcur, qnext, si, b),
+            STATE_QUIT => None,
+            nsi => Some(nsi),
+        }
+    }
+
+    /// Computes and returns the start state, where searching begins at
+    /// position `at` in `text`. If the state has already been computed,
+    /// then it is pulled from the cache. If the state hasn't been cached,
+    /// then it is computed, cached and a pointer to it is returned.
+    ///
+    /// This may return STATE_DEAD but never STATE_UNKNOWN.
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn start_state(
+        &mut self,
+        q: &mut SparseSet,
+        empty_flags: EmptyFlags,
+        state_flags: StateFlags,
+    ) -> Option<StatePtr> {
+        // Compute an index into our cache of start states based on the set
+        // of empty/state flags set at the current position in the input. We
+        // don't use every flag since not all flags matter. For example, since
+        // matches are delayed by one byte, start states can never be match
+        // states.
+        let flagi = {
+            (((empty_flags.start as u8) << 0)
+                | ((empty_flags.end as u8) << 1)
+                | ((empty_flags.start_line as u8) << 2)
+                | ((empty_flags.end_line as u8) << 3)
+                | ((empty_flags.word_boundary as u8) << 4)
+                | ((empty_flags.not_word_boundary as u8) << 5)
+                | ((state_flags.is_word() as u8) << 6)) as usize
+        };
+        match self.cache.start_states[flagi] {
+            STATE_UNKNOWN => {}
+            si => return Some(si),
+        }
+        q.clear();
+        let start = usize_to_u32(self.prog.start);
+        self.follow_epsilons(start, q, empty_flags);
+        // Start states can never be match states because we delay every match
+        // by one byte. Given an empty string and an empty match, the match
+        // won't actually occur until the DFA processes the special EOF
+        // sentinel byte.
+        let sp = match self.cached_state(q, state_flags, None) {
+            None => return None,
+            Some(sp) => self.start_ptr(sp),
+        };
+        self.cache.start_states[flagi] = sp;
+        Some(sp)
+    }
+
+    /// Computes the set of starting flags for the given position in text.
+    ///
+    /// This should only be used when executing the DFA forwards over the
+    /// input.
+    fn start_flags(&self, text: &[u8], at: usize) -> (EmptyFlags, StateFlags) {
+        let mut empty_flags = EmptyFlags::default();
+        let mut state_flags = StateFlags::default();
+        empty_flags.start = at == 0;
+        empty_flags.end = text.is_empty();
+        empty_flags.start_line = at == 0 || text[at - 1] == b'\n';
+        empty_flags.end_line = text.is_empty();
+
+        let is_word_last = at > 0 && Byte::byte(text[at - 1]).is_ascii_word();
+        let is_word = at < text.len() && Byte::byte(text[at]).is_ascii_word();
+        if is_word_last {
+            state_flags.set_word();
+        }
+        if is_word == is_word_last {
+            empty_flags.not_word_boundary = true;
+        } else {
+            empty_flags.word_boundary = true;
+        }
+        (empty_flags, state_flags)
+    }
+
+    /// Computes the set of starting flags for the given position in text.
+    ///
+    /// This should only be used when executing the DFA in reverse over the
+    /// input.
+    fn start_flags_reverse(
+        &self,
+        text: &[u8],
+        at: usize,
+    ) -> (EmptyFlags, StateFlags) {
+        let mut empty_flags = EmptyFlags::default();
+        let mut state_flags = StateFlags::default();
+        empty_flags.start = at == text.len();
+        empty_flags.end = text.is_empty();
+        empty_flags.start_line = at == text.len() || text[at] == b'\n';
+        empty_flags.end_line = text.is_empty();
+
+        let is_word_last =
+            at < text.len() && Byte::byte(text[at]).is_ascii_word();
+        let is_word = at > 0 && Byte::byte(text[at - 1]).is_ascii_word();
+        if is_word_last {
+            state_flags.set_word();
+        }
+        if is_word == is_word_last {
+            empty_flags.not_word_boundary = true;
+        } else {
+            empty_flags.word_boundary = true;
+        }
+        (empty_flags, state_flags)
+    }
+
+    /// Returns a reference to a State given a pointer to it.
+    fn state(&self, si: StatePtr) -> &State {
+        self.cache.compiled.get_state(si).unwrap()
+    }
+
+    /// Adds the given state to the DFA.
+    ///
+    /// This allocates room for transitions out of this state in
+    /// self.cache.trans. The transitions can be set with the returned
+    /// StatePtr.
+    ///
+    /// If None is returned, then the state limit was reached and the DFA
+    /// should quit.
+    fn add_state(&mut self, state: State) -> Option<StatePtr> {
+        // This will fail if the next state pointer exceeds STATE_PTR. In
+        // practice, the cache limit will prevent us from ever getting here,
+        // but maybe callers will set the cache size to something ridiculous...
+        let si = match self.cache.trans.add() {
+            None => return None,
+            Some(si) => si,
+        };
+        // If the program has a Unicode word boundary, then set any transitions
+        // for non-ASCII bytes to STATE_QUIT. If the DFA stumbles over such a
+        // transition, then it will quit and an alternative matching engine
+        // will take over.
+        if self.prog.has_unicode_word_boundary {
+            for b in 128..256 {
+                let cls = self.byte_class(Byte::byte(b as u8));
+                self.cache.trans.set_next(si, cls, STATE_QUIT);
+            }
+        }
+        // Finally, put our actual state on to our heap of states and index it
+        // so we can find it later.
+        self.cache.size += self.cache.trans.state_heap_size()
+            + state.data.len()
+            + (2 * mem::size_of::<State>())
+            + mem::size_of::<StatePtr>();
+        self.cache.compiled.insert(state, si);
+        // Transition table and set of states and map should all be in sync.
+        debug_assert!(
+            self.cache.compiled.len() == self.cache.trans.num_states()
+        );
+        Some(si)
+    }
+
+    /// Quickly finds the next occurrence of any literal prefixes in the regex.
+    /// If there are no literal prefixes, then the current position is
+    /// returned. If there are literal prefixes and one could not be found,
+    /// then None is returned.
+    ///
+    /// This should only be called when the DFA is in a start state.
+    fn prefix_at(&self, text: &[u8], at: usize) -> Option<usize> {
+        self.prog.prefixes.find(&text[at..]).map(|(s, _)| at + s)
+    }
+
+    /// Returns the number of byte classes required to discriminate transitions
+    /// in each state.
+    ///
+    /// invariant: num_byte_classes() == len(State.next)
+    fn num_byte_classes(&self) -> usize {
+        // We add 1 to account for the special EOF byte.
+        (self.prog.byte_classes[255] as usize + 1) + 1
+    }
+
+    /// Given an input byte or the special EOF sentinel, return its
+    /// corresponding byte class.
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn byte_class(&self, b: Byte) -> usize {
+        match b.as_byte() {
+            None => self.num_byte_classes() - 1,
+            Some(b) => self.u8_class(b),
+        }
+    }
+
+    /// Like byte_class, but explicitly for u8s.
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn u8_class(&self, b: u8) -> usize {
+        self.prog.byte_classes[b as usize] as usize
+    }
+
+    /// Returns true if the DFA should continue searching past the first match.
+    ///
+    /// Leftmost first semantics in the DFA are preserved by not following NFA
+    /// transitions after the first match is seen.
+    ///
+    /// On occasion, we want to avoid leftmost first semantics to find either
+    /// the longest match (for reverse search) or all possible matches (for
+    /// regex sets).
+    fn continue_past_first_match(&self) -> bool {
+        self.prog.is_reverse || self.prog.matches.len() > 1
+    }
+
+    /// Returns true if there is a prefix we can quickly search for.
+    fn has_prefix(&self) -> bool {
+        !self.prog.is_reverse
+            && !self.prog.prefixes.is_empty()
+            && !self.prog.is_anchored_start
+    }
+
+    /// Sets the STATE_START bit in the given state pointer if and only if
+    /// we have a prefix to scan for.
+    ///
+    /// If there's no prefix, then it's a waste to treat the start state
+    /// specially.
+    fn start_ptr(&self, si: StatePtr) -> StatePtr {
+        if self.has_prefix() {
+            si | STATE_START
+        } else {
+            si
+        }
+    }
+
+    /// Approximate size returns the approximate heap space currently used by
+    /// the DFA. It is used to determine whether the DFA's state cache needs to
+    /// be wiped. Namely, it is possible that for certain regexes on certain
+    /// inputs, a new state could be created for every byte of input. (This is
+    /// bad for memory use, so we bound it with a cache.)
+    fn approximate_size(&self) -> usize {
+        self.cache.size + self.prog.approximate_size()
+    }
+}
+
+/// An abstraction for representing a map of states. The map supports two
+/// different ways of state lookup. One is fast constant time access via a
+/// state pointer. The other is a hashmap lookup based on the DFA's
+/// constituent NFA states.
+///
+/// A DFA state internally uses an Arc such that we only need to store the
+/// set of NFA states on the heap once, even though we support looking up
+/// states by two different means. A more natural way to express this might
+/// use raw pointers, but an Arc is safe and effectively achieves the same
+/// thing.
+#[derive(Debug)]
+struct StateMap {
+    /// The keys are not actually static but rely on always pointing to a
+    /// buffer in `states` which will never be moved except when clearing
+    /// the map or on drop, in which case the keys of this map will be
+    /// removed before
+    map: HashMap<State, StatePtr>,
+    /// Our set of states. Note that `StatePtr / num_byte_classes` indexes
+    /// this Vec rather than just a `StatePtr`.
+    states: Vec<State>,
+    /// The number of byte classes in the DFA. Used to index `states`.
+    num_byte_classes: usize,
+}
+
+impl StateMap {
+    fn new(num_byte_classes: usize) -> StateMap {
+        StateMap { map: HashMap::new(), states: vec![], num_byte_classes }
+    }
+
+    fn len(&self) -> usize {
+        self.states.len()
+    }
+
+    fn is_empty(&self) -> bool {
+        self.states.is_empty()
+    }
+
+    fn get_ptr(&self, state: &State) -> Option<StatePtr> {
+        self.map.get(state).cloned()
+    }
+
+    fn get_state(&self, si: StatePtr) -> Option<&State> {
+        self.states.get(si as usize / self.num_byte_classes)
+    }
+
+    fn insert(&mut self, state: State, si: StatePtr) {
+        self.map.insert(state.clone(), si);
+        self.states.push(state);
+    }
+
+    fn clear(&mut self) {
+        self.map.clear();
+        self.states.clear();
+    }
+}
+
+impl Transitions {
+    /// Create a new transition table.
+    ///
+    /// The number of byte classes corresponds to the stride. Every state will
+    /// have `num_byte_classes` slots for transitions.
+    fn new(num_byte_classes: usize) -> Transitions {
+        Transitions { table: vec![], num_byte_classes }
+    }
+
+    /// Returns the total number of states currently in this table.
+    fn num_states(&self) -> usize {
+        self.table.len() / self.num_byte_classes
+    }
+
+    /// Allocates room for one additional state and returns a pointer to it.
+    ///
+    /// If there's no more room, None is returned.
+    fn add(&mut self) -> Option<StatePtr> {
+        let si = self.table.len();
+        if si > STATE_MAX as usize {
+            return None;
+        }
+        self.table.extend(repeat(STATE_UNKNOWN).take(self.num_byte_classes));
+        Some(usize_to_u32(si))
+    }
+
+    /// Clears the table of all states.
+    fn clear(&mut self) {
+        self.table.clear();
+    }
+
+    /// Sets the transition from (si, cls) to next.
+    fn set_next(&mut self, si: StatePtr, cls: usize, next: StatePtr) {
+        self.table[si as usize + cls] = next;
+    }
+
+    /// Returns the transition corresponding to (si, cls).
+    fn next(&self, si: StatePtr, cls: usize) -> StatePtr {
+        self.table[si as usize + cls]
+    }
+
+    /// The heap size, in bytes, of a single state in the transition table.
+    fn state_heap_size(&self) -> usize {
+        self.num_byte_classes * mem::size_of::<StatePtr>()
+    }
+
+    /// Like `next`, but uses unchecked access and is therefore not safe.
+    unsafe fn next_unchecked(&self, si: StatePtr, cls: usize) -> StatePtr {
+        debug_assert!((si as usize) < self.table.len());
+        debug_assert!(cls < self.num_byte_classes);
+        *self.table.get_unchecked(si as usize + cls)
+    }
+}
+
+impl StateFlags {
+    fn is_match(&self) -> bool {
+        self.0 & 0b0000_0001 > 0
+    }
+
+    fn set_match(&mut self) {
+        self.0 |= 0b0000_0001;
+    }
+
+    fn is_word(&self) -> bool {
+        self.0 & 0b0000_0010 > 0
+    }
+
+    fn set_word(&mut self) {
+        self.0 |= 0b0000_0010;
+    }
+
+    fn has_empty(&self) -> bool {
+        self.0 & 0b0000_0100 > 0
+    }
+
+    fn set_empty(&mut self) {
+        self.0 |= 0b0000_0100;
+    }
+}
+
+impl Byte {
+    fn byte(b: u8) -> Self {
+        Byte(b as u16)
+    }
+    fn eof() -> Self {
+        Byte(256)
+    }
+    fn is_eof(&self) -> bool {
+        self.0 == 256
+    }
+
+    fn is_ascii_word(&self) -> bool {
+        let b = match self.as_byte() {
+            None => return false,
+            Some(b) => b,
+        };
+        match b {
+            b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'_' => true,
+            _ => false,
+        }
+    }
+
+    fn as_byte(&self) -> Option<u8> {
+        if self.is_eof() {
+            None
+        } else {
+            Some(self.0 as u8)
+        }
+    }
+}
+
+impl fmt::Debug for State {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let ips: Vec<usize> = self.inst_ptrs().collect();
+        f.debug_struct("State")
+            .field("flags", &self.flags())
+            .field("insts", &ips)
+            .finish()
+    }
+}
+
+impl fmt::Debug for Transitions {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut fmtd = f.debug_map();
+        for si in 0..self.num_states() {
+            let s = si * self.num_byte_classes;
+            let e = s + self.num_byte_classes;
+            fmtd.entry(&si.to_string(), &TransitionsRow(&self.table[s..e]));
+        }
+        fmtd.finish()
+    }
+}
+
+struct TransitionsRow<'a>(&'a [StatePtr]);
+
+impl<'a> fmt::Debug for TransitionsRow<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut fmtd = f.debug_map();
+        for (b, si) in self.0.iter().enumerate() {
+            match *si {
+                STATE_UNKNOWN => {}
+                STATE_DEAD => {
+                    fmtd.entry(&vb(b as usize), &"DEAD");
+                }
+                si => {
+                    fmtd.entry(&vb(b as usize), &si.to_string());
+                }
+            }
+        }
+        fmtd.finish()
+    }
+}
+
+impl fmt::Debug for StateFlags {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("StateFlags")
+            .field("is_match", &self.is_match())
+            .field("is_word", &self.is_word())
+            .field("has_empty", &self.has_empty())
+            .finish()
+    }
+}
+
+/// Helper function for formatting a byte as a nice-to-read escaped string.
+fn vb(b: usize) -> String {
+    use std::ascii::escape_default;
+
+    if b > ::std::u8::MAX as usize {
+        "EOF".to_owned()
+    } else {
+        let escaped = escape_default(b as u8).collect::<Vec<u8>>();
+        String::from_utf8_lossy(&escaped).into_owned()
+    }
+}
+
+fn usize_to_u32(n: usize) -> u32 {
+    if (n as u64) > (::std::u32::MAX as u64) {
+        panic!("BUG: {} is too big to fit into u32", n)
+    }
+    n as u32
+}
+
+#[allow(dead_code)] // useful for debugging
+fn show_state_ptr(si: StatePtr) -> String {
+    let mut s = format!("{:?}", si & STATE_MAX);
+    if si == STATE_UNKNOWN {
+        s = format!("{} (unknown)", s);
+    }
+    if si == STATE_DEAD {
+        s = format!("{} (dead)", s);
+    }
+    if si == STATE_QUIT {
+        s = format!("{} (quit)", s);
+    }
+    if si & STATE_START > 0 {
+        s = format!("{} (start)", s);
+    }
+    if si & STATE_MATCH > 0 {
+        s = format!("{} (match)", s);
+    }
+    s
+}
+
+/// https://developers.google.com/protocol-buffers/docs/encoding#varints
+fn write_vari32(data: &mut Vec<u8>, n: i32) {
+    let mut un = (n as u32) << 1;
+    if n < 0 {
+        un = !un;
+    }
+    write_varu32(data, un)
+}
+
+/// https://developers.google.com/protocol-buffers/docs/encoding#varints
+fn read_vari32(data: &[u8]) -> (i32, usize) {
+    let (un, i) = read_varu32(data);
+    let mut n = (un >> 1) as i32;
+    if un & 1 != 0 {
+        n = !n;
+    }
+    (n, i)
+}
+
+/// https://developers.google.com/protocol-buffers/docs/encoding#varints
+fn write_varu32(data: &mut Vec<u8>, mut n: u32) {
+    while n >= 0b1000_0000 {
+        data.push((n as u8) | 0b1000_0000);
+        n >>= 7;
+    }
+    data.push(n as u8);
+}
+
+/// https://developers.google.com/protocol-buffers/docs/encoding#varints
+fn read_varu32(data: &[u8]) -> (u32, usize) {
+    let mut n: u32 = 0;
+    let mut shift: u32 = 0;
+    for (i, &b) in data.iter().enumerate() {
+        if b < 0b1000_0000 {
+            return (n | ((b as u32) << shift), i + 1);
+        }
+        n |= ((b as u32) & 0b0111_1111) << shift;
+        shift += 7;
+    }
+    (0, 0)
+}
+
+#[cfg(test)]
+mod tests {
+
+    use super::{
+        push_inst_ptr, read_vari32, read_varu32, write_vari32, write_varu32,
+        State, StateFlags,
+    };
+    use quickcheck::{quickcheck, Gen, QuickCheck};
+    use std::sync::Arc;
+
+    #[test]
+    fn prop_state_encode_decode() {
+        fn p(mut ips: Vec<u32>, flags: u8) -> bool {
+            // It looks like our encoding scheme can't handle instruction
+            // pointers at or above 2**31. We should fix that, but it seems
+            // unlikely to occur in real code due to the amount of memory
+            // required for such a state machine. So for now, we just clamp
+            // our test data.
+            for ip in &mut ips {
+                if *ip >= 1 << 31 {
+                    *ip = (1 << 31) - 1;
+                }
+            }
+            let mut data = vec![flags];
+            let mut prev = 0;
+            for &ip in ips.iter() {
+                push_inst_ptr(&mut data, &mut prev, ip);
+            }
+            let state = State { data: Arc::from(&data[..]) };
+
+            let expected: Vec<usize> =
+                ips.into_iter().map(|ip| ip as usize).collect();
+            let got: Vec<usize> = state.inst_ptrs().collect();
+            expected == got && state.flags() == StateFlags(flags)
+        }
+        QuickCheck::new()
+            .gen(Gen::new(10_000))
+            .quickcheck(p as fn(Vec<u32>, u8) -> bool);
+    }
+
+    #[test]
+    fn prop_read_write_u32() {
+        fn p(n: u32) -> bool {
+            let mut buf = vec![];
+            write_varu32(&mut buf, n);
+            let (got, nread) = read_varu32(&buf);
+            nread == buf.len() && got == n
+        }
+        quickcheck(p as fn(u32) -> bool);
+    }
+
+    #[test]
+    fn prop_read_write_i32() {
+        fn p(n: i32) -> bool {
+            let mut buf = vec![];
+            write_vari32(&mut buf, n);
+            let (got, nread) = read_vari32(&buf);
+            nread == buf.len() && got == n
+        }
+        quickcheck(p as fn(i32) -> bool);
+    }
+}
diff --git a/crates/regex/src/error.rs b/crates/regex/src/error.rs
new file mode 100644
index 0000000..3e0ec75
--- /dev/null
+++ b/crates/regex/src/error.rs
@@ -0,0 +1,71 @@
+use std::fmt;
+use std::iter::repeat;
+
+/// An error that occurred during parsing or compiling a regular expression.
+#[derive(Clone, PartialEq)]
+pub enum Error {
+    /// A syntax error.
+    Syntax(String),
+    /// The compiled program exceeded the set size limit.
+    /// The argument is the size limit imposed.
+    CompiledTooBig(usize),
+    /// Hints that destructuring should not be exhaustive.
+    ///
+    /// This enum may grow additional variants, so this makes sure clients
+    /// don't count on exhaustive matching. (Otherwise, adding a new variant
+    /// could break existing code.)
+    #[doc(hidden)]
+    __Nonexhaustive,
+}
+
+impl ::std::error::Error for Error {
+    // TODO: Remove this method entirely on the next breaking semver release.
+    #[allow(deprecated)]
+    fn description(&self) -> &str {
+        match *self {
+            Error::Syntax(ref err) => err,
+            Error::CompiledTooBig(_) => "compiled program too big",
+            Error::__Nonexhaustive => unreachable!(),
+        }
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            Error::Syntax(ref err) => err.fmt(f),
+            Error::CompiledTooBig(limit) => write!(
+                f,
+                "Compiled regex exceeds size limit of {} bytes.",
+                limit
+            ),
+            Error::__Nonexhaustive => unreachable!(),
+        }
+    }
+}
+
+// We implement our own Debug implementation so that we show nicer syntax
+// errors when people use `Regex::new(...).unwrap()`. It's a little weird,
+// but the `Syntax` variant is already storing a `String` anyway, so we might
+// as well format it nicely.
+impl fmt::Debug for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            Error::Syntax(ref err) => {
+                let hr: String = repeat('~').take(79).collect();
+                writeln!(f, "Syntax(")?;
+                writeln!(f, "{}", hr)?;
+                writeln!(f, "{}", err)?;
+                writeln!(f, "{}", hr)?;
+                write!(f, ")")?;
+                Ok(())
+            }
+            Error::CompiledTooBig(limit) => {
+                f.debug_tuple("CompiledTooBig").field(&limit).finish()
+            }
+            Error::__Nonexhaustive => {
+                f.debug_tuple("__Nonexhaustive").finish()
+            }
+        }
+    }
+}
diff --git a/crates/regex/src/exec.rs b/crates/regex/src/exec.rs
new file mode 100644
index 0000000..b9abcdc
--- /dev/null
+++ b/crates/regex/src/exec.rs
@@ -0,0 +1,1655 @@
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::panic::AssertUnwindSafe;
+use std::sync::Arc;
+
+#[cfg(feature = "perf-literal")]
+use aho_corasick::{AhoCorasick, AhoCorasickBuilder, MatchKind};
+use regex_syntax::hir::literal::Literals;
+use regex_syntax::hir::Hir;
+use regex_syntax::ParserBuilder;
+
+use crate::backtrack;
+use crate::compile::Compiler;
+#[cfg(feature = "perf-dfa")]
+use crate::dfa;
+use crate::error::Error;
+use crate::input::{ByteInput, CharInput};
+use crate::literal::LiteralSearcher;
+use crate::pikevm;
+use crate::pool::{Pool, PoolGuard};
+use crate::prog::Program;
+use crate::re_builder::RegexOptions;
+use crate::re_bytes;
+use crate::re_set;
+use crate::re_trait::{Locations, RegularExpression, Slot};
+use crate::re_unicode;
+use crate::utf8::next_utf8;
+
+/// `Exec` manages the execution of a regular expression.
+///
+/// In particular, this manages the various compiled forms of a single regular
+/// expression and the choice of which matching engine to use to execute a
+/// regular expression.
+#[derive(Debug)]
+pub struct Exec {
+    /// All read only state.
+    ro: Arc<ExecReadOnly>,
+    /// A pool of reusable values for the various matching engines.
+    ///
+    /// Note that boxing this value is not strictly necessary, but it is an
+    /// easy way to ensure that T does not bloat the stack sized used by a pool
+    /// in the case where T is big. And this turns out to be the case at the
+    /// time of writing for regex's use of this pool. At the time of writing,
+    /// the size of a Regex on the stack is 856 bytes. Boxing this value
+    /// reduces that size to 16 bytes.
+    pool: Box<Pool<ProgramCache>>,
+}
+
+/// `ExecNoSync` is like `Exec`, except it embeds a reference to a cache. This
+/// means it is no longer Sync, but we can now avoid the overhead of
+/// synchronization to fetch the cache.
+#[derive(Debug)]
+pub struct ExecNoSync<'c> {
+    /// All read only state.
+    ro: &'c Arc<ExecReadOnly>,
+    /// Caches for the various matching engines.
+    cache: PoolGuard<'c, ProgramCache>,
+}
+
+/// `ExecNoSyncStr` is like `ExecNoSync`, but matches on &str instead of &[u8].
+#[derive(Debug)]
+pub struct ExecNoSyncStr<'c>(ExecNoSync<'c>);
+
+/// `ExecReadOnly` comprises all read only state for a regex. Namely, all such
+/// state is determined at compile time and never changes during search.
+#[derive(Debug)]
+struct ExecReadOnly {
+    /// The original regular expressions given by the caller to compile.
+    res: Vec<String>,
+    /// A compiled program that is used in the NFA simulation and backtracking.
+    /// It can be byte-based or Unicode codepoint based.
+    ///
+    /// N.B. It is not possibly to make this byte-based from the public API.
+    /// It is only used for testing byte based programs in the NFA simulations.
+    nfa: Program,
+    /// A compiled byte based program for DFA execution. This is only used
+    /// if a DFA can be executed. (Currently, only word boundary assertions are
+    /// not supported.) Note that this program contains an embedded `.*?`
+    /// preceding the first capture group, unless the regex is anchored at the
+    /// beginning.
+    dfa: Program,
+    /// The same as above, except the program is reversed (and there is no
+    /// preceding `.*?`). This is used by the DFA to find the starting location
+    /// of matches.
+    dfa_reverse: Program,
+    /// A set of suffix literals extracted from the regex.
+    ///
+    /// Prefix literals are stored on the `Program`, since they are used inside
+    /// the matching engines.
+    suffixes: LiteralSearcher,
+    /// An Aho-Corasick automaton with leftmost-first match semantics.
+    ///
+    /// This is only set when the entire regex is a simple unanchored
+    /// alternation of literals. We could probably use it more circumstances,
+    /// but this is already hacky enough in this architecture.
+    ///
+    /// N.B. We use u32 as a state ID representation under the assumption that
+    /// if we were to exhaust the ID space, we probably would have long
+    /// surpassed the compilation size limit.
+    #[cfg(feature = "perf-literal")]
+    ac: Option<AhoCorasick<u32>>,
+    /// match_type encodes as much upfront knowledge about how we're going to
+    /// execute a search as possible.
+    match_type: MatchType,
+}
+
+/// Facilitates the construction of an executor by exposing various knobs
+/// to control how a regex is executed and what kinds of resources it's
+/// permitted to use.
+// `ExecBuilder` is only public via the `internal` module, so avoid deriving
+// `Debug`.
+#[allow(missing_debug_implementations)]
+pub struct ExecBuilder {
+    options: RegexOptions,
+    match_type: Option<MatchType>,
+    bytes: bool,
+    only_utf8: bool,
+}
+
+/// Parsed represents a set of parsed regular expressions and their detected
+/// literals.
+struct Parsed {
+    exprs: Vec<Hir>,
+    prefixes: Literals,
+    suffixes: Literals,
+    bytes: bool,
+}
+
+impl ExecBuilder {
+    /// Create a regex execution builder.
+    ///
+    /// This uses default settings for everything except the regex itself,
+    /// which must be provided. Further knobs can be set by calling methods,
+    /// and then finally, `build` to actually create the executor.
+    pub fn new(re: &str) -> Self {
+        Self::new_many(&[re])
+    }
+
+    /// Like new, but compiles the union of the given regular expressions.
+    ///
+    /// Note that when compiling 2 or more regular expressions, capture groups
+    /// are completely unsupported. (This means both `find` and `captures`
+    /// won't work.)
+    pub fn new_many<I, S>(res: I) -> Self
+    where
+        S: AsRef<str>,
+        I: IntoIterator<Item = S>,
+    {
+        let mut opts = RegexOptions::default();
+        opts.pats = res.into_iter().map(|s| s.as_ref().to_owned()).collect();
+        Self::new_options(opts)
+    }
+
+    /// Create a regex execution builder.
+    pub fn new_options(opts: RegexOptions) -> Self {
+        ExecBuilder {
+            options: opts,
+            match_type: None,
+            bytes: false,
+            only_utf8: true,
+        }
+    }
+
+    /// Set the matching engine to be automatically determined.
+    ///
+    /// This is the default state and will apply whatever optimizations are
+    /// possible, such as running a DFA.
+    ///
+    /// This overrides whatever was previously set via the `nfa` or
+    /// `bounded_backtracking` methods.
+    pub fn automatic(mut self) -> Self {
+        self.match_type = None;
+        self
+    }
+
+    /// Sets the matching engine to use the NFA algorithm no matter what
+    /// optimizations are possible.
+    ///
+    /// This overrides whatever was previously set via the `automatic` or
+    /// `bounded_backtracking` methods.
+    pub fn nfa(mut self) -> Self {
+        self.match_type = Some(MatchType::Nfa(MatchNfaType::PikeVM));
+        self
+    }
+
+    /// Sets the matching engine to use a bounded backtracking engine no
+    /// matter what optimizations are possible.
+    ///
+    /// One must use this with care, since the bounded backtracking engine
+    /// uses memory proportion to `len(regex) * len(text)`.
+    ///
+    /// This overrides whatever was previously set via the `automatic` or
+    /// `nfa` methods.
+    pub fn bounded_backtracking(mut self) -> Self {
+        self.match_type = Some(MatchType::Nfa(MatchNfaType::Backtrack));
+        self
+    }
+
+    /// Compiles byte based programs for use with the NFA matching engines.
+    ///
+    /// By default, the NFA engines match on Unicode scalar values. They can
+    /// be made to use byte based programs instead. In general, the byte based
+    /// programs are slower because of a less efficient encoding of character
+    /// classes.
+    ///
+    /// Note that this does not impact DFA matching engines, which always
+    /// execute on bytes.
+    pub fn bytes(mut self, yes: bool) -> Self {
+        self.bytes = yes;
+        self
+    }
+
+    /// When disabled, the program compiled may match arbitrary bytes.
+    ///
+    /// When enabled (the default), all compiled programs exclusively match
+    /// valid UTF-8 bytes.
+    pub fn only_utf8(mut self, yes: bool) -> Self {
+        self.only_utf8 = yes;
+        self
+    }
+
+    /// Set the Unicode flag.
+    pub fn unicode(mut self, yes: bool) -> Self {
+        self.options.unicode = yes;
+        self
+    }
+
+    /// Parse the current set of patterns into their AST and extract literals.
+    fn parse(&self) -> Result<Parsed, Error> {
+        let mut exprs = Vec::with_capacity(self.options.pats.len());
+        let mut prefixes = Some(Literals::empty());
+        let mut suffixes = Some(Literals::empty());
+        let mut bytes = false;
+        let is_set = self.options.pats.len() > 1;
+        // If we're compiling a regex set and that set has any anchored
+        // expressions, then disable all literal optimizations.
+        for pat in &self.options.pats {
+            let mut parser = ParserBuilder::new()
+                .octal(self.options.octal)
+                .case_insensitive(self.options.case_insensitive)
+                .multi_line(self.options.multi_line)
+                .dot_matches_new_line(self.options.dot_matches_new_line)
+                .swap_greed(self.options.swap_greed)
+                .ignore_whitespace(self.options.ignore_whitespace)
+                .unicode(self.options.unicode)
+                .allow_invalid_utf8(!self.only_utf8)
+                .nest_limit(self.options.nest_limit)
+                .build();
+            let expr =
+                parser.parse(pat).map_err(|e| Error::Syntax(e.to_string()))?;
+            bytes = bytes || !expr.is_always_utf8();
+
+            if cfg!(feature = "perf-literal") {
+                if !expr.is_anchored_start() && expr.is_any_anchored_start() {
+                    // Partial anchors unfortunately make it hard to use
+                    // prefixes, so disable them.
+                    prefixes = None;
+                } else if is_set && expr.is_anchored_start() {
+                    // Regex sets with anchors do not go well with literal
+                    // optimizations.
+                    prefixes = None;
+                }
+                prefixes = prefixes.and_then(|mut prefixes| {
+                    if !prefixes.union_prefixes(&expr) {
+                        None
+                    } else {
+                        Some(prefixes)
+                    }
+                });
+
+                if !expr.is_anchored_end() && expr.is_any_anchored_end() {
+                    // Partial anchors unfortunately make it hard to use
+                    // suffixes, so disable them.
+                    suffixes = None;
+                } else if is_set && expr.is_anchored_end() {
+                    // Regex sets with anchors do not go well with literal
+                    // optimizations.
+                    suffixes = None;
+                }
+                suffixes = suffixes.and_then(|mut suffixes| {
+                    if !suffixes.union_suffixes(&expr) {
+                        None
+                    } else {
+                        Some(suffixes)
+                    }
+                });
+            }
+            exprs.push(expr);
+        }
+        Ok(Parsed {
+            exprs,
+            prefixes: prefixes.unwrap_or_else(Literals::empty),
+            suffixes: suffixes.unwrap_or_else(Literals::empty),
+            bytes,
+        })
+    }
+
+    /// Build an executor that can run a regular expression.
+    pub fn build(self) -> Result<Exec, Error> {
+        // Special case when we have no patterns to compile.
+        // This can happen when compiling a regex set.
+        if self.options.pats.is_empty() {
+            let ro = Arc::new(ExecReadOnly {
+                res: vec![],
+                nfa: Program::new(),
+                dfa: Program::new(),
+                dfa_reverse: Program::new(),
+                suffixes: LiteralSearcher::empty(),
+                #[cfg(feature = "perf-literal")]
+                ac: None,
+                match_type: MatchType::Nothing,
+            });
+            let pool = ExecReadOnly::new_pool(&ro);
+            return Ok(Exec { ro, pool });
+        }
+        let parsed = self.parse()?;
+        let mut nfa = Compiler::new()
+            .size_limit(self.options.size_limit)
+            .bytes(self.bytes || parsed.bytes)
+            .only_utf8(self.only_utf8)
+            .compile(&parsed.exprs)?;
+        let mut dfa = Compiler::new()
+            .size_limit(self.options.size_limit)
+            .dfa(true)
+            .only_utf8(self.only_utf8)
+            .compile(&parsed.exprs)?;
+        let mut dfa_reverse = Compiler::new()
+            .size_limit(self.options.size_limit)
+            .dfa(true)
+            .only_utf8(self.only_utf8)
+            .reverse(true)
+            .compile(&parsed.exprs)?;
+
+        #[cfg(feature = "perf-literal")]
+        let ac = self.build_aho_corasick(&parsed);
+        nfa.prefixes = LiteralSearcher::prefixes(parsed.prefixes);
+        dfa.prefixes = nfa.prefixes.clone();
+        dfa.dfa_size_limit = self.options.dfa_size_limit;
+        dfa_reverse.dfa_size_limit = self.options.dfa_size_limit;
+
+        let mut ro = ExecReadOnly {
+            res: self.options.pats,
+            nfa,
+            dfa,
+            dfa_reverse,
+            suffixes: LiteralSearcher::suffixes(parsed.suffixes),
+            #[cfg(feature = "perf-literal")]
+            ac,
+            match_type: MatchType::Nothing,
+        };
+        ro.match_type = ro.choose_match_type(self.match_type);
+
+        let ro = Arc::new(ro);
+        let pool = ExecReadOnly::new_pool(&ro);
+        Ok(Exec { ro, pool })
+    }
+
+    #[cfg(feature = "perf-literal")]
+    fn build_aho_corasick(&self, parsed: &Parsed) -> Option<AhoCorasick<u32>> {
+        if parsed.exprs.len() != 1 {
+            return None;
+        }
+        let lits = match alternation_literals(&parsed.exprs[0]) {
+            None => return None,
+            Some(lits) => lits,
+        };
+        // If we have a small number of literals, then let Teddy handle
+        // things (see literal/mod.rs).
+        if lits.len() <= 32 {
+            return None;
+        }
+        Some(
+            AhoCorasickBuilder::new()
+                .match_kind(MatchKind::LeftmostFirst)
+                .auto_configure(&lits)
+                .build_with_size::<u32, _, _>(&lits)
+                // This should never happen because we'd long exceed the
+                // compilation limit for regexes first.
+                .expect("AC automaton too big"),
+        )
+    }
+}
+
+impl<'c> RegularExpression for ExecNoSyncStr<'c> {
+    type Text = str;
+
+    fn slots_len(&self) -> usize {
+        self.0.slots_len()
+    }
+
+    fn next_after_empty(&self, text: &str, i: usize) -> usize {
+        next_utf8(text.as_bytes(), i)
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn shortest_match_at(&self, text: &str, start: usize) -> Option<usize> {
+        self.0.shortest_match_at(text.as_bytes(), start)
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn is_match_at(&self, text: &str, start: usize) -> bool {
+        self.0.is_match_at(text.as_bytes(), start)
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn find_at(&self, text: &str, start: usize) -> Option<(usize, usize)> {
+        self.0.find_at(text.as_bytes(), start)
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn captures_read_at(
+        &self,
+        locs: &mut Locations,
+        text: &str,
+        start: usize,
+    ) -> Option<(usize, usize)> {
+        self.0.captures_read_at(locs, text.as_bytes(), start)
+    }
+}
+
+impl<'c> RegularExpression for ExecNoSync<'c> {
+    type Text = [u8];
+
+    /// Returns the number of capture slots in the regular expression. (There
+    /// are two slots for every capture group, corresponding to possibly empty
+    /// start and end locations of the capture.)
+    fn slots_len(&self) -> usize {
+        self.ro.nfa.captures.len() * 2
+    }
+
+    fn next_after_empty(&self, _text: &[u8], i: usize) -> usize {
+        i + 1
+    }
+
+    /// Returns the end of a match location, possibly occurring before the
+    /// end location of the correct leftmost-first match.
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn shortest_match_at(&self, text: &[u8], start: usize) -> Option<usize> {
+        if !self.is_anchor_end_match(text) {
+            return None;
+        }
+        match self.ro.match_type {
+            #[cfg(feature = "perf-literal")]
+            MatchType::Literal(ty) => {
+                self.find_literals(ty, text, start).map(|(_, e)| e)
+            }
+            #[cfg(feature = "perf-dfa")]
+            MatchType::Dfa | MatchType::DfaMany => {
+                match self.shortest_dfa(text, start) {
+                    dfa::Result::Match(end) => Some(end),
+                    dfa::Result::NoMatch(_) => None,
+                    dfa::Result::Quit => self.shortest_nfa(text, start),
+                }
+            }
+            #[cfg(feature = "perf-dfa")]
+            MatchType::DfaAnchoredReverse => {
+                match dfa::Fsm::reverse(
+                    &self.ro.dfa_reverse,
+                    self.cache.value(),
+                    true,
+                    &text[start..],
+                    text.len() - start,
+                ) {
+                    dfa::Result::Match(_) => Some(text.len()),
+                    dfa::Result::NoMatch(_) => None,
+                    dfa::Result::Quit => self.shortest_nfa(text, start),
+                }
+            }
+            #[cfg(all(feature = "perf-dfa", feature = "perf-literal"))]
+            MatchType::DfaSuffix => {
+                match self.shortest_dfa_reverse_suffix(text, start) {
+                    dfa::Result::Match(e) => Some(e),
+                    dfa::Result::NoMatch(_) => None,
+                    dfa::Result::Quit => self.shortest_nfa(text, start),
+                }
+            }
+            MatchType::Nfa(ty) => self.shortest_nfa_type(ty, text, start),
+            MatchType::Nothing => None,
+        }
+    }
+
+    /// Returns true if and only if the regex matches text.
+    ///
+    /// For single regular expressions, this is equivalent to calling
+    /// shortest_match(...).is_some().
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn is_match_at(&self, text: &[u8], start: usize) -> bool {
+        if !self.is_anchor_end_match(text) {
+            return false;
+        }
+        // We need to do this dance because shortest_match relies on the NFA
+        // filling in captures[1], but a RegexSet has no captures. In other
+        // words, a RegexSet can't (currently) use shortest_match. ---AG
+        match self.ro.match_type {
+            #[cfg(feature = "perf-literal")]
+            MatchType::Literal(ty) => {
+                self.find_literals(ty, text, start).is_some()
+            }
+            #[cfg(feature = "perf-dfa")]
+            MatchType::Dfa | MatchType::DfaMany => {
+                match self.shortest_dfa(text, start) {
+                    dfa::Result::Match(_) => true,
+                    dfa::Result::NoMatch(_) => false,
+                    dfa::Result::Quit => self.match_nfa(text, start),
+                }
+            }
+            #[cfg(feature = "perf-dfa")]
+            MatchType::DfaAnchoredReverse => {
+                match dfa::Fsm::reverse(
+                    &self.ro.dfa_reverse,
+                    self.cache.value(),
+                    true,
+                    &text[start..],
+                    text.len() - start,
+                ) {
+                    dfa::Result::Match(_) => true,
+                    dfa::Result::NoMatch(_) => false,
+                    dfa::Result::Quit => self.match_nfa(text, start),
+                }
+            }
+            #[cfg(all(feature = "perf-dfa", feature = "perf-literal"))]
+            MatchType::DfaSuffix => {
+                match self.shortest_dfa_reverse_suffix(text, start) {
+                    dfa::Result::Match(_) => true,
+                    dfa::Result::NoMatch(_) => false,
+                    dfa::Result::Quit => self.match_nfa(text, start),
+                }
+            }
+            MatchType::Nfa(ty) => self.match_nfa_type(ty, text, start),
+            MatchType::Nothing => false,
+        }
+    }
+
+    /// Finds the start and end location of the leftmost-first match, starting
+    /// at the given location.
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn find_at(&self, text: &[u8], start: usize) -> Option<(usize, usize)> {
+        if !self.is_anchor_end_match(text) {
+            return None;
+        }
+        match self.ro.match_type {
+            #[cfg(feature = "perf-literal")]
+            MatchType::Literal(ty) => self.find_literals(ty, text, start),
+            #[cfg(feature = "perf-dfa")]
+            MatchType::Dfa => match self.find_dfa_forward(text, start) {
+                dfa::Result::Match((s, e)) => Some((s, e)),
+                dfa::Result::NoMatch(_) => None,
+                dfa::Result::Quit => {
+                    self.find_nfa(MatchNfaType::Auto, text, start)
+                }
+            },
+            #[cfg(feature = "perf-dfa")]
+            MatchType::DfaAnchoredReverse => {
+                match self.find_dfa_anchored_reverse(text, start) {
+                    dfa::Result::Match((s, e)) => Some((s, e)),
+                    dfa::Result::NoMatch(_) => None,
+                    dfa::Result::Quit => {
+                        self.find_nfa(MatchNfaType::Auto, text, start)
+                    }
+                }
+            }
+            #[cfg(all(feature = "perf-dfa", feature = "perf-literal"))]
+            MatchType::DfaSuffix => {
+                match self.find_dfa_reverse_suffix(text, start) {
+                    dfa::Result::Match((s, e)) => Some((s, e)),
+                    dfa::Result::NoMatch(_) => None,
+                    dfa::Result::Quit => {
+                        self.find_nfa(MatchNfaType::Auto, text, start)
+                    }
+                }
+            }
+            MatchType::Nfa(ty) => self.find_nfa(ty, text, start),
+            MatchType::Nothing => None,
+            #[cfg(feature = "perf-dfa")]
+            MatchType::DfaMany => {
+                unreachable!("BUG: RegexSet cannot be used with find")
+            }
+        }
+    }
+
+    /// Finds the start and end location of the leftmost-first match and also
+    /// fills in all matching capture groups.
+    ///
+    /// The number of capture slots given should be equal to the total number
+    /// of capture slots in the compiled program.
+    ///
+    /// Note that the first two slots always correspond to the start and end
+    /// locations of the overall match.
+    fn captures_read_at(
+        &self,
+        locs: &mut Locations,
+        text: &[u8],
+        start: usize,
+    ) -> Option<(usize, usize)> {
+        let slots = locs.as_slots();
+        for slot in slots.iter_mut() {
+            *slot = None;
+        }
+        // If the caller unnecessarily uses this, then we try to save them
+        // from themselves.
+        match slots.len() {
+            0 => return self.find_at(text, start),
+            2 => {
+                return self.find_at(text, start).map(|(s, e)| {
+                    slots[0] = Some(s);
+                    slots[1] = Some(e);
+                    (s, e)
+                });
+            }
+            _ => {} // fallthrough
+        }
+        if !self.is_anchor_end_match(text) {
+            return None;
+        }
+        match self.ro.match_type {
+            #[cfg(feature = "perf-literal")]
+            MatchType::Literal(ty) => {
+                self.find_literals(ty, text, start).and_then(|(s, e)| {
+                    self.captures_nfa_type(
+                        MatchNfaType::Auto,
+                        slots,
+                        text,
+                        s,
+                        e,
+                    )
+                })
+            }
+            #[cfg(feature = "perf-dfa")]
+            MatchType::Dfa => {
+                if self.ro.nfa.is_anchored_start {
+                    self.captures_nfa(slots, text, start)
+                } else {
+                    match self.find_dfa_forward(text, start) {
+                        dfa::Result::Match((s, e)) => self.captures_nfa_type(
+                            MatchNfaType::Auto,
+                            slots,
+                            text,
+                            s,
+                            e,
+                        ),
+                        dfa::Result::NoMatch(_) => None,
+                        dfa::Result::Quit => {
+                            self.captures_nfa(slots, text, start)
+                        }
+                    }
+                }
+            }
+            #[cfg(feature = "perf-dfa")]
+            MatchType::DfaAnchoredReverse => {
+                match self.find_dfa_anchored_reverse(text, start) {
+                    dfa::Result::Match((s, e)) => self.captures_nfa_type(
+                        MatchNfaType::Auto,
+                        slots,
+                        text,
+                        s,
+                        e,
+                    ),
+                    dfa::Result::NoMatch(_) => None,
+                    dfa::Result::Quit => self.captures_nfa(slots, text, start),
+                }
+            }
+            #[cfg(all(feature = "perf-dfa", feature = "perf-literal"))]
+            MatchType::DfaSuffix => {
+                match self.find_dfa_reverse_suffix(text, start) {
+                    dfa::Result::Match((s, e)) => self.captures_nfa_type(
+                        MatchNfaType::Auto,
+                        slots,
+                        text,
+                        s,
+                        e,
+                    ),
+                    dfa::Result::NoMatch(_) => None,
+                    dfa::Result::Quit => self.captures_nfa(slots, text, start),
+                }
+            }
+            MatchType::Nfa(ty) => {
+                self.captures_nfa_type(ty, slots, text, start, text.len())
+            }
+            MatchType::Nothing => None,
+            #[cfg(feature = "perf-dfa")]
+            MatchType::DfaMany => {
+                unreachable!("BUG: RegexSet cannot be used with captures")
+            }
+        }
+    }
+}
+
+impl<'c> ExecNoSync<'c> {
+    /// Finds the leftmost-first match using only literal search.
+    #[cfg(feature = "perf-literal")]
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn find_literals(
+        &self,
+        ty: MatchLiteralType,
+        text: &[u8],
+        start: usize,
+    ) -> Option<(usize, usize)> {
+        use self::MatchLiteralType::*;
+        match ty {
+            Unanchored => {
+                let lits = &self.ro.nfa.prefixes;
+                lits.find(&text[start..]).map(|(s, e)| (start + s, start + e))
+            }
+            AnchoredStart => {
+                let lits = &self.ro.nfa.prefixes;
+                if start == 0 || !self.ro.nfa.is_anchored_start {
+                    lits.find_start(&text[start..])
+                        .map(|(s, e)| (start + s, start + e))
+                } else {
+                    None
+                }
+            }
+            AnchoredEnd => {
+                let lits = &self.ro.suffixes;
+                lits.find_end(&text[start..])
+                    .map(|(s, e)| (start + s, start + e))
+            }
+            AhoCorasick => self
+                .ro
+                .ac
+                .as_ref()
+                .unwrap()
+                .find(&text[start..])
+                .map(|m| (start + m.start(), start + m.end())),
+        }
+    }
+
+    /// Finds the leftmost-first match (start and end) using only the DFA.
+    ///
+    /// If the result returned indicates that the DFA quit, then another
+    /// matching engine should be used.
+    #[cfg(feature = "perf-dfa")]
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn find_dfa_forward(
+        &self,
+        text: &[u8],
+        start: usize,
+    ) -> dfa::Result<(usize, usize)> {
+        use crate::dfa::Result::*;
+        let end = match dfa::Fsm::forward(
+            &self.ro.dfa,
+            self.cache.value(),
+            false,
+            text,
+            start,
+        ) {
+            NoMatch(i) => return NoMatch(i),
+            Quit => return Quit,
+            Match(end) if start == end => return Match((start, start)),
+            Match(end) => end,
+        };
+        // Now run the DFA in reverse to find the start of the match.
+        match dfa::Fsm::reverse(
+            &self.ro.dfa_reverse,
+            self.cache.value(),
+            false,
+            &text[start..],
+            end - start,
+        ) {
+            Match(s) => Match((start + s, end)),
+            NoMatch(i) => NoMatch(i),
+            Quit => Quit,
+        }
+    }
+
+    /// Finds the leftmost-first match (start and end) using only the DFA,
+    /// but assumes the regex is anchored at the end and therefore starts at
+    /// the end of the regex and matches in reverse.
+    ///
+    /// If the result returned indicates that the DFA quit, then another
+    /// matching engine should be used.
+    #[cfg(feature = "perf-dfa")]
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn find_dfa_anchored_reverse(
+        &self,
+        text: &[u8],
+        start: usize,
+    ) -> dfa::Result<(usize, usize)> {
+        use crate::dfa::Result::*;
+        match dfa::Fsm::reverse(
+            &self.ro.dfa_reverse,
+            self.cache.value(),
+            false,
+            &text[start..],
+            text.len() - start,
+        ) {
+            Match(s) => Match((start + s, text.len())),
+            NoMatch(i) => NoMatch(i),
+            Quit => Quit,
+        }
+    }
+
+    /// Finds the end of the shortest match using only the DFA.
+    #[cfg(feature = "perf-dfa")]
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn shortest_dfa(&self, text: &[u8], start: usize) -> dfa::Result<usize> {
+        dfa::Fsm::forward(&self.ro.dfa, self.cache.value(), true, text, start)
+    }
+
+    /// Finds the end of the shortest match using only the DFA by scanning for
+    /// suffix literals.
+    #[cfg(all(feature = "perf-dfa", feature = "perf-literal"))]
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn shortest_dfa_reverse_suffix(
+        &self,
+        text: &[u8],
+        start: usize,
+    ) -> dfa::Result<usize> {
+        match self.exec_dfa_reverse_suffix(text, start) {
+            None => self.shortest_dfa(text, start),
+            Some(r) => r.map(|(_, end)| end),
+        }
+    }
+
+    /// Finds the end of the shortest match using only the DFA by scanning for
+    /// suffix literals. It also reports the start of the match.
+    ///
+    /// Note that if None is returned, then the optimization gave up to avoid
+    /// worst case quadratic behavior. A forward scanning DFA should be tried
+    /// next.
+    ///
+    /// If a match is returned and the full leftmost-first match is desired,
+    /// then a forward scan starting from the beginning of the match must be
+    /// done.
+    ///
+    /// If the result returned indicates that the DFA quit, then another
+    /// matching engine should be used.
+    #[cfg(all(feature = "perf-dfa", feature = "perf-literal"))]
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn exec_dfa_reverse_suffix(
+        &self,
+        text: &[u8],
+        original_start: usize,
+    ) -> Option<dfa::Result<(usize, usize)>> {
+        use crate::dfa::Result::*;
+
+        let lcs = self.ro.suffixes.lcs();
+        debug_assert!(lcs.len() >= 1);
+        let mut start = original_start;
+        let mut end = start;
+        let mut last_literal = start;
+        while end <= text.len() {
+            last_literal += match lcs.find(&text[last_literal..]) {
+                None => return Some(NoMatch(text.len())),
+                Some(i) => i,
+            };
+            end = last_literal + lcs.len();
+            match dfa::Fsm::reverse(
+                &self.ro.dfa_reverse,
+                self.cache.value(),
+                false,
+                &text[start..end],
+                end - start,
+            ) {
+                Match(0) | NoMatch(0) => return None,
+                Match(i) => return Some(Match((start + i, end))),
+                NoMatch(i) => {
+                    start += i;
+                    last_literal += 1;
+                    continue;
+                }
+                Quit => return Some(Quit),
+            };
+        }
+        Some(NoMatch(text.len()))
+    }
+
+    /// Finds the leftmost-first match (start and end) using only the DFA
+    /// by scanning for suffix literals.
+    ///
+    /// If the result returned indicates that the DFA quit, then another
+    /// matching engine should be used.
+    #[cfg(all(feature = "perf-dfa", feature = "perf-literal"))]
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn find_dfa_reverse_suffix(
+        &self,
+        text: &[u8],
+        start: usize,
+    ) -> dfa::Result<(usize, usize)> {
+        use crate::dfa::Result::*;
+
+        let match_start = match self.exec_dfa_reverse_suffix(text, start) {
+            None => return self.find_dfa_forward(text, start),
+            Some(Match((start, _))) => start,
+            Some(r) => return r,
+        };
+        // At this point, we've found a match. The only way to quit now
+        // without a match is if the DFA gives up (seems unlikely).
+        //
+        // Now run the DFA forwards to find the proper end of the match.
+        // (The suffix literal match can only indicate the earliest
+        // possible end location, which may appear before the end of the
+        // leftmost-first match.)
+        match dfa::Fsm::forward(
+            &self.ro.dfa,
+            self.cache.value(),
+            false,
+            text,
+            match_start,
+        ) {
+            NoMatch(_) => panic!("BUG: reverse match implies forward match"),
+            Quit => Quit,
+            Match(e) => Match((match_start, e)),
+        }
+    }
+
+    /// Executes the NFA engine to return whether there is a match or not.
+    ///
+    /// Ideally, we could use shortest_nfa(...).is_some() and get the same
+    /// performance characteristics, but regex sets don't have captures, which
+    /// shortest_nfa depends on.
+    #[cfg(feature = "perf-dfa")]
+    fn match_nfa(&self, text: &[u8], start: usize) -> bool {
+        self.match_nfa_type(MatchNfaType::Auto, text, start)
+    }
+
+    /// Like match_nfa, but allows specification of the type of NFA engine.
+    fn match_nfa_type(
+        &self,
+        ty: MatchNfaType,
+        text: &[u8],
+        start: usize,
+    ) -> bool {
+        self.exec_nfa(
+            ty,
+            &mut [false],
+            &mut [],
+            true,
+            false,
+            text,
+            start,
+            text.len(),
+        )
+    }
+
+    /// Finds the shortest match using an NFA.
+    #[cfg(feature = "perf-dfa")]
+    fn shortest_nfa(&self, text: &[u8], start: usize) -> Option<usize> {
+        self.shortest_nfa_type(MatchNfaType::Auto, text, start)
+    }
+
+    /// Like shortest_nfa, but allows specification of the type of NFA engine.
+    fn shortest_nfa_type(
+        &self,
+        ty: MatchNfaType,
+        text: &[u8],
+        start: usize,
+    ) -> Option<usize> {
+        let mut slots = [None, None];
+        if self.exec_nfa(
+            ty,
+            &mut [false],
+            &mut slots,
+            true,
+            true,
+            text,
+            start,
+            text.len(),
+        ) {
+            slots[1]
+        } else {
+            None
+        }
+    }
+
+    /// Like find, but executes an NFA engine.
+    fn find_nfa(
+        &self,
+        ty: MatchNfaType,
+        text: &[u8],
+        start: usize,
+    ) -> Option<(usize, usize)> {
+        let mut slots = [None, None];
+        if self.exec_nfa(
+            ty,
+            &mut [false],
+            &mut slots,
+            false,
+            false,
+            text,
+            start,
+            text.len(),
+        ) {
+            match (slots[0], slots[1]) {
+                (Some(s), Some(e)) => Some((s, e)),
+                _ => None,
+            }
+        } else {
+            None
+        }
+    }
+
+    /// Like find_nfa, but fills in captures.
+    ///
+    /// `slots` should have length equal to `2 * nfa.captures.len()`.
+    #[cfg(feature = "perf-dfa")]
+    fn captures_nfa(
+        &self,
+        slots: &mut [Slot],
+        text: &[u8],
+        start: usize,
+    ) -> Option<(usize, usize)> {
+        self.captures_nfa_type(
+            MatchNfaType::Auto,
+            slots,
+            text,
+            start,
+            text.len(),
+        )
+    }
+
+    /// Like captures_nfa, but allows specification of type of NFA engine.
+    fn captures_nfa_type(
+        &self,
+        ty: MatchNfaType,
+        slots: &mut [Slot],
+        text: &[u8],
+        start: usize,
+        end: usize,
+    ) -> Option<(usize, usize)> {
+        if self.exec_nfa(
+            ty,
+            &mut [false],
+            slots,
+            false,
+            false,
+            text,
+            start,
+            end,
+        ) {
+            match (slots[0], slots[1]) {
+                (Some(s), Some(e)) => Some((s, e)),
+                _ => None,
+            }
+        } else {
+            None
+        }
+    }
+
+    fn exec_nfa(
+        &self,
+        mut ty: MatchNfaType,
+        matches: &mut [bool],
+        slots: &mut [Slot],
+        quit_after_match: bool,
+        quit_after_match_with_pos: bool,
+        text: &[u8],
+        start: usize,
+        end: usize,
+    ) -> bool {
+        use self::MatchNfaType::*;
+        if let Auto = ty {
+            if backtrack::should_exec(self.ro.nfa.len(), text.len()) {
+                ty = Backtrack;
+            } else {
+                ty = PikeVM;
+            }
+        }
+        // The backtracker can't return the shortest match position as it is
+        // implemented today. So if someone calls `shortest_match` and we need
+        // to run an NFA, then use the PikeVM.
+        if quit_after_match_with_pos || ty == PikeVM {
+            self.exec_pikevm(
+                matches,
+                slots,
+                quit_after_match,
+                text,
+                start,
+                end,
+            )
+        } else {
+            self.exec_backtrack(matches, slots, text, start, end)
+        }
+    }
+
+    /// Always run the NFA algorithm.
+    fn exec_pikevm(
+        &self,
+        matches: &mut [bool],
+        slots: &mut [Slot],
+        quit_after_match: bool,
+        text: &[u8],
+        start: usize,
+        end: usize,
+    ) -> bool {
+        if self.ro.nfa.uses_bytes() {
+            pikevm::Fsm::exec(
+                &self.ro.nfa,
+                self.cache.value(),
+                matches,
+                slots,
+                quit_after_match,
+                ByteInput::new(text, self.ro.nfa.only_utf8),
+                start,
+                end,
+            )
+        } else {
+            pikevm::Fsm::exec(
+                &self.ro.nfa,
+                self.cache.value(),
+                matches,
+                slots,
+                quit_after_match,
+                CharInput::new(text),
+                start,
+                end,
+            )
+        }
+    }
+
+    /// Always runs the NFA using bounded backtracking.
+    fn exec_backtrack(
+        &self,
+        matches: &mut [bool],
+        slots: &mut [Slot],
+        text: &[u8],
+        start: usize,
+        end: usize,
+    ) -> bool {
+        if self.ro.nfa.uses_bytes() {
+            backtrack::Bounded::exec(
+                &self.ro.nfa,
+                self.cache.value(),
+                matches,
+                slots,
+                ByteInput::new(text, self.ro.nfa.only_utf8),
+                start,
+                end,
+            )
+        } else {
+            backtrack::Bounded::exec(
+                &self.ro.nfa,
+                self.cache.value(),
+                matches,
+                slots,
+                CharInput::new(text),
+                start,
+                end,
+            )
+        }
+    }
+
+    /// Finds which regular expressions match the given text.
+    ///
+    /// `matches` should have length equal to the number of regexes being
+    /// searched.
+    ///
+    /// This is only useful when one wants to know which regexes in a set
+    /// match some text.
+    pub fn many_matches_at(
+        &self,
+        matches: &mut [bool],
+        text: &[u8],
+        start: usize,
+    ) -> bool {
+        use self::MatchType::*;
+        if !self.is_anchor_end_match(text) {
+            return false;
+        }
+        match self.ro.match_type {
+            #[cfg(feature = "perf-literal")]
+            Literal(ty) => {
+                debug_assert_eq!(matches.len(), 1);
+                matches[0] = self.find_literals(ty, text, start).is_some();
+                matches[0]
+            }
+            #[cfg(feature = "perf-dfa")]
+            Dfa | DfaAnchoredReverse | DfaMany => {
+                match dfa::Fsm::forward_many(
+                    &self.ro.dfa,
+                    self.cache.value(),
+                    matches,
+                    text,
+                    start,
+                ) {
+                    dfa::Result::Match(_) => true,
+                    dfa::Result::NoMatch(_) => false,
+                    dfa::Result::Quit => self.exec_nfa(
+                        MatchNfaType::Auto,
+                        matches,
+                        &mut [],
+                        false,
+                        false,
+                        text,
+                        start,
+                        text.len(),
+                    ),
+                }
+            }
+            #[cfg(all(feature = "perf-dfa", feature = "perf-literal"))]
+            DfaSuffix => {
+                match dfa::Fsm::forward_many(
+                    &self.ro.dfa,
+                    self.cache.value(),
+                    matches,
+                    text,
+                    start,
+                ) {
+                    dfa::Result::Match(_) => true,
+                    dfa::Result::NoMatch(_) => false,
+                    dfa::Result::Quit => self.exec_nfa(
+                        MatchNfaType::Auto,
+                        matches,
+                        &mut [],
+                        false,
+                        false,
+                        text,
+                        start,
+                        text.len(),
+                    ),
+                }
+            }
+            Nfa(ty) => self.exec_nfa(
+                ty,
+                matches,
+                &mut [],
+                false,
+                false,
+                text,
+                start,
+                text.len(),
+            ),
+            Nothing => false,
+        }
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn is_anchor_end_match(&self, text: &[u8]) -> bool {
+        #[cfg(not(feature = "perf-literal"))]
+        fn imp(_: &ExecReadOnly, _: &[u8]) -> bool {
+            true
+        }
+
+        #[cfg(feature = "perf-literal")]
+        fn imp(ro: &ExecReadOnly, text: &[u8]) -> bool {
+            // Only do this check if the haystack is big (>1MB).
+            if text.len() > (1 << 20) && ro.nfa.is_anchored_end {
+                let lcs = ro.suffixes.lcs();
+                if lcs.len() >= 1 && !lcs.is_suffix(text) {
+                    return false;
+                }
+            }
+            true
+        }
+
+        imp(&self.ro, text)
+    }
+
+    pub fn capture_name_idx(&self) -> &Arc<HashMap<String, usize>> {
+        &self.ro.nfa.capture_name_idx
+    }
+}
+
+impl<'c> ExecNoSyncStr<'c> {
+    pub fn capture_name_idx(&self) -> &Arc<HashMap<String, usize>> {
+        self.0.capture_name_idx()
+    }
+}
+
+impl Exec {
+    /// Get a searcher that isn't Sync.
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub fn searcher(&self) -> ExecNoSync<'_> {
+        ExecNoSync {
+            ro: &self.ro, // a clone is too expensive here! (and not needed)
+            cache: self.pool.get(),
+        }
+    }
+
+    /// Get a searcher that isn't Sync and can match on &str.
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub fn searcher_str(&self) -> ExecNoSyncStr<'_> {
+        ExecNoSyncStr(self.searcher())
+    }
+
+    /// Build a Regex from this executor.
+    pub fn into_regex(self) -> re_unicode::Regex {
+        re_unicode::Regex::from(self)
+    }
+
+    /// Build a RegexSet from this executor.
+    pub fn into_regex_set(self) -> re_set::unicode::RegexSet {
+        re_set::unicode::RegexSet::from(self)
+    }
+
+    /// Build a Regex from this executor that can match arbitrary bytes.
+    pub fn into_byte_regex(self) -> re_bytes::Regex {
+        re_bytes::Regex::from(self)
+    }
+
+    /// Build a RegexSet from this executor that can match arbitrary bytes.
+    pub fn into_byte_regex_set(self) -> re_set::bytes::RegexSet {
+        re_set::bytes::RegexSet::from(self)
+    }
+
+    /// The original regular expressions given by the caller that were
+    /// compiled.
+    pub fn regex_strings(&self) -> &[String] {
+        &self.ro.res
+    }
+
+    /// Return a slice of capture names.
+    ///
+    /// Any capture that isn't named is None.
+    pub fn capture_names(&self) -> &[Option<String>] {
+        &self.ro.nfa.captures
+    }
+
+    /// Return a reference to named groups mapping (from group name to
+    /// group position).
+    pub fn capture_name_idx(&self) -> &Arc<HashMap<String, usize>> {
+        &self.ro.nfa.capture_name_idx
+    }
+}
+
+impl Clone for Exec {
+    fn clone(&self) -> Exec {
+        let pool = ExecReadOnly::new_pool(&self.ro);
+        Exec { ro: self.ro.clone(), pool }
+    }
+}
+
+impl ExecReadOnly {
+    fn choose_match_type(&self, hint: Option<MatchType>) -> MatchType {
+        if let Some(MatchType::Nfa(_)) = hint {
+            return hint.unwrap();
+        }
+        // If the NFA is empty, then we'll never match anything.
+        if self.nfa.insts.is_empty() {
+            return MatchType::Nothing;
+        }
+        if let Some(literalty) = self.choose_literal_match_type() {
+            return literalty;
+        }
+        if let Some(dfaty) = self.choose_dfa_match_type() {
+            return dfaty;
+        }
+        // We're so totally hosed.
+        MatchType::Nfa(MatchNfaType::Auto)
+    }
+
+    /// If a plain literal scan can be used, then a corresponding literal
+    /// search type is returned.
+    fn choose_literal_match_type(&self) -> Option<MatchType> {
+        #[cfg(not(feature = "perf-literal"))]
+        fn imp(_: &ExecReadOnly) -> Option<MatchType> {
+            None
+        }
+
+        #[cfg(feature = "perf-literal")]
+        fn imp(ro: &ExecReadOnly) -> Option<MatchType> {
+            // If our set of prefixes is complete, then we can use it to find
+            // a match in lieu of a regex engine. This doesn't quite work well
+            // in the presence of multiple regexes, so only do it when there's
+            // one.
+            //
+            // TODO(burntsushi): Also, don't try to match literals if the regex
+            // is partially anchored. We could technically do it, but we'd need
+            // to create two sets of literals: all of them and then the subset
+            // that aren't anchored. We would then only search for all of them
+            // when at the beginning of the input and use the subset in all
+            // other cases.
+            if ro.res.len() != 1 {
+                return None;
+            }
+            if ro.ac.is_some() {
+                return Some(MatchType::Literal(
+                    MatchLiteralType::AhoCorasick,
+                ));
+            }
+            if ro.nfa.prefixes.complete() {
+                return if ro.nfa.is_anchored_start {
+                    Some(MatchType::Literal(MatchLiteralType::AnchoredStart))
+                } else {
+                    Some(MatchType::Literal(MatchLiteralType::Unanchored))
+                };
+            }
+            if ro.suffixes.complete() {
+                return if ro.nfa.is_anchored_end {
+                    Some(MatchType::Literal(MatchLiteralType::AnchoredEnd))
+                } else {
+                    // This case shouldn't happen. When the regex isn't
+                    // anchored, then complete prefixes should imply complete
+                    // suffixes.
+                    Some(MatchType::Literal(MatchLiteralType::Unanchored))
+                };
+            }
+            None
+        }
+
+        imp(self)
+    }
+
+    /// If a DFA scan can be used, then choose the appropriate DFA strategy.
+    fn choose_dfa_match_type(&self) -> Option<MatchType> {
+        #[cfg(not(feature = "perf-dfa"))]
+        fn imp(_: &ExecReadOnly) -> Option<MatchType> {
+            None
+        }
+
+        #[cfg(feature = "perf-dfa")]
+        fn imp(ro: &ExecReadOnly) -> Option<MatchType> {
+            if !dfa::can_exec(&ro.dfa) {
+                return None;
+            }
+            // Regex sets require a slightly specialized path.
+            if ro.res.len() >= 2 {
+                return Some(MatchType::DfaMany);
+            }
+            // If the regex is anchored at the end but not the start, then
+            // just match in reverse from the end of the haystack.
+            if !ro.nfa.is_anchored_start && ro.nfa.is_anchored_end {
+                return Some(MatchType::DfaAnchoredReverse);
+            }
+            #[cfg(feature = "perf-literal")]
+            {
+                // If there's a longish suffix literal, then it might be faster
+                // to look for that first.
+                if ro.should_suffix_scan() {
+                    return Some(MatchType::DfaSuffix);
+                }
+            }
+            // Fall back to your garden variety forward searching lazy DFA.
+            Some(MatchType::Dfa)
+        }
+
+        imp(self)
+    }
+
+    /// Returns true if the program is amenable to suffix scanning.
+    ///
+    /// When this is true, as a heuristic, we assume it is OK to quickly scan
+    /// for suffix literals and then do a *reverse* DFA match from any matches
+    /// produced by the literal scan. (And then followed by a forward DFA
+    /// search, since the previously found suffix literal maybe not actually be
+    /// the end of a match.)
+    ///
+    /// This is a bit of a specialized optimization, but can result in pretty
+    /// big performance wins if 1) there are no prefix literals and 2) the
+    /// suffix literals are pretty rare in the text. (1) is obviously easy to
+    /// account for but (2) is harder. As a proxy, we assume that longer
+    /// strings are generally rarer, so we only enable this optimization when
+    /// we have a meaty suffix.
+    #[cfg(all(feature = "perf-dfa", feature = "perf-literal"))]
+    fn should_suffix_scan(&self) -> bool {
+        if self.suffixes.is_empty() {
+            return false;
+        }
+        let lcs_len = self.suffixes.lcs().char_len();
+        lcs_len >= 3 && lcs_len > self.dfa.prefixes.lcp().char_len()
+    }
+
+    fn new_pool(ro: &Arc<ExecReadOnly>) -> Box<Pool<ProgramCache>> {
+        let ro = ro.clone();
+        Box::new(Pool::new(Box::new(move || {
+            AssertUnwindSafe(RefCell::new(ProgramCacheInner::new(&ro)))
+        })))
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+enum MatchType {
+    /// A single or multiple literal search. This is only used when the regex
+    /// can be decomposed into a literal search.
+    #[cfg(feature = "perf-literal")]
+    Literal(MatchLiteralType),
+    /// A normal DFA search.
+    #[cfg(feature = "perf-dfa")]
+    Dfa,
+    /// A reverse DFA search starting from the end of a haystack.
+    #[cfg(feature = "perf-dfa")]
+    DfaAnchoredReverse,
+    /// A reverse DFA search with suffix literal scanning.
+    #[cfg(all(feature = "perf-dfa", feature = "perf-literal"))]
+    DfaSuffix,
+    /// Use the DFA on two or more regular expressions.
+    #[cfg(feature = "perf-dfa")]
+    DfaMany,
+    /// An NFA variant.
+    Nfa(MatchNfaType),
+    /// No match is ever possible, so don't ever try to search.
+    Nothing,
+}
+
+#[derive(Clone, Copy, Debug)]
+#[cfg(feature = "perf-literal")]
+enum MatchLiteralType {
+    /// Match literals anywhere in text.
+    Unanchored,
+    /// Match literals only at the start of text.
+    AnchoredStart,
+    /// Match literals only at the end of text.
+    AnchoredEnd,
+    /// Use an Aho-Corasick automaton. This requires `ac` to be Some on
+    /// ExecReadOnly.
+    AhoCorasick,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum MatchNfaType {
+    /// Choose between Backtrack and PikeVM.
+    Auto,
+    /// NFA bounded backtracking.
+    ///
+    /// (This is only set by tests, since it never makes sense to always want
+    /// backtracking.)
+    Backtrack,
+    /// The Pike VM.
+    ///
+    /// (This is only set by tests, since it never makes sense to always want
+    /// the Pike VM.)
+    PikeVM,
+}
+
+/// `ProgramCache` maintains reusable allocations for each matching engine
+/// available to a particular program.
+///
+/// We declare this as unwind safe since it's a cache that's only used for
+/// performance purposes. If a panic occurs, it is (or should be) always safe
+/// to continue using the same regex object.
+pub type ProgramCache = AssertUnwindSafe<RefCell<ProgramCacheInner>>;
+
+#[derive(Debug)]
+pub struct ProgramCacheInner {
+    pub pikevm: pikevm::Cache,
+    pub backtrack: backtrack::Cache,
+    #[cfg(feature = "perf-dfa")]
+    pub dfa: dfa::Cache,
+    #[cfg(feature = "perf-dfa")]
+    pub dfa_reverse: dfa::Cache,
+}
+
+impl ProgramCacheInner {
+    fn new(ro: &ExecReadOnly) -> Self {
+        ProgramCacheInner {
+            pikevm: pikevm::Cache::new(&ro.nfa),
+            backtrack: backtrack::Cache::new(&ro.nfa),
+            #[cfg(feature = "perf-dfa")]
+            dfa: dfa::Cache::new(&ro.dfa),
+            #[cfg(feature = "perf-dfa")]
+            dfa_reverse: dfa::Cache::new(&ro.dfa_reverse),
+        }
+    }
+}
+
+/// Alternation literals checks if the given HIR is a simple alternation of
+/// literals, and if so, returns them. Otherwise, this returns None.
+#[cfg(feature = "perf-literal")]
+fn alternation_literals(expr: &Hir) -> Option<Vec<Vec<u8>>> {
+    use regex_syntax::hir::{HirKind, Literal};
+
+    // This is pretty hacky, but basically, if `is_alternation_literal` is
+    // true, then we can make several assumptions about the structure of our
+    // HIR. This is what justifies the `unreachable!` statements below.
+    //
+    // This code should be refactored once we overhaul this crate's
+    // optimization pipeline, because this is a terribly inflexible way to go
+    // about things.
+
+    if !expr.is_alternation_literal() {
+        return None;
+    }
+    let alts = match *expr.kind() {
+        HirKind::Alternation(ref alts) => alts,
+        _ => return None, // one literal isn't worth it
+    };
+
+    let extendlit = |lit: &Literal, dst: &mut Vec<u8>| match *lit {
+        Literal::Unicode(c) => {
+            let mut buf = [0; 4];
+            dst.extend_from_slice(c.encode_utf8(&mut buf).as_bytes());
+        }
+        Literal::Byte(b) => {
+            dst.push(b);
+        }
+    };
+
+    let mut lits = vec![];
+    for alt in alts {
+        let mut lit = vec![];
+        match *alt.kind() {
+            HirKind::Literal(ref x) => extendlit(x, &mut lit),
+            HirKind::Concat(ref exprs) => {
+                for e in exprs {
+                    match *e.kind() {
+                        HirKind::Literal(ref x) => extendlit(x, &mut lit),
+                        _ => unreachable!("expected literal, got {:?}", e),
+                    }
+                }
+            }
+            _ => unreachable!("expected literal or concat, got {:?}", alt),
+        }
+        lits.push(lit);
+    }
+    Some(lits)
+}
+
+#[cfg(test)]
+mod test {
+    #[test]
+    fn uppercut_s_backtracking_bytes_default_bytes_mismatch() {
+        use crate::internal::ExecBuilder;
+
+        let backtrack_bytes_re = ExecBuilder::new("^S")
+            .bounded_backtracking()
+            .only_utf8(false)
+            .build()
+            .map(|exec| exec.into_byte_regex())
+            .map_err(|err| format!("{}", err))
+            .unwrap();
+
+        let default_bytes_re = ExecBuilder::new("^S")
+            .only_utf8(false)
+            .build()
+            .map(|exec| exec.into_byte_regex())
+            .map_err(|err| format!("{}", err))
+            .unwrap();
+
+        let input = vec![83, 83];
+
+        let s1 = backtrack_bytes_re.split(&input);
+        let s2 = default_bytes_re.split(&input);
+        for (chunk1, chunk2) in s1.zip(s2) {
+            assert_eq!(chunk1, chunk2);
+        }
+    }
+
+    #[test]
+    fn unicode_lit_star_backtracking_utf8bytes_default_utf8bytes_mismatch() {
+        use crate::internal::ExecBuilder;
+
+        let backtrack_bytes_re = ExecBuilder::new(r"^(?u:\*)")
+            .bounded_backtracking()
+            .bytes(true)
+            .build()
+            .map(|exec| exec.into_regex())
+            .map_err(|err| format!("{}", err))
+            .unwrap();
+
+        let default_bytes_re = ExecBuilder::new(r"^(?u:\*)")
+            .bytes(true)
+            .build()
+            .map(|exec| exec.into_regex())
+            .map_err(|err| format!("{}", err))
+            .unwrap();
+
+        let input = "**";
+
+        let s1 = backtrack_bytes_re.split(input);
+        let s2 = default_bytes_re.split(input);
+        for (chunk1, chunk2) in s1.zip(s2) {
+            assert_eq!(chunk1, chunk2);
+        }
+    }
+}
diff --git a/crates/regex/src/expand.rs b/crates/regex/src/expand.rs
new file mode 100644
index 0000000..67b5149
--- /dev/null
+++ b/crates/regex/src/expand.rs
@@ -0,0 +1,239 @@
+use std::str;
+
+use crate::find_byte::find_byte;
+
+use crate::re_bytes;
+use crate::re_unicode;
+
+pub fn expand_str(
+    caps: &re_unicode::Captures<'_>,
+    mut replacement: &str,
+    dst: &mut String,
+) {
+    while !replacement.is_empty() {
+        match find_byte(b'$', replacement.as_bytes()) {
+            None => break,
+            Some(i) => {
+                dst.push_str(&replacement[..i]);
+                replacement = &replacement[i..];
+            }
+        }
+        if replacement.as_bytes().get(1).map_or(false, |&b| b == b'$') {
+            dst.push_str("$");
+            replacement = &replacement[2..];
+            continue;
+        }
+        debug_assert!(!replacement.is_empty());
+        let cap_ref = match find_cap_ref(replacement.as_bytes()) {
+            Some(cap_ref) => cap_ref,
+            None => {
+                dst.push_str("$");
+                replacement = &replacement[1..];
+                continue;
+            }
+        };
+        replacement = &replacement[cap_ref.end..];
+        match cap_ref.cap {
+            Ref::Number(i) => {
+                dst.push_str(caps.get(i).map(|m| m.as_str()).unwrap_or(""));
+            }
+            Ref::Named(name) => {
+                dst.push_str(
+                    caps.name(name).map(|m| m.as_str()).unwrap_or(""),
+                );
+            }
+        }
+    }
+    dst.push_str(replacement);
+}
+
+pub fn expand_bytes(
+    caps: &re_bytes::Captures<'_>,
+    mut replacement: &[u8],
+    dst: &mut Vec<u8>,
+) {
+    while !replacement.is_empty() {
+        match find_byte(b'$', replacement) {
+            None => break,
+            Some(i) => {
+                dst.extend(&replacement[..i]);
+                replacement = &replacement[i..];
+            }
+        }
+        if replacement.get(1).map_or(false, |&b| b == b'$') {
+            dst.push(b'$');
+            replacement = &replacement[2..];
+            continue;
+        }
+        debug_assert!(!replacement.is_empty());
+        let cap_ref = match find_cap_ref(replacement) {
+            Some(cap_ref) => cap_ref,
+            None => {
+                dst.push(b'$');
+                replacement = &replacement[1..];
+                continue;
+            }
+        };
+        replacement = &replacement[cap_ref.end..];
+        match cap_ref.cap {
+            Ref::Number(i) => {
+                dst.extend(caps.get(i).map(|m| m.as_bytes()).unwrap_or(b""));
+            }
+            Ref::Named(name) => {
+                dst.extend(
+                    caps.name(name).map(|m| m.as_bytes()).unwrap_or(b""),
+                );
+            }
+        }
+    }
+    dst.extend(replacement);
+}
+
+/// `CaptureRef` represents a reference to a capture group inside some text.
+/// The reference is either a capture group name or a number.
+///
+/// It is also tagged with the position in the text following the
+/// capture reference.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct CaptureRef<'a> {
+    cap: Ref<'a>,
+    end: usize,
+}
+
+/// A reference to a capture group in some text.
+///
+/// e.g., `$2`, `$foo`, `${foo}`.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum Ref<'a> {
+    Named(&'a str),
+    Number(usize),
+}
+
+impl<'a> From<&'a str> for Ref<'a> {
+    fn from(x: &'a str) -> Ref<'a> {
+        Ref::Named(x)
+    }
+}
+
+impl From<usize> for Ref<'static> {
+    fn from(x: usize) -> Ref<'static> {
+        Ref::Number(x)
+    }
+}
+
+/// Parses a possible reference to a capture group name in the given text,
+/// starting at the beginning of `replacement`.
+///
+/// If no such valid reference could be found, None is returned.
+fn find_cap_ref(replacement: &[u8]) -> Option<CaptureRef<'_>> {
+    let mut i = 0;
+    let rep: &[u8] = replacement;
+    if rep.len() <= 1 || rep[0] != b'$' {
+        return None;
+    }
+    i += 1;
+    if rep[i] == b'{' {
+        return find_cap_ref_braced(rep, i + 1);
+    }
+    let mut cap_end = i;
+    while rep.get(cap_end).copied().map_or(false, is_valid_cap_letter) {
+        cap_end += 1;
+    }
+    if cap_end == i {
+        return None;
+    }
+    // We just verified that the range 0..cap_end is valid ASCII, so it must
+    // therefore be valid UTF-8. If we really cared, we could avoid this UTF-8
+    // check via an unchecked conversion or by parsing the number straight from
+    // &[u8].
+    let cap =
+        str::from_utf8(&rep[i..cap_end]).expect("valid UTF-8 capture name");
+    Some(CaptureRef {
+        cap: match cap.parse::<u32>() {
+            Ok(i) => Ref::Number(i as usize),
+            Err(_) => Ref::Named(cap),
+        },
+        end: cap_end,
+    })
+}
+
+fn find_cap_ref_braced(rep: &[u8], mut i: usize) -> Option<CaptureRef<'_>> {
+    let start = i;
+    while rep.get(i).map_or(false, |&b| b != b'}') {
+        i += 1;
+    }
+    if !rep.get(i).map_or(false, |&b| b == b'}') {
+        return None;
+    }
+    // When looking at braced names, we don't put any restrictions on the name,
+    // so it's possible it could be invalid UTF-8. But a capture group name
+    // can never be invalid UTF-8, so if we have invalid UTF-8, then we can
+    // safely return None.
+    let cap = match str::from_utf8(&rep[start..i]) {
+        Err(_) => return None,
+        Ok(cap) => cap,
+    };
+    Some(CaptureRef {
+        cap: match cap.parse::<u32>() {
+            Ok(i) => Ref::Number(i as usize),
+            Err(_) => Ref::Named(cap),
+        },
+        end: i + 1,
+    })
+}
+
+/// Returns true if and only if the given byte is allowed in a capture name.
+fn is_valid_cap_letter(b: u8) -> bool {
+    match b {
+        b'0'..=b'9' | b'a'..=b'z' | b'A'..=b'Z' | b'_' => true,
+        _ => false,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{find_cap_ref, CaptureRef};
+
+    macro_rules! find {
+        ($name:ident, $text:expr) => {
+            #[test]
+            fn $name() {
+                assert_eq!(None, find_cap_ref($text.as_bytes()));
+            }
+        };
+        ($name:ident, $text:expr, $capref:expr) => {
+            #[test]
+            fn $name() {
+                assert_eq!(Some($capref), find_cap_ref($text.as_bytes()));
+            }
+        };
+    }
+
+    macro_rules! c {
+        ($name_or_number:expr, $pos:expr) => {
+            CaptureRef { cap: $name_or_number.into(), end: $pos }
+        };
+    }
+
+    find!(find_cap_ref1, "$foo", c!("foo", 4));
+    find!(find_cap_ref2, "${foo}", c!("foo", 6));
+    find!(find_cap_ref3, "$0", c!(0, 2));
+    find!(find_cap_ref4, "$5", c!(5, 2));
+    find!(find_cap_ref5, "$10", c!(10, 3));
+    // See https://github.com/rust-lang/regex/pull/585
+    // for more on characters following numbers
+    find!(find_cap_ref6, "$42a", c!("42a", 4));
+    find!(find_cap_ref7, "${42}a", c!(42, 5));
+    find!(find_cap_ref8, "${42");
+    find!(find_cap_ref9, "${42 ");
+    find!(find_cap_ref10, " $0 ");
+    find!(find_cap_ref11, "$");
+    find!(find_cap_ref12, " ");
+    find!(find_cap_ref13, "");
+    find!(find_cap_ref14, "$1-$2", c!(1, 2));
+    find!(find_cap_ref15, "$1_$2", c!("1_", 3));
+    find!(find_cap_ref16, "$x-$y", c!("x", 2));
+    find!(find_cap_ref17, "$x_$y", c!("x_", 3));
+    find!(find_cap_ref18, "${#}", c!("#", 4));
+    find!(find_cap_ref19, "${Z[}", c!("Z[", 5));
+}
diff --git a/crates/regex/src/find_byte.rs b/crates/regex/src/find_byte.rs
new file mode 100644
index 0000000..e95f72a
--- /dev/null
+++ b/crates/regex/src/find_byte.rs
@@ -0,0 +1,18 @@
+/// Searches for the given needle in the given haystack.
+///
+/// If the perf-literal feature is enabled, then this uses the super optimized
+/// memchr crate. Otherwise, it uses the naive byte-at-a-time implementation.
+pub fn find_byte(needle: u8, haystack: &[u8]) -> Option<usize> {
+    #[cfg(not(feature = "perf-literal"))]
+    fn imp(needle: u8, haystack: &[u8]) -> Option<usize> {
+        haystack.iter().position(|&b| b == needle)
+    }
+
+    #[cfg(feature = "perf-literal")]
+    fn imp(needle: u8, haystack: &[u8]) -> Option<usize> {
+        use memchr::memchr;
+        memchr(needle, haystack)
+    }
+
+    imp(needle, haystack)
+}
diff --git a/crates/regex/src/freqs.rs b/crates/regex/src/freqs.rs
new file mode 100644
index 0000000..fcffa95
--- /dev/null
+++ b/crates/regex/src/freqs.rs
@@ -0,0 +1,261 @@
+// NOTE: The following code was generated by "scripts/frequencies.py", do not
+// edit directly
+
+pub const BYTE_FREQUENCIES: [u8; 256] = [
+    55,  // '\x00'
+    52,  // '\x01'
+    51,  // '\x02'
+    50,  // '\x03'
+    49,  // '\x04'
+    48,  // '\x05'
+    47,  // '\x06'
+    46,  // '\x07'
+    45,  // '\x08'
+    103, // '\t'
+    242, // '\n'
+    66,  // '\x0b'
+    67,  // '\x0c'
+    229, // '\r'
+    44,  // '\x0e'
+    43,  // '\x0f'
+    42,  // '\x10'
+    41,  // '\x11'
+    40,  // '\x12'
+    39,  // '\x13'
+    38,  // '\x14'
+    37,  // '\x15'
+    36,  // '\x16'
+    35,  // '\x17'
+    34,  // '\x18'
+    33,  // '\x19'
+    56,  // '\x1a'
+    32,  // '\x1b'
+    31,  // '\x1c'
+    30,  // '\x1d'
+    29,  // '\x1e'
+    28,  // '\x1f'
+    255, // ' '
+    148, // '!'
+    164, // '"'
+    149, // '#'
+    136, // '$'
+    160, // '%'
+    155, // '&'
+    173, // "'"
+    221, // '('
+    222, // ')'
+    134, // '*'
+    122, // '+'
+    232, // ','
+    202, // '-'
+    215, // '.'
+    224, // '/'
+    208, // '0'
+    220, // '1'
+    204, // '2'
+    187, // '3'
+    183, // '4'
+    179, // '5'
+    177, // '6'
+    168, // '7'
+    178, // '8'
+    200, // '9'
+    226, // ':'
+    195, // ';'
+    154, // '<'
+    184, // '='
+    174, // '>'
+    126, // '?'
+    120, // '@'
+    191, // 'A'
+    157, // 'B'
+    194, // 'C'
+    170, // 'D'
+    189, // 'E'
+    162, // 'F'
+    161, // 'G'
+    150, // 'H'
+    193, // 'I'
+    142, // 'J'
+    137, // 'K'
+    171, // 'L'
+    176, // 'M'
+    185, // 'N'
+    167, // 'O'
+    186, // 'P'
+    112, // 'Q'
+    175, // 'R'
+    192, // 'S'
+    188, // 'T'
+    156, // 'U'
+    140, // 'V'
+    143, // 'W'
+    123, // 'X'
+    133, // 'Y'
+    128, // 'Z'
+    147, // '['
+    138, // '\\'
+    146, // ']'
+    114, // '^'
+    223, // '_'
+    151, // '`'
+    249, // 'a'
+    216, // 'b'
+    238, // 'c'
+    236, // 'd'
+    253, // 'e'
+    227, // 'f'
+    218, // 'g'
+    230, // 'h'
+    247, // 'i'
+    135, // 'j'
+    180, // 'k'
+    241, // 'l'
+    233, // 'm'
+    246, // 'n'
+    244, // 'o'
+    231, // 'p'
+    139, // 'q'
+    245, // 'r'
+    243, // 's'
+    251, // 't'
+    235, // 'u'
+    201, // 'v'
+    196, // 'w'
+    240, // 'x'
+    214, // 'y'
+    152, // 'z'
+    182, // '{'
+    205, // '|'
+    181, // '}'
+    127, // '~'
+    27,  // '\x7f'
+    212, // '\x80'
+    211, // '\x81'
+    210, // '\x82'
+    213, // '\x83'
+    228, // '\x84'
+    197, // '\x85'
+    169, // '\x86'
+    159, // '\x87'
+    131, // '\x88'
+    172, // '\x89'
+    105, // '\x8a'
+    80,  // '\x8b'
+    98,  // '\x8c'
+    96,  // '\x8d'
+    97,  // '\x8e'
+    81,  // '\x8f'
+    207, // '\x90'
+    145, // '\x91'
+    116, // '\x92'
+    115, // '\x93'
+    144, // '\x94'
+    130, // '\x95'
+    153, // '\x96'
+    121, // '\x97'
+    107, // '\x98'
+    132, // '\x99'
+    109, // '\x9a'
+    110, // '\x9b'
+    124, // '\x9c'
+    111, // '\x9d'
+    82,  // '\x9e'
+    108, // '\x9f'
+    118, // '\xa0'
+    141, // '¡'
+    113, // '¢'
+    129, // '£'
+    119, // '¤'
+    125, // '¥'
+    165, // '¦'
+    117, // '§'
+    92,  // '¨'
+    106, // '©'
+    83,  // 'ª'
+    72,  // '«'
+    99,  // '¬'
+    93,  // '\xad'
+    65,  // '®'
+    79,  // '¯'
+    166, // '°'
+    237, // '±'
+    163, // '²'
+    199, // '³'
+    190, // '´'
+    225, // 'µ'
+    209, // '¶'
+    203, // '·'
+    198, // '¸'
+    217, // '¹'
+    219, // 'º'
+    206, // '»'
+    234, // '¼'
+    248, // '½'
+    158, // '¾'
+    239, // '¿'
+    255, // 'À'
+    255, // 'Á'
+    255, // 'Â'
+    255, // 'Ã'
+    255, // 'Ä'
+    255, // 'Å'
+    255, // 'Æ'
+    255, // 'Ç'
+    255, // 'È'
+    255, // 'É'
+    255, // 'Ê'
+    255, // 'Ë'
+    255, // 'Ì'
+    255, // 'Í'
+    255, // 'Î'
+    255, // 'Ï'
+    255, // 'Ð'
+    255, // 'Ñ'
+    255, // 'Ò'
+    255, // 'Ó'
+    255, // 'Ô'
+    255, // 'Õ'
+    255, // 'Ö'
+    255, // '×'
+    255, // 'Ø'
+    255, // 'Ù'
+    255, // 'Ú'
+    255, // 'Û'
+    255, // 'Ü'
+    255, // 'Ý'
+    255, // 'Þ'
+    255, // 'ß'
+    255, // 'à'
+    255, // 'á'
+    255, // 'â'
+    255, // 'ã'
+    255, // 'ä'
+    255, // 'å'
+    255, // 'æ'
+    255, // 'ç'
+    255, // 'è'
+    255, // 'é'
+    255, // 'ê'
+    255, // 'ë'
+    255, // 'ì'
+    255, // 'í'
+    255, // 'î'
+    255, // 'ï'
+    255, // 'ð'
+    255, // 'ñ'
+    255, // 'ò'
+    255, // 'ó'
+    255, // 'ô'
+    255, // 'õ'
+    255, // 'ö'
+    255, // '÷'
+    255, // 'ø'
+    255, // 'ù'
+    255, // 'ú'
+    255, // 'û'
+    255, // 'ü'
+    255, // 'ý'
+    255, // 'þ'
+    255, // 'ÿ'
+];
diff --git a/crates/regex/src/input.rs b/crates/regex/src/input.rs
new file mode 100644
index 0000000..df6c3e0
--- /dev/null
+++ b/crates/regex/src/input.rs
@@ -0,0 +1,432 @@
+use std::char;
+use std::cmp::Ordering;
+use std::fmt;
+use std::ops;
+use std::u32;
+
+use crate::literal::LiteralSearcher;
+use crate::prog::InstEmptyLook;
+use crate::utf8::{decode_last_utf8, decode_utf8};
+
+/// Represents a location in the input.
+#[derive(Clone, Copy, Debug)]
+pub struct InputAt {
+    pos: usize,
+    c: Char,
+    byte: Option<u8>,
+    len: usize,
+}
+
+impl InputAt {
+    /// Returns true iff this position is at the beginning of the input.
+    pub fn is_start(&self) -> bool {
+        self.pos == 0
+    }
+
+    /// Returns true iff this position is past the end of the input.
+    pub fn is_end(&self) -> bool {
+        self.c.is_none() && self.byte.is_none()
+    }
+
+    /// Returns the character at this position.
+    ///
+    /// If this position is just before or after the input, then an absent
+    /// character is returned.
+    pub fn char(&self) -> Char {
+        self.c
+    }
+
+    /// Returns the byte at this position.
+    pub fn byte(&self) -> Option<u8> {
+        self.byte
+    }
+
+    /// Returns the UTF-8 width of the character at this position.
+    pub fn len(&self) -> usize {
+        self.len
+    }
+
+    /// Returns whether the UTF-8 width of the character at this position
+    /// is zero.
+    pub fn is_empty(&self) -> bool {
+        self.len == 0
+    }
+
+    /// Returns the byte offset of this position.
+    pub fn pos(&self) -> usize {
+        self.pos
+    }
+
+    /// Returns the byte offset of the next position in the input.
+    pub fn next_pos(&self) -> usize {
+        self.pos + self.len
+    }
+}
+
+/// An abstraction over input used in the matching engines.
+pub trait Input: fmt::Debug {
+    /// Return an encoding of the position at byte offset `i`.
+    fn at(&self, i: usize) -> InputAt;
+
+    /// Return the Unicode character occurring next to `at`.
+    ///
+    /// If no such character could be decoded, then `Char` is absent.
+    fn next_char(&self, at: InputAt) -> Char;
+
+    /// Return the Unicode character occurring previous to `at`.
+    ///
+    /// If no such character could be decoded, then `Char` is absent.
+    fn previous_char(&self, at: InputAt) -> Char;
+
+    /// Return true if the given empty width instruction matches at the
+    /// input position given.
+    fn is_empty_match(&self, at: InputAt, empty: &InstEmptyLook) -> bool;
+
+    /// Scan the input for a matching prefix.
+    fn prefix_at(
+        &self,
+        prefixes: &LiteralSearcher,
+        at: InputAt,
+    ) -> Option<InputAt>;
+
+    /// The number of bytes in the input.
+    fn len(&self) -> usize;
+
+    /// Whether the input is empty.
+    fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Return the given input as a sequence of bytes.
+    fn as_bytes(&self) -> &[u8];
+}
+
+impl<'a, T: Input> Input for &'a T {
+    fn at(&self, i: usize) -> InputAt {
+        (**self).at(i)
+    }
+
+    fn next_char(&self, at: InputAt) -> Char {
+        (**self).next_char(at)
+    }
+
+    fn previous_char(&self, at: InputAt) -> Char {
+        (**self).previous_char(at)
+    }
+
+    fn is_empty_match(&self, at: InputAt, empty: &InstEmptyLook) -> bool {
+        (**self).is_empty_match(at, empty)
+    }
+
+    fn prefix_at(
+        &self,
+        prefixes: &LiteralSearcher,
+        at: InputAt,
+    ) -> Option<InputAt> {
+        (**self).prefix_at(prefixes, at)
+    }
+
+    fn len(&self) -> usize {
+        (**self).len()
+    }
+
+    fn as_bytes(&self) -> &[u8] {
+        (**self).as_bytes()
+    }
+}
+
+/// An input reader over characters.
+#[derive(Clone, Copy, Debug)]
+pub struct CharInput<'t>(&'t [u8]);
+
+impl<'t> CharInput<'t> {
+    /// Return a new character input reader for the given string.
+    pub fn new(s: &'t [u8]) -> CharInput<'t> {
+        CharInput(s)
+    }
+}
+
+impl<'t> ops::Deref for CharInput<'t> {
+    type Target = [u8];
+
+    fn deref(&self) -> &[u8] {
+        self.0
+    }
+}
+
+impl<'t> Input for CharInput<'t> {
+    fn at(&self, i: usize) -> InputAt {
+        if i >= self.len() {
+            InputAt { pos: self.len(), c: None.into(), byte: None, len: 0 }
+        } else {
+            let c = decode_utf8(&self[i..]).map(|(c, _)| c).into();
+            InputAt { pos: i, c, byte: None, len: c.len_utf8() }
+        }
+    }
+
+    fn next_char(&self, at: InputAt) -> Char {
+        at.char()
+    }
+
+    fn previous_char(&self, at: InputAt) -> Char {
+        decode_last_utf8(&self[..at.pos()]).map(|(c, _)| c).into()
+    }
+
+    fn is_empty_match(&self, at: InputAt, empty: &InstEmptyLook) -> bool {
+        use crate::prog::EmptyLook::*;
+        match empty.look {
+            StartLine => {
+                let c = self.previous_char(at);
+                at.pos() == 0 || c == '\n'
+            }
+            EndLine => {
+                let c = self.next_char(at);
+                at.pos() == self.len() || c == '\n'
+            }
+            StartText => at.pos() == 0,
+            EndText => at.pos() == self.len(),
+            WordBoundary => {
+                let (c1, c2) = (self.previous_char(at), self.next_char(at));
+                c1.is_word_char() != c2.is_word_char()
+            }
+            NotWordBoundary => {
+                let (c1, c2) = (self.previous_char(at), self.next_char(at));
+                c1.is_word_char() == c2.is_word_char()
+            }
+            WordBoundaryAscii => {
+                let (c1, c2) = (self.previous_char(at), self.next_char(at));
+                c1.is_word_byte() != c2.is_word_byte()
+            }
+            NotWordBoundaryAscii => {
+                let (c1, c2) = (self.previous_char(at), self.next_char(at));
+                c1.is_word_byte() == c2.is_word_byte()
+            }
+        }
+    }
+
+    fn prefix_at(
+        &self,
+        prefixes: &LiteralSearcher,
+        at: InputAt,
+    ) -> Option<InputAt> {
+        prefixes.find(&self[at.pos()..]).map(|(s, _)| self.at(at.pos() + s))
+    }
+
+    fn len(&self) -> usize {
+        self.0.len()
+    }
+
+    fn as_bytes(&self) -> &[u8] {
+        self.0
+    }
+}
+
+/// An input reader over bytes.
+#[derive(Clone, Copy, Debug)]
+pub struct ByteInput<'t> {
+    text: &'t [u8],
+    only_utf8: bool,
+}
+
+impl<'t> ByteInput<'t> {
+    /// Return a new byte-based input reader for the given string.
+    pub fn new(text: &'t [u8], only_utf8: bool) -> ByteInput<'t> {
+        ByteInput { text, only_utf8 }
+    }
+}
+
+impl<'t> ops::Deref for ByteInput<'t> {
+    type Target = [u8];
+
+    fn deref(&self) -> &[u8] {
+        self.text
+    }
+}
+
+impl<'t> Input for ByteInput<'t> {
+    fn at(&self, i: usize) -> InputAt {
+        if i >= self.len() {
+            InputAt { pos: self.len(), c: None.into(), byte: None, len: 0 }
+        } else {
+            InputAt {
+                pos: i,
+                c: None.into(),
+                byte: self.get(i).cloned(),
+                len: 1,
+            }
+        }
+    }
+
+    fn next_char(&self, at: InputAt) -> Char {
+        decode_utf8(&self[at.pos()..]).map(|(c, _)| c).into()
+    }
+
+    fn previous_char(&self, at: InputAt) -> Char {
+        decode_last_utf8(&self[..at.pos()]).map(|(c, _)| c).into()
+    }
+
+    fn is_empty_match(&self, at: InputAt, empty: &InstEmptyLook) -> bool {
+        use crate::prog::EmptyLook::*;
+        match empty.look {
+            StartLine => {
+                let c = self.previous_char(at);
+                at.pos() == 0 || c == '\n'
+            }
+            EndLine => {
+                let c = self.next_char(at);
+                at.pos() == self.len() || c == '\n'
+            }
+            StartText => at.pos() == 0,
+            EndText => at.pos() == self.len(),
+            WordBoundary => {
+                let (c1, c2) = (self.previous_char(at), self.next_char(at));
+                c1.is_word_char() != c2.is_word_char()
+            }
+            NotWordBoundary => {
+                let (c1, c2) = (self.previous_char(at), self.next_char(at));
+                c1.is_word_char() == c2.is_word_char()
+            }
+            WordBoundaryAscii => {
+                let (c1, c2) = (self.previous_char(at), self.next_char(at));
+                if self.only_utf8 {
+                    // If we must match UTF-8, then we can't match word
+                    // boundaries at invalid UTF-8.
+                    if c1.is_none() && !at.is_start() {
+                        return false;
+                    }
+                    if c2.is_none() && !at.is_end() {
+                        return false;
+                    }
+                }
+                c1.is_word_byte() != c2.is_word_byte()
+            }
+            NotWordBoundaryAscii => {
+                let (c1, c2) = (self.previous_char(at), self.next_char(at));
+                if self.only_utf8 {
+                    // If we must match UTF-8, then we can't match word
+                    // boundaries at invalid UTF-8.
+                    if c1.is_none() && !at.is_start() {
+                        return false;
+                    }
+                    if c2.is_none() && !at.is_end() {
+                        return false;
+                    }
+                }
+                c1.is_word_byte() == c2.is_word_byte()
+            }
+        }
+    }
+
+    fn prefix_at(
+        &self,
+        prefixes: &LiteralSearcher,
+        at: InputAt,
+    ) -> Option<InputAt> {
+        prefixes.find(&self[at.pos()..]).map(|(s, _)| self.at(at.pos() + s))
+    }
+
+    fn len(&self) -> usize {
+        self.text.len()
+    }
+
+    fn as_bytes(&self) -> &[u8] {
+        self.text
+    }
+}
+
+/// An inline representation of `Option<char>`.
+///
+/// This eliminates the need to do case analysis on `Option<char>` to determine
+/// ordinality with other characters.
+///
+/// (The `Option<char>` is not related to encoding. Instead, it is used in the
+/// matching engines to represent the beginning and ending boundaries of the
+/// search text.)
+#[derive(Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Char(u32);
+
+impl fmt::Debug for Char {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match char::from_u32(self.0) {
+            None => write!(f, "Empty"),
+            Some(c) => write!(f, "{:?}", c),
+        }
+    }
+}
+
+impl Char {
+    /// Returns true iff the character is absent.
+    #[inline]
+    pub fn is_none(self) -> bool {
+        self.0 == u32::MAX
+    }
+
+    /// Returns the length of the character's UTF-8 encoding.
+    ///
+    /// If the character is absent, then `1` is returned.
+    #[inline]
+    pub fn len_utf8(self) -> usize {
+        char::from_u32(self.0).map_or(1, |c| c.len_utf8())
+    }
+
+    /// Returns true iff the character is a word character.
+    ///
+    /// If the character is absent, then false is returned.
+    pub fn is_word_char(self) -> bool {
+        // is_word_character can panic if the Unicode data for \w isn't
+        // available. However, our compiler ensures that if a Unicode word
+        // boundary is used, then the data must also be available. If it isn't,
+        // then the compiler returns an error.
+        char::from_u32(self.0).map_or(false, regex_syntax::is_word_character)
+    }
+
+    /// Returns true iff the byte is a word byte.
+    ///
+    /// If the byte is absent, then false is returned.
+    pub fn is_word_byte(self) -> bool {
+        match char::from_u32(self.0) {
+            Some(c) if c <= '\u{7F}' => regex_syntax::is_word_byte(c as u8),
+            None | Some(_) => false,
+        }
+    }
+}
+
+impl From<char> for Char {
+    fn from(c: char) -> Char {
+        Char(c as u32)
+    }
+}
+
+impl From<Option<char>> for Char {
+    fn from(c: Option<char>) -> Char {
+        c.map_or(Char(u32::MAX), |c| c.into())
+    }
+}
+
+impl PartialEq<char> for Char {
+    #[inline]
+    fn eq(&self, other: &char) -> bool {
+        self.0 == *other as u32
+    }
+}
+
+impl PartialEq<Char> for char {
+    #[inline]
+    fn eq(&self, other: &Char) -> bool {
+        *self as u32 == other.0
+    }
+}
+
+impl PartialOrd<char> for Char {
+    #[inline]
+    fn partial_cmp(&self, other: &char) -> Option<Ordering> {
+        self.0.partial_cmp(&(*other as u32))
+    }
+}
+
+impl PartialOrd<Char> for char {
+    #[inline]
+    fn partial_cmp(&self, other: &Char) -> Option<Ordering> {
+        (*self as u32).partial_cmp(&other.0)
+    }
+}
diff --git a/crates/regex/src/lib.rs b/crates/regex/src/lib.rs
new file mode 100644
index 0000000..6b95739
--- /dev/null
+++ b/crates/regex/src/lib.rs
@@ -0,0 +1,769 @@
+/*!
+This crate provides a library for parsing, compiling, and executing regular
+expressions. Its syntax is similar to Perl-style regular expressions, but lacks
+a few features like look around and backreferences. In exchange, all searches
+execute in linear time with respect to the size of the regular expression and
+search text.
+
+This crate's documentation provides some simple examples, describes
+[Unicode support](#unicode) and exhaustively lists the
+[supported syntax](#syntax).
+
+For more specific details on the API for regular expressions, please see the
+documentation for the [`Regex`](struct.Regex.html) type.
+
+# Usage
+
+This crate is [on crates.io](https://crates.io/crates/regex) and can be
+used by adding `regex` to your dependencies in your project's `Cargo.toml`.
+
+```toml
+[dependencies]
+regex = "1"
+```
+
+# Example: find a date
+
+General use of regular expressions in this package involves compiling an
+expression and then using it to search, split or replace text. For example,
+to confirm that some text resembles a date:
+
+```rust
+use regex::Regex;
+let re = Regex::new(r"^\d{4}-\d{2}-\d{2}$").unwrap();
+assert!(re.is_match("2014-01-01"));
+```
+
+Notice the use of the `^` and `$` anchors. In this crate, every expression
+is executed with an implicit `.*?` at the beginning and end, which allows
+it to match anywhere in the text. Anchors can be used to ensure that the
+full text matches an expression.
+
+This example also demonstrates the utility of
+[raw strings](https://doc.rust-lang.org/stable/reference/tokens.html#raw-string-literals)
+in Rust, which
+are just like regular strings except they are prefixed with an `r` and do
+not process any escape sequences. For example, `"\\d"` is the same
+expression as `r"\d"`.
+
+# Example: Avoid compiling the same regex in a loop
+
+It is an anti-pattern to compile the same regular expression in a loop
+since compilation is typically expensive. (It takes anywhere from a few
+microseconds to a few **milliseconds** depending on the size of the
+regex.) Not only is compilation itself expensive, but this also prevents
+optimizations that reuse allocations internally to the matching engines.
+
+In Rust, it can sometimes be a pain to pass regular expressions around if
+they're used from inside a helper function. Instead, we recommend using the
+[`lazy_static`](https://crates.io/crates/lazy_static) crate to ensure that
+regular expressions are compiled exactly once.
+
+For example:
+
+```rust
+use lazy_static::lazy_static;
+use regex::Regex;
+
+fn some_helper_function(text: &str) -> bool {
+    lazy_static! {
+        static ref RE: Regex = Regex::new("...").unwrap();
+    }
+    RE.is_match(text)
+}
+
+fn main() {}
+```
+
+Specifically, in this example, the regex will be compiled when it is used for
+the first time. On subsequent uses, it will reuse the previous compilation.
+
+# Example: iterating over capture groups
+
+This crate provides convenient iterators for matching an expression
+repeatedly against a search string to find successive non-overlapping
+matches. For example, to find all dates in a string and be able to access
+them by their component pieces:
+
+```rust
+# use regex::Regex;
+# fn main() {
+let re = Regex::new(r"(\d{4})-(\d{2})-(\d{2})").unwrap();
+let text = "2012-03-14, 2013-01-01 and 2014-07-05";
+for cap in re.captures_iter(text) {
+    println!("Month: {} Day: {} Year: {}", &cap[2], &cap[3], &cap[1]);
+}
+// Output:
+// Month: 03 Day: 14 Year: 2012
+// Month: 01 Day: 01 Year: 2013
+// Month: 07 Day: 05 Year: 2014
+# }
+```
+
+Notice that the year is in the capture group indexed at `1`. This is
+because the *entire match* is stored in the capture group at index `0`.
+
+# Example: replacement with named capture groups
+
+Building on the previous example, perhaps we'd like to rearrange the date
+formats. This can be done with text replacement. But to make the code
+clearer, we can *name*  our capture groups and use those names as variables
+in our replacement text:
+
+```rust
+# use regex::Regex;
+# fn main() {
+let re = Regex::new(r"(?P<y>\d{4})-(?P<m>\d{2})-(?P<d>\d{2})").unwrap();
+let before = "2012-03-14, 2013-01-01 and 2014-07-05";
+let after = re.replace_all(before, "$m/$d/$y");
+assert_eq!(after, "03/14/2012, 01/01/2013 and 07/05/2014");
+# }
+```
+
+The `replace` methods are actually polymorphic in the replacement, which
+provides more flexibility than is seen here. (See the documentation for
+`Regex::replace` for more details.)
+
+Note that if your regex gets complicated, you can use the `x` flag to
+enable insignificant whitespace mode, which also lets you write comments:
+
+```rust
+# use regex::Regex;
+# fn main() {
+let re = Regex::new(r"(?x)
+  (?P<y>\d{4}) # the year
+  -
+  (?P<m>\d{2}) # the month
+  -
+  (?P<d>\d{2}) # the day
+").unwrap();
+let before = "2012-03-14, 2013-01-01 and 2014-07-05";
+let after = re.replace_all(before, "$m/$d/$y");
+assert_eq!(after, "03/14/2012, 01/01/2013 and 07/05/2014");
+# }
+```
+
+If you wish to match against whitespace in this mode, you can still use `\s`,
+`\n`, `\t`, etc. For escaping a single space character, you can escape it
+directly with `\ `, use its hex character code `\x20` or temporarily disable
+the `x` flag, e.g., `(?-x: )`.
+
+# Example: match multiple regular expressions simultaneously
+
+This demonstrates how to use a `RegexSet` to match multiple (possibly
+overlapping) regular expressions in a single scan of the search text:
+
+```rust
+use regex::RegexSet;
+
+let set = RegexSet::new(&[
+    r"\w+",
+    r"\d+",
+    r"\pL+",
+    r"foo",
+    r"bar",
+    r"barfoo",
+    r"foobar",
+]).unwrap();
+
+// Iterate over and collect all of the matches.
+let matches: Vec<_> = set.matches("foobar").into_iter().collect();
+assert_eq!(matches, vec![0, 2, 3, 4, 6]);
+
+// You can also test whether a particular regex matched:
+let matches = set.matches("foobar");
+assert!(!matches.matched(5));
+assert!(matches.matched(6));
+```
+
+# Pay for what you use
+
+With respect to searching text with a regular expression, there are three
+questions that can be asked:
+
+1. Does the text match this expression?
+2. If so, where does it match?
+3. Where did the capturing groups match?
+
+Generally speaking, this crate could provide a function to answer only #3,
+which would subsume #1 and #2 automatically. However, it can be significantly
+more expensive to compute the location of capturing group matches, so it's best
+not to do it if you don't need to.
+
+Therefore, only use what you need. For example, don't use `find` if you
+only need to test if an expression matches a string. (Use `is_match`
+instead.)
+
+# Unicode
+
+This implementation executes regular expressions **only** on valid UTF-8
+while exposing match locations as byte indices into the search string. (To
+relax this restriction, use the [`bytes`](bytes/index.html) sub-module.)
+
+Only simple case folding is supported. Namely, when matching
+case-insensitively, the characters are first mapped using the "simple" case
+folding rules defined by Unicode.
+
+Regular expressions themselves are **only** interpreted as a sequence of
+Unicode scalar values. This means you can use Unicode characters directly
+in your expression:
+
+```rust
+# use regex::Regex;
+# fn main() {
+let re = Regex::new(r"(?i)Δ+").unwrap();
+let mat = re.find("ΔδΔ").unwrap();
+assert_eq!((mat.start(), mat.end()), (0, 6));
+# }
+```
+
+Most features of the regular expressions in this crate are Unicode aware. Here
+are some examples:
+
+* `.` will match any valid UTF-8 encoded Unicode scalar value except for `\n`.
+  (To also match `\n`, enable the `s` flag, e.g., `(?s:.)`.)
+* `\w`, `\d` and `\s` are Unicode aware. For example, `\s` will match all forms
+  of whitespace categorized by Unicode.
+* `\b` matches a Unicode word boundary.
+* Negated character classes like `[^a]` match all Unicode scalar values except
+  for `a`.
+* `^` and `$` are **not** Unicode aware in multi-line mode. Namely, they only
+  recognize `\n` and not any of the other forms of line terminators defined
+  by Unicode.
+
+Unicode general categories, scripts, script extensions, ages and a smattering
+of boolean properties are available as character classes. For example, you can
+match a sequence of numerals, Greek or Cherokee letters:
+
+```rust
+# use regex::Regex;
+# fn main() {
+let re = Regex::new(r"[\pN\p{Greek}\p{Cherokee}]+").unwrap();
+let mat = re.find("abcΔᎠβⅠᏴγδⅡxyz").unwrap();
+assert_eq!((mat.start(), mat.end()), (3, 23));
+# }
+```
+
+For a more detailed breakdown of Unicode support with respect to
+[UTS#18](https://unicode.org/reports/tr18/),
+please see the
+[UNICODE](https://github.com/rust-lang/regex/blob/master/UNICODE.md)
+document in the root of the regex repository.
+
+# Opt out of Unicode support
+
+The `bytes` sub-module provides a `Regex` type that can be used to match
+on `&[u8]`. By default, text is interpreted as UTF-8 just like it is with
+the main `Regex` type. However, this behavior can be disabled by turning
+off the `u` flag, even if doing so could result in matching invalid UTF-8.
+For example, when the `u` flag is disabled, `.` will match any byte instead
+of any Unicode scalar value.
+
+Disabling the `u` flag is also possible with the standard `&str`-based `Regex`
+type, but it is only allowed where the UTF-8 invariant is maintained. For
+example, `(?-u:\w)` is an ASCII-only `\w` character class and is legal in an
+`&str`-based `Regex`, but `(?-u:\xFF)` will attempt to match the raw byte
+`\xFF`, which is invalid UTF-8 and therefore is illegal in `&str`-based
+regexes.
+
+Finally, since Unicode support requires bundling large Unicode data
+tables, this crate exposes knobs to disable the compilation of those
+data tables, which can be useful for shrinking binary size and reducing
+compilation times. For details on how to do that, see the section on [crate
+features](#crate-features).
+
+# Syntax
+
+The syntax supported in this crate is documented below.
+
+Note that the regular expression parser and abstract syntax are exposed in
+a separate crate, [`regex-syntax`](https://docs.rs/regex-syntax).
+
+## Matching one character
+
+<pre class="rust">
+.             any character except new line (includes new line with s flag)
+\d            digit (\p{Nd})
+\D            not digit
+\pN           One-letter name Unicode character class
+\p{Greek}     Unicode character class (general category or script)
+\PN           Negated one-letter name Unicode character class
+\P{Greek}     negated Unicode character class (general category or script)
+</pre>
+
+### Character classes
+
+<pre class="rust">
+[xyz]         A character class matching either x, y or z (union).
+[^xyz]        A character class matching any character except x, y and z.
+[a-z]         A character class matching any character in range a-z.
+[[:alpha:]]   ASCII character class ([A-Za-z])
+[[:^alpha:]]  Negated ASCII character class ([^A-Za-z])
+[x[^xyz]]     Nested/grouping character class (matching any character except y and z)
+[a-y&&xyz]    Intersection (matching x or y)
+[0-9&&[^4]]   Subtraction using intersection and negation (matching 0-9 except 4)
+[0-9--4]      Direct subtraction (matching 0-9 except 4)
+[a-g~~b-h]    Symmetric difference (matching `a` and `h` only)
+[\[\]]        Escaping in character classes (matching [ or ])
+</pre>
+
+Any named character class may appear inside a bracketed `[...]` character
+class. For example, `[\p{Greek}[:digit:]]` matches any Greek or ASCII
+digit. `[\p{Greek}&&\pL]` matches Greek letters.
+
+Precedence in character classes, from most binding to least:
+
+1. Ranges: `a-cd` == `[a-c]d`
+2. Union: `ab&&bc` == `[ab]&&[bc]`
+3. Intersection: `^a-z&&b` == `^[a-z&&b]`
+4. Negation
+
+## Composites
+
+<pre class="rust">
+xy    concatenation (x followed by y)
+x|y   alternation (x or y, prefer x)
+</pre>
+
+## Repetitions
+
+<pre class="rust">
+x*        zero or more of x (greedy)
+x+        one or more of x (greedy)
+x?        zero or one of x (greedy)
+x*?       zero or more of x (ungreedy/lazy)
+x+?       one or more of x (ungreedy/lazy)
+x??       zero or one of x (ungreedy/lazy)
+x{n,m}    at least n x and at most m x (greedy)
+x{n,}     at least n x (greedy)
+x{n}      exactly n x
+x{n,m}?   at least n x and at most m x (ungreedy/lazy)
+x{n,}?    at least n x (ungreedy/lazy)
+x{n}?     exactly n x
+</pre>
+
+## Empty matches
+
+<pre class="rust">
+^     the beginning of text (or start-of-line with multi-line mode)
+$     the end of text (or end-of-line with multi-line mode)
+\A    only the beginning of text (even with multi-line mode enabled)
+\z    only the end of text (even with multi-line mode enabled)
+\b    a Unicode word boundary (\w on one side and \W, \A, or \z on other)
+\B    not a Unicode word boundary
+</pre>
+
+The empty regex is valid and matches the empty string. For example, the empty
+regex matches `abc` at positions `0`, `1`, `2` and `3`.
+
+## Grouping and flags
+
+<pre class="rust">
+(exp)          numbered capture group (indexed by opening parenthesis)
+(?P&lt;name&gt;exp)  named (also numbered) capture group (allowed chars: [_0-9a-zA-Z.\[\]])
+(?:exp)        non-capturing group
+(?flags)       set flags within current group
+(?flags:exp)   set flags for exp (non-capturing)
+</pre>
+
+Flags are each a single character. For example, `(?x)` sets the flag `x`
+and `(?-x)` clears the flag `x`. Multiple flags can be set or cleared at
+the same time: `(?xy)` sets both the `x` and `y` flags and `(?x-y)` sets
+the `x` flag and clears the `y` flag.
+
+All flags are by default disabled unless stated otherwise. They are:
+
+<pre class="rust">
+i     case-insensitive: letters match both upper and lower case
+m     multi-line mode: ^ and $ match begin/end of line
+s     allow . to match \n
+U     swap the meaning of x* and x*?
+u     Unicode support (enabled by default)
+x     ignore whitespace and allow line comments (starting with `#`)
+</pre>
+
+Flags can be toggled within a pattern. Here's an example that matches
+case-insensitively for the first part but case-sensitively for the second part:
+
+```rust
+# use regex::Regex;
+# fn main() {
+let re = Regex::new(r"(?i)a+(?-i)b+").unwrap();
+let cap = re.captures("AaAaAbbBBBb").unwrap();
+assert_eq!(&cap[0], "AaAaAbb");
+# }
+```
+
+Notice that the `a+` matches either `a` or `A`, but the `b+` only matches
+`b`.
+
+Multi-line mode means `^` and `$` no longer match just at the beginning/end of
+the input, but at the beginning/end of lines:
+
+```
+# use regex::Regex;
+let re = Regex::new(r"(?m)^line \d+").unwrap();
+let m = re.find("line one\nline 2\n").unwrap();
+assert_eq!(m.as_str(), "line 2");
+```
+
+Note that `^` matches after new lines, even at the end of input:
+
+```
+# use regex::Regex;
+let re = Regex::new(r"(?m)^").unwrap();
+let m = re.find_iter("test\n").last().unwrap();
+assert_eq!((m.start(), m.end()), (5, 5));
+```
+
+Here is an example that uses an ASCII word boundary instead of a Unicode
+word boundary:
+
+```rust
+# use regex::Regex;
+# fn main() {
+let re = Regex::new(r"(?-u:\b).+(?-u:\b)").unwrap();
+let cap = re.captures("$$abc$$").unwrap();
+assert_eq!(&cap[0], "abc");
+# }
+```
+
+## Escape sequences
+
+<pre class="rust">
+\*          literal *, works for any punctuation character: \.+*?()|[]{}^$
+\a          bell (\x07)
+\f          form feed (\x0C)
+\t          horizontal tab
+\n          new line
+\r          carriage return
+\v          vertical tab (\x0B)
+\123        octal character code (up to three digits) (when enabled)
+\x7F        hex character code (exactly two digits)
+\x{10FFFF}  any hex character code corresponding to a Unicode code point
+\u007F      hex character code (exactly four digits)
+\u{7F}      any hex character code corresponding to a Unicode code point
+\U0000007F  hex character code (exactly eight digits)
+\U{7F}      any hex character code corresponding to a Unicode code point
+</pre>
+
+## Perl character classes (Unicode friendly)
+
+These classes are based on the definitions provided in
+[UTS#18](https://www.unicode.org/reports/tr18/#Compatibility_Properties):
+
+<pre class="rust">
+\d     digit (\p{Nd})
+\D     not digit
+\s     whitespace (\p{White_Space})
+\S     not whitespace
+\w     word character (\p{Alphabetic} + \p{M} + \d + \p{Pc} + \p{Join_Control})
+\W     not word character
+</pre>
+
+## ASCII character classes
+
+<pre class="rust">
+[[:alnum:]]    alphanumeric ([0-9A-Za-z])
+[[:alpha:]]    alphabetic ([A-Za-z])
+[[:ascii:]]    ASCII ([\x00-\x7F])
+[[:blank:]]    blank ([\t ])
+[[:cntrl:]]    control ([\x00-\x1F\x7F])
+[[:digit:]]    digits ([0-9])
+[[:graph:]]    graphical ([!-~])
+[[:lower:]]    lower case ([a-z])
+[[:print:]]    printable ([ -~])
+[[:punct:]]    punctuation ([!-/:-@\[-`{-~])
+[[:space:]]    whitespace ([\t\n\v\f\r ])
+[[:upper:]]    upper case ([A-Z])
+[[:word:]]     word characters ([0-9A-Za-z_])
+[[:xdigit:]]   hex digit ([0-9A-Fa-f])
+</pre>
+
+# Crate features
+
+By default, this crate tries pretty hard to make regex matching both as fast
+as possible and as correct as it can be, within reason. This means that there
+is a lot of code dedicated to performance, the handling of Unicode data and the
+Unicode data itself. Overall, this leads to more dependencies, larger binaries
+and longer compile times.  This trade off may not be appropriate in all cases,
+and indeed, even when all Unicode and performance features are disabled, one
+is still left with a perfectly serviceable regex engine that will work well
+in many cases.
+
+This crate exposes a number of features for controlling that trade off. Some
+of these features are strictly performance oriented, such that disabling them
+won't result in a loss of functionality, but may result in worse performance.
+Other features, such as the ones controlling the presence or absence of Unicode
+data, can result in a loss of functionality. For example, if one disables the
+`unicode-case` feature (described below), then compiling the regex `(?i)a`
+will fail since Unicode case insensitivity is enabled by default. Instead,
+callers must use `(?i-u)a` instead to disable Unicode case folding. Stated
+differently, enabling or disabling any of the features below can only add or
+subtract from the total set of valid regular expressions. Enabling or disabling
+a feature will never modify the match semantics of a regular expression.
+
+All features below are enabled by default.
+
+### Ecosystem features
+
+* **std** -
+  When enabled, this will cause `regex` to use the standard library. Currently,
+  disabling this feature will always result in a compilation error. It is
+  intended to add `alloc`-only support to regex in the future.
+
+### Performance features
+
+* **perf** -
+  Enables all performance related features. This feature is enabled by default
+  and will always cover all features that improve performance, even if more
+  are added in the future.
+* **perf-dfa** -
+  Enables the use of a lazy DFA for matching. The lazy DFA is used to compile
+  portions of a regex to a very fast DFA on an as-needed basis. This can
+  result in substantial speedups, usually by an order of magnitude on large
+  haystacks. The lazy DFA does not bring in any new dependencies, but it can
+  make compile times longer.
+* **perf-inline** -
+  Enables the use of aggressive inlining inside match routines. This reduces
+  the overhead of each match. The aggressive inlining, however, increases
+  compile times and binary size.
+* **perf-literal** -
+  Enables the use of literal optimizations for speeding up matches. In some
+  cases, literal optimizations can result in speedups of _several_ orders of
+  magnitude. Disabling this drops the `aho-corasick` and `memchr` dependencies.
+* **perf-cache** -
+  This feature used to enable a faster internal cache at the cost of using
+  additional dependencies, but this is no longer an option. A fast internal
+  cache is now used unconditionally with no additional dependencies. This may
+  change in the future.
+
+### Unicode features
+
+* **unicode** -
+  Enables all Unicode features. This feature is enabled by default, and will
+  always cover all Unicode features, even if more are added in the future.
+* **unicode-age** -
+  Provide the data for the
+  [Unicode `Age` property](https://www.unicode.org/reports/tr44/tr44-24.html#Character_Age).
+  This makes it possible to use classes like `\p{Age:6.0}` to refer to all
+  codepoints first introduced in Unicode 6.0
+* **unicode-bool** -
+  Provide the data for numerous Unicode boolean properties. The full list
+  is not included here, but contains properties like `Alphabetic`, `Emoji`,
+  `Lowercase`, `Math`, `Uppercase` and `White_Space`.
+* **unicode-case** -
+  Provide the data for case insensitive matching using
+  [Unicode's "simple loose matches" specification](https://www.unicode.org/reports/tr18/#Simple_Loose_Matches).
+* **unicode-gencat** -
+  Provide the data for
+  [Unicode general categories](https://www.unicode.org/reports/tr44/tr44-24.html#General_Category_Values).
+  This includes, but is not limited to, `Decimal_Number`, `Letter`,
+  `Math_Symbol`, `Number` and `Punctuation`.
+* **unicode-perl** -
+  Provide the data for supporting the Unicode-aware Perl character classes,
+  corresponding to `\w`, `\s` and `\d`. This is also necessary for using
+  Unicode-aware word boundary assertions. Note that if this feature is
+  disabled, the `\s` and `\d` character classes are still available if the
+  `unicode-bool` and `unicode-gencat` features are enabled, respectively.
+* **unicode-script** -
+  Provide the data for
+  [Unicode scripts and script extensions](https://www.unicode.org/reports/tr24/).
+  This includes, but is not limited to, `Arabic`, `Cyrillic`, `Hebrew`,
+  `Latin` and `Thai`.
+* **unicode-segment** -
+  Provide the data necessary to provide the properties used to implement the
+  [Unicode text segmentation algorithms](https://www.unicode.org/reports/tr29/).
+  This enables using classes like `\p{gcb=Extend}`, `\p{wb=Katakana}` and
+  `\p{sb=ATerm}`.
+
+
+# Untrusted input
+
+This crate can handle both untrusted regular expressions and untrusted
+search text.
+
+Untrusted regular expressions are handled by capping the size of a compiled
+regular expression.
+(See [`RegexBuilder::size_limit`](struct.RegexBuilder.html#method.size_limit).)
+Without this, it would be trivial for an attacker to exhaust your system's
+memory with expressions like `a{100}{100}{100}`.
+
+Untrusted search text is allowed because the matching engine(s) in this
+crate have time complexity `O(mn)` (with `m ~ regex` and `n ~ search
+text`), which means there's no way to cause exponential blow-up like with
+some other regular expression engines. (We pay for this by disallowing
+features like arbitrary look-ahead and backreferences.)
+
+When a DFA is used, pathological cases with exponential state blow-up are
+avoided by constructing the DFA lazily or in an "online" manner. Therefore,
+at most one new state can be created for each byte of input. This satisfies
+our time complexity guarantees, but can lead to memory growth
+proportional to the size of the input. As a stopgap, the DFA is only
+allowed to store a fixed number of states. When the limit is reached, its
+states are wiped and continues on, possibly duplicating previous work. If
+the limit is reached too frequently, it gives up and hands control off to
+another matching engine with fixed memory requirements.
+(The DFA size limit can also be tweaked. See
+[`RegexBuilder::dfa_size_limit`](struct.RegexBuilder.html#method.dfa_size_limit).)
+*/
+
+#![deny(missing_docs)]
+#![cfg_attr(feature = "pattern", feature(pattern))]
+#![warn(missing_debug_implementations)]
+
+#[cfg(not(feature = "std"))]
+compile_error!("`std` feature is currently required to build this crate");
+
+// To check README's example
+// TODO: Re-enable this once the MSRV is 1.43 or greater.
+// See: https://github.com/rust-lang/regex/issues/684
+// See: https://github.com/rust-lang/regex/issues/685
+// #[cfg(doctest)]
+// doc_comment::doctest!("../README.md");
+
+#[cfg(feature = "std")]
+pub use crate::error::Error;
+#[cfg(feature = "std")]
+pub use crate::re_builder::set_unicode::*;
+#[cfg(feature = "std")]
+pub use crate::re_builder::unicode::*;
+#[cfg(feature = "std")]
+pub use crate::re_set::unicode::*;
+#[cfg(feature = "std")]
+pub use crate::re_unicode::{
+    escape, CaptureLocations, CaptureMatches, CaptureNames, Captures,
+    Locations, Match, Matches, NoExpand, Regex, Replacer, ReplacerRef, Split,
+    SplitN, SubCaptureMatches,
+};
+
+/**
+Match regular expressions on arbitrary bytes.
+
+This module provides a nearly identical API to the one found in the
+top-level of this crate. There are two important differences:
+
+1. Matching is done on `&[u8]` instead of `&str`. Additionally, `Vec<u8>`
+is used where `String` would have been used.
+2. Unicode support can be disabled even when disabling it would result in
+matching invalid UTF-8 bytes.
+
+# Example: match null terminated string
+
+This shows how to find all null-terminated strings in a slice of bytes:
+
+```rust
+# use regex::bytes::Regex;
+let re = Regex::new(r"(?-u)(?P<cstr>[^\x00]+)\x00").unwrap();
+let text = b"foo\x00bar\x00baz\x00";
+
+// Extract all of the strings without the null terminator from each match.
+// The unwrap is OK here since a match requires the `cstr` capture to match.
+let cstrs: Vec<&[u8]> =
+    re.captures_iter(text)
+      .map(|c| c.name("cstr").unwrap().as_bytes())
+      .collect();
+assert_eq!(vec![&b"foo"[..], &b"bar"[..], &b"baz"[..]], cstrs);
+```
+
+# Example: selectively enable Unicode support
+
+This shows how to match an arbitrary byte pattern followed by a UTF-8 encoded
+string (e.g., to extract a title from a Matroska file):
+
+```rust
+# use std::str;
+# use regex::bytes::Regex;
+let re = Regex::new(
+    r"(?-u)\x7b\xa9(?:[\x80-\xfe]|[\x40-\xff].)(?u:(.*))"
+).unwrap();
+let text = b"\x12\xd0\x3b\x5f\x7b\xa9\x85\xe2\x98\x83\x80\x98\x54\x76\x68\x65";
+let caps = re.captures(text).unwrap();
+
+// Notice that despite the `.*` at the end, it will only match valid UTF-8
+// because Unicode mode was enabled with the `u` flag. Without the `u` flag,
+// the `.*` would match the rest of the bytes.
+let mat = caps.get(1).unwrap();
+assert_eq!((7, 10), (mat.start(), mat.end()));
+
+// If there was a match, Unicode mode guarantees that `title` is valid UTF-8.
+let title = str::from_utf8(&caps[1]).unwrap();
+assert_eq!("☃", title);
+```
+
+In general, if the Unicode flag is enabled in a capture group and that capture
+is part of the overall match, then the capture is *guaranteed* to be valid
+UTF-8.
+
+# Syntax
+
+The supported syntax is pretty much the same as the syntax for Unicode
+regular expressions with a few changes that make sense for matching arbitrary
+bytes:
+
+1. The `u` flag can be disabled even when disabling it might cause the regex to
+match invalid UTF-8. When the `u` flag is disabled, the regex is said to be in
+"ASCII compatible" mode.
+2. In ASCII compatible mode, neither Unicode scalar values nor Unicode
+character classes are allowed.
+3. In ASCII compatible mode, Perl character classes (`\w`, `\d` and `\s`)
+revert to their typical ASCII definition. `\w` maps to `[[:word:]]`, `\d` maps
+to `[[:digit:]]` and `\s` maps to `[[:space:]]`.
+4. In ASCII compatible mode, word boundaries use the ASCII compatible `\w` to
+determine whether a byte is a word byte or not.
+5. Hexadecimal notation can be used to specify arbitrary bytes instead of
+Unicode codepoints. For example, in ASCII compatible mode, `\xFF` matches the
+literal byte `\xFF`, while in Unicode mode, `\xFF` is a Unicode codepoint that
+matches its UTF-8 encoding of `\xC3\xBF`. Similarly for octal notation when
+enabled.
+6. In ASCII compatible mode, `.` matches any *byte* except for `\n`. When the
+`s` flag is additionally enabled, `.` matches any byte.
+
+# Performance
+
+In general, one should expect performance on `&[u8]` to be roughly similar to
+performance on `&str`.
+*/
+#[cfg(feature = "std")]
+pub mod bytes {
+    pub use crate::re_builder::bytes::*;
+    pub use crate::re_builder::set_bytes::*;
+    pub use crate::re_bytes::*;
+    pub use crate::re_set::bytes::*;
+}
+
+mod backtrack;
+mod compile;
+#[cfg(feature = "perf-dfa")]
+mod dfa;
+mod error;
+mod exec;
+mod expand;
+mod find_byte;
+mod input;
+mod literal;
+#[cfg(feature = "pattern")]
+mod pattern;
+mod pikevm;
+mod pool;
+mod prog;
+mod re_builder;
+mod re_bytes;
+mod re_set;
+mod re_trait;
+mod re_unicode;
+mod sparse;
+mod utf8;
+
+/// The `internal` module exists to support suspicious activity, such as
+/// testing different matching engines and supporting the `regex-debug` CLI
+/// utility.
+#[doc(hidden)]
+#[cfg(feature = "std")]
+pub mod internal {
+    pub use crate::compile::Compiler;
+    pub use crate::exec::{Exec, ExecBuilder};
+    pub use crate::input::{Char, CharInput, Input, InputAt};
+    pub use crate::literal::LiteralSearcher;
+    pub use crate::prog::{EmptyLook, Inst, InstRanges, Program};
+}
diff --git a/crates/regex/src/literal/imp.rs b/crates/regex/src/literal/imp.rs
new file mode 100644
index 0000000..90b2f11
--- /dev/null
+++ b/crates/regex/src/literal/imp.rs
@@ -0,0 +1,402 @@
+use std::mem;
+
+use aho_corasick::{self, packed, AhoCorasick, AhoCorasickBuilder};
+use memchr::{memchr, memchr2, memchr3, memmem};
+use regex_syntax::hir::literal::{Literal, Literals};
+
+/// A prefix extracted from a compiled regular expression.
+///
+/// A regex prefix is a set of literal strings that *must* be matched at the
+/// beginning of a regex in order for the entire regex to match. Similarly
+/// for a regex suffix.
+#[derive(Clone, Debug)]
+pub struct LiteralSearcher {
+    complete: bool,
+    lcp: Memmem,
+    lcs: Memmem,
+    matcher: Matcher,
+}
+
+#[derive(Clone, Debug)]
+enum Matcher {
+    /// No literals. (Never advances through the input.)
+    Empty,
+    /// A set of four or more single byte literals.
+    Bytes(SingleByteSet),
+    /// A single substring, using vector accelerated routines when available.
+    Memmem(Memmem),
+    /// An Aho-Corasick automaton.
+    AC { ac: AhoCorasick<u32>, lits: Vec<Literal> },
+    /// A packed multiple substring searcher, using SIMD.
+    ///
+    /// Note that Aho-Corasick will actually use this packed searcher
+    /// internally automatically, however, there is some overhead associated
+    /// with going through the Aho-Corasick machinery. So using the packed
+    /// searcher directly results in some gains.
+    Packed { s: packed::Searcher, lits: Vec<Literal> },
+}
+
+impl LiteralSearcher {
+    /// Returns a matcher that never matches and never advances the input.
+    pub fn empty() -> Self {
+        Self::new(Literals::empty(), Matcher::Empty)
+    }
+
+    /// Returns a matcher for literal prefixes from the given set.
+    pub fn prefixes(lits: Literals) -> Self {
+        let matcher = Matcher::prefixes(&lits);
+        Self::new(lits, matcher)
+    }
+
+    /// Returns a matcher for literal suffixes from the given set.
+    pub fn suffixes(lits: Literals) -> Self {
+        let matcher = Matcher::suffixes(&lits);
+        Self::new(lits, matcher)
+    }
+
+    fn new(lits: Literals, matcher: Matcher) -> Self {
+        let complete = lits.all_complete();
+        LiteralSearcher {
+            complete,
+            lcp: Memmem::new(lits.longest_common_prefix()),
+            lcs: Memmem::new(lits.longest_common_suffix()),
+            matcher,
+        }
+    }
+
+    /// Returns true if all matches comprise the entire regular expression.
+    ///
+    /// This does not necessarily mean that a literal match implies a match
+    /// of the regular expression. For example, the regular expression `^a`
+    /// is comprised of a single complete literal `a`, but the regular
+    /// expression demands that it only match at the beginning of a string.
+    pub fn complete(&self) -> bool {
+        self.complete && !self.is_empty()
+    }
+
+    /// Find the position of a literal in `haystack` if it exists.
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub fn find(&self, haystack: &[u8]) -> Option<(usize, usize)> {
+        use self::Matcher::*;
+        match self.matcher {
+            Empty => Some((0, 0)),
+            Bytes(ref sset) => sset.find(haystack).map(|i| (i, i + 1)),
+            Memmem(ref s) => s.find(haystack).map(|i| (i, i + s.len())),
+            AC { ref ac, .. } => {
+                ac.find(haystack).map(|m| (m.start(), m.end()))
+            }
+            Packed { ref s, .. } => {
+                s.find(haystack).map(|m| (m.start(), m.end()))
+            }
+        }
+    }
+
+    /// Like find, except matches must start at index `0`.
+    pub fn find_start(&self, haystack: &[u8]) -> Option<(usize, usize)> {
+        for lit in self.iter() {
+            if lit.len() > haystack.len() {
+                continue;
+            }
+            if lit == &haystack[0..lit.len()] {
+                return Some((0, lit.len()));
+            }
+        }
+        None
+    }
+
+    /// Like find, except matches must end at index `haystack.len()`.
+    pub fn find_end(&self, haystack: &[u8]) -> Option<(usize, usize)> {
+        for lit in self.iter() {
+            if lit.len() > haystack.len() {
+                continue;
+            }
+            if lit == &haystack[haystack.len() - lit.len()..] {
+                return Some((haystack.len() - lit.len(), haystack.len()));
+            }
+        }
+        None
+    }
+
+    /// Returns an iterator over all literals to be matched.
+    pub fn iter(&self) -> LiteralIter<'_> {
+        match self.matcher {
+            Matcher::Empty => LiteralIter::Empty,
+            Matcher::Bytes(ref sset) => LiteralIter::Bytes(&sset.dense),
+            Matcher::Memmem(ref s) => LiteralIter::Single(&s.finder.needle()),
+            Matcher::AC { ref lits, .. } => LiteralIter::AC(lits),
+            Matcher::Packed { ref lits, .. } => LiteralIter::Packed(lits),
+        }
+    }
+
+    /// Returns a matcher for the longest common prefix of this matcher.
+    pub fn lcp(&self) -> &Memmem {
+        &self.lcp
+    }
+
+    /// Returns a matcher for the longest common suffix of this matcher.
+    pub fn lcs(&self) -> &Memmem {
+        &self.lcs
+    }
+
+    /// Returns true iff this prefix is empty.
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Returns the number of prefixes in this machine.
+    pub fn len(&self) -> usize {
+        use self::Matcher::*;
+        match self.matcher {
+            Empty => 0,
+            Bytes(ref sset) => sset.dense.len(),
+            Memmem(_) => 1,
+            AC { ref ac, .. } => ac.pattern_count(),
+            Packed { ref lits, .. } => lits.len(),
+        }
+    }
+
+    /// Return the approximate heap usage of literals in bytes.
+    pub fn approximate_size(&self) -> usize {
+        use self::Matcher::*;
+        match self.matcher {
+            Empty => 0,
+            Bytes(ref sset) => sset.approximate_size(),
+            Memmem(ref single) => single.approximate_size(),
+            AC { ref ac, .. } => ac.heap_bytes(),
+            Packed { ref s, .. } => s.heap_bytes(),
+        }
+    }
+}
+
+impl Matcher {
+    fn prefixes(lits: &Literals) -> Self {
+        let sset = SingleByteSet::prefixes(lits);
+        Matcher::new(lits, sset)
+    }
+
+    fn suffixes(lits: &Literals) -> Self {
+        let sset = SingleByteSet::suffixes(lits);
+        Matcher::new(lits, sset)
+    }
+
+    fn new(lits: &Literals, sset: SingleByteSet) -> Self {
+        if lits.literals().is_empty() {
+            return Matcher::Empty;
+        }
+        if sset.dense.len() >= 26 {
+            // Avoid trying to match a large number of single bytes.
+            // This is *very* sensitive to a frequency analysis comparison
+            // between the bytes in sset and the composition of the haystack.
+            // No matter the size of sset, if its members all are rare in the
+            // haystack, then it'd be worth using it. How to tune this... IDK.
+            // ---AG
+            return Matcher::Empty;
+        }
+        if sset.complete {
+            return Matcher::Bytes(sset);
+        }
+        if lits.literals().len() == 1 {
+            return Matcher::Memmem(Memmem::new(&lits.literals()[0]));
+        }
+
+        let pats = lits.literals().to_owned();
+        let is_aho_corasick_fast = sset.dense.len() <= 1 && sset.all_ascii;
+        if lits.literals().len() <= 100 && !is_aho_corasick_fast {
+            let mut builder = packed::Config::new()
+                .match_kind(packed::MatchKind::LeftmostFirst)
+                .builder();
+            if let Some(s) = builder.extend(&pats).build() {
+                return Matcher::Packed { s, lits: pats };
+            }
+        }
+        let ac = AhoCorasickBuilder::new()
+            .match_kind(aho_corasick::MatchKind::LeftmostFirst)
+            .dfa(true)
+            .build_with_size::<u32, _, _>(&pats)
+            .unwrap();
+        Matcher::AC { ac, lits: pats }
+    }
+}
+
+#[derive(Debug)]
+pub enum LiteralIter<'a> {
+    Empty,
+    Bytes(&'a [u8]),
+    Single(&'a [u8]),
+    AC(&'a [Literal]),
+    Packed(&'a [Literal]),
+}
+
+impl<'a> Iterator for LiteralIter<'a> {
+    type Item = &'a [u8];
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match *self {
+            LiteralIter::Empty => None,
+            LiteralIter::Bytes(ref mut many) => {
+                if many.is_empty() {
+                    None
+                } else {
+                    let next = &many[0..1];
+                    *many = &many[1..];
+                    Some(next)
+                }
+            }
+            LiteralIter::Single(ref mut one) => {
+                if one.is_empty() {
+                    None
+                } else {
+                    let next = &one[..];
+                    *one = &[];
+                    Some(next)
+                }
+            }
+            LiteralIter::AC(ref mut lits) => {
+                if lits.is_empty() {
+                    None
+                } else {
+                    let next = &lits[0];
+                    *lits = &lits[1..];
+                    Some(&**next)
+                }
+            }
+            LiteralIter::Packed(ref mut lits) => {
+                if lits.is_empty() {
+                    None
+                } else {
+                    let next = &lits[0];
+                    *lits = &lits[1..];
+                    Some(&**next)
+                }
+            }
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+struct SingleByteSet {
+    sparse: Vec<bool>,
+    dense: Vec<u8>,
+    complete: bool,
+    all_ascii: bool,
+}
+
+impl SingleByteSet {
+    fn new() -> SingleByteSet {
+        SingleByteSet {
+            sparse: vec![false; 256],
+            dense: vec![],
+            complete: true,
+            all_ascii: true,
+        }
+    }
+
+    fn prefixes(lits: &Literals) -> SingleByteSet {
+        let mut sset = SingleByteSet::new();
+        for lit in lits.literals() {
+            sset.complete = sset.complete && lit.len() == 1;
+            if let Some(&b) = lit.get(0) {
+                if !sset.sparse[b as usize] {
+                    if b > 0x7F {
+                        sset.all_ascii = false;
+                    }
+                    sset.dense.push(b);
+                    sset.sparse[b as usize] = true;
+                }
+            }
+        }
+        sset
+    }
+
+    fn suffixes(lits: &Literals) -> SingleByteSet {
+        let mut sset = SingleByteSet::new();
+        for lit in lits.literals() {
+            sset.complete = sset.complete && lit.len() == 1;
+            if let Some(&b) = lit.get(lit.len().checked_sub(1).unwrap()) {
+                if !sset.sparse[b as usize] {
+                    if b > 0x7F {
+                        sset.all_ascii = false;
+                    }
+                    sset.dense.push(b);
+                    sset.sparse[b as usize] = true;
+                }
+            }
+        }
+        sset
+    }
+
+    /// Faster find that special cases certain sizes to use memchr.
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn find(&self, text: &[u8]) -> Option<usize> {
+        match self.dense.len() {
+            0 => None,
+            1 => memchr(self.dense[0], text),
+            2 => memchr2(self.dense[0], self.dense[1], text),
+            3 => memchr3(self.dense[0], self.dense[1], self.dense[2], text),
+            _ => self._find(text),
+        }
+    }
+
+    /// Generic find that works on any sized set.
+    fn _find(&self, haystack: &[u8]) -> Option<usize> {
+        for (i, &b) in haystack.iter().enumerate() {
+            if self.sparse[b as usize] {
+                return Some(i);
+            }
+        }
+        None
+    }
+
+    fn approximate_size(&self) -> usize {
+        (self.dense.len() * mem::size_of::<u8>())
+            + (self.sparse.len() * mem::size_of::<bool>())
+    }
+}
+
+/// A simple wrapper around the memchr crate's memmem implementation.
+///
+/// The API this exposes mirrors the API of previous substring searchers that
+/// this supplanted.
+#[derive(Clone, Debug)]
+pub struct Memmem {
+    finder: memmem::Finder<'static>,
+    char_len: usize,
+}
+
+impl Memmem {
+    fn new(pat: &[u8]) -> Memmem {
+        Memmem {
+            finder: memmem::Finder::new(pat).into_owned(),
+            char_len: char_len_lossy(pat),
+        }
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub fn find(&self, haystack: &[u8]) -> Option<usize> {
+        self.finder.find(haystack)
+    }
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub fn is_suffix(&self, text: &[u8]) -> bool {
+        if text.len() < self.len() {
+            return false;
+        }
+        &text[text.len() - self.len()..] == self.finder.needle()
+    }
+
+    pub fn len(&self) -> usize {
+        self.finder.needle().len()
+    }
+
+    pub fn char_len(&self) -> usize {
+        self.char_len
+    }
+
+    fn approximate_size(&self) -> usize {
+        self.finder.needle().len() * mem::size_of::<u8>()
+    }
+}
+
+fn char_len_lossy(bytes: &[u8]) -> usize {
+    String::from_utf8_lossy(bytes).chars().count()
+}
diff --git a/crates/regex/src/literal/mod.rs b/crates/regex/src/literal/mod.rs
new file mode 100644
index 0000000..980f523
--- /dev/null
+++ b/crates/regex/src/literal/mod.rs
@@ -0,0 +1,55 @@
+pub use self::imp::*;
+
+#[cfg(feature = "perf-literal")]
+mod imp;
+
+#[allow(missing_docs)]
+#[cfg(not(feature = "perf-literal"))]
+mod imp {
+    use regex_syntax::hir::literal::Literals;
+
+    #[derive(Clone, Debug)]
+    pub struct LiteralSearcher(());
+
+    impl LiteralSearcher {
+        pub fn empty() -> Self {
+            LiteralSearcher(())
+        }
+
+        pub fn prefixes(_: Literals) -> Self {
+            LiteralSearcher(())
+        }
+
+        pub fn suffixes(_: Literals) -> Self {
+            LiteralSearcher(())
+        }
+
+        pub fn complete(&self) -> bool {
+            false
+        }
+
+        pub fn find(&self, _: &[u8]) -> Option<(usize, usize)> {
+            unreachable!()
+        }
+
+        pub fn find_start(&self, _: &[u8]) -> Option<(usize, usize)> {
+            unreachable!()
+        }
+
+        pub fn find_end(&self, _: &[u8]) -> Option<(usize, usize)> {
+            unreachable!()
+        }
+
+        pub fn is_empty(&self) -> bool {
+            true
+        }
+
+        pub fn len(&self) -> usize {
+            0
+        }
+
+        pub fn approximate_size(&self) -> usize {
+            0
+        }
+    }
+}
diff --git a/crates/regex/src/pattern.rs b/crates/regex/src/pattern.rs
new file mode 100644
index 0000000..00549e5
--- /dev/null
+++ b/crates/regex/src/pattern.rs
@@ -0,0 +1,63 @@
+use std::str::pattern::{Pattern, SearchStep, Searcher};
+
+use crate::re_unicode::{Matches, Regex};
+
+#[derive(Debug)]
+pub struct RegexSearcher<'r, 't> {
+    haystack: &'t str,
+    it: Matches<'r, 't>,
+    last_step_end: usize,
+    next_match: Option<(usize, usize)>,
+}
+
+impl<'r, 't> Pattern<'t> for &'r Regex {
+    type Searcher = RegexSearcher<'r, 't>;
+
+    fn into_searcher(self, haystack: &'t str) -> RegexSearcher<'r, 't> {
+        RegexSearcher {
+            haystack,
+            it: self.find_iter(haystack),
+            last_step_end: 0,
+            next_match: None,
+        }
+    }
+}
+
+unsafe impl<'r, 't> Searcher<'t> for RegexSearcher<'r, 't> {
+    #[inline]
+    fn haystack(&self) -> &'t str {
+        self.haystack
+    }
+
+    #[inline]
+    fn next(&mut self) -> SearchStep {
+        if let Some((s, e)) = self.next_match {
+            self.next_match = None;
+            self.last_step_end = e;
+            return SearchStep::Match(s, e);
+        }
+        match self.it.next() {
+            None => {
+                if self.last_step_end < self.haystack().len() {
+                    let last = self.last_step_end;
+                    self.last_step_end = self.haystack().len();
+                    SearchStep::Reject(last, self.haystack().len())
+                } else {
+                    SearchStep::Done
+                }
+            }
+            Some(m) => {
+                let (s, e) = (m.start(), m.end());
+                if s == self.last_step_end {
+                    self.last_step_end = e;
+                    SearchStep::Match(s, e)
+                } else {
+                    self.next_match = Some((s, e));
+                    let last = self.last_step_end;
+                    self.last_step_end = s;
+                    SearchStep::Reject(last, s)
+                }
+            }
+        }
+    }
+}
diff --git a/crates/regex/src/pikevm.rs b/crates/regex/src/pikevm.rs
new file mode 100644
index 0000000..8c9eac2
--- /dev/null
+++ b/crates/regex/src/pikevm.rs
@@ -0,0 +1,360 @@
+// This module implements the Pike VM. That is, it guarantees linear time
+// search of a regex on any text with memory use proportional to the size of
+// the regex.
+//
+// It is equal in power to the backtracking engine in this crate, except the
+// backtracking engine is typically faster on small regexes/texts at the
+// expense of a bigger memory footprint.
+//
+// It can do more than the DFA can (specifically, record capture locations
+// and execute Unicode word boundary assertions), but at a slower speed.
+// Specifically, the Pike VM executes a DFA implicitly by repeatedly expanding
+// epsilon transitions. That is, the Pike VM engine can be in multiple states
+// at once where as the DFA is only ever in one state at a time.
+//
+// Therefore, the Pike VM is generally treated as the fallback when the other
+// matching engines either aren't feasible to run or are insufficient.
+
+use std::mem;
+
+use crate::exec::ProgramCache;
+use crate::input::{Input, InputAt};
+use crate::prog::{InstPtr, Program};
+use crate::re_trait::Slot;
+use crate::sparse::SparseSet;
+
+/// An NFA simulation matching engine.
+#[derive(Debug)]
+pub struct Fsm<'r, I> {
+    /// The sequence of opcodes (among other things) that is actually executed.
+    ///
+    /// The program may be byte oriented or Unicode codepoint oriented.
+    prog: &'r Program,
+    /// An explicit stack used for following epsilon transitions. (This is
+    /// borrowed from the cache.)
+    stack: &'r mut Vec<FollowEpsilon>,
+    /// The input to search.
+    input: I,
+}
+
+/// A cached allocation that can be reused on each execution.
+#[derive(Clone, Debug)]
+pub struct Cache {
+    /// A pair of ordered sets for tracking NFA states.
+    clist: Threads,
+    nlist: Threads,
+    /// An explicit stack used for following epsilon transitions.
+    stack: Vec<FollowEpsilon>,
+}
+
+/// An ordered set of NFA states and their captures.
+#[derive(Clone, Debug)]
+struct Threads {
+    /// An ordered set of opcodes (each opcode is an NFA state).
+    set: SparseSet,
+    /// Captures for every NFA state.
+    ///
+    /// It is stored in row-major order, where the columns are the capture
+    /// slots and the rows are the states.
+    caps: Vec<Slot>,
+    /// The number of capture slots stored per thread. (Every capture has
+    /// two slots.)
+    slots_per_thread: usize,
+}
+
+/// A representation of an explicit stack frame when following epsilon
+/// transitions. This is used to avoid recursion.
+#[derive(Clone, Debug)]
+enum FollowEpsilon {
+    /// Follow transitions at the given instruction pointer.
+    IP(InstPtr),
+    /// Restore the capture slot with the given position in the input.
+    Capture { slot: usize, pos: Slot },
+}
+
+impl Cache {
+    /// Create a new allocation used by the NFA machine to record execution
+    /// and captures.
+    pub fn new(_prog: &Program) -> Self {
+        Cache { clist: Threads::new(), nlist: Threads::new(), stack: vec![] }
+    }
+}
+
+impl<'r, I: Input> Fsm<'r, I> {
+    /// Execute the NFA matching engine.
+    ///
+    /// If there's a match, `exec` returns `true` and populates the given
+    /// captures accordingly.
+    pub fn exec(
+        prog: &'r Program,
+        cache: &ProgramCache,
+        matches: &mut [bool],
+        slots: &mut [Slot],
+        quit_after_match: bool,
+        input: I,
+        start: usize,
+        end: usize,
+    ) -> bool {
+        let mut cache = cache.borrow_mut();
+        let cache = &mut cache.pikevm;
+        cache.clist.resize(prog.len(), prog.captures.len());
+        cache.nlist.resize(prog.len(), prog.captures.len());
+        let at = input.at(start);
+        Fsm { prog, stack: &mut cache.stack, input }.exec_(
+            &mut cache.clist,
+            &mut cache.nlist,
+            matches,
+            slots,
+            quit_after_match,
+            at,
+            end,
+        )
+    }
+
+    fn exec_(
+        &mut self,
+        mut clist: &mut Threads,
+        mut nlist: &mut Threads,
+        matches: &mut [bool],
+        slots: &mut [Slot],
+        quit_after_match: bool,
+        mut at: InputAt,
+        end: usize,
+    ) -> bool {
+        let mut matched = false;
+        let mut all_matched = false;
+        clist.set.clear();
+        nlist.set.clear();
+        'LOOP: loop {
+            if clist.set.is_empty() {
+                // Three ways to bail out when our current set of threads is
+                // empty.
+                //
+                // 1. We have a match---so we're done exploring any possible
+                //    alternatives. Time to quit. (We can't do this if we're
+                //    looking for matches for multiple regexes, unless we know
+                //    they all matched.)
+                //
+                // 2. If the expression starts with a '^' we can terminate as
+                //    soon as the last thread dies.
+                if (matched && matches.len() <= 1)
+                    || all_matched
+                    || (!at.is_start() && self.prog.is_anchored_start)
+                {
+                    break;
+                }
+
+                // 3. If there's a literal prefix for the program, try to
+                //    jump ahead quickly. If it can't be found, then we can
+                //    bail out early.
+                if !self.prog.prefixes.is_empty() {
+                    at = match self.input.prefix_at(&self.prog.prefixes, at) {
+                        None => break,
+                        Some(at) => at,
+                    };
+                }
+            }
+
+            // This simulates a preceding '.*?' for every regex by adding
+            // a state starting at the current position in the input for the
+            // beginning of the program only if we don't already have a match.
+            if clist.set.is_empty()
+                || (!self.prog.is_anchored_start && !all_matched)
+            {
+                self.add(&mut clist, slots, 0, at);
+            }
+            // The previous call to "add" actually inspects the position just
+            // before the current character. For stepping through the machine,
+            // we can to look at the current character, so we advance the
+            // input.
+            let at_next = self.input.at(at.next_pos());
+            for i in 0..clist.set.len() {
+                let ip = clist.set[i];
+                if self.step(
+                    &mut nlist,
+                    matches,
+                    slots,
+                    clist.caps(ip),
+                    ip,
+                    at,
+                    at_next,
+                ) {
+                    matched = true;
+                    all_matched = all_matched || matches.iter().all(|&b| b);
+                    if quit_after_match {
+                        // If we only care if a match occurs (not its
+                        // position), then we can quit right now.
+                        break 'LOOP;
+                    }
+                    if self.prog.matches.len() == 1 {
+                        // We don't need to check the rest of the threads
+                        // in this set because we've matched something
+                        // ("leftmost-first"). However, we still need to check
+                        // threads in the next set to support things like
+                        // greedy matching.
+                        //
+                        // This is only true on normal regexes. For regex sets,
+                        // we need to mush on to observe other matches.
+                        break;
+                    }
+                }
+            }
+            if at.pos() >= end {
+                break;
+            }
+            at = at_next;
+            mem::swap(clist, nlist);
+            nlist.set.clear();
+        }
+        matched
+    }
+
+    /// Step through the input, one token (byte or codepoint) at a time.
+    ///
+    /// nlist is the set of states that will be processed on the next token
+    /// in the input.
+    ///
+    /// caps is the set of captures passed by the caller of the NFA. They are
+    /// written to only when a match state is visited.
+    ///
+    /// thread_caps is the set of captures set for the current NFA state, ip.
+    ///
+    /// at and at_next are the current and next positions in the input. at or
+    /// at_next may be EOF.
+    fn step(
+        &mut self,
+        nlist: &mut Threads,
+        matches: &mut [bool],
+        slots: &mut [Slot],
+        thread_caps: &mut [Option<usize>],
+        ip: usize,
+        at: InputAt,
+        at_next: InputAt,
+    ) -> bool {
+        use crate::prog::Inst::*;
+        match self.prog[ip] {
+            Match(match_slot) => {
+                if match_slot < matches.len() {
+                    matches[match_slot] = true;
+                }
+                for (slot, val) in slots.iter_mut().zip(thread_caps.iter()) {
+                    *slot = *val;
+                }
+                true
+            }
+            Char(ref inst) => {
+                if inst.c == at.char() {
+                    self.add(nlist, thread_caps, inst.goto, at_next);
+                }
+                false
+            }
+            Ranges(ref inst) => {
+                if inst.matches(at.char()) {
+                    self.add(nlist, thread_caps, inst.goto, at_next);
+                }
+                false
+            }
+            Bytes(ref inst) => {
+                if let Some(b) = at.byte() {
+                    if inst.matches(b) {
+                        self.add(nlist, thread_caps, inst.goto, at_next);
+                    }
+                }
+                false
+            }
+            EmptyLook(_) | Save(_) | Split(_) => false,
+        }
+    }
+
+    /// Follows epsilon transitions and adds them for processing to nlist,
+    /// starting at and including ip.
+    fn add(
+        &mut self,
+        nlist: &mut Threads,
+        thread_caps: &mut [Option<usize>],
+        ip: usize,
+        at: InputAt,
+    ) {
+        self.stack.push(FollowEpsilon::IP(ip));
+        while let Some(frame) = self.stack.pop() {
+            match frame {
+                FollowEpsilon::IP(ip) => {
+                    self.add_step(nlist, thread_caps, ip, at);
+                }
+                FollowEpsilon::Capture { slot, pos } => {
+                    thread_caps[slot] = pos;
+                }
+            }
+        }
+    }
+
+    /// A helper function for add that avoids excessive pushing to the stack.
+    fn add_step(
+        &mut self,
+        nlist: &mut Threads,
+        thread_caps: &mut [Option<usize>],
+        mut ip: usize,
+        at: InputAt,
+    ) {
+        // Instead of pushing and popping to the stack, we mutate ip as we
+        // traverse the set of states. We only push to the stack when we
+        // absolutely need recursion (restoring captures or following a
+        // branch).
+        use crate::prog::Inst::*;
+        loop {
+            // Don't visit states we've already added.
+            if nlist.set.contains(ip) {
+                return;
+            }
+            nlist.set.insert(ip);
+            match self.prog[ip] {
+                EmptyLook(ref inst) => {
+                    if self.input.is_empty_match(at, inst) {
+                        ip = inst.goto;
+                    }
+                }
+                Save(ref inst) => {
+                    if inst.slot < thread_caps.len() {
+                        self.stack.push(FollowEpsilon::Capture {
+                            slot: inst.slot,
+                            pos: thread_caps[inst.slot],
+                        });
+                        thread_caps[inst.slot] = Some(at.pos());
+                    }
+                    ip = inst.goto;
+                }
+                Split(ref inst) => {
+                    self.stack.push(FollowEpsilon::IP(inst.goto2));
+                    ip = inst.goto1;
+                }
+                Match(_) | Char(_) | Ranges(_) | Bytes(_) => {
+                    let t = &mut nlist.caps(ip);
+                    for (slot, val) in t.iter_mut().zip(thread_caps.iter()) {
+                        *slot = *val;
+                    }
+                    return;
+                }
+            }
+        }
+    }
+}
+
+impl Threads {
+    fn new() -> Self {
+        Threads { set: SparseSet::new(0), caps: vec![], slots_per_thread: 0 }
+    }
+
+    fn resize(&mut self, num_insts: usize, ncaps: usize) {
+        if num_insts == self.set.capacity() {
+            return;
+        }
+        self.slots_per_thread = ncaps * 2;
+        self.set = SparseSet::new(num_insts);
+        self.caps = vec![None; self.slots_per_thread * num_insts];
+    }
+
+    fn caps(&mut self, pc: usize) -> &mut [Option<usize>] {
+        let i = pc * self.slots_per_thread;
+        &mut self.caps[i..i + self.slots_per_thread]
+    }
+}
diff --git a/crates/regex/src/pool.rs b/crates/regex/src/pool.rs
new file mode 100644
index 0000000..6a6f15b
--- /dev/null
+++ b/crates/regex/src/pool.rs
@@ -0,0 +1,333 @@
+// This module provides a relatively simple thread-safe pool of reusable
+// objects. For the most part, it's implemented by a stack represented by a
+// Mutex<Vec<T>>. It has one small trick: because unlocking a mutex is somewhat
+// costly, in the case where a pool is accessed by the first thread that tried
+// to get a value, we bypass the mutex. Here are some benchmarks showing the
+// difference.
+//
+// 1) misc::anchored_literal_long_non_match    21 (18571 MB/s)
+// 2) misc::anchored_literal_long_non_match   107 (3644 MB/s)
+// 3) misc::anchored_literal_long_non_match    45 (8666 MB/s)
+// 4) misc::anchored_literal_long_non_match    19 (20526 MB/s)
+//
+// (1) represents our baseline: the master branch at the time of writing when
+// using the 'thread_local' crate to implement the pool below.
+//
+// (2) represents a naive pool implemented completely via Mutex<Vec<T>>. There
+// is no special trick for bypassing the mutex.
+//
+// (3) is the same as (2), except it uses Mutex<Vec<Box<T>>>. It is twice as
+// fast because a Box<T> is much smaller than the T we use with a Pool in this
+// crate. So pushing and popping a Box<T> from a Vec is quite a bit faster
+// than for T.
+//
+// (4) is the same as (3), but with the trick for bypassing the mutex in the
+// case of the first-to-get thread.
+//
+// Why move off of thread_local? Even though (4) is a hair faster than (1)
+// above, this was not the main goal. The main goal was to move off of
+// thread_local and find a way to *simply* re-capture some of its speed for
+// regex's specific case. So again, why move off of it? The *primary* reason is
+// because of memory leaks. See https://github.com/rust-lang/regex/issues/362
+// for example. (Why do I want it to be simple? Well, I suppose what I mean is,
+// "use as much safe code as possible to minimize risk and be as sure as I can
+// be that it is correct.")
+//
+// My guess is that the thread_local design is probably not appropriate for
+// regex since its memory usage scales to the number of active threads that
+// have used a regex, where as the pool below scales to the number of threads
+// that simultaneously use a regex. While neither case permits contraction,
+// since we own the pool data structure below, we can add contraction if a
+// clear use case pops up in the wild. More pressingly though, it seems that
+// there are at least some use case patterns where one might have many threads
+// sitting around that might have used a regex at one point. While thread_local
+// does try to reuse space previously used by a thread that has since stopped,
+// its maximal memory usage still scales with the total number of active
+// threads. In contrast, the pool below scales with the total number of threads
+// *simultaneously* using the pool. The hope is that this uses less memory
+// overall. And if it doesn't, we can hopefully tune it somehow.
+//
+// It seems that these sort of conditions happen frequently
+// in FFI inside of other more "managed" languages. This was
+// mentioned in the issue linked above, and also mentioned here:
+// https://github.com/BurntSushi/rure-go/issues/3. And in particular, users
+// confirm that disabling the use of thread_local resolves the leak.
+//
+// There were other weaker reasons for moving off of thread_local as well.
+// Namely, at the time, I was looking to reduce dependencies. And for something
+// like regex, maintenance can be simpler when we own the full dependency tree.
+
+use std::panic::{RefUnwindSafe, UnwindSafe};
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::Mutex;
+
+/// An atomic counter used to allocate thread IDs.
+static COUNTER: AtomicUsize = AtomicUsize::new(1);
+
+thread_local!(
+    /// A thread local used to assign an ID to a thread.
+    static THREAD_ID: usize = {
+        let next = COUNTER.fetch_add(1, Ordering::Relaxed);
+        // SAFETY: We cannot permit the reuse of thread IDs since reusing a
+        // thread ID might result in more than one thread "owning" a pool,
+        // and thus, permit accessing a mutable value from multiple threads
+        // simultaneously without synchronization. The intent of this panic is
+        // to be a sanity check. It is not expected that the thread ID space
+        // will actually be exhausted in practice.
+        //
+        // This checks that the counter never wraps around, since atomic
+        // addition wraps around on overflow.
+        if next == 0 {
+            panic!("regex: thread ID allocation space exhausted");
+        }
+        next
+    };
+);
+
+/// The type of the function used to create values in a pool when the pool is
+/// empty and the caller requests one.
+type CreateFn<T> =
+    Box<dyn Fn() -> T + Send + Sync + UnwindSafe + RefUnwindSafe + 'static>;
+
+/// A simple thread safe pool for reusing values.
+///
+/// Getting a value out comes with a guard. When that guard is dropped, the
+/// value is automatically put back in the pool.
+///
+/// A Pool<T> impls Sync when T is Send (even if it's not Sync). This means
+/// that T can use interior mutability. This is possible because a pool is
+/// guaranteed to provide a value to exactly one thread at any time.
+///
+/// Currently, a pool never contracts in size. Its size is proportional to the
+/// number of simultaneous uses.
+pub struct Pool<T> {
+    /// A stack of T values to hand out. These are used when a Pool is
+    /// accessed by a thread that didn't create it.
+    stack: Mutex<Vec<Box<T>>>,
+    /// A function to create more T values when stack is empty and a caller
+    /// has requested a T.
+    create: CreateFn<T>,
+    /// The ID of the thread that owns this pool. The owner is the thread
+    /// that makes the first call to 'get'. When the owner calls 'get', it
+    /// gets 'owner_val' directly instead of returning a T from 'stack'.
+    /// See comments elsewhere for details, but this is intended to be an
+    /// optimization for the common case that makes getting a T faster.
+    ///
+    /// It is initialized to a value of zero (an impossible thread ID) as a
+    /// sentinel to indicate that it is unowned.
+    owner: AtomicUsize,
+    /// A value to return when the caller is in the same thread that created
+    /// the Pool.
+    owner_val: T,
+}
+
+// SAFETY: Since we want to use a Pool from multiple threads simultaneously
+// behind an Arc, we need for it to be Sync. In cases where T is sync, Pool<T>
+// would be Sync. However, since we use a Pool to store mutable scratch space,
+// we wind up using a T that has interior mutability and is thus itself not
+// Sync. So what we *really* want is for our Pool<T> to by Sync even when T is
+// not Sync (but is at least Send).
+//
+// The only non-sync aspect of a Pool is its 'owner_val' field, which is used
+// to implement faster access to a pool value in the common case of a pool
+// being accessed in the same thread in which it was created. The 'stack' field
+// is also shared, but a Mutex<T> where T: Send is already Sync. So we only
+// need to worry about 'owner_val'.
+//
+// The key is to guarantee that 'owner_val' can only ever be accessed from one
+// thread. In our implementation below, we guarantee this by only returning the
+// 'owner_val' when the ID of the current thread matches the ID of the thread
+// that created the Pool. Since this can only ever be one thread, it follows
+// that only one thread can access 'owner_val' at any point in time. Thus, it
+// is safe to declare that Pool<T> is Sync when T is Send.
+//
+// NOTE: It would also be possible to make the owning thread be the *first*
+// thread that tries to get a value out of a Pool. However, the current
+// implementation is a little simpler and it's not clear if making the first
+// thread (rather than the creating thread) is meaningfully better.
+//
+// If there is a way to achieve our performance goals using safe code, then
+// I would very much welcome a patch. As it stands, the implementation below
+// tries to balance safety with performance. The case where a Regex is used
+// from multiple threads simultaneously will suffer a bit since getting a cache
+// will require unlocking a mutex.
+unsafe impl<T: Send> Sync for Pool<T> {}
+
+impl<T: ::std::fmt::Debug> ::std::fmt::Debug for Pool<T> {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        f.debug_struct("Pool")
+            .field("stack", &self.stack)
+            .field("owner", &self.owner)
+            .field("owner_val", &self.owner_val)
+            .finish()
+    }
+}
+
+/// A guard that is returned when a caller requests a value from the pool.
+///
+/// The purpose of the guard is to use RAII to automatically put the value back
+/// in the pool once it's dropped.
+#[derive(Debug)]
+pub struct PoolGuard<'a, T: Send> {
+    /// The pool that this guard is attached to.
+    pool: &'a Pool<T>,
+    /// This is None when the guard represents the special "owned" value. In
+    /// which case, the value is retrieved from 'pool.owner_val'.
+    value: Option<Box<T>>,
+}
+
+impl<T: Send> Pool<T> {
+    /// Create a new pool. The given closure is used to create values in the
+    /// pool when necessary.
+    pub fn new(create: CreateFn<T>) -> Pool<T> {
+        let owner = AtomicUsize::new(0);
+        let owner_val = create();
+        Pool { stack: Mutex::new(vec![]), create, owner, owner_val }
+    }
+
+    /// Get a value from the pool. The caller is guaranteed to have exclusive
+    /// access to the given value.
+    ///
+    /// Note that there is no guarantee provided about which value in the
+    /// pool is returned. That is, calling get, dropping the guard (causing
+    /// the value to go back into the pool) and then calling get again is NOT
+    /// guaranteed to return the same value received in the first get call.
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub fn get(&self) -> PoolGuard<'_, T> {
+        // Our fast path checks if the caller is the thread that "owns" this
+        // pool. Or stated differently, whether it is the first thread that
+        // tried to extract a value from the pool. If it is, then we can return
+        // a T to the caller without going through a mutex.
+        //
+        // SAFETY: We must guarantee that only one thread gets access to this
+        // value. Since a thread is uniquely identified by the THREAD_ID thread
+        // local, it follows that is the caller's thread ID is equal to the
+        // owner, then only one thread may receive this value.
+        let caller = THREAD_ID.with(|id| *id);
+        let owner = self.owner.load(Ordering::Relaxed);
+        if caller == owner {
+            return self.guard_owned();
+        }
+        self.get_slow(caller, owner)
+    }
+
+    /// This is the "slow" version that goes through a mutex to pop an
+    /// allocated value off a stack to return to the caller. (Or, if the stack
+    /// is empty, a new value is created.)
+    ///
+    /// If the pool has no owner, then this will set the owner.
+    #[cold]
+    fn get_slow(&self, caller: usize, owner: usize) -> PoolGuard<'_, T> {
+        use std::sync::atomic::Ordering::Relaxed;
+
+        if owner == 0 {
+            // The sentinel 0 value means this pool is not yet owned. We
+            // try to atomically set the owner. If we do, then this thread
+            // becomes the owner and we can return a guard that represents
+            // the special T for the owner.
+            let res = self.owner.compare_exchange(0, caller, Relaxed, Relaxed);
+            if res.is_ok() {
+                return self.guard_owned();
+            }
+        }
+        let mut stack = self.stack.lock().unwrap();
+        let value = match stack.pop() {
+            None => Box::new((self.create)()),
+            Some(value) => value,
+        };
+        self.guard_stack(value)
+    }
+
+    /// Puts a value back into the pool. Callers don't need to call this. Once
+    /// the guard that's returned by 'get' is dropped, it is put back into the
+    /// pool automatically.
+    fn put(&self, value: Box<T>) {
+        let mut stack = self.stack.lock().unwrap();
+        stack.push(value);
+    }
+
+    /// Create a guard that represents the special owned T.
+    fn guard_owned(&self) -> PoolGuard<'_, T> {
+        PoolGuard { pool: self, value: None }
+    }
+
+    /// Create a guard that contains a value from the pool's stack.
+    fn guard_stack(&self, value: Box<T>) -> PoolGuard<'_, T> {
+        PoolGuard { pool: self, value: Some(value) }
+    }
+}
+
+impl<'a, T: Send> PoolGuard<'a, T> {
+    /// Return the underlying value.
+    pub fn value(&self) -> &T {
+        match self.value {
+            None => &self.pool.owner_val,
+            Some(ref v) => &**v,
+        }
+    }
+}
+
+impl<'a, T: Send> Drop for PoolGuard<'a, T> {
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn drop(&mut self) {
+        if let Some(value) = self.value.take() {
+            self.pool.put(value);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::panic::{RefUnwindSafe, UnwindSafe};
+
+    use super::*;
+
+    #[test]
+    fn oibits() {
+        use crate::exec::ProgramCache;
+
+        fn has_oibits<T: Send + Sync + UnwindSafe + RefUnwindSafe>() {}
+        has_oibits::<Pool<ProgramCache>>();
+    }
+
+    // Tests that Pool implements the "single owner" optimization. That is, the
+    // thread that first accesses the pool gets its own copy, while all other
+    // threads get distinct copies.
+    #[test]
+    fn thread_owner_optimization() {
+        use std::cell::RefCell;
+        use std::sync::Arc;
+
+        let pool: Arc<Pool<RefCell<Vec<char>>>> =
+            Arc::new(Pool::new(Box::new(|| RefCell::new(vec!['a']))));
+        pool.get().value().borrow_mut().push('x');
+
+        let pool1 = pool.clone();
+        let t1 = std::thread::spawn(move || {
+            let guard = pool1.get();
+            let v = guard.value();
+            v.borrow_mut().push('y');
+        });
+
+        let pool2 = pool.clone();
+        let t2 = std::thread::spawn(move || {
+            let guard = pool2.get();
+            let v = guard.value();
+            v.borrow_mut().push('z');
+        });
+
+        t1.join().unwrap();
+        t2.join().unwrap();
+
+        // If we didn't implement the single owner optimization, then one of
+        // the threads above is likely to have mutated the [a, x] vec that
+        // we stuffed in the pool before spawning the threads. But since
+        // neither thread was first to access the pool, and because of the
+        // optimization, we should be guaranteed that neither thread mutates
+        // the special owned pool value.
+        //
+        // (Technically this is an implementation detail and not a contract of
+        // Pool's API.)
+        assert_eq!(vec!['a', 'x'], *pool.get().value().borrow());
+    }
+}
diff --git a/crates/regex/src/prog.rs b/crates/regex/src/prog.rs
new file mode 100644
index 0000000..c211f71
--- /dev/null
+++ b/crates/regex/src/prog.rs
@@ -0,0 +1,447 @@
+use std::cmp::Ordering;
+use std::collections::HashMap;
+use std::fmt;
+use std::mem;
+use std::ops::Deref;
+use std::slice;
+use std::sync::Arc;
+
+use crate::input::Char;
+use crate::literal::LiteralSearcher;
+
+/// `InstPtr` represents the index of an instruction in a regex program.
+pub type InstPtr = usize;
+
+/// Program is a sequence of instructions and various facts about thos
+/// instructions.
+#[derive(Clone)]
+pub struct Program {
+    /// A sequence of instructions that represents an NFA.
+    pub insts: Vec<Inst>,
+    /// Pointers to each Match instruction in the sequence.
+    ///
+    /// This is always length 1 unless this program represents a regex set.
+    pub matches: Vec<InstPtr>,
+    /// The ordered sequence of all capture groups extracted from the AST.
+    /// Unnamed groups are `None`.
+    pub captures: Vec<Option<String>>,
+    /// Pointers to all named capture groups into `captures`.
+    pub capture_name_idx: Arc<HashMap<String, usize>>,
+    /// A pointer to the start instruction. This can vary depending on how
+    /// the program was compiled. For example, programs for use with the DFA
+    /// engine have a `.*?` inserted at the beginning of unanchored regular
+    /// expressions. The actual starting point of the program is after the
+    /// `.*?`.
+    pub start: InstPtr,
+    /// A set of equivalence classes for discriminating bytes in the compiled
+    /// program.
+    pub byte_classes: Vec<u8>,
+    /// When true, this program can only match valid UTF-8.
+    pub only_utf8: bool,
+    /// When true, this program uses byte range instructions instead of Unicode
+    /// range instructions.
+    pub is_bytes: bool,
+    /// When true, the program is compiled for DFA matching. For example, this
+    /// implies `is_bytes` and also inserts a preceding `.*?` for unanchored
+    /// regexes.
+    pub is_dfa: bool,
+    /// When true, the program matches text in reverse (for use only in the
+    /// DFA).
+    pub is_reverse: bool,
+    /// Whether the regex must match from the start of the input.
+    pub is_anchored_start: bool,
+    /// Whether the regex must match at the end of the input.
+    pub is_anchored_end: bool,
+    /// Whether this program contains a Unicode word boundary instruction.
+    pub has_unicode_word_boundary: bool,
+    /// A possibly empty machine for very quickly matching prefix literals.
+    pub prefixes: LiteralSearcher,
+    /// A limit on the size of the cache that the DFA is allowed to use while
+    /// matching.
+    ///
+    /// The cache limit specifies approximately how much space we're willing to
+    /// give to the state cache. Once the state cache exceeds the size, it is
+    /// wiped and all states must be re-computed.
+    ///
+    /// Note that this value does not impact correctness. It can be set to 0
+    /// and the DFA will run just fine. (It will only ever store exactly one
+    /// state in the cache, and will likely run very slowly, but it will work.)
+    ///
+    /// Also note that this limit is *per thread of execution*. That is,
+    /// if the same regex is used to search text across multiple threads
+    /// simultaneously, then the DFA cache is not shared. Instead, copies are
+    /// made.
+    pub dfa_size_limit: usize,
+}
+
+impl Program {
+    /// Creates an empty instruction sequence. Fields are given default
+    /// values.
+    pub fn new() -> Self {
+        Program {
+            insts: vec![],
+            matches: vec![],
+            captures: vec![],
+            capture_name_idx: Arc::new(HashMap::new()),
+            start: 0,
+            byte_classes: vec![0; 256],
+            only_utf8: true,
+            is_bytes: false,
+            is_dfa: false,
+            is_reverse: false,
+            is_anchored_start: false,
+            is_anchored_end: false,
+            has_unicode_word_boundary: false,
+            prefixes: LiteralSearcher::empty(),
+            dfa_size_limit: 2 * (1 << 20),
+        }
+    }
+
+    /// If pc is an index to a no-op instruction (like Save), then return the
+    /// next pc that is not a no-op instruction.
+    pub fn skip(&self, mut pc: usize) -> usize {
+        loop {
+            match self[pc] {
+                Inst::Save(ref i) => pc = i.goto,
+                _ => return pc,
+            }
+        }
+    }
+
+    /// Return true if and only if an execution engine at instruction `pc` will
+    /// always lead to a match.
+    pub fn leads_to_match(&self, pc: usize) -> bool {
+        if self.matches.len() > 1 {
+            // If we have a regex set, then we have more than one ending
+            // state, so leading to one of those states is generally
+            // meaningless.
+            return false;
+        }
+        match self[self.skip(pc)] {
+            Inst::Match(_) => true,
+            _ => false,
+        }
+    }
+
+    /// Returns true if the current configuration demands that an implicit
+    /// `.*?` be prepended to the instruction sequence.
+    pub fn needs_dotstar(&self) -> bool {
+        self.is_dfa && !self.is_reverse && !self.is_anchored_start
+    }
+
+    /// Returns true if this program uses Byte instructions instead of
+    /// Char/Range instructions.
+    pub fn uses_bytes(&self) -> bool {
+        self.is_bytes || self.is_dfa
+    }
+
+    /// Returns true if this program exclusively matches valid UTF-8 bytes.
+    ///
+    /// That is, if an invalid UTF-8 byte is seen, then no match is possible.
+    pub fn only_utf8(&self) -> bool {
+        self.only_utf8
+    }
+
+    /// Return the approximate heap usage of this instruction sequence in
+    /// bytes.
+    pub fn approximate_size(&self) -> usize {
+        // The only instruction that uses heap space is Ranges (for
+        // Unicode codepoint programs) to store non-overlapping codepoint
+        // ranges. To keep this operation constant time, we ignore them.
+        (self.len() * mem::size_of::<Inst>())
+            + (self.matches.len() * mem::size_of::<InstPtr>())
+            + (self.captures.len() * mem::size_of::<Option<String>>())
+            + (self.capture_name_idx.len()
+                * (mem::size_of::<String>() + mem::size_of::<usize>()))
+            + (self.byte_classes.len() * mem::size_of::<u8>())
+            + self.prefixes.approximate_size()
+    }
+}
+
+impl Deref for Program {
+    type Target = [Inst];
+
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    fn deref(&self) -> &Self::Target {
+        &*self.insts
+    }
+}
+
+impl fmt::Debug for Program {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use self::Inst::*;
+
+        fn with_goto(cur: usize, goto: usize, fmtd: String) -> String {
+            if goto == cur + 1 {
+                fmtd
+            } else {
+                format!("{} (goto: {})", fmtd, goto)
+            }
+        }
+
+        fn visible_byte(b: u8) -> String {
+            use std::ascii::escape_default;
+            let escaped = escape_default(b).collect::<Vec<u8>>();
+            String::from_utf8_lossy(&escaped).into_owned()
+        }
+
+        for (pc, inst) in self.iter().enumerate() {
+            match *inst {
+                Match(slot) => write!(f, "{:04} Match({:?})", pc, slot)?,
+                Save(ref inst) => {
+                    let s = format!("{:04} Save({})", pc, inst.slot);
+                    write!(f, "{}", with_goto(pc, inst.goto, s))?;
+                }
+                Split(ref inst) => {
+                    write!(
+                        f,
+                        "{:04} Split({}, {})",
+                        pc, inst.goto1, inst.goto2
+                    )?;
+                }
+                EmptyLook(ref inst) => {
+                    let s = format!("{:?}", inst.look);
+                    write!(f, "{:04} {}", pc, with_goto(pc, inst.goto, s))?;
+                }
+                Char(ref inst) => {
+                    let s = format!("{:?}", inst.c);
+                    write!(f, "{:04} {}", pc, with_goto(pc, inst.goto, s))?;
+                }
+                Ranges(ref inst) => {
+                    let ranges = inst
+                        .ranges
+                        .iter()
+                        .map(|r| format!("{:?}-{:?}", r.0, r.1))
+                        .collect::<Vec<String>>()
+                        .join(", ");
+                    write!(
+                        f,
+                        "{:04} {}",
+                        pc,
+                        with_goto(pc, inst.goto, ranges)
+                    )?;
+                }
+                Bytes(ref inst) => {
+                    let s = format!(
+                        "Bytes({}, {})",
+                        visible_byte(inst.start),
+                        visible_byte(inst.end)
+                    );
+                    write!(f, "{:04} {}", pc, with_goto(pc, inst.goto, s))?;
+                }
+            }
+            if pc == self.start {
+                write!(f, " (start)")?;
+            }
+            writeln!(f)?;
+        }
+        Ok(())
+    }
+}
+
+impl<'a> IntoIterator for &'a Program {
+    type Item = &'a Inst;
+    type IntoIter = slice::Iter<'a, Inst>;
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
+
+/// Inst is an instruction code in a Regex program.
+///
+/// Regrettably, a regex program either contains Unicode codepoint
+/// instructions (Char and Ranges) or it contains byte instructions (Bytes).
+/// A regex program can never contain both.
+///
+/// It would be worth investigating splitting this into two distinct types and
+/// then figuring out how to make the matching engines polymorphic over those
+/// types without sacrificing performance.
+///
+/// Other than the benefit of moving invariants into the type system, another
+/// benefit is the decreased size. If we remove the `Char` and `Ranges`
+/// instructions from the `Inst` enum, then its size shrinks from 32 bytes to
+/// 24 bytes. (This is because of the removal of a `Box<[]>` in the `Ranges`
+/// variant.) Given that byte based machines are typically much bigger than
+/// their Unicode analogues (because they can decode UTF-8 directly), this ends
+/// up being a pretty significant savings.
+#[derive(Clone, Debug)]
+pub enum Inst {
+    /// Match indicates that the program has reached a match state.
+    ///
+    /// The number in the match corresponds to the Nth logical regular
+    /// expression in this program. This index is always 0 for normal regex
+    /// programs. Values greater than 0 appear when compiling regex sets, and
+    /// each match instruction gets its own unique value. The value corresponds
+    /// to the Nth regex in the set.
+    Match(usize),
+    /// Save causes the program to save the current location of the input in
+    /// the slot indicated by InstSave.
+    Save(InstSave),
+    /// Split causes the program to diverge to one of two paths in the
+    /// program, preferring goto1 in InstSplit.
+    Split(InstSplit),
+    /// EmptyLook represents a zero-width assertion in a regex program. A
+    /// zero-width assertion does not consume any of the input text.
+    EmptyLook(InstEmptyLook),
+    /// Char requires the regex program to match the character in InstChar at
+    /// the current position in the input.
+    Char(InstChar),
+    /// Ranges requires the regex program to match the character at the current
+    /// position in the input with one of the ranges specified in InstRanges.
+    Ranges(InstRanges),
+    /// Bytes is like Ranges, except it expresses a single byte range. It is
+    /// used in conjunction with Split instructions to implement multi-byte
+    /// character classes.
+    Bytes(InstBytes),
+}
+
+impl Inst {
+    /// Returns true if and only if this is a match instruction.
+    pub fn is_match(&self) -> bool {
+        match *self {
+            Inst::Match(_) => true,
+            _ => false,
+        }
+    }
+}
+
+/// Representation of the Save instruction.
+#[derive(Clone, Debug)]
+pub struct InstSave {
+    /// The next location to execute in the program.
+    pub goto: InstPtr,
+    /// The capture slot (there are two slots for every capture in a regex,
+    /// including the zeroth capture for the entire match).
+    pub slot: usize,
+}
+
+/// Representation of the Split instruction.
+#[derive(Clone, Debug)]
+pub struct InstSplit {
+    /// The first instruction to try. A match resulting from following goto1
+    /// has precedence over a match resulting from following goto2.
+    pub goto1: InstPtr,
+    /// The second instruction to try. A match resulting from following goto1
+    /// has precedence over a match resulting from following goto2.
+    pub goto2: InstPtr,
+}
+
+/// Representation of the `EmptyLook` instruction.
+#[derive(Clone, Debug)]
+pub struct InstEmptyLook {
+    /// The next location to execute in the program if this instruction
+    /// succeeds.
+    pub goto: InstPtr,
+    /// The type of zero-width assertion to check.
+    pub look: EmptyLook,
+}
+
+/// The set of zero-width match instructions.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum EmptyLook {
+    /// Start of line or input.
+    StartLine,
+    /// End of line or input.
+    EndLine,
+    /// Start of input.
+    StartText,
+    /// End of input.
+    EndText,
+    /// Word character on one side and non-word character on other.
+    WordBoundary,
+    /// Word character on both sides or non-word character on both sides.
+    NotWordBoundary,
+    /// ASCII word boundary.
+    WordBoundaryAscii,
+    /// Not ASCII word boundary.
+    NotWordBoundaryAscii,
+}
+
+/// Representation of the Char instruction.
+#[derive(Clone, Debug)]
+pub struct InstChar {
+    /// The next location to execute in the program if this instruction
+    /// succeeds.
+    pub goto: InstPtr,
+    /// The character to test.
+    pub c: char,
+}
+
+/// Representation of the Ranges instruction.
+#[derive(Clone, Debug)]
+pub struct InstRanges {
+    /// The next location to execute in the program if this instruction
+    /// succeeds.
+    pub goto: InstPtr,
+    /// The set of Unicode scalar value ranges to test.
+    pub ranges: Box<[(char, char)]>,
+}
+
+impl InstRanges {
+    /// Tests whether the given input character matches this instruction.
+    pub fn matches(&self, c: Char) -> bool {
+        // This speeds up the `match_class_unicode` benchmark by checking
+        // some common cases quickly without binary search. e.g., Matching
+        // a Unicode class on predominantly ASCII text.
+        for r in self.ranges.iter().take(4) {
+            if c < r.0 {
+                return false;
+            }
+            if c <= r.1 {
+                return true;
+            }
+        }
+        self.ranges
+            .binary_search_by(|r| {
+                if r.1 < c {
+                    Ordering::Less
+                } else if r.0 > c {
+                    Ordering::Greater
+                } else {
+                    Ordering::Equal
+                }
+            })
+            .is_ok()
+    }
+
+    /// Return the number of distinct characters represented by all of the
+    /// ranges.
+    pub fn num_chars(&self) -> usize {
+        self.ranges
+            .iter()
+            .map(|&(s, e)| 1 + (e as u32) - (s as u32))
+            .sum::<u32>() as usize
+    }
+}
+
+/// Representation of the Bytes instruction.
+#[derive(Clone, Debug)]
+pub struct InstBytes {
+    /// The next location to execute in the program if this instruction
+    /// succeeds.
+    pub goto: InstPtr,
+    /// The start (inclusive) of this byte range.
+    pub start: u8,
+    /// The end (inclusive) of this byte range.
+    pub end: u8,
+}
+
+impl InstBytes {
+    /// Returns true if and only if the given byte is in this range.
+    pub fn matches(&self, byte: u8) -> bool {
+        self.start <= byte && byte <= self.end
+    }
+}
+
+#[cfg(test)]
+mod test {
+    #[test]
+    #[cfg(target_pointer_width = "64")]
+    fn test_size_of_inst() {
+        use std::mem::size_of;
+
+        use super::Inst;
+
+        assert_eq!(32, size_of::<Inst>());
+    }
+}
diff --git a/crates/regex/src/re_builder.rs b/crates/regex/src/re_builder.rs
new file mode 100644
index 0000000..ee63836
--- /dev/null
+++ b/crates/regex/src/re_builder.rs
@@ -0,0 +1,421 @@
+/// The set of user configurable options for compiling zero or more regexes.
+#[derive(Clone, Debug)]
+#[allow(missing_docs)]
+pub struct RegexOptions {
+    pub pats: Vec<String>,
+    pub size_limit: usize,
+    pub dfa_size_limit: usize,
+    pub nest_limit: u32,
+    pub case_insensitive: bool,
+    pub multi_line: bool,
+    pub dot_matches_new_line: bool,
+    pub swap_greed: bool,
+    pub ignore_whitespace: bool,
+    pub unicode: bool,
+    pub octal: bool,
+}
+
+impl Default for RegexOptions {
+    fn default() -> Self {
+        RegexOptions {
+            pats: vec![],
+            size_limit: 10 * (1 << 20),
+            dfa_size_limit: 2 * (1 << 20),
+            nest_limit: 250,
+            case_insensitive: false,
+            multi_line: false,
+            dot_matches_new_line: false,
+            swap_greed: false,
+            ignore_whitespace: false,
+            unicode: true,
+            octal: false,
+        }
+    }
+}
+
+macro_rules! define_builder {
+    ($name:ident, $regex_mod:ident, $only_utf8:expr) => {
+        pub mod $name {
+            use super::RegexOptions;
+            use crate::error::Error;
+            use crate::exec::ExecBuilder;
+
+            use crate::$regex_mod::Regex;
+
+            /// A configurable builder for a regular expression.
+            ///
+            /// A builder can be used to configure how the regex is built, for example, by
+            /// setting the default flags (which can be overridden in the expression
+            /// itself) or setting various limits.
+            #[derive(Debug)]
+            pub struct RegexBuilder(RegexOptions);
+
+            impl RegexBuilder {
+                /// Create a new regular expression builder with the given pattern.
+                ///
+                /// If the pattern is invalid, then an error will be returned when
+                /// `build` is called.
+                pub fn new(pattern: &str) -> RegexBuilder {
+                    let mut builder = RegexBuilder(RegexOptions::default());
+                    builder.0.pats.push(pattern.to_owned());
+                    builder
+                }
+
+                /// Consume the builder and compile the regular expression.
+                ///
+                /// Note that calling `as_str` on the resulting `Regex` will produce the
+                /// pattern given to `new` verbatim. Notably, it will not incorporate any
+                /// of the flags set on this builder.
+                pub fn build(&self) -> Result<Regex, Error> {
+                    ExecBuilder::new_options(self.0.clone())
+                        .only_utf8($only_utf8)
+                        .build()
+                        .map(Regex::from)
+                }
+
+                /// Set the value for the case insensitive (`i`) flag.
+                ///
+                /// When enabled, letters in the pattern will match both upper case and
+                /// lower case variants.
+                pub fn case_insensitive(
+                    &mut self,
+                    yes: bool,
+                ) -> &mut RegexBuilder {
+                    self.0.case_insensitive = yes;
+                    self
+                }
+
+                /// Set the value for the multi-line matching (`m`) flag.
+                ///
+                /// When enabled, `^` matches the beginning of lines and `$` matches the
+                /// end of lines.
+                ///
+                /// By default, they match beginning/end of the input.
+                pub fn multi_line(&mut self, yes: bool) -> &mut RegexBuilder {
+                    self.0.multi_line = yes;
+                    self
+                }
+
+                /// Set the value for the any character (`s`) flag, where in `.` matches
+                /// anything when `s` is set and matches anything except for new line when
+                /// it is not set (the default).
+                ///
+                /// N.B. "matches anything" means "any byte" when Unicode is disabled and
+                /// means "any valid UTF-8 encoding of any Unicode scalar value" when
+                /// Unicode is enabled.
+                pub fn dot_matches_new_line(
+                    &mut self,
+                    yes: bool,
+                ) -> &mut RegexBuilder {
+                    self.0.dot_matches_new_line = yes;
+                    self
+                }
+
+                /// Set the value for the greedy swap (`U`) flag.
+                ///
+                /// When enabled, a pattern like `a*` is lazy (tries to find shortest
+                /// match) and `a*?` is greedy (tries to find longest match).
+                ///
+                /// By default, `a*` is greedy and `a*?` is lazy.
+                pub fn swap_greed(&mut self, yes: bool) -> &mut RegexBuilder {
+                    self.0.swap_greed = yes;
+                    self
+                }
+
+                /// Set the value for the ignore whitespace (`x`) flag.
+                ///
+                /// When enabled, whitespace such as new lines and spaces will be ignored
+                /// between expressions of the pattern, and `#` can be used to start a
+                /// comment until the next new line.
+                pub fn ignore_whitespace(
+                    &mut self,
+                    yes: bool,
+                ) -> &mut RegexBuilder {
+                    self.0.ignore_whitespace = yes;
+                    self
+                }
+
+                /// Set the value for the Unicode (`u`) flag.
+                ///
+                /// Enabled by default. When disabled, character classes such as `\w` only
+                /// match ASCII word characters instead of all Unicode word characters.
+                pub fn unicode(&mut self, yes: bool) -> &mut RegexBuilder {
+                    self.0.unicode = yes;
+                    self
+                }
+
+                /// Whether to support octal syntax or not.
+                ///
+                /// Octal syntax is a little-known way of uttering Unicode codepoints in
+                /// a regular expression. For example, `a`, `\x61`, `\u0061` and
+                /// `\141` are all equivalent regular expressions, where the last example
+                /// shows octal syntax.
+                ///
+                /// While supporting octal syntax isn't in and of itself a problem, it does
+                /// make good error messages harder. That is, in PCRE based regex engines,
+                /// syntax like `\0` invokes a backreference, which is explicitly
+                /// unsupported in Rust's regex engine. However, many users expect it to
+                /// be supported. Therefore, when octal support is disabled, the error
+                /// message will explicitly mention that backreferences aren't supported.
+                ///
+                /// Octal syntax is disabled by default.
+                pub fn octal(&mut self, yes: bool) -> &mut RegexBuilder {
+                    self.0.octal = yes;
+                    self
+                }
+
+                /// Set the approximate size limit of the compiled regular expression.
+                ///
+                /// This roughly corresponds to the number of bytes occupied by a single
+                /// compiled program. If the program exceeds this number, then a
+                /// compilation error is returned.
+                pub fn size_limit(
+                    &mut self,
+                    limit: usize,
+                ) -> &mut RegexBuilder {
+                    self.0.size_limit = limit;
+                    self
+                }
+
+                /// Set the approximate size of the cache used by the DFA.
+                ///
+                /// This roughly corresponds to the number of bytes that the DFA will
+                /// use while searching.
+                ///
+                /// Note that this is a *per thread* limit. There is no way to set a global
+                /// limit. In particular, if a regex is used from multiple threads
+                /// simultaneously, then each thread may use up to the number of bytes
+                /// specified here.
+                pub fn dfa_size_limit(
+                    &mut self,
+                    limit: usize,
+                ) -> &mut RegexBuilder {
+                    self.0.dfa_size_limit = limit;
+                    self
+                }
+
+                /// Set the nesting limit for this parser.
+                ///
+                /// The nesting limit controls how deep the abstract syntax tree is allowed
+                /// to be. If the AST exceeds the given limit (e.g., with too many nested
+                /// groups), then an error is returned by the parser.
+                ///
+                /// The purpose of this limit is to act as a heuristic to prevent stack
+                /// overflow for consumers that do structural induction on an `Ast` using
+                /// explicit recursion. While this crate never does this (instead using
+                /// constant stack space and moving the call stack to the heap), other
+                /// crates may.
+                ///
+                /// This limit is not checked until the entire Ast is parsed. Therefore,
+                /// if callers want to put a limit on the amount of heap space used, then
+                /// they should impose a limit on the length, in bytes, of the concrete
+                /// pattern string. In particular, this is viable since this parser
+                /// implementation will limit itself to heap space proportional to the
+                /// length of the pattern string.
+                ///
+                /// Note that a nest limit of `0` will return a nest limit error for most
+                /// patterns but not all. For example, a nest limit of `0` permits `a` but
+                /// not `ab`, since `ab` requires a concatenation, which results in a nest
+                /// depth of `1`. In general, a nest limit is not something that manifests
+                /// in an obvious way in the concrete syntax, therefore, it should not be
+                /// used in a granular way.
+                pub fn nest_limit(&mut self, limit: u32) -> &mut RegexBuilder {
+                    self.0.nest_limit = limit;
+                    self
+                }
+            }
+        }
+    };
+}
+
+define_builder!(bytes, re_bytes, false);
+define_builder!(unicode, re_unicode, true);
+
+macro_rules! define_set_builder {
+    ($name:ident, $regex_mod:ident, $only_utf8:expr) => {
+        pub mod $name {
+            use super::RegexOptions;
+            use crate::error::Error;
+            use crate::exec::ExecBuilder;
+
+            use crate::re_set::$regex_mod::RegexSet;
+
+            /// A configurable builder for a set of regular expressions.
+            ///
+            /// A builder can be used to configure how the regexes are built, for example,
+            /// by setting the default flags (which can be overridden in the expression
+            /// itself) or setting various limits.
+            #[derive(Debug)]
+            pub struct RegexSetBuilder(RegexOptions);
+
+            impl RegexSetBuilder {
+                /// Create a new regular expression builder with the given pattern.
+                ///
+                /// If the pattern is invalid, then an error will be returned when
+                /// `build` is called.
+                pub fn new<I, S>(patterns: I) -> RegexSetBuilder
+                where
+                    S: AsRef<str>,
+                    I: IntoIterator<Item = S>,
+                {
+                    let mut builder = RegexSetBuilder(RegexOptions::default());
+                    for pat in patterns {
+                        builder.0.pats.push(pat.as_ref().to_owned());
+                    }
+                    builder
+                }
+
+                /// Consume the builder and compile the regular expressions into a set.
+                pub fn build(&self) -> Result<RegexSet, Error> {
+                    ExecBuilder::new_options(self.0.clone())
+                        .only_utf8($only_utf8)
+                        .build()
+                        .map(RegexSet::from)
+                }
+
+                /// Set the value for the case insensitive (`i`) flag.
+                pub fn case_insensitive(
+                    &mut self,
+                    yes: bool,
+                ) -> &mut RegexSetBuilder {
+                    self.0.case_insensitive = yes;
+                    self
+                }
+
+                /// Set the value for the multi-line matching (`m`) flag.
+                pub fn multi_line(
+                    &mut self,
+                    yes: bool,
+                ) -> &mut RegexSetBuilder {
+                    self.0.multi_line = yes;
+                    self
+                }
+
+                /// Set the value for the any character (`s`) flag, where in `.` matches
+                /// anything when `s` is set and matches anything except for new line when
+                /// it is not set (the default).
+                ///
+                /// N.B. "matches anything" means "any byte" for `regex::bytes::RegexSet`
+                /// expressions and means "any Unicode scalar value" for `regex::RegexSet`
+                /// expressions.
+                pub fn dot_matches_new_line(
+                    &mut self,
+                    yes: bool,
+                ) -> &mut RegexSetBuilder {
+                    self.0.dot_matches_new_line = yes;
+                    self
+                }
+
+                /// Set the value for the greedy swap (`U`) flag.
+                pub fn swap_greed(
+                    &mut self,
+                    yes: bool,
+                ) -> &mut RegexSetBuilder {
+                    self.0.swap_greed = yes;
+                    self
+                }
+
+                /// Set the value for the ignore whitespace (`x`) flag.
+                pub fn ignore_whitespace(
+                    &mut self,
+                    yes: bool,
+                ) -> &mut RegexSetBuilder {
+                    self.0.ignore_whitespace = yes;
+                    self
+                }
+
+                /// Set the value for the Unicode (`u`) flag.
+                pub fn unicode(&mut self, yes: bool) -> &mut RegexSetBuilder {
+                    self.0.unicode = yes;
+                    self
+                }
+
+                /// Whether to support octal syntax or not.
+                ///
+                /// Octal syntax is a little-known way of uttering Unicode codepoints in
+                /// a regular expression. For example, `a`, `\x61`, `\u0061` and
+                /// `\141` are all equivalent regular expressions, where the last example
+                /// shows octal syntax.
+                ///
+                /// While supporting octal syntax isn't in and of itself a problem, it does
+                /// make good error messages harder. That is, in PCRE based regex engines,
+                /// syntax like `\0` invokes a backreference, which is explicitly
+                /// unsupported in Rust's regex engine. However, many users expect it to
+                /// be supported. Therefore, when octal support is disabled, the error
+                /// message will explicitly mention that backreferences aren't supported.
+                ///
+                /// Octal syntax is disabled by default.
+                pub fn octal(&mut self, yes: bool) -> &mut RegexSetBuilder {
+                    self.0.octal = yes;
+                    self
+                }
+
+                /// Set the approximate size limit of the compiled regular expression.
+                ///
+                /// This roughly corresponds to the number of bytes occupied by a single
+                /// compiled program. If the program exceeds this number, then a
+                /// compilation error is returned.
+                pub fn size_limit(
+                    &mut self,
+                    limit: usize,
+                ) -> &mut RegexSetBuilder {
+                    self.0.size_limit = limit;
+                    self
+                }
+
+                /// Set the approximate size of the cache used by the DFA.
+                ///
+                /// This roughly corresponds to the number of bytes that the DFA will
+                /// use while searching.
+                ///
+                /// Note that this is a *per thread* limit. There is no way to set a global
+                /// limit. In particular, if a regex is used from multiple threads
+                /// simultaneously, then each thread may use up to the number of bytes
+                /// specified here.
+                pub fn dfa_size_limit(
+                    &mut self,
+                    limit: usize,
+                ) -> &mut RegexSetBuilder {
+                    self.0.dfa_size_limit = limit;
+                    self
+                }
+
+                /// Set the nesting limit for this parser.
+                ///
+                /// The nesting limit controls how deep the abstract syntax tree is allowed
+                /// to be. If the AST exceeds the given limit (e.g., with too many nested
+                /// groups), then an error is returned by the parser.
+                ///
+                /// The purpose of this limit is to act as a heuristic to prevent stack
+                /// overflow for consumers that do structural induction on an `Ast` using
+                /// explicit recursion. While this crate never does this (instead using
+                /// constant stack space and moving the call stack to the heap), other
+                /// crates may.
+                ///
+                /// This limit is not checked until the entire Ast is parsed. Therefore,
+                /// if callers want to put a limit on the amount of heap space used, then
+                /// they should impose a limit on the length, in bytes, of the concrete
+                /// pattern string. In particular, this is viable since this parser
+                /// implementation will limit itself to heap space proportional to the
+                /// length of the pattern string.
+                ///
+                /// Note that a nest limit of `0` will return a nest limit error for most
+                /// patterns but not all. For example, a nest limit of `0` permits `a` but
+                /// not `ab`, since `ab` requires a concatenation, which results in a nest
+                /// depth of `1`. In general, a nest limit is not something that manifests
+                /// in an obvious way in the concrete syntax, therefore, it should not be
+                /// used in a granular way.
+                pub fn nest_limit(
+                    &mut self,
+                    limit: u32,
+                ) -> &mut RegexSetBuilder {
+                    self.0.nest_limit = limit;
+                    self
+                }
+            }
+        }
+    };
+}
+
+define_set_builder!(set_bytes, bytes, false);
+define_set_builder!(set_unicode, unicode, true);
diff --git a/crates/regex/src/re_bytes.rs b/crates/regex/src/re_bytes.rs
new file mode 100644
index 0000000..07e9f98
--- /dev/null
+++ b/crates/regex/src/re_bytes.rs
@@ -0,0 +1,1260 @@
+use std::borrow::Cow;
+use std::collections::HashMap;
+use std::fmt;
+use std::iter::FusedIterator;
+use std::ops::{Index, Range};
+use std::str::FromStr;
+use std::sync::Arc;
+
+use crate::find_byte::find_byte;
+
+use crate::error::Error;
+use crate::exec::{Exec, ExecNoSync};
+use crate::expand::expand_bytes;
+use crate::re_builder::bytes::RegexBuilder;
+use crate::re_trait::{self, RegularExpression, SubCapturesPosIter};
+
+/// Match represents a single match of a regex in a haystack.
+///
+/// The lifetime parameter `'t` refers to the lifetime of the matched text.
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub struct Match<'t> {
+    text: &'t [u8],
+    start: usize,
+    end: usize,
+}
+
+impl<'t> Match<'t> {
+    /// Returns the starting byte offset of the match in the haystack.
+    #[inline]
+    pub fn start(&self) -> usize {
+        self.start
+    }
+
+    /// Returns the ending byte offset of the match in the haystack.
+    #[inline]
+    pub fn end(&self) -> usize {
+        self.end
+    }
+
+    /// Returns the range over the starting and ending byte offsets of the
+    /// match in the haystack.
+    #[inline]
+    pub fn range(&self) -> Range<usize> {
+        self.start..self.end
+    }
+
+    /// Returns the matched text.
+    #[inline]
+    pub fn as_bytes(&self) -> &'t [u8] {
+        &self.text[self.range()]
+    }
+
+    /// Creates a new match from the given haystack and byte offsets.
+    #[inline]
+    fn new(haystack: &'t [u8], start: usize, end: usize) -> Match<'t> {
+        Match { text: haystack, start, end }
+    }
+}
+
+impl<'t> From<Match<'t>> for Range<usize> {
+    fn from(m: Match<'t>) -> Range<usize> {
+        m.range()
+    }
+}
+
+/// A compiled regular expression for matching arbitrary bytes.
+///
+/// It can be used to search, split or replace text. All searching is done with
+/// an implicit `.*?` at the beginning and end of an expression. To force an
+/// expression to match the whole string (or a prefix or a suffix), you must
+/// use an anchor like `^` or `$` (or `\A` and `\z`).
+///
+/// Like the `Regex` type in the parent module, matches with this regex return
+/// byte offsets into the search text. **Unlike** the parent `Regex` type,
+/// these byte offsets may not correspond to UTF-8 sequence boundaries since
+/// the regexes in this module can match arbitrary bytes.
+#[derive(Clone)]
+pub struct Regex(Exec);
+
+impl fmt::Display for Regex {
+    /// Shows the original regular expression.
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.as_str())
+    }
+}
+
+impl fmt::Debug for Regex {
+    /// Shows the original regular expression.
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(self, f)
+    }
+}
+
+/// A constructor for Regex from an Exec.
+///
+/// This is hidden because Exec isn't actually part of the public API.
+#[doc(hidden)]
+impl From<Exec> for Regex {
+    fn from(exec: Exec) -> Regex {
+        Regex(exec)
+    }
+}
+
+impl FromStr for Regex {
+    type Err = Error;
+
+    /// Attempts to parse a string into a regular expression
+    fn from_str(s: &str) -> Result<Regex, Error> {
+        Regex::new(s)
+    }
+}
+
+/// Core regular expression methods.
+impl Regex {
+    /// Compiles a regular expression. Once compiled, it can be used repeatedly
+    /// to search, split or replace text in a string.
+    ///
+    /// If an invalid expression is given, then an error is returned.
+    pub fn new(re: &str) -> Result<Regex, Error> {
+        RegexBuilder::new(re).build()
+    }
+
+    /// Returns true if and only if there is a match for the regex in the
+    /// string given.
+    ///
+    /// It is recommended to use this method if all you need to do is test
+    /// a match, since the underlying matching engine may be able to do less
+    /// work.
+    ///
+    /// # Example
+    ///
+    /// Test if some text contains at least one word with exactly 13 ASCII word
+    /// bytes:
+    ///
+    /// ```rust
+    /// # use regex::bytes::Regex;
+    /// # fn main() {
+    /// let text = b"I categorically deny having triskaidekaphobia.";
+    /// assert!(Regex::new(r"\b\w{13}\b").unwrap().is_match(text));
+    /// # }
+    /// ```
+    pub fn is_match(&self, text: &[u8]) -> bool {
+        self.is_match_at(text, 0)
+    }
+
+    /// Returns the start and end byte range of the leftmost-first match in
+    /// `text`. If no match exists, then `None` is returned.
+    ///
+    /// Note that this should only be used if you want to discover the position
+    /// of the match. Testing the existence of a match is faster if you use
+    /// `is_match`.
+    ///
+    /// # Example
+    ///
+    /// Find the start and end location of the first word with exactly 13
+    /// ASCII word bytes:
+    ///
+    /// ```rust
+    /// # use regex::bytes::Regex;
+    /// # fn main() {
+    /// let text = b"I categorically deny having triskaidekaphobia.";
+    /// let mat = Regex::new(r"\b\w{13}\b").unwrap().find(text).unwrap();
+    /// assert_eq!((mat.start(), mat.end()), (2, 15));
+    /// # }
+    /// ```
+    pub fn find<'t>(&self, text: &'t [u8]) -> Option<Match<'t>> {
+        self.find_at(text, 0)
+    }
+
+    /// Returns an iterator for each successive non-overlapping match in
+    /// `text`, returning the start and end byte indices with respect to
+    /// `text`.
+    ///
+    /// # Example
+    ///
+    /// Find the start and end location of every word with exactly 13 ASCII
+    /// word bytes:
+    ///
+    /// ```rust
+    /// # use regex::bytes::Regex;
+    /// # fn main() {
+    /// let text = b"Retroactively relinquishing remunerations is reprehensible.";
+    /// for mat in Regex::new(r"\b\w{13}\b").unwrap().find_iter(text) {
+    ///     println!("{:?}", mat);
+    /// }
+    /// # }
+    /// ```
+    pub fn find_iter<'r, 't>(&'r self, text: &'t [u8]) -> Matches<'r, 't> {
+        Matches(self.0.searcher().find_iter(text))
+    }
+
+    /// Returns the capture groups corresponding to the leftmost-first
+    /// match in `text`. Capture group `0` always corresponds to the entire
+    /// match. If no match is found, then `None` is returned.
+    ///
+    /// You should only use `captures` if you need access to the location of
+    /// capturing group matches. Otherwise, `find` is faster for discovering
+    /// the location of the overall match.
+    ///
+    /// # Examples
+    ///
+    /// Say you have some text with movie names and their release years,
+    /// like "'Citizen Kane' (1941)". It'd be nice if we could search for text
+    /// looking like that, while also extracting the movie name and its release
+    /// year separately.
+    ///
+    /// ```rust
+    /// # use regex::bytes::Regex;
+    /// # fn main() {
+    /// let re = Regex::new(r"'([^']+)'\s+\((\d{4})\)").unwrap();
+    /// let text = b"Not my favorite movie: 'Citizen Kane' (1941).";
+    /// let caps = re.captures(text).unwrap();
+    /// assert_eq!(caps.get(1).unwrap().as_bytes(), &b"Citizen Kane"[..]);
+    /// assert_eq!(caps.get(2).unwrap().as_bytes(), &b"1941"[..]);
+    /// assert_eq!(caps.get(0).unwrap().as_bytes(), &b"'Citizen Kane' (1941)"[..]);
+    /// // You can also access the groups by index using the Index notation.
+    /// // Note that this will panic on an invalid index.
+    /// assert_eq!(&caps[1], b"Citizen Kane");
+    /// assert_eq!(&caps[2], b"1941");
+    /// assert_eq!(&caps[0], b"'Citizen Kane' (1941)");
+    /// # }
+    /// ```
+    ///
+    /// Note that the full match is at capture group `0`. Each subsequent
+    /// capture group is indexed by the order of its opening `(`.
+    ///
+    /// We can make this example a bit clearer by using *named* capture groups:
+    ///
+    /// ```rust
+    /// # use regex::bytes::Regex;
+    /// # fn main() {
+    /// let re = Regex::new(r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)")
+    ///                .unwrap();
+    /// let text = b"Not my favorite movie: 'Citizen Kane' (1941).";
+    /// let caps = re.captures(text).unwrap();
+    /// assert_eq!(caps.name("title").unwrap().as_bytes(), b"Citizen Kane");
+    /// assert_eq!(caps.name("year").unwrap().as_bytes(), b"1941");
+    /// assert_eq!(caps.get(0).unwrap().as_bytes(), &b"'Citizen Kane' (1941)"[..]);
+    /// // You can also access the groups by name using the Index notation.
+    /// // Note that this will panic on an invalid group name.
+    /// assert_eq!(&caps["title"], b"Citizen Kane");
+    /// assert_eq!(&caps["year"], b"1941");
+    /// assert_eq!(&caps[0], b"'Citizen Kane' (1941)");
+    ///
+    /// # }
+    /// ```
+    ///
+    /// Here we name the capture groups, which we can access with the `name`
+    /// method or the `Index` notation with a `&str`. Note that the named
+    /// capture groups are still accessible with `get` or the `Index` notation
+    /// with a `usize`.
+    ///
+    /// The `0`th capture group is always unnamed, so it must always be
+    /// accessed with `get(0)` or `[0]`.
+    pub fn captures<'t>(&self, text: &'t [u8]) -> Option<Captures<'t>> {
+        let mut locs = self.capture_locations();
+        self.captures_read_at(&mut locs, text, 0).map(move |_| Captures {
+            text,
+            locs: locs.0,
+            named_groups: self.0.capture_name_idx().clone(),
+        })
+    }
+
+    /// Returns an iterator over all the non-overlapping capture groups matched
+    /// in `text`. This is operationally the same as `find_iter`, except it
+    /// yields information about capturing group matches.
+    ///
+    /// # Example
+    ///
+    /// We can use this to find all movie titles and their release years in
+    /// some text, where the movie is formatted like "'Title' (xxxx)":
+    ///
+    /// ```rust
+    /// # use std::str; use regex::bytes::Regex;
+    /// # fn main() {
+    /// let re = Regex::new(r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)")
+    ///                .unwrap();
+    /// let text = b"'Citizen Kane' (1941), 'The Wizard of Oz' (1939), 'M' (1931).";
+    /// for caps in re.captures_iter(text) {
+    ///     let title = str::from_utf8(&caps["title"]).unwrap();
+    ///     let year = str::from_utf8(&caps["year"]).unwrap();
+    ///     println!("Movie: {:?}, Released: {:?}", title, year);
+    /// }
+    /// // Output:
+    /// // Movie: Citizen Kane, Released: 1941
+    /// // Movie: The Wizard of Oz, Released: 1939
+    /// // Movie: M, Released: 1931
+    /// # }
+    /// ```
+    pub fn captures_iter<'r, 't>(
+        &'r self,
+        text: &'t [u8],
+    ) -> CaptureMatches<'r, 't> {
+        CaptureMatches(self.0.searcher().captures_iter(text))
+    }
+
+    /// Returns an iterator of substrings of `text` delimited by a match of the
+    /// regular expression. Namely, each element of the iterator corresponds to
+    /// text that *isn't* matched by the regular expression.
+    ///
+    /// This method will *not* copy the text given.
+    ///
+    /// # Example
+    ///
+    /// To split a string delimited by arbitrary amounts of spaces or tabs:
+    ///
+    /// ```rust
+    /// # use regex::bytes::Regex;
+    /// # fn main() {
+    /// let re = Regex::new(r"[ \t]+").unwrap();
+    /// let fields: Vec<&[u8]> = re.split(b"a b \t  c\td    e").collect();
+    /// assert_eq!(fields, vec![
+    ///     &b"a"[..], &b"b"[..], &b"c"[..], &b"d"[..], &b"e"[..],
+    /// ]);
+    /// # }
+    /// ```
+    pub fn split<'r, 't>(&'r self, text: &'t [u8]) -> Split<'r, 't> {
+        Split { finder: self.find_iter(text), last: 0 }
+    }
+
+    /// Returns an iterator of at most `limit` substrings of `text` delimited
+    /// by a match of the regular expression. (A `limit` of `0` will return no
+    /// substrings.) Namely, each element of the iterator corresponds to text
+    /// that *isn't* matched by the regular expression. The remainder of the
+    /// string that is not split will be the last element in the iterator.
+    ///
+    /// This method will *not* copy the text given.
+    ///
+    /// # Example
+    ///
+    /// Get the first two words in some text:
+    ///
+    /// ```rust
+    /// # use regex::bytes::Regex;
+    /// # fn main() {
+    /// let re = Regex::new(r"\W+").unwrap();
+    /// let fields: Vec<&[u8]> = re.splitn(b"Hey! How are you?", 3).collect();
+    /// assert_eq!(fields, vec![&b"Hey"[..], &b"How"[..], &b"are you?"[..]]);
+    /// # }
+    /// ```
+    pub fn splitn<'r, 't>(
+        &'r self,
+        text: &'t [u8],
+        limit: usize,
+    ) -> SplitN<'r, 't> {
+        SplitN { splits: self.split(text), n: limit }
+    }
+
+    /// Replaces the leftmost-first match with the replacement provided. The
+    /// replacement can be a regular byte string (where `$N` and `$name` are
+    /// expanded to match capture groups) or a function that takes the matches'
+    /// `Captures` and returns the replaced byte string.
+    ///
+    /// If no match is found, then a copy of the byte string is returned
+    /// unchanged.
+    ///
+    /// # Replacement string syntax
+    ///
+    /// All instances of `$name` in the replacement text is replaced with the
+    /// corresponding capture group `name`.
+    ///
+    /// `name` may be an integer corresponding to the index of the
+    /// capture group (counted by order of opening parenthesis where `0` is the
+    /// entire match) or it can be a name (consisting of letters, digits or
+    /// underscores) corresponding to a named capture group.
+    ///
+    /// If `name` isn't a valid capture group (whether the name doesn't exist
+    /// or isn't a valid index), then it is replaced with the empty string.
+    ///
+    /// The longest possible name is used. e.g., `$1a` looks up the capture
+    /// group named `1a` and not the capture group at index `1`. To exert more
+    /// precise control over the name, use braces, e.g., `${1}a`.
+    ///
+    /// To write a literal `$` use `$$`.
+    ///
+    /// # Examples
+    ///
+    /// Note that this function is polymorphic with respect to the replacement.
+    /// In typical usage, this can just be a normal byte string:
+    ///
+    /// ```rust
+    /// # use regex::bytes::Regex;
+    /// # fn main() {
+    /// let re = Regex::new("[^01]+").unwrap();
+    /// assert_eq!(re.replace(b"1078910", &b""[..]), &b"1010"[..]);
+    /// # }
+    /// ```
+    ///
+    /// But anything satisfying the `Replacer` trait will work. For example, a
+    /// closure of type `|&Captures| -> Vec<u8>` provides direct access to the
+    /// captures corresponding to a match. This allows one to access capturing
+    /// group matches easily:
+    ///
+    /// ```rust
+    /// # use regex::bytes::Regex;
+    /// # use regex::bytes::Captures; fn main() {
+    /// let re = Regex::new(r"([^,\s]+),\s+(\S+)").unwrap();
+    /// let result = re.replace(b"Springsteen, Bruce", |caps: &Captures| {
+    ///     let mut replacement = caps[2].to_owned();
+    ///     replacement.push(b' ');
+    ///     replacement.extend(&caps[1]);
+    ///     replacement
+    /// });
+    /// assert_eq!(result, &b"Bruce Springsteen"[..]);
+    /// # }
+    /// ```
+    ///
+    /// But this is a bit cumbersome to use all the time. Instead, a simple
+    /// syntax is supported that expands `$name` into the corresponding capture
+    /// group. Here's the last example, but using this expansion technique
+    /// with named capture groups:
+    ///
+    /// ```rust
+    /// # use regex::bytes::Regex;
+    /// # fn main() {
+    /// let re = Regex::new(r"(?P<last>[^,\s]+),\s+(?P<first>\S+)").unwrap();
+    /// let result = re.replace(b"Springsteen, Bruce", &b"$first $last"[..]);
+    /// assert_eq!(result, &b"Bruce Springsteen"[..]);
+    /// # }
+    /// ```
+    ///
+    /// Note that using `$2` instead of `$first` or `$1` instead of `$last`
+    /// would produce the same result. To write a literal `$` use `$$`.
+    ///
+    /// Sometimes the replacement string requires use of curly braces to
+    /// delineate a capture group replacement and surrounding literal text.
+    /// For example, if we wanted to join two words together with an
+    /// underscore:
+    ///
+    /// ```rust
+    /// # use regex::bytes::Regex;
+    /// # fn main() {
+    /// let re = Regex::new(r"(?P<first>\w+)\s+(?P<second>\w+)").unwrap();
+    /// let result = re.replace(b"deep fried", &b"${first}_$second"[..]);
+    /// assert_eq!(result, &b"deep_fried"[..]);
+    /// # }
+    /// ```
+    ///
+    /// Without the curly braces, the capture group name `first_` would be
+    /// used, and since it doesn't exist, it would be replaced with the empty
+    /// string.
+    ///
+    /// Finally, sometimes you just want to replace a literal string with no
+    /// regard for capturing group expansion. This can be done by wrapping a
+    /// byte string with `NoExpand`:
+    ///
+    /// ```rust
+    /// # use regex::bytes::Regex;
+    /// # fn main() {
+    /// use regex::bytes::NoExpand;
+    ///
+    /// let re = Regex::new(r"(?P<last>[^,\s]+),\s+(\S+)").unwrap();
+    /// let result = re.replace(b"Springsteen, Bruce", NoExpand(b"$2 $last"));
+    /// assert_eq!(result, &b"$2 $last"[..]);
+    /// # }
+    /// ```
+    pub fn replace<'t, R: Replacer>(
+        &self,
+        text: &'t [u8],
+        rep: R,
+    ) -> Cow<'t, [u8]> {
+        self.replacen(text, 1, rep)
+    }
+
+    /// Replaces all non-overlapping matches in `text` with the replacement
+    /// provided. This is the same as calling `replacen` with `limit` set to
+    /// `0`.
+    ///
+    /// See the documentation for `replace` for details on how to access
+    /// capturing group matches in the replacement text.
+    pub fn replace_all<'t, R: Replacer>(
+        &self,
+        text: &'t [u8],
+        rep: R,
+    ) -> Cow<'t, [u8]> {
+        self.replacen(text, 0, rep)
+    }
+
+    /// Replaces at most `limit` non-overlapping matches in `text` with the
+    /// replacement provided. If `limit` is 0, then all non-overlapping matches
+    /// are replaced.
+    ///
+    /// See the documentation for `replace` for details on how to access
+    /// capturing group matches in the replacement text.
+    pub fn replacen<'t, R: Replacer>(
+        &self,
+        text: &'t [u8],
+        limit: usize,
+        mut rep: R,
+    ) -> Cow<'t, [u8]> {
+        if let Some(rep) = rep.no_expansion() {
+            let mut it = self.find_iter(text).enumerate().peekable();
+            if it.peek().is_none() {
+                return Cow::Borrowed(text);
+            }
+            let mut new = Vec::with_capacity(text.len());
+            let mut last_match = 0;
+            for (i, m) in it {
+                new.extend_from_slice(&text[last_match..m.start()]);
+                new.extend_from_slice(&rep);
+                last_match = m.end();
+                if limit > 0 && i >= limit - 1 {
+                    break;
+                }
+            }
+            new.extend_from_slice(&text[last_match..]);
+            return Cow::Owned(new);
+        }
+
+        // The slower path, which we use if the replacement needs access to
+        // capture groups.
+        let mut it = self.captures_iter(text).enumerate().peekable();
+        if it.peek().is_none() {
+            return Cow::Borrowed(text);
+        }
+        let mut new = Vec::with_capacity(text.len());
+        let mut last_match = 0;
+        for (i, cap) in it {
+            // unwrap on 0 is OK because captures only reports matches
+            let m = cap.get(0).unwrap();
+            new.extend_from_slice(&text[last_match..m.start()]);
+            rep.replace_append(&cap, &mut new);
+            last_match = m.end();
+            if limit > 0 && i >= limit - 1 {
+                break;
+            }
+        }
+        new.extend_from_slice(&text[last_match..]);
+        Cow::Owned(new)
+    }
+}
+
+/// Advanced or "lower level" search methods.
+impl Regex {
+    /// Returns the end location of a match in the text given.
+    ///
+    /// This method may have the same performance characteristics as
+    /// `is_match`, except it provides an end location for a match. In
+    /// particular, the location returned *may be shorter* than the proper end
+    /// of the leftmost-first match.
+    ///
+    /// # Example
+    ///
+    /// Typically, `a+` would match the entire first sequence of `a` in some
+    /// text, but `shortest_match` can give up as soon as it sees the first
+    /// `a`.
+    ///
+    /// ```rust
+    /// # use regex::bytes::Regex;
+    /// # fn main() {
+    /// let text = b"aaaaa";
+    /// let pos = Regex::new(r"a+").unwrap().shortest_match(text);
+    /// assert_eq!(pos, Some(1));
+    /// # }
+    /// ```
+    pub fn shortest_match(&self, text: &[u8]) -> Option<usize> {
+        self.shortest_match_at(text, 0)
+    }
+
+    /// Returns the same as shortest_match, but starts the search at the given
+    /// offset.
+    ///
+    /// The significance of the starting point is that it takes the surrounding
+    /// context into consideration. For example, the `\A` anchor can only
+    /// match when `start == 0`.
+    pub fn shortest_match_at(
+        &self,
+        text: &[u8],
+        start: usize,
+    ) -> Option<usize> {
+        self.0.searcher().shortest_match_at(text, start)
+    }
+
+    /// Returns the same as is_match, but starts the search at the given
+    /// offset.
+    ///
+    /// The significance of the starting point is that it takes the surrounding
+    /// context into consideration. For example, the `\A` anchor can only
+    /// match when `start == 0`.
+    pub fn is_match_at(&self, text: &[u8], start: usize) -> bool {
+        self.0.searcher().is_match_at(text, start)
+    }
+
+    /// Returns the same as find, but starts the search at the given
+    /// offset.
+    ///
+    /// The significance of the starting point is that it takes the surrounding
+    /// context into consideration. For example, the `\A` anchor can only
+    /// match when `start == 0`.
+    pub fn find_at<'t>(
+        &self,
+        text: &'t [u8],
+        start: usize,
+    ) -> Option<Match<'t>> {
+        self.0
+            .searcher()
+            .find_at(text, start)
+            .map(|(s, e)| Match::new(text, s, e))
+    }
+
+    /// This is like `captures`, but uses
+    /// [`CaptureLocations`](struct.CaptureLocations.html)
+    /// instead of
+    /// [`Captures`](struct.Captures.html) in order to amortize allocations.
+    ///
+    /// To create a `CaptureLocations` value, use the
+    /// `Regex::capture_locations` method.
+    ///
+    /// This returns the overall match if this was successful, which is always
+    /// equivalence to the `0`th capture group.
+    pub fn captures_read<'t>(
+        &self,
+        locs: &mut CaptureLocations,
+        text: &'t [u8],
+    ) -> Option<Match<'t>> {
+        self.captures_read_at(locs, text, 0)
+    }
+
+    /// Returns the same as `captures_read`, but starts the search at the given
+    /// offset and populates the capture locations given.
+    ///
+    /// The significance of the starting point is that it takes the surrounding
+    /// context into consideration. For example, the `\A` anchor can only
+    /// match when `start == 0`.
+    pub fn captures_read_at<'t>(
+        &self,
+        locs: &mut CaptureLocations,
+        text: &'t [u8],
+        start: usize,
+    ) -> Option<Match<'t>> {
+        self.0
+            .searcher()
+            .captures_read_at(&mut locs.0, text, start)
+            .map(|(s, e)| Match::new(text, s, e))
+    }
+
+    /// An undocumented alias for `captures_read_at`.
+    ///
+    /// The `regex-capi` crate previously used this routine, so to avoid
+    /// breaking that crate, we continue to provide the name as an undocumented
+    /// alias.
+    #[doc(hidden)]
+    pub fn read_captures_at<'t>(
+        &self,
+        locs: &mut CaptureLocations,
+        text: &'t [u8],
+        start: usize,
+    ) -> Option<Match<'t>> {
+        self.captures_read_at(locs, text, start)
+    }
+}
+
+/// Auxiliary methods.
+impl Regex {
+    /// Returns the original string of this regex.
+    pub fn as_str(&self) -> &str {
+        &self.0.regex_strings()[0]
+    }
+
+    /// Returns an iterator over the capture names.
+    pub fn capture_names(&self) -> CaptureNames<'_> {
+        CaptureNames(self.0.capture_names().iter())
+    }
+
+    /// Returns the number of captures.
+    pub fn captures_len(&self) -> usize {
+        self.0.capture_names().len()
+    }
+
+    /// Returns an empty set of capture locations that can be reused in
+    /// multiple calls to `captures_read` or `captures_read_at`.
+    pub fn capture_locations(&self) -> CaptureLocations {
+        CaptureLocations(self.0.searcher().locations())
+    }
+
+    /// An alias for `capture_locations` to preserve backward compatibility.
+    ///
+    /// The `regex-capi` crate uses this method, so to avoid breaking that
+    /// crate, we continue to export it as an undocumented API.
+    #[doc(hidden)]
+    pub fn locations(&self) -> CaptureLocations {
+        CaptureLocations(self.0.searcher().locations())
+    }
+}
+
+/// An iterator over all non-overlapping matches for a particular string.
+///
+/// The iterator yields a tuple of integers corresponding to the start and end
+/// of the match. The indices are byte offsets. The iterator stops when no more
+/// matches can be found.
+///
+/// `'r` is the lifetime of the compiled regular expression and `'t` is the
+/// lifetime of the matched byte string.
+#[derive(Debug)]
+pub struct Matches<'r, 't>(re_trait::Matches<'t, ExecNoSync<'r>>);
+
+impl<'r, 't> Iterator for Matches<'r, 't> {
+    type Item = Match<'t>;
+
+    fn next(&mut self) -> Option<Match<'t>> {
+        let text = self.0.text();
+        self.0.next().map(|(s, e)| Match::new(text, s, e))
+    }
+}
+
+impl<'r, 't> FusedIterator for Matches<'r, 't> {}
+
+/// An iterator that yields all non-overlapping capture groups matching a
+/// particular regular expression.
+///
+/// The iterator stops when no more matches can be found.
+///
+/// `'r` is the lifetime of the compiled regular expression and `'t` is the
+/// lifetime of the matched byte string.
+#[derive(Debug)]
+pub struct CaptureMatches<'r, 't>(
+    re_trait::CaptureMatches<'t, ExecNoSync<'r>>,
+);
+
+impl<'r, 't> Iterator for CaptureMatches<'r, 't> {
+    type Item = Captures<'t>;
+
+    fn next(&mut self) -> Option<Captures<'t>> {
+        self.0.next().map(|locs| Captures {
+            text: self.0.text(),
+            locs,
+            named_groups: self.0.regex().capture_name_idx().clone(),
+        })
+    }
+}
+
+impl<'r, 't> FusedIterator for CaptureMatches<'r, 't> {}
+
+/// Yields all substrings delimited by a regular expression match.
+///
+/// `'r` is the lifetime of the compiled regular expression and `'t` is the
+/// lifetime of the byte string being split.
+#[derive(Debug)]
+pub struct Split<'r, 't> {
+    finder: Matches<'r, 't>,
+    last: usize,
+}
+
+impl<'r, 't> Iterator for Split<'r, 't> {
+    type Item = &'t [u8];
+
+    fn next(&mut self) -> Option<&'t [u8]> {
+        let text = self.finder.0.text();
+        match self.finder.next() {
+            None => {
+                if self.last > text.len() {
+                    None
+                } else {
+                    let s = &text[self.last..];
+                    self.last = text.len() + 1; // Next call will return None
+                    Some(s)
+                }
+            }
+            Some(m) => {
+                let matched = &text[self.last..m.start()];
+                self.last = m.end();
+                Some(matched)
+            }
+        }
+    }
+}
+
+impl<'r, 't> FusedIterator for Split<'r, 't> {}
+
+/// Yields at most `N` substrings delimited by a regular expression match.
+///
+/// The last substring will be whatever remains after splitting.
+///
+/// `'r` is the lifetime of the compiled regular expression and `'t` is the
+/// lifetime of the byte string being split.
+#[derive(Debug)]
+pub struct SplitN<'r, 't> {
+    splits: Split<'r, 't>,
+    n: usize,
+}
+
+impl<'r, 't> Iterator for SplitN<'r, 't> {
+    type Item = &'t [u8];
+
+    fn next(&mut self) -> Option<&'t [u8]> {
+        if self.n == 0 {
+            return None;
+        }
+
+        self.n -= 1;
+        if self.n > 0 {
+            return self.splits.next();
+        }
+
+        let text = self.splits.finder.0.text();
+        if self.splits.last > text.len() {
+            // We've already returned all substrings.
+            None
+        } else {
+            // self.n == 0, so future calls will return None immediately
+            Some(&text[self.splits.last..])
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (0, Some(self.n))
+    }
+}
+
+impl<'r, 't> FusedIterator for SplitN<'r, 't> {}
+
+/// An iterator over the names of all possible captures.
+///
+/// `None` indicates an unnamed capture; the first element (capture 0, the
+/// whole matched region) is always unnamed.
+///
+/// `'r` is the lifetime of the compiled regular expression.
+#[derive(Clone, Debug)]
+pub struct CaptureNames<'r>(::std::slice::Iter<'r, Option<String>>);
+
+impl<'r> Iterator for CaptureNames<'r> {
+    type Item = Option<&'r str>;
+
+    fn next(&mut self) -> Option<Option<&'r str>> {
+        self.0
+            .next()
+            .as_ref()
+            .map(|slot| slot.as_ref().map(|name| name.as_ref()))
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.0.size_hint()
+    }
+
+    fn count(self) -> usize {
+        self.0.count()
+    }
+}
+
+impl<'r> ExactSizeIterator for CaptureNames<'r> {}
+
+impl<'r> FusedIterator for CaptureNames<'r> {}
+
+/// CaptureLocations is a low level representation of the raw offsets of each
+/// submatch.
+///
+/// You can think of this as a lower level
+/// [`Captures`](struct.Captures.html), where this type does not support
+/// named capturing groups directly and it does not borrow the text that these
+/// offsets were matched on.
+///
+/// Primarily, this type is useful when using the lower level `Regex` APIs
+/// such as `read_captures`, which permits amortizing the allocation in which
+/// capture match locations are stored.
+///
+/// In order to build a value of this type, you'll need to call the
+/// `capture_locations` method on the `Regex` being used to execute the search.
+/// The value returned can then be reused in subsequent searches.
+#[derive(Clone, Debug)]
+pub struct CaptureLocations(re_trait::Locations);
+
+/// A type alias for `CaptureLocations` for backwards compatibility.
+///
+/// Previously, we exported `CaptureLocations` as `Locations` in an
+/// undocumented API. To prevent breaking that code (e.g., in `regex-capi`),
+/// we continue re-exporting the same undocumented API.
+#[doc(hidden)]
+pub type Locations = CaptureLocations;
+
+impl CaptureLocations {
+    /// Returns the start and end positions of the Nth capture group. Returns
+    /// `None` if `i` is not a valid capture group or if the capture group did
+    /// not match anything. The positions returned are *always* byte indices
+    /// with respect to the original string matched.
+    #[inline]
+    pub fn get(&self, i: usize) -> Option<(usize, usize)> {
+        self.0.pos(i)
+    }
+
+    /// Returns the total number of capture groups (even if they didn't match).
+    ///
+    /// This is always at least `1` since every regex has at least `1`
+    /// capturing group that corresponds to the entire match.
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.0.len()
+    }
+
+    /// An alias for the `get` method for backwards compatibility.
+    ///
+    /// Previously, we exported `get` as `pos` in an undocumented API. To
+    /// prevent breaking that code (e.g., in `regex-capi`), we continue
+    /// re-exporting the same undocumented API.
+    #[doc(hidden)]
+    #[inline]
+    pub fn pos(&self, i: usize) -> Option<(usize, usize)> {
+        self.get(i)
+    }
+}
+
+/// Captures represents a group of captured byte strings for a single match.
+///
+/// The 0th capture always corresponds to the entire match. Each subsequent
+/// index corresponds to the next capture group in the regex. If a capture
+/// group is named, then the matched byte string is *also* available via the
+/// `name` method. (Note that the 0th capture is always unnamed and so must be
+/// accessed with the `get` method.)
+///
+/// Positions returned from a capture group are always byte indices.
+///
+/// `'t` is the lifetime of the matched text.
+pub struct Captures<'t> {
+    text: &'t [u8],
+    locs: re_trait::Locations,
+    named_groups: Arc<HashMap<String, usize>>,
+}
+
+impl<'t> Captures<'t> {
+    /// Returns the match associated with the capture group at index `i`. If
+    /// `i` does not correspond to a capture group, or if the capture group
+    /// did not participate in the match, then `None` is returned.
+    ///
+    /// # Examples
+    ///
+    /// Get the text of the match with a default of an empty string if this
+    /// group didn't participate in the match:
+    ///
+    /// ```rust
+    /// # use regex::bytes::Regex;
+    /// let re = Regex::new(r"[a-z]+(?:([0-9]+)|([A-Z]+))").unwrap();
+    /// let caps = re.captures(b"abc123").unwrap();
+    ///
+    /// let text1 = caps.get(1).map_or(&b""[..], |m| m.as_bytes());
+    /// let text2 = caps.get(2).map_or(&b""[..], |m| m.as_bytes());
+    /// assert_eq!(text1, &b"123"[..]);
+    /// assert_eq!(text2, &b""[..]);
+    /// ```
+    pub fn get(&self, i: usize) -> Option<Match<'t>> {
+        self.locs.pos(i).map(|(s, e)| Match::new(self.text, s, e))
+    }
+
+    /// Returns the match for the capture group named `name`. If `name` isn't a
+    /// valid capture group or didn't match anything, then `None` is returned.
+    pub fn name(&self, name: &str) -> Option<Match<'t>> {
+        self.named_groups.get(name).and_then(|&i| self.get(i))
+    }
+
+    /// An iterator that yields all capturing matches in the order in which
+    /// they appear in the regex. If a particular capture group didn't
+    /// participate in the match, then `None` is yielded for that capture.
+    ///
+    /// The first match always corresponds to the overall match of the regex.
+    pub fn iter<'c>(&'c self) -> SubCaptureMatches<'c, 't> {
+        SubCaptureMatches { caps: self, it: self.locs.iter() }
+    }
+
+    /// Expands all instances of `$name` in `replacement` to the corresponding
+    /// capture group `name`, and writes them to the `dst` buffer given.
+    ///
+    /// `name` may be an integer corresponding to the index of the capture
+    /// group (counted by order of opening parenthesis where `0` is the
+    /// entire match) or it can be a name (consisting of letters, digits or
+    /// underscores) corresponding to a named capture group.
+    ///
+    /// If `name` isn't a valid capture group (whether the name doesn't exist
+    /// or isn't a valid index), then it is replaced with the empty string.
+    ///
+    /// The longest possible name consisting of the characters `[_0-9A-Za-z]`
+    /// is used. e.g., `$1a` looks up the capture group named `1a` and not the
+    /// capture group at index `1`. To exert more precise control over the
+    /// name, or to refer to a capture group name that uses characters outside
+    /// of `[_0-9A-Za-z]`, use braces, e.g., `${1}a` or `${foo[bar].baz}`. When
+    /// using braces, any sequence of valid UTF-8 bytes is permitted. If the
+    /// sequence does not refer to a capture group name in the corresponding
+    /// regex, then it is replaced with an empty string.
+    ///
+    /// To write a literal `$` use `$$`.
+    pub fn expand(&self, replacement: &[u8], dst: &mut Vec<u8>) {
+        expand_bytes(self, replacement, dst)
+    }
+
+    /// Returns the total number of capture groups (even if they didn't match).
+    ///
+    /// This is always at least `1`, since every regex has at least one capture
+    /// group that corresponds to the full match.
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.locs.len()
+    }
+}
+
+impl<'t> fmt::Debug for Captures<'t> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_tuple("Captures").field(&CapturesDebug(self)).finish()
+    }
+}
+
+struct CapturesDebug<'c, 't>(&'c Captures<'t>);
+
+impl<'c, 't> fmt::Debug for CapturesDebug<'c, 't> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fn escape_bytes(bytes: &[u8]) -> String {
+            let mut s = String::new();
+            for &b in bytes {
+                s.push_str(&escape_byte(b));
+            }
+            s
+        }
+
+        fn escape_byte(byte: u8) -> String {
+            use std::ascii::escape_default;
+
+            let escaped: Vec<u8> = escape_default(byte).collect();
+            String::from_utf8_lossy(&escaped).into_owned()
+        }
+
+        // We'd like to show something nice here, even if it means an
+        // allocation to build a reverse index.
+        let slot_to_name: HashMap<&usize, &String> =
+            self.0.named_groups.iter().map(|(a, b)| (b, a)).collect();
+        let mut map = f.debug_map();
+        for (slot, m) in self.0.locs.iter().enumerate() {
+            let m = m.map(|(s, e)| escape_bytes(&self.0.text[s..e]));
+            if let Some(name) = slot_to_name.get(&slot) {
+                map.entry(&name, &m);
+            } else {
+                map.entry(&slot, &m);
+            }
+        }
+        map.finish()
+    }
+}
+
+/// Get a group by index.
+///
+/// `'t` is the lifetime of the matched text.
+///
+/// The text can't outlive the `Captures` object if this method is
+/// used, because of how `Index` is defined (normally `a[i]` is part
+/// of `a` and can't outlive it); to do that, use `get()` instead.
+///
+/// # Panics
+///
+/// If there is no group at the given index.
+impl<'t> Index<usize> for Captures<'t> {
+    type Output = [u8];
+
+    fn index(&self, i: usize) -> &[u8] {
+        self.get(i)
+            .map(|m| m.as_bytes())
+            .unwrap_or_else(|| panic!("no group at index '{}'", i))
+    }
+}
+
+/// Get a group by name.
+///
+/// `'t` is the lifetime of the matched text and `'i` is the lifetime
+/// of the group name (the index).
+///
+/// The text can't outlive the `Captures` object if this method is
+/// used, because of how `Index` is defined (normally `a[i]` is part
+/// of `a` and can't outlive it); to do that, use `name` instead.
+///
+/// # Panics
+///
+/// If there is no group named by the given value.
+impl<'t, 'i> Index<&'i str> for Captures<'t> {
+    type Output = [u8];
+
+    fn index<'a>(&'a self, name: &'i str) -> &'a [u8] {
+        self.name(name)
+            .map(|m| m.as_bytes())
+            .unwrap_or_else(|| panic!("no group named '{}'", name))
+    }
+}
+
+/// An iterator that yields all capturing matches in the order in which they
+/// appear in the regex.
+///
+/// If a particular capture group didn't participate in the match, then `None`
+/// is yielded for that capture. The first match always corresponds to the
+/// overall match of the regex.
+///
+/// The lifetime `'c` corresponds to the lifetime of the `Captures` value, and
+/// the lifetime `'t` corresponds to the originally matched text.
+#[derive(Clone, Debug)]
+pub struct SubCaptureMatches<'c, 't> {
+    caps: &'c Captures<'t>,
+    it: SubCapturesPosIter<'c>,
+}
+
+impl<'c, 't> Iterator for SubCaptureMatches<'c, 't> {
+    type Item = Option<Match<'t>>;
+
+    fn next(&mut self) -> Option<Option<Match<'t>>> {
+        self.it
+            .next()
+            .map(|cap| cap.map(|(s, e)| Match::new(self.caps.text, s, e)))
+    }
+}
+
+impl<'c, 't> FusedIterator for SubCaptureMatches<'c, 't> {}
+
+/// Replacer describes types that can be used to replace matches in a byte
+/// string.
+///
+/// In general, users of this crate shouldn't need to implement this trait,
+/// since implementations are already provided for `&[u8]` along with other
+/// variants of bytes types and `FnMut(&Captures) -> Vec<u8>` (or any
+/// `FnMut(&Captures) -> T` where `T: AsRef<[u8]>`), which covers most use cases.
+pub trait Replacer {
+    /// Appends text to `dst` to replace the current match.
+    ///
+    /// The current match is represented by `caps`, which is guaranteed to
+    /// have a match at capture group `0`.
+    ///
+    /// For example, a no-op replacement would be
+    /// `dst.extend(&caps[0])`.
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut Vec<u8>);
+
+    /// Return a fixed unchanging replacement byte string.
+    ///
+    /// When doing replacements, if access to `Captures` is not needed (e.g.,
+    /// the replacement byte string does not need `$` expansion), then it can
+    /// be beneficial to avoid finding sub-captures.
+    ///
+    /// In general, this is called once for every call to `replacen`.
+    fn no_expansion<'r>(&'r mut self) -> Option<Cow<'r, [u8]>> {
+        None
+    }
+
+    /// Return a `Replacer` that borrows and wraps this `Replacer`.
+    ///
+    /// This is useful when you want to take a generic `Replacer` (which might
+    /// not be cloneable) and use it without consuming it, so it can be used
+    /// more than once.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex::bytes::{Regex, Replacer};
+    ///
+    /// fn replace_all_twice<R: Replacer>(
+    ///     re: Regex,
+    ///     src: &[u8],
+    ///     mut rep: R,
+    /// ) -> Vec<u8> {
+    ///     let dst = re.replace_all(src, rep.by_ref());
+    ///     let dst = re.replace_all(&dst, rep.by_ref());
+    ///     dst.into_owned()
+    /// }
+    /// ```
+    fn by_ref<'r>(&'r mut self) -> ReplacerRef<'r, Self> {
+        ReplacerRef(self)
+    }
+}
+
+/// By-reference adaptor for a `Replacer`
+///
+/// Returned by [`Replacer::by_ref`](trait.Replacer.html#method.by_ref).
+#[derive(Debug)]
+pub struct ReplacerRef<'a, R: ?Sized>(&'a mut R);
+
+impl<'a, R: Replacer + ?Sized + 'a> Replacer for ReplacerRef<'a, R> {
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut Vec<u8>) {
+        self.0.replace_append(caps, dst)
+    }
+    fn no_expansion<'r>(&'r mut self) -> Option<Cow<'r, [u8]>> {
+        self.0.no_expansion()
+    }
+}
+
+impl<'a> Replacer for &'a [u8] {
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut Vec<u8>) {
+        caps.expand(*self, dst);
+    }
+
+    fn no_expansion(&mut self) -> Option<Cow<'_, [u8]>> {
+        no_expansion(self)
+    }
+}
+
+impl<'a> Replacer for &'a Vec<u8> {
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut Vec<u8>) {
+        caps.expand(*self, dst);
+    }
+
+    fn no_expansion(&mut self) -> Option<Cow<'_, [u8]>> {
+        no_expansion(self)
+    }
+}
+
+impl Replacer for Vec<u8> {
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut Vec<u8>) {
+        caps.expand(self, dst);
+    }
+
+    fn no_expansion(&mut self) -> Option<Cow<'_, [u8]>> {
+        no_expansion(self)
+    }
+}
+
+impl<'a> Replacer for Cow<'a, [u8]> {
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut Vec<u8>) {
+        caps.expand(self.as_ref(), dst);
+    }
+
+    fn no_expansion(&mut self) -> Option<Cow<'_, [u8]>> {
+        no_expansion(self)
+    }
+}
+
+impl<'a> Replacer for &'a Cow<'a, [u8]> {
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut Vec<u8>) {
+        caps.expand(self.as_ref(), dst);
+    }
+
+    fn no_expansion(&mut self) -> Option<Cow<'_, [u8]>> {
+        no_expansion(self)
+    }
+}
+
+fn no_expansion<T: AsRef<[u8]>>(t: &T) -> Option<Cow<'_, [u8]>> {
+    let s = t.as_ref();
+    match find_byte(b'$', s) {
+        Some(_) => None,
+        None => Some(Cow::Borrowed(s)),
+    }
+}
+
+impl<F, T> Replacer for F
+where
+    F: FnMut(&Captures<'_>) -> T,
+    T: AsRef<[u8]>,
+{
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut Vec<u8>) {
+        dst.extend_from_slice((*self)(caps).as_ref());
+    }
+}
+
+/// `NoExpand` indicates literal byte string replacement.
+///
+/// It can be used with `replace` and `replace_all` to do a literal byte string
+/// replacement without expanding `$name` to their corresponding capture
+/// groups. This can be both convenient (to avoid escaping `$`, for example)
+/// and performant (since capture groups don't need to be found).
+///
+/// `'t` is the lifetime of the literal text.
+#[derive(Clone, Debug)]
+pub struct NoExpand<'t>(pub &'t [u8]);
+
+impl<'t> Replacer for NoExpand<'t> {
+    fn replace_append(&mut self, _: &Captures<'_>, dst: &mut Vec<u8>) {
+        dst.extend_from_slice(self.0);
+    }
+
+    fn no_expansion(&mut self) -> Option<Cow<'_, [u8]>> {
+        Some(Cow::Borrowed(self.0))
+    }
+}
diff --git a/crates/regex/src/re_set.rs b/crates/regex/src/re_set.rs
new file mode 100644
index 0000000..a6d886d
--- /dev/null
+++ b/crates/regex/src/re_set.rs
@@ -0,0 +1,507 @@
+macro_rules! define_set {
+    ($name:ident, $builder_mod:ident, $text_ty:ty, $as_bytes:expr,
+     $(#[$doc_regexset_example:meta])* ) => {
+        pub mod $name {
+            use std::fmt;
+            use std::iter;
+            use std::slice;
+            use std::vec;
+
+            use crate::error::Error;
+            use crate::exec::Exec;
+            use crate::re_builder::$builder_mod::RegexSetBuilder;
+            use crate::re_trait::RegularExpression;
+
+/// Match multiple (possibly overlapping) regular expressions in a single scan.
+///
+/// A regex set corresponds to the union of two or more regular expressions.
+/// That is, a regex set will match text where at least one of its
+/// constituent regular expressions matches. A regex set as its formulated here
+/// provides a touch more power: it will also report *which* regular
+/// expressions in the set match. Indeed, this is the key difference between
+/// regex sets and a single `Regex` with many alternates, since only one
+/// alternate can match at a time.
+///
+/// For example, consider regular expressions to match email addresses and
+/// domains: `[a-z]+@[a-z]+\.(com|org|net)` and `[a-z]+\.(com|org|net)`. If a
+/// regex set is constructed from those regexes, then searching the text
+/// `foo@example.com` will report both regexes as matching. Of course, one
+/// could accomplish this by compiling each regex on its own and doing two
+/// searches over the text. The key advantage of using a regex set is that it
+/// will report the matching regexes using a *single pass through the text*.
+/// If one has hundreds or thousands of regexes to match repeatedly (like a URL
+/// router for a complex web application or a user agent matcher), then a regex
+/// set can realize huge performance gains.
+///
+/// # Example
+///
+/// This shows how the above two regexes (for matching email addresses and
+/// domains) might work:
+///
+$(#[$doc_regexset_example])*
+///
+/// Note that it would be possible to adapt the above example to using `Regex`
+/// with an expression like:
+///
+/// ```text
+/// (?P<email>[a-z]+@(?P<email_domain>[a-z]+[.](com|org|net)))|(?P<domain>[a-z]+[.](com|org|net))
+/// ```
+///
+/// After a match, one could then inspect the capture groups to figure out
+/// which alternates matched. The problem is that it is hard to make this
+/// approach scale when there are many regexes since the overlap between each
+/// alternate isn't always obvious to reason about.
+///
+/// # Limitations
+///
+/// Regex sets are limited to answering the following two questions:
+///
+/// 1. Does any regex in the set match?
+/// 2. If so, which regexes in the set match?
+///
+/// As with the main [`Regex`][crate::Regex] type, it is cheaper to ask (1)
+/// instead of (2) since the matching engines can stop after the first match
+/// is found.
+///
+/// You cannot directly extract [`Match`][crate::Match] or
+/// [`Captures`][crate::Captures] objects from a regex set. If you need these
+/// operations, the recommended approach is to compile each pattern in the set
+/// independently and scan the exact same input a second time with those
+/// independently compiled patterns:
+///
+/// ```rust
+/// use regex::{Regex, RegexSet};
+///
+/// let patterns = ["foo", "bar"];
+/// // Both patterns will match different ranges of this string.
+/// let text = "barfoo";
+///
+/// // Compile a set matching any of our patterns.
+/// let set = RegexSet::new(&patterns).unwrap();
+/// // Compile each pattern independently.
+/// let regexes: Vec<_> = set.patterns().iter()
+///     .map(|pat| Regex::new(pat).unwrap())
+///     .collect();
+///
+/// // Match against the whole set first and identify the individual
+/// // matching patterns.
+/// let matches: Vec<&str> = set.matches(text).into_iter()
+///     // Dereference the match index to get the corresponding
+///     // compiled pattern.
+///     .map(|match_idx| &regexes[match_idx])
+///     // To get match locations or any other info, we then have to search
+///     // the exact same text again, using our separately-compiled pattern.
+///     .map(|pat| pat.find(text).unwrap().as_str())
+///     .collect();
+///
+/// // Matches arrive in the order the constituent patterns were declared,
+/// // not the order they appear in the input.
+/// assert_eq!(vec!["foo", "bar"], matches);
+/// ```
+///
+/// # Performance
+///
+/// A `RegexSet` has the same performance characteristics as `Regex`. Namely,
+/// search takes `O(mn)` time, where `m` is proportional to the size of the
+/// regex set and `n` is proportional to the length of the search text.
+#[derive(Clone)]
+pub struct RegexSet(Exec);
+
+impl RegexSet {
+    /// Create a new regex set with the given regular expressions.
+    ///
+    /// This takes an iterator of `S`, where `S` is something that can produce
+    /// a `&str`. If any of the strings in the iterator are not valid regular
+    /// expressions, then an error is returned.
+    ///
+    /// # Example
+    ///
+    /// Create a new regex set from an iterator of strings:
+    ///
+    /// ```rust
+    /// # use regex::RegexSet;
+    /// let set = RegexSet::new(&[r"\w+", r"\d+"]).unwrap();
+    /// assert!(set.is_match("foo"));
+    /// ```
+    pub fn new<I, S>(exprs: I) -> Result<RegexSet, Error>
+            where S: AsRef<str>, I: IntoIterator<Item=S> {
+        RegexSetBuilder::new(exprs).build()
+    }
+
+    /// Create a new empty regex set.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # use regex::RegexSet;
+    /// let set = RegexSet::empty();
+    /// assert!(set.is_empty());
+    /// ```
+    pub fn empty() -> RegexSet {
+        RegexSetBuilder::new(&[""; 0]).build().unwrap()
+    }
+
+    /// Returns true if and only if one of the regexes in this set matches
+    /// the text given.
+    ///
+    /// This method should be preferred if you only need to test whether any
+    /// of the regexes in the set should match, but don't care about *which*
+    /// regexes matched. This is because the underlying matching engine will
+    /// quit immediately after seeing the first match instead of continuing to
+    /// find all matches.
+    ///
+    /// Note that as with searches using `Regex`, the expression is unanchored
+    /// by default. That is, if the regex does not start with `^` or `\A`, or
+    /// end with `$` or `\z`, then it is permitted to match anywhere in the
+    /// text.
+    ///
+    /// # Example
+    ///
+    /// Tests whether a set matches some text:
+    ///
+    /// ```rust
+    /// # use regex::RegexSet;
+    /// let set = RegexSet::new(&[r"\w+", r"\d+"]).unwrap();
+    /// assert!(set.is_match("foo"));
+    /// assert!(!set.is_match("☃"));
+    /// ```
+    pub fn is_match(&self, text: $text_ty) -> bool {
+        self.is_match_at(text, 0)
+    }
+
+    /// Returns the same as is_match, but starts the search at the given
+    /// offset.
+    ///
+    /// The significance of the starting point is that it takes the surrounding
+    /// context into consideration. For example, the `\A` anchor can only
+    /// match when `start == 0`.
+    #[doc(hidden)]
+    pub fn is_match_at(&self, text: $text_ty, start: usize) -> bool {
+        self.0.searcher().is_match_at($as_bytes(text), start)
+    }
+
+    /// Returns the set of regular expressions that match in the given text.
+    ///
+    /// The set returned contains the index of each regular expression that
+    /// matches in the given text. The index is in correspondence with the
+    /// order of regular expressions given to `RegexSet`'s constructor.
+    ///
+    /// The set can also be used to iterate over the matched indices.
+    ///
+    /// Note that as with searches using `Regex`, the expression is unanchored
+    /// by default. That is, if the regex does not start with `^` or `\A`, or
+    /// end with `$` or `\z`, then it is permitted to match anywhere in the
+    /// text.
+    ///
+    /// # Example
+    ///
+    /// Tests which regular expressions match the given text:
+    ///
+    /// ```rust
+    /// # use regex::RegexSet;
+    /// let set = RegexSet::new(&[
+    ///     r"\w+",
+    ///     r"\d+",
+    ///     r"\pL+",
+    ///     r"foo",
+    ///     r"bar",
+    ///     r"barfoo",
+    ///     r"foobar",
+    /// ]).unwrap();
+    /// let matches: Vec<_> = set.matches("foobar").into_iter().collect();
+    /// assert_eq!(matches, vec![0, 2, 3, 4, 6]);
+    ///
+    /// // You can also test whether a particular regex matched:
+    /// let matches = set.matches("foobar");
+    /// assert!(!matches.matched(5));
+    /// assert!(matches.matched(6));
+    /// ```
+    pub fn matches(&self, text: $text_ty) -> SetMatches {
+        let mut matches = vec![false; self.0.regex_strings().len()];
+        let any = self.read_matches_at(&mut matches, text, 0);
+        SetMatches {
+            matched_any: any,
+            matches: matches,
+        }
+    }
+
+    /// Returns the same as matches, but starts the search at the given
+    /// offset and stores the matches into the slice given.
+    ///
+    /// The significance of the starting point is that it takes the surrounding
+    /// context into consideration. For example, the `\A` anchor can only
+    /// match when `start == 0`.
+    ///
+    /// `matches` must have a length that is at least the number of regexes
+    /// in this set.
+    ///
+    /// This method returns true if and only if at least one member of
+    /// `matches` is true after executing the set against `text`.
+    #[doc(hidden)]
+    pub fn read_matches_at(
+        &self,
+        matches: &mut [bool],
+        text: $text_ty,
+        start: usize,
+    ) -> bool {
+        self.0.searcher().many_matches_at(matches, $as_bytes(text), start)
+    }
+
+    /// Returns the total number of regular expressions in this set.
+    pub fn len(&self) -> usize {
+        self.0.regex_strings().len()
+    }
+
+    /// Returns `true` if this set contains no regular expressions.
+    pub fn is_empty(&self) -> bool {
+        self.0.regex_strings().is_empty()
+    }
+
+    /// Returns the patterns that this set will match on.
+    ///
+    /// This function can be used to determine the pattern for a match. The
+    /// slice returned has exactly as many patterns givens to this regex set,
+    /// and the order of the slice is the same as the order of the patterns
+    /// provided to the set.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # use regex::RegexSet;
+    /// let set = RegexSet::new(&[
+    ///     r"\w+",
+    ///     r"\d+",
+    ///     r"\pL+",
+    ///     r"foo",
+    ///     r"bar",
+    ///     r"barfoo",
+    ///     r"foobar",
+    /// ]).unwrap();
+    /// let matches: Vec<_> = set
+    ///     .matches("foobar")
+    ///     .into_iter()
+    ///     .map(|match_idx| &set.patterns()[match_idx])
+    ///     .collect();
+    /// assert_eq!(matches, vec![r"\w+", r"\pL+", r"foo", r"bar", r"foobar"]);
+    /// ```
+    pub fn patterns(&self) -> &[String] {
+        self.0.regex_strings()
+    }
+}
+
+/// A set of matches returned by a regex set.
+#[derive(Clone, Debug)]
+pub struct SetMatches {
+    matched_any: bool,
+    matches: Vec<bool>,
+}
+
+impl SetMatches {
+    /// Whether this set contains any matches.
+    pub fn matched_any(&self) -> bool {
+        self.matched_any
+    }
+
+    /// Whether the regex at the given index matched.
+    ///
+    /// The index for a regex is determined by its insertion order upon the
+    /// initial construction of a `RegexSet`, starting at `0`.
+    ///
+    /// # Panics
+    ///
+    /// If `regex_index` is greater than or equal to `self.len()`.
+    pub fn matched(&self, regex_index: usize) -> bool {
+        self.matches[regex_index]
+    }
+
+    /// The total number of regexes in the set that created these matches.
+    pub fn len(&self) -> usize {
+        self.matches.len()
+    }
+
+    /// Returns an iterator over indexes in the regex that matched.
+    ///
+    /// This will always produces matches in ascending order of index, where
+    /// the index corresponds to the index of the regex that matched with
+    /// respect to its position when initially building the set.
+    pub fn iter(&self) -> SetMatchesIter<'_> {
+        SetMatchesIter((&*self.matches).into_iter().enumerate())
+    }
+}
+
+impl IntoIterator for SetMatches {
+    type IntoIter = SetMatchesIntoIter;
+    type Item = usize;
+
+    fn into_iter(self) -> Self::IntoIter {
+        SetMatchesIntoIter(self.matches.into_iter().enumerate())
+    }
+}
+
+impl<'a> IntoIterator for &'a SetMatches {
+    type IntoIter = SetMatchesIter<'a>;
+    type Item = usize;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
+
+/// An owned iterator over the set of matches from a regex set.
+///
+/// This will always produces matches in ascending order of index, where the
+/// index corresponds to the index of the regex that matched with respect to
+/// its position when initially building the set.
+#[derive(Debug)]
+pub struct SetMatchesIntoIter(iter::Enumerate<vec::IntoIter<bool>>);
+
+impl Iterator for SetMatchesIntoIter {
+    type Item = usize;
+
+    fn next(&mut self) -> Option<usize> {
+        loop {
+            match self.0.next() {
+                None => return None,
+                Some((_, false)) => {}
+                Some((i, true)) => return Some(i),
+            }
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.0.size_hint()
+    }
+}
+
+impl DoubleEndedIterator for SetMatchesIntoIter {
+    fn next_back(&mut self) -> Option<usize> {
+        loop {
+            match self.0.next_back() {
+                None => return None,
+                Some((_, false)) => {}
+                Some((i, true)) => return Some(i),
+            }
+        }
+    }
+}
+
+impl iter::FusedIterator for SetMatchesIntoIter {}
+
+/// A borrowed iterator over the set of matches from a regex set.
+///
+/// The lifetime `'a` refers to the lifetime of a `SetMatches` value.
+///
+/// This will always produces matches in ascending order of index, where the
+/// index corresponds to the index of the regex that matched with respect to
+/// its position when initially building the set.
+#[derive(Clone, Debug)]
+pub struct SetMatchesIter<'a>(iter::Enumerate<slice::Iter<'a, bool>>);
+
+impl<'a> Iterator for SetMatchesIter<'a> {
+    type Item = usize;
+
+    fn next(&mut self) -> Option<usize> {
+        loop {
+            match self.0.next() {
+                None => return None,
+                Some((_, &false)) => {}
+                Some((i, &true)) => return Some(i),
+            }
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.0.size_hint()
+    }
+}
+
+impl<'a> DoubleEndedIterator for SetMatchesIter<'a> {
+    fn next_back(&mut self) -> Option<usize> {
+        loop {
+            match self.0.next_back() {
+                None => return None,
+                Some((_, &false)) => {}
+                Some((i, &true)) => return Some(i),
+            }
+        }
+    }
+}
+
+impl<'a> iter::FusedIterator for SetMatchesIter<'a> {}
+
+#[doc(hidden)]
+impl From<Exec> for RegexSet {
+    fn from(exec: Exec) -> Self {
+        RegexSet(exec)
+    }
+}
+
+impl fmt::Debug for RegexSet {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "RegexSet({:?})", self.0.regex_strings())
+    }
+}
+
+#[allow(dead_code)] fn as_bytes_str(text: &str) -> &[u8] { text.as_bytes() }
+#[allow(dead_code)] fn as_bytes_bytes(text: &[u8]) -> &[u8] { text }
+        }
+    }
+}
+
+define_set! {
+    unicode,
+    set_unicode,
+    &str,
+    as_bytes_str,
+/// ```rust
+/// # use regex::RegexSet;
+/// let set = RegexSet::new(&[
+///     r"[a-z]+@[a-z]+\.(com|org|net)",
+///     r"[a-z]+\.(com|org|net)",
+/// ]).unwrap();
+///
+/// // Ask whether any regexes in the set match.
+/// assert!(set.is_match("foo@example.com"));
+///
+/// // Identify which regexes in the set match.
+/// let matches: Vec<_> = set.matches("foo@example.com").into_iter().collect();
+/// assert_eq!(vec![0, 1], matches);
+///
+/// // Try again, but with text that only matches one of the regexes.
+/// let matches: Vec<_> = set.matches("example.com").into_iter().collect();
+/// assert_eq!(vec![1], matches);
+///
+/// // Try again, but with text that doesn't match any regex in the set.
+/// let matches: Vec<_> = set.matches("example").into_iter().collect();
+/// assert!(matches.is_empty());
+/// ```
+}
+
+define_set! {
+    bytes,
+    set_bytes,
+    &[u8],
+    as_bytes_bytes,
+/// ```rust
+/// # use regex::bytes::RegexSet;
+/// let set = RegexSet::new(&[
+///     r"[a-z]+@[a-z]+\.(com|org|net)",
+///     r"[a-z]+\.(com|org|net)",
+/// ]).unwrap();
+///
+/// // Ask whether any regexes in the set match.
+/// assert!(set.is_match(b"foo@example.com"));
+///
+/// // Identify which regexes in the set match.
+/// let matches: Vec<_> = set.matches(b"foo@example.com").into_iter().collect();
+/// assert_eq!(vec![0, 1], matches);
+///
+/// // Try again, but with text that only matches one of the regexes.
+/// let matches: Vec<_> = set.matches(b"example.com").into_iter().collect();
+/// assert_eq!(vec![1], matches);
+///
+/// // Try again, but with text that doesn't match any regex in the set.
+/// let matches: Vec<_> = set.matches(b"example").into_iter().collect();
+/// assert!(matches.is_empty());
+/// ```
+}
diff --git a/crates/regex/src/re_trait.rs b/crates/regex/src/re_trait.rs
new file mode 100644
index 0000000..d0c717d
--- /dev/null
+++ b/crates/regex/src/re_trait.rs
@@ -0,0 +1,294 @@
+use std::fmt;
+use std::iter::FusedIterator;
+
+/// Slot is a single saved capture location. Note that there are two slots for
+/// every capture in a regular expression (one slot each for the start and end
+/// of the capture).
+pub type Slot = Option<usize>;
+
+/// Locations represents the offsets of each capturing group in a regex for
+/// a single match.
+///
+/// Unlike `Captures`, a `Locations` value only stores offsets.
+#[doc(hidden)]
+#[derive(Clone, Debug)]
+pub struct Locations(Vec<Slot>);
+
+impl Locations {
+    /// Returns the start and end positions of the Nth capture group. Returns
+    /// `None` if `i` is not a valid capture group or if the capture group did
+    /// not match anything. The positions returned are *always* byte indices
+    /// with respect to the original string matched.
+    pub fn pos(&self, i: usize) -> Option<(usize, usize)> {
+        let (s, e) = (i * 2, i * 2 + 1);
+        match (self.0.get(s), self.0.get(e)) {
+            (Some(&Some(s)), Some(&Some(e))) => Some((s, e)),
+            _ => None,
+        }
+    }
+
+    /// Creates an iterator of all the capture group positions in order of
+    /// appearance in the regular expression. Positions are byte indices
+    /// in terms of the original string matched.
+    pub fn iter(&self) -> SubCapturesPosIter<'_> {
+        SubCapturesPosIter { idx: 0, locs: self }
+    }
+
+    /// Returns the total number of capturing groups.
+    ///
+    /// This is always at least `1` since every regex has at least `1`
+    /// capturing group that corresponds to the entire match.
+    pub fn len(&self) -> usize {
+        self.0.len() / 2
+    }
+
+    /// Return the individual slots as a slice.
+    pub(crate) fn as_slots(&mut self) -> &mut [Slot] {
+        &mut self.0
+    }
+}
+
+/// An iterator over capture group positions for a particular match of a
+/// regular expression.
+///
+/// Positions are byte indices in terms of the original string matched.
+///
+/// `'c` is the lifetime of the captures.
+#[derive(Clone, Debug)]
+pub struct SubCapturesPosIter<'c> {
+    idx: usize,
+    locs: &'c Locations,
+}
+
+impl<'c> Iterator for SubCapturesPosIter<'c> {
+    type Item = Option<(usize, usize)>;
+
+    fn next(&mut self) -> Option<Option<(usize, usize)>> {
+        if self.idx >= self.locs.len() {
+            return None;
+        }
+        let x = match self.locs.pos(self.idx) {
+            None => Some(None),
+            Some((s, e)) => Some(Some((s, e))),
+        };
+        self.idx += 1;
+        x
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let len = self.locs.len() - self.idx;
+        (len, Some(len))
+    }
+
+    fn count(self) -> usize {
+        self.len()
+    }
+}
+
+impl<'c> ExactSizeIterator for SubCapturesPosIter<'c> {}
+
+impl<'c> FusedIterator for SubCapturesPosIter<'c> {}
+
+/// `RegularExpression` describes types that can implement regex searching.
+///
+/// This trait is my attempt at reducing code duplication and to standardize
+/// the internal API. Specific duplication that is avoided are the `find`
+/// and `capture` iterators, which are slightly tricky.
+///
+/// It's not clear whether this trait is worth it, and it also isn't
+/// clear whether it's useful as a public trait or not. Methods like
+/// `next_after_empty` reak of bad design, but the rest of the methods seem
+/// somewhat reasonable. One particular thing this trait would expose would be
+/// the ability to start the search of a regex anywhere in a haystack, which
+/// isn't possible in the current public API.
+pub trait RegularExpression: Sized + fmt::Debug {
+    /// The type of the haystack.
+    type Text: ?Sized + fmt::Debug;
+
+    /// The number of capture slots in the compiled regular expression. This is
+    /// always two times the number of capture groups (two slots per group).
+    fn slots_len(&self) -> usize;
+
+    /// Allocates fresh space for all capturing groups in this regex.
+    fn locations(&self) -> Locations {
+        Locations(vec![None; self.slots_len()])
+    }
+
+    /// Returns the position of the next character after `i`.
+    ///
+    /// For example, a haystack with type `&[u8]` probably returns `i+1`,
+    /// whereas a haystack with type `&str` probably returns `i` plus the
+    /// length of the next UTF-8 sequence.
+    fn next_after_empty(&self, text: &Self::Text, i: usize) -> usize;
+
+    /// Returns the location of the shortest match.
+    fn shortest_match_at(
+        &self,
+        text: &Self::Text,
+        start: usize,
+    ) -> Option<usize>;
+
+    /// Returns whether the regex matches the text given.
+    fn is_match_at(&self, text: &Self::Text, start: usize) -> bool;
+
+    /// Returns the leftmost-first match location if one exists.
+    fn find_at(
+        &self,
+        text: &Self::Text,
+        start: usize,
+    ) -> Option<(usize, usize)>;
+
+    /// Returns the leftmost-first match location if one exists, and also
+    /// fills in any matching capture slot locations.
+    fn captures_read_at(
+        &self,
+        locs: &mut Locations,
+        text: &Self::Text,
+        start: usize,
+    ) -> Option<(usize, usize)>;
+
+    /// Returns an iterator over all non-overlapping successive leftmost-first
+    /// matches.
+    fn find_iter(self, text: &Self::Text) -> Matches<'_, Self> {
+        Matches { re: self, text, last_end: 0, last_match: None }
+    }
+
+    /// Returns an iterator over all non-overlapping successive leftmost-first
+    /// matches with captures.
+    fn captures_iter(self, text: &Self::Text) -> CaptureMatches<'_, Self> {
+        CaptureMatches(self.find_iter(text))
+    }
+}
+
+/// An iterator over all non-overlapping successive leftmost-first matches.
+#[derive(Debug)]
+pub struct Matches<'t, R>
+where
+    R: RegularExpression,
+    R::Text: 't,
+{
+    re: R,
+    text: &'t R::Text,
+    last_end: usize,
+    last_match: Option<usize>,
+}
+
+impl<'t, R> Matches<'t, R>
+where
+    R: RegularExpression,
+    R::Text: 't,
+{
+    /// Return the text being searched.
+    pub fn text(&self) -> &'t R::Text {
+        self.text
+    }
+
+    /// Return the underlying regex.
+    pub fn regex(&self) -> &R {
+        &self.re
+    }
+}
+
+impl<'t, R> Iterator for Matches<'t, R>
+where
+    R: RegularExpression,
+    R::Text: 't + AsRef<[u8]>,
+{
+    type Item = (usize, usize);
+
+    fn next(&mut self) -> Option<(usize, usize)> {
+        if self.last_end > self.text.as_ref().len() {
+            return None;
+        }
+        let (s, e) = match self.re.find_at(self.text, self.last_end) {
+            None => return None,
+            Some((s, e)) => (s, e),
+        };
+        if s == e {
+            // This is an empty match. To ensure we make progress, start
+            // the next search at the smallest possible starting position
+            // of the next match following this one.
+            self.last_end = self.re.next_after_empty(self.text, e);
+            // Don't accept empty matches immediately following a match.
+            // Just move on to the next match.
+            if Some(e) == self.last_match {
+                return self.next();
+            }
+        } else {
+            self.last_end = e;
+        }
+        self.last_match = Some(e);
+        Some((s, e))
+    }
+}
+
+impl<'t, R> FusedIterator for Matches<'t, R>
+where
+    R: RegularExpression,
+    R::Text: 't + AsRef<[u8]>,
+{
+}
+
+/// An iterator over all non-overlapping successive leftmost-first matches with
+/// captures.
+#[derive(Debug)]
+pub struct CaptureMatches<'t, R>(Matches<'t, R>)
+where
+    R: RegularExpression,
+    R::Text: 't;
+
+impl<'t, R> CaptureMatches<'t, R>
+where
+    R: RegularExpression,
+    R::Text: 't,
+{
+    /// Return the text being searched.
+    pub fn text(&self) -> &'t R::Text {
+        self.0.text()
+    }
+
+    /// Return the underlying regex.
+    pub fn regex(&self) -> &R {
+        self.0.regex()
+    }
+}
+
+impl<'t, R> Iterator for CaptureMatches<'t, R>
+where
+    R: RegularExpression,
+    R::Text: 't + AsRef<[u8]>,
+{
+    type Item = Locations;
+
+    fn next(&mut self) -> Option<Locations> {
+        if self.0.last_end > self.0.text.as_ref().len() {
+            return None;
+        }
+        let mut locs = self.0.re.locations();
+        let (s, e) = match self.0.re.captures_read_at(
+            &mut locs,
+            self.0.text,
+            self.0.last_end,
+        ) {
+            None => return None,
+            Some((s, e)) => (s, e),
+        };
+        if s == e {
+            self.0.last_end = self.0.re.next_after_empty(self.0.text, e);
+            if Some(e) == self.0.last_match {
+                return self.next();
+            }
+        } else {
+            self.0.last_end = e;
+        }
+        self.0.last_match = Some(e);
+        Some(locs)
+    }
+}
+
+impl<'t, R> FusedIterator for CaptureMatches<'t, R>
+where
+    R: RegularExpression,
+    R::Text: 't + AsRef<[u8]>,
+{
+}
diff --git a/crates/regex/src/re_unicode.rs b/crates/regex/src/re_unicode.rs
new file mode 100644
index 0000000..197510e
--- /dev/null
+++ b/crates/regex/src/re_unicode.rs
@@ -0,0 +1,1311 @@
+use std::borrow::Cow;
+use std::collections::HashMap;
+use std::fmt;
+use std::iter::FusedIterator;
+use std::ops::{Index, Range};
+use std::str::FromStr;
+use std::sync::Arc;
+
+use crate::find_byte::find_byte;
+
+use crate::error::Error;
+use crate::exec::{Exec, ExecNoSyncStr};
+use crate::expand::expand_str;
+use crate::re_builder::unicode::RegexBuilder;
+use crate::re_trait::{self, RegularExpression, SubCapturesPosIter};
+
+/// Escapes all regular expression meta characters in `text`.
+///
+/// The string returned may be safely used as a literal in a regular
+/// expression.
+pub fn escape(text: &str) -> String {
+    regex_syntax::escape(text)
+}
+
+/// Match represents a single match of a regex in a haystack.
+///
+/// The lifetime parameter `'t` refers to the lifetime of the matched text.
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub struct Match<'t> {
+    text: &'t str,
+    start: usize,
+    end: usize,
+}
+
+impl<'t> Match<'t> {
+    /// Returns the starting byte offset of the match in the haystack.
+    #[inline]
+    pub fn start(&self) -> usize {
+        self.start
+    }
+
+    /// Returns the ending byte offset of the match in the haystack.
+    #[inline]
+    pub fn end(&self) -> usize {
+        self.end
+    }
+
+    /// Returns the range over the starting and ending byte offsets of the
+    /// match in the haystack.
+    #[inline]
+    pub fn range(&self) -> Range<usize> {
+        self.start..self.end
+    }
+
+    /// Returns the matched text.
+    #[inline]
+    pub fn as_str(&self) -> &'t str {
+        &self.text[self.range()]
+    }
+
+    /// Creates a new match from the given haystack and byte offsets.
+    #[inline]
+    fn new(haystack: &'t str, start: usize, end: usize) -> Match<'t> {
+        Match { text: haystack, start, end }
+    }
+}
+
+impl<'t> From<Match<'t>> for &'t str {
+    fn from(m: Match<'t>) -> &'t str {
+        m.as_str()
+    }
+}
+
+impl<'t> From<Match<'t>> for Range<usize> {
+    fn from(m: Match<'t>) -> Range<usize> {
+        m.range()
+    }
+}
+
+/// A compiled regular expression for matching Unicode strings.
+///
+/// It is represented as either a sequence of bytecode instructions (dynamic)
+/// or as a specialized Rust function (native). It can be used to search, split
+/// or replace text. All searching is done with an implicit `.*?` at the
+/// beginning and end of an expression. To force an expression to match the
+/// whole string (or a prefix or a suffix), you must use an anchor like `^` or
+/// `$` (or `\A` and `\z`).
+///
+/// While this crate will handle Unicode strings (whether in the regular
+/// expression or in the search text), all positions returned are **byte
+/// indices**. Every byte index is guaranteed to be at a Unicode code point
+/// boundary.
+///
+/// The lifetimes `'r` and `'t` in this crate correspond to the lifetime of a
+/// compiled regular expression and text to search, respectively.
+///
+/// The only methods that allocate new strings are the string replacement
+/// methods. All other methods (searching and splitting) return borrowed
+/// pointers into the string given.
+///
+/// # Examples
+///
+/// Find the location of a US phone number:
+///
+/// ```rust
+/// # use regex::Regex;
+/// let re = Regex::new("[0-9]{3}-[0-9]{3}-[0-9]{4}").unwrap();
+/// let mat = re.find("phone: 111-222-3333").unwrap();
+/// assert_eq!((mat.start(), mat.end()), (7, 19));
+/// ```
+///
+/// # Using the `std::str::pattern` methods with `Regex`
+///
+/// > **Note**: This section requires that this crate is compiled with the
+/// > `pattern` Cargo feature enabled, which **requires nightly Rust**.
+///
+/// Since `Regex` implements `Pattern`, you can use regexes with methods
+/// defined on `&str`. For example, `is_match`, `find`, `find_iter`
+/// and `split` can be replaced with `str::contains`, `str::find`,
+/// `str::match_indices` and `str::split`.
+///
+/// Here are some examples:
+///
+/// ```rust,ignore
+/// # use regex::Regex;
+/// let re = Regex::new(r"\d+").unwrap();
+/// let haystack = "a111b222c";
+///
+/// assert!(haystack.contains(&re));
+/// assert_eq!(haystack.find(&re), Some(1));
+/// assert_eq!(haystack.match_indices(&re).collect::<Vec<_>>(),
+///            vec![(1, "111"), (5, "222")]);
+/// assert_eq!(haystack.split(&re).collect::<Vec<_>>(), vec!["a", "b", "c"]);
+/// ```
+#[derive(Clone)]
+pub struct Regex(Exec);
+
+impl fmt::Display for Regex {
+    /// Shows the original regular expression.
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.as_str())
+    }
+}
+
+impl fmt::Debug for Regex {
+    /// Shows the original regular expression.
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(self, f)
+    }
+}
+
+#[doc(hidden)]
+impl From<Exec> for Regex {
+    fn from(exec: Exec) -> Regex {
+        Regex(exec)
+    }
+}
+
+impl FromStr for Regex {
+    type Err = Error;
+
+    /// Attempts to parse a string into a regular expression
+    fn from_str(s: &str) -> Result<Regex, Error> {
+        Regex::new(s)
+    }
+}
+
+/// Core regular expression methods.
+impl Regex {
+    /// Compiles a regular expression. Once compiled, it can be used repeatedly
+    /// to search, split or replace text in a string.
+    ///
+    /// If an invalid expression is given, then an error is returned.
+    pub fn new(re: &str) -> Result<Regex, Error> {
+        RegexBuilder::new(re).build()
+    }
+
+    /// Returns true if and only if there is a match for the regex in the
+    /// string given.
+    ///
+    /// It is recommended to use this method if all you need to do is test
+    /// a match, since the underlying matching engine may be able to do less
+    /// work.
+    ///
+    /// # Example
+    ///
+    /// Test if some text contains at least one word with exactly 13
+    /// Unicode word characters:
+    ///
+    /// ```rust
+    /// # use regex::Regex;
+    /// # fn main() {
+    /// let text = "I categorically deny having triskaidekaphobia.";
+    /// assert!(Regex::new(r"\b\w{13}\b").unwrap().is_match(text));
+    /// # }
+    /// ```
+    pub fn is_match(&self, text: &str) -> bool {
+        self.is_match_at(text, 0)
+    }
+
+    /// Returns the start and end byte range of the leftmost-first match in
+    /// `text`. If no match exists, then `None` is returned.
+    ///
+    /// Note that this should only be used if you want to discover the position
+    /// of the match. Testing the existence of a match is faster if you use
+    /// `is_match`.
+    ///
+    /// # Example
+    ///
+    /// Find the start and end location of the first word with exactly 13
+    /// Unicode word characters:
+    ///
+    /// ```rust
+    /// # use regex::Regex;
+    /// # fn main() {
+    /// let text = "I categorically deny having triskaidekaphobia.";
+    /// let mat = Regex::new(r"\b\w{13}\b").unwrap().find(text).unwrap();
+    /// assert_eq!(mat.start(), 2);
+    /// assert_eq!(mat.end(), 15);
+    /// # }
+    /// ```
+    pub fn find<'t>(&self, text: &'t str) -> Option<Match<'t>> {
+        self.find_at(text, 0)
+    }
+
+    /// Returns an iterator for each successive non-overlapping match in
+    /// `text`, returning the start and end byte indices with respect to
+    /// `text`.
+    ///
+    /// # Example
+    ///
+    /// Find the start and end location of every word with exactly 13 Unicode
+    /// word characters:
+    ///
+    /// ```rust
+    /// # use regex::Regex;
+    /// # fn main() {
+    /// let text = "Retroactively relinquishing remunerations is reprehensible.";
+    /// for mat in Regex::new(r"\b\w{13}\b").unwrap().find_iter(text) {
+    ///     println!("{:?}", mat);
+    /// }
+    /// # }
+    /// ```
+    pub fn find_iter<'r, 't>(&'r self, text: &'t str) -> Matches<'r, 't> {
+        Matches(self.0.searcher_str().find_iter(text))
+    }
+
+    /// Returns the capture groups corresponding to the leftmost-first
+    /// match in `text`. Capture group `0` always corresponds to the entire
+    /// match. If no match is found, then `None` is returned.
+    ///
+    /// You should only use `captures` if you need access to the location of
+    /// capturing group matches. Otherwise, `find` is faster for discovering
+    /// the location of the overall match.
+    ///
+    /// # Examples
+    ///
+    /// Say you have some text with movie names and their release years,
+    /// like "'Citizen Kane' (1941)". It'd be nice if we could search for text
+    /// looking like that, while also extracting the movie name and its release
+    /// year separately.
+    ///
+    /// ```rust
+    /// # use regex::Regex;
+    /// # fn main() {
+    /// let re = Regex::new(r"'([^']+)'\s+\((\d{4})\)").unwrap();
+    /// let text = "Not my favorite movie: 'Citizen Kane' (1941).";
+    /// let caps = re.captures(text).unwrap();
+    /// assert_eq!(caps.get(1).unwrap().as_str(), "Citizen Kane");
+    /// assert_eq!(caps.get(2).unwrap().as_str(), "1941");
+    /// assert_eq!(caps.get(0).unwrap().as_str(), "'Citizen Kane' (1941)");
+    /// // You can also access the groups by index using the Index notation.
+    /// // Note that this will panic on an invalid index.
+    /// assert_eq!(&caps[1], "Citizen Kane");
+    /// assert_eq!(&caps[2], "1941");
+    /// assert_eq!(&caps[0], "'Citizen Kane' (1941)");
+    /// # }
+    /// ```
+    ///
+    /// Note that the full match is at capture group `0`. Each subsequent
+    /// capture group is indexed by the order of its opening `(`.
+    ///
+    /// We can make this example a bit clearer by using *named* capture groups:
+    ///
+    /// ```rust
+    /// # use regex::Regex;
+    /// # fn main() {
+    /// let re = Regex::new(r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)")
+    ///                .unwrap();
+    /// let text = "Not my favorite movie: 'Citizen Kane' (1941).";
+    /// let caps = re.captures(text).unwrap();
+    /// assert_eq!(caps.name("title").unwrap().as_str(), "Citizen Kane");
+    /// assert_eq!(caps.name("year").unwrap().as_str(), "1941");
+    /// assert_eq!(caps.get(0).unwrap().as_str(), "'Citizen Kane' (1941)");
+    /// // You can also access the groups by name using the Index notation.
+    /// // Note that this will panic on an invalid group name.
+    /// assert_eq!(&caps["title"], "Citizen Kane");
+    /// assert_eq!(&caps["year"], "1941");
+    /// assert_eq!(&caps[0], "'Citizen Kane' (1941)");
+    ///
+    /// # }
+    /// ```
+    ///
+    /// Here we name the capture groups, which we can access with the `name`
+    /// method or the `Index` notation with a `&str`. Note that the named
+    /// capture groups are still accessible with `get` or the `Index` notation
+    /// with a `usize`.
+    ///
+    /// The `0`th capture group is always unnamed, so it must always be
+    /// accessed with `get(0)` or `[0]`.
+    pub fn captures<'t>(&self, text: &'t str) -> Option<Captures<'t>> {
+        let mut locs = self.capture_locations();
+        self.captures_read_at(&mut locs, text, 0).map(move |_| Captures {
+            text,
+            locs: locs.0,
+            named_groups: self.0.capture_name_idx().clone(),
+        })
+    }
+
+    /// Returns an iterator over all the non-overlapping capture groups matched
+    /// in `text`. This is operationally the same as `find_iter`, except it
+    /// yields information about capturing group matches.
+    ///
+    /// # Example
+    ///
+    /// We can use this to find all movie titles and their release years in
+    /// some text, where the movie is formatted like "'Title' (xxxx)":
+    ///
+    /// ```rust
+    /// # use regex::Regex;
+    /// # fn main() {
+    /// let re = Regex::new(r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)")
+    ///                .unwrap();
+    /// let text = "'Citizen Kane' (1941), 'The Wizard of Oz' (1939), 'M' (1931).";
+    /// for caps in re.captures_iter(text) {
+    ///     println!("Movie: {:?}, Released: {:?}",
+    ///              &caps["title"], &caps["year"]);
+    /// }
+    /// // Output:
+    /// // Movie: Citizen Kane, Released: 1941
+    /// // Movie: The Wizard of Oz, Released: 1939
+    /// // Movie: M, Released: 1931
+    /// # }
+    /// ```
+    pub fn captures_iter<'r, 't>(
+        &'r self,
+        text: &'t str,
+    ) -> CaptureMatches<'r, 't> {
+        CaptureMatches(self.0.searcher_str().captures_iter(text))
+    }
+
+    /// Returns an iterator of substrings of `text` delimited by a match of the
+    /// regular expression. Namely, each element of the iterator corresponds to
+    /// text that *isn't* matched by the regular expression.
+    ///
+    /// This method will *not* copy the text given.
+    ///
+    /// # Example
+    ///
+    /// To split a string delimited by arbitrary amounts of spaces or tabs:
+    ///
+    /// ```rust
+    /// # use regex::Regex;
+    /// # fn main() {
+    /// let re = Regex::new(r"[ \t]+").unwrap();
+    /// let fields: Vec<&str> = re.split("a b \t  c\td    e").collect();
+    /// assert_eq!(fields, vec!["a", "b", "c", "d", "e"]);
+    /// # }
+    /// ```
+    pub fn split<'r, 't>(&'r self, text: &'t str) -> Split<'r, 't> {
+        Split { finder: self.find_iter(text), last: 0 }
+    }
+
+    /// Returns an iterator of at most `limit` substrings of `text` delimited
+    /// by a match of the regular expression. (A `limit` of `0` will return no
+    /// substrings.) Namely, each element of the iterator corresponds to text
+    /// that *isn't* matched by the regular expression. The remainder of the
+    /// string that is not split will be the last element in the iterator.
+    ///
+    /// This method will *not* copy the text given.
+    ///
+    /// # Example
+    ///
+    /// Get the first two words in some text:
+    ///
+    /// ```rust
+    /// # use regex::Regex;
+    /// # fn main() {
+    /// let re = Regex::new(r"\W+").unwrap();
+    /// let fields: Vec<&str> = re.splitn("Hey! How are you?", 3).collect();
+    /// assert_eq!(fields, vec!("Hey", "How", "are you?"));
+    /// # }
+    /// ```
+    pub fn splitn<'r, 't>(
+        &'r self,
+        text: &'t str,
+        limit: usize,
+    ) -> SplitN<'r, 't> {
+        SplitN { splits: self.split(text), n: limit }
+    }
+
+    /// Replaces the leftmost-first match with the replacement provided.
+    /// The replacement can be a regular string (where `$N` and `$name` are
+    /// expanded to match capture groups) or a function that takes the matches'
+    /// `Captures` and returns the replaced string.
+    ///
+    /// If no match is found, then a copy of the string is returned unchanged.
+    ///
+    /// # Replacement string syntax
+    ///
+    /// All instances of `$name` in the replacement text is replaced with the
+    /// corresponding capture group `name`.
+    ///
+    /// `name` may be an integer corresponding to the index of the
+    /// capture group (counted by order of opening parenthesis where `0` is the
+    /// entire match) or it can be a name (consisting of letters, digits or
+    /// underscores) corresponding to a named capture group.
+    ///
+    /// If `name` isn't a valid capture group (whether the name doesn't exist
+    /// or isn't a valid index), then it is replaced with the empty string.
+    ///
+    /// The longest possible name is used. e.g., `$1a` looks up the capture
+    /// group named `1a` and not the capture group at index `1`. To exert more
+    /// precise control over the name, use braces, e.g., `${1}a`.
+    ///
+    /// To write a literal `$` use `$$`.
+    ///
+    /// # Examples
+    ///
+    /// Note that this function is polymorphic with respect to the replacement.
+    /// In typical usage, this can just be a normal string:
+    ///
+    /// ```rust
+    /// # use regex::Regex;
+    /// # fn main() {
+    /// let re = Regex::new("[^01]+").unwrap();
+    /// assert_eq!(re.replace("1078910", ""), "1010");
+    /// # }
+    /// ```
+    ///
+    /// But anything satisfying the `Replacer` trait will work. For example,
+    /// a closure of type `|&Captures| -> String` provides direct access to the
+    /// captures corresponding to a match. This allows one to access
+    /// capturing group matches easily:
+    ///
+    /// ```rust
+    /// # use regex::Regex;
+    /// # use regex::Captures; fn main() {
+    /// let re = Regex::new(r"([^,\s]+),\s+(\S+)").unwrap();
+    /// let result = re.replace("Springsteen, Bruce", |caps: &Captures| {
+    ///     format!("{} {}", &caps[2], &caps[1])
+    /// });
+    /// assert_eq!(result, "Bruce Springsteen");
+    /// # }
+    /// ```
+    ///
+    /// But this is a bit cumbersome to use all the time. Instead, a simple
+    /// syntax is supported that expands `$name` into the corresponding capture
+    /// group. Here's the last example, but using this expansion technique
+    /// with named capture groups:
+    ///
+    /// ```rust
+    /// # use regex::Regex;
+    /// # fn main() {
+    /// let re = Regex::new(r"(?P<last>[^,\s]+),\s+(?P<first>\S+)").unwrap();
+    /// let result = re.replace("Springsteen, Bruce", "$first $last");
+    /// assert_eq!(result, "Bruce Springsteen");
+    /// # }
+    /// ```
+    ///
+    /// Note that using `$2` instead of `$first` or `$1` instead of `$last`
+    /// would produce the same result. To write a literal `$` use `$$`.
+    ///
+    /// Sometimes the replacement string requires use of curly braces to
+    /// delineate a capture group replacement and surrounding literal text.
+    /// For example, if we wanted to join two words together with an
+    /// underscore:
+    ///
+    /// ```rust
+    /// # use regex::Regex;
+    /// # fn main() {
+    /// let re = Regex::new(r"(?P<first>\w+)\s+(?P<second>\w+)").unwrap();
+    /// let result = re.replace("deep fried", "${first}_$second");
+    /// assert_eq!(result, "deep_fried");
+    /// # }
+    /// ```
+    ///
+    /// Without the curly braces, the capture group name `first_` would be
+    /// used, and since it doesn't exist, it would be replaced with the empty
+    /// string.
+    ///
+    /// Finally, sometimes you just want to replace a literal string with no
+    /// regard for capturing group expansion. This can be done by wrapping a
+    /// byte string with `NoExpand`:
+    ///
+    /// ```rust
+    /// # use regex::Regex;
+    /// # fn main() {
+    /// use regex::NoExpand;
+    ///
+    /// let re = Regex::new(r"(?P<last>[^,\s]+),\s+(\S+)").unwrap();
+    /// let result = re.replace("Springsteen, Bruce", NoExpand("$2 $last"));
+    /// assert_eq!(result, "$2 $last");
+    /// # }
+    /// ```
+    pub fn replace<'t, R: Replacer>(
+        &self,
+        text: &'t str,
+        rep: R,
+    ) -> Cow<'t, str> {
+        self.replacen(text, 1, rep)
+    }
+
+    /// Replaces all non-overlapping matches in `text` with the replacement
+    /// provided. This is the same as calling `replacen` with `limit` set to
+    /// `0`.
+    ///
+    /// See the documentation for `replace` for details on how to access
+    /// capturing group matches in the replacement string.
+    pub fn replace_all<'t, R: Replacer>(
+        &self,
+        text: &'t str,
+        rep: R,
+    ) -> Cow<'t, str> {
+        self.replacen(text, 0, rep)
+    }
+
+    /// Replaces at most `limit` non-overlapping matches in `text` with the
+    /// replacement provided. If `limit` is 0, then all non-overlapping matches
+    /// are replaced.
+    ///
+    /// See the documentation for `replace` for details on how to access
+    /// capturing group matches in the replacement string.
+    pub fn replacen<'t, R: Replacer>(
+        &self,
+        text: &'t str,
+        limit: usize,
+        mut rep: R,
+    ) -> Cow<'t, str> {
+        // If we know that the replacement doesn't have any capture expansions,
+        // then we can use the fast path. The fast path can make a tremendous
+        // difference:
+        //
+        //   1) We use `find_iter` instead of `captures_iter`. Not asking for
+        //      captures generally makes the regex engines faster.
+        //   2) We don't need to look up all of the capture groups and do
+        //      replacements inside the replacement string. We just push it
+        //      at each match and be done with it.
+        if let Some(rep) = rep.no_expansion() {
+            let mut it = self.find_iter(text).enumerate().peekable();
+            if it.peek().is_none() {
+                return Cow::Borrowed(text);
+            }
+            let mut new = String::with_capacity(text.len());
+            let mut last_match = 0;
+            for (i, m) in it {
+                new.push_str(&text[last_match..m.start()]);
+                new.push_str(&rep);
+                last_match = m.end();
+                if limit > 0 && i >= limit - 1 {
+                    break;
+                }
+            }
+            new.push_str(&text[last_match..]);
+            return Cow::Owned(new);
+        }
+
+        // The slower path, which we use if the replacement needs access to
+        // capture groups.
+        let mut it = self.captures_iter(text).enumerate().peekable();
+        if it.peek().is_none() {
+            return Cow::Borrowed(text);
+        }
+        let mut new = String::with_capacity(text.len());
+        let mut last_match = 0;
+        for (i, cap) in it {
+            // unwrap on 0 is OK because captures only reports matches
+            let m = cap.get(0).unwrap();
+            new.push_str(&text[last_match..m.start()]);
+            rep.replace_append(&cap, &mut new);
+            last_match = m.end();
+            if limit > 0 && i >= limit - 1 {
+                break;
+            }
+        }
+        new.push_str(&text[last_match..]);
+        Cow::Owned(new)
+    }
+}
+
+/// Advanced or "lower level" search methods.
+impl Regex {
+    /// Returns the end location of a match in the text given.
+    ///
+    /// This method may have the same performance characteristics as
+    /// `is_match`, except it provides an end location for a match. In
+    /// particular, the location returned *may be shorter* than the proper end
+    /// of the leftmost-first match.
+    ///
+    /// # Example
+    ///
+    /// Typically, `a+` would match the entire first sequence of `a` in some
+    /// text, but `shortest_match` can give up as soon as it sees the first
+    /// `a`.
+    ///
+    /// ```rust
+    /// # use regex::Regex;
+    /// # fn main() {
+    /// let text = "aaaaa";
+    /// let pos = Regex::new(r"a+").unwrap().shortest_match(text);
+    /// assert_eq!(pos, Some(1));
+    /// # }
+    /// ```
+    pub fn shortest_match(&self, text: &str) -> Option<usize> {
+        self.shortest_match_at(text, 0)
+    }
+
+    /// Returns the same as shortest_match, but starts the search at the given
+    /// offset.
+    ///
+    /// The significance of the starting point is that it takes the surrounding
+    /// context into consideration. For example, the `\A` anchor can only
+    /// match when `start == 0`.
+    pub fn shortest_match_at(
+        &self,
+        text: &str,
+        start: usize,
+    ) -> Option<usize> {
+        self.0.searcher_str().shortest_match_at(text, start)
+    }
+
+    /// Returns the same as is_match, but starts the search at the given
+    /// offset.
+    ///
+    /// The significance of the starting point is that it takes the surrounding
+    /// context into consideration. For example, the `\A` anchor can only
+    /// match when `start == 0`.
+    pub fn is_match_at(&self, text: &str, start: usize) -> bool {
+        self.0.searcher_str().is_match_at(text, start)
+    }
+
+    /// Returns the same as find, but starts the search at the given
+    /// offset.
+    ///
+    /// The significance of the starting point is that it takes the surrounding
+    /// context into consideration. For example, the `\A` anchor can only
+    /// match when `start == 0`.
+    pub fn find_at<'t>(
+        &self,
+        text: &'t str,
+        start: usize,
+    ) -> Option<Match<'t>> {
+        self.0
+            .searcher_str()
+            .find_at(text, start)
+            .map(|(s, e)| Match::new(text, s, e))
+    }
+
+    /// This is like `captures`, but uses
+    /// [`CaptureLocations`](struct.CaptureLocations.html)
+    /// instead of
+    /// [`Captures`](struct.Captures.html) in order to amortize allocations.
+    ///
+    /// To create a `CaptureLocations` value, use the
+    /// `Regex::capture_locations` method.
+    ///
+    /// This returns the overall match if this was successful, which is always
+    /// equivalence to the `0`th capture group.
+    pub fn captures_read<'t>(
+        &self,
+        locs: &mut CaptureLocations,
+        text: &'t str,
+    ) -> Option<Match<'t>> {
+        self.captures_read_at(locs, text, 0)
+    }
+
+    /// Returns the same as captures, but starts the search at the given
+    /// offset and populates the capture locations given.
+    ///
+    /// The significance of the starting point is that it takes the surrounding
+    /// context into consideration. For example, the `\A` anchor can only
+    /// match when `start == 0`.
+    pub fn captures_read_at<'t>(
+        &self,
+        locs: &mut CaptureLocations,
+        text: &'t str,
+        start: usize,
+    ) -> Option<Match<'t>> {
+        self.0
+            .searcher_str()
+            .captures_read_at(&mut locs.0, text, start)
+            .map(|(s, e)| Match::new(text, s, e))
+    }
+
+    /// An undocumented alias for `captures_read_at`.
+    ///
+    /// The `regex-capi` crate previously used this routine, so to avoid
+    /// breaking that crate, we continue to provide the name as an undocumented
+    /// alias.
+    #[doc(hidden)]
+    pub fn read_captures_at<'t>(
+        &self,
+        locs: &mut CaptureLocations,
+        text: &'t str,
+        start: usize,
+    ) -> Option<Match<'t>> {
+        self.captures_read_at(locs, text, start)
+    }
+}
+
+/// Auxiliary methods.
+impl Regex {
+    /// Returns the original string of this regex.
+    pub fn as_str(&self) -> &str {
+        &self.0.regex_strings()[0]
+    }
+
+    /// Returns an iterator over the capture names.
+    pub fn capture_names(&self) -> CaptureNames<'_> {
+        CaptureNames(self.0.capture_names().iter())
+    }
+
+    /// Returns the number of captures.
+    pub fn captures_len(&self) -> usize {
+        self.0.capture_names().len()
+    }
+
+    /// Returns an empty set of capture locations that can be reused in
+    /// multiple calls to `captures_read` or `captures_read_at`.
+    pub fn capture_locations(&self) -> CaptureLocations {
+        CaptureLocations(self.0.searcher_str().locations())
+    }
+
+    /// An alias for `capture_locations` to preserve backward compatibility.
+    ///
+    /// The `regex-capi` crate uses this method, so to avoid breaking that
+    /// crate, we continue to export it as an undocumented API.
+    #[doc(hidden)]
+    pub fn locations(&self) -> CaptureLocations {
+        CaptureLocations(self.0.searcher_str().locations())
+    }
+}
+
+/// An iterator over the names of all possible captures.
+///
+/// `None` indicates an unnamed capture; the first element (capture 0, the
+/// whole matched region) is always unnamed.
+///
+/// `'r` is the lifetime of the compiled regular expression.
+#[derive(Clone, Debug)]
+pub struct CaptureNames<'r>(::std::slice::Iter<'r, Option<String>>);
+
+impl<'r> Iterator for CaptureNames<'r> {
+    type Item = Option<&'r str>;
+
+    fn next(&mut self) -> Option<Option<&'r str>> {
+        self.0
+            .next()
+            .as_ref()
+            .map(|slot| slot.as_ref().map(|name| name.as_ref()))
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.0.size_hint()
+    }
+
+    fn count(self) -> usize {
+        self.0.count()
+    }
+}
+
+impl<'r> ExactSizeIterator for CaptureNames<'r> {}
+
+impl<'r> FusedIterator for CaptureNames<'r> {}
+
+/// Yields all substrings delimited by a regular expression match.
+///
+/// `'r` is the lifetime of the compiled regular expression and `'t` is the
+/// lifetime of the string being split.
+#[derive(Debug)]
+pub struct Split<'r, 't> {
+    finder: Matches<'r, 't>,
+    last: usize,
+}
+
+impl<'r, 't> Iterator for Split<'r, 't> {
+    type Item = &'t str;
+
+    fn next(&mut self) -> Option<&'t str> {
+        let text = self.finder.0.text();
+        match self.finder.next() {
+            None => {
+                if self.last > text.len() {
+                    None
+                } else {
+                    let s = &text[self.last..];
+                    self.last = text.len() + 1; // Next call will return None
+                    Some(s)
+                }
+            }
+            Some(m) => {
+                let matched = &text[self.last..m.start()];
+                self.last = m.end();
+                Some(matched)
+            }
+        }
+    }
+}
+
+impl<'r, 't> FusedIterator for Split<'r, 't> {}
+
+/// Yields at most `N` substrings delimited by a regular expression match.
+///
+/// The last substring will be whatever remains after splitting.
+///
+/// `'r` is the lifetime of the compiled regular expression and `'t` is the
+/// lifetime of the string being split.
+#[derive(Debug)]
+pub struct SplitN<'r, 't> {
+    splits: Split<'r, 't>,
+    n: usize,
+}
+
+impl<'r, 't> Iterator for SplitN<'r, 't> {
+    type Item = &'t str;
+
+    fn next(&mut self) -> Option<&'t str> {
+        if self.n == 0 {
+            return None;
+        }
+
+        self.n -= 1;
+        if self.n > 0 {
+            return self.splits.next();
+        }
+
+        let text = self.splits.finder.0.text();
+        if self.splits.last > text.len() {
+            // We've already returned all substrings.
+            None
+        } else {
+            // self.n == 0, so future calls will return None immediately
+            Some(&text[self.splits.last..])
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (0, Some(self.n))
+    }
+}
+
+impl<'r, 't> FusedIterator for SplitN<'r, 't> {}
+
+/// CaptureLocations is a low level representation of the raw offsets of each
+/// submatch.
+///
+/// You can think of this as a lower level
+/// [`Captures`](struct.Captures.html), where this type does not support
+/// named capturing groups directly and it does not borrow the text that these
+/// offsets were matched on.
+///
+/// Primarily, this type is useful when using the lower level `Regex` APIs
+/// such as `read_captures`, which permits amortizing the allocation in which
+/// capture match locations are stored.
+///
+/// In order to build a value of this type, you'll need to call the
+/// `capture_locations` method on the `Regex` being used to execute the search.
+/// The value returned can then be reused in subsequent searches.
+#[derive(Clone, Debug)]
+pub struct CaptureLocations(re_trait::Locations);
+
+/// A type alias for `CaptureLocations` for backwards compatibility.
+///
+/// Previously, we exported `CaptureLocations` as `Locations` in an
+/// undocumented API. To prevent breaking that code (e.g., in `regex-capi`),
+/// we continue re-exporting the same undocumented API.
+#[doc(hidden)]
+pub type Locations = CaptureLocations;
+
+impl CaptureLocations {
+    /// Returns the start and end positions of the Nth capture group. Returns
+    /// `None` if `i` is not a valid capture group or if the capture group did
+    /// not match anything. The positions returned are *always* byte indices
+    /// with respect to the original string matched.
+    #[inline]
+    pub fn get(&self, i: usize) -> Option<(usize, usize)> {
+        self.0.pos(i)
+    }
+
+    /// Returns the total number of capture groups (even if they didn't match).
+    ///
+    /// This is always at least `1` since every regex has at least `1`
+    /// capturing group that corresponds to the entire match.
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.0.len()
+    }
+
+    /// An alias for the `get` method for backwards compatibility.
+    ///
+    /// Previously, we exported `get` as `pos` in an undocumented API. To
+    /// prevent breaking that code (e.g., in `regex-capi`), we continue
+    /// re-exporting the same undocumented API.
+    #[doc(hidden)]
+    #[inline]
+    pub fn pos(&self, i: usize) -> Option<(usize, usize)> {
+        self.get(i)
+    }
+}
+
+/// Captures represents a group of captured strings for a single match.
+///
+/// The 0th capture always corresponds to the entire match. Each subsequent
+/// index corresponds to the next capture group in the regex. If a capture
+/// group is named, then the matched string is *also* available via the `name`
+/// method. (Note that the 0th capture is always unnamed and so must be
+/// accessed with the `get` method.)
+///
+/// Positions returned from a capture group are always byte indices.
+///
+/// `'t` is the lifetime of the matched text.
+pub struct Captures<'t> {
+    text: &'t str,
+    locs: re_trait::Locations,
+    named_groups: Arc<HashMap<String, usize>>,
+}
+
+impl<'t> Captures<'t> {
+    /// Returns the match associated with the capture group at index `i`. If
+    /// `i` does not correspond to a capture group, or if the capture group
+    /// did not participate in the match, then `None` is returned.
+    ///
+    /// # Examples
+    ///
+    /// Get the text of the match with a default of an empty string if this
+    /// group didn't participate in the match:
+    ///
+    /// ```rust
+    /// # use regex::Regex;
+    /// let re = Regex::new(r"[a-z]+(?:([0-9]+)|([A-Z]+))").unwrap();
+    /// let caps = re.captures("abc123").unwrap();
+    ///
+    /// let text1 = caps.get(1).map_or("", |m| m.as_str());
+    /// let text2 = caps.get(2).map_or("", |m| m.as_str());
+    /// assert_eq!(text1, "123");
+    /// assert_eq!(text2, "");
+    /// ```
+    pub fn get(&self, i: usize) -> Option<Match<'t>> {
+        self.locs.pos(i).map(|(s, e)| Match::new(self.text, s, e))
+    }
+
+    /// Returns the match for the capture group named `name`. If `name` isn't a
+    /// valid capture group or didn't match anything, then `None` is returned.
+    pub fn name(&self, name: &str) -> Option<Match<'t>> {
+        self.named_groups.get(name).and_then(|&i| self.get(i))
+    }
+
+    /// An iterator that yields all capturing matches in the order in which
+    /// they appear in the regex. If a particular capture group didn't
+    /// participate in the match, then `None` is yielded for that capture.
+    ///
+    /// The first match always corresponds to the overall match of the regex.
+    pub fn iter<'c>(&'c self) -> SubCaptureMatches<'c, 't> {
+        SubCaptureMatches { caps: self, it: self.locs.iter() }
+    }
+
+    /// Expands all instances of `$name` in `replacement` to the corresponding
+    /// capture group `name`, and writes them to the `dst` buffer given.
+    ///
+    /// `name` may be an integer corresponding to the index of the capture
+    /// group (counted by order of opening parenthesis where `0` is the
+    /// entire match) or it can be a name (consisting of letters, digits or
+    /// underscores) corresponding to a named capture group.
+    ///
+    /// If `name` isn't a valid capture group (whether the name doesn't exist
+    /// or isn't a valid index), then it is replaced with the empty string.
+    ///
+    /// The longest possible name consisting of the characters `[_0-9A-Za-z]`
+    /// is used. e.g., `$1a` looks up the capture group named `1a` and not the
+    /// capture group at index `1`. To exert more precise control over the
+    /// name, or to refer to a capture group name that uses characters outside
+    /// of `[_0-9A-Za-z]`, use braces, e.g., `${1}a` or `${foo[bar].baz}`. When
+    /// using braces, any sequence of characters is permitted. If the sequence
+    /// does not refer to a capture group name in the corresponding regex, then
+    /// it is replaced with an empty string.
+    ///
+    /// To write a literal `$` use `$$`.
+    pub fn expand(&self, replacement: &str, dst: &mut String) {
+        expand_str(self, replacement, dst)
+    }
+
+    /// Returns the total number of capture groups (even if they didn't match).
+    ///
+    /// This is always at least `1`, since every regex has at least one capture
+    /// group that corresponds to the full match.
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.locs.len()
+    }
+}
+
+impl<'t> fmt::Debug for Captures<'t> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_tuple("Captures").field(&CapturesDebug(self)).finish()
+    }
+}
+
+struct CapturesDebug<'c, 't>(&'c Captures<'t>);
+
+impl<'c, 't> fmt::Debug for CapturesDebug<'c, 't> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        // We'd like to show something nice here, even if it means an
+        // allocation to build a reverse index.
+        let slot_to_name: HashMap<&usize, &String> =
+            self.0.named_groups.iter().map(|(a, b)| (b, a)).collect();
+        let mut map = f.debug_map();
+        for (slot, m) in self.0.locs.iter().enumerate() {
+            let m = m.map(|(s, e)| &self.0.text[s..e]);
+            if let Some(name) = slot_to_name.get(&slot) {
+                map.entry(&name, &m);
+            } else {
+                map.entry(&slot, &m);
+            }
+        }
+        map.finish()
+    }
+}
+
+/// Get a group by index.
+///
+/// `'t` is the lifetime of the matched text.
+///
+/// The text can't outlive the `Captures` object if this method is
+/// used, because of how `Index` is defined (normally `a[i]` is part
+/// of `a` and can't outlive it); to do that, use `get()` instead.
+///
+/// # Panics
+///
+/// If there is no group at the given index.
+impl<'t> Index<usize> for Captures<'t> {
+    type Output = str;
+
+    fn index(&self, i: usize) -> &str {
+        self.get(i)
+            .map(|m| m.as_str())
+            .unwrap_or_else(|| panic!("no group at index '{}'", i))
+    }
+}
+
+/// Get a group by name.
+///
+/// `'t` is the lifetime of the matched text and `'i` is the lifetime
+/// of the group name (the index).
+///
+/// The text can't outlive the `Captures` object if this method is
+/// used, because of how `Index` is defined (normally `a[i]` is part
+/// of `a` and can't outlive it); to do that, use `name` instead.
+///
+/// # Panics
+///
+/// If there is no group named by the given value.
+impl<'t, 'i> Index<&'i str> for Captures<'t> {
+    type Output = str;
+
+    fn index<'a>(&'a self, name: &'i str) -> &'a str {
+        self.name(name)
+            .map(|m| m.as_str())
+            .unwrap_or_else(|| panic!("no group named '{}'", name))
+    }
+}
+
+/// An iterator that yields all capturing matches in the order in which they
+/// appear in the regex.
+///
+/// If a particular capture group didn't participate in the match, then `None`
+/// is yielded for that capture. The first match always corresponds to the
+/// overall match of the regex.
+///
+/// The lifetime `'c` corresponds to the lifetime of the `Captures` value, and
+/// the lifetime `'t` corresponds to the originally matched text.
+#[derive(Clone, Debug)]
+pub struct SubCaptureMatches<'c, 't> {
+    caps: &'c Captures<'t>,
+    it: SubCapturesPosIter<'c>,
+}
+
+impl<'c, 't> Iterator for SubCaptureMatches<'c, 't> {
+    type Item = Option<Match<'t>>;
+
+    fn next(&mut self) -> Option<Option<Match<'t>>> {
+        self.it
+            .next()
+            .map(|cap| cap.map(|(s, e)| Match::new(self.caps.text, s, e)))
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.it.size_hint()
+    }
+
+    fn count(self) -> usize {
+        self.it.count()
+    }
+}
+
+impl<'c, 't> ExactSizeIterator for SubCaptureMatches<'c, 't> {}
+
+impl<'c, 't> FusedIterator for SubCaptureMatches<'c, 't> {}
+
+/// An iterator that yields all non-overlapping capture groups matching a
+/// particular regular expression.
+///
+/// The iterator stops when no more matches can be found.
+///
+/// `'r` is the lifetime of the compiled regular expression and `'t` is the
+/// lifetime of the matched string.
+#[derive(Debug)]
+pub struct CaptureMatches<'r, 't>(
+    re_trait::CaptureMatches<'t, ExecNoSyncStr<'r>>,
+);
+
+impl<'r, 't> Iterator for CaptureMatches<'r, 't> {
+    type Item = Captures<'t>;
+
+    fn next(&mut self) -> Option<Captures<'t>> {
+        self.0.next().map(|locs| Captures {
+            text: self.0.text(),
+            locs,
+            named_groups: self.0.regex().capture_name_idx().clone(),
+        })
+    }
+}
+
+impl<'r, 't> FusedIterator for CaptureMatches<'r, 't> {}
+
+/// An iterator over all non-overlapping matches for a particular string.
+///
+/// The iterator yields a `Match` value. The iterator stops when no more
+/// matches can be found.
+///
+/// `'r` is the lifetime of the compiled regular expression and `'t` is the
+/// lifetime of the matched string.
+#[derive(Debug)]
+pub struct Matches<'r, 't>(re_trait::Matches<'t, ExecNoSyncStr<'r>>);
+
+impl<'r, 't> Iterator for Matches<'r, 't> {
+    type Item = Match<'t>;
+
+    fn next(&mut self) -> Option<Match<'t>> {
+        let text = self.0.text();
+        self.0.next().map(|(s, e)| Match::new(text, s, e))
+    }
+}
+
+impl<'r, 't> FusedIterator for Matches<'r, 't> {}
+
+/// Replacer describes types that can be used to replace matches in a string.
+///
+/// In general, users of this crate shouldn't need to implement this trait,
+/// since implementations are already provided for `&str` along with other
+/// variants of string types and `FnMut(&Captures) -> String` (or any
+/// `FnMut(&Captures) -> T` where `T: AsRef<str>`), which covers most use cases.
+pub trait Replacer {
+    /// Appends text to `dst` to replace the current match.
+    ///
+    /// The current match is represented by `caps`, which is guaranteed to
+    /// have a match at capture group `0`.
+    ///
+    /// For example, a no-op replacement would be
+    /// `dst.push_str(caps.get(0).unwrap().as_str())`.
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String);
+
+    /// Return a fixed unchanging replacement string.
+    ///
+    /// When doing replacements, if access to `Captures` is not needed (e.g.,
+    /// the replacement byte string does not need `$` expansion), then it can
+    /// be beneficial to avoid finding sub-captures.
+    ///
+    /// In general, this is called once for every call to `replacen`.
+    fn no_expansion<'r>(&'r mut self) -> Option<Cow<'r, str>> {
+        None
+    }
+
+    /// Return a `Replacer` that borrows and wraps this `Replacer`.
+    ///
+    /// This is useful when you want to take a generic `Replacer` (which might
+    /// not be cloneable) and use it without consuming it, so it can be used
+    /// more than once.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use regex::{Regex, Replacer};
+    ///
+    /// fn replace_all_twice<R: Replacer>(
+    ///     re: Regex,
+    ///     src: &str,
+    ///     mut rep: R,
+    /// ) -> String {
+    ///     let dst = re.replace_all(src, rep.by_ref());
+    ///     let dst = re.replace_all(&dst, rep.by_ref());
+    ///     dst.into_owned()
+    /// }
+    /// ```
+    fn by_ref<'r>(&'r mut self) -> ReplacerRef<'r, Self> {
+        ReplacerRef(self)
+    }
+}
+
+/// By-reference adaptor for a `Replacer`
+///
+/// Returned by [`Replacer::by_ref`](trait.Replacer.html#method.by_ref).
+#[derive(Debug)]
+pub struct ReplacerRef<'a, R: ?Sized>(&'a mut R);
+
+impl<'a, R: Replacer + ?Sized + 'a> Replacer for ReplacerRef<'a, R> {
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String) {
+        self.0.replace_append(caps, dst)
+    }
+    fn no_expansion(&mut self) -> Option<Cow<'_, str>> {
+        self.0.no_expansion()
+    }
+}
+
+impl<'a> Replacer for &'a str {
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String) {
+        caps.expand(*self, dst);
+    }
+
+    fn no_expansion(&mut self) -> Option<Cow<'_, str>> {
+        no_expansion(self)
+    }
+}
+
+impl<'a> Replacer for &'a String {
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String) {
+        self.as_str().replace_append(caps, dst)
+    }
+
+    fn no_expansion(&mut self) -> Option<Cow<'_, str>> {
+        no_expansion(self)
+    }
+}
+
+impl Replacer for String {
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String) {
+        self.as_str().replace_append(caps, dst)
+    }
+
+    fn no_expansion(&mut self) -> Option<Cow<'_, str>> {
+        no_expansion(self)
+    }
+}
+
+impl<'a> Replacer for Cow<'a, str> {
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String) {
+        self.as_ref().replace_append(caps, dst)
+    }
+
+    fn no_expansion(&mut self) -> Option<Cow<'_, str>> {
+        no_expansion(self)
+    }
+}
+
+impl<'a> Replacer for &'a Cow<'a, str> {
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String) {
+        self.as_ref().replace_append(caps, dst)
+    }
+
+    fn no_expansion(&mut self) -> Option<Cow<'_, str>> {
+        no_expansion(self)
+    }
+}
+
+fn no_expansion<T: AsRef<str>>(t: &T) -> Option<Cow<'_, str>> {
+    let s = t.as_ref();
+    match find_byte(b'$', s.as_bytes()) {
+        Some(_) => None,
+        None => Some(Cow::Borrowed(s)),
+    }
+}
+
+impl<F, T> Replacer for F
+where
+    F: FnMut(&Captures<'_>) -> T,
+    T: AsRef<str>,
+{
+    fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String) {
+        dst.push_str((*self)(caps).as_ref());
+    }
+}
+
+/// `NoExpand` indicates literal string replacement.
+///
+/// It can be used with `replace` and `replace_all` to do a literal string
+/// replacement without expanding `$name` to their corresponding capture
+/// groups. This can be both convenient (to avoid escaping `$`, for example)
+/// and performant (since capture groups don't need to be found).
+///
+/// `'t` is the lifetime of the literal text.
+#[derive(Clone, Debug)]
+pub struct NoExpand<'t>(pub &'t str);
+
+impl<'t> Replacer for NoExpand<'t> {
+    fn replace_append(&mut self, _: &Captures<'_>, dst: &mut String) {
+        dst.push_str(self.0);
+    }
+
+    fn no_expansion(&mut self) -> Option<Cow<'_, str>> {
+        Some(Cow::Borrowed(self.0))
+    }
+}
diff --git a/crates/regex/src/sparse.rs b/crates/regex/src/sparse.rs
new file mode 100644
index 0000000..98b7266
--- /dev/null
+++ b/crates/regex/src/sparse.rs
@@ -0,0 +1,84 @@
+use std::fmt;
+use std::ops::Deref;
+use std::slice;
+
+/// A sparse set used for representing ordered NFA states.
+///
+/// This supports constant time addition and membership testing. Clearing an
+/// entire set can also be done in constant time. Iteration yields elements
+/// in the order in which they were inserted.
+///
+/// The data structure is based on: https://research.swtch.com/sparse
+/// Note though that we don't actually use uninitialized memory. We generally
+/// reuse allocations, so the initial allocation cost is bareable. However,
+/// its other properties listed above are extremely useful.
+#[derive(Clone)]
+pub struct SparseSet {
+    /// Dense contains the instruction pointers in the order in which they
+    /// were inserted.
+    dense: Vec<usize>,
+    /// Sparse maps instruction pointers to their location in dense.
+    ///
+    /// An instruction pointer is in the set if and only if
+    /// sparse[ip] < dense.len() && ip == dense[sparse[ip]].
+    sparse: Box<[usize]>,
+}
+
+impl SparseSet {
+    pub fn new(size: usize) -> SparseSet {
+        SparseSet {
+            dense: Vec::with_capacity(size),
+            sparse: vec![0; size].into_boxed_slice(),
+        }
+    }
+
+    pub fn len(&self) -> usize {
+        self.dense.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.dense.is_empty()
+    }
+
+    pub fn capacity(&self) -> usize {
+        self.dense.capacity()
+    }
+
+    pub fn insert(&mut self, value: usize) {
+        let i = self.len();
+        assert!(i < self.capacity());
+        self.dense.push(value);
+        self.sparse[value] = i;
+    }
+
+    pub fn contains(&self, value: usize) -> bool {
+        let i = self.sparse[value];
+        self.dense.get(i) == Some(&value)
+    }
+
+    pub fn clear(&mut self) {
+        self.dense.clear();
+    }
+}
+
+impl fmt::Debug for SparseSet {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "SparseSet({:?})", self.dense)
+    }
+}
+
+impl Deref for SparseSet {
+    type Target = [usize];
+
+    fn deref(&self) -> &Self::Target {
+        &self.dense
+    }
+}
+
+impl<'a> IntoIterator for &'a SparseSet {
+    type Item = &'a usize;
+    type IntoIter = slice::Iter<'a, usize>;
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
diff --git a/crates/regex/src/testdata/LICENSE b/crates/regex/src/testdata/LICENSE
new file mode 100644
index 0000000..f47dbf4
--- /dev/null
+++ b/crates/regex/src/testdata/LICENSE
@@ -0,0 +1,19 @@
+The following license covers testregex.c and all associated test data.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of THIS SOFTWARE FILE (the "Software"), to deal in the Software
+without restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, and/or sell copies of the
+Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following disclaimer:
+
+THIS SOFTWARE IS PROVIDED BY AT&T ``AS IS'' AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+IN NO EVENT SHALL AT&T BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/crates/regex/src/testdata/README b/crates/regex/src/testdata/README
new file mode 100644
index 0000000..6efc2da
--- /dev/null
+++ b/crates/regex/src/testdata/README
@@ -0,0 +1,17 @@
+Test data was taken from the Go distribution, which was in turn taken from the
+testregex test suite:
+
+  http://www2.research.att.com/~astopen/testregex/testregex.html
+
+The LICENSE in this directory corresponds to the LICENSE that the data was
+released under.
+
+The tests themselves were modified for RE2/Go. A couple were modified further
+by me (Andrew Gallant) (only in repetition.dat) so that RE2/Go would pass them.
+(Yes, it seems like RE2/Go includes failing test cases.) This may or may not
+have been a bad idea, but I think being consistent with an established Regex
+library is worth something.
+
+Note that these files are read by 'scripts/regex-match-tests.py' and turned
+into Rust tests found in 'regex_macros/tests/matches.rs'.
+
diff --git a/crates/regex/src/testdata/basic.dat b/crates/regex/src/testdata/basic.dat
new file mode 100644
index 0000000..632e1bb
--- /dev/null
+++ b/crates/regex/src/testdata/basic.dat
@@ -0,0 +1,221 @@
+NOTE	all standard compliant implementations should pass these : 2002-05-31
+
+BE	abracadabra$	abracadabracadabra	(7,18)
+BE	a...b		abababbb		(2,7)
+BE	XXXXXX		..XXXXXX		(2,8)
+E	\)		()	(1,2)
+BE	a]		a]a	(0,2)
+B	}		}	(0,1)
+E	\}		}	(0,1)
+BE	\]		]	(0,1)
+B	]		]	(0,1)
+E	]		]	(0,1)
+B	{		{	(0,1)
+B	}		}	(0,1)
+BE	^a		ax	(0,1)
+BE	\^a		a^a	(1,3)
+BE	a\^		a^	(0,2)
+BE	a$		aa	(1,2)
+BE	a\$		a$	(0,2)
+BE	^$		NULL	(0,0)
+E	$^		NULL	(0,0)
+E	a($)		aa	(1,2)(2,2)
+E	a*(^a)		aa	(0,1)(0,1)
+E	(..)*(...)*		a	(0,0)
+E	(..)*(...)*		abcd	(0,4)(2,4)
+E	(ab|a)(bc|c)		abc	(0,3)(0,2)(2,3)
+E	(ab)c|abc		abc	(0,3)(0,2)
+E	a{0}b		ab			(1,2)
+E	(a*)(b?)(b+)b{3}	aaabbbbbbb	(0,10)(0,3)(3,4)(4,7)
+E	(a*)(b{0,1})(b{1,})b{3}	aaabbbbbbb	(0,10)(0,3)(3,4)(4,7)
+E	a{9876543210}	NULL	BADBR
+E	((a|a)|a)			a	(0,1)(0,1)(0,1)
+E	(a*)(a|aa)			aaaa	(0,4)(0,3)(3,4)
+E	a*(a.|aa)			aaaa	(0,4)(2,4)
+E	a(b)|c(d)|a(e)f			aef	(0,3)(?,?)(?,?)(1,2)
+E	(a|b)?.*			b	(0,1)(0,1)
+E	(a|b)c|a(b|c)			ac	(0,2)(0,1)
+E	(a|b)c|a(b|c)			ab	(0,2)(?,?)(1,2)
+E	(a|b)*c|(a|ab)*c		abc	(0,3)(1,2)
+E	(a|b)*c|(a|ab)*c		xc	(1,2)
+E	(.a|.b).*|.*(.a|.b)		xa	(0,2)(0,2)
+E	a?(ab|ba)ab			abab	(0,4)(0,2)
+E	a?(ac{0}b|ba)ab			abab	(0,4)(0,2)
+E	ab|abab				abbabab	(0,2)
+E	aba|bab|bba			baaabbbaba	(5,8)
+E	aba|bab				baaabbbaba	(6,9)
+E	(aa|aaa)*|(a|aaaaa)		aa	(0,2)(0,2)
+E	(a.|.a.)*|(a|.a...)		aa	(0,2)(0,2)
+E	ab|a				xabc	(1,3)
+E	ab|a				xxabc	(2,4)
+Ei	(?-u)(Ab|cD)*			aBcD	(0,4)(2,4)
+BE	[^-]			--a		(2,3)
+BE	[a-]*			--a		(0,3)
+BE	[a-m-]*			--amoma--	(0,4)
+E	:::1:::0:|:::1:1:0:	:::0:::1:::1:::0:	(8,17)
+E	:::1:::0:|:::1:1:1:	:::0:::1:::1:::0:	(8,17)
+{E	[[:upper:]]		A		(0,1)	[[<element>]] not supported
+E	[[:lower:]]+		`az{		(1,3)
+E	[[:upper:]]+		@AZ[		(1,3)
+# No collation in Go
+#BE	[[-]]			[[-]]		(2,4)
+#BE	[[.NIL.]]	NULL	ECOLLATE
+#BE	[[=aleph=]]	NULL	ECOLLATE
+}
+BE$	\n		\n	(0,1)
+BEn$	\n		\n	(0,1)
+BE$	[^a]		\n	(0,1)
+BE$	\na		\na	(0,2)
+E	(a)(b)(c)	abc	(0,3)(0,1)(1,2)(2,3)
+BE	xxx		xxx	(0,3)
+E1	(^|[ (,;])((([Ff]eb[^ ]* *|0*2/|\* */?)0*[6-7]))([^0-9]|$)	feb 6,	(0,6)
+E1	(^|[ (,;])((([Ff]eb[^ ]* *|0*2/|\* */?)0*[6-7]))([^0-9]|$)	2/7	(0,3)
+E1	(^|[ (,;])((([Ff]eb[^ ]* *|0*2/|\* */?)0*[6-7]))([^0-9]|$)	feb 1,Feb 6	(5,11)
+E3	((((((((((((((((((((((((((((((x))))))))))))))))))))))))))))))	x	(0,1)(0,1)(0,1)
+E3	((((((((((((((((((((((((((((((x))))))))))))))))))))))))))))))*	xx	(0,2)(1,2)(1,2)
+E	a?(ab|ba)*	ababababababababababababababababababababababababababababababababababababababababa	(0,81)(79,81)
+E	abaa|abbaa|abbbaa|abbbbaa	ababbabbbabbbabbbbabbbbaa	(18,25)
+E	abaa|abbaa|abbbaa|abbbbaa	ababbabbbabbbabbbbabaa	(18,22)
+E	aaac|aabc|abac|abbc|baac|babc|bbac|bbbc	baaabbbabac	(7,11)
+BE$	.*			\x01\x7f	(0,2)
+E	aaaa|bbbb|cccc|ddddd|eeeeee|fffffff|gggg|hhhh|iiiii|jjjjj|kkkkk|llll		XaaaXbbbXcccXdddXeeeXfffXgggXhhhXiiiXjjjXkkkXlllXcbaXaaaa	(53,57)
+L	aaaa\nbbbb\ncccc\nddddd\neeeeee\nfffffff\ngggg\nhhhh\niiiii\njjjjj\nkkkkk\nllll		XaaaXbbbXcccXdddXeeeXfffXgggXhhhXiiiXjjjXkkkXlllXcbaXaaaa	NOMATCH
+E	a*a*a*a*a*b		aaaaaaaaab	(0,10)
+BE	^			NULL		(0,0)
+BE	$			NULL		(0,0)
+BE	^$			NULL		(0,0)
+BE	^a$			a		(0,1)
+BE	abc			abc		(0,3)
+BE	abc			xabcy		(1,4)
+BE	abc			ababc		(2,5)
+BE	ab*c			abc		(0,3)
+BE	ab*bc			abc		(0,3)
+BE	ab*bc			abbc		(0,4)
+BE	ab*bc			abbbbc		(0,6)
+E	ab+bc			abbc		(0,4)
+E	ab+bc			abbbbc		(0,6)
+E	ab?bc			abbc		(0,4)
+E	ab?bc			abc		(0,3)
+E	ab?c			abc		(0,3)
+BE	^abc$			abc		(0,3)
+BE	^abc			abcc		(0,3)
+BE	abc$			aabc		(1,4)
+BE	^			abc		(0,0)
+BE	$			abc		(3,3)
+BE	a.c			abc		(0,3)
+BE	a.c			axc		(0,3)
+BE	a.*c			axyzc		(0,5)
+BE	a[bc]d			abd		(0,3)
+BE	a[b-d]e			ace		(0,3)
+BE	a[b-d]			aac		(1,3)
+BE	a[-b]			a-		(0,2)
+BE	a[b-]			a-		(0,2)
+BE	a]			a]		(0,2)
+BE	a[]]b			a]b		(0,3)
+BE	a[^bc]d			aed		(0,3)
+BE	a[^-b]c			adc		(0,3)
+BE	a[^]b]c			adc		(0,3)
+E	ab|cd			abc		(0,2)
+E	ab|cd			abcd		(0,2)
+E	a\(b			a(b		(0,3)
+E	a\(*b			ab		(0,2)
+E	a\(*b			a((b		(0,4)
+E	((a))			abc		(0,1)(0,1)(0,1)
+E	(a)b(c)			abc		(0,3)(0,1)(2,3)
+E	a+b+c			aabbabc		(4,7)
+E	a*			aaa		(0,3)
+#E	(a*)*			-		(0,0)(0,0)
+E	(a*)*			-		(0,0)(?,?)	RE2/Go
+E	(a*)+			-		(0,0)(0,0)
+#E	(a*|b)*			-		(0,0)(0,0)
+E	(a*|b)*			-		(0,0)(?,?)	RE2/Go
+E	(a+|b)*			ab		(0,2)(1,2)
+E	(a+|b)+			ab		(0,2)(1,2)
+E	(a+|b)?			ab		(0,1)(0,1)
+BE	[^ab]*			cde		(0,3)
+#E	(^)*			-		(0,0)(0,0)
+E	(^)*			-		(0,0)(?,?)	RE2/Go
+BE	a*			NULL		(0,0)
+E	([abc])*d		abbbcd		(0,6)(4,5)
+E	([abc])*bcd		abcd		(0,4)(0,1)
+E	a|b|c|d|e		e		(0,1)
+E	(a|b|c|d|e)f		ef		(0,2)(0,1)
+#E	((a*|b))*		-		(0,0)(0,0)(0,0)
+E	((a*|b))*		-		(0,0)(?,?)(?,?)	RE2/Go
+BE	abcd*efg		abcdefg		(0,7)
+BE	ab*			xabyabbbz	(1,3)
+BE	ab*			xayabbbz	(1,2)
+E	(ab|cd)e		abcde		(2,5)(2,4)
+BE	[abhgefdc]ij		hij		(0,3)
+E	(a|b)c*d		abcd		(1,4)(1,2)
+E	(ab|ab*)bc		abc		(0,3)(0,1)
+E	a([bc]*)c*		abc		(0,3)(1,3)
+E	a([bc]*)(c*d)		abcd		(0,4)(1,3)(3,4)
+E	a([bc]+)(c*d)		abcd		(0,4)(1,3)(3,4)
+E	a([bc]*)(c+d)		abcd		(0,4)(1,2)(2,4)
+E	a[bcd]*dcdcde		adcdcde		(0,7)
+E	(ab|a)b*c		abc		(0,3)(0,2)
+E	((a)(b)c)(d)		abcd		(0,4)(0,3)(0,1)(1,2)(3,4)
+BE	[A-Za-z_][A-Za-z0-9_]*	alpha		(0,5)
+E	^a(bc+|b[eh])g|.h$	abh		(1,3)
+E	(bc+d$|ef*g.|h?i(j|k))	effgz		(0,5)(0,5)
+E	(bc+d$|ef*g.|h?i(j|k))	ij		(0,2)(0,2)(1,2)
+E	(bc+d$|ef*g.|h?i(j|k))	reffgz		(1,6)(1,6)
+E	(((((((((a)))))))))	a		(0,1)(0,1)(0,1)(0,1)(0,1)(0,1)(0,1)(0,1)(0,1)(0,1)
+BE	multiple words		multiple words yeah	(0,14)
+E	(.*)c(.*)		abcde		(0,5)(0,2)(3,5)
+BE	abcd			abcd		(0,4)
+E	a(bc)d			abcd		(0,4)(1,3)
+E	a[-]?c		ac		(0,3)
+E	M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]	Muammar Qaddafi	(0,15)(?,?)(10,12)
+E	M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]	Mo'ammar Gadhafi	(0,16)(?,?)(11,13)
+E	M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]	Muammar Kaddafi	(0,15)(?,?)(10,12)
+E	M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]	Muammar Qadhafi	(0,15)(?,?)(10,12)
+E	M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]	Muammar Gadafi	(0,14)(?,?)(10,11)
+E	M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]	Mu'ammar Qadafi	(0,15)(?,?)(11,12)
+E	M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]	Moamar Gaddafi	(0,14)(?,?)(9,11)
+E	M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]	Mu'ammar Qadhdhafi	(0,18)(?,?)(13,15)
+E	M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]	Muammar Khaddafi	(0,16)(?,?)(11,13)
+E	M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]	Muammar Ghaddafy	(0,16)(?,?)(11,13)
+E	M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]	Muammar Ghadafi	(0,15)(?,?)(11,12)
+E	M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]	Muammar Ghaddafi	(0,16)(?,?)(11,13)
+E	M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]	Muamar Kaddafi	(0,14)(?,?)(9,11)
+E	M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]	Muammar Quathafi	(0,16)(?,?)(11,13)
+E	M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]	Muammar Gheddafi	(0,16)(?,?)(11,13)
+E	M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]	Moammar Khadafy	(0,15)(?,?)(11,12)
+E	M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]	Moammar Qudhafi	(0,15)(?,?)(10,12)
+E	a+(b|c)*d+		aabcdd			(0,6)(3,4)
+E	^.+$			vivi			(0,4)
+E	^(.+)$			vivi			(0,4)(0,4)
+E	^([^!.]+).att.com!(.+)$	gryphon.att.com!eby	(0,19)(0,7)(16,19)
+E	^([^!]+!)?([^!]+)$	bas			(0,3)(?,?)(0,3)
+E	^([^!]+!)?([^!]+)$	bar!bas			(0,7)(0,4)(4,7)
+E	^([^!]+!)?([^!]+)$	foo!bas			(0,7)(0,4)(4,7)
+E	^.+!([^!]+!)([^!]+)$	foo!bar!bas		(0,11)(4,8)(8,11)
+E	((foo)|(bar))!bas	bar!bas			(0,7)(0,3)(?,?)(0,3)
+E	((foo)|(bar))!bas	foo!bar!bas		(4,11)(4,7)(?,?)(4,7)
+E	((foo)|(bar))!bas	foo!bas			(0,7)(0,3)(0,3)
+E	((foo)|bar)!bas		bar!bas			(0,7)(0,3)
+E	((foo)|bar)!bas		foo!bar!bas		(4,11)(4,7)
+E	((foo)|bar)!bas		foo!bas			(0,7)(0,3)(0,3)
+E	(foo|(bar))!bas		bar!bas			(0,7)(0,3)(0,3)
+E	(foo|(bar))!bas		foo!bar!bas		(4,11)(4,7)(4,7)
+E	(foo|(bar))!bas		foo!bas			(0,7)(0,3)
+E	(foo|bar)!bas		bar!bas			(0,7)(0,3)
+E	(foo|bar)!bas		foo!bar!bas		(4,11)(4,7)
+E	(foo|bar)!bas		foo!bas			(0,7)(0,3)
+E	^(([^!]+!)?([^!]+)|.+!([^!]+!)([^!]+))$	foo!bar!bas	(0,11)(0,11)(?,?)(?,?)(4,8)(8,11)
+E	^([^!]+!)?([^!]+)$|^.+!([^!]+!)([^!]+)$	bas		(0,3)(?,?)(0,3)
+E	^([^!]+!)?([^!]+)$|^.+!([^!]+!)([^!]+)$	bar!bas		(0,7)(0,4)(4,7)
+E	^([^!]+!)?([^!]+)$|^.+!([^!]+!)([^!]+)$	foo!bar!bas	(0,11)(?,?)(?,?)(4,8)(8,11)
+E	^([^!]+!)?([^!]+)$|^.+!([^!]+!)([^!]+)$	foo!bas		(0,7)(0,4)(4,7)
+E	^(([^!]+!)?([^!]+)|.+!([^!]+!)([^!]+))$	bas		(0,3)(0,3)(?,?)(0,3)
+E	^(([^!]+!)?([^!]+)|.+!([^!]+!)([^!]+))$	bar!bas		(0,7)(0,7)(0,4)(4,7)
+E	^(([^!]+!)?([^!]+)|.+!([^!]+!)([^!]+))$	foo!bar!bas	(0,11)(0,11)(?,?)(?,?)(4,8)(8,11)
+E	^(([^!]+!)?([^!]+)|.+!([^!]+!)([^!]+))$	foo!bas		(0,7)(0,7)(0,4)(4,7)
+E	.*(/XXX).*			/XXX			(0,4)(0,4)
+E	.*(\\XXX).*			\XXX			(0,4)(0,4)
+E	\\XXX				\XXX			(0,4)
+E	.*(/000).*			/000			(0,4)(0,4)
+E	.*(\\000).*			\000			(0,4)(0,4)
+E	\\000				\000			(0,4)
diff --git a/crates/regex/src/testdata/nullsubexpr.dat b/crates/regex/src/testdata/nullsubexpr.dat
new file mode 100644
index 0000000..2e18fbb
--- /dev/null
+++ b/crates/regex/src/testdata/nullsubexpr.dat
@@ -0,0 +1,79 @@
+NOTE	null subexpression matches : 2002-06-06
+
+E	(a*)*		a		(0,1)(0,1)
+#E	SAME		x		(0,0)(0,0)
+E	SAME		x		(0,0)(?,?)	RE2/Go
+E	SAME		aaaaaa		(0,6)(0,6)
+E	SAME		aaaaaax		(0,6)(0,6)
+E	(a*)+		a		(0,1)(0,1)
+E	SAME		x		(0,0)(0,0)
+E	SAME		aaaaaa		(0,6)(0,6)
+E	SAME		aaaaaax		(0,6)(0,6)
+E	(a+)*		a		(0,1)(0,1)
+E	SAME		x		(0,0)
+E	SAME		aaaaaa		(0,6)(0,6)
+E	SAME		aaaaaax		(0,6)(0,6)
+E	(a+)+		a		(0,1)(0,1)
+E	SAME		x		NOMATCH
+E	SAME		aaaaaa		(0,6)(0,6)
+E	SAME		aaaaaax		(0,6)(0,6)
+
+E	([a]*)*		a		(0,1)(0,1)
+#E	SAME		x		(0,0)(0,0)
+E	SAME		x		(0,0)(?,?)	RE2/Go
+E	SAME		aaaaaa		(0,6)(0,6)
+E	SAME		aaaaaax		(0,6)(0,6)
+E	([a]*)+		a		(0,1)(0,1)
+E	SAME		x		(0,0)(0,0)
+E	SAME		aaaaaa		(0,6)(0,6)
+E	SAME		aaaaaax		(0,6)(0,6)
+E	([^b]*)*	a		(0,1)(0,1)
+#E	SAME		b		(0,0)(0,0)
+E	SAME		b		(0,0)(?,?)	RE2/Go
+E	SAME		aaaaaa		(0,6)(0,6)
+E	SAME		aaaaaab		(0,6)(0,6)
+E	([ab]*)*	a		(0,1)(0,1)
+E	SAME		aaaaaa		(0,6)(0,6)
+E	SAME		ababab		(0,6)(0,6)
+E	SAME		bababa		(0,6)(0,6)
+E	SAME		b		(0,1)(0,1)
+E	SAME		bbbbbb		(0,6)(0,6)
+E	SAME		aaaabcde	(0,5)(0,5)
+E	([^a]*)*	b		(0,1)(0,1)
+E	SAME		bbbbbb		(0,6)(0,6)
+#E	SAME		aaaaaa		(0,0)(0,0)
+E	SAME		aaaaaa		(0,0)(?,?)	RE2/Go
+E	([^ab]*)*	ccccxx		(0,6)(0,6)
+#E	SAME		ababab		(0,0)(0,0)
+E	SAME		ababab		(0,0)(?,?)	RE2/Go
+
+E	((z)+|a)*	zabcde		(0,2)(1,2)
+
+#{E	a+?		aaaaaa		(0,1)	no *? +? mimimal match ops
+#E	(a)		aaa		(0,1)(0,1)
+#E	(a*?)		aaa		(0,0)(0,0)
+#E	(a)*?		aaa		(0,0)
+#E	(a*?)*?		aaa		(0,0)
+#}
+
+B	\(a*\)*\(x\)		x	(0,1)(0,0)(0,1)
+B	\(a*\)*\(x\)		ax	(0,2)(0,1)(1,2)
+B	\(a*\)*\(x\)		axa	(0,2)(0,1)(1,2)
+B	\(a*\)*\(x\)\(\1\)	x	(0,1)(0,0)(0,1)(1,1)
+B	\(a*\)*\(x\)\(\1\)	ax	(0,2)(1,1)(1,2)(2,2)
+B	\(a*\)*\(x\)\(\1\)	axa	(0,3)(0,1)(1,2)(2,3)
+B	\(a*\)*\(x\)\(\1\)\(x\)	axax	(0,4)(0,1)(1,2)(2,3)(3,4)
+B	\(a*\)*\(x\)\(\1\)\(x\)	axxa	(0,3)(1,1)(1,2)(2,2)(2,3)
+
+#E	(a*)*(x)		x	(0,1)(0,0)(0,1)
+E	(a*)*(x)		x	(0,1)(?,?)(0,1)	RE2/Go
+E	(a*)*(x)		ax	(0,2)(0,1)(1,2)
+E	(a*)*(x)		axa	(0,2)(0,1)(1,2)
+
+E	(a*)+(x)		x	(0,1)(0,0)(0,1)
+E	(a*)+(x)		ax	(0,2)(0,1)(1,2)
+E	(a*)+(x)		axa	(0,2)(0,1)(1,2)
+
+E	(a*){2}(x)		x	(0,1)(0,0)(0,1)
+E	(a*){2}(x)		ax	(0,2)(1,1)(1,2)
+E	(a*){2}(x)		axa	(0,2)(1,1)(1,2)
diff --git a/crates/regex/src/testdata/repetition.dat b/crates/regex/src/testdata/repetition.dat
new file mode 100644
index 0000000..3bb2121
--- /dev/null
+++ b/crates/regex/src/testdata/repetition.dat
@@ -0,0 +1,163 @@
+NOTE	implicit vs. explicit repetitions : 2009-02-02
+
+# Glenn Fowler <gsf@research.att.com>
+# conforming matches (column 4) must match one of the following BREs
+#	NOMATCH
+#	(0,.)\((\(.\),\(.\))(?,?)(\2,\3)\)*
+#	(0,.)\((\(.\),\(.\))(\2,\3)(?,?)\)*
+# i.e., each 3-tuple has two identical elements and one (?,?)
+
+E	((..)|(.))				NULL		NOMATCH
+E	((..)|(.))((..)|(.))			NULL		NOMATCH
+E	((..)|(.))((..)|(.))((..)|(.))		NULL		NOMATCH
+
+E	((..)|(.)){1}				NULL		NOMATCH
+E	((..)|(.)){2}				NULL		NOMATCH
+E	((..)|(.)){3}				NULL		NOMATCH
+
+E	((..)|(.))*				NULL		(0,0)
+
+E	((..)|(.))				a		(0,1)(0,1)(?,?)(0,1)
+E	((..)|(.))((..)|(.))			a		NOMATCH
+E	((..)|(.))((..)|(.))((..)|(.))		a		NOMATCH
+
+E	((..)|(.)){1}				a		(0,1)(0,1)(?,?)(0,1)
+E	((..)|(.)){2}				a		NOMATCH
+E	((..)|(.)){3}				a		NOMATCH
+
+E	((..)|(.))*				a		(0,1)(0,1)(?,?)(0,1)
+
+E	((..)|(.))				aa		(0,2)(0,2)(0,2)(?,?)
+E	((..)|(.))((..)|(.))			aa		(0,2)(0,1)(?,?)(0,1)(1,2)(?,?)(1,2)
+E	((..)|(.))((..)|(.))((..)|(.))		aa		NOMATCH
+
+E	((..)|(.)){1}				aa		(0,2)(0,2)(0,2)(?,?)
+E	((..)|(.)){2}				aa		(0,2)(1,2)(?,?)(1,2)
+E	((..)|(.)){3}				aa		NOMATCH
+
+E	((..)|(.))*				aa		(0,2)(0,2)(0,2)(?,?)
+
+E	((..)|(.))				aaa		(0,2)(0,2)(0,2)(?,?)
+E	((..)|(.))((..)|(.))			aaa		(0,3)(0,2)(0,2)(?,?)(2,3)(?,?)(2,3)
+E	((..)|(.))((..)|(.))((..)|(.))		aaa		(0,3)(0,1)(?,?)(0,1)(1,2)(?,?)(1,2)(2,3)(?,?)(2,3)
+
+E	((..)|(.)){1}				aaa		(0,2)(0,2)(0,2)(?,?)
+#E	((..)|(.)){2}				aaa		(0,3)(2,3)(?,?)(2,3)
+E	((..)|(.)){2}				aaa		(0,3)(2,3)(0,2)(2,3)	RE2/Go
+E	((..)|(.)){3}				aaa		(0,3)(2,3)(?,?)(2,3)
+
+#E	((..)|(.))*				aaa		(0,3)(2,3)(?,?)(2,3)
+E	((..)|(.))*				aaa		(0,3)(2,3)(0,2)(2,3)	RE2/Go
+
+E	((..)|(.))				aaaa		(0,2)(0,2)(0,2)(?,?)
+E	((..)|(.))((..)|(.))			aaaa		(0,4)(0,2)(0,2)(?,?)(2,4)(2,4)(?,?)
+E	((..)|(.))((..)|(.))((..)|(.))		aaaa		(0,4)(0,2)(0,2)(?,?)(2,3)(?,?)(2,3)(3,4)(?,?)(3,4)
+
+E	((..)|(.)){1}				aaaa		(0,2)(0,2)(0,2)(?,?)
+E	((..)|(.)){2}				aaaa		(0,4)(2,4)(2,4)(?,?)
+#E	((..)|(.)){3}				aaaa		(0,4)(3,4)(?,?)(3,4)
+E	((..)|(.)){3}				aaaa		(0,4)(3,4)(0,2)(3,4)	RE2/Go
+
+E	((..)|(.))*				aaaa		(0,4)(2,4)(2,4)(?,?)
+
+E	((..)|(.))				aaaaa		(0,2)(0,2)(0,2)(?,?)
+E	((..)|(.))((..)|(.))			aaaaa		(0,4)(0,2)(0,2)(?,?)(2,4)(2,4)(?,?)
+E	((..)|(.))((..)|(.))((..)|(.))		aaaaa		(0,5)(0,2)(0,2)(?,?)(2,4)(2,4)(?,?)(4,5)(?,?)(4,5)
+
+E	((..)|(.)){1}				aaaaa		(0,2)(0,2)(0,2)(?,?)
+E	((..)|(.)){2}				aaaaa		(0,4)(2,4)(2,4)(?,?)
+#E	((..)|(.)){3}				aaaaa		(0,5)(4,5)(?,?)(4,5)
+E	((..)|(.)){3}				aaaaa		(0,5)(4,5)(2,4)(4,5)	RE2/Go
+
+#E	((..)|(.))*				aaaaa		(0,5)(4,5)(?,?)(4,5)
+E	((..)|(.))*				aaaaa		(0,5)(4,5)(2,4)(4,5)	RE2/Go
+
+E	((..)|(.))				aaaaaa		(0,2)(0,2)(0,2)(?,?)
+E	((..)|(.))((..)|(.))			aaaaaa		(0,4)(0,2)(0,2)(?,?)(2,4)(2,4)(?,?)
+E	((..)|(.))((..)|(.))((..)|(.))		aaaaaa		(0,6)(0,2)(0,2)(?,?)(2,4)(2,4)(?,?)(4,6)(4,6)(?,?)
+
+E	((..)|(.)){1}				aaaaaa		(0,2)(0,2)(0,2)(?,?)
+E	((..)|(.)){2}				aaaaaa		(0,4)(2,4)(2,4)(?,?)
+E	((..)|(.)){3}				aaaaaa		(0,6)(4,6)(4,6)(?,?)
+
+E	((..)|(.))*				aaaaaa		(0,6)(4,6)(4,6)(?,?)
+
+NOTE	additional repetition tests graciously provided by Chris Kuklewicz www.haskell.org 2009-02-02
+
+# These test a bug in OS X / FreeBSD / NetBSD, and libtree. 
+# Linux/GLIBC gets the {8,} and {8,8} wrong.
+
+:HA#100:E	X(.?){0,}Y	X1234567Y	(0,9)(7,8)
+:HA#101:E	X(.?){1,}Y	X1234567Y	(0,9)(7,8)
+:HA#102:E	X(.?){2,}Y	X1234567Y	(0,9)(7,8)
+:HA#103:E	X(.?){3,}Y	X1234567Y	(0,9)(7,8)
+:HA#104:E	X(.?){4,}Y	X1234567Y	(0,9)(7,8)
+:HA#105:E	X(.?){5,}Y	X1234567Y	(0,9)(7,8)
+:HA#106:E	X(.?){6,}Y	X1234567Y	(0,9)(7,8)
+:HA#107:E	X(.?){7,}Y	X1234567Y	(0,9)(7,8)
+:HA#108:E	X(.?){8,}Y	X1234567Y	(0,9)(8,8)
+#:HA#110:E	X(.?){0,8}Y	X1234567Y	(0,9)(7,8)
+:HA#110:E	X(.?){0,8}Y	X1234567Y	(0,9)(8,8)	RE2/Go
+#:HA#111:E	X(.?){1,8}Y	X1234567Y	(0,9)(7,8)
+:HA#111:E	X(.?){1,8}Y	X1234567Y	(0,9)(8,8)	RE2/Go
+#:HA#112:E	X(.?){2,8}Y	X1234567Y	(0,9)(7,8)
+:HA#112:E	X(.?){2,8}Y	X1234567Y	(0,9)(8,8)	RE2/Go
+#:HA#113:E	X(.?){3,8}Y	X1234567Y	(0,9)(7,8)
+:HA#113:E	X(.?){3,8}Y	X1234567Y	(0,9)(8,8)	RE2/Go
+#:HA#114:E	X(.?){4,8}Y	X1234567Y	(0,9)(7,8)
+:HA#114:E	X(.?){4,8}Y	X1234567Y	(0,9)(8,8)	RE2/Go
+#:HA#115:E	X(.?){5,8}Y	X1234567Y	(0,9)(7,8)
+:HA#115:E	X(.?){5,8}Y	X1234567Y	(0,9)(8,8)	RE2/Go
+#:HA#116:E	X(.?){6,8}Y	X1234567Y	(0,9)(7,8)
+:HA#116:E	X(.?){6,8}Y	X1234567Y	(0,9)(8,8)	RE2/Go
+#:HA#117:E	X(.?){7,8}Y	X1234567Y	(0,9)(7,8)
+:HA#117:E	X(.?){7,8}Y	X1234567Y	(0,9)(8,8)	RE2/Go
+:HA#118:E	X(.?){8,8}Y	X1234567Y	(0,9)(8,8)
+
+# These test a fixed bug in my regex-tdfa that did not keep the expanded
+# form properly grouped, so right association did the wrong thing with
+# these ambiguous patterns (crafted just to test my code when I became
+# suspicious of my implementation).  The first subexpression should use
+# "ab" then "a" then "bcd".
+
+# OS X / FreeBSD / NetBSD badly fail many of these, with impossible
+# results like (0,6)(4,5)(6,6).
+
+:HA#260:E	(a|ab|c|bcd){0,}(d*)	ababcd	(0,1)(0,1)(1,1)
+:HA#261:E	(a|ab|c|bcd){1,}(d*)	ababcd	(0,1)(0,1)(1,1)
+:HA#262:E	(a|ab|c|bcd){2,}(d*)	ababcd	(0,6)(3,6)(6,6)
+:HA#263:E	(a|ab|c|bcd){3,}(d*)	ababcd	(0,6)(3,6)(6,6)
+:HA#264:E	(a|ab|c|bcd){4,}(d*)	ababcd	NOMATCH
+:HA#265:E	(a|ab|c|bcd){0,10}(d*)	ababcd	(0,1)(0,1)(1,1)
+:HA#266:E	(a|ab|c|bcd){1,10}(d*)	ababcd	(0,1)(0,1)(1,1)
+:HA#267:E	(a|ab|c|bcd){2,10}(d*)	ababcd	(0,6)(3,6)(6,6)
+:HA#268:E	(a|ab|c|bcd){3,10}(d*)	ababcd	(0,6)(3,6)(6,6)
+:HA#269:E	(a|ab|c|bcd){4,10}(d*)	ababcd	NOMATCH
+:HA#270:E	(a|ab|c|bcd)*(d*)	ababcd	(0,1)(0,1)(1,1)
+:HA#271:E	(a|ab|c|bcd)+(d*)	ababcd	(0,1)(0,1)(1,1)
+
+# The above worked on Linux/GLIBC but the following often fail.
+# They also trip up OS X / FreeBSD / NetBSD:
+
+#:HA#280:E	(ab|a|c|bcd){0,}(d*)	ababcd	(0,6)(3,6)(6,6)
+:HA#280:E	(ab|a|c|bcd){0,}(d*)	ababcd	(0,6)(4,5)(5,6)	RE2/Go
+#:HA#281:E	(ab|a|c|bcd){1,}(d*)	ababcd	(0,6)(3,6)(6,6)
+:HA#281:E	(ab|a|c|bcd){1,}(d*)	ababcd	(0,6)(4,5)(5,6)	RE2/Go
+#:HA#282:E	(ab|a|c|bcd){2,}(d*)	ababcd	(0,6)(3,6)(6,6)
+:HA#282:E	(ab|a|c|bcd){2,}(d*)	ababcd	(0,6)(4,5)(5,6)	RE2/Go
+#:HA#283:E	(ab|a|c|bcd){3,}(d*)	ababcd	(0,6)(3,6)(6,6)
+:HA#283:E	(ab|a|c|bcd){3,}(d*)	ababcd	(0,6)(4,5)(5,6)	RE2/Go
+:HA#284:E	(ab|a|c|bcd){4,}(d*)	ababcd	NOMATCH
+#:HA#285:E	(ab|a|c|bcd){0,10}(d*)	ababcd	(0,6)(3,6)(6,6)
+:HA#285:E	(ab|a|c|bcd){0,10}(d*)	ababcd	(0,6)(4,5)(5,6)	RE2/Go
+#:HA#286:E	(ab|a|c|bcd){1,10}(d*)	ababcd	(0,6)(3,6)(6,6)
+:HA#286:E	(ab|a|c|bcd){1,10}(d*)	ababcd	(0,6)(4,5)(5,6)	RE2/Go
+#:HA#287:E	(ab|a|c|bcd){2,10}(d*)	ababcd	(0,6)(3,6)(6,6)
+:HA#287:E	(ab|a|c|bcd){2,10}(d*)	ababcd	(0,6)(4,5)(5,6)	RE2/Go
+#:HA#288:E	(ab|a|c|bcd){3,10}(d*)	ababcd	(0,6)(3,6)(6,6)
+:HA#288:E	(ab|a|c|bcd){3,10}(d*)	ababcd	(0,6)(4,5)(5,6)	RE2/Go
+:HA#289:E	(ab|a|c|bcd){4,10}(d*)	ababcd	NOMATCH
+#:HA#290:E	(ab|a|c|bcd)*(d*)	ababcd	(0,6)(3,6)(6,6)
+:HA#290:E	(ab|a|c|bcd)*(d*)	ababcd	(0,6)(4,5)(5,6)	RE2/Go
+#:HA#291:E	(ab|a|c|bcd)+(d*)	ababcd	(0,6)(3,6)(6,6)
+:HA#291:E	(ab|a|c|bcd)+(d*)	ababcd	(0,6)(4,5)(5,6)	RE2/Go
diff --git a/crates/regex/src/utf8.rs b/crates/regex/src/utf8.rs
new file mode 100644
index 0000000..2dfd2c0
--- /dev/null
+++ b/crates/regex/src/utf8.rs
@@ -0,0 +1,264 @@
+/// A few elementary UTF-8 encoding and decoding functions used by the matching
+/// engines.
+///
+/// In an ideal world, the matching engines operate on `&str` and we can just
+/// lean on the standard library for all our UTF-8 needs. However, to support
+/// byte based regexes (that can match on arbitrary bytes which may contain
+/// UTF-8), we need to be capable of searching and decoding UTF-8 on a `&[u8]`.
+/// The standard library doesn't really recognize this use case, so we have
+/// to build it out ourselves.
+///
+/// Should this be factored out into a separate crate? It seems independently
+/// useful. There are other crates that already exist (e.g., `utf-8`) that have
+/// overlapping use cases. Not sure what to do.
+use std::char;
+
+const TAG_CONT: u8 = 0b1000_0000;
+const TAG_TWO: u8 = 0b1100_0000;
+const TAG_THREE: u8 = 0b1110_0000;
+const TAG_FOUR: u8 = 0b1111_0000;
+
+/// Returns the smallest possible index of the next valid UTF-8 sequence
+/// starting after `i`.
+pub fn next_utf8(text: &[u8], i: usize) -> usize {
+    let b = match text.get(i) {
+        None => return i + 1,
+        Some(&b) => b,
+    };
+    let inc = if b <= 0x7F {
+        1
+    } else if b <= 0b110_11111 {
+        2
+    } else if b <= 0b1110_1111 {
+        3
+    } else {
+        4
+    };
+    i + inc
+}
+
+/// Decode a single UTF-8 sequence into a single Unicode codepoint from `src`.
+///
+/// If no valid UTF-8 sequence could be found, then `None` is returned.
+/// Otherwise, the decoded codepoint and the number of bytes read is returned.
+/// The number of bytes read (for a valid UTF-8 sequence) is guaranteed to be
+/// 1, 2, 3 or 4.
+///
+/// Note that a UTF-8 sequence is invalid if it is incorrect UTF-8, encodes a
+/// codepoint that is out of range (surrogate codepoints are out of range) or
+/// is not the shortest possible UTF-8 sequence for that codepoint.
+#[inline]
+pub fn decode_utf8(src: &[u8]) -> Option<(char, usize)> {
+    let b0 = match src.get(0) {
+        None => return None,
+        Some(&b) if b <= 0x7F => return Some((b as char, 1)),
+        Some(&b) => b,
+    };
+    match b0 {
+        0b110_00000..=0b110_11111 => {
+            if src.len() < 2 {
+                return None;
+            }
+            let b1 = src[1];
+            if 0b11_000000 & b1 != TAG_CONT {
+                return None;
+            }
+            let cp = ((b0 & !TAG_TWO) as u32) << 6 | ((b1 & !TAG_CONT) as u32);
+            match cp {
+                0x80..=0x7FF => char::from_u32(cp).map(|cp| (cp, 2)),
+                _ => None,
+            }
+        }
+        0b1110_0000..=0b1110_1111 => {
+            if src.len() < 3 {
+                return None;
+            }
+            let (b1, b2) = (src[1], src[2]);
+            if 0b11_000000 & b1 != TAG_CONT {
+                return None;
+            }
+            if 0b11_000000 & b2 != TAG_CONT {
+                return None;
+            }
+            let cp = ((b0 & !TAG_THREE) as u32) << 12
+                | ((b1 & !TAG_CONT) as u32) << 6
+                | ((b2 & !TAG_CONT) as u32);
+            match cp {
+                // char::from_u32 will disallow surrogate codepoints.
+                0x800..=0xFFFF => char::from_u32(cp).map(|cp| (cp, 3)),
+                _ => None,
+            }
+        }
+        0b11110_000..=0b11110_111 => {
+            if src.len() < 4 {
+                return None;
+            }
+            let (b1, b2, b3) = (src[1], src[2], src[3]);
+            if 0b11_000000 & b1 != TAG_CONT {
+                return None;
+            }
+            if 0b11_000000 & b2 != TAG_CONT {
+                return None;
+            }
+            if 0b11_000000 & b3 != TAG_CONT {
+                return None;
+            }
+            let cp = ((b0 & !TAG_FOUR) as u32) << 18
+                | ((b1 & !TAG_CONT) as u32) << 12
+                | ((b2 & !TAG_CONT) as u32) << 6
+                | ((b3 & !TAG_CONT) as u32);
+            match cp {
+                0x10000..=0x0010_FFFF => char::from_u32(cp).map(|cp| (cp, 4)),
+                _ => None,
+            }
+        }
+        _ => None,
+    }
+}
+
+/// Like `decode_utf8`, but decodes the last UTF-8 sequence in `src` instead
+/// of the first.
+pub fn decode_last_utf8(src: &[u8]) -> Option<(char, usize)> {
+    if src.is_empty() {
+        return None;
+    }
+    let mut start = src.len() - 1;
+    if src[start] <= 0x7F {
+        return Some((src[start] as char, 1));
+    }
+    while start > src.len().saturating_sub(4) {
+        start -= 1;
+        if is_start_byte(src[start]) {
+            break;
+        }
+    }
+    match decode_utf8(&src[start..]) {
+        None => None,
+        Some((_, n)) if n < src.len() - start => None,
+        Some((cp, n)) => Some((cp, n)),
+    }
+}
+
+fn is_start_byte(b: u8) -> bool {
+    b & 0b11_000000 != 0b1_0000000
+}
+
+#[cfg(test)]
+mod tests {
+    use std::str;
+
+    use quickcheck::quickcheck;
+
+    use super::{
+        decode_last_utf8, decode_utf8, TAG_CONT, TAG_FOUR, TAG_THREE, TAG_TWO,
+    };
+
+    #[test]
+    fn prop_roundtrip() {
+        fn p(given_cp: char) -> bool {
+            let mut tmp = [0; 4];
+            let encoded_len = given_cp.encode_utf8(&mut tmp).len();
+            let (got_cp, got_len) = decode_utf8(&tmp[..encoded_len]).unwrap();
+            encoded_len == got_len && given_cp == got_cp
+        }
+        quickcheck(p as fn(char) -> bool)
+    }
+
+    #[test]
+    fn prop_roundtrip_last() {
+        fn p(given_cp: char) -> bool {
+            let mut tmp = [0; 4];
+            let encoded_len = given_cp.encode_utf8(&mut tmp).len();
+            let (got_cp, got_len) =
+                decode_last_utf8(&tmp[..encoded_len]).unwrap();
+            encoded_len == got_len && given_cp == got_cp
+        }
+        quickcheck(p as fn(char) -> bool)
+    }
+
+    #[test]
+    fn prop_encode_matches_std() {
+        fn p(cp: char) -> bool {
+            let mut got = [0; 4];
+            let n = cp.encode_utf8(&mut got).len();
+            let expected = cp.to_string();
+            &got[..n] == expected.as_bytes()
+        }
+        quickcheck(p as fn(char) -> bool)
+    }
+
+    #[test]
+    fn prop_decode_matches_std() {
+        fn p(given_cp: char) -> bool {
+            let mut tmp = [0; 4];
+            let n = given_cp.encode_utf8(&mut tmp).len();
+            let (got_cp, _) = decode_utf8(&tmp[..n]).unwrap();
+            let expected_cp =
+                str::from_utf8(&tmp[..n]).unwrap().chars().next().unwrap();
+            got_cp == expected_cp
+        }
+        quickcheck(p as fn(char) -> bool)
+    }
+
+    #[test]
+    fn prop_decode_last_matches_std() {
+        fn p(given_cp: char) -> bool {
+            let mut tmp = [0; 4];
+            let n = given_cp.encode_utf8(&mut tmp).len();
+            let (got_cp, _) = decode_last_utf8(&tmp[..n]).unwrap();
+            let expected_cp = str::from_utf8(&tmp[..n])
+                .unwrap()
+                .chars()
+                .rev()
+                .next()
+                .unwrap();
+            got_cp == expected_cp
+        }
+        quickcheck(p as fn(char) -> bool)
+    }
+
+    #[test]
+    fn reject_invalid() {
+        // Invalid start byte
+        assert_eq!(decode_utf8(&[0xFF]), None);
+        // Surrogate pair
+        assert_eq!(decode_utf8(&[0xED, 0xA0, 0x81]), None);
+        // Invalid continuation byte.
+        assert_eq!(decode_utf8(&[0xD4, 0xC2]), None);
+        // Bad lengths
+        assert_eq!(decode_utf8(&[0xC3]), None); // 2 bytes
+        assert_eq!(decode_utf8(&[0xEF, 0xBF]), None); // 3 bytes
+        assert_eq!(decode_utf8(&[0xF4, 0x8F, 0xBF]), None); // 4 bytes
+                                                            // Not a minimal UTF-8 sequence
+        assert_eq!(decode_utf8(&[TAG_TWO, TAG_CONT | b'a']), None);
+        assert_eq!(decode_utf8(&[TAG_THREE, TAG_CONT, TAG_CONT | b'a']), None);
+        assert_eq!(
+            decode_utf8(&[TAG_FOUR, TAG_CONT, TAG_CONT, TAG_CONT | b'a',]),
+            None
+        );
+    }
+
+    #[test]
+    fn reject_invalid_last() {
+        // Invalid start byte
+        assert_eq!(decode_last_utf8(&[0xFF]), None);
+        // Surrogate pair
+        assert_eq!(decode_last_utf8(&[0xED, 0xA0, 0x81]), None);
+        // Bad lengths
+        assert_eq!(decode_last_utf8(&[0xC3]), None); // 2 bytes
+        assert_eq!(decode_last_utf8(&[0xEF, 0xBF]), None); // 3 bytes
+        assert_eq!(decode_last_utf8(&[0xF4, 0x8F, 0xBF]), None); // 4 bytes
+                                                                 // Not a minimal UTF-8 sequence
+        assert_eq!(decode_last_utf8(&[TAG_TWO, TAG_CONT | b'a']), None);
+        assert_eq!(
+            decode_last_utf8(&[TAG_THREE, TAG_CONT, TAG_CONT | b'a',]),
+            None
+        );
+        assert_eq!(
+            decode_last_utf8(
+                &[TAG_FOUR, TAG_CONT, TAG_CONT, TAG_CONT | b'a',]
+            ),
+            None
+        );
+    }
+}
diff --git a/crates/regex/test b/crates/regex/test
new file mode 100755
index 0000000..b10564f
--- /dev/null
+++ b/crates/regex/test
@@ -0,0 +1,30 @@
+#!/bin/bash
+
+set -e
+
+# This is a convenience script for running a broad swath of tests across
+# features. We don't test the complete space, since the complete space is quite
+# large. Hopefully once we migrate the test suite to better infrastructure
+# (like regex-automata), we'll be able to test more of the space.
+echo "===== DEFAULT FEATURES ==="
+cargo test
+
+echo "===== DOC TESTS ==="
+cargo test --doc
+
+features=(
+    "std"
+    "std unicode"
+    "std unicode-perl"
+    "std perf"
+    "std perf-cache"
+    "std perf-dfa"
+    "std perf-inline"
+    "std perf-literal"
+)
+for f in "${features[@]}"; do
+    echo "===== FEATURE: $f (default) ==="
+    cargo test --test default --no-default-features --features "$f"
+    echo "===== FEATURE: $f (default-bytes) ==="
+    cargo test --test default-bytes --no-default-features --features "$f"
+done
diff --git a/crates/regex/tests/api.rs b/crates/regex/tests/api.rs
new file mode 100644
index 0000000..c7250a8
--- /dev/null
+++ b/crates/regex/tests/api.rs
@@ -0,0 +1,234 @@
+#[test]
+fn empty_regex_empty_match() {
+    let re = regex!("");
+    assert_eq!(vec![(0, 0)], findall!(re, ""));
+}
+
+#[test]
+fn empty_regex_nonempty_match() {
+    let re = regex!("");
+    assert_eq!(vec![(0, 0), (1, 1), (2, 2), (3, 3)], findall!(re, "abc"));
+}
+
+#[test]
+fn one_zero_length_match() {
+    let re = regex!(r"[0-9]*");
+    assert_eq!(vec![(0, 0), (1, 2), (3, 4)], findall!(re, "a1b2"));
+}
+
+#[test]
+fn many_zero_length_match() {
+    let re = regex!(r"[0-9]*");
+    assert_eq!(
+        vec![(0, 0), (1, 2), (3, 3), (4, 4), (5, 6)],
+        findall!(re, "a1bbb2")
+    );
+}
+
+#[test]
+fn many_sequential_zero_length_match() {
+    let re = regex!(r"[0-9]?");
+    assert_eq!(
+        vec![(0, 0), (1, 2), (2, 3), (4, 5), (6, 6)],
+        findall!(re, "a12b3c")
+    );
+}
+
+#[test]
+fn quoted_bracket_set() {
+    let re = regex!(r"([\x{5b}\x{5d}])");
+    assert_eq!(vec![(0, 1), (1, 2)], findall!(re, "[]"));
+    let re = regex!(r"([\[\]])");
+    assert_eq!(vec![(0, 1), (1, 2)], findall!(re, "[]"));
+}
+
+#[test]
+fn first_range_starts_with_left_bracket() {
+    let re = regex!(r"([\[-z])");
+    assert_eq!(vec![(0, 1), (1, 2)], findall!(re, "[]"));
+}
+
+#[test]
+fn range_ends_with_escape() {
+    let re = regex!(r"([\[-\x{5d}])");
+    assert_eq!(vec![(0, 1), (1, 2)], findall!(re, "[]"));
+}
+
+#[test]
+fn empty_match_find_iter() {
+    let re = regex!(r".*?");
+    assert_eq!(vec![(0, 0), (1, 1), (2, 2), (3, 3)], findall!(re, "abc"));
+}
+
+#[test]
+fn empty_match_captures_iter() {
+    let re = regex!(r".*?");
+    let ms: Vec<_> = re
+        .captures_iter(text!("abc"))
+        .map(|c| c.get(0).unwrap())
+        .map(|m| (m.start(), m.end()))
+        .collect();
+    assert_eq!(ms, vec![(0, 0), (1, 1), (2, 2), (3, 3)]);
+}
+
+#[test]
+fn capture_names() {
+    let re = regex!(r"(.)(?P<a>.)");
+    assert_eq!(3, re.captures_len());
+    assert_eq!((3, Some(3)), re.capture_names().size_hint());
+    assert_eq!(
+        vec![None, None, Some("a")],
+        re.capture_names().collect::<Vec<_>>()
+    );
+}
+
+#[test]
+fn regex_string() {
+    assert_eq!(r"[a-zA-Z0-9]+", regex!(r"[a-zA-Z0-9]+").as_str());
+    assert_eq!(r"[a-zA-Z0-9]+", &format!("{}", regex!(r"[a-zA-Z0-9]+")));
+    assert_eq!(r"[a-zA-Z0-9]+", &format!("{:?}", regex!(r"[a-zA-Z0-9]+")));
+}
+
+#[test]
+fn capture_index() {
+    let re = regex!(r"^(?P<name>.+)$");
+    let cap = re.captures(t!("abc")).unwrap();
+    assert_eq!(&cap[0], t!("abc"));
+    assert_eq!(&cap[1], t!("abc"));
+    assert_eq!(&cap["name"], t!("abc"));
+}
+
+#[test]
+#[should_panic]
+#[cfg_attr(all(target_env = "msvc", target_pointer_width = "32"), ignore)]
+fn capture_index_panic_usize() {
+    let re = regex!(r"^(?P<name>.+)$");
+    let cap = re.captures(t!("abc")).unwrap();
+    let _ = cap[2];
+}
+
+#[test]
+#[should_panic]
+#[cfg_attr(all(target_env = "msvc", target_pointer_width = "32"), ignore)]
+fn capture_index_panic_name() {
+    let re = regex!(r"^(?P<name>.+)$");
+    let cap = re.captures(t!("abc")).unwrap();
+    let _ = cap["bad name"];
+}
+
+#[test]
+fn capture_index_lifetime() {
+    // This is a test of whether the types on `caps["..."]` are general
+    // enough. If not, this will fail to typecheck.
+    fn inner(s: &str) -> usize {
+        let re = regex!(r"(?P<number>[0-9]+)");
+        let caps = re.captures(t!(s)).unwrap();
+        caps["number"].len()
+    }
+    assert_eq!(3, inner("123"));
+}
+
+#[test]
+fn capture_misc() {
+    let re = regex!(r"(.)(?P<a>a)?(.)(?P<b>.)");
+    let cap = re.captures(t!("abc")).unwrap();
+
+    assert_eq!(5, cap.len());
+
+    assert_eq!((0, 3), {
+        let m = cap.get(0).unwrap();
+        (m.start(), m.end())
+    });
+    assert_eq!(None, cap.get(2));
+    assert_eq!((2, 3), {
+        let m = cap.get(4).unwrap();
+        (m.start(), m.end())
+    });
+
+    assert_eq!(t!("abc"), match_text!(cap.get(0).unwrap()));
+    assert_eq!(None, cap.get(2));
+    assert_eq!(t!("c"), match_text!(cap.get(4).unwrap()));
+
+    assert_eq!(None, cap.name("a"));
+    assert_eq!(t!("c"), match_text!(cap.name("b").unwrap()));
+}
+
+#[test]
+fn sub_capture_matches() {
+    let re = regex!(r"([a-z])(([a-z])|([0-9]))");
+    let cap = re.captures(t!("a5")).unwrap();
+    let subs: Vec<_> = cap.iter().collect();
+
+    assert_eq!(5, subs.len());
+    assert!(subs[0].is_some());
+    assert!(subs[1].is_some());
+    assert!(subs[2].is_some());
+    assert!(subs[3].is_none());
+    assert!(subs[4].is_some());
+
+    assert_eq!(t!("a5"), match_text!(subs[0].unwrap()));
+    assert_eq!(t!("a"), match_text!(subs[1].unwrap()));
+    assert_eq!(t!("5"), match_text!(subs[2].unwrap()));
+    assert_eq!(t!("5"), match_text!(subs[4].unwrap()));
+}
+
+expand!(expand1, r"(?-u)(?P<foo>\w+)", "abc", "$foo", "abc");
+expand!(expand2, r"(?-u)(?P<foo>\w+)", "abc", "$0", "abc");
+expand!(expand3, r"(?-u)(?P<foo>\w+)", "abc", "$1", "abc");
+expand!(expand4, r"(?-u)(?P<foo>\w+)", "abc", "$$1", "$1");
+expand!(expand5, r"(?-u)(?P<foo>\w+)", "abc", "$$foo", "$foo");
+expand!(expand6, r"(?-u)(?P<a>\w+)\s+(?P<b>\d+)", "abc 123", "$b$a", "123abc");
+expand!(expand7, r"(?-u)(?P<a>\w+)\s+(?P<b>\d+)", "abc 123", "z$bz$az", "z");
+expand!(
+    expand8,
+    r"(?-u)(?P<a>\w+)\s+(?P<b>\d+)",
+    "abc 123",
+    ".$b.$a.",
+    ".123.abc."
+);
+expand!(
+    expand9,
+    r"(?-u)(?P<a>\w+)\s+(?P<b>\d+)",
+    "abc 123",
+    " $b $a ",
+    " 123 abc "
+);
+expand!(expand10, r"(?-u)(?P<a>\w+)\s+(?P<b>\d+)", "abc 123", "$bz$az", "");
+
+expand!(expand_name1, r"%(?P<Z>[a-z]+)", "%abc", "$Z%", "abc%");
+expand!(expand_name2, r"\[(?P<Z>[a-z]+)", "[abc", "$Z[", "abc[");
+expand!(expand_name3, r"\{(?P<Z>[a-z]+)", "{abc", "$Z{", "abc{");
+expand!(expand_name4, r"\}(?P<Z>[a-z]+)", "}abc", "$Z}", "abc}");
+expand!(expand_name5, r"%([a-z]+)", "%abc", "$1a%", "%");
+expand!(expand_name6, r"%([a-z]+)", "%abc", "${1}a%", "abca%");
+expand!(expand_name7, r"\[(?P<Z[>[a-z]+)", "[abc", "${Z[}[", "abc[");
+expand!(expand_name8, r"\[(?P<Z[>[a-z]+)", "[abc", "${foo}[", "[");
+expand!(expand_name9, r"\[(?P<Z[>[a-z]+)", "[abc", "${1a}[", "[");
+expand!(expand_name10, r"\[(?P<Z[>[a-z]+)", "[abc", "${#}[", "[");
+expand!(expand_name11, r"\[(?P<Z[>[a-z]+)", "[abc", "${$$}[", "[");
+
+split!(
+    split1,
+    r"(?-u)\s+",
+    "a b\nc\td\n\t e",
+    &[t!("a"), t!("b"), t!("c"), t!("d"), t!("e")]
+);
+split!(
+    split2,
+    r"(?-u)\b",
+    "a b c",
+    &[t!(""), t!("a"), t!(" "), t!("b"), t!(" "), t!("c"), t!("")]
+);
+split!(split3, r"a$", "a", &[t!(""), t!("")]);
+split!(split_none, r"-", r"a", &[t!("a")]);
+split!(split_trailing_blank, r"-", r"a-", &[t!("a"), t!("")]);
+split!(split_trailing_blanks, r"-", r"a--", &[t!("a"), t!(""), t!("")]);
+split!(split_empty, r"-", r"", &[t!("")]);
+
+splitn!(splitn_below_limit, r"-", r"a", 2, &[t!("a")]);
+splitn!(splitn_at_limit, r"-", r"a-b", 2, &[t!("a"), t!("b")]);
+splitn!(splitn_above_limit, r"-", r"a-b-c", 2, &[t!("a"), t!("b-c")]);
+splitn!(splitn_zero_limit, r"-", r"a-b", 0, empty_vec!());
+splitn!(splitn_trailing_blank, r"-", r"a-", 2, &[t!("a"), t!("")]);
+splitn!(splitn_trailing_separator, r"-", r"a--", 2, &[t!("a"), t!("-")]);
+splitn!(splitn_empty, r"-", r"", 1, &[t!("")]);
diff --git a/crates/regex/tests/api_str.rs b/crates/regex/tests/api_str.rs
new file mode 100644
index 0000000..480116d
--- /dev/null
+++ b/crates/regex/tests/api_str.rs
@@ -0,0 +1,34 @@
+// These tests don't really make sense with the bytes API, so we only test them
+// on the Unicode API.
+
+#[test]
+fn empty_match_unicode_find_iter() {
+    // Tests that we still yield byte ranges at valid UTF-8 sequence boundaries
+    // even when we're susceptible to empty width matches.
+    let re = regex!(r".*?");
+    assert_eq!(
+        vec![(0, 0), (3, 3), (4, 4), (7, 7), (8, 8)],
+        findall!(re, "Ⅰ1Ⅱ2")
+    );
+}
+
+#[test]
+fn empty_match_unicode_captures_iter() {
+    // Same as empty_match_unicode_find_iter, but tests capture iteration.
+    let re = regex!(r".*?");
+    let ms: Vec<_> = re
+        .captures_iter(text!("Ⅰ1Ⅱ2"))
+        .map(|c| c.get(0).unwrap())
+        .map(|m| (m.start(), m.end()))
+        .collect();
+    assert_eq!(vec![(0, 0), (3, 3), (4, 4), (7, 7), (8, 8)], ms);
+}
+
+#[test]
+fn match_as_str() {
+    let re = regex!(r"fo+");
+    let caps = re.captures("barfoobar").unwrap();
+    assert_eq!(caps.get(0).map(|m| m.as_str()), Some("foo"));
+    assert_eq!(caps.get(0).map(From::from), Some("foo"));
+    assert_eq!(caps.get(0).map(Into::into), Some("foo"));
+}
diff --git a/crates/regex/tests/bytes.rs b/crates/regex/tests/bytes.rs
new file mode 100644
index 0000000..d05f138
--- /dev/null
+++ b/crates/regex/tests/bytes.rs
@@ -0,0 +1,107 @@
+// These are tests specifically crafted for regexes that can match arbitrary
+// bytes.
+
+// A silly wrapper to make it possible to write and match raw bytes.
+struct R<'a>(&'a [u8]);
+impl<'a> R<'a> {
+    fn as_bytes(&self) -> &'a [u8] {
+        self.0
+    }
+}
+
+mat!(word_boundary, r"(?-u) \b", " δ", None);
+#[cfg(feature = "unicode-perl")]
+mat!(word_boundary_unicode, r" \b", " δ", Some((0, 1)));
+mat!(word_not_boundary, r"(?-u) \B", " δ", Some((0, 1)));
+#[cfg(feature = "unicode-perl")]
+mat!(word_not_boundary_unicode, r" \B", " δ", None);
+
+mat!(perl_w_ascii, r"(?-u)\w+", "aδ", Some((0, 1)));
+#[cfg(feature = "unicode-perl")]
+mat!(perl_w_unicode, r"\w+", "aδ", Some((0, 3)));
+mat!(perl_d_ascii, r"(?-u)\d+", "1२३9", Some((0, 1)));
+#[cfg(feature = "unicode-perl")]
+mat!(perl_d_unicode, r"\d+", "1२३9", Some((0, 8)));
+mat!(perl_s_ascii, r"(?-u)\s+", " \u{1680}", Some((0, 1)));
+#[cfg(feature = "unicode-perl")]
+mat!(perl_s_unicode, r"\s+", " \u{1680}", Some((0, 4)));
+
+// The first `(.+)` matches two Unicode codepoints, but can't match the 5th
+// byte, which isn't valid UTF-8. The second (byte based) `(.+)` takes over and
+// matches.
+mat!(
+    mixed1,
+    r"(.+)(?-u)(.+)",
+    R(b"\xCE\x93\xCE\x94\xFF"),
+    Some((0, 5)),
+    Some((0, 4)),
+    Some((4, 5))
+);
+
+mat!(case_ascii_one, r"(?i-u)a", "A", Some((0, 1)));
+mat!(case_ascii_class, r"(?i-u)[a-z]+", "AaAaA", Some((0, 5)));
+#[cfg(feature = "unicode-case")]
+mat!(case_unicode, r"(?i)[a-z]+", "aA\u{212A}aA", Some((0, 7)));
+mat!(case_not_unicode, r"(?i-u)[a-z]+", "aA\u{212A}aA", Some((0, 2)));
+
+mat!(negate_unicode, r"[^a]", "δ", Some((0, 2)));
+mat!(negate_not_unicode, r"(?-u)[^a]", "δ", Some((0, 1)));
+
+// This doesn't match in a normal Unicode regex because the implicit preceding
+// `.*?` is Unicode aware.
+mat!(dotstar_prefix_not_unicode1, r"(?-u)a", R(b"\xFFa"), Some((1, 2)));
+mat!(dotstar_prefix_not_unicode2, r"a", R(b"\xFFa"), Some((1, 2)));
+
+// Have fun with null bytes.
+mat!(
+    null_bytes,
+    r"(?-u)(?P<cstr>[^\x00]+)\x00",
+    R(b"foo\x00"),
+    Some((0, 4)),
+    Some((0, 3))
+);
+
+// Test that lookahead operators work properly in the face of invalid UTF-8.
+// See: https://github.com/rust-lang/regex/issues/277
+matiter!(
+    invalidutf8_anchor1,
+    r"(?-u)\xcc?^",
+    R(b"\x8d#;\x1a\xa4s3\x05foobarX\\\x0f0t\xe4\x9b\xa4"),
+    (0, 0)
+);
+matiter!(
+    invalidutf8_anchor2,
+    r"(?-u)^\xf7|4\xff\d\x8a\x8a\x8a\x8a\x8a\x8a\x8a\x8a\x8a\x8a\x8a\x8a\x8a##########[] d\x8a\x8a\x8a\x8a\x8a\x8a\x8a\x8a\x8a\x8a\x8a\x8a\x8a##########\[] #####\x80\S7|$",
+    R(b"\x8d#;\x1a\xa4s3\x05foobarX\\\x0f0t\xe4\x9b\xa4"),
+    (22, 22)
+);
+matiter!(
+    invalidutf8_anchor3,
+    r"(?-u)^|ddp\xff\xffdddddlQd@\x80",
+    R(b"\x8d#;\x1a\xa4s3\x05foobarX\\\x0f0t\xe4\x9b\xa4"),
+    (0, 0)
+);
+
+// See https://github.com/rust-lang/regex/issues/303
+#[test]
+fn negated_full_byte_range() {
+    assert!(::regex::bytes::Regex::new(r#"(?-u)[^\x00-\xff]"#).is_err());
+}
+
+matiter!(word_boundary_ascii1, r"(?-u:\B)x(?-u:\B)", "áxβ");
+matiter!(
+    word_boundary_ascii2,
+    r"(?-u:\B)",
+    "0\u{7EF5E}",
+    (2, 2),
+    (3, 3),
+    (4, 4),
+    (5, 5)
+);
+
+// See: https://github.com/rust-lang/regex/issues/264
+mat!(ascii_boundary_no_capture, r"(?-u)\B", "\u{28f3e}", Some((0, 0)));
+mat!(ascii_boundary_capture, r"(?-u)(\B)", "\u{28f3e}", Some((0, 0)));
+
+// See: https://github.com/rust-lang/regex/issues/271
+mat!(end_not_wb, r"$(?-u:\B)", "\u{5c124}\u{b576c}", Some((8, 8)));
diff --git a/crates/regex/tests/consistent.rs b/crates/regex/tests/consistent.rs
new file mode 100644
index 0000000..722f2a5
--- /dev/null
+++ b/crates/regex/tests/consistent.rs
@@ -0,0 +1,238 @@
+use regex::internal::ExecBuilder;
+
+/// Given a regex, check if all of the backends produce the same
+/// results on a number of different inputs.
+///
+/// For now this just throws quickcheck at the problem, which
+/// is not very good because it only really tests half of the
+/// problem space. It is pretty unlikely that a random string
+/// will match any given regex, so this will probably just
+/// be checking that the different backends fail in the same
+/// way. This is still worthwhile to test, but is definitely not
+/// the whole story.
+///
+/// TODO(ethan): In order to cover the other half of the problem
+/// space, we should generate a random matching string by inspecting
+/// the AST of the input regex. The right way to do this probably
+/// involves adding a custom Arbitrary instance around a couple
+/// of newtypes. That way we can respect the quickcheck size hinting
+/// and shrinking and whatnot.
+pub fn backends_are_consistent(re: &str) -> Result<u64, String> {
+    let standard_backends = vec![
+        (
+            "bounded_backtracking_re",
+            ExecBuilder::new(re)
+                .bounded_backtracking()
+                .build()
+                .map(|exec| exec.into_regex())
+                .map_err(|err| format!("{}", err))?,
+        ),
+        (
+            "pikevm_re",
+            ExecBuilder::new(re)
+                .nfa()
+                .build()
+                .map(|exec| exec.into_regex())
+                .map_err(|err| format!("{}", err))?,
+        ),
+        (
+            "default_re",
+            ExecBuilder::new(re)
+                .build()
+                .map(|exec| exec.into_regex())
+                .map_err(|err| format!("{}", err))?,
+        ),
+    ];
+
+    let utf8bytes_backends = vec![
+        (
+            "bounded_backtracking_utf8bytes_re",
+            ExecBuilder::new(re)
+                .bounded_backtracking()
+                .bytes(true)
+                .build()
+                .map(|exec| exec.into_regex())
+                .map_err(|err| format!("{}", err))?,
+        ),
+        (
+            "pikevm_utf8bytes_re",
+            ExecBuilder::new(re)
+                .nfa()
+                .bytes(true)
+                .build()
+                .map(|exec| exec.into_regex())
+                .map_err(|err| format!("{}", err))?,
+        ),
+        (
+            "default_utf8bytes_re",
+            ExecBuilder::new(re)
+                .bytes(true)
+                .build()
+                .map(|exec| exec.into_regex())
+                .map_err(|err| format!("{}", err))?,
+        ),
+    ];
+
+    let bytes_backends = vec![
+        (
+            "bounded_backtracking_bytes_re",
+            ExecBuilder::new(re)
+                .bounded_backtracking()
+                .only_utf8(false)
+                .build()
+                .map(|exec| exec.into_byte_regex())
+                .map_err(|err| format!("{}", err))?,
+        ),
+        (
+            "pikevm_bytes_re",
+            ExecBuilder::new(re)
+                .nfa()
+                .only_utf8(false)
+                .build()
+                .map(|exec| exec.into_byte_regex())
+                .map_err(|err| format!("{}", err))?,
+        ),
+        (
+            "default_bytes_re",
+            ExecBuilder::new(re)
+                .only_utf8(false)
+                .build()
+                .map(|exec| exec.into_byte_regex())
+                .map_err(|err| format!("{}", err))?,
+        ),
+    ];
+
+    Ok(string_checker::check_backends(&standard_backends)?
+        + string_checker::check_backends(&utf8bytes_backends)?
+        + bytes_checker::check_backends(&bytes_backends)?)
+}
+
+//
+// A consistency checker parameterized by the input type (&str or &[u8]).
+//
+
+macro_rules! checker {
+    ($module_name:ident, $regex_type:path, $mk_input:expr) => {
+        mod $module_name {
+            use quickcheck;
+            use quickcheck::{Arbitrary, TestResult};
+
+            pub fn check_backends(
+                backends: &[(&str, $regex_type)],
+            ) -> Result<u64, String> {
+                let mut total_passed = 0;
+                for regex in backends[1..].iter() {
+                    total_passed += quickcheck_regex_eq(&backends[0], regex)?;
+                }
+
+                Ok(total_passed)
+            }
+
+            fn quickcheck_regex_eq(
+                &(name1, ref re1): &(&str, $regex_type),
+                &(name2, ref re2): &(&str, $regex_type),
+            ) -> Result<u64, String> {
+                quickcheck::QuickCheck::new()
+                    .quicktest(RegexEqualityTest::new(
+                        re1.clone(),
+                        re2.clone(),
+                    ))
+                    .map_err(|err| {
+                        format!(
+                            "{}(/{}/) and {}(/{}/) are inconsistent.\
+                             QuickCheck Err: {:?}",
+                            name1, re1, name2, re2, err
+                        )
+                    })
+            }
+
+            struct RegexEqualityTest {
+                re1: $regex_type,
+                re2: $regex_type,
+            }
+            impl RegexEqualityTest {
+                fn new(re1: $regex_type, re2: $regex_type) -> Self {
+                    RegexEqualityTest { re1: re1, re2: re2 }
+                }
+            }
+
+            impl quickcheck::Testable for RegexEqualityTest {
+                fn result(&self, gen: &mut quickcheck::Gen) -> TestResult {
+                    let input = $mk_input(gen);
+                    let input = &input;
+
+                    if self.re1.find(&input) != self.re2.find(input) {
+                        return TestResult::error(format!(
+                            "find mismatch input={:?}",
+                            input
+                        ));
+                    }
+
+                    let cap1 = self.re1.captures(input);
+                    let cap2 = self.re2.captures(input);
+                    match (cap1, cap2) {
+                        (None, None) => {}
+                        (Some(cap1), Some(cap2)) => {
+                            for (c1, c2) in cap1.iter().zip(cap2.iter()) {
+                                if c1 != c2 {
+                                    return TestResult::error(format!(
+                                        "captures mismatch input={:?}",
+                                        input
+                                    ));
+                                }
+                            }
+                        }
+                        _ => {
+                            return TestResult::error(format!(
+                                "captures mismatch input={:?}",
+                                input
+                            ))
+                        }
+                    }
+
+                    let fi1 = self.re1.find_iter(input);
+                    let fi2 = self.re2.find_iter(input);
+                    for (m1, m2) in fi1.zip(fi2) {
+                        if m1 != m2 {
+                            return TestResult::error(format!(
+                                "find_iter mismatch input={:?}",
+                                input
+                            ));
+                        }
+                    }
+
+                    let ci1 = self.re1.captures_iter(input);
+                    let ci2 = self.re2.captures_iter(input);
+                    for (cap1, cap2) in ci1.zip(ci2) {
+                        for (c1, c2) in cap1.iter().zip(cap2.iter()) {
+                            if c1 != c2 {
+                                return TestResult::error(format!(
+                                    "captures_iter mismatch input={:?}",
+                                    input
+                                ));
+                            }
+                        }
+                    }
+
+                    let s1 = self.re1.split(input);
+                    let s2 = self.re2.split(input);
+                    for (chunk1, chunk2) in s1.zip(s2) {
+                        if chunk1 != chunk2 {
+                            return TestResult::error(format!(
+                                "split mismatch input={:?}",
+                                input
+                            ));
+                        }
+                    }
+
+                    TestResult::from_bool(true)
+                }
+            }
+        } // mod
+    }; // rule case
+} // macro_rules!
+
+checker!(string_checker, ::regex::Regex, |gen| String::arbitrary(gen));
+checker!(bytes_checker, ::regex::bytes::Regex, |gen| Vec::<u8>::arbitrary(
+    gen
+));
diff --git a/crates/regex/tests/crates_regex.rs b/crates/regex/tests/crates_regex.rs
new file mode 100644
index 0000000..200ec27
--- /dev/null
+++ b/crates/regex/tests/crates_regex.rs
@@ -0,0 +1,3287 @@
+// DO NOT EDIT. Automatically generated by 'scripts/scrape_crates_io.py'
+// on 2018-06-20 09:56:32.820354.
+
+// autoshutdown-0.1.0: r"\s*(\d+)(\w)\s*"
+consistent!(autoshutdown_0, r"\s*(\d+)(\w)\s*");
+
+// epub-1.1.1: r"/"
+consistent!(epub_0, r"/");
+
+// rpi-info-0.2.0: "^Revision\t+: ([0-9a-fA-F]+)"
+consistent!(rpi_info_0, "^Revision\t+: ([0-9a-fA-F]+)");
+
+// rpi-info-0.2.0: "Serial\t+: ([0-9a-fA-F]+)"
+consistent!(rpi_info_1, "Serial\t+: ([0-9a-fA-F]+)");
+
+// pnet_macros-0.21.0: r"^u([0-9]+)(be|le|he)?$"
+consistent!(pnet_macros_0, r"^u([0-9]+)(be|le|he)?$");
+
+// iban_validate-1.0.3: r"^[A-Z]{2}\d{2}[A-Z\d]{1,30}$"
+consistent!(iban_validate_0, r"^[A-Z]{2}\d{2}[A-Z\d]{1,30}$");
+
+// markifier-0.1.0: r".*\[(?P<percent>.+)%.*\].*"
+consistent!(markifier_0, r".*\[(?P<percent>.+)%.*\].*");
+
+// mallumo-0.3.0: r"(#include) (\S*)(.*)"
+consistent!(mallumo_0, r"(#include) (\S*)(.*)");
+
+// mallumo-0.3.0: r"(ERROR: \d+:)(\d+)(: )(.+)"
+consistent!(mallumo_1, r"(ERROR: \d+:)(\d+)(: )(.+)");
+
+// mallumo-0.3.0: r"(\d+\()(\d+)(?:\) : )(.+)"
+consistent!(mallumo_2, r"(\d+\()(\d+)(?:\) : )(.+)");
+
+// magnet_more-0.0.1: r"(.+?)(\[.*?\])?"
+consistent!(magnet_more_0, r"(.+?)(\[.*?\])?");
+
+// magnet_app-0.0.1: r":(?P<k>[a-zA-Z_]+)"
+consistent!(magnet_app_0, r":(?P<k>[a-zA-Z_]+)");
+
+// yubibomb-0.2.0: r"^\d{6}(?:\s*,\s*\d{6})*$"
+consistent!(yubibomb_0, r"^\d{6}(?:\s*,\s*\d{6})*$");
+
+// multirust-rs-0.0.4: r"[\\/]([^\\/?]+)(\?.*)?$"
+consistent!(multirust_rs_0, r"[\\/]([^\\/?]+)(\?.*)?$");
+
+// hueclient-0.3.2: "\"[a-z]*\":null"
+consistent!(hueclient_0, "\"[a-z]*\":null");
+
+// hueclient-0.3.2: ",+"
+consistent!(hueclient_1, ",+");
+
+// hueclient-0.3.2: ",\\}"
+consistent!(hueclient_2, ",\\}");
+
+// hueclient-0.3.2: "\\{,"
+consistent!(hueclient_3, "\\{,");
+
+// aerial-0.1.0: r"[a-zA-Z_\$][a-zA-Z_0-9]*"
+consistent!(aerial_0, r"[a-zA-Z_\$][a-zA-Z_0-9]*");
+
+// aerial-0.1.0: r"thi[sng]+"
+consistent!(aerial_1, r"thi[sng]+");
+
+// rvue-0.1.0: r"(.+)\s+\((.+?)\)"
+consistent!(rvue_0, r"(.+)\s+\((.+?)\)");
+
+// rvue-0.1.0: r"([\d\.]+)\s*out\s*of\s*([\d\.]+)"
+consistent!(rvue_1, r"([\d\.]+)\s*out\s*of\s*([\d\.]+)");
+
+// rvue-0.1.0: r"^([\d\.]+)\s*(?:\(\))?$"
+consistent!(rvue_2, r"^([\d\.]+)\s*(?:\(\))?$");
+
+// rvue-0.1.0: r"([\d\.]+)\s*Points\s*Possible"
+consistent!(rvue_3, r"([\d\.]+)\s*Points\s*Possible");
+
+// rvue-0.1.0: r"([\d\.]+)\s*/\s*([\d\.]+)"
+consistent!(rvue_4, r"([\d\.]+)\s*/\s*([\d\.]+)");
+
+// rvsim-0.1.0: r"_?([_a-z0-9]+)\s*:\s*([_a-z0-9]+)\s*[,)]"
+consistent!(rvsim_0, r"_?([_a-z0-9]+)\s*:\s*([_a-z0-9]+)\s*[,)]");
+
+// nereon-0.1.4: "(.*[^\\\\])\\{\\}(.*)"
+consistent!(nereon_0, "(.*[^\\\\])\\{\\}(.*)");
+
+// next_episode-0.3.0: r"((?i)^(.+).s(\d+)e(\d+).*)$"
+consistent!(next_episode_0, r"((?i)^(.+).s(\d+)e(\d+).*)$");
+
+// migrant_lib-0.19.2: r"[^a-z0-9-]+"
+consistent!(migrant_lib_0, r"[^a-z0-9-]+");
+
+// migrant_lib-0.19.2: r"[0-9]{14}_[a-z0-9-]+"
+consistent!(migrant_lib_1, r"[0-9]{14}_[a-z0-9-]+");
+
+// migrant_lib-0.19.2: r"([0-9]{14}_)?[a-z0-9-]+"
+consistent!(migrant_lib_2, r"([0-9]{14}_)?[a-z0-9-]+");
+
+// minipre-0.2.0: "$_"
+consistent!(minipre_0, "$_");
+
+// minifier-0.0.13: r">\s+<"
+consistent!(minifier_0, r">\s+<");
+
+// minifier-0.0.13: r"\s{2,}|[\r\n]"
+consistent!(minifier_1, r"\s{2,}|[\r\n]");
+
+// minifier-0.0.13: r"<(style|script)[\w|\s].*?>"
+consistent!(minifier_2, r"<(style|script)[\w|\s].*?>");
+
+// minifier-0.0.13: "<!--(.|\n)*?-->"
+consistent!(minifier_3, "<!--(.|\n)*?-->");
+
+// minifier-0.0.13: r"<\w.*?>"
+consistent!(minifier_4, r"<\w.*?>");
+
+// minifier-0.0.13: r" \s+|\s +"
+consistent!(minifier_5, r" \s+|\s +");
+
+// minifier-0.0.13: r"\w\s+\w"
+consistent!(minifier_6, r"\w\s+\w");
+
+// minifier-0.0.13: r"'\s+>"
+consistent!(minifier_7, r"'\s+>");
+
+// minifier-0.0.13: r"\d\s+>"
+consistent!(minifier_8, r"\d\s+>");
+
+// ggp-rs-0.1.2: r"(?P<relation>\([^)]+\))|(?P<prop>[a-zA-Z0-9_]+)"
+consistent!(ggp_rs_0, r"(?P<relation>\([^)]+\))|(?P<prop>[a-zA-Z0-9_]+)");
+
+// ggp-rs-0.1.2: r"\((.*)\)."
+consistent!(ggp_rs_1, r"\((.*)\).");
+
+// poe-superfilter-0.2.0: "[A-Za-z0-9_]"
+consistent!(poe_superfilter_0, "[A-Za-z0-9_]");
+
+// poke-a-mango-0.5.0: r"(\d+)x(\d+)"
+consistent!(poke_a_mango_0, r"(\d+)x(\d+)");
+
+// pop3-rs-0.1.0: r"(?P<nmsg>\d+) (?P<size>\d+)"
+consistent!(pop3_rs_0, r"(?P<nmsg>\d+) (?P<size>\d+)");
+
+// pop3-rs-0.1.0: r"(?P<msgid>\d+) (?P<uidl>[\x21-\x7E]{1,70})"
+consistent!(pop3_rs_1, r"(?P<msgid>\d+) (?P<uidl>[\x21-\x7E]{1,70})");
+
+// pop3-rs-0.1.0: r"(<.*>)\r\n$"
+consistent!(pop3_rs_2, r"(<.*>)\r\n$");
+
+// pop3-rs-0.1.0: r"^(?P<status>\+OK|-ERR) (?P<statustext>.*)"
+consistent!(pop3_rs_3, r"^(?P<status>\+OK|-ERR) (?P<statustext>.*)");
+
+// pop3-1.0.6: r"^\.\r\n$"
+consistent!(pop3_0, r"^\.\r\n$");
+
+// pop3-1.0.6: r"\+OK(.*)"
+consistent!(pop3_1, r"\+OK(.*)");
+
+// pop3-1.0.6: r"-ERR(.*)"
+consistent!(pop3_2, r"-ERR(.*)");
+
+// pop3-1.0.6: r"\+OK (\d+) (\d+)\r\n"
+consistent!(pop3_3, r"\+OK (\d+) (\d+)\r\n");
+
+// pop3-1.0.6: r"(\d+) ([\x21-\x7e]+)\r\n"
+consistent!(pop3_4, r"(\d+) ([\x21-\x7e]+)\r\n");
+
+// pop3-1.0.6: r"\+OK (\d+) ([\x21-\x7e]+)\r\n"
+consistent!(pop3_5, r"\+OK (\d+) ([\x21-\x7e]+)\r\n");
+
+// pop3-1.0.6: r"(\d+) (\d+)\r\n"
+consistent!(pop3_6, r"(\d+) (\d+)\r\n");
+
+// pop3-1.0.6: r"\+OK (\d+) (\d+)\r\n"
+consistent!(pop3_7, r"\+OK (\d+) (\d+)\r\n");
+
+// polk-1.1.3: "github:(\\w+)/?(\\w+)?"
+consistent!(polk_0, "github:(\\w+)/?(\\w+)?");
+
+// geochunk-0.1.5: "^[0-9]{5}"
+consistent!(geochunk_0, "^[0-9]{5}");
+
+// generic-dns-update-1.1.4: r"((?:(?:0|1[\d]{0,2}|2(?:[0-4]\d?|5[0-5]?|[6-9])?|[3-9]\d?)\.){3}(?:0|1[\d]{0,2}|2(?:[0-4]\d?|5[0-5]?|[6-9])?|[3-9]\d?))"
+consistent!(generic_dns_update_0, r"((?:(?:0|1[\d]{0,2}|2(?:[0-4]\d?|5[0-5]?|[6-9])?|[3-9]\d?)\.){3}(?:0|1[\d]{0,2}|2(?:[0-4]\d?|5[0-5]?|[6-9])?|[3-9]\d?))");
+
+// generic-dns-update-1.1.4: r"((([0-9A-Fa-f]{1,4}:){7}[0-9A-Fa-f]{1,4})|(([0-9A-Fa-f]{1,4}:){6}:[0-9A-Fa-f]{1,4})|(([0-9A-Fa-f]{1,4}:){5}:([0-9A-Fa-f]{1,4}:)?[0-9A-Fa-f]{1,4})|(([0-9A-Fa-f]{1,4}:){4}:([0-9A-Fa-f]{1,4}:){0,2}[0-9A-Fa-f]{1,4})|(([0-9A-Fa-f]{1,4}:){3}:([0-9A-Fa-f]{1,4}:){0,3}[0-9A-Fa-f]{1,4})|(([0-9A-Fa-f]{1,4}:){2}:([0-9A-Fa-f]{1,4}:){0,4}[0-9A-Fa-f]{1,4})|(([0-9A-Fa-f]{1,4}:){6}((\d((25[0-5])|(1\d{2})|(2[0-4]\d)|(\d{1,2}))\d)\.){3}(\d((25[0-5])|(1\d{2})|(2[0-4]\d)|(\d{1,2}))\d))|(([0-9A-Fa-f]{1,4}:){0,5}:((\d((25[0-5])|(1\d{2})|(2[0-4]\d)|(\d{1,2}))\d)\.){3}(\d((25[0-5])|(1\d{2})|(2[0-4]\d)|(\d{1,2}))\d))|(::([0-9A-Fa-f]{1,4}:){0,5}((\d((25[0-5])|(1\d{2})|(2[0-4]\d)|(\d{1,2}))\d)\.){3}(\d((25[0-5])|(1\d{2})|(2[0-4]\d)|(\d{1,2}))\d))|([0-9A-Fa-f]{1,4}::([0-9A-Fa-f]{1,4}:){0,5}[0-9A-Fa-f]{1,4})|(::([0-9A-Fa-f]{1,4}:){0,6}[0-9A-Fa-f]{1,4})|(([0-9A-Fa-f]{1,4}:){1,7}:))"
+consistent!(generic_dns_update_1, r"((([0-9A-Fa-f]{1,4}:){7}[0-9A-Fa-f]{1,4})|(([0-9A-Fa-f]{1,4}:){6}:[0-9A-Fa-f]{1,4})|(([0-9A-Fa-f]{1,4}:){5}:([0-9A-Fa-f]{1,4}:)?[0-9A-Fa-f]{1,4})|(([0-9A-Fa-f]{1,4}:){4}:([0-9A-Fa-f]{1,4}:){0,2}[0-9A-Fa-f]{1,4})|(([0-9A-Fa-f]{1,4}:){3}:([0-9A-Fa-f]{1,4}:){0,3}[0-9A-Fa-f]{1,4})|(([0-9A-Fa-f]{1,4}:){2}:([0-9A-Fa-f]{1,4}:){0,4}[0-9A-Fa-f]{1,4})|(([0-9A-Fa-f]{1,4}:){6}((\d((25[0-5])|(1\d{2})|(2[0-4]\d)|(\d{1,2}))\d)\.){3}(\d((25[0-5])|(1\d{2})|(2[0-4]\d)|(\d{1,2}))\d))|(([0-9A-Fa-f]{1,4}:){0,5}:((\d((25[0-5])|(1\d{2})|(2[0-4]\d)|(\d{1,2}))\d)\.){3}(\d((25[0-5])|(1\d{2})|(2[0-4]\d)|(\d{1,2}))\d))|(::([0-9A-Fa-f]{1,4}:){0,5}((\d((25[0-5])|(1\d{2})|(2[0-4]\d)|(\d{1,2}))\d)\.){3}(\d((25[0-5])|(1\d{2})|(2[0-4]\d)|(\d{1,2}))\d))|([0-9A-Fa-f]{1,4}::([0-9A-Fa-f]{1,4}:){0,5}[0-9A-Fa-f]{1,4})|(::([0-9A-Fa-f]{1,4}:){0,6}[0-9A-Fa-f]{1,4})|(([0-9A-Fa-f]{1,4}:){1,7}:))");
+
+// generic-dns-update-1.1.4: r"<value><string>([0-9.]*)</string></value>"
+consistent!(
+    generic_dns_update_2,
+    r"<value><string>([0-9.]*)</string></value>"
+);
+
+// generic-dns-update-1.1.4: r"<int>([0-9]+)</int>"
+consistent!(generic_dns_update_3, r"<int>([0-9]+)</int>");
+
+// generic-dns-update-1.1.4: r"<int>([0-9]+)</int>"
+consistent!(generic_dns_update_4, r"<int>([0-9]+)</int>");
+
+// generic-dns-update-1.1.4: r"<boolean>([0-1]*)</boolean>"
+consistent!(generic_dns_update_5, r"<boolean>([0-1]*)</boolean>");
+
+// generate-nix-pkg-0.3.0: r"(\d*)\.(\d*)\.(\d*)(-(\S*))?"
+consistent!(generate_nix_pkg_0, r"(\d*)\.(\d*)\.(\d*)(-(\S*))?");
+
+// generate-nix-pkg-0.3.0: r"^(\S*) (\d*)\.(\d*)\.(\d*)(-(\S*))?"
+consistent!(generate_nix_pkg_1, r"^(\S*) (\d*)\.(\d*)\.(\d*)(-(\S*))?");
+
+// genact-0.6.0: r"arch/([a-z0-9_])+/"
+consistent!(genact_0, r"arch/([a-z0-9_])+/");
+
+// genact-0.6.0: r"arch/([a-z0-9_])+/"
+consistent!(genact_1, r"arch/([a-z0-9_])+/");
+
+// cron_rs-0.1.6: r"^\s*((\*(/\d+)?)|[0-9-,/]+)(\s+((\*(/\d+)?)|[0-9-,/]+)){4,5}\s*$"
+consistent!(
+    cron_rs_0,
+    r"^\s*((\*(/\d+)?)|[0-9-,/]+)(\s+((\*(/\d+)?)|[0-9-,/]+)){4,5}\s*$"
+);
+
+// systemfd-0.3.0: r"^([a-zA-Z]+)::(.+)$"
+consistent!(systemfd_0, r"^([a-zA-Z]+)::(.+)$");
+
+// symbolic-debuginfo-5.0.2: "__?hidden#\\d+_"
+consistent!(symbolic_debuginfo_0, "__?hidden#\\d+_");
+
+// symbolic-minidump-5.0.2: r"^Linux ([^ ]+) (.*) \w+(?: GNU/Linux)?$"
+consistent!(symbolic_minidump_0, r"^Linux ([^ ]+) (.*) \w+(?: GNU/Linux)?$");
+
+// graphql-idl-parser-0.1.1: "^(?u:\\#)(?u:[\t-\r - \u{85}-\u{85}\u{a0}-\u{a0}\u{1680}-\u{1680}\u{2000}-\u{200a}\u{2028}-\u{2029}\u{202f}-\u{202f}\u{205f}-\u{205f}\u{3000}-\u{3000}])*(?u:.)+"
+consistent!(graphql_idl_parser_0, "^(?u:\\#)(?u:[\t-\r - \u{85}-\u{85}\u{a0}-\u{a0}\u{1680}-\u{1680}\u{2000}-\u{200a}\u{2028}-\u{2029}\u{202f}-\u{202f}\u{205f}-\u{205f}\u{3000}-\u{3000}])*(?u:.)+");
+
+// graphql-idl-parser-0.1.1: "^(?u:=)(?u:[\t-\r - \u{85}-\u{85}\u{a0}-\u{a0}\u{1680}-\u{1680}\u{2000}-\u{200a}\u{2028}-\u{2029}\u{202f}-\u{202f}\u{205f}-\u{205f}\u{3000}-\u{3000}])*(?u:.)+"
+consistent!(graphql_idl_parser_1, "^(?u:=)(?u:[\t-\r - \u{85}-\u{85}\u{a0}-\u{a0}\u{1680}-\u{1680}\u{2000}-\u{200a}\u{2028}-\u{2029}\u{202f}-\u{202f}\u{205f}-\u{205f}\u{3000}-\u{3000}])*(?u:.)+");
+
+// graphql-idl-parser-0.1.1: "^(?u:[A-Z_-_a-z])(?u:[0-9A-Z_-_a-z])*"
+consistent!(graphql_idl_parser_2, "^(?u:[A-Z_-_a-z])(?u:[0-9A-Z_-_a-z])*");
+
+// graphql-idl-parser-0.1.1: "^(?u:!)"
+consistent!(graphql_idl_parser_3, "^(?u:!)");
+
+// graphql-idl-parser-0.1.1: "^(?u:\\()"
+consistent!(graphql_idl_parser_4, "^(?u:\\()");
+
+// graphql-idl-parser-0.1.1: "^(?u:\\))"
+consistent!(graphql_idl_parser_5, "^(?u:\\))");
+
+// graphql-idl-parser-0.1.1: "^(?u:,)"
+consistent!(graphql_idl_parser_6, "^(?u:,)");
+
+// graphql-idl-parser-0.1.1: "^(?u::)"
+consistent!(graphql_idl_parser_7, "^(?u::)");
+
+// graphql-idl-parser-0.1.1: "^(?u:@)"
+consistent!(graphql_idl_parser_8, "^(?u:@)");
+
+// graphql-idl-parser-0.1.1: "^(?u:\\[)"
+consistent!(graphql_idl_parser_9, "^(?u:\\[)");
+
+// graphql-idl-parser-0.1.1: "^(?u:\\])"
+consistent!(graphql_idl_parser_10, "^(?u:\\])");
+
+// graphql-idl-parser-0.1.1: "^(?u:enum)"
+consistent!(graphql_idl_parser_11, "^(?u:enum)");
+
+// graphql-idl-parser-0.1.1: "^(?u:implements)"
+consistent!(graphql_idl_parser_12, "^(?u:implements)");
+
+// graphql-idl-parser-0.1.1: "^(?u:input)"
+consistent!(graphql_idl_parser_13, "^(?u:input)");
+
+// graphql-idl-parser-0.1.1: "^(?u:interface)"
+consistent!(graphql_idl_parser_14, "^(?u:interface)");
+
+// graphql-idl-parser-0.1.1: "^(?u:scalar)"
+consistent!(graphql_idl_parser_15, "^(?u:scalar)");
+
+// graphql-idl-parser-0.1.1: "^(?u:type)"
+consistent!(graphql_idl_parser_16, "^(?u:type)");
+
+// graphql-idl-parser-0.1.1: "^(?u:union)"
+consistent!(graphql_idl_parser_17, "^(?u:union)");
+
+// graphql-idl-parser-0.1.1: "^(?u:\\{)"
+consistent!(graphql_idl_parser_18, "^(?u:\\{)");
+
+// graphql-idl-parser-0.1.1: "^(?u:\\})"
+consistent!(graphql_idl_parser_19, "^(?u:\\})");
+
+// grimoire-0.1.0: r"(?s)/\*(?P<config>.*?)\*/"
+consistent!(grimoire_0, r"(?s)/\*(?P<config>.*?)\*/");
+
+// phonenumber-0.2.0+8.9.0: r"[\d]+(?:[~\x{2053}\x{223C}\x{FF5E}][\d]+)?"
+consistent!(phonenumber_0, r"[\d]+(?:[~\x{2053}\x{223C}\x{FF5E}][\d]+)?");
+
+// phonenumber-0.2.0+8.9.0: r"[, \[\]]"
+consistent!(phonenumber_1, r"[, \[\]]");
+
+// phonenumber-0.2.0+8.9.0: r"[\\/] *x"
+consistent!(phonenumber_2, r"[\\/] *x");
+
+// phonenumber-0.2.0+8.9.0: r"[[\P{N}&&\P{L}]&&[^#]]+$"
+consistent!(phonenumber_3, r"[[\P{N}&&\P{L}]&&[^#]]+$");
+
+// phonenumber-0.2.0+8.9.0: r"(?:.*?[A-Za-z]){3}.*"
+consistent!(phonenumber_4, r"(?:.*?[A-Za-z]){3}.*");
+
+// phonenumber-0.2.0+8.9.0: r"(\D+)"
+consistent!(phonenumber_5, r"(\D+)");
+
+// phonenumber-0.2.0+8.9.0: r"(\$\d)"
+consistent!(phonenumber_6, r"(\$\d)");
+
+// phonenumber-0.2.0+8.9.0: r"\(?\$1\)?"
+consistent!(phonenumber_7, r"\(?\$1\)?");
+
+// phone_number-0.1.0: r"\D"
+consistent!(phone_number_0, r"\D");
+
+// phone_number-0.1.0: r"^0+"
+consistent!(phone_number_1, r"^0+");
+
+// phone_number-0.1.0: r"^89"
+consistent!(phone_number_2, r"^89");
+
+// phone_number-0.1.0: r"^8+"
+consistent!(phone_number_3, r"^8+");
+
+// phile-0.1.4: r"^ *(\^_*\^) *$"
+consistent!(phile_0, r"^ *(\^_*\^) *$");
+
+// phile-0.1.4: r"^[_\p{XID_Start}]$"
+consistent!(phile_1, r"^[_\p{XID_Start}]$");
+
+// phile-0.1.4: r"^\p{XID_Continue}$"
+consistent!(phile_2, r"^\p{XID_Continue}$");
+
+// uritemplate-0.1.2: "%25(?P<hex>[0-9a-fA-F][0-9a-fA-F])"
+consistent!(uritemplate_0, "%25(?P<hex>[0-9a-fA-F][0-9a-fA-F])");
+
+// urdf-rs-0.4.2: "^package://(\\w+)/"
+consistent!(urdf_rs_0, "^package://(\\w+)/");
+
+// url-match-0.1.7: r"(?P<key>[?&.])"
+consistent!(url_match_0, r"(?P<key>[?&.])");
+
+// url-match-0.1.7: r":(?P<key>[a-zA-Z0-9_-]+)"
+consistent!(url_match_1, r":(?P<key>[a-zA-Z0-9_-]+)");
+
+// tsm-sys-0.1.0: r"hello world"
+consistent!(tsm_sys_0, r"hello world");
+
+// deb-version-0.1.0: "^(?:(?:(?:\\d+:).+)|(?:[^:]+))$"
+consistent!(deb_version_0, "^(?:(?:(?:\\d+:).+)|(?:[^:]+))$");
+
+// debcargo-2.1.0: r"^(?i)(a|an|the)\s+"
+consistent!(debcargo_0, r"^(?i)(a|an|the)\s+");
+
+// debcargo-2.1.0: r"^(?i)(rust\s+)?(implementation|library|tool|crate)\s+(of|to|for)\s+"
+consistent!(
+    debcargo_1,
+    r"^(?i)(rust\s+)?(implementation|library|tool|crate)\s+(of|to|for)\s+"
+);
+
+// feaders-0.2.0: r"^.*\.h$"
+consistent!(feaders_0, r"^.*\.h$");
+
+// feaders-0.2.0: r"^.*\.c$"
+consistent!(feaders_1, r"^.*\.c$");
+
+// feaders-0.2.0: r"^.*\.hpp$"
+consistent!(feaders_2, r"^.*\.hpp$");
+
+// feaders-0.2.0: r"^.*\.cc$"
+consistent!(feaders_3, r"^.*\.cc$");
+
+// feaders-0.2.0: r"^.*\.cpp$"
+consistent!(feaders_4, r"^.*\.cpp$");
+
+// hyperscan-0.1.6: r"CPtr\(\w+\)"
+consistent!(hyperscan_0, r"CPtr\(\w+\)");
+
+// hyperscan-0.1.6: r"^Version:\s(\d\.\d\.\d)\sFeatures:\s+(\w+)?\sMode:\s(\w+)$"
+consistent!(
+    hyperscan_1,
+    r"^Version:\s(\d\.\d\.\d)\sFeatures:\s+(\w+)?\sMode:\s(\w+)$"
+);
+
+// hyperscan-0.1.6: r"RawDatabase<Block>\{db: \w+\}"
+consistent!(hyperscan_2, r"RawDatabase<Block>\{db: \w+\}");
+
+// hyperscan-0.1.6: r"RawSerializedDatabase\{p: \w+, len: \d+\}"
+consistent!(hyperscan_3, r"RawSerializedDatabase\{p: \w+, len: \d+\}");
+
+// ucd-parse-0.1.1: r"[0-9A-F]+"
+consistent!(ucd_parse_0, r"[0-9A-F]+");
+
+// afsort-0.2.0: r".*"
+consistent!(afsort_0, r".*");
+
+// afsort-0.2.0: r".*"
+consistent!(afsort_1, r".*");
+
+// afsort-0.2.0: r".*"
+consistent!(afsort_2, r".*");
+
+// afsort-0.2.0: r".*"
+consistent!(afsort_3, r".*");
+
+// afsort-0.2.0: r".*"
+consistent!(afsort_4, r".*");
+
+// afsort-0.2.0: r".*"
+consistent!(afsort_5, r".*");
+
+// afsort-0.2.0: r"^[a-z]+$"
+consistent!(afsort_6, r"^[a-z]+$");
+
+// afsort-0.2.0: r"^[a-z]+$"
+consistent!(afsort_7, r"^[a-z]+$");
+
+// tin-summer-1.21.4: r"(\.git|\.pijul|_darcs|\.hg)$"
+consistent!(tin_summer_0, r"(\.git|\.pijul|_darcs|\.hg)$");
+
+// tin-drummer-1.0.1: r".*?\.(a|la|lo|o|ll|keter|bc|dyn_o|d|rlib|crate|min\.js|hi|dyn_hi|S|jsexe|webapp|js\.externs|ibc|toc|aux|fdb_latexmk|fls|egg-info|whl|js_a|js_hi|jld|ji|js_o|so.*|dump-.*|vmb|crx|orig|elmo|elmi|pyc|mod|p_hi|p_o|prof|tix)$"
+consistent!(tin_drummer_0, r".*?\.(a|la|lo|o|ll|keter|bc|dyn_o|d|rlib|crate|min\.js|hi|dyn_hi|S|jsexe|webapp|js\.externs|ibc|toc|aux|fdb_latexmk|fls|egg-info|whl|js_a|js_hi|jld|ji|js_o|so.*|dump-.*|vmb|crx|orig|elmo|elmi|pyc|mod|p_hi|p_o|prof|tix)$");
+
+// tin-drummer-1.0.1: r".*?\.(stats|conf|h|out|cache.*|dat|pc|info|\.js)$"
+consistent!(
+    tin_drummer_1,
+    r".*?\.(stats|conf|h|out|cache.*|dat|pc|info|\.js)$"
+);
+
+// tin-drummer-1.0.1: r".*?\.(exe|a|la|o|ll|keter|bc|dyn_o|d|rlib|crate|min\.js|hi|dyn_hi|jsexe|webapp|js\.externs|ibc|toc|aux|fdb_latexmk|fls|egg-info|whl|js_a|js_hi|jld|ji|js_o|so.*|dump-.*|vmb|crx|orig|elmo|elmi|pyc|mod|p_hi|p_o|prof|tix)$"
+consistent!(tin_drummer_2, r".*?\.(exe|a|la|o|ll|keter|bc|dyn_o|d|rlib|crate|min\.js|hi|dyn_hi|jsexe|webapp|js\.externs|ibc|toc|aux|fdb_latexmk|fls|egg-info|whl|js_a|js_hi|jld|ji|js_o|so.*|dump-.*|vmb|crx|orig|elmo|elmi|pyc|mod|p_hi|p_o|prof|tix)$");
+
+// tin-drummer-1.0.1: r".*?\.(stats|conf|h|out|cache.*|\.js)$"
+consistent!(tin_drummer_3, r".*?\.(stats|conf|h|out|cache.*|\.js)$");
+
+// tin-drummer-1.0.1: r"(\.git|\.pijul|_darcs|\.hg)$"
+consistent!(tin_drummer_4, r"(\.git|\.pijul|_darcs|\.hg)$");
+
+// tin-drummer-1.0.1: r".*?\.(dyn_o|out|d|hi|dyn_hi|dump-.*|p_hi|p_o|prof|tix)$"
+consistent!(
+    tin_drummer_5,
+    r".*?\.(dyn_o|out|d|hi|dyn_hi|dump-.*|p_hi|p_o|prof|tix)$"
+);
+
+// tin-drummer-1.0.1: r".*?\.(ibc)$"
+consistent!(tin_drummer_6, r".*?\.(ibc)$");
+
+// tin-drummer-1.0.1: r"\.stack-work|dist-newstyle"
+consistent!(tin_drummer_7, r"\.stack-work|dist-newstyle");
+
+// timmy-0.3.0: r"_NET_WM_PID\(CARDINAL\) = (\d+)"
+consistent!(timmy_0, r"_NET_WM_PID\(CARDINAL\) = (\d+)");
+
+// timmy-0.3.0: r"today|yesterday|now"
+consistent!(timmy_1, r"today|yesterday|now");
+
+// timmy-0.3.0: r"(?P<day>\d{1,2})/(?P<month>\d{1,2})(/(?P<year>\d{4}|\d{2}))?"
+consistent!(
+    timmy_2,
+    r"(?P<day>\d{1,2})/(?P<month>\d{1,2})(/(?P<year>\d{4}|\d{2}))?"
+);
+
+// timmy-0.3.0: r"(?P<n>\d+) (days?|ds?)(?P<ago>( ago)?)"
+consistent!(timmy_3, r"(?P<n>\d+) (days?|ds?)(?P<ago>( ago)?)");
+
+// timmy-0.3.0: r"(?P<hr>\d{2}):(?P<mins>\d{2})"
+consistent!(timmy_4, r"(?P<hr>\d{2}):(?P<mins>\d{2})");
+
+// tinfo-0.5.0: r"^(\d+): \d+ windows \(.*\) \[\d+x\d+\]( \(attached\))?"
+consistent!(
+    tinfo_0,
+    r"^(\d+): \d+ windows \(.*\) \[\d+x\d+\]( \(attached\))?"
+);
+
+// tinfo-0.5.0: r"^(\d+):(\d+): (.*) \((\d+) panes\) \[(\d+)x(\d+)\]"
+consistent!(tinfo_1, r"^(\d+):(\d+): (.*) \((\d+) panes\) \[(\d+)x(\d+)\]");
+
+// timespan-0.0.4: r"(?:\\\{start\\\}|\\\{end\\\})"
+consistent!(timespan_0, r"(?:\\\{start\\\}|\\\{end\\\})");
+
+// timespan-0.0.4: r"(.*)\s+-\s+(.*)"
+consistent!(timespan_1, r"(.*)\s+-\s+(.*)");
+
+// timespan-0.0.4: r"(.*)\s+(\w+)$"
+consistent!(timespan_2, r"(.*)\s+(\w+)$");
+
+// timespan-0.0.4: r"(.*)\s+(\w+)$"
+consistent!(timespan_3, r"(.*)\s+(\w+)$");
+
+// timespan-0.0.4: r"(.*)\s+-\s+(.*)"
+consistent!(timespan_4, r"(.*)\s+-\s+(.*)");
+
+// titlecase-0.10.0: r"[[:lower:]]"
+consistent!(titlecase_0, r"[[:lower:]]");
+
+// tight-0.1.3: r"^\d+ (day|week|month|year)s?$"
+consistent!(tight_0, r"^\d+ (day|week|month|year)s?$");
+
+// tight-0.1.3: r"^\d+ (day|week|month|year)s?$"
+consistent!(tight_1, r"^\d+ (day|week|month|year)s?$");
+
+// yaml-0.2.1: r"^[-+]?(0|[1-9][0-9_]*)$"
+consistent!(yaml_0, r"^[-+]?(0|[1-9][0-9_]*)$");
+
+// yaml-0.2.1: r"^([-+]?)0o?([0-7_]+)$"
+consistent!(yaml_1, r"^([-+]?)0o?([0-7_]+)$");
+
+// yaml-0.2.1: r"^([-+]?)0x([0-9a-fA-F_]+)$"
+consistent!(yaml_2, r"^([-+]?)0x([0-9a-fA-F_]+)$");
+
+// yaml-0.2.1: r"^([-+]?)0b([0-1_]+)$"
+consistent!(yaml_3, r"^([-+]?)0b([0-1_]+)$");
+
+// yaml-0.2.1: r"^([-+]?)(\.[0-9]+|[0-9]+(\.[0-9]*)?([eE][-+]?[0-9]+)?)$"
+consistent!(
+    yaml_4,
+    r"^([-+]?)(\.[0-9]+|[0-9]+(\.[0-9]*)?([eE][-+]?[0-9]+)?)$"
+);
+
+// yaml-0.2.1: r"^[+]?(\.inf|\.Inf|\.INF)$"
+consistent!(yaml_5, r"^[+]?(\.inf|\.Inf|\.INF)$");
+
+// yaml-0.2.1: r"^-(\.inf|\.Inf|\.INF)$"
+consistent!(yaml_6, r"^-(\.inf|\.Inf|\.INF)$");
+
+// yaml-0.2.1: r"^(\.nan|\.NaN|\.NAN)$"
+consistent!(yaml_7, r"^(\.nan|\.NaN|\.NAN)$");
+
+// yaml-0.2.1: r"^(null|Null|NULL|~)$"
+consistent!(yaml_8, r"^(null|Null|NULL|~)$");
+
+// yaml-0.2.1: r"^(true|True|TRUE|yes|Yes|YES)$"
+consistent!(yaml_9, r"^(true|True|TRUE|yes|Yes|YES)$");
+
+// yaml-0.2.1: r"^(false|False|FALSE|no|No|NO)$"
+consistent!(yaml_10, r"^(false|False|FALSE|no|No|NO)$");
+
+// kefia-0.1.0: r"(?m)^(\S+)/(\S+) (\S+)(?: \((.*)\))?$"
+consistent!(kefia_0, r"(?m)^(\S+)/(\S+) (\S+)(?: \((.*)\))?$");
+
+// risp-0.7.0: "^(\\s+|;.*?(\n|$))+"
+consistent!(risp_0, "^(\\s+|;.*?(\n|$))+");
+
+// risp-0.7.0: "^\".*?\""
+consistent!(risp_1, "^\".*?\"");
+
+// risp-0.7.0: r"^[^\s\{\}()\[\]]+"
+consistent!(risp_2, r"^[^\s\{\}()\[\]]+");
+
+// risp-0.7.0: r"^-?\d+"
+consistent!(risp_3, r"^-?\d+");
+
+// ripgrep-0.8.1: "^([0-9]+)([KMG])?$"
+consistent!(ripgrep_0, "^([0-9]+)([KMG])?$");
+
+// riquid-0.0.1: r"^\w+"
+consistent!(riquid_0, r"^\w+");
+
+// riquid-0.0.1: r"^\d+"
+consistent!(riquid_1, r"^\d+");
+
+// recursive_disassembler-2.1.2: r"\A(0x)?([a-fA-F0-9]+)\z"
+consistent!(recursive_disassembler_0, r"\A(0x)?([a-fA-F0-9]+)\z");
+
+// remake-0.1.0: r"^[a-zA-Z_][a-zA-Z0-9_]*"
+consistent!(remake_0, r"^[a-zA-Z_][a-zA-Z0-9_]*");
+
+// regex-decode-0.1.0: r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)"
+consistent!(regex_decode_0, r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)");
+
+// regex-decode-0.1.0: r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)"
+consistent!(regex_decode_1, r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)");
+
+// regex-decode-0.1.0: r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)"
+consistent!(regex_decode_2, r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)");
+
+// regex-decode-0.1.0: r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)"
+consistent!(regex_decode_3, r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)");
+
+// regex-decode-0.1.0: r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)"
+consistent!(regex_decode_4, r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)");
+
+// regex-decode-0.1.0: r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)"
+consistent!(regex_decode_5, r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)");
+
+// regex-decode-0.1.0: r"'(?P<title>[^']+)'\s+\((?P<year>\d{2})\)"
+consistent!(regex_decode_6, r"'(?P<title>[^']+)'\s+\((?P<year>\d{2})\)");
+
+// regex-decode-0.1.0: r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)"
+consistent!(regex_decode_7, r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)");
+
+// regex-decode-0.1.0: r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)"
+consistent!(regex_decode_8, r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)");
+
+// regex-decode-0.1.0: r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})?\)"
+consistent!(regex_decode_9, r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})?\)");
+
+// regex-decode-0.1.0: r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})?\)"
+consistent!(regex_decode_10, r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})?\)");
+
+// regex-decode-0.1.0: r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})?\)"
+consistent!(regex_decode_11, r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})?\)");
+
+// regex-decode-0.1.0: r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})?\)"
+consistent!(regex_decode_12, r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})?\)");
+
+// regex-decode-0.1.0: r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})?\)"
+consistent!(regex_decode_13, r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})?\)");
+
+// regex-cache-0.2.0: "[0-9]{3}-[0-9]{3}-[0-9]{4}"
+consistent!(regex_cache_0, "[0-9]{3}-[0-9]{3}-[0-9]{4}");
+
+// regex-cache-0.2.0: r"^\d+$"
+consistent!(regex_cache_1, r"^\d+$");
+
+// regex-cache-0.2.0: r"^[a-z]+$"
+consistent!(regex_cache_2, r"^[a-z]+$");
+
+// regex-cache-0.2.0: r"^\d+$"
+consistent!(regex_cache_3, r"^\d+$");
+
+// regex-cache-0.2.0: r"^\d+$"
+consistent!(regex_cache_4, r"^\d+$");
+
+// regex_dfa-0.5.0: r"\d{4}-\d{2}-\d{2}"
+consistent!(regex_dfa_0, r"\d{4}-\d{2}-\d{2}");
+
+// reaper-2.0.0: r"^[0-9\p{L} _\\.]{3,16}$"
+consistent!(reaper_0, r"^[0-9\p{L} _\\.]{3,16}$");
+
+// retdec-0.1.0: r"^attachment; filename=(.+)$"
+consistent!(retdec_0, r"^attachment; filename=(.+)$");
+
+// renvsubst-0.1.2: r"(\\)(?P<head>\$[0-9A-Za-z_{])"
+consistent!(renvsubst_0, r"(\\)(?P<head>\$[0-9A-Za-z_{])");
+
+// renvsubst-0.1.2: r"\$([[:word:]]+)"
+consistent!(renvsubst_1, r"\$([[:word:]]+)");
+
+// renvsubst-0.1.2: r"\$\{([[:word:]]+)\}"
+consistent!(renvsubst_2, r"\$\{([[:word:]]+)\}");
+
+// rexpect-0.3.0: r"'[a-z]+'"
+consistent!(rexpect_0, r"'[a-z]+'");
+
+// rexpect-0.3.0: r"^\d{4}-\d{2}-\d{2}$"
+consistent!(rexpect_1, r"^\d{4}-\d{2}-\d{2}$");
+
+// rexpect-0.3.0: r"-\d{2}-"
+consistent!(rexpect_2, r"-\d{2}-");
+
+// luther-0.1.0: "^a(b|c)c*$"
+consistent!(luther_0, "^a(b|c)c*$");
+
+// little_boxes-1.6.0: r"(\x9B|\x1B\[)[0-?]*[ -/]*[@-~]"
+consistent!(little_boxes_0, r"(\x9B|\x1B\[)[0-?]*[ -/]*[@-~]");
+
+// libimagentrytag-0.8.0: "^[a-zA-Z]([a-zA-Z0-9_-]*)$"
+consistent!(libimagentrytag_0, "^[a-zA-Z]([a-zA-Z0-9_-]*)$");
+
+// libimaginteraction-0.8.0: r"^[Yy](\n?)$"
+consistent!(libimaginteraction_0, r"^[Yy](\n?)$");
+
+// libimaginteraction-0.8.0: r"^[Nn](\n?)$"
+consistent!(libimaginteraction_1, r"^[Nn](\n?)$");
+
+// libimagutil-0.8.0: "^(?P<KEY>([^=]*))=(.*)$"
+consistent!(libimagutil_0, "^(?P<KEY>([^=]*))=(.*)$");
+
+// libimagutil-0.8.0: "(.*)=(\"(?P<QVALUE>([^\"]*))\"|(?P<VALUE>(.*)))$"
+consistent!(libimagutil_1, "(.*)=(\"(?P<QVALUE>([^\"]*))\"|(?P<VALUE>(.*)))$");
+
+// linux_ip-0.1.0: r"\s+"
+consistent!(linux_ip_0, r"\s+");
+
+// linux_ip-0.1.0: r"\s*[\n\r]+\s*"
+consistent!(linux_ip_1, r"\s*[\n\r]+\s*");
+
+// linux_ip-0.1.0: r"^([0-9a-fA-F\.:/]+)\s+dev\s+([a-z0-9\.]+)\s*(.*)$"
+consistent!(linux_ip_2, r"^([0-9a-fA-F\.:/]+)\s+dev\s+([a-z0-9\.]+)\s*(.*)$");
+
+// linux_ip-0.1.0: r"^([0-9a-fA-F\.:/]+|default)\s+via\s+([a-z0-9\.:]+)\s+dev\s+([a-z0-9\.]+)\s*(.*)$"
+consistent!(linux_ip_3, r"^([0-9a-fA-F\.:/]+|default)\s+via\s+([a-z0-9\.:]+)\s+dev\s+([a-z0-9\.]+)\s*(.*)$");
+
+// linux_ip-0.1.0: r"^(blackhole)\s+([0-9a-fA-F\.:/]+)$"
+consistent!(linux_ip_4, r"^(blackhole)\s+([0-9a-fA-F\.:/]+)$");
+
+// linux_ip-0.1.0: r"^(unreachable)\s+([0-9a-fA-F\.:/]+)\s+dev\s+([a-z0-9\.]+)\s+(.*)$"
+consistent!(
+    linux_ip_5,
+    r"^(unreachable)\s+([0-9a-fA-F\.:/]+)\s+dev\s+([a-z0-9\.]+)\s+(.*)$"
+);
+
+// linux_ip-0.1.0: r"\s*[\n\r]+\s*"
+consistent!(linux_ip_6, r"\s*[\n\r]+\s*");
+
+// linux_ip-0.1.0: r"^\d+:\s+([a-zA-Z0-9\.-]+)(@\S+)*:\s+(.*)$"
+consistent!(linux_ip_7, r"^\d+:\s+([a-zA-Z0-9\.-]+)(@\S+)*:\s+(.*)$");
+
+// linux_ip-0.1.0: r"\s*link/ether\s+([a-f0-9:]+)\s+.*"
+consistent!(linux_ip_8, r"\s*link/ether\s+([a-f0-9:]+)\s+.*");
+
+// linux_ip-0.1.0: r"\s*inet[6]*\s+([0-9a-f:\./]+)\s+.*"
+consistent!(linux_ip_9, r"\s*inet[6]*\s+([0-9a-f:\./]+)\s+.*");
+
+// linky-0.1.4: r"[^\w -]"
+consistent!(linky_0, r"[^\w -]");
+
+// linky-0.1.4: r"^(.*):(\d+): [^ ]* ([^ ]*)$"
+consistent!(linky_1, r"^(.*):(\d+): [^ ]* ([^ ]*)$");
+
+// limonite-0.2.1: r"^(\d{4}-\d{2}-\d{2})-(\d{3})-(.+)$"
+consistent!(limonite_0, r"^(\d{4}-\d{2}-\d{2})-(\d{3})-(.+)$");
+
+// process-queue-0.1.1: r"^[a-zA-Z]+$"
+consistent!(process_queue_0, r"^[a-zA-Z]+$");
+
+// pronghorn-0.1.2: r"^\{([a-zA-Z_]+)\}$"
+consistent!(pronghorn_0, r"^\{([a-zA-Z_]+)\}$");
+
+// protocol-ftp-client-0.1.1: "(?m:^(\\d{3}) (.+)\r$)"
+consistent!(protocol_ftp_client_0, "(?m:^(\\d{3}) (.+)\r$)");
+
+// protocol-ftp-client-0.1.1: "\"(.+)\""
+consistent!(protocol_ftp_client_1, "\"(.+)\"");
+
+// protocol-ftp-client-0.1.1: "(\\w+) [Tt]ype: (\\w+)"
+consistent!(protocol_ftp_client_2, "(\\w+) [Tt]ype: (\\w+)");
+
+// protocol-ftp-client-0.1.1: "(?m:^(\\d{3})-.+\r$)"
+consistent!(protocol_ftp_client_3, "(?m:^(\\d{3})-.+\r$)");
+
+// protocol-ftp-client-0.1.1: "Entering Passive Mode \\((\\d+),(\\d+),(\\d+),(\\d+),(\\d+),(\\d+)\\)"
+consistent!(
+    protocol_ftp_client_4,
+    "Entering Passive Mode \\((\\d+),(\\d+),(\\d+),(\\d+),(\\d+),(\\d+)\\)"
+);
+
+// protocol-ftp-client-0.1.1: "(?m:^(.+)\r$)"
+consistent!(protocol_ftp_client_5, "(?m:^(.+)\r$)");
+
+// protocol-ftp-client-0.1.1: "^([d-])(?:[rwx-]{3}){3} +\\d+ +\\w+ +\\w+ +(\\d+) +(.+) +(.+)$"
+consistent!(
+    protocol_ftp_client_6,
+    "^([d-])(?:[rwx-]{3}){3} +\\d+ +\\w+ +\\w+ +(\\d+) +(.+) +(.+)$"
+);
+
+// article-date-extractor-0.1.1: r"([\./\-_]{0,1}(19|20)\d{2})[\./\-_]{0,1}(([0-3]{0,1}[0-9][\./\-_])|(\w{3,5}[\./\-_]))([0-3]{0,1}[0-9][\./\-]{0,1})"
+consistent!(article_date_extractor_0, r"([\./\-_]{0,1}(19|20)\d{2})[\./\-_]{0,1}(([0-3]{0,1}[0-9][\./\-_])|(\w{3,5}[\./\-_]))([0-3]{0,1}[0-9][\./\-]{0,1})");
+
+// article-date-extractor-0.1.1: r"(?i)publishdate|pubdate|timestamp|article_date|articledate|date"
+consistent!(
+    article_date_extractor_1,
+    r"(?i)publishdate|pubdate|timestamp|article_date|articledate|date"
+);
+
+// arthas_plugin-0.1.1: r"type\((.*)\)"
+consistent!(arthas_plugin_0, r"type\((.*)\)");
+
+// arthas_plugin-0.1.1: r"Vec<(.*)>"
+consistent!(arthas_plugin_1, r"Vec<(.*)>");
+
+// arthas_plugin-0.1.1: r"Option<(.*)>"
+consistent!(arthas_plugin_2, r"Option<(.*)>");
+
+// arthas_plugin-0.1.1: r"HashMap<[a-z0-9A-Z]+, *(.*)>"
+consistent!(arthas_plugin_3, r"HashMap<[a-z0-9A-Z]+, *(.*)>");
+
+// arthas_derive-0.1.0: "Vec *< *(.*) *>"
+consistent!(arthas_derive_0, "Vec *< *(.*) *>");
+
+// arthas_derive-0.1.0: r"Option *< *(.*) *>"
+consistent!(arthas_derive_1, r"Option *< *(.*) *>");
+
+// arthas_derive-0.1.0: r"HashMap *< *[a-z0-9A-Z]+ *, *(.*) *>"
+consistent!(arthas_derive_2, r"HashMap *< *[a-z0-9A-Z]+ *, *(.*) *>");
+
+// arpabet-0.2.0: r"^([\w\-\(\)\.']+)\s+([^\s].*)\s*$"
+consistent!(arpabet_0, r"^([\w\-\(\)\.']+)\s+([^\s].*)\s*$");
+
+// arpabet-0.2.0: r"^;;;\s+"
+consistent!(arpabet_1, r"^;;;\s+");
+
+// glossy_codegen-0.2.0: r"/\*.*?\*/|//.*"
+consistent!(glossy_codegen_0, r"/\*.*?\*/|//.*");
+
+// glossy_codegen-0.2.0: "^\\s*#\\s*include\\s+<([:print:]+)>\\s*$"
+consistent!(glossy_codegen_1, "^\\s*#\\s*include\\s+<([:print:]+)>\\s*$");
+
+// glossy_codegen-0.2.0: "^\\s*#\\s*include\\s+\"([:print:]+)\"\\s*$"
+consistent!(glossy_codegen_2, "^\\s*#\\s*include\\s+\"([:print:]+)\"\\s*$");
+
+// glossy_codegen-0.2.0: r"^\s*#\s*version\s+(\d+)"
+consistent!(glossy_codegen_3, r"^\s*#\s*version\s+(\d+)");
+
+// glossy_codegen-0.2.0: r"^\s*$"
+consistent!(glossy_codegen_4, r"^\s*$");
+
+// gluster-1.0.1: r"(?P<addr>via \S+)"
+consistent!(gluster_0, r"(?P<addr>via \S+)");
+
+// gluster-1.0.1: r"(?P<src>src \S+)"
+consistent!(gluster_1, r"(?P<src>src \S+)");
+
+// gl_helpers-0.1.7: r"(.*)\[\d+\]"
+consistent!(gl_helpers_0, r"(.*)\[\d+\]");
+
+// gl_helpers-0.1.7: r"(\d+).(\d+)"
+consistent!(gl_helpers_1, r"(\d+).(\d+)");
+
+// glr-parser-0.0.1: r"(?P<c>[\\\.\+\*\?\(\)\|\[\]\{\}\^\$])"
+consistent!(glr_parser_0, r"(?P<c>[\\\.\+\*\?\(\)\|\[\]\{\}\^\$])");
+
+// glr-parser-0.0.1: r"^\w+$"
+consistent!(glr_parser_1, r"^\w+$");
+
+// glr-parser-0.0.1: "'[^']+'"
+consistent!(glr_parser_2, "'[^']+'");
+
+// hoodlum-0.5.0: r"(?m)//.*"
+consistent!(hoodlum_0, r"(?m)//.*");
+
+// form-checker-0.2.2: r"^1\d{10}$"
+consistent!(form_checker_0, r"^1\d{10}$");
+
+// form-checker-0.2.2: r"(?i)^[\w.%+-]+@(?:[A-Z0-9-]+\.)+[A-Z]{2,4}$"
+consistent!(form_checker_1, r"(?i)^[\w.%+-]+@(?:[A-Z0-9-]+\.)+[A-Z]{2,4}$");
+
+// wikibase-0.2.0: r"(?P<user_agent>[a-zA-Z0-9-_]+/[0-9\.]+)"
+consistent!(wikibase_0, r"(?P<user_agent>[a-zA-Z0-9-_]+/[0-9\.]+)");
+
+// wifiscanner-0.3.6: r"Cell [0-9]{2,} - Address:"
+consistent!(wifiscanner_0, r"Cell [0-9]{2,} - Address:");
+
+// wifiscanner-0.3.6: r"([0-9a-zA-Z]{1}[0-9a-zA-Z]{1}[:]{1}){5}[0-9a-zA-Z]{1}[0-9a-zA-Z]{1}"
+consistent!(
+    wifiscanner_1,
+    r"([0-9a-zA-Z]{1}[0-9a-zA-Z]{1}[:]{1}){5}[0-9a-zA-Z]{1}[0-9a-zA-Z]{1}"
+);
+
+// wifiscanner-0.3.6: r"Signal level=(\d+)/100"
+consistent!(wifiscanner_2, r"Signal level=(\d+)/100");
+
+// bbcode-1.0.2: r"(?s)\[b\](.*?)\[/b\]"
+consistent!(bbcode_0, r"(?s)\[b\](.*?)\[/b\]");
+
+// bbcode-1.0.2: r"(?s)\[i\](.*?)\[/i\]"
+consistent!(bbcode_1, r"(?s)\[i\](.*?)\[/i\]");
+
+// bbcode-1.0.2: r"(?s)\[u\](.*?)\[/u\]"
+consistent!(bbcode_2, r"(?s)\[u\](.*?)\[/u\]");
+
+// bbcode-1.0.2: r"(?s)\[s\](.*?)\[/s\]"
+consistent!(bbcode_3, r"(?s)\[s\](.*?)\[/s\]");
+
+// bbcode-1.0.2: r"(?s)\[size=(\d+)](.*?)\[/size\]"
+consistent!(bbcode_4, r"(?s)\[size=(\d+)](.*?)\[/size\]");
+
+// bbcode-1.0.2: r"(?s)\[color=(.+)](.*?)\[/color\]"
+consistent!(bbcode_5, r"(?s)\[color=(.+)](.*?)\[/color\]");
+
+// bbcode-1.0.2: r"(?s)\[center\](.*?)\[/center\]"
+consistent!(bbcode_6, r"(?s)\[center\](.*?)\[/center\]");
+
+// bbcode-1.0.2: r"(?s)\[left\](.*?)\[/left\]"
+consistent!(bbcode_7, r"(?s)\[left\](.*?)\[/left\]");
+
+// bbcode-1.0.2: r"(?s)\[right\](.*?)\[/right\]"
+consistent!(bbcode_8, r"(?s)\[right\](.*?)\[/right\]");
+
+// bbcode-1.0.2: r"(?s)\[table\](.*?)\[/table\]"
+consistent!(bbcode_9, r"(?s)\[table\](.*?)\[/table\]");
+
+// bbcode-1.0.2: r"(?s)\[td\](.*?)\[/td\]"
+consistent!(bbcode_10, r"(?s)\[td\](.*?)\[/td\]");
+
+// bbcode-1.0.2: r"(?s)\[tr\](.*?)\[/tr\]"
+consistent!(bbcode_11, r"(?s)\[tr\](.*?)\[/tr\]");
+
+// bbcode-1.0.2: r"(?s)\[th\](.*?)\[/th\]"
+consistent!(bbcode_12, r"(?s)\[th\](.*?)\[/th\]");
+
+// bbcode-1.0.2: r"(?s)\[url\](.*?)\[/url\]"
+consistent!(bbcode_13, r"(?s)\[url\](.*?)\[/url\]");
+
+// bbcode-1.0.2: r"(?s)\[url=(.+)\](.*?)\[/url\]"
+consistent!(bbcode_14, r"(?s)\[url=(.+)\](.*?)\[/url\]");
+
+// bbcode-1.0.2: r"(?s)\[quote\](.*?)\[/quote\]"
+consistent!(bbcode_15, r"(?s)\[quote\](.*?)\[/quote\]");
+
+// bbcode-1.0.2: r"(?s)\[quote=(.+)\](.*?)\[/quote\]"
+consistent!(bbcode_16, r"(?s)\[quote=(.+)\](.*?)\[/quote\]");
+
+// bbcode-1.0.2: r"(?s)\[img=(\d+)x(\d+)(\b.*)?\](.*?)\[/img\]"
+consistent!(bbcode_17, r"(?s)\[img=(\d+)x(\d+)(\b.*)?\](.*?)\[/img\]");
+
+// bbcode-1.0.2: r"(?s)\[img=(.+)(\b.*)?\](.*?)\[/img\]"
+consistent!(bbcode_18, r"(?s)\[img=(.+)(\b.*)?\](.*?)\[/img\]");
+
+// bbcode-1.0.2: r"(?s)\[img(\b.*)?\](.*?)\[/img\]"
+consistent!(bbcode_19, r"(?s)\[img(\b.*)?\](.*?)\[/img\]");
+
+// bbcode-1.0.2: r"(?s)\[ol\](.*?)\[/ol\]"
+consistent!(bbcode_20, r"(?s)\[ol\](.*?)\[/ol\]");
+
+// bbcode-1.0.2: r"(?s)\[ul\](.*?)\[/ul\]"
+consistent!(bbcode_21, r"(?s)\[ul\](.*?)\[/ul\]");
+
+// bbcode-1.0.2: r"(?s)\[list\](.*?)\[/list\]"
+consistent!(bbcode_22, r"(?s)\[list\](.*?)\[/list\]");
+
+// bbcode-1.0.2: r"(?s)\[youtube\](.*?)\[/youtube\]"
+consistent!(bbcode_23, r"(?s)\[youtube\](.*?)\[/youtube\]");
+
+// bbcode-1.0.2: r"(?s)\[youtube=(\d+)x(\d+)\](.*?)\[/youtube\]"
+consistent!(bbcode_24, r"(?s)\[youtube=(\d+)x(\d+)\](.*?)\[/youtube\]");
+
+// bbcode-1.0.2: r"(?s)\[li\](.*?)\[/li\]"
+consistent!(bbcode_25, r"(?s)\[li\](.*?)\[/li\]");
+
+// block-utils-0.5.0: r"loop\d+"
+consistent!(block_utils_0, r"loop\d+");
+
+// block-utils-0.5.0: r"ram\d+"
+consistent!(block_utils_1, r"ram\d+");
+
+// block-utils-0.5.0: r"md\d+"
+consistent!(block_utils_2, r"md\d+");
+
+// kvvliveapi-0.1.0: r"^([1-9]) min$"
+consistent!(kvvliveapi_0, r"^([1-9]) min$");
+
+// rfc822_sanitizer-0.3.3: r"(\d{2}):(\d{2}):(\d{2})"
+consistent!(rfc822_sanitizer_0, r"(\d{2}):(\d{2}):(\d{2})");
+
+// rfc822_sanitizer-0.3.3: r"(\d{1,2}):(\d{1,2}):(\d{1,2})"
+consistent!(rfc822_sanitizer_1, r"(\d{1,2}):(\d{1,2}):(\d{1,2})");
+
+// faker-0.0.4: r"[2-9]"
+consistent!(faker_0, r"[2-9]");
+
+// faker-0.0.4: r"[1-9]"
+consistent!(faker_1, r"[1-9]");
+
+// faker-0.0.4: r"[0-9]"
+consistent!(faker_2, r"[0-9]");
+
+// faker-0.0.4: r"\d{10}"
+consistent!(faker_3, r"\d{10}");
+
+// faker-0.0.4: r"\d{1}"
+consistent!(faker_4, r"\d{1}");
+
+// faker-0.0.4: r"^\w+"
+consistent!(faker_5, r"^\w+");
+
+// faker-0.0.4: r"^\w+"
+consistent!(faker_6, r"^\w+");
+
+// faker-0.0.4: r"^(\w+\.? ?){2,3}$"
+consistent!(faker_7, r"^(\w+\.? ?){2,3}$");
+
+// faker-0.0.4: r"^[A-Z][a-z]+\.?$"
+consistent!(faker_8, r"^[A-Z][a-z]+\.?$");
+
+// faker-0.0.4: r"^[A-Z][A-Za-z]*\.?$"
+consistent!(faker_9, r"^[A-Z][A-Za-z]*\.?$");
+
+// faker-0.0.4: r"http://lorempixel.com/100/100/\w+"
+consistent!(faker_10, r"http://lorempixel.com/100/100/\w+");
+
+// faker-0.0.4: r"http://lorempixel.com/100/100/cats"
+consistent!(faker_11, r"http://lorempixel.com/100/100/cats");
+
+// fancy-regex-0.1.0: "(?i:ß)"
+consistent!(fancy_regex_0, "(?i:ß)");
+
+// fancy-regex-0.1.0: "(?i:\\x{0587})"
+consistent!(fancy_regex_1, "(?i:\\x{0587})");
+
+// fancy-regex-0.1.0: "^\\\\([!-/:-@\\[-`\\{-~aftnrv]|[0-7]{1,3}|x[0-9a-fA-F]{2}|x\\{[0-9a-fA-F]{1,6}\\})"
+consistent!(fancy_regex_2, "^\\\\([!-/:-@\\[-`\\{-~aftnrv]|[0-7]{1,3}|x[0-9a-fA-F]{2}|x\\{[0-9a-fA-F]{1,6}\\})");
+
+// fancy-prompt-0.1.5: r"/([^/])[^/]+/"
+consistent!(fancy_prompt_0, r"/([^/])[^/]+/");
+
+// fancy-prompt-0.1.5: r"^([^:]+):.*?(?::([^:]+))?$"
+consistent!(fancy_prompt_1, r"^([^:]+):.*?(?::([^:]+))?$");
+
+// fanta-0.2.0: r"^(/?__\w+__)/(.*)"
+consistent!(fanta_0, r"^(/?__\w+__)/(.*)");
+
+// fanta-cli-0.1.1: r"(.)([A-Z])"
+consistent!(fanta_cli_0, r"(.)([A-Z])");
+
+// fanta-cli-0.1.1: "\\{:[^\\s]+\\}"
+consistent!(fanta_cli_1, "\\{:[^\\s]+\\}");
+
+// amethyst_tools-0.7.1: "(?P<last>[^\r])\n"
+consistent!(amethyst_tools_0, "(?P<last>[^\r])\n");
+
+// amigo-0.3.1: r"^-?\d+(\.\d)?"
+consistent!(amigo_0, r"^-?\d+(\.\d)?");
+
+// amigo-0.3.1: r"^[a-zA-Z_]+[\w-]*[!?_]?"
+consistent!(amigo_1, r"^[a-zA-Z_]+[\w-]*[!?_]?");
+
+// amigo-0.3.1: r"^\("
+consistent!(amigo_2, r"^\(");
+
+// amigo-0.3.1: r"^\)"
+consistent!(amigo_3, r"^\)");
+
+// amigo-0.3.1: r"^\s+"
+consistent!(amigo_4, r"^\s+");
+
+// ethcore-logger-1.12.0: "\x1b\\[[^m]+m"
+consistent!(ethcore_logger_0, "\x1b\\[[^m]+m");
+
+// dash2html-1.0.1: r"__.*?__"
+consistent!(dash2html_0, r"__.*?__");
+
+// dash2html-1.0.1: r"(?i)@(?:time|clipboard|cursor|date)"
+consistent!(dash2html_1, r"(?i)@(?:time|clipboard|cursor|date)");
+
+// os_type-2.0.0: r"^Microsoft Windows \[Version\s(\d+\.\d+\.\d+)\]$"
+consistent!(os_type_0, r"^Microsoft Windows \[Version\s(\d+\.\d+\.\d+)\]$");
+
+// os_type-2.0.0: r"ProductName:\s([\w\s]+)\n"
+consistent!(os_type_1, r"ProductName:\s([\w\s]+)\n");
+
+// os_type-2.0.0: r"ProductVersion:\s(\w+\.\w+\.\w+)"
+consistent!(os_type_2, r"ProductVersion:\s(\w+\.\w+\.\w+)");
+
+// os_type-2.0.0: r"BuildVersion:\s(\w+)"
+consistent!(os_type_3, r"BuildVersion:\s(\w+)");
+
+// os_type-2.0.0: r"(\w+) Linux release"
+consistent!(os_type_4, r"(\w+) Linux release");
+
+// os_type-2.0.0: r"release\s([\w\.]+)"
+consistent!(os_type_5, r"release\s([\w\.]+)");
+
+// os_type-2.0.0: r"Distributor ID:\s(\w+)"
+consistent!(os_type_6, r"Distributor ID:\s(\w+)");
+
+// os_type-2.0.0: r"Release:\s([\w\.]+)"
+consistent!(os_type_7, r"Release:\s([\w\.]+)");
+
+// bindgen-0.37.0: r"typename type\-parameter\-\d+\-\d+::.+"
+consistent!(bindgen_0, r"typename type\-parameter\-\d+\-\d+::.+");
+
+// imap-0.8.1: "^+(.*)\r\n"
+consistent!(imap_0, "^+(.*)\r\n");
+
+// image-base64-0.1.0: r"^ffd8ffe0"
+consistent!(image_base64_0, r"^ffd8ffe0");
+
+// image-base64-0.1.0: r"^89504e47"
+consistent!(image_base64_1, r"^89504e47");
+
+// image-base64-0.1.0: r"^47494638"
+consistent!(image_base64_2, r"^47494638");
+
+// json-pointer-0.3.2: "^(/([^/~]|~[01])*)*$"
+consistent!(json_pointer_0, "^(/([^/~]|~[01])*)*$");
+
+// json-pointer-0.3.2: "^#(/([^/~%]|~[01]|%[0-9a-fA-F]{2})*)*$"
+consistent!(json_pointer_1, "^#(/([^/~%]|~[01]|%[0-9a-fA-F]{2})*)*$");
+
+// mysql_common-0.7.0: r"^5.5.5-(\d{1,2})\.(\d{1,2})\.(\d{1,3})-MariaDB"
+consistent!(mysql_common_0, r"^5.5.5-(\d{1,2})\.(\d{1,2})\.(\d{1,3})-MariaDB");
+
+// mysql_common-0.7.0: r"^(\d{1,2})\.(\d{1,2})\.(\d{1,3})(.*)"
+consistent!(mysql_common_1, r"^(\d{1,2})\.(\d{1,2})\.(\d{1,3})(.*)");
+
+// government_id-0.1.0: r"^[0-9]{4}[0-9A-Z]{2}[0-9]{3}$"
+consistent!(government_id_0, r"^[0-9]{4}[0-9A-Z]{2}[0-9]{3}$");
+
+// ohmers-0.1.1: r"UniqueIndexViolation: (\w+)"
+consistent!(ohmers_0, r"UniqueIndexViolation: (\w+)");
+
+// eliza-1.0.0: r"(.*) you are (.*)"
+consistent!(eliza_0, r"(.*) you are (.*)");
+
+// eliza-1.0.0: r"(.*) you are (.*)"
+consistent!(eliza_1, r"(.*) you are (.*)");
+
+// eliza-1.0.0: r"(.*) you are (.*)"
+consistent!(eliza_2, r"(.*) you are (.*)");
+
+// chema-0.0.5: "^\\s*\\*"
+consistent!(chema_0, "^\\s*\\*");
+
+// chema-0.0.5: "^\\s*@(\\w+)\\s+(.*)"
+consistent!(chema_1, "^\\s*@(\\w+)\\s+(.*)");
+
+// chord3-0.3.0: r"^\s*#"
+consistent!(chord3_0, r"^\s*#");
+
+// chord3-0.3.0: r"\{(?P<cmd>\w+)(?::?\s*(?P<arg>.*))?\}"
+consistent!(chord3_1, r"\{(?P<cmd>\w+)(?::?\s*(?P<arg>.*))?\}");
+
+// chord3-0.3.0: r"\{(eot|end_of_tab):?\s*"
+consistent!(chord3_2, r"\{(eot|end_of_tab):?\s*");
+
+// chord3-0.3.0: r"([^\[]*)(?:\[([^\]]*)\])?"
+consistent!(chord3_3, r"([^\[]*)(?:\[([^\]]*)\])?");
+
+// checkmail-0.1.1: "^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$"
+consistent!(checkmail_0, "^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$");
+
+// cntk-0.2.1: r"\b\w\w+\b"
+consistent!(cntk_0, r"\b\w\w+\b");
+
+// cntk-0.2.1: r"\b\w\w+\b"
+consistent!(cntk_1, r"\b\w\w+\b");
+
+// cniguru-0.1.0: r"\(id: (\d+)\)"
+consistent!(cniguru_0, r"\(id: (\d+)\)");
+
+// upm_lib-0.3.0: r"^(\d+)\.(\d+)\.(\d+)(?:-([\dA-Za-z-]+(?:\.[\dA-Za-z-]+)*))?(?:\+([\dA-Za-z-]+(?:\.[\dA-Za-z-]+)*))?$"
+consistent!(upm_lib_0, r"^(\d+)\.(\d+)\.(\d+)(?:-([\dA-Za-z-]+(?:\.[\dA-Za-z-]+)*))?(?:\+([\dA-Za-z-]+(?:\.[\dA-Za-z-]+)*))?$");
+
+// avro-0.2.1: r"^\s*(\*+(\s+))?"
+consistent!(avro_0, r"^\s*(\*+(\s+))?");
+
+// avro-0.2.1: r"^\s*(\*+)?"
+consistent!(avro_1, r"^\s*(\*+)?");
+
+// nomi-0.0.2: "[0-9]+"
+consistent!(nomi_0, "[0-9]+");
+
+// nodes-0.1.0: "([0-9]+)@(?:nodes|n)?:([^@]+)?"
+consistent!(nodes_0, "([0-9]+)@(?:nodes|n)?:([^@]+)?");
+
+// not-stakkr-1.0.0: r"(?i)in (\d+) (second|minute|hour|day|week)s?"
+consistent!(not_stakkr_0, r"(?i)in (\d+) (second|minute|hour|day|week)s?");
+
+// notetxt-0.0.1: "^([A-Za-z0-9 -_:]+)\n-+\n"
+consistent!(notetxt_0, "^([A-Za-z0-9 -_:]+)\n-+\n");
+
+// nail-0.1.0-pre.0: r"^-?[0-9]+(\.[0-9]+)?([eE]-?[0-9]+)?$"
+consistent!(nail_0, r"^-?[0-9]+(\.[0-9]+)?([eE]-?[0-9]+)?$");
+
+// nail-0.1.0-pre.0: r"^-?[0-9]+$"
+consistent!(nail_1, r"^-?[0-9]+$");
+
+// askalono-0.2.0: r"[^\w\s\pP]+"
+consistent!(askalono_0, r"[^\w\s\pP]+");
+
+// askalono-0.2.0: r"(?x)[ \t\p{Zs} \\ / \| \x2044 ]+"
+consistent!(askalono_1, r"(?x)[ \t\p{Zs} \\ / \| \x2044 ]+");
+
+// askalono-0.2.0: r"\p{Pd}+"
+consistent!(askalono_2, r"\p{Pd}+");
+
+// askalono-0.2.0: r"\p{Ps}+"
+consistent!(askalono_3, r"\p{Ps}+");
+
+// askalono-0.2.0: r"\p{Pe}+"
+consistent!(askalono_4, r"\p{Pe}+");
+
+// askalono-0.2.0: r"\p{Pc}+"
+consistent!(askalono_5, r"\p{Pc}+");
+
+// askalono-0.2.0: r"[©Ⓒⓒ]"
+consistent!(askalono_6, r"[©Ⓒⓒ]");
+
+// askalono-0.2.0: r"[\r\n\v\f]"
+consistent!(askalono_7, r"[\r\n\v\f]");
+
+// askalono-0.2.0: r"\n{3,}"
+consistent!(askalono_8, r"\n{3,}");
+
+// askalono-0.2.0: r"[^\w\s]+"
+consistent!(askalono_9, r"[^\w\s]+");
+
+// askalono-0.2.0: r"\s+"
+consistent!(askalono_10, r"\s+");
+
+// assembunny_plus-0.0.3: r"[^0-9a-zA-Z_]"
+consistent!(assembunny_plus_0, r"[^0-9a-zA-Z_]");
+
+// assembunny_plus-0.0.3: r"[0-9]"
+consistent!(assembunny_plus_1, r"[0-9]");
+
+// salt-compressor-0.4.0: r"(?m)^Minion (\S*) did not respond\. No job will be sent\.$"
+consistent!(
+    salt_compressor_0,
+    r"(?m)^Minion (\S*) did not respond\. No job will be sent\.$"
+);
+
+// sabisabi-0.4.1: r"</?[^>]+?>"
+consistent!(sabisabi_0, r"</?[^>]+?>");
+
+// sabisabi-0.4.1: r"\([^)]*\)"
+consistent!(sabisabi_1, r"\([^)]*\)");
+
+// sassers-0.13.5-h28: "@import \"([^\"]*)\";"
+consistent!(sassers_0, "@import \"([^\"]*)\";");
+
+// shadowsocks-0.6.2: r"[A-Za-z\d-]{1,63}$"
+consistent!(shadowsocks_0, r"[A-Za-z\d-]{1,63}$");
+
+// shkeleton-0.1.5: "[abc]+"
+consistent!(shkeleton_0, "[abc]+");
+
+// shellwords-0.1.0: r"([^A-Za-z0-9_\-.,:/@\n])"
+consistent!(shellwords_0, r"([^A-Za-z0-9_\-.,:/@\n])");
+
+// shellwords-0.1.0: r"\n"
+consistent!(shellwords_1, r"\n");
+
+// shush-0.1.5: "(?P<num>[0-9]+)(?P<units>[dhms])"
+consistent!(shush_0, "(?P<num>[0-9]+)(?P<units>[dhms])");
+
+// woothee-0.8.0: r"(?:Chrome|CrMo|CriOS)/([.0-9]+)"
+consistent!(woothee_0, r"(?:Chrome|CrMo|CriOS)/([.0-9]+)");
+
+// woothee-0.8.0: r"Vivaldi/([.0-9]+)"
+consistent!(woothee_1, r"Vivaldi/([.0-9]+)");
+
+// woothee-0.8.0: r"Firefox/([.0-9]+)"
+consistent!(woothee_2, r"Firefox/([.0-9]+)");
+
+// woothee-0.8.0: r"^Mozilla/[.0-9]+ \((?:Mobile|Tablet);(?:.*;)? rv:([.0-9]+)\) Gecko/[.0-9]+ Firefox/[.0-9]+$"
+consistent!(woothee_3, r"^Mozilla/[.0-9]+ \((?:Mobile|Tablet);(?:.*;)? rv:([.0-9]+)\) Gecko/[.0-9]+ Firefox/[.0-9]+$");
+
+// woothee-0.8.0: r"FxiOS/([.0-9]+)"
+consistent!(woothee_4, r"FxiOS/([.0-9]+)");
+
+// woothee-0.8.0: r"\(([^;)]+);FOMA;"
+consistent!(woothee_5, r"\(([^;)]+);FOMA;");
+
+// woothee-0.8.0: r"jig browser[^;]+; ([^);]+)"
+consistent!(woothee_6, r"jig browser[^;]+; ([^);]+)");
+
+// woothee-0.8.0: r"(?i)rss(?:reader|bar|[-_ /;()]|[ +]*/)"
+consistent!(woothee_7, r"(?i)rss(?:reader|bar|[-_ /;()]|[ +]*/)");
+
+// woothee-0.8.0: r"(?i)(?:bot|crawler|spider)(?:[-_ ./;@()]|$)"
+consistent!(woothee_8, r"(?i)(?:bot|crawler|spider)(?:[-_ ./;@()]|$)");
+
+// woothee-0.8.0: r"(?i)(?:feed|web) ?parser"
+consistent!(woothee_9, r"(?i)(?:feed|web) ?parser");
+
+// woothee-0.8.0: r"(?i)watch ?dog"
+consistent!(woothee_10, r"(?i)watch ?dog");
+
+// woothee-0.8.0: r"Edge/([.0-9]+)"
+consistent!(woothee_11, r"Edge/([.0-9]+)");
+
+// woothee-0.8.0: r"MSIE ([.0-9]+);"
+consistent!(woothee_12, r"MSIE ([.0-9]+);");
+
+// woothee-0.8.0: r"Version/([.0-9]+)"
+consistent!(woothee_13, r"Version/([.0-9]+)");
+
+// woothee-0.8.0: r"Opera[/ ]([.0-9]+)"
+consistent!(woothee_14, r"Opera[/ ]([.0-9]+)");
+
+// woothee-0.8.0: r"OPR/([.0-9]+)"
+consistent!(woothee_15, r"OPR/([.0-9]+)");
+
+// woothee-0.8.0: r"Version/([.0-9]+)"
+consistent!(woothee_16, r"Version/([.0-9]+)");
+
+// woothee-0.8.0: r"(?:SoftBank|Vodafone|J-PHONE)/[.0-9]+/([^ /;()]+)"
+consistent!(woothee_17, r"(?:SoftBank|Vodafone|J-PHONE)/[.0-9]+/([^ /;()]+)");
+
+// woothee-0.8.0: r"Trident/([.0-9]+);"
+consistent!(woothee_18, r"Trident/([.0-9]+);");
+
+// woothee-0.8.0: r" rv:([.0-9]+)"
+consistent!(woothee_19, r" rv:([.0-9]+)");
+
+// woothee-0.8.0: r"IEMobile/([.0-9]+);"
+consistent!(woothee_20, r"IEMobile/([.0-9]+);");
+
+// woothee-0.8.0: r"(?:WILLCOM|DDIPOCKET);[^/]+/([^ /;()]+)"
+consistent!(woothee_21, r"(?:WILLCOM|DDIPOCKET);[^/]+/([^ /;()]+)");
+
+// woothee-0.8.0: r"Windows ([ .a-zA-Z0-9]+)[;\\)]"
+consistent!(woothee_22, r"Windows ([ .a-zA-Z0-9]+)[;\\)]");
+
+// woothee-0.8.0: r"^Phone(?: OS)? ([.0-9]+)"
+consistent!(woothee_23, r"^Phone(?: OS)? ([.0-9]+)");
+
+// woothee-0.8.0: r"iP(hone;|ad;|od) .*like Mac OS X"
+consistent!(woothee_24, r"iP(hone;|ad;|od) .*like Mac OS X");
+
+// woothee-0.8.0: r"Version/([.0-9]+)"
+consistent!(woothee_25, r"Version/([.0-9]+)");
+
+// woothee-0.8.0: r"rv:(\d+\.\d+\.\d+)"
+consistent!(woothee_26, r"rv:(\d+\.\d+\.\d+)");
+
+// woothee-0.8.0: r"FreeBSD ([^;\)]+);"
+consistent!(woothee_27, r"FreeBSD ([^;\)]+);");
+
+// woothee-0.8.0: r"CrOS ([^\)]+)\)"
+consistent!(woothee_28, r"CrOS ([^\)]+)\)");
+
+// woothee-0.8.0: r"Android[- ](\d+\.\d+(?:\.\d+)?)"
+consistent!(woothee_29, r"Android[- ](\d+\.\d+(?:\.\d+)?)");
+
+// woothee-0.8.0: r"PSP \(PlayStation Portable\); ([.0-9]+)\)"
+consistent!(woothee_30, r"PSP \(PlayStation Portable\); ([.0-9]+)\)");
+
+// woothee-0.8.0: r"PLAYSTATION 3;? ([.0-9]+)\)"
+consistent!(woothee_31, r"PLAYSTATION 3;? ([.0-9]+)\)");
+
+// woothee-0.8.0: r"PlayStation Vita ([.0-9]+)\)"
+consistent!(woothee_32, r"PlayStation Vita ([.0-9]+)\)");
+
+// woothee-0.8.0: r"PlayStation 4 ([.0-9]+)\)"
+consistent!(woothee_33, r"PlayStation 4 ([.0-9]+)\)");
+
+// woothee-0.8.0: r"BB10(?:.+)Version/([.0-9]+) "
+consistent!(woothee_34, r"BB10(?:.+)Version/([.0-9]+) ");
+
+// woothee-0.8.0: r"BlackBerry(?:\d+)/([.0-9]+) "
+consistent!(woothee_35, r"BlackBerry(?:\d+)/([.0-9]+) ");
+
+// woothee-0.8.0: r"; CPU(?: iPhone)? OS (\d+_\d+(?:_\d+)?) like Mac OS X"
+consistent!(
+    woothee_36,
+    r"; CPU(?: iPhone)? OS (\d+_\d+(?:_\d+)?) like Mac OS X"
+);
+
+// woothee-0.8.0: r"Mac OS X (10[._]\d+(?:[._]\d+)?)(?:\)|;)"
+consistent!(woothee_37, r"Mac OS X (10[._]\d+(?:[._]\d+)?)(?:\)|;)");
+
+// woothee-0.8.0: r"^(?:Apache-HttpClient/|Jakarta Commons-HttpClient/|Java/)"
+consistent!(
+    woothee_38,
+    r"^(?:Apache-HttpClient/|Jakarta Commons-HttpClient/|Java/)"
+);
+
+// woothee-0.8.0: r"[- ]HttpClient(/|$)"
+consistent!(woothee_39, r"[- ]HttpClient(/|$)");
+
+// woothee-0.8.0: r"^(?:PHP|WordPress|CakePHP|PukiWiki|PECL::HTTP)(?:/| |$)"
+consistent!(
+    woothee_40,
+    r"^(?:PHP|WordPress|CakePHP|PukiWiki|PECL::HTTP)(?:/| |$)"
+);
+
+// woothee-0.8.0: r"(?:PEAR HTTP_Request|HTTP_Request)(?: class|2)"
+consistent!(woothee_41, r"(?:PEAR HTTP_Request|HTTP_Request)(?: class|2)");
+
+// woothee-0.8.0: r"(?:Rome Client |UnwindFetchor/|ia_archiver |Summify |PostRank/)"
+consistent!(
+    woothee_42,
+    r"(?:Rome Client |UnwindFetchor/|ia_archiver |Summify |PostRank/)"
+);
+
+// woothee-0.8.0: r"Sleipnir/([.0-9]+)"
+consistent!(woothee_43, r"Sleipnir/([.0-9]+)");
+
+// word_replace-0.0.3: r"@@[a-z|A-Z|\d]+@@"
+consistent!(word_replace_0, r"@@[a-z|A-Z|\d]+@@");
+
+// wordcount-0.1.0: r"\w+"
+consistent!(wordcount_0, r"\w+");
+
+// just-0.3.12: "^([^=]+)=(.*)$"
+consistent!(just_0, "^([^=]+)=(.*)$");
+
+// emote-0.1.0: r":[a-zA-Z_]+?:"
+consistent!(emote_0, r":[a-zA-Z_]+?:");
+
+// emojicons-1.0.1: r":([a-zA-Z0-9_+-]+):"
+consistent!(emojicons_0, r":([a-zA-Z0-9_+-]+):");
+
+// git2_codecommit-0.1.2: r"git-codecommit\.([a-z0-9-]+)\.amazonaws\.com"
+consistent!(
+    git2_codecommit_0,
+    r"git-codecommit\.([a-z0-9-]+)\.amazonaws\.com"
+);
+
+// git-workarea-3.1.2: r"^submodule\.(?P<name>.*)\.(?P<key>[^=]*)=(?P<value>.*)$"
+consistent!(
+    git_workarea_0,
+    r"^submodule\.(?P<name>.*)\.(?P<key>[^=]*)=(?P<value>.*)$"
+);
+
+// git-shell-enforce-directory-1.0.0: r"^(?P<command>git-(?:receive|upload)-pack) '(?P<path>.+)'$"
+consistent!(
+    git_shell_enforce_directory_0,
+    r"^(?P<command>git-(?:receive|upload)-pack) '(?P<path>.+)'$"
+);
+
+// git-journal-1.6.3: r"[ \n]:(.*?):"
+consistent!(git_journal_0, r"[ \n]:(.*?):");
+
+// git-find-0.3.2: r"^git@(?P<host>[[:alnum:]\._-]+):(?P<path>[[:alnum:]\._\-/]+).git$"
+consistent!(
+    git_find_0,
+    r"^git@(?P<host>[[:alnum:]\._-]+):(?P<path>[[:alnum:]\._\-/]+).git$"
+);
+
+// gitlab-api-0.6.0: r"private_token=\w{20}"
+consistent!(gitlab_api_0, r"private_token=\w{20}");
+
+// td-client-0.7.0: "^(http://|https://)"
+consistent!(td_client_0, "^(http://|https://)");
+
+// karaconv-0.3.0: r"--(?P<type>[a-zA-Z]+)-- (?P<contents>.*)"
+consistent!(karaconv_0, r"--(?P<type>[a-zA-Z]+)-- (?P<contents>.*)");
+
+// katana-1.0.2: r"(?P<comp>et al\.)(?:\.)"
+consistent!(katana_0, r"(?P<comp>et al\.)(?:\.)");
+
+// katana-1.0.2: r"\.{3}"
+consistent!(katana_1, r"\.{3}");
+
+// katana-1.0.2: r"(?P<number>[0-9]+)\.(?P<decimal>[0-9]+)"
+consistent!(katana_2, r"(?P<number>[0-9]+)\.(?P<decimal>[0-9]+)");
+
+// katana-1.0.2: r"\s\.(?P<nums>[0-9]+)"
+consistent!(katana_3, r"\s\.(?P<nums>[0-9]+)");
+
+// katana-1.0.2: r"(?:[A-Za-z]\.){2,}"
+consistent!(katana_4, r"(?:[A-Za-z]\.){2,}");
+
+// katana-1.0.2: r"(?P<init>[A-Z])(?P<point>\.)"
+consistent!(katana_5, r"(?P<init>[A-Z])(?P<point>\.)");
+
+// katana-1.0.2: r"(?P<title>[A-Z][a-z]{1,3})(\.)"
+consistent!(katana_6, r"(?P<title>[A-Z][a-z]{1,3})(\.)");
+
+// katana-1.0.2: r"&==&(?P<p>[.!?])"
+consistent!(katana_7, r"&==&(?P<p>[.!?])");
+
+// katana-1.0.2: r"&\^&(?P<p>[.!?])"
+consistent!(katana_8, r"&\^&(?P<p>[.!?])");
+
+// katana-1.0.2: r"&\*\*&(?P<p>[.!?])"
+consistent!(katana_9, r"&\*\*&(?P<p>[.!?])");
+
+// katana-1.0.2: r"&=&(?P<p>[.!?])"
+consistent!(katana_10, r"&=&(?P<p>[.!?])");
+
+// katana-1.0.2: r"&##&(?P<p>[.!?])"
+consistent!(katana_11, r"&##&(?P<p>[.!?])");
+
+// katana-1.0.2: r"&\$&(?P<p>[.!?])"
+consistent!(katana_12, r"&\$&(?P<p>[.!?])");
+
+// kailua_syntax-1.1.0: r"@(?:_|\d+(?:/\d+(?:-\d+)?)?)"
+consistent!(kailua_syntax_0, r"@(?:_|\d+(?:/\d+(?:-\d+)?)?)");
+
+// kailua_syntax-1.1.0: r"<(\d+)>"
+consistent!(kailua_syntax_1, r"<(\d+)>");
+
+// ftp-3.0.1: r"\((\d+),(\d+),(\d+),(\d+),(\d+),(\d+)\)"
+consistent!(ftp_0, r"\((\d+),(\d+),(\d+),(\d+),(\d+),(\d+)\)");
+
+// ftp-3.0.1: r"\b(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})\b"
+consistent!(ftp_1, r"\b(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})\b");
+
+// ftp-3.0.1: r"\s+(\d+)\s*$"
+consistent!(ftp_2, r"\s+(\d+)\s*$");
+
+// vat-0.1.0: r"<countryCode>(.*?)</countryCode>"
+consistent!(vat_0, r"<countryCode>(.*?)</countryCode>");
+
+// vat-0.1.0: r"<vatNumber>(.*?)</vatNumber>"
+consistent!(vat_1, r"<vatNumber>(.*?)</vatNumber>");
+
+// vat-0.1.0: r"<name>(.*?)</name>"
+consistent!(vat_2, r"<name>(.*?)</name>");
+
+// vat-0.1.0: r"<address>(?s)(.*?)(?-s)</address>"
+consistent!(vat_3, r"<address>(?s)(.*?)(?-s)</address>");
+
+// vat-0.1.0: r"<valid>(true|false)</valid>"
+consistent!(vat_4, r"<valid>(true|false)</valid>");
+
+// vat-0.1.0: r"^ATU\d{8}$"
+consistent!(vat_5, r"^ATU\d{8}$");
+
+// vat-0.1.0: r"^BE0?\d{9, 10}$"
+consistent!(vat_6, r"^BE0?\d{9, 10}$");
+
+// vat-0.1.0: r"^BG\d{9,10}$"
+consistent!(vat_7, r"^BG\d{9,10}$");
+
+// vat-0.1.0: r"^HR\d{11}$"
+consistent!(vat_8, r"^HR\d{11}$");
+
+// vat-0.1.0: r"^CY\d{8}[A-Z]$"
+consistent!(vat_9, r"^CY\d{8}[A-Z]$");
+
+// vat-0.1.0: r"^CZ\d{8,10}$"
+consistent!(vat_10, r"^CZ\d{8,10}$");
+
+// vat-0.1.0: r"^DK\d{8}$"
+consistent!(vat_11, r"^DK\d{8}$");
+
+// vat-0.1.0: r"^EE\d{9}$"
+consistent!(vat_12, r"^EE\d{9}$");
+
+// vat-0.1.0: r"^FI\d{8}$"
+consistent!(vat_13, r"^FI\d{8}$");
+
+// vat-0.1.0: r"^FR[A-HJ-NP-Z0-9][A-HJ-NP-Z0-9]\d{9}$"
+consistent!(vat_14, r"^FR[A-HJ-NP-Z0-9][A-HJ-NP-Z0-9]\d{9}$");
+
+// vat-0.1.0: r"^DE\d{9}$"
+consistent!(vat_15, r"^DE\d{9}$");
+
+// vat-0.1.0: r"^EL\d{9}$"
+consistent!(vat_16, r"^EL\d{9}$");
+
+// vat-0.1.0: r"^HU\d{8}$"
+consistent!(vat_17, r"^HU\d{8}$");
+
+// vat-0.1.0: r"^IE\d[A-Z0-9\+\*]\d{5}[A-Z]{1,2}$"
+consistent!(vat_18, r"^IE\d[A-Z0-9\+\*]\d{5}[A-Z]{1,2}$");
+
+// vat-0.1.0: r"^IT\d{11}$"
+consistent!(vat_19, r"^IT\d{11}$");
+
+// vat-0.1.0: r"^LV\d{11}$"
+consistent!(vat_20, r"^LV\d{11}$");
+
+// vat-0.1.0: r"^LT(\d{9}|\d{12})$"
+consistent!(vat_21, r"^LT(\d{9}|\d{12})$");
+
+// vat-0.1.0: r"^LU\d{8}$"
+consistent!(vat_22, r"^LU\d{8}$");
+
+// vat-0.1.0: r"^MT\d{8}$"
+consistent!(vat_23, r"^MT\d{8}$");
+
+// vat-0.1.0: r"^NL\d{9}B\d{2}$"
+consistent!(vat_24, r"^NL\d{9}B\d{2}$");
+
+// vat-0.1.0: r"^PL\d{10}$"
+consistent!(vat_25, r"^PL\d{10}$");
+
+// vat-0.1.0: r"^PT\d{9}$"
+consistent!(vat_26, r"^PT\d{9}$");
+
+// vat-0.1.0: r"^RO\d{2,10}$"
+consistent!(vat_27, r"^RO\d{2,10}$");
+
+// vat-0.1.0: r"^SK\d{10}$"
+consistent!(vat_28, r"^SK\d{10}$");
+
+// vat-0.1.0: r"^SI\d{8}$"
+consistent!(vat_29, r"^SI\d{8}$");
+
+// vat-0.1.0: r"^ES[A-Z0-9]\d{7}[A-Z0-9]$"
+consistent!(vat_30, r"^ES[A-Z0-9]\d{7}[A-Z0-9]$");
+
+// vat-0.1.0: r"^SE\d{10}01$"
+consistent!(vat_31, r"^SE\d{10}01$");
+
+// vat-0.1.0: r"^(GB(GD|HA)\d{3}|GB\d{9}|GB\d{12})$"
+consistent!(vat_32, r"^(GB(GD|HA)\d{3}|GB\d{9}|GB\d{12})$");
+
+// eve-0.1.1: r"\{\{(.*)\}\}"
+consistent!(eve_0, r"\{\{(.*)\}\}");
+
+// egc-0.1.2: "^mio"
+consistent!(egc_0, "^mio");
+
+// pew-0.2.3: ""
+consistent!(pew_0, "");
+
+// pew-0.2.3: ""
+consistent!(pew_1, "");
+
+// mob-0.4.3: "y"
+consistent!(mob_0, "y");
+
+// lit-0.2.8: "@([a-z]+)"
+consistent!(lit_0, "@([a-z]+)");
+
+// lit-0.2.8: "([A-Z-]+):(.*)"
+consistent!(lit_1, "([A-Z-]+):(.*)");
+
+// lit-0.2.8: "^[a-zA-Z_][a-zA-Z0-9_]*$"
+consistent!(lit_2, "^[a-zA-Z_][a-zA-Z0-9_]*$");
+
+// avm-1.0.1: r"\d+\.\d+\.\d+"
+consistent!(avm_0, r"\d+\.\d+\.\d+");
+
+// avm-1.0.1: r"\d+\.\d+\.\d+"
+consistent!(avm_1, r"\d+\.\d+\.\d+");
+
+// orm-0.2.0: r"^Vec<(.+)>$"
+consistent!(orm_0, r"^Vec<(.+)>$");
+
+// sgf-0.1.5: r"\\(\r\n|\n\r|\n|\r)"
+consistent!(sgf_0, r"\\(\r\n|\n\r|\n|\r)");
+
+// sgf-0.1.5: r"\\(.)"
+consistent!(sgf_1, r"\\(.)");
+
+// sgf-0.1.5: r"\r\n|\n\r|\n|\r"
+consistent!(sgf_2, r"\r\n|\n\r|\n|\r");
+
+// sgf-0.1.5: r"([\]\\:])"
+consistent!(sgf_3, r"([\]\\:])");
+
+// dok-0.2.0: "^Bearer realm=\"(.+?)\",service=\"(.+?)\",scope=\"(.+?)\"$"
+consistent!(
+    dok_0,
+    "^Bearer realm=\"(.+?)\",service=\"(.+?)\",scope=\"(.+?)\"$"
+);
+
+// d20-0.1.0: r"([+-]?\s*\d+[dD]\d+|[+-]?\s*\d+)"
+consistent!(d20_0, r"([+-]?\s*\d+[dD]\d+|[+-]?\s*\d+)");
+
+// dvb-0.3.0: "E"
+consistent!(dvb_0, "E");
+
+// dvb-0.3.0: "^F"
+consistent!(dvb_1, "^F");
+
+// dvb-0.3.0: "^S"
+consistent!(dvb_2, "^S");
+
+// ger-0.2.0: r"Change-Id: (I[a-f0-9]{40})$"
+consistent!(ger_0, r"Change-Id: (I[a-f0-9]{40})$");
+
+// ger-0.2.0: r"(refs|ref|fix|fixes|close|closes)\s+([A-Z]{2,5}-[0-9]{1,5})$"
+consistent!(
+    ger_1,
+    r"(refs|ref|fix|fixes|close|closes)\s+([A-Z]{2,5}-[0-9]{1,5})$"
+);
+
+// n5-0.2.1: r"(\d+)(\.(\d+))?(\.(\d+))?(.*)"
+consistent!(n5_0, r"(\d+)(\.(\d+))?(\.(\d+))?(.*)");
+
+// po-0.1.4: r"[A-Za-z0-9]"
+consistent!(po_0, r"[A-Za-z0-9]");
+
+// carnix-0.8.5: "path is (‘|')?([^’'\n]*)(’|')?"
+consistent!(carnix_0, "path is (‘|')?([^’'\n]*)(’|')?");
+
+// carnix-0.8.5: r"^(\S*) (\d*)\.(\d*)\.(\d*)(-(\S*))?(.*)?"
+consistent!(carnix_1, r"^(\S*) (\d*)\.(\d*)\.(\d*)(-(\S*))?(.*)?");
+
+// carnix-0.8.5: r"(\d*)\.(\d*)\.(\d*)(-(\S*))?"
+consistent!(carnix_2, r"(\d*)\.(\d*)\.(\d*)(-(\S*))?");
+
+// carnix-0.8.5: r"(\S*)-(\d*)\.(\d*)\.(\d*)(-(\S*))?"
+consistent!(carnix_3, r"(\S*)-(\d*)\.(\d*)\.(\d*)(-(\S*))?");
+
+// caseless-0.2.1: r"^# CaseFolding-(\d+)\.(\d+)\.(\d+).txt$"
+consistent!(caseless_0, r"^# CaseFolding-(\d+)\.(\d+)\.(\d+).txt$");
+
+// caseless-0.2.1: r"^([0-9A-F]+); [CF]; ([0-9A-F ]+);"
+consistent!(caseless_1, r"^([0-9A-F]+); [CF]; ([0-9A-F ]+);");
+
+// cabot-0.2.0: "\r?\n\r?\n"
+consistent!(cabot_0, "\r?\n\r?\n");
+
+// cabot-0.2.0: "\r?\n"
+consistent!(cabot_1, "\r?\n");
+
+// card-validate-2.2.1: r"^600"
+consistent!(card_validate_0, r"^600");
+
+// card-validate-2.2.1: r"^5019"
+consistent!(card_validate_1, r"^5019");
+
+// card-validate-2.2.1: r"^4"
+consistent!(card_validate_2, r"^4");
+
+// card-validate-2.2.1: r"^(5[1-5]|2[2-7])"
+consistent!(card_validate_3, r"^(5[1-5]|2[2-7])");
+
+// card-validate-2.2.1: r"^3[47]"
+consistent!(card_validate_4, r"^3[47]");
+
+// card-validate-2.2.1: r"^3[0689]"
+consistent!(card_validate_5, r"^3[0689]");
+
+// card-validate-2.2.1: r"^6([045]|22)"
+consistent!(card_validate_6, r"^6([045]|22)");
+
+// card-validate-2.2.1: r"^(62|88)"
+consistent!(card_validate_7, r"^(62|88)");
+
+// card-validate-2.2.1: r"^35"
+consistent!(card_validate_8, r"^35");
+
+// card-validate-2.2.1: r"^[0-9]+$"
+consistent!(card_validate_9, r"^[0-9]+$");
+
+// cargo-testify-0.3.0: r"\d{1,} passed.*filtered out"
+consistent!(cargo_testify_0, r"\d{1,} passed.*filtered out");
+
+// cargo-testify-0.3.0: r"error(:|\[).*"
+consistent!(cargo_testify_1, r"error(:|\[).*");
+
+// cargo-wix-0.0.5: r"<(.*?)>"
+consistent!(cargo_wix_0, r"<(.*?)>");
+
+// cargo-wix-0.0.5: r"<(.*?)>"
+consistent!(cargo_wix_1, r"<(.*?)>");
+
+// cargo-wix-0.0.5: r"<(.*?)>"
+consistent!(cargo_wix_2, r"<(.*?)>");
+
+// cargo-wix-0.0.5: r"<(.*?)>"
+consistent!(cargo_wix_3, r"<(.*?)>");
+
+// cargo-incremental-0.1.23: r"(?m)^incremental: re-using (\d+) out of (\d+) modules$"
+consistent!(
+    cargo_incremental_0,
+    r"(?m)^incremental: re-using (\d+) out of (\d+) modules$"
+);
+
+// cargo-incremental-0.1.23: "(?m)(warning|error): (.*)\n  --> ([^:]:\\d+:\\d+)$"
+consistent!(
+    cargo_incremental_1,
+    "(?m)(warning|error): (.*)\n  --> ([^:]:\\d+:\\d+)$"
+);
+
+// cargo-incremental-0.1.23: r"(?m)^test (.*) \.\.\. (\w+)"
+consistent!(cargo_incremental_2, r"(?m)^test (.*) \.\.\. (\w+)");
+
+// cargo-incremental-0.1.23: r"(?m)(\d+) passed; (\d+) failed; (\d+) ignored; \d+ measured"
+consistent!(
+    cargo_incremental_3,
+    r"(?m)(\d+) passed; (\d+) failed; (\d+) ignored; \d+ measured"
+);
+
+// cargo-testjs-0.1.2: r"^[^-]+-[0-9a-f]+\.js$"
+consistent!(cargo_testjs_0, r"^[^-]+-[0-9a-f]+\.js$");
+
+// cargo-tarpaulin-0.6.2: r"\s*//"
+consistent!(cargo_tarpaulin_0, r"\s*//");
+
+// cargo-tarpaulin-0.6.2: r"/\*"
+consistent!(cargo_tarpaulin_1, r"/\*");
+
+// cargo-tarpaulin-0.6.2: r"\*/"
+consistent!(cargo_tarpaulin_2, r"\*/");
+
+// cargo-culture-kit-0.1.0: r"^fo"
+consistent!(cargo_culture_kit_0, r"^fo");
+
+// cargo-screeps-0.1.3: "\\s+"
+consistent!(cargo_screeps_0, "\\s+");
+
+// cargo-brew-0.1.4: r"`(\S+) v([0-9.]+)"
+consistent!(cargo_brew_0, r"`(\S+) v([0-9.]+)");
+
+// cargo-release-0.10.2: "^\\[.+\\]"
+consistent!(cargo_release_0, "^\\[.+\\]");
+
+// cargo-release-0.10.2: "^\\[\\[.+\\]\\]"
+consistent!(cargo_release_1, "^\\[\\[.+\\]\\]");
+
+// cargo-edit-0.3.0-beta.1: r"^https://github.com/([-_0-9a-zA-Z]+)/([-_0-9a-zA-Z]+)(/|.git)?$"
+consistent!(
+    cargo_edit_0,
+    r"^https://github.com/([-_0-9a-zA-Z]+)/([-_0-9a-zA-Z]+)(/|.git)?$"
+);
+
+// cargo-edit-0.3.0-beta.1: r"^https://gitlab.com/([-_0-9a-zA-Z]+)/([-_0-9a-zA-Z]+)(/|.git)?$"
+consistent!(
+    cargo_edit_1,
+    r"^https://gitlab.com/([-_0-9a-zA-Z]+)/([-_0-9a-zA-Z]+)(/|.git)?$"
+);
+
+// cargo-disassemble-0.1.1: ".*"
+consistent!(cargo_disassemble_0, ".*");
+
+// cargo-demangle-0.1.2: r"(?m)(?P<symbol>_ZN[0-9]+.*E)"
+consistent!(cargo_demangle_0, r"(?m)(?P<symbol>_ZN[0-9]+.*E)");
+
+// cargo-coverage-annotations-0.1.5: r"^\s*\}(?:\)*;?|\s*else\s*\{)$"
+consistent!(cargo_coverage_annotations_0, r"^\s*\}(?:\)*;?|\s*else\s*\{)$");
+
+// cargo-urlcrate-1.0.1: "[\u{001b}\u{009b}][\\[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-PRZcf-nqry=><]"
+consistent!(cargo_urlcrate_0, "[\u{001b}\u{009b}][\\[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-PRZcf-nqry=><]");
+
+// cargo-script-0.2.8: r"^\s*\*( |$)"
+consistent!(cargo_script_0, r"^\s*\*( |$)");
+
+// cargo-script-0.2.8: r"^(\s+)"
+consistent!(cargo_script_1, r"^(\s+)");
+
+// cargo-script-0.2.8: r"/\*|\*/"
+consistent!(cargo_script_2, r"/\*|\*/");
+
+// cargo-script-0.2.8: r"^\s*//!"
+consistent!(cargo_script_3, r"^\s*//!");
+
+// cargo-script-0.2.8: r"^#![^\[].*?(\r\n|\n)"
+consistent!(cargo_script_4, r"^#![^\[].*?(\r\n|\n)");
+
+// cargo-update-1.5.2: r"cargo-install-update\.exe-v.+"
+consistent!(cargo_update_0, r"cargo-install-update\.exe-v.+");
+
+// canteen-0.4.1: r"^<(?:(int|uint|str|float|path):)?([\w_][a-zA-Z0-9_]*)>$"
+consistent!(
+    canteen_0,
+    r"^<(?:(int|uint|str|float|path):)?([\w_][a-zA-Z0-9_]*)>$"
+);
+
+// thruster-cli-0.1.3: r"(.)([A-Z])"
+consistent!(thruster_cli_0, r"(.)([A-Z])");
+
+// thieves-cant-0.1.0: "([Z]+)$"
+consistent!(thieves_cant_0, "([Z]+)$");
+
+// codeowners-0.1.3: r"^@\S+/\S+"
+consistent!(codeowners_0, r"^@\S+/\S+");
+
+// codeowners-0.1.3: r"^@\S+"
+consistent!(codeowners_1, r"^@\S+");
+
+// codeowners-0.1.3: r"^\S+@\S+"
+consistent!(codeowners_2, r"^\S+@\S+");
+
+// conserve-0.4.2: r"^b0000 {21} complete   20[-0-9T:+]+\s +\d+s\n$"
+consistent!(conserve_0, r"^b0000 {21} complete   20[-0-9T:+]+\s +\d+s\n$");
+
+// commodore-0.3.0: r"(?P<greeting>\S+?) (?P<name>\S+?)$"
+consistent!(commodore_0, r"(?P<greeting>\S+?) (?P<name>\S+?)$");
+
+// corollary-0.3.0: r"([ \t]*)```haskell([\s\S]*?)```"
+consistent!(corollary_0, r"([ \t]*)```haskell([\s\S]*?)```");
+
+// corollary-0.3.0: r"\b((?:a|b|t)\d*)\b"
+consistent!(corollary_1, r"\b((?:a|b|t)\d*)\b");
+
+// colorizex-0.1.3: "NB"
+consistent!(colorizex_0, "NB");
+
+// colorstring-0.0.1: r"(?i)\[[a-z0-9_-]+\]"
+consistent!(colorstring_0, r"(?i)\[[a-z0-9_-]+\]");
+
+// colorstring-0.0.1: r"^(?i)(\[[a-z0-9_-]+\])+"
+consistent!(colorstring_1, r"^(?i)(\[[a-z0-9_-]+\])+");
+
+// cosmogony-0.3.0: "name:(.+)"
+consistent!(cosmogony_0, "name:(.+)");
+
+// cobalt-bin-0.12.1: r"(?m:^ {0,3}\[[^\]]+\]:.+$)"
+consistent!(cobalt_bin_0, r"(?m:^ {0,3}\[[^\]]+\]:.+$)");
+
+// comrak-0.2.12: r"[^\p{L}\p{M}\p{N}\p{Pc} -]"
+consistent!(comrak_0, r"[^\p{L}\p{M}\p{N}\p{Pc} -]");
+
+// content-blocker-0.2.3: ""
+consistent!(content_blocker_0, "");
+
+// content-blocker-0.2.3: "(?i)hi"
+consistent!(content_blocker_1, "(?i)hi");
+
+// content-blocker-0.2.3: "http[s]?://domain.org"
+consistent!(content_blocker_2, "http[s]?://domain.org");
+
+// content-blocker-0.2.3: "(?i)http[s]?://domain.org"
+consistent!(content_blocker_3, "(?i)http[s]?://domain.org");
+
+// content-blocker-0.2.3: "http://domain.org"
+consistent!(content_blocker_4, "http://domain.org");
+
+// content-blocker-0.2.3: "http://domain.org"
+consistent!(content_blocker_5, "http://domain.org");
+
+// content-blocker-0.2.3: "ad.html"
+consistent!(content_blocker_6, "ad.html");
+
+// content-blocker-0.2.3: "ad.html"
+consistent!(content_blocker_7, "ad.html");
+
+// content-blocker-0.2.3: "http://domain.org"
+consistent!(content_blocker_8, "http://domain.org");
+
+// content-blocker-0.2.3: "http://domain.org/nocookies.sjs"
+consistent!(content_blocker_9, "http://domain.org/nocookies.sjs");
+
+// content-blocker-0.2.3: "http://domain.org/nocookies.sjs"
+consistent!(content_blocker_10, "http://domain.org/nocookies.sjs");
+
+// content-blocker-0.2.3: "http://domain.org/hideme.jpg"
+consistent!(content_blocker_11, "http://domain.org/hideme.jpg");
+
+// content-blocker-0.2.3: "http://domain.org/ok.html"
+consistent!(content_blocker_12, "http://domain.org/ok.html");
+
+// content-blocker-0.2.3: "http://domain.org/ok.html\\?except_this=1"
+consistent!(content_blocker_13, "http://domain.org/ok.html\\?except_this=1");
+
+// victoria-dom-0.1.2: "[A-Za-z0-9=]"
+consistent!(victoria_dom_0, "[A-Za-z0-9=]");
+
+// numbat-1.0.0: r"^nsq://"
+consistent!(numbat_0, r"^nsq://");
+
+// airkorea-0.1.2: r"[\s\t\r\n]"
+consistent!(airkorea_0, r"[\s\t\r\n]");
+
+// airkorea-0.1.2: r"([\{\[,])|([\}\]])"
+consistent!(airkorea_1, r"([\{\[,])|([\}\]])");
+
+// airkorea-0.1.2: r"[^.\d]+$"
+consistent!(airkorea_2, r"[^.\d]+$");
+
+// rofl-0.0.1: r"\b"
+// consistent!(rofl_0, r"\b");
+
+// rogcat-0.2.15: r"--------- beginning of.*"
+consistent!(rogcat_0, r"--------- beginning of.*");
+
+// rogcat-0.2.15: r"a|e|i|o|u"
+consistent!(rogcat_1, r"a|e|i|o|u");
+
+// rogcat-0.2.15: r"^(\d+)([kMG])$"
+consistent!(rogcat_2, r"^(\d+)([kMG])$");
+
+// media_filename-0.1.4: "\\.([A-Za-z0-9]{2,4})$"
+consistent!(media_filename_0, "\\.([A-Za-z0-9]{2,4})$");
+
+// media_filename-0.1.4: "([0-9]{3,4}p|[0-9]{3,4}x[0-9]{3,4})"
+consistent!(media_filename_1, "([0-9]{3,4}p|[0-9]{3,4}x[0-9]{3,4})");
+
+// media_filename-0.1.4: "(?:^\\[([^]]+)\\]|- ?([^-]+)$)"
+consistent!(media_filename_2, "(?:^\\[([^]]+)\\]|- ?([^-]+)$)");
+
+// media_filename-0.1.4: "(?:[eE]([0-9]{2,3})|[^0-9A-Za-z]([0-9]{2,3})(?:v[0-9])?[^0-9A-Za-z])"
+consistent!(
+    media_filename_3,
+    "(?:[eE]([0-9]{2,3})|[^0-9A-Za-z]([0-9]{2,3})(?:v[0-9])?[^0-9A-Za-z])"
+);
+
+// media_filename-0.1.4: "[sS]([0-9]{1,2})"
+consistent!(media_filename_4, "[sS]([0-9]{1,2})");
+
+// media_filename-0.1.4: "((?i)(?:PPV.)?[HP]DTV|(?:HD)?CAM|BRRIP|[^a-z]TS[^a-z]|(?:PPV )?WEB.?DL(?: DVDRip)?|HDRip|DVDRip|CamRip|W[EB]BRip|BluRay|BD|DVD|DvDScr|hdtv)"
+consistent!(media_filename_5, "((?i)(?:PPV.)?[HP]DTV|(?:HD)?CAM|BRRIP|[^a-z]TS[^a-z]|(?:PPV )?WEB.?DL(?: DVDRip)?|HDRip|DVDRip|CamRip|W[EB]BRip|BluRay|BD|DVD|DvDScr|hdtv)");
+
+// media_filename-0.1.4: "((19[0-9]|20[01])[0-9])"
+consistent!(media_filename_6, "((19[0-9]|20[01])[0-9])");
+
+// media_filename-0.1.4: "((?i)xvid|x264|h\\.?264)"
+consistent!(media_filename_7, "((?i)xvid|x264|h\\.?264)");
+
+// media_filename-0.1.4: "((?i)MP3|DD5\\.?1|Dual[- ]Audio|LiNE|DTS|AAC(?:\\.?2\\.0)?|AC3(?:\\.5\\.1)?)"
+consistent!(media_filename_8, "((?i)MP3|DD5\\.?1|Dual[- ]Audio|LiNE|DTS|AAC(?:\\.?2\\.0)?|AC3(?:\\.5\\.1)?)");
+
+// media_filename-0.1.4: "\\[([0-9A-F]{8})\\]"
+consistent!(media_filename_9, "\\[([0-9A-F]{8})\\]");
+
+// termimage-0.3.2: r"(\d+)[xX](\d+)"
+consistent!(termimage_0, r"(\d+)[xX](\d+)");
+
+// teensy-0.1.0: r".*(\d{4}-\d{2}-\d{2}).*"
+consistent!(teensy_0, r".*(\d{4}-\d{2}-\d{2}).*");
+
+// telescreen-0.1.3: r"<@(.+)>"
+consistent!(telescreen_0, r"<@(.+)>");
+
+// tempus_fugit-0.4.4: r"^(\d+)"
+consistent!(tempus_fugit_0, r"^(\d+)");
+
+// fselect-0.4.1: "(\\?|\\.|\\*|\\[|\\]|\\(|\\)|\\^|\\$)"
+consistent!(fselect_0, "(\\?|\\.|\\*|\\[|\\]|\\(|\\)|\\^|\\$)");
+
+// fselect-0.4.1: "(%|_|\\?|\\.|\\*|\\[|\\]|\\(|\\)|\\^|\\$)"
+consistent!(fselect_1, "(%|_|\\?|\\.|\\*|\\[|\\]|\\(|\\)|\\^|\\$)");
+
+// fs_eventbridge-0.1.0: r"^([A-Z]+)(?:\s(.+))?\s*"
+consistent!(fs_eventbridge_0, r"^([A-Z]+)(?:\s(.+))?\s*");
+
+// joseki-0.0.1: r"(\w{1,2})\[(.+?)\]"
+consistent!(joseki_0, r"(\w{1,2})\[(.+?)\]");
+
+// tweetr-0.2.1: r"(?i)in (\d+) (second|minute|hour|day|week)s?"
+consistent!(tweetr_0, r"(?i)in (\d+) (second|minute|hour|day|week)s?");
+
+// bullet_core-0.1.1: "^(?u:[0-9])+"
+consistent!(bullet_core_0, "^(?u:[0-9])+");
+
+// bullet_core-0.1.1: "^(?u:[0-9])+(?u:\\.)(?u:[0-9])+"
+consistent!(bullet_core_1, "^(?u:[0-9])+(?u:\\.)(?u:[0-9])+");
+
+// bullet_core-0.1.1: "^(?u:[A-Za-zª-ªµ-µº-ºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬ-ˬˮ-ˮͰ-ʹͶ-ͷͺ-ͽͿ-ͿΆ-ΆΈ-ΊΌ-ΌΎ-ΡΣ-ϵϷ-ҁҊ-ԯԱ-Ֆՙ-ՙա-ևא-תװ-ײؠ-يٮ-ٯٱ-ۓە-ەۥ-ۦۮ-ۯۺ-ۼۿ-ۿܐ-ܐܒ-ܯݍ-ޥޱ-ޱߊ-ߪߴ-ߵߺ-ߺࠀ-ࠕࠚ-ࠚࠤ-ࠤࠨ-ࠨࡀ-ࡘࢠ-ࢴऄ-हऽ-ऽॐ-ॐक़-ॡॱ-ঀঅ-ঌএ-ঐও-নপ-রল-লশ-হঽ-ঽৎ-ৎড়-ঢ়য়-ৡৰ-ৱਅ-ਊਏ-ਐਓ-ਨਪ-ਰਲ-ਲ਼ਵ-ਸ਼ਸ-ਹਖ਼-ੜਫ਼-ਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલ-ળવ-હઽ-ઽૐ-ૐૠ-ૡૹ-ૹଅ-ଌଏ-ଐଓ-ନପ-ରଲ-ଳଵ-ହଽ-ଽଡ଼-ଢ଼ୟ-ୡୱ-ୱஃ-ஃஅ-ஊஎ-ஐஒ-கங-சஜ-ஜஞ-டண-தந-பம-ஹௐ-ௐఅ-ఌఎ-ఐఒ-నప-హఽ-ఽౘ-ౚౠ-ౡಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽ-ಽೞ-ೞೠ-ೡೱ-ೲഅ-ഌഎ-ഐഒ-ഺഽ-ഽൎ-ൎൟ-ൡൺ-ൿඅ-ඖක-නඳ-රල-ලව-ෆก-ะา-ำเ-ๆກ-ຂຄ-ຄງ-ຈຊ-ຊຍ-ຍດ-ທນ-ຟມ-ຣລ-ລວ-ວສ-ຫອ-ະາ-ຳຽ-ຽເ-ໄໆ-ໆໜ-ໟༀ-ༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿ-ဿၐ-ၕၚ-ၝၡ-ၡၥ-ၦၮ-ၰၵ-ႁႎ-ႎႠ-ჅჇ-ჇჍ-Ⴭა-ჺჼ-ቈቊ-ቍቐ-ቖቘ-ቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀ-ዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏽᏸ-ᏽᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛱ-ᛸᜀ-ᜌᜎ-ᜑᜠ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗ-ៗៜ-ៜᠠ-ᡷᢀ-ᢨᢪ-ᢪᢰ-ᣵᤀ-ᤞᥐ-ᥭᥰ-ᥴᦀ-ᦫᦰ-ᧉᨀ-ᨖᨠ-ᩔᪧ-ᪧᬅ-ᬳᭅ-ᭋᮃ-ᮠᮮ-ᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᳩ-ᳬᳮ-ᳱᳵ-ᳶᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙ-ὙὛ-ὛὝ-ὝὟ-ώᾀ-ᾴᾶ-ᾼι-ιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱ-ⁱⁿ-ⁿₐ-ₜℂ-ℂℇ-ℇℊ-ℓℕ-ℕℙ-ℝℤ-ℤΩ-Ωℨ-ℨK-ℭℯ-ℹℼ-ℿⅅ-ⅉⅎ-ⅎↃ-ↄⰀ-Ⱞⰰ-ⱞⱠ-ⳤⳫ-ⳮⳲ-ⳳⴀ-ⴥⴧ-ⴧⴭ-ⴭⴰ-ⵧⵯ-ⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞⸯ-ⸯ々-〆〱-〵〻-〼ぁ-ゖゝ-ゟァ-ヺー-ヿㄅ-ㄭㄱ-ㆎㆠ-ㆺㇰ-ㇿ㐀-䶵一-鿕ꀀ-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪ-ꘫꙀ-ꙮꙿ-ꚝꚠ-ꛥꜗ-ꜟꜢ-ꞈꞋ-ꞭꞰ-ꞷꟷ-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻ-ꣻꣽ-ꣽꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏ-ꧏꧠ-ꧤꧦ-ꧯꧺ-ꧾꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺ-ꩺꩾ-ꪯꪱ-ꪱꪵ-ꪶꪹ-ꪽꫀ-ꫀꫂ-ꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꬰ-ꭚꭜ-ꭥꭰ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ﬀ-ﬆﬓ-ﬗיִ-יִײַ-ﬨשׁ-זּטּ-לּמּ-מּנּ-סּףּ-פּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ𐀀-𐀋𐀍-𐀦𐀨-𐀺𐀼-𐀽𐀿-𐁍𐁐-𐁝𐂀-𐃺𐊀-𐊜𐊠-𐋐𐌀-𐌟𐌰-𐍀𐍂-𐍉𐍐-𐍵𐎀-𐎝𐎠-𐏃𐏈-𐏏𐐀-𐒝𐔀-𐔧𐔰-𐕣𐘀-𐜶𐝀-𐝕𐝠-𐝧𐠀-𐠅𐠈-𐠈𐠊-𐠵𐠷-𐠸𐠼-𐠼𐠿-𐡕𐡠-𐡶𐢀-𐢞𐣠-𐣲𐣴-𐣵𐤀-𐤕𐤠-𐤹𐦀-𐦷𐦾-𐦿𐨀-𐨀𐨐-𐨓𐨕-𐨗𐨙-𐨳𐩠-𐩼𐪀-𐪜𐫀-𐫇𐫉-𐫤𐬀-𐬵𐭀-𐭕𐭠-𐭲𐮀-𐮑𐰀-𐱈𐲀-𐲲𐳀-𐳲𑀃-𑀷𑂃-𑂯𑃐-𑃨𑄃-𑄦𑅐-𑅲𑅶-𑅶𑆃-𑆲𑇁-𑇄𑇚-𑇚𑇜-𑇜𑈀-𑈑𑈓-𑈫𑊀-𑊆𑊈-𑊈𑊊-𑊍𑊏-𑊝𑊟-𑊨𑊰-𑋞𑌅-𑌌𑌏-𑌐𑌓-𑌨𑌪-𑌰𑌲-𑌳𑌵-𑌹𑌽-𑌽𑍐-𑍐𑍝-𑍡𑒀-𑒯𑓄-𑓅𑓇-𑓇𑖀-𑖮𑗘-𑗛𑘀-𑘯𑙄-𑙄𑚀-𑚪𑜀-𑜙𑢠-𑣟𑣿-𑣿𑫀-𑫸𒀀-𒎙𒒀-𒕃𓀀-𓐮𔐀-𔙆𖠀-𖨸𖩀-𖩞𖫐-𖫭𖬀-𖬯𖭀-𖭃𖭣-𖭷𖭽-𖮏𖼀-𖽄𖽐-𖽐𖾓-𖾟𛀀-𛀁𛰀-𛱪𛱰-𛱼𛲀-𛲈𛲐-𛲙𝐀-𝑔𝑖-𝒜𝒞-𝒟𝒢-𝒢𝒥-𝒦𝒩-𝒬𝒮-𝒹𝒻-𝒻𝒽-𝓃𝓅-𝔅𝔇-𝔊𝔍-𝔔𝔖-𝔜𝔞-𝔹𝔻-𝔾𝕀-𝕄𝕆-𝕆𝕊-𝕐𝕒-𝚥𝚨-𝛀𝛂-𝛚𝛜-𝛺𝛼-𝜔𝜖-𝜴𝜶-𝝎𝝐-𝝮𝝰-𝞈𝞊-𝞨𝞪-𝟂𝟄-𝟋𞠀-𞣄𞸀-𞸃𞸅-𞸟𞸡-𞸢𞸤-𞸤𞸧-𞸧𞸩-𞸲𞸴-𞸷𞸹-𞸹𞸻-𞸻𞹂-𞹂𞹇-𞹇𞹉-𞹉𞹋-𞹋𞹍-𞹏𞹑-𞹒𞹔-𞹔𞹗-𞹗𞹙-𞹙𞹛-𞹛𞹝-𞹝𞹟-𞹟𞹡-𞹢𞹤-𞹤𞹧-𞹪𞹬-𞹲𞹴-𞹷𞹹-𞹼𞹾-𞹾𞺀-𞺉𞺋-𞺛𞺡-𞺣𞺥-𞺩𞺫-𞺻𠀀-𪛖𪜀-𫜴𫝀-𫠝𫠠-𬺡丽-𪘀])+"
+consistent!(bullet_core_2, "^(?u:[A-Za-zª-ªµ-µº-ºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬ-ˬˮ-ˮͰ-ʹͶ-ͷͺ-ͽͿ-ͿΆ-ΆΈ-ΊΌ-ΌΎ-ΡΣ-ϵϷ-ҁҊ-ԯԱ-Ֆՙ-ՙա-ևא-תװ-ײؠ-يٮ-ٯٱ-ۓە-ەۥ-ۦۮ-ۯۺ-ۼۿ-ۿܐ-ܐܒ-ܯݍ-ޥޱ-ޱߊ-ߪߴ-ߵߺ-ߺࠀ-ࠕࠚ-ࠚࠤ-ࠤࠨ-ࠨࡀ-ࡘࢠ-ࢴऄ-हऽ-ऽॐ-ॐक़-ॡॱ-ঀঅ-ঌএ-ঐও-নপ-রল-লশ-হঽ-ঽৎ-ৎড়-ঢ়য়-ৡৰ-ৱਅ-ਊਏ-ਐਓ-ਨਪ-ਰਲ-ਲ਼ਵ-ਸ਼ਸ-ਹਖ਼-ੜਫ਼-ਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલ-ળવ-હઽ-ઽૐ-ૐૠ-ૡૹ-ૹଅ-ଌଏ-ଐଓ-ନପ-ରଲ-ଳଵ-ହଽ-ଽଡ଼-ଢ଼ୟ-ୡୱ-ୱஃ-ஃஅ-ஊஎ-ஐஒ-கங-சஜ-ஜஞ-டண-தந-பம-ஹௐ-ௐఅ-ఌఎ-ఐఒ-నప-హఽ-ఽౘ-ౚౠ-ౡಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽ-ಽೞ-ೞೠ-ೡೱ-ೲഅ-ഌഎ-ഐഒ-ഺഽ-ഽൎ-ൎൟ-ൡൺ-ൿඅ-ඖක-නඳ-රල-ලව-ෆก-ะา-ำเ-ๆກ-ຂຄ-ຄງ-ຈຊ-ຊຍ-ຍດ-ທນ-ຟມ-ຣລ-ລວ-ວສ-ຫອ-ະາ-ຳຽ-ຽເ-ໄໆ-ໆໜ-ໟༀ-ༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿ-ဿၐ-ၕၚ-ၝၡ-ၡၥ-ၦၮ-ၰၵ-ႁႎ-ႎႠ-ჅჇ-ჇჍ-Ⴭა-ჺჼ-ቈቊ-ቍቐ-ቖቘ-ቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀ-ዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏽᏸ-ᏽᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛱ-ᛸᜀ-ᜌᜎ-ᜑᜠ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗ-ៗៜ-ៜᠠ-ᡷᢀ-ᢨᢪ-ᢪᢰ-ᣵᤀ-ᤞᥐ-ᥭᥰ-ᥴᦀ-ᦫᦰ-ᧉᨀ-ᨖᨠ-ᩔᪧ-ᪧᬅ-ᬳᭅ-ᭋᮃ-ᮠᮮ-ᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᳩ-ᳬᳮ-ᳱᳵ-ᳶᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙ-ὙὛ-ὛὝ-ὝὟ-ώᾀ-ᾴᾶ-ᾼι-ιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱ-ⁱⁿ-ⁿₐ-ₜℂ-ℂℇ-ℇℊ-ℓℕ-ℕℙ-ℝℤ-ℤΩ-Ωℨ-ℨK-ℭℯ-ℹℼ-ℿⅅ-ⅉⅎ-ⅎↃ-ↄⰀ-Ⱞⰰ-ⱞⱠ-ⳤⳫ-ⳮⳲ-ⳳⴀ-ⴥⴧ-ⴧⴭ-ⴭⴰ-ⵧⵯ-ⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞⸯ-ⸯ々-〆〱-〵〻-〼ぁ-ゖゝ-ゟァ-ヺー-ヿㄅ-ㄭㄱ-ㆎㆠ-ㆺㇰ-ㇿ㐀-䶵一-鿕ꀀ-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪ-ꘫꙀ-ꙮꙿ-ꚝꚠ-ꛥꜗ-ꜟꜢ-ꞈꞋ-ꞭꞰ-ꞷꟷ-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻ-ꣻꣽ-ꣽꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏ-ꧏꧠ-ꧤꧦ-ꧯꧺ-ꧾꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺ-ꩺꩾ-ꪯꪱ-ꪱꪵ-ꪶꪹ-ꪽꫀ-ꫀꫂ-ꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꬰ-ꭚꭜ-ꭥꭰ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ﬀ-ﬆﬓ-ﬗיִ-יִײַ-ﬨשׁ-זּטּ-לּמּ-מּנּ-סּףּ-פּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ𐀀-𐀋𐀍-𐀦𐀨-𐀺𐀼-𐀽𐀿-𐁍𐁐-𐁝𐂀-𐃺𐊀-𐊜𐊠-𐋐𐌀-𐌟𐌰-𐍀𐍂-𐍉𐍐-𐍵𐎀-𐎝𐎠-𐏃𐏈-𐏏𐐀-𐒝𐔀-𐔧𐔰-𐕣𐘀-𐜶𐝀-𐝕𐝠-𐝧𐠀-𐠅𐠈-𐠈𐠊-𐠵𐠷-𐠸𐠼-𐠼𐠿-𐡕𐡠-𐡶𐢀-𐢞𐣠-𐣲𐣴-𐣵𐤀-𐤕𐤠-𐤹𐦀-𐦷𐦾-𐦿𐨀-𐨀𐨐-𐨓𐨕-𐨗𐨙-𐨳𐩠-𐩼𐪀-𐪜𐫀-𐫇𐫉-𐫤𐬀-𐬵𐭀-𐭕𐭠-𐭲𐮀-𐮑𐰀-𐱈𐲀-𐲲𐳀-𐳲𑀃-𑀷𑂃-𑂯𑃐-𑃨𑄃-𑄦𑅐-𑅲𑅶-𑅶𑆃-𑆲𑇁-𑇄𑇚-𑇚𑇜-𑇜𑈀-𑈑𑈓-𑈫𑊀-𑊆𑊈-𑊈𑊊-𑊍𑊏-𑊝𑊟-𑊨𑊰-𑋞𑌅-𑌌𑌏-𑌐𑌓-𑌨𑌪-𑌰𑌲-𑌳𑌵-𑌹𑌽-𑌽𑍐-𑍐𑍝-𑍡𑒀-𑒯𑓄-𑓅𑓇-𑓇𑖀-𑖮𑗘-𑗛𑘀-𑘯𑙄-𑙄𑚀-𑚪𑜀-𑜙𑢠-𑣟𑣿-𑣿𑫀-𑫸𒀀-𒎙𒒀-𒕃𓀀-𓐮𔐀-𔙆𖠀-𖨸𖩀-𖩞𖫐-𖫭𖬀-𖬯𖭀-𖭃𖭣-𖭷𖭽-𖮏𖼀-𖽄𖽐-𖽐𖾓-𖾟𛀀-𛀁𛰀-𛱪𛱰-𛱼𛲀-𛲈𛲐-𛲙𝐀-𝑔𝑖-𝒜𝒞-𝒟𝒢-𝒢𝒥-𝒦𝒩-𝒬𝒮-𝒹𝒻-𝒻𝒽-𝓃𝓅-𝔅𝔇-𝔊𝔍-𝔔𝔖-𝔜𝔞-𝔹𝔻-𝔾𝕀-𝕄𝕆-𝕆𝕊-𝕐𝕒-𝚥𝚨-𝛀𝛂-𝛚𝛜-𝛺𝛼-𝜔𝜖-𝜴𝜶-𝝎𝝐-𝝮𝝰-𝞈𝞊-𝞨𝞪-𝟂𝟄-𝟋𞠀-𞣄𞸀-𞸃𞸅-𞸟𞸡-𞸢𞸤-𞸤𞸧-𞸧𞸩-𞸲𞸴-𞸷𞸹-𞸹𞸻-𞸻𞹂-𞹂𞹇-𞹇𞹉-𞹉𞹋-𞹋𞹍-𞹏𞹑-𞹒𞹔-𞹔𞹗-𞹗𞹙-𞹙𞹛-𞹛𞹝-𞹝𞹟-𞹟𞹡-𞹢𞹤-𞹤𞹧-𞹪𞹬-𞹲𞹴-𞹷𞹹-𞹼𞹾-𞹾𞺀-𞺉𞺋-𞺛𞺡-𞺣𞺥-𞺩𞺫-𞺻𠀀-𪛖𪜀-𫜴𫝀-𫠝𫠠-𬺡丽-𪘀])+");
+
+// bullet_core-0.1.1: "^(?u:d/d)((?u:[A-Za-zª-ªµ-µº-ºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬ-ˬˮ-ˮͰ-ʹͶ-ͷͺ-ͽͿ-ͿΆ-ΆΈ-ΊΌ-ΌΎ-ΡΣ-ϵϷ-ҁҊ-ԯԱ-Ֆՙ-ՙա-ևא-תװ-ײؠ-يٮ-ٯٱ-ۓە-ەۥ-ۦۮ-ۯۺ-ۼۿ-ۿܐ-ܐܒ-ܯݍ-ޥޱ-ޱߊ-ߪߴ-ߵߺ-ߺࠀ-ࠕࠚ-ࠚࠤ-ࠤࠨ-ࠨࡀ-ࡘࢠ-ࢴऄ-हऽ-ऽॐ-ॐक़-ॡॱ-ঀঅ-ঌএ-ঐও-নপ-রল-লশ-হঽ-ঽৎ-ৎড়-ঢ়য়-ৡৰ-ৱਅ-ਊਏ-ਐਓ-ਨਪ-ਰਲ-ਲ਼ਵ-ਸ਼ਸ-ਹਖ਼-ੜਫ਼-ਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલ-ળવ-હઽ-ઽૐ-ૐૠ-ૡૹ-ૹଅ-ଌଏ-ଐଓ-ନପ-ରଲ-ଳଵ-ହଽ-ଽଡ଼-ଢ଼ୟ-ୡୱ-ୱஃ-ஃஅ-ஊஎ-ஐஒ-கங-சஜ-ஜஞ-டண-தந-பம-ஹௐ-ௐఅ-ఌఎ-ఐఒ-నప-హఽ-ఽౘ-ౚౠ-ౡಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽ-ಽೞ-ೞೠ-ೡೱ-ೲഅ-ഌഎ-ഐഒ-ഺഽ-ഽൎ-ൎൟ-ൡൺ-ൿඅ-ඖක-නඳ-රල-ලව-ෆก-ะา-ำเ-ๆກ-ຂຄ-ຄງ-ຈຊ-ຊຍ-ຍດ-ທນ-ຟມ-ຣລ-ລວ-ວສ-ຫອ-ະາ-ຳຽ-ຽເ-ໄໆ-ໆໜ-ໟༀ-ༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿ-ဿၐ-ၕၚ-ၝၡ-ၡၥ-ၦၮ-ၰၵ-ႁႎ-ႎႠ-ჅჇ-ჇჍ-Ⴭა-ჺჼ-ቈቊ-ቍቐ-ቖቘ-ቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀ-ዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏽᏸ-ᏽᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛱ-ᛸᜀ-ᜌᜎ-ᜑᜠ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗ-ៗៜ-ៜᠠ-ᡷᢀ-ᢨᢪ-ᢪᢰ-ᣵᤀ-ᤞᥐ-ᥭᥰ-ᥴᦀ-ᦫᦰ-ᧉᨀ-ᨖᨠ-ᩔᪧ-ᪧᬅ-ᬳᭅ-ᭋᮃ-ᮠᮮ-ᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᳩ-ᳬᳮ-ᳱᳵ-ᳶᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙ-ὙὛ-ὛὝ-ὝὟ-ώᾀ-ᾴᾶ-ᾼι-ιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱ-ⁱⁿ-ⁿₐ-ₜℂ-ℂℇ-ℇℊ-ℓℕ-ℕℙ-ℝℤ-ℤΩ-Ωℨ-ℨK-ℭℯ-ℹℼ-ℿⅅ-ⅉⅎ-ⅎↃ-ↄⰀ-Ⱞⰰ-ⱞⱠ-ⳤⳫ-ⳮⳲ-ⳳⴀ-ⴥⴧ-ⴧⴭ-ⴭⴰ-ⵧⵯ-ⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞⸯ-ⸯ々-〆〱-〵〻-〼ぁ-ゖゝ-ゟァ-ヺー-ヿㄅ-ㄭㄱ-ㆎㆠ-ㆺㇰ-ㇿ㐀-䶵一-鿕ꀀ-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪ-ꘫꙀ-ꙮꙿ-ꚝꚠ-ꛥꜗ-ꜟꜢ-ꞈꞋ-ꞭꞰ-ꞷꟷ-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻ-ꣻꣽ-ꣽꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏ-ꧏꧠ-ꧤꧦ-ꧯꧺ-ꧾꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺ-ꩺꩾ-ꪯꪱ-ꪱꪵ-ꪶꪹ-ꪽꫀ-ꫀꫂ-ꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꬰ-ꭚꭜ-ꭥꭰ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ﬀ-ﬆﬓ-ﬗיִ-יִײַ-ﬨשׁ-זּטּ-לּמּ-מּנּ-סּףּ-פּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ𐀀-𐀋𐀍-𐀦𐀨-𐀺𐀼-𐀽𐀿-𐁍𐁐-𐁝𐂀-𐃺𐊀-𐊜𐊠-𐋐𐌀-𐌟𐌰-𐍀𐍂-𐍉𐍐-𐍵𐎀-𐎝𐎠-𐏃𐏈-𐏏𐐀-𐒝𐔀-𐔧𐔰-𐕣𐘀-𐜶𐝀-𐝕𐝠-𐝧𐠀-𐠅𐠈-𐠈𐠊-𐠵𐠷-𐠸𐠼-𐠼𐠿-𐡕𐡠-𐡶𐢀-𐢞𐣠-𐣲𐣴-𐣵𐤀-𐤕𐤠-𐤹𐦀-𐦷𐦾-𐦿𐨀-𐨀𐨐-𐨓𐨕-𐨗𐨙-𐨳𐩠-𐩼𐪀-𐪜𐫀-𐫇𐫉-𐫤𐬀-𐬵𐭀-𐭕𐭠-𐭲𐮀-𐮑𐰀-𐱈𐲀-𐲲𐳀-𐳲𑀃-𑀷𑂃-𑂯𑃐-𑃨𑄃-𑄦𑅐-𑅲𑅶-𑅶𑆃-𑆲𑇁-𑇄𑇚-𑇚𑇜-𑇜𑈀-𑈑𑈓-𑈫𑊀-𑊆𑊈-𑊈𑊊-𑊍𑊏-𑊝𑊟-𑊨𑊰-𑋞𑌅-𑌌𑌏-𑌐𑌓-𑌨𑌪-𑌰𑌲-𑌳𑌵-𑌹𑌽-𑌽𑍐-𑍐𑍝-𑍡𑒀-𑒯𑓄-𑓅𑓇-𑓇𑖀-𑖮𑗘-𑗛𑘀-𑘯𑙄-𑙄𑚀-𑚪𑜀-𑜙𑢠-𑣟𑣿-𑣿𑫀-𑫸𒀀-𒎙𒒀-𒕃𓀀-𓐮𔐀-𔙆𖠀-𖨸𖩀-𖩞𖫐-𖫭𖬀-𖬯𖭀-𖭃𖭣-𖭷𖭽-𖮏𖼀-𖽄𖽐-𖽐𖾓-𖾟𛀀-𛀁𛰀-𛱪𛱰-𛱼𛲀-𛲈𛲐-𛲙𝐀-𝑔𝑖-𝒜𝒞-𝒟𝒢-𝒢𝒥-𝒦𝒩-𝒬𝒮-𝒹𝒻-𝒻𝒽-𝓃𝓅-𝔅𝔇-𝔊𝔍-𝔔𝔖-𝔜𝔞-𝔹𝔻-𝔾𝕀-𝕄𝕆-𝕆𝕊-𝕐𝕒-𝚥𝚨-𝛀𝛂-𝛚𝛜-𝛺𝛼-𝜔𝜖-𝜴𝜶-𝝎𝝐-𝝮𝝰-𝞈𝞊-𝞨𝞪-𝟂𝟄-𝟋𞠀-𞣄𞸀-𞸃𞸅-𞸟𞸡-𞸢𞸤-𞸤𞸧-𞸧𞸩-𞸲𞸴-𞸷𞸹-𞸹𞸻-𞸻𞹂-𞹂𞹇-𞹇𞹉-𞹉𞹋-𞹋𞹍-𞹏𞹑-𞹒𞹔-𞹔𞹗-𞹗𞹙-𞹙𞹛-𞹛𞹝-𞹝𞹟-𞹟𞹡-𞹢𞹤-𞹤𞹧-𞹪𞹬-𞹲𞹴-𞹷𞹹-𞹼𞹾-𞹾𞺀-𞺉𞺋-𞺛𞺡-𞺣𞺥-𞺩𞺫-𞺻𠀀-𪛖𪜀-𫜴𫝀-𫠝𫠠-𬺡丽-𪘀])+)"
+consistent!(bullet_core_3, "^(?u:d/d)((?u:[A-Za-zª-ªµ-µº-ºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬ-ˬˮ-ˮͰ-ʹͶ-ͷͺ-ͽͿ-ͿΆ-ΆΈ-ΊΌ-ΌΎ-ΡΣ-ϵϷ-ҁҊ-ԯԱ-Ֆՙ-ՙա-ևא-תװ-ײؠ-يٮ-ٯٱ-ۓە-ەۥ-ۦۮ-ۯۺ-ۼۿ-ۿܐ-ܐܒ-ܯݍ-ޥޱ-ޱߊ-ߪߴ-ߵߺ-ߺࠀ-ࠕࠚ-ࠚࠤ-ࠤࠨ-ࠨࡀ-ࡘࢠ-ࢴऄ-हऽ-ऽॐ-ॐक़-ॡॱ-ঀঅ-ঌএ-ঐও-নপ-রল-লশ-হঽ-ঽৎ-ৎড়-ঢ়য়-ৡৰ-ৱਅ-ਊਏ-ਐਓ-ਨਪ-ਰਲ-ਲ਼ਵ-ਸ਼ਸ-ਹਖ਼-ੜਫ਼-ਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલ-ળવ-હઽ-ઽૐ-ૐૠ-ૡૹ-ૹଅ-ଌଏ-ଐଓ-ନପ-ରଲ-ଳଵ-ହଽ-ଽଡ଼-ଢ଼ୟ-ୡୱ-ୱஃ-ஃஅ-ஊஎ-ஐஒ-கங-சஜ-ஜஞ-டண-தந-பம-ஹௐ-ௐఅ-ఌఎ-ఐఒ-నప-హఽ-ఽౘ-ౚౠ-ౡಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽ-ಽೞ-ೞೠ-ೡೱ-ೲഅ-ഌഎ-ഐഒ-ഺഽ-ഽൎ-ൎൟ-ൡൺ-ൿඅ-ඖක-නඳ-රල-ලව-ෆก-ะา-ำเ-ๆກ-ຂຄ-ຄງ-ຈຊ-ຊຍ-ຍດ-ທນ-ຟມ-ຣລ-ລວ-ວສ-ຫອ-ະາ-ຳຽ-ຽເ-ໄໆ-ໆໜ-ໟༀ-ༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿ-ဿၐ-ၕၚ-ၝၡ-ၡၥ-ၦၮ-ၰၵ-ႁႎ-ႎႠ-ჅჇ-ჇჍ-Ⴭა-ჺჼ-ቈቊ-ቍቐ-ቖቘ-ቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀ-ዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏽᏸ-ᏽᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛱ-ᛸᜀ-ᜌᜎ-ᜑᜠ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗ-ៗៜ-ៜᠠ-ᡷᢀ-ᢨᢪ-ᢪᢰ-ᣵᤀ-ᤞᥐ-ᥭᥰ-ᥴᦀ-ᦫᦰ-ᧉᨀ-ᨖᨠ-ᩔᪧ-ᪧᬅ-ᬳᭅ-ᭋᮃ-ᮠᮮ-ᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᳩ-ᳬᳮ-ᳱᳵ-ᳶᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙ-ὙὛ-ὛὝ-ὝὟ-ώᾀ-ᾴᾶ-ᾼι-ιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱ-ⁱⁿ-ⁿₐ-ₜℂ-ℂℇ-ℇℊ-ℓℕ-ℕℙ-ℝℤ-ℤΩ-Ωℨ-ℨK-ℭℯ-ℹℼ-ℿⅅ-ⅉⅎ-ⅎↃ-ↄⰀ-Ⱞⰰ-ⱞⱠ-ⳤⳫ-ⳮⳲ-ⳳⴀ-ⴥⴧ-ⴧⴭ-ⴭⴰ-ⵧⵯ-ⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞⸯ-ⸯ々-〆〱-〵〻-〼ぁ-ゖゝ-ゟァ-ヺー-ヿㄅ-ㄭㄱ-ㆎㆠ-ㆺㇰ-ㇿ㐀-䶵一-鿕ꀀ-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪ-ꘫꙀ-ꙮꙿ-ꚝꚠ-ꛥꜗ-ꜟꜢ-ꞈꞋ-ꞭꞰ-ꞷꟷ-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻ-ꣻꣽ-ꣽꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏ-ꧏꧠ-ꧤꧦ-ꧯꧺ-ꧾꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺ-ꩺꩾ-ꪯꪱ-ꪱꪵ-ꪶꪹ-ꪽꫀ-ꫀꫂ-ꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꬰ-ꭚꭜ-ꭥꭰ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ﬀ-ﬆﬓ-ﬗיִ-יִײַ-ﬨשׁ-זּטּ-לּמּ-מּנּ-סּףּ-פּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ𐀀-𐀋𐀍-𐀦𐀨-𐀺𐀼-𐀽𐀿-𐁍𐁐-𐁝𐂀-𐃺𐊀-𐊜𐊠-𐋐𐌀-𐌟𐌰-𐍀𐍂-𐍉𐍐-𐍵𐎀-𐎝𐎠-𐏃𐏈-𐏏𐐀-𐒝𐔀-𐔧𐔰-𐕣𐘀-𐜶𐝀-𐝕𐝠-𐝧𐠀-𐠅𐠈-𐠈𐠊-𐠵𐠷-𐠸𐠼-𐠼𐠿-𐡕𐡠-𐡶𐢀-𐢞𐣠-𐣲𐣴-𐣵𐤀-𐤕𐤠-𐤹𐦀-𐦷𐦾-𐦿𐨀-𐨀𐨐-𐨓𐨕-𐨗𐨙-𐨳𐩠-𐩼𐪀-𐪜𐫀-𐫇𐫉-𐫤𐬀-𐬵𐭀-𐭕𐭠-𐭲𐮀-𐮑𐰀-𐱈𐲀-𐲲𐳀-𐳲𑀃-𑀷𑂃-𑂯𑃐-𑃨𑄃-𑄦𑅐-𑅲𑅶-𑅶𑆃-𑆲𑇁-𑇄𑇚-𑇚𑇜-𑇜𑈀-𑈑𑈓-𑈫𑊀-𑊆𑊈-𑊈𑊊-𑊍𑊏-𑊝𑊟-𑊨𑊰-𑋞𑌅-𑌌𑌏-𑌐𑌓-𑌨𑌪-𑌰𑌲-𑌳𑌵-𑌹𑌽-𑌽𑍐-𑍐𑍝-𑍡𑒀-𑒯𑓄-𑓅𑓇-𑓇𑖀-𑖮𑗘-𑗛𑘀-𑘯𑙄-𑙄𑚀-𑚪𑜀-𑜙𑢠-𑣟𑣿-𑣿𑫀-𑫸𒀀-𒎙𒒀-𒕃𓀀-𓐮𔐀-𔙆𖠀-𖨸𖩀-𖩞𖫐-𖫭𖬀-𖬯𖭀-𖭃𖭣-𖭷𖭽-𖮏𖼀-𖽄𖽐-𖽐𖾓-𖾟𛀀-𛀁𛰀-𛱪𛱰-𛱼𛲀-𛲈𛲐-𛲙𝐀-𝑔𝑖-𝒜𝒞-𝒟𝒢-𝒢𝒥-𝒦𝒩-𝒬𝒮-𝒹𝒻-𝒻𝒽-𝓃𝓅-𝔅𝔇-𝔊𝔍-𝔔𝔖-𝔜𝔞-𝔹𝔻-𝔾𝕀-𝕄𝕆-𝕆𝕊-𝕐𝕒-𝚥𝚨-𝛀𝛂-𝛚𝛜-𝛺𝛼-𝜔𝜖-𝜴𝜶-𝝎𝝐-𝝮𝝰-𝞈𝞊-𝞨𝞪-𝟂𝟄-𝟋𞠀-𞣄𞸀-𞸃𞸅-𞸟𞸡-𞸢𞸤-𞸤𞸧-𞸧𞸩-𞸲𞸴-𞸷𞸹-𞸹𞸻-𞸻𞹂-𞹂𞹇-𞹇𞹉-𞹉𞹋-𞹋𞹍-𞹏𞹑-𞹒𞹔-𞹔𞹗-𞹗𞹙-𞹙𞹛-𞹛𞹝-𞹝𞹟-𞹟𞹡-𞹢𞹤-𞹤𞹧-𞹪𞹬-𞹲𞹴-𞹷𞹹-𞹼𞹾-𞹾𞺀-𞺉𞺋-𞺛𞺡-𞺣𞺥-𞺩𞺫-𞺻𠀀-𪛖𪜀-𫜴𫝀-𫠝𫠠-𬺡丽-𪘀])+)");
+
+// bullet_core-0.1.1: "^(?u:\\()"
+consistent!(bullet_core_4, "^(?u:\\()");
+
+// bullet_core-0.1.1: "^(?u:\\))"
+consistent!(bullet_core_5, "^(?u:\\))");
+
+// bullet_core-0.1.1: "^(?u:\\*)"
+consistent!(bullet_core_6, "^(?u:\\*)");
+
+// bullet_core-0.1.1: "^(?u:\\+)"
+consistent!(bullet_core_7, "^(?u:\\+)");
+
+// bullet_core-0.1.1: "^(?u:,)"
+consistent!(bullet_core_8, "^(?u:,)");
+
+// bullet_core-0.1.1: "^(?u:\\-)"
+consistent!(bullet_core_9, "^(?u:\\-)");
+
+// bullet_core-0.1.1: "^(?u:/)"
+consistent!(bullet_core_10, "^(?u:/)");
+
+// bullet_core-0.1.1: "^(?u:\\[)"
+consistent!(bullet_core_11, "^(?u:\\[)");
+
+// bullet_core-0.1.1: "^(?u:\\])"
+consistent!(bullet_core_12, "^(?u:\\])");
+
+// bullet_core-0.1.1: "^(?u:\\^)"
+consistent!(bullet_core_13, "^(?u:\\^)");
+
+// bullet_core-0.1.1: "^(?u:·)"
+consistent!(bullet_core_14, "^(?u:·)");
+
+// actix-web-0.6.13: "//+"
+consistent!(actix_web_0, "//+");
+
+// actix-web-0.6.13: "//+"
+consistent!(actix_web_1, "//+");
+
+// althea_kernel_interface-0.1.0: r"(\S*) .* (\S*) (REACHABLE|STALE|DELAY)"
+consistent!(
+    althea_kernel_interface_0,
+    r"(\S*) .* (\S*) (REACHABLE|STALE|DELAY)"
+);
+
+// althea_kernel_interface-0.1.0: r"-s (.*) --ip6-dst (.*)/.* bcnt = (.*)"
+consistent!(
+    althea_kernel_interface_1,
+    r"-s (.*) --ip6-dst (.*)/.* bcnt = (.*)"
+);
+
+// alcibiades-0.3.0: r"\buci(?:\s|$)"
+consistent!(alcibiades_0, r"\buci(?:\s|$)");
+
+// ruma-identifiers-0.11.0: r"\A[a-z0-9._=-]+\z"
+consistent!(ruma_identifiers_0, r"\A[a-z0-9._=-]+\z");
+
+// rusqbin-0.2.3: r"/rusqbins/((?i)[A-F0-9]{8}\-[A-F0-9]{4}\-4[A-F0-9]{3}\-[89AB][A-F0-9]{3}\-[A-F0-9]{12})$"
+consistent!(rusqbin_0, r"/rusqbins/((?i)[A-F0-9]{8}\-[A-F0-9]{4}\-4[A-F0-9]{3}\-[89AB][A-F0-9]{3}\-[A-F0-9]{12})$");
+
+// rusqbin-0.2.3: r"/rusqbins/((?i)[A-F0-9]{8}\-[A-F0-9]{4}\-4[A-F0-9]{3}\-[89AB][A-F0-9]{3}\-[A-F0-9]{12})/requests/?$"
+consistent!(rusqbin_1, r"/rusqbins/((?i)[A-F0-9]{8}\-[A-F0-9]{4}\-4[A-F0-9]{3}\-[89AB][A-F0-9]{3}\-[A-F0-9]{12})/requests/?$");
+
+// rust-install-0.0.4: r"^(nightly|beta|stable)(?:-(\d{4}-\d{2}-\d{2}))?$"
+consistent!(
+    rust_install_0,
+    r"^(nightly|beta|stable)(?:-(\d{4}-\d{2}-\d{2}))?$"
+);
+
+// rust_inbox-0.0.5: "^+(.*)\r\n"
+consistent!(rust_inbox_0, "^+(.*)\r\n");
+
+// rust_inbox-0.0.5: r"^\* CAPABILITY (.*)\r\n"
+consistent!(rust_inbox_1, r"^\* CAPABILITY (.*)\r\n");
+
+// rust_inbox-0.0.5: r"^([a-zA-Z0-9]+) (OK|NO|BAD)(.*)"
+consistent!(rust_inbox_2, r"^([a-zA-Z0-9]+) (OK|NO|BAD)(.*)");
+
+// rust_inbox-0.0.5: r"^\* (\d+) EXISTS\r\n"
+consistent!(rust_inbox_3, r"^\* (\d+) EXISTS\r\n");
+
+// rust_inbox-0.0.5: r"^\* (\d+) RECENT\r\n"
+consistent!(rust_inbox_4, r"^\* (\d+) RECENT\r\n");
+
+// rust_inbox-0.0.5: r"^\* FLAGS (.+)\r\n"
+consistent!(rust_inbox_5, r"^\* FLAGS (.+)\r\n");
+
+// rust_inbox-0.0.5: r"^\* OK \[UNSEEN (\d+)\](.*)\r\n"
+consistent!(rust_inbox_6, r"^\* OK \[UNSEEN (\d+)\](.*)\r\n");
+
+// rust_inbox-0.0.5: r"^\* OK \[UIDVALIDITY (\d+)\](.*)\r\n"
+consistent!(rust_inbox_7, r"^\* OK \[UIDVALIDITY (\d+)\](.*)\r\n");
+
+// rust_inbox-0.0.5: r"^\* OK \[UIDNEXT (\d+)\](.*)\r\n"
+consistent!(rust_inbox_8, r"^\* OK \[UIDNEXT (\d+)\](.*)\r\n");
+
+// rust_inbox-0.0.5: r"^\* OK \[PERMANENTFLAGS (.+)\](.*)\r\n"
+consistent!(rust_inbox_9, r"^\* OK \[PERMANENTFLAGS (.+)\](.*)\r\n");
+
+// rustml-0.0.7: r"^[a-z]+ (\d+)$"
+consistent!(rustml_0, r"^[a-z]+ (\d+)$");
+
+// rustml-0.0.7: r"^[a-z]+ (\d+)$"
+consistent!(rustml_1, r"^[a-z]+ (\d+)$");
+
+// rustml-0.0.7: r"^[a-z]+ (\d+)$"
+consistent!(rustml_2, r"^[a-z]+ (\d+)$");
+
+// rustfmt-0.10.0: r"([^\\](\\\\)*)\\[\n\r][[:space:]]*"
+consistent!(rustfmt_0, r"([^\\](\\\\)*)\\[\n\r][[:space:]]*");
+
+// rustfmt-core-0.4.0: r"(^\s*$)|(^\s*//\s*rustfmt-[^:]+:\s*\S+)"
+consistent!(rustfmt_core_0, r"(^\s*$)|(^\s*//\s*rustfmt-[^:]+:\s*\S+)");
+
+// rustfmt-core-0.4.0: r"^## `([^`]+)`"
+consistent!(rustfmt_core_1, r"^## `([^`]+)`");
+
+// rustfmt-core-0.4.0: r"([^\\](\\\\)*)\\[\n\r][[:space:]]*"
+consistent!(rustfmt_core_2, r"([^\\](\\\\)*)\\[\n\r][[:space:]]*");
+
+// rustfmt-core-0.4.0: r"\s;"
+consistent!(rustfmt_core_3, r"\s;");
+
+// rust-enum-derive-0.4.0: r"^(0x)?([:digit:]+)$"
+consistent!(rust_enum_derive_0, r"^(0x)?([:digit:]+)$");
+
+// rust-enum-derive-0.4.0: r"^([:digit:]+)[:space:]*<<[:space:]*([:digit:]+)$"
+consistent!(
+    rust_enum_derive_1,
+    r"^([:digit:]+)[:space:]*<<[:space:]*([:digit:]+)$"
+);
+
+// rust-enum-derive-0.4.0: r"^[:space:]*([[:alnum:]_]+)([:space:]*=[:space:]*([:graph:]+))?[:space:]*,"
+consistent!(rust_enum_derive_2, r"^[:space:]*([[:alnum:]_]+)([:space:]*=[:space:]*([:graph:]+))?[:space:]*,");
+
+// rust-enum-derive-0.4.0: r"^#define[:space:]+([:graph:]+)[:space:]+([:graph:]+)"
+consistent!(
+    rust_enum_derive_3,
+    r"^#define[:space:]+([:graph:]+)[:space:]+([:graph:]+)"
+);
+
+// rustsourcebundler-0.2.0: r"^\s*pub mod (.+);$"
+consistent!(rustsourcebundler_0, r"^\s*pub mod (.+);$");
+
+// rustsourcebundler-0.2.0: r"^\s*pub mod (.+);$"
+consistent!(rustsourcebundler_1, r"^\s*pub mod (.+);$");
+
+// rustfmt-nightly-0.8.2: r"([^\\](\\\\)*)\\[\n\r][[:space:]]*"
+consistent!(rustfmt_nightly_0, r"([^\\](\\\\)*)\\[\n\r][[:space:]]*");
+
+// rustfmt-nightly-0.8.2: r"\s;"
+consistent!(rustfmt_nightly_1, r"\s;");
+
+// rustache-0.1.0: r"(?s)(.*?)([ \t\r\n]*)(\{\{(\{?\S?\s*?[\w\.\s]*.*?\s*?\}?)\}\})([ \t\r\n]*)"
+consistent!(rustache_0, r"(?s)(.*?)([ \t\r\n]*)(\{\{(\{?\S?\s*?[\w\.\s]*.*?\s*?\}?)\}\})([ \t\r\n]*)");
+
+// rustfilt-0.2.0: r"_ZN[\$\._[:alnum:]]*"
+consistent!(rustfilt_0, r"_ZN[\$\._[:alnum:]]*");
+
+// rustache-lists-0.1.2: r"(?s)(.*?)([ \t\r\n]*)(\{\{(\{?\S?\s*?[\w\.\s]*.*?\s*?\}?)\}\})([ \t\r\n]*)"
+consistent!(rustache_lists_0, r"(?s)(.*?)([ \t\r\n]*)(\{\{(\{?\S?\s*?[\w\.\s]*.*?\s*?\}?)\}\})([ \t\r\n]*)");
+
+// rural-0.7.3: "(.+)=(.+)"
+consistent!(rural_0, "(.+)=(.+)");
+
+// rural-0.7.3: "(.*):(.+)"
+consistent!(rural_1, "(.*):(.+)");
+
+// rural-0.7.3: "(.+):=(.+)"
+consistent!(rural_2, "(.+):=(.+)");
+
+// rural-0.7.3: "(.*)==(.+)"
+consistent!(rural_3, "(.*)==(.+)");
+
+// rusoto_credential-0.11.0: r"^\[([^\]]+)\]$"
+consistent!(rusoto_credential_0, r"^\[([^\]]+)\]$");
+
+// rumblebars-0.3.0: "([:blank:]*)$"
+consistent!(rumblebars_0, "([:blank:]*)$");
+
+// rumblebars-0.3.0: "(\r?\n)[:blank:]*(\\{\\{~?[#!/](?:\\}?[^}])*\\}\\})[:blank:]*(:?\r?\n)?\\z"
+consistent!(rumblebars_1, "(\r?\n)[:blank:]*(\\{\\{~?[#!/](?:\\}?[^}])*\\}\\})[:blank:]*(:?\r?\n)?\\z");
+
+// rumblebars-0.3.0: "(\r?\n[:blank:]*)(\\{\\{~?>(?:\\}?[^}])*\\}\\})[:blank:]*(:?\r?\n)?\\z"
+consistent!(
+    rumblebars_2,
+    "(\r?\n[:blank:]*)(\\{\\{~?>(?:\\}?[^}])*\\}\\})[:blank:]*(:?\r?\n)?\\z"
+);
+
+// rumblebars-0.3.0: "((?:[:blank:]|\r?\n)*)(\r?\n)[:blank:]*$"
+consistent!(rumblebars_3, "((?:[:blank:]|\r?\n)*)(\r?\n)[:blank:]*$");
+
+// rumblebars-0.3.0: "^([:blank:]*\r?\n)(.*)"
+consistent!(rumblebars_4, "^([:blank:]*\r?\n)(.*)");
+
+// diesel_cli-1.3.1: r"(?P<stamp>[\d-]*)_hello"
+consistent!(diesel_cli_0, r"(?P<stamp>[\d-]*)_hello");
+
+// dishub-0.1.1: r"(\d+)s"
+consistent!(dishub_0, r"(\d+)s");
+
+// spreadsheet_textconv-0.1.0: r"\n"
+consistent!(spreadsheet_textconv_0, r"\n");
+
+// spreadsheet_textconv-0.1.0: r"\r"
+consistent!(spreadsheet_textconv_1, r"\r");
+
+// spreadsheet_textconv-0.1.0: r"\t"
+consistent!(spreadsheet_textconv_2, r"\t");
+
+// split_aud-0.1.0: r"DELAY (-?\d+)ms"
+consistent!(split_aud_0, r"DELAY (-?\d+)ms");
+
+// split_aud-0.1.0: r"Trim\((\d+), ?(\d+)\)"
+consistent!(split_aud_1, r"Trim\((\d+), ?(\d+)\)");
+
+// spotrust-0.0.5: r"spotify:[a-z]+:[a-zA-Z0-9]+"
+consistent!(spotrust_0, r"spotify:[a-z]+:[a-zA-Z0-9]+");
+
+// spaceslugs-0.1.0: r"[^\x00-\x7F]"
+consistent!(spaceslugs_0, r"[^\x00-\x7F]");
+
+// spaceslugs-0.1.0: r"[']+"
+consistent!(spaceslugs_1, r"[']+");
+
+// spaceslugs-0.1.0: r"\W+"
+consistent!(spaceslugs_2, r"\W+");
+
+// spaceslugs-0.1.0: r"[ ]+"
+consistent!(spaceslugs_3, r"[ ]+");
+
+// space_email_api-0.1.1: "PHPSESSID=([0-9a-f]+)"
+consistent!(space_email_api_0, "PHPSESSID=([0-9a-f]+)");
+
+// lorikeet-0.7.0: "[^0-9.,]"
+consistent!(lorikeet_0, "[^0-9.,]");
+
+// claude-0.3.0: r"^(?:\b|(-)?)(\p{Currency_Symbol})?((?:(?:\d{1,3}[\.,])+\d{3})|\d+)(?:[\.,](\d{2}))?\b$"
+consistent!(claude_0, r"^(?:\b|(-)?)(\p{Currency_Symbol})?((?:(?:\d{1,3}[\.,])+\d{3})|\d+)(?:[\.,](\d{2}))?\b$");
+
+// clam-0.1.6: r"<%=\s*(.+?)\s*%>"
+consistent!(clam_0, r"<%=\s*(.+?)\s*%>");
+
+// classifier-0.0.3: r"(\s)"
+consistent!(classifier_0, r"(\s)");
+
+// click-0.3.2: r"(-----BEGIN .*-----\n)((?:(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)*\n)+)(-----END .*-----)"
+consistent!(click_0, r"(-----BEGIN .*-----\n)((?:(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)*\n)+)(-----END .*-----)");
+
+// click-0.3.2: r"-----BEGIN PRIVATE KEY-----"
+consistent!(click_1, r"-----BEGIN PRIVATE KEY-----");
+
+// ultrastar-txt-0.1.2: r"#([A-Z3a-z]*):(.*)"
+consistent!(ultrastar_txt_0, r"#([A-Z3a-z]*):(.*)");
+
+// ultrastar-txt-0.1.2: "^-\\s?(-?[0-9]+)\\s*$"
+consistent!(ultrastar_txt_1, "^-\\s?(-?[0-9]+)\\s*$");
+
+// ultrastar-txt-0.1.2: "^-\\s?(-?[0-9]+)\\s+(-?[0-9]+)"
+consistent!(ultrastar_txt_2, "^-\\s?(-?[0-9]+)\\s+(-?[0-9]+)");
+
+// ultrastar-txt-0.1.2: "^(.)\\s*(-?[0-9]+)\\s+(-?[0-9]+)\\s+(-?[0-9]+)\\s?(.*)"
+consistent!(
+    ultrastar_txt_3,
+    "^(.)\\s*(-?[0-9]+)\\s+(-?[0-9]+)\\s+(-?[0-9]+)\\s?(.*)"
+);
+
+// ultrastar-txt-0.1.2: "^P\\s?(-?[0-9]+)"
+consistent!(ultrastar_txt_4, "^P\\s?(-?[0-9]+)");
+
+// db-accelerate-2.0.0: r"^template\.add($|\..+$)"
+consistent!(db_accelerate_0, r"^template\.add($|\..+$)");
+
+// db-accelerate-2.0.0: r"^template\.sub($|\..+$)"
+consistent!(db_accelerate_1, r"^template\.sub($|\..+$)");
+
+// sterling-0.3.0: r"(\d+)([cegps])"
+consistent!(sterling_0, r"(\d+)([cegps])");
+
+// stache-0.2.0: r"[^\w]"
+consistent!(stache_0, r"[^\w]");
+
+// strukt-0.1.0: "\"([<>]?)([xcbB\\?hHiIlLqQfdspP]*)\""
+consistent!(strukt_0, "\"([<>]?)([xcbB\\?hHiIlLqQfdspP]*)\"");
+
+// steamid-ng-0.3.1: r"^STEAM_([0-4]):([0-1]):([0-9]{1,10})$"
+consistent!(steamid_ng_0, r"^STEAM_([0-4]):([0-1]):([0-9]{1,10})$");
+
+// steamid-ng-0.3.1: r"^\[([AGMPCgcLTIUai]):([0-4]):([0-9]{1,10})(:([0-9]+))?\]$"
+consistent!(
+    steamid_ng_1,
+    r"^\[([AGMPCgcLTIUai]):([0-4]):([0-9]{1,10})(:([0-9]+))?\]$"
+);
+
+// strscan-0.1.1: r"^\w+"
+consistent!(strscan_0, r"^\w+");
+
+// strscan-0.1.1: r"^\s+"
+consistent!(strscan_1, r"^\s+");
+
+// strscan-0.1.1: r"^\w+"
+consistent!(strscan_2, r"^\w+");
+
+// strscan-0.1.1: r"^\s+"
+consistent!(strscan_3, r"^\s+");
+
+// strscan-0.1.1: r"^(\w+)\s+"
+consistent!(strscan_4, r"^(\w+)\s+");
+
+// tk-carbon-0.2.0: r"^([a-zA-Z0-9\.-]+)(?:\s+(\d+))$"
+consistent!(tk_carbon_0, r"^([a-zA-Z0-9\.-]+)(?:\s+(\d+))$");
+
+// tk-carbon-0.2.0: r"^([a-zA-Z0-9\.-]+)(?:\s+(\d+))$"
+consistent!(tk_carbon_1, r"^([a-zA-Z0-9\.-]+)(?:\s+(\d+))$");
+
+// evalrs-0.0.10: r"extern\s+crate\s+([a-z0-9_]+)\s*;(\s*//(.+))?"
+consistent!(evalrs_0, r"extern\s+crate\s+([a-z0-9_]+)\s*;(\s*//(.+))?");
+
+// evalrs-0.0.10: r"(?m)^# "
+consistent!(evalrs_1, r"(?m)^# ");
+
+// evalrs-0.0.10: r"(?m)^\s*fn +main *\( *\)"
+consistent!(evalrs_2, r"(?m)^\s*fn +main *\( *\)");
+
+// evalrs-0.0.10: r"(extern\s+crate\s+[a-z0-9_]+\s*;)"
+consistent!(evalrs_3, r"(extern\s+crate\s+[a-z0-9_]+\s*;)");
+
+// gate_build-0.5.0: "(.*)_t([0-9]+)"
+consistent!(gate_build_0, "(.*)_t([0-9]+)");
+
+// rake-0.1.1: r"[^\P{P}-]|\s+-\s+"
+consistent!(rake_0, r"[^\P{P}-]|\s+-\s+");
+
+// rafy-0.2.1: r"^.*(?:(?:youtu\.be/|v/|vi/|u/w/|embed/)|(?:(?:watch)?\?v(?:i)?=|\&v(?:i)?=))([^#\&\?]*).*"
+consistent!(rafy_0, r"^.*(?:(?:youtu\.be/|v/|vi/|u/w/|embed/)|(?:(?:watch)?\?v(?:i)?=|\&v(?:i)?=))([^#\&\?]*).*");
+
+// raven-0.2.1: r"^(?P<protocol>.*?)://(?P<public_key>.*?):(?P<secret_key>.*?)@(?P<host>.*?)/(?P<path>.*/)?(?P<project_id>.*)$"
+consistent!(raven_0, r"^(?P<protocol>.*?)://(?P<public_key>.*?):(?P<secret_key>.*?)@(?P<host>.*?)/(?P<path>.*/)?(?P<project_id>.*)$");
+
+// rargs-0.2.0: r"\{[[:space:]]*[^{}]*[[:space:]]*\}"
+consistent!(rargs_0, r"\{[[:space:]]*[^{}]*[[:space:]]*\}");
+
+// rargs-0.2.0: r"^\{[[:space:]]*(?P<name>[[:word:]]*)[[:space:]]*\}$"
+consistent!(rargs_1, r"^\{[[:space:]]*(?P<name>[[:word:]]*)[[:space:]]*\}$");
+
+// rargs-0.2.0: r"^\{[[:space:]]*(?P<num>-?\d+)[[:space:]]*\}$"
+consistent!(rargs_2, r"^\{[[:space:]]*(?P<num>-?\d+)[[:space:]]*\}$");
+
+// rargs-0.2.0: r"^\{(?P<left>-?\d*)?\.\.(?P<right>-?\d*)?(?::(?P<sep>.*))?\}$"
+consistent!(
+    rargs_3,
+    r"^\{(?P<left>-?\d*)?\.\.(?P<right>-?\d*)?(?::(?P<sep>.*))?\}$"
+);
+
+// rargs-0.2.0: r"(.*?)[[:space:]]+|(.*?)$"
+consistent!(rargs_4, r"(.*?)[[:space:]]+|(.*?)$");
+
+// indradb-lib-0.15.0: r"[a-zA-Z0-9]{8}"
+consistent!(indradb_lib_0, r"[a-zA-Z0-9]{8}");
+
+// fungi-lang-0.1.50: r"::"
+consistent!(fungi_lang_0, r"::");
+
+// nickel-0.10.1: "/hello/(?P<name>[a-zA-Z]+)"
+consistent!(nickel_0, "/hello/(?P<name>[a-zA-Z]+)");
+
+// nickel-0.10.1: "/hello/(?P<name>[a-zA-Z]+)"
+consistent!(nickel_1, "/hello/(?P<name>[a-zA-Z]+)");
+
+// pact_verifier-0.4.0: r"\{(\w+)\}"
+consistent!(pact_verifier_0, r"\{(\w+)\}");
+
+// pact_matching-0.4.1: "application/.*json"
+consistent!(pact_matching_0, "application/.*json");
+
+// pact_matching-0.4.1: "application/json.*"
+consistent!(pact_matching_1, "application/json.*");
+
+// pact_matching-0.4.1: "application/.*xml"
+consistent!(pact_matching_2, "application/.*xml");
+
+// pangu-0.2.0: "([\"'\\(\\[\\{{<\u{201c}])(\\s*)(.+?)(\\s*)([\"'\\)\\]\\}}>\u{201d}])"
+consistent!(
+    pangu_0,
+    "([\"'\\(\\[\\{{<\u{201c}])(\\s*)(.+?)(\\s*)([\"'\\)\\]\\}}>\u{201d}])"
+);
+
+// pangu-0.2.0: "([\\(\\[\\{{<\u{201c}]+)(\\s*)(.+?)(\\s*)([\\)\\]\\}}>\u{201d}]+)"
+consistent!(
+    pangu_1,
+    "([\\(\\[\\{{<\u{201c}]+)(\\s*)(.+?)(\\s*)([\\)\\]\\}}>\u{201d}]+)"
+);
+
+// parser-haskell-0.2.0: r"\{-[\s\S]*?-\}"
+consistent!(parser_haskell_0, r"\{-[\s\S]*?-\}");
+
+// parser-haskell-0.2.0: r"(?m);+\s*$"
+consistent!(parser_haskell_1, r"(?m);+\s*$");
+
+// parser-haskell-0.2.0: r"(?m)^#(if|ifn?def|endif|else|include|elif).*"
+consistent!(parser_haskell_2, r"(?m)^#(if|ifn?def|endif|else|include|elif).*");
+
+// parser-haskell-0.2.0: r"'([^'\\]|\\[A-Z]{1,3}|\\.)'"
+consistent!(parser_haskell_3, r"'([^'\\]|\\[A-Z]{1,3}|\\.)'");
+
+// parser-haskell-0.2.0: r"forall\s+(.*?)\."
+consistent!(parser_haskell_4, r"forall\s+(.*?)\.");
+
+// html2md-0.2.1: "\\s{2,}"
+consistent!(html2md_0, "\\s{2,}");
+
+// html2md-0.2.1: "\\n{2,}"
+consistent!(html2md_1, "\\n{2,}");
+
+// html2md-0.2.1: "(?m)(\\S) $"
+consistent!(html2md_2, "(?m)(\\S) $");
+
+// html2md-0.2.1: "(?m)^[-*] "
+consistent!(html2md_3, "(?m)^[-*] ");
+
+// ovpnfile-0.1.2: r"#.*$"
+consistent!(ovpnfile_0, r"#.*$");
+
+// ovpnfile-0.1.2: r"^<(\S+)>"
+consistent!(ovpnfile_1, r"^<(\S+)>");
+
+// ovpnfile-0.1.2: r"^</(\S+)>"
+consistent!(ovpnfile_2, r"^</(\S+)>");
+
+// screenruster-saver-fractal-0.1.1: r"#([:xdigit:]{2})([:xdigit:]{2})([:xdigit:]{2})"
+consistent!(
+    screenruster_saver_fractal_0,
+    r"#([:xdigit:]{2})([:xdigit:]{2})([:xdigit:]{2})"
+);
+
+// scarlet-0.2.2: r"rgb\((?: *(\d{1,3}),)(?: *(\d{1,3}),)(?: *(\d{1,3}))\)"
+consistent!(
+    scarlet_0,
+    r"rgb\((?: *(\d{1,3}),)(?: *(\d{1,3}),)(?: *(\d{1,3}))\)"
+);
+
+// cpp_to_rust_generator-0.2.0: r"^([\w:]+)<(.+)>$"
+consistent!(cpp_to_rust_generator_0, r"^([\w:]+)<(.+)>$");
+
+// cpp_to_rust_generator-0.2.0: r"^type-parameter-(\d+)-(\d+)$"
+consistent!(cpp_to_rust_generator_1, r"^type-parameter-(\d+)-(\d+)$");
+
+// cpp_to_rust_generator-0.2.0: r"^([\w~]+)<[^<>]+>$"
+consistent!(cpp_to_rust_generator_2, r"^([\w~]+)<[^<>]+>$");
+
+// cpp_to_rust_generator-0.2.0: r"(signals|Q_SIGNALS)\s*:"
+consistent!(cpp_to_rust_generator_3, r"(signals|Q_SIGNALS)\s*:");
+
+// cpp_to_rust_generator-0.2.0: r"(slots|Q_SLOTS)\s*:"
+consistent!(cpp_to_rust_generator_4, r"(slots|Q_SLOTS)\s*:");
+
+// cpp_to_rust_generator-0.2.0: r"(public|protected|private)\s*:"
+consistent!(cpp_to_rust_generator_5, r"(public|protected|private)\s*:");
+
+// cpp_to_rust-0.5.3: r"^([\w:]+)<(.+)>$"
+consistent!(cpp_to_rust_0, r"^([\w:]+)<(.+)>$");
+
+// cpp_to_rust-0.5.3: r"^type-parameter-(\d+)-(\d+)$"
+consistent!(cpp_to_rust_1, r"^type-parameter-(\d+)-(\d+)$");
+
+// cpp_to_rust-0.5.3: r"^([\w~]+)<[^<>]+>$"
+consistent!(cpp_to_rust_2, r"^([\w~]+)<[^<>]+>$");
+
+// cpp_to_rust-0.5.3: r"(signals|Q_SIGNALS)\s*:"
+consistent!(cpp_to_rust_3, r"(signals|Q_SIGNALS)\s*:");
+
+// cpp_to_rust-0.5.3: r"(slots|Q_SLOTS)\s*:"
+consistent!(cpp_to_rust_4, r"(slots|Q_SLOTS)\s*:");
+
+// cpp_to_rust-0.5.3: r"(public|protected|private)\s*:"
+consistent!(cpp_to_rust_5, r"(public|protected|private)\s*:");
+
+// fritzbox_logs-0.2.0: "(\\d{2}\\.\\d{2}\\.\\d{2}) (\\d{2}:\\d{2}:\\d{2}) (.*)"
+consistent!(
+    fritzbox_logs_0,
+    "(\\d{2}\\.\\d{2}\\.\\d{2}) (\\d{2}:\\d{2}:\\d{2}) (.*)"
+);
+
+// fractal-matrix-api-3.29.0: r"mxc://(?P<server>[^/]+)/(?P<media>.+)"
+consistent!(fractal_matrix_api_0, r"mxc://(?P<server>[^/]+)/(?P<media>.+)");
+
+// smtp2go-0.1.4: r"^api-[a-zA-Z0-9]{32}$"
+consistent!(smtp2go_0, r"^api-[a-zA-Z0-9]{32}$");
+
+// pusher-0.3.1: r"^[-a-zA-Z0-9_=@,.;]+$"
+consistent!(pusher_0, r"^[-a-zA-Z0-9_=@,.;]+$");
+
+// pusher-0.3.1: r"\A\d+\.\d+\z"
+consistent!(pusher_1, r"\A\d+\.\d+\z");
+
+// bakervm-0.9.0: r"^\.(.+?) +?(.+)$"
+consistent!(bakervm_0, r"^\.(.+?) +?(.+)$");
+
+// bakervm-0.9.0: r"^\.([^\s]+)$"
+consistent!(bakervm_1, r"^\.([^\s]+)$");
+
+// bakervm-0.9.0: r"^include! +([^\s]+)$"
+consistent!(bakervm_2, r"^include! +([^\s]+)$");
+
+// bakervm-0.9.0: r"^@(\d+)$"
+consistent!(bakervm_3, r"^@(\d+)$");
+
+// bakervm-0.9.0: r"^true|false$"
+consistent!(bakervm_4, r"^true|false$");
+
+// bakervm-0.9.0: r"^(-?\d+)?\.[0-9]+$"
+consistent!(bakervm_5, r"^(-?\d+)?\.[0-9]+$");
+
+// bakervm-0.9.0: r"^(-?\d+)?$"
+consistent!(bakervm_6, r"^(-?\d+)?$");
+
+// bakervm-0.9.0: r"^#([0-9abcdefABCDEF]{6})$"
+consistent!(bakervm_7, r"^#([0-9abcdefABCDEF]{6})$");
+
+// bakervm-0.9.0: r"^'(.)'$"
+consistent!(bakervm_8, r"^'(.)'$");
+
+// bakervm-0.9.0: r"^\$vi\((\d+)\)$"
+consistent!(bakervm_9, r"^\$vi\((\d+)\)$");
+
+// bakervm-0.9.0: r"^\$key\((\d+)\)$"
+consistent!(bakervm_10, r"^\$key\((\d+)\)$");
+
+// banana-0.0.2: "(?P<type>[A-Z^']+) (?P<route>[^']+) HTTP/(?P<http>[^']+)"
+consistent!(
+    banana_0,
+    "(?P<type>[A-Z^']+) (?P<route>[^']+) HTTP/(?P<http>[^']+)"
+);
+
+// serial-key-2.0.0: r"[A-F0-9]{8}"
+consistent!(serial_key_0, r"[A-F0-9]{8}");
+
+// serde-hjson-0.8.1: "[\\\\\"\x00-\x1f\x7f-\u{9f}\u{00ad}\u{0600}-\u{0604}\u{070f}\u{17b4}\u{17b5}\u{200c}-\u{200f}\u{2028}-\u{202f}\u{2060}-\u{206f}\u{feff}\u{fff0}-\u{ffff}]"
+consistent!(serde_hjson_0, "[\\\\\"\x00-\x1f\x7f-\u{9f}\u{00ad}\u{0600}-\u{0604}\u{070f}\u{17b4}\u{17b5}\u{200c}-\u{200f}\u{2028}-\u{202f}\u{2060}-\u{206f}\u{feff}\u{fff0}-\u{ffff}]");
+
+// serde-hjson-0.8.1: "[\x00-\x1f\x7f-\u{9f}\u{00ad}\u{0600}-\u{0604}\u{070f}\u{17b4}\u{17b5}\u{200c}-\u{200f}\u{2028}-\u{202f}\u{2060}-\u{206f}\u{feff}\u{fff0}-\u{ffff}]"
+consistent!(serde_hjson_1, "[\x00-\x1f\x7f-\u{9f}\u{00ad}\u{0600}-\u{0604}\u{070f}\u{17b4}\u{17b5}\u{200c}-\u{200f}\u{2028}-\u{202f}\u{2060}-\u{206f}\u{feff}\u{fff0}-\u{ffff}]");
+
+// serde-hjson-0.8.1: "'''|[\x00-\x09\x0b\x0c\x0e-\x1f\x7f-\u{9f}\u{00ad}\u{0600}-\u{0604}\u{070f}\u{17b4}\u{17b5}\u{200c}-\u{200f}\u{2028}-\u{202f}\u{2060}-\u{206f}\u{feff}\u{fff0}-\u{ffff}]"
+consistent!(serde_hjson_2, "'''|[\x00-\x09\x0b\x0c\x0e-\x1f\x7f-\u{9f}\u{00ad}\u{0600}-\u{0604}\u{070f}\u{17b4}\u{17b5}\u{200c}-\u{200f}\u{2028}-\u{202f}\u{2060}-\u{206f}\u{feff}\u{fff0}-\u{ffff}]");
+
+// serde-odbc-0.1.0: r"/todos/(?P<id>\d+)"
+consistent!(serde_odbc_0, r"/todos/(?P<id>\d+)");
+
+// sentry-0.6.0: r"^(?:_<)?([a-zA-Z0-9_]+?)(?:\.\.|::)"
+consistent!(sentry_0, r"^(?:_<)?([a-zA-Z0-9_]+?)(?:\.\.|::)");
+
+// sentiment-0.1.1: r"[^a-zA-Z0 -]+"
+consistent!(sentiment_0, r"[^a-zA-Z0 -]+");
+
+// sentiment-0.1.1: r" {2,}"
+consistent!(sentiment_1, r" {2,}");
+
+// verilog-0.0.1: r"(?m)//.*"
+consistent!(verilog_0, r"(?m)//.*");
+
+// verex-0.2.2: "(?P<robot>C3PO)"
+consistent!(verex_0, "(?P<robot>C3PO)");
+
+// handlebars-0.32.4: ">|<|\"|&"
+consistent!(handlebars_0, ">|<|\"|&");
+
+// haikunator-0.1.2: r"^\w+-\w+-[0123456789]{4}$"
+consistent!(haikunator_0, r"^\w+-\w+-[0123456789]{4}$");
+
+// haikunator-0.1.2: r"^\w+@\w+@[0123456789]{4}$"
+consistent!(haikunator_1, r"^\w+@\w+@[0123456789]{4}$");
+
+// haikunator-0.1.2: r"^\w+-\w+-[0123456789abcdef]{4}$"
+consistent!(haikunator_2, r"^\w+-\w+-[0123456789abcdef]{4}$");
+
+// haikunator-0.1.2: r"^\w+-\w+-[0123456789忠犬ハチ公]{10}$"
+consistent!(haikunator_3, r"^\w+-\w+-[0123456789忠犬ハチ公]{10}$");
+
+// haikunator-0.1.2: r"^\w+-\w+$"
+consistent!(haikunator_4, r"^\w+-\w+$");
+
+// haikunator-0.1.2: r"^\w+-\w+-[foo]{4}$"
+consistent!(haikunator_5, r"^\w+-\w+-[foo]{4}$");
+
+// haikunator-0.1.2: r"^\w+-\w+-[0123456789忠犬ハチ公]{5}$"
+consistent!(haikunator_6, r"^\w+-\w+-[0123456789忠犬ハチ公]{5}$");
+
+// bobbin-cli-0.8.3: r"(.*)"
+consistent!(bobbin_cli_0, r"(.*)");
+
+// bobbin-cli-0.8.3: r"rustc (.*)"
+consistent!(bobbin_cli_1, r"rustc (.*)");
+
+// bobbin-cli-0.8.3: r"cargo (.*)"
+consistent!(bobbin_cli_2, r"cargo (.*)");
+
+// bobbin-cli-0.8.3: r"xargo (.*)\n"
+consistent!(bobbin_cli_3, r"xargo (.*)\n");
+
+// bobbin-cli-0.8.3: r"Open On-Chip Debugger (.*)"
+consistent!(bobbin_cli_4, r"Open On-Chip Debugger (.*)");
+
+// bobbin-cli-0.8.3: r"arm-none-eabi-gcc \(GNU Tools for ARM Embedded Processors[^\)]*\) (.*)"
+consistent!(
+    bobbin_cli_5,
+    r"arm-none-eabi-gcc \(GNU Tools for ARM Embedded Processors[^\)]*\) (.*)"
+);
+
+// bobbin-cli-0.8.3: r"(?m).*\nBasic Open Source SAM-BA Application \(BOSSA\) Version (.*)\n"
+consistent!(
+    bobbin_cli_6,
+    r"(?m).*\nBasic Open Source SAM-BA Application \(BOSSA\) Version (.*)\n"
+);
+
+// bobbin-cli-0.8.3: r"(?m)SEGGER J-Link Commander (.*)\n"
+consistent!(bobbin_cli_7, r"(?m)SEGGER J-Link Commander (.*)\n");
+
+// bobbin-cli-0.8.3: r"(?m)Teensy Loader, Command Line, Version (.*)\n"
+consistent!(bobbin_cli_8, r"(?m)Teensy Loader, Command Line, Version (.*)\n");
+
+// bobbin-cli-0.8.3: r"dfu-util (.*)\n"
+consistent!(bobbin_cli_9, r"dfu-util (.*)\n");
+
+// borsholder-0.9.1: r"^/static/[\w.]+$"
+consistent!(borsholder_0, r"^/static/[\w.]+$");
+
+// borsholder-0.9.1: r"^/timeline/([0-9]+)$"
+consistent!(borsholder_1, r"^/timeline/([0-9]+)$");
+
+// fblog-1.0.1: "\u{001B}\\[[\\d;]*[^\\d;]"
+consistent!(fblog_0, "\u{001B}\\[[\\d;]*[^\\d;]");
+
+// fblog-1.0.1: "\u{001B}\\[[\\d;]*[^\\d;]"
+consistent!(fblog_1, "\u{001B}\\[[\\d;]*[^\\d;]");
+
+// toml-query-0.6.0: r"^\[\d+\]$"
+consistent!(toml_query_0, r"^\[\d+\]$");
+
+// todo-txt-1.1.0: r" (?P<key>[^\s]+):(?P<value>[^\s^/]+)"
+consistent!(todo_txt_0, r" (?P<key>[^\s]+):(?P<value>[^\s^/]+)");
+
+// findr-0.1.5: r"\band\b"
+consistent!(findr_0, r"\band\b");
+
+// findr-0.1.5: r"\bor\b"
+consistent!(findr_1, r"\bor\b");
+
+// findr-0.1.5: r"\bnot\b"
+consistent!(findr_2, r"\bnot\b");
+
+// file-sniffer-3.0.1: r".*?\.(a|la|lo|o|ll|keter|bc|dyn_o|out|d|rlib|crate|min\.js|hi|dyn_hi|S|jsexe|webapp|js\.externs|ibc|toc|aux|fdb_latexmk|fls|egg-info|whl|js_a|js_hi|jld|ji|js_o|so.*|dump-.*|vmb|crx|orig|elmo|elmi|pyc|mod|p_hi|p_o|prof|tix)$"
+consistent!(file_sniffer_0, r".*?\.(a|la|lo|o|ll|keter|bc|dyn_o|out|d|rlib|crate|min\.js|hi|dyn_hi|S|jsexe|webapp|js\.externs|ibc|toc|aux|fdb_latexmk|fls|egg-info|whl|js_a|js_hi|jld|ji|js_o|so.*|dump-.*|vmb|crx|orig|elmo|elmi|pyc|mod|p_hi|p_o|prof|tix)$");
+
+// file-sniffer-3.0.1: r".*?\.(stats|conf|h|cache.*|dat|pc|info)$"
+consistent!(file_sniffer_1, r".*?\.(stats|conf|h|cache.*|dat|pc|info)$");
+
+// file-sniffer-3.0.1: r".*?\.(exe|a|la|o|ll|keter|bc|dyn_o|out|d|rlib|crate|min\.js|hi|dyn_hi|jsexe|webapp|js\.externs|ibc|toc|aux|fdb_latexmk|fls|egg-info|whl|js_a|js_hi|jld|ji|js_o|so.*|dump-.*|vmb|crx|orig|elmo|elmi|pyc|mod|p_hi|p_o|prof|tix)$"
+consistent!(file_sniffer_2, r".*?\.(exe|a|la|o|ll|keter|bc|dyn_o|out|d|rlib|crate|min\.js|hi|dyn_hi|jsexe|webapp|js\.externs|ibc|toc|aux|fdb_latexmk|fls|egg-info|whl|js_a|js_hi|jld|ji|js_o|so.*|dump-.*|vmb|crx|orig|elmo|elmi|pyc|mod|p_hi|p_o|prof|tix)$");
+
+// file-sniffer-3.0.1: r".*?\.(stats|conf|h|cache.*)$"
+consistent!(file_sniffer_3, r".*?\.(stats|conf|h|cache.*)$");
+
+// file-sniffer-3.0.1: r"(\.git|\.pijul|_darcs|\.hg)$"
+consistent!(file_sniffer_4, r"(\.git|\.pijul|_darcs|\.hg)$");
+
+// file_logger-0.1.0: "test"
+consistent!(file_logger_0, "test");
+
+// file_scanner-0.2.0: r"foo"
+consistent!(file_scanner_0, r"foo");
+
+// file_scanner-0.2.0: r"a+b"
+consistent!(file_scanner_1, r"a+b");
+
+// file_scanner-0.2.0: r"a[ab]*b"
+consistent!(file_scanner_2, r"a[ab]*b");
+
+// file_scanner-0.2.0: r"\s+"
+consistent!(file_scanner_3, r"\s+");
+
+// file_scanner-0.2.0: r"\s+"
+consistent!(file_scanner_4, r"\s+");
+
+// cellsplit-0.2.1: r"^\s*([^\s]+) %cellsplit<\d+>$"
+consistent!(cellsplit_0, r"^\s*([^\s]+) %cellsplit<\d+>$");
+
+// cellsplit-0.2.1: r"^\s*([^\s]+) %cellsplit<\d+>$"
+consistent!(cellsplit_1, r"^\s*([^\s]+) %cellsplit<\d+>$");
+
+// aterm-0.20.0: r"^[+\-]?[0-9]+"
+consistent!(aterm_0, r"^[+\-]?[0-9]+");
+
+// aterm-0.20.0: r"^[+\-]?[0-9]+\.[0-9]*([eE][+\-]?[0-9]+)?"
+consistent!(aterm_1, r"^[+\-]?[0-9]+\.[0-9]*([eE][+\-]?[0-9]+)?");
+
+// atarashii_imap-0.3.0: r"^[*] OK"
+consistent!(atarashii_imap_0, r"^[*] OK");
+
+// atarashii_imap-0.3.0: r"FLAGS\s\((.+)\)"
+consistent!(atarashii_imap_1, r"FLAGS\s\((.+)\)");
+
+// atarashii_imap-0.3.0: r"\[PERMANENTFLAGS\s\((.+)\)\]"
+consistent!(atarashii_imap_2, r"\[PERMANENTFLAGS\s\((.+)\)\]");
+
+// atarashii_imap-0.3.0: r"\[UIDVALIDITY\s(\d+)\]"
+consistent!(atarashii_imap_3, r"\[UIDVALIDITY\s(\d+)\]");
+
+// atarashii_imap-0.3.0: r"(\d+)\sEXISTS"
+consistent!(atarashii_imap_4, r"(\d+)\sEXISTS");
+
+// atarashii_imap-0.3.0: r"(\d+)\sRECENT"
+consistent!(atarashii_imap_5, r"(\d+)\sRECENT");
+
+// atarashii_imap-0.3.0: r"\[UNSEEN\s(\d+)\]"
+consistent!(atarashii_imap_6, r"\[UNSEEN\s(\d+)\]");
+
+// atarashii_imap-0.3.0: r"\[UIDNEXT\s(\d+)\]"
+consistent!(atarashii_imap_7, r"\[UIDNEXT\s(\d+)\]");
+
+// editorconfig-1.0.0: r"\\(\{|\})"
+consistent!(editorconfig_0, r"\\(\{|\})");
+
+// editorconfig-1.0.0: r"(^|[^\\])\\\|"
+consistent!(editorconfig_1, r"(^|[^\\])\\\|");
+
+// editorconfig-1.0.0: r"\[([^\]]*)$"
+consistent!(editorconfig_2, r"\[([^\]]*)$");
+
+// editorconfig-1.0.0: r"\[(.*/.*)\]"
+consistent!(editorconfig_3, r"\[(.*/.*)\]");
+
+// editorconfig-1.0.0: r"\{(-?\d+\\\.\\\.-?\d+)\}"
+consistent!(editorconfig_4, r"\{(-?\d+\\\.\\\.-?\d+)\}");
+
+// editorconfig-1.0.0: r"\{([^,]+)\}"
+consistent!(editorconfig_5, r"\{([^,]+)\}");
+
+// editorconfig-1.0.0: r"\{(([^\}].*)?(,|\|)(.*[^\\])?)\}"
+consistent!(editorconfig_6, r"\{(([^\}].*)?(,|\|)(.*[^\\])?)\}");
+
+// editorconfig-1.0.0: r"^/"
+consistent!(editorconfig_7, r"^/");
+
+// editorconfig-1.0.0: r"(^|[^\\])(\{|\})"
+consistent!(editorconfig_8, r"(^|[^\\])(\{|\})");
+
+// edmunge-1.0.0: "^#!.*\n"
+consistent!(edmunge_0, "^#!.*\n");
+
+// unicode_names2_macros-0.2.0: r"\\N\{(.*?)(?:\}|$)"
+consistent!(unicode_names2_macros_0, r"\\N\{(.*?)(?:\}|$)");
+
+// unidiff-0.2.1: r"^--- (?P<filename>[^\t\n]+)(?:\t(?P<timestamp>[^\n]+))?"
+consistent!(
+    unidiff_0,
+    r"^--- (?P<filename>[^\t\n]+)(?:\t(?P<timestamp>[^\n]+))?"
+);
+
+// unidiff-0.2.1: r"^\+\+\+ (?P<filename>[^\t\n]+)(?:\t(?P<timestamp>[^\n]+))?"
+consistent!(
+    unidiff_1,
+    r"^\+\+\+ (?P<filename>[^\t\n]+)(?:\t(?P<timestamp>[^\n]+))?"
+);
+
+// unidiff-0.2.1: r"^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@[ ]?(.*)"
+consistent!(unidiff_2, r"^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@[ ]?(.*)");
+
+// unidiff-0.2.1: r"^(?P<line_type>[- \n\+\\]?)(?P<value>.*)"
+consistent!(unidiff_3, r"^(?P<line_type>[- \n\+\\]?)(?P<value>.*)");
+
+// slippy-map-tiles-0.13.1: "/?(?P<zoom>[0-9]?[0-9])/(?P<x>[0-9]{1,10})/(?P<y>[0-9]{1,10})(\\.[a-zA-Z]{3,4})?$"
+consistent!(slippy_map_tiles_0, "/?(?P<zoom>[0-9]?[0-9])/(?P<x>[0-9]{1,10})/(?P<y>[0-9]{1,10})(\\.[a-zA-Z]{3,4})?$");
+
+// slippy-map-tiles-0.13.1: r"^(?P<minlon>-?[0-9]{1,3}(\.[0-9]{1,10})?) (?P<minlat>-?[0-9]{1,3}(\.[0-9]{1,10})?) (?P<maxlon>-?[0-9]{1,3}(\.[0-9]{1,10})?) (?P<maxlat>-?[0-9]{1,3}(\.[0-9]{1,10})?)$"
+consistent!(slippy_map_tiles_1, r"^(?P<minlon>-?[0-9]{1,3}(\.[0-9]{1,10})?) (?P<minlat>-?[0-9]{1,3}(\.[0-9]{1,10})?) (?P<maxlon>-?[0-9]{1,3}(\.[0-9]{1,10})?) (?P<maxlat>-?[0-9]{1,3}(\.[0-9]{1,10})?)$");
+
+// slippy-map-tiles-0.13.1: r"^(?P<minlon>-?[0-9]{1,3}(\.[0-9]{1,10})?),(?P<minlat>-?[0-9]{1,3}(\.[0-9]{1,10})?),(?P<maxlon>-?[0-9]{1,3}(\.[0-9]{1,10})?),(?P<maxlat>-?[0-9]{1,3}(\.[0-9]{1,10})?)$"
+consistent!(slippy_map_tiles_2, r"^(?P<minlon>-?[0-9]{1,3}(\.[0-9]{1,10})?),(?P<minlat>-?[0-9]{1,3}(\.[0-9]{1,10})?),(?P<maxlon>-?[0-9]{1,3}(\.[0-9]{1,10})?),(?P<maxlat>-?[0-9]{1,3}(\.[0-9]{1,10})?)$");
+
+// sonos-0.1.2: r"^https?://(.+?):1400/xml"
+consistent!(sonos_0, r"^https?://(.+?):1400/xml");
+
+// validator_derive-0.7.0: r"^[a-z]{2}$"
+consistent!(validator_derive_0, r"^[a-z]{2}$");
+
+// validator_derive-0.7.0: r"[a-z]{2}"
+consistent!(validator_derive_1, r"[a-z]{2}");
+
+// validator_derive-0.7.0: r"[a-z]{2}"
+consistent!(validator_derive_2, r"[a-z]{2}");
+
+// nginx-config-0.8.0: r"one of \d+ options"
+consistent!(nginx_config_0, r"one of \d+ options");
+
+// waltz-0.4.0: r"[\s,]"
+consistent!(waltz_0, r"[\s,]");
+
+// warheadhateus-0.2.1: r"^aws_access_key_id = (.*)"
+consistent!(warheadhateus_0, r"^aws_access_key_id = (.*)");
+
+// warheadhateus-0.2.1: r"^aws_secret_access_key = (.*)"
+consistent!(warheadhateus_1, r"^aws_secret_access_key = (.*)");
+
+// warheadhateus-0.2.1: r"^aws_access_key_id = (.*)"
+consistent!(warheadhateus_2, r"^aws_access_key_id = (.*)");
+
+// warheadhateus-0.2.1: r"^aws_secret_access_key = (.*)"
+consistent!(warheadhateus_3, r"^aws_secret_access_key = (.*)");
+
+// jieba-rs-0.2.2: r"([\u{4E00}-\u{9FD5}a-zA-Z0-9+#&\._%]+)"
+consistent!(jieba_rs_0, r"([\u{4E00}-\u{9FD5}a-zA-Z0-9+#&\._%]+)");
+
+// jieba-rs-0.2.2: r"(\r\n|\s)"
+consistent!(jieba_rs_1, r"(\r\n|\s)");
+
+// jieba-rs-0.2.2: "([\u{4E00}-\u{9FD5}]+)"
+consistent!(jieba_rs_2, "([\u{4E00}-\u{9FD5}]+)");
+
+// jieba-rs-0.2.2: r"[^a-zA-Z0-9+#\n]"
+consistent!(jieba_rs_3, r"[^a-zA-Z0-9+#\n]");
+
+// jieba-rs-0.2.2: r"([\u{4E00}-\u{9FD5}]+)"
+consistent!(jieba_rs_4, r"([\u{4E00}-\u{9FD5}]+)");
+
+// jieba-rs-0.2.2: r"([a-zA-Z0-9]+(?:.\d+)?%?)"
+consistent!(jieba_rs_5, r"([a-zA-Z0-9]+(?:.\d+)?%?)");
+
+// lalrpop-0.15.2: r"Span\([0-9 ,]*\)"
+consistent!(lalrpop_0, r"Span\([0-9 ,]*\)");
+
+// lalrpop-snap-0.15.2: r"Span\([0-9 ,]*\)"
+consistent!(lalrpop_snap_0, r"Span\([0-9 ,]*\)");
+
+// nlp-tokenize-0.1.0: r"[\S]+"
+consistent!(nlp_tokenize_0, r"[\S]+");
+
+// kbgpg-0.1.2: "[[:xdigit:]][70]"
+consistent!(kbgpg_0, "[[:xdigit:]][70]");
+
+// cdbd-0.1.1: r"^((?P<address>.*):)?(?P<port>\d+)$"
+consistent!(cdbd_0, r"^((?P<address>.*):)?(?P<port>\d+)$");
+
+// mbutiles-0.1.1: r"[\w\s=+-/]+\((\{(.|\n)*\})\);?"
+consistent!(mbutiles_0, r"[\w\s=+-/]+\((\{(.|\n)*\})\);?");
+
+// extrahop-0.2.5: r"^-\d+(?:ms|s|m|h|d|w|y)?$"
+consistent!(extrahop_0, r"^-\d+(?:ms|s|m|h|d|w|y)?$");
+
+// pippin-0.1.0: "^((?:.*)-)?ss(0|[1-9][0-9]*)\\.pip$"
+consistent!(pippin_0, "^((?:.*)-)?ss(0|[1-9][0-9]*)\\.pip$");
+
+// pippin-0.1.0: "^((?:.*)-)?ss(0|[1-9][0-9]*)-cl(0|[1-9][0-9]*)\\.piplog$"
+consistent!(
+    pippin_1,
+    "^((?:.*)-)?ss(0|[1-9][0-9]*)-cl(0|[1-9][0-9]*)\\.piplog$"
+);
+
+// pippin-0.1.0: "^((?:.*)-)?ss(0|[1-9][0-9]*)\\.pip$"
+consistent!(pippin_2, "^((?:.*)-)?ss(0|[1-9][0-9]*)\\.pip$");
+
+// pippin-0.1.0: "^((?:.*)-)?ss(0|[1-9][0-9]*)-cl(0|[1-9][0-9]*)\\.piplog$"
+consistent!(
+    pippin_3,
+    "^((?:.*)-)?ss(0|[1-9][0-9]*)-cl(0|[1-9][0-9]*)\\.piplog$"
+);
+
+// pippin-0.1.0: "^.*pn(0|[1-9][0-9]*)(-ss(0|[1-9][0-9]*)(\\.pip|-cl(0|[1-9][0-9]*)\\.piplog))?$"
+consistent!(pippin_4, "^.*pn(0|[1-9][0-9]*)(-ss(0|[1-9][0-9]*)(\\.pip|-cl(0|[1-9][0-9]*)\\.piplog))?$");
+
+// pippin-0.1.0: "^(.*)-ss(?:0|[1-9][0-9]*)(?:\\.pip|-cl(?:0|[1-9][0-9]*)\\.piplog)$"
+consistent!(
+    pippin_5,
+    "^(.*)-ss(?:0|[1-9][0-9]*)(?:\\.pip|-cl(?:0|[1-9][0-9]*)\\.piplog)$"
+);
+
+// pinyin-0.3.0: r"(?i)[āáǎàēéěèōóǒòīíǐìūúǔùüǘǚǜńň]"
+consistent!(
+    pinyin_0,
+    r"(?i)[āáǎàēéěèōóǒòīíǐìūúǔùüǘǚǜńň]"
+);
+
+// pinyin-0.3.0: r"([aeoiuvnm])([0-4])$"
+consistent!(pinyin_1, r"([aeoiuvnm])([0-4])$");
+
+// duration-parser-0.2.0: r"(?P<value>\d+)(?P<units>[a-z])"
+consistent!(duration_parser_0, r"(?P<value>\d+)(?P<units>[a-z])");
+
+// dutree-0.2.7: r"^\d+\D?$"
+consistent!(dutree_0, r"^\d+\D?$");
+
+// djangohashers-0.3.0: r"^[A-Za-z0-9]*$"
+consistent!(djangohashers_0, r"^[A-Za-z0-9]*$");
+
+// rtag-0.3.5: r"^[A-Z][A-Z0-9]{2,}$"
+consistent!(rtag_0, r"^[A-Z][A-Z0-9]{2,}$");
+
+// rtag-0.3.5: r"^http://www\.emusic\.com"
+consistent!(rtag_1, r"^http://www\.emusic\.com");
+
+// rtag-0.3.5: r"^[A-Z][A-Z0-9]{2,}"
+consistent!(rtag_2, r"^[A-Z][A-Z0-9]{2,}");
+
+// rtag-0.3.5: r"(^[\x{0}|\x{feff}|\x{fffe}]*|[\x{0}|\x{feff}|\x{fffe}]*$)"
+consistent!(
+    rtag_3,
+    r"(^[\x{0}|\x{feff}|\x{fffe}]*|[\x{0}|\x{feff}|\x{fffe}]*$)"
+);
+
+// rtow-0.1.0: r"(\d+)[xX](\d+)"
+consistent!(rtow_0, r"(\d+)[xX](\d+)");
+
+// pleingres-sql-plugin-0.1.0: r"\$([a-zA-Z0-9_]+)"
+consistent!(pleingres_sql_plugin_0, r"\$([a-zA-Z0-9_]+)");
+
+// dono-2.0.0: "[\\n]+"
+consistent!(dono_0, "[\\n]+");
+
+// dono-2.0.0: "(?m)^\\n"
+consistent!(dono_1, "(?m)^\\n");
+
+// dono-2.0.0: "(?m)^\\n"
+consistent!(dono_2, "(?m)^\\n");
+
+// ssb-common-0.3.0: r"^[0-9A-Za-z\+/]{43}=\.ed25519$"
+consistent!(ssb_common_0, r"^[0-9A-Za-z\+/]{43}=\.ed25519$");
+
+// ssb-common-0.3.0: r"^[0-9A-Za-z\+/]{86}==\.ed25519$"
+consistent!(ssb_common_1, r"^[0-9A-Za-z\+/]{86}==\.ed25519$");
+
+// ssb-common-0.3.0: r"^[0-9A-Za-z\+/]{43}=\.sha256$"
+consistent!(ssb_common_2, r"^[0-9A-Za-z\+/]{43}=\.sha256$");
+
+// mozversion-0.1.3: r"^(?P<major>\d+)\.(?P<minor>\d+)(?:\.(?P<patch>\d+))?(?:(?P<pre0>[a-z]+)(?P<pre1>\d*))?$"
+consistent!(mozversion_0, r"^(?P<major>\d+)\.(?P<minor>\d+)(?:\.(?P<patch>\d+))?(?:(?P<pre0>[a-z]+)(?P<pre1>\d*))?$");
+
+// monger-0.5.6: r"^(\d+)\.(\d+)$"
+consistent!(monger_0, r"^(\d+)\.(\d+)$");
+
+// mongo_rub-0.0.2: r"^[rv]2\.6"
+consistent!(mongo_rub_0, r"^[rv]2\.6");
+
+// flow-0.3.5: "body value"
+consistent!(flow_0, "body value");
+
+// flow-0.3.5: "start marker"
+consistent!(flow_1, "start marker");
+
+// flow-0.3.5: "end marker"
+consistent!(flow_2, "end marker");
+
+// flow-0.3.5: "body value"
+consistent!(flow_3, "body value");
+
+// vobsub-0.2.3: "^([A-Za-z/ ]+): (.*)"
+consistent!(vobsub_0, "^([A-Za-z/ ]+): (.*)");
+
+// voidmap-1.1.2: r"#([^\s=]+)*"
+consistent!(voidmap_0, r"#([^\s=]+)*");
+
+// voidmap-1.1.2: r"#(\S+)*"
+consistent!(voidmap_1, r"#(\S+)*");
+
+// voidmap-1.1.2: r"#prio=(\d+)"
+consistent!(voidmap_2, r"#prio=(\d+)");
+
+// voidmap-1.1.2: r"\[(\S+)\]"
+consistent!(voidmap_3, r"\[(\S+)\]");
+
+// voidmap-1.1.2: r"#limit=(\d+)"
+consistent!(voidmap_4, r"#limit=(\d+)");
+
+// voidmap-1.1.2: r"#tagged=(\S+)"
+consistent!(voidmap_5, r"#tagged=(\S+)");
+
+// voidmap-1.1.2: r"#rev\b"
+consistent!(voidmap_6, r"#rev\b");
+
+// voidmap-1.1.2: r"#done\b"
+consistent!(voidmap_7, r"#done\b");
+
+// voidmap-1.1.2: r"#open\b"
+consistent!(voidmap_8, r"#open\b");
+
+// voidmap-1.1.2: r"#since=(\S+)"
+consistent!(voidmap_9, r"#since=(\S+)");
+
+// voidmap-1.1.2: r"#until=(\S+)"
+consistent!(voidmap_10, r"#until=(\S+)");
+
+// voidmap-1.1.2: r"#plot=(\S+)"
+consistent!(voidmap_11, r"#plot=(\S+)");
+
+// voidmap-1.1.2: r"#n=(\d+)"
+consistent!(voidmap_12, r"#n=(\d+)");
+
+// voidmap-1.1.2: r"(\S+)"
+consistent!(voidmap_13, r"(\S+)");
+
+// voidmap-1.1.2: r"(?P<y>\d+)y"
+consistent!(voidmap_14, r"(?P<y>\d+)y");
+
+// voidmap-1.1.2: r"(?P<m>\d+)m"
+consistent!(voidmap_15, r"(?P<m>\d+)m");
+
+// voidmap-1.1.2: r"(?P<w>\d+)w"
+consistent!(voidmap_16, r"(?P<w>\d+)w");
+
+// voidmap-1.1.2: r"(?P<d>\d+)d"
+consistent!(voidmap_17, r"(?P<d>\d+)d");
+
+// voidmap-1.1.2: r"(?P<h>\d+)h"
+consistent!(voidmap_18, r"(?P<h>\d+)h");
+
+// voidmap-1.1.2: r"C-(.)"
+consistent!(voidmap_19, r"C-(.)");
+
+// qt_generator-0.2.0: r"^\.\./qt[^/]+/"
+consistent!(qt_generator_0, r"^\.\./qt[^/]+/");
+
+// qt_generator-0.2.0: "(href|src)=\"([^\"]*)\""
+consistent!(qt_generator_1, "(href|src)=\"([^\"]*)\"");
+
+// kryptos-0.6.1: r"[01]{5}"
+consistent!(kryptos_0, r"[01]{5}");
+
+// cifar_10_loader-0.2.0: "data_batch_[1-5].bin"
+consistent!(cifar_10_loader_0, "data_batch_[1-5].bin");
+
+// cifar_10_loader-0.2.0: "test_batch.bin"
+consistent!(cifar_10_loader_1, "test_batch.bin");
+
+// circadian-0.6.0: r"^\d+.\d+s$"
+consistent!(circadian_0, r"^\d+.\d+s$");
+
+// circadian-0.6.0: r"^\d+:\d+$"
+consistent!(circadian_1, r"^\d+:\d+$");
+
+// circadian-0.6.0: r"^\d+:\d+m$"
+consistent!(circadian_2, r"^\d+:\d+m$");
+
+// cicada-0.8.1: r"!!"
+consistent!(cicada_0, r"!!");
+
+// cicada-0.8.1: r"^([^`]*)`([^`]+)`(.*)$"
+consistent!(cicada_1, r"^([^`]*)`([^`]+)`(.*)$");
+
+// cicada-0.8.1: r"\*+"
+consistent!(cicada_2, r"\*+");
+
+// cicada-0.8.1: r"([^\$]*)\$\{?([A-Za-z0-9\?\$_]+)\}?(.*)"
+consistent!(cicada_3, r"([^\$]*)\$\{?([A-Za-z0-9\?\$_]+)\}?(.*)");
+
+// cicada-0.8.1: r"^ *alias +([a-zA-Z0-9_\.-]+)=(.*)$"
+consistent!(cicada_4, r"^ *alias +([a-zA-Z0-9_\.-]+)=(.*)$");
+
+// vterm-sys-0.1.0: r"hi"
+consistent!(vterm_sys_0, r"hi");
+
+// skim-0.5.0: r".*?\t"
+consistent!(skim_0, r".*?\t");
+
+// skim-0.5.0: r".*?[\t ]"
+consistent!(skim_1, r".*?[\t ]");
+
+// skim-0.5.0: r"(\{-?[0-9.,q]*?})"
+consistent!(skim_2, r"(\{-?[0-9.,q]*?})");
+
+// skim-0.5.0: r"[ \t\n]+"
+consistent!(skim_3, r"[ \t\n]+");
+
+// skim-0.5.0: r"[ \t\n]+"
+consistent!(skim_4, r"[ \t\n]+");
+
+// skim-0.5.0: r"([^ |]+( +\| +[^ |]*)+)|( +)"
+consistent!(skim_5, r"([^ |]+( +\| +[^ |]*)+)|( +)");
+
+// skim-0.5.0: r" +\| +"
+consistent!(skim_6, r" +\| +");
+
+// skim-0.5.0: r"^(?P<left>-?\d+)?(?P<sep>\.\.)?(?P<right>-?\d+)?$"
+consistent!(skim_7, r"^(?P<left>-?\d+)?(?P<sep>\.\.)?(?P<right>-?\d+)?$");
+
+// skim-0.5.0: ","
+consistent!(skim_8, ",");
+
+// skim-0.5.0: ".*?,"
+consistent!(skim_9, ".*?,");
+
+// skim-0.5.0: ".*?,"
+consistent!(skim_10, ".*?,");
+
+// skim-0.5.0: ","
+consistent!(skim_11, ",");
+
+// skim-0.5.0: r"\x1B\[(?:([0-9]+;[0-9]+[Hf])|([0-9]+[ABCD])|(s|u|2J|K)|([0-9;]*m)|(=[0-9]+[hI]))"
+consistent!(skim_12, r"\x1B\[(?:([0-9]+;[0-9]+[Hf])|([0-9]+[ABCD])|(s|u|2J|K)|([0-9;]*m)|(=[0-9]+[hI]))");
+
+// egg-mode-text-1.14.7: r"[-_./]\z"
+consistent!(egg_mode_text_0, r"[-_./]\z");
+
+// java-properties-1.1.1: "^[ \t\r\n\x0c]*[#!]"
+consistent!(java_properties_0, "^[ \t\r\n\x0c]*[#!]");
+
+// java-properties-1.1.1: r"^[ \t\x0c]*[#!][^\r\n]*$"
+consistent!(java_properties_1, r"^[ \t\x0c]*[#!][^\r\n]*$");
+
+// java-properties-1.1.1: r"^([ \t\x0c]*[:=][ \t\x0c]*|[ \t\x0c]+)$"
+consistent!(java_properties_2, r"^([ \t\x0c]*[:=][ \t\x0c]*|[ \t\x0c]+)$");
+
+// ipaddress-0.1.2: r":.+\."
+consistent!(ipaddress_0, r":.+\.");
+
+// ipaddress-0.1.2: r"\."
+consistent!(ipaddress_1, r"\.");
+
+// ipaddress-0.1.2: r":"
+consistent!(ipaddress_2, r":");
+
+// iptables-0.2.2: r"v(\d+)\.(\d+)\.(\d+)"
+consistent!(iptables_0, r"v(\d+)\.(\d+)\.(\d+)");
+
+// rsure-0.8.1: r"^([^-]+)-(.*)\.dat\.gz$"
+consistent!(rsure_0, r"^([^-]+)-(.*)\.dat\.gz$");
+
+// rs-jsonpath-0.1.0: "^(.*?)(<=|<|==|>=|>)(.*?)$"
+consistent!(rs_jsonpath_0, "^(.*?)(<=|<|==|>=|>)(.*?)$");
+
+// oatie-0.3.0: r"(\n|^)(\w+):([\n\w\W]+?)(\n(?:\w)|(\n\]))"
+consistent!(oatie_0, r"(\n|^)(\w+):([\n\w\W]+?)(\n(?:\w)|(\n\]))");
+
+// weld-0.2.0: "#.*$"
+consistent!(weld_0, "#.*$");
+
+// weld-0.2.0: r"^[A-Za-z$_][A-Za-z0-9$_]*$"
+consistent!(weld_1, r"^[A-Za-z$_][A-Za-z0-9$_]*$");
+
+// weld-0.2.0: r"^[0-9]+[cC]$"
+consistent!(weld_2, r"^[0-9]+[cC]$");
+
+// weld-0.2.0: r"^0b[0-1]+[cC]$"
+consistent!(weld_3, r"^0b[0-1]+[cC]$");
+
+// weld-0.2.0: r"^0x[0-9a-fA-F]+[cC]$"
+consistent!(weld_4, r"^0x[0-9a-fA-F]+[cC]$");
+
+// weld-0.2.0: r"^[0-9]+$"
+consistent!(weld_5, r"^[0-9]+$");
+
+// weld-0.2.0: r"^0b[0-1]+$"
+consistent!(weld_6, r"^0b[0-1]+$");
+
+// weld-0.2.0: r"^0x[0-9a-fA-F]+$"
+consistent!(weld_7, r"^0x[0-9a-fA-F]+$");
+
+// weld-0.2.0: r"^[0-9]+[lL]$"
+consistent!(weld_8, r"^[0-9]+[lL]$");
+
+// weld-0.2.0: r"^0b[0-1]+[lL]$"
+consistent!(weld_9, r"^0b[0-1]+[lL]$");
+
+// weld-0.2.0: r"^0x[0-9a-fA-F]+[lL]$"
+consistent!(weld_10, r"^0x[0-9a-fA-F]+[lL]$");
+
+// webgl_generator-0.1.0: "([(, ])enum\\b"
+consistent!(webgl_generator_0, "([(, ])enum\\b");
+
+// webgl_generator-0.1.0: "\\bAcquireResourcesCallback\\b"
+consistent!(webgl_generator_1, "\\bAcquireResourcesCallback\\b");
+
+// weave-0.2.0: r"^(\d+)(,(\d+))?([acd]).*$"
+consistent!(weave_0, r"^(\d+)(,(\d+))?([acd]).*$");
+
+// wemo-0.0.12: r"<BinaryState>(\d)(\|-?\d+)*</BinaryState>"
+consistent!(wemo_0, r"<BinaryState>(\d)(\|-?\d+)*</BinaryState>");
+
+// webscale-0.9.4: r"(http[s]?://[^\s]+)"
+consistent!(webscale_0, r"(http[s]?://[^\s]+)");
+
+// svgrep-1.1.0: r"^\d+.*$"
+consistent!(svgrep_0, r"^\d+.*$");
+
+// ignore-0.4.2: r"^[\pL\pN]+$"
+consistent!(ignore_0, r"^[\pL\pN]+$");
+
+// ommui_string_patterns-0.1.2: r"^([A-Za-z][0-9A-Za-z_]*)?$"
+consistent!(ommui_string_patterns_0, r"^([A-Za-z][0-9A-Za-z_]*)?$");
+
+// ommui_string_patterns-0.1.2: r"^(\S+(?:.*\S)?)?$"
+consistent!(ommui_string_patterns_1, r"^(\S+(?:.*\S)?)?$");
+
+// opcua-types-0.3.0: "^(?P<min>[0-9]{1,10})(:(?P<max>[0-9]{1,10}))?$"
+consistent!(opcua_types_0, "^(?P<min>[0-9]{1,10})(:(?P<max>[0-9]{1,10}))?$");
+
+// opcua-types-0.3.0: r"^(ns=(?P<ns>[0-9]+);)?(?P<t>[isgb])=(?P<v>.+)$"
+consistent!(opcua_types_1, r"^(ns=(?P<ns>[0-9]+);)?(?P<t>[isgb])=(?P<v>.+)$");
+
+// open_read_later-1.1.1: r"^(.+?)\s*:\s*(.+)$"
+consistent!(open_read_later_0, r"^(.+?)\s*:\s*(.+)$");
+
+// youtube-downloader-0.1.0: r"^.*(?:(?:youtu\.be/|v/|vi/|u/w/|embed/)|(?:(?:watch)?\?v(?:i)?=|\&v(?:i)?=))([^#\&\?]*).*"
+consistent!(youtube_downloader_0, r"^.*(?:(?:youtu\.be/|v/|vi/|u/w/|embed/)|(?:(?:watch)?\?v(?:i)?=|\&v(?:i)?=))([^#\&\?]*).*");
+
+// yobot-0.1.1: "."
+consistent!(yobot_0, ".");
+
+// yobot-0.1.1: r"."
+consistent!(yobot_1, r".");
+
+// yobot-0.1.1: r".+"
+consistent!(yobot_2, r".+");
+
+// yobot-0.1.1: r"."
+consistent!(yobot_3, r".");
+
+// ubiquity-0.1.5: r"foo"
+consistent!(ubiquity_0, r"foo");
+
+// ubiquity-0.1.5: r"/target/"
+consistent!(ubiquity_1, r"/target/");
+
+// ubiquity-0.1.5: r".DS_Store"
+consistent!(ubiquity_2, r".DS_Store");
+
+// qasm-1.0.0: r"//.*"
+consistent!(qasm_0, r"//.*");
+
+// drill-0.3.5: r"\{\{ *([a-z\._]+) *\}\}"
+consistent!(drill_0, r"\{\{ *([a-z\._]+) *\}\}");
+
+// queryst-2.0.0: r"^([^\]\[]+)"
+consistent!(queryst_0, r"^([^\]\[]+)");
+
+// queryst-2.0.0: r"(\[[^\]\[]*\])"
+consistent!(queryst_1, r"(\[[^\]\[]*\])");
+
+// qui-vive-0.1.0: r"^/(\w+)$"
+consistent!(qui_vive_0, r"^/(\w+)$");
+
+// qui-vive-0.1.0: r"^/key$"
+consistent!(qui_vive_1, r"^/key$");
+
+// qui-vive-0.1.0: r"^/key/(\w+)$"
+consistent!(qui_vive_2, r"^/key/(\w+)$");
+
+// qui-vive-0.1.0: r"^/url$"
+consistent!(qui_vive_3, r"^/url$");
+
+// qui-vive-0.1.0: r"^/url/(\w+)$"
+consistent!(qui_vive_4, r"^/url/(\w+)$");
+
+// qui-vive-0.1.0: r"^/inv$"
+consistent!(qui_vive_5, r"^/inv$");
+
+// qui-vive-0.1.0: r"^/inv/(\w+)$"
+consistent!(qui_vive_6, r"^/inv/(\w+)$");
+
+// subdiff-0.1.0: r"\b"
+// consistent!(subdiff_0, r"\b");
+
+// substudy-0.4.5: r"^(\d+)/(\d+)$"
+consistent!(substudy_0, r"^(\d+)/(\d+)$");
+
+// substudy-0.4.5: r"\s+"
+consistent!(substudy_1, r"\s+");
+
+// substudy-0.4.5: r"<[a-z/][^>]*>"
+consistent!(substudy_2, r"<[a-z/][^>]*>");
+
+// substudy-0.4.5: r"(\([^)]*\)|♪[^♪]*♪|[A-Z]{2,} ?:)"
+consistent!(substudy_3, r"(\([^)]*\)|♪[^♪]*♪|[A-Z]{2,} ?:)");
+
+// substudy-0.4.5: r"\s+"
+consistent!(substudy_4, r"\s+");
+
+// isbnid-0.1.3: r"^(\d(-| )?){9}(x|X|\d|(\d(-| )?){3}\d)$"
+consistent!(isbnid_0, r"^(\d(-| )?){9}(x|X|\d|(\d(-| )?){3}\d)$");
+
+// isbnid-0.1.3: r"[^0-9X]"
+consistent!(isbnid_1, r"[^0-9X]");
+
+// ispc-0.3.5: r"Intel\(r\) SPMD Program Compiler \(ispc\), (\d+\.\d+\.\d+)"
+consistent!(
+    ispc_0,
+    r"Intel\(r\) SPMD Program Compiler \(ispc\), (\d+\.\d+\.\d+)"
+);
diff --git a/crates/regex/tests/crazy.rs b/crates/regex/tests/crazy.rs
new file mode 100644
index 0000000..293ac1a
--- /dev/null
+++ b/crates/regex/tests/crazy.rs
@@ -0,0 +1,459 @@
+mat!(ascii_literal, r"a", "a", Some((0, 1)));
+
+// Some crazy expressions from regular-expressions.info.
+mat!(
+    match_ranges,
+    r"(?-u)\b(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\b",
+    "num: 255",
+    Some((5, 8))
+);
+mat!(
+    match_ranges_not,
+    r"(?-u)\b(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\b",
+    "num: 256",
+    None
+);
+mat!(match_float1, r"[-+]?[0-9]*\.?[0-9]+", "0.1", Some((0, 3)));
+mat!(match_float2, r"[-+]?[0-9]*\.?[0-9]+", "0.1.2", Some((0, 3)));
+mat!(match_float3, r"[-+]?[0-9]*\.?[0-9]+", "a1.2", Some((1, 4)));
+mat!(match_float4, r"^[-+]?[0-9]*\.?[0-9]+$", "1.a", None);
+mat!(
+    match_email,
+    r"(?i-u)\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}\b",
+    "mine is jam.slam@gmail.com ",
+    Some((8, 26))
+);
+mat!(
+    match_email_not,
+    r"(?i-u)\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}\b",
+    "mine is jam.slam@gmail ",
+    None
+);
+mat!(
+    match_email_big,
+    r"[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?",
+    "mine is jam.slam@gmail.com ",
+    Some((8, 26))
+);
+mat!(
+    match_date1,
+    r"(?-u)^(19|20)\d\d[- /.](0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])$",
+    "1900-01-01",
+    Some((0, 10))
+);
+mat!(
+    match_date2,
+    r"(?-u)^(19|20)\d\d[- /.](0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])$",
+    "1900-00-01",
+    None
+);
+mat!(
+    match_date3,
+    r"(?-u)^(19|20)\d\d[- /.](0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])$",
+    "1900-13-01",
+    None
+);
+
+// Do some crazy dancing with the start/end assertions.
+matiter!(match_start_end_empty, r"^$", "", (0, 0));
+matiter!(match_start_end_empty_many_1, r"^$^$^$", "", (0, 0));
+matiter!(match_start_end_empty_many_2, r"^^^$$$", "", (0, 0));
+matiter!(match_start_end_empty_rev, r"$^", "", (0, 0));
+matiter!(
+    match_start_end_empty_rep,
+    r"(?:^$)*",
+    "a\nb\nc",
+    (0, 0),
+    (1, 1),
+    (2, 2),
+    (3, 3),
+    (4, 4),
+    (5, 5)
+);
+matiter!(
+    match_start_end_empty_rep_rev,
+    r"(?:$^)*",
+    "a\nb\nc",
+    (0, 0),
+    (1, 1),
+    (2, 2),
+    (3, 3),
+    (4, 4),
+    (5, 5)
+);
+
+// Test negated character classes.
+mat!(negclass_letters, r"[^ac]", "acx", Some((2, 3)));
+mat!(negclass_letter_comma, r"[^a,]", "a,x", Some((2, 3)));
+mat!(negclass_letter_space, r"[^a[:space:]]", "a x", Some((2, 3)));
+mat!(negclass_comma, r"[^,]", ",,x", Some((2, 3)));
+mat!(negclass_space, r"[^[:space:]]", " a", Some((1, 2)));
+mat!(negclass_space_comma, r"[^,[:space:]]", ", a", Some((2, 3)));
+mat!(negclass_comma_space, r"[^[:space:],]", " ,a", Some((2, 3)));
+mat!(negclass_ascii, r"[^[:alpha:]Z]", "A1", Some((1, 2)));
+
+// Test that repeated empty expressions don't loop forever.
+mat!(lazy_many_many, r"((?:.*)*?)=", "a=b", Some((0, 2)));
+mat!(lazy_many_optional, r"((?:.?)*?)=", "a=b", Some((0, 2)));
+mat!(lazy_one_many_many, r"((?:.*)+?)=", "a=b", Some((0, 2)));
+mat!(lazy_one_many_optional, r"((?:.?)+?)=", "a=b", Some((0, 2)));
+mat!(lazy_range_min_many, r"((?:.*){1,}?)=", "a=b", Some((0, 2)));
+mat!(lazy_range_many, r"((?:.*){1,2}?)=", "a=b", Some((0, 2)));
+mat!(greedy_many_many, r"((?:.*)*)=", "a=b", Some((0, 2)));
+mat!(greedy_many_optional, r"((?:.?)*)=", "a=b", Some((0, 2)));
+mat!(greedy_one_many_many, r"((?:.*)+)=", "a=b", Some((0, 2)));
+mat!(greedy_one_many_optional, r"((?:.?)+)=", "a=b", Some((0, 2)));
+mat!(greedy_range_min_many, r"((?:.*){1,})=", "a=b", Some((0, 2)));
+mat!(greedy_range_many, r"((?:.*){1,2})=", "a=b", Some((0, 2)));
+
+// Test that we handle various flavors of empty expressions.
+matiter!(match_empty1, r"", "", (0, 0));
+matiter!(match_empty2, r"", "abc", (0, 0), (1, 1), (2, 2), (3, 3));
+matiter!(match_empty3, r"()", "abc", (0, 0), (1, 1), (2, 2), (3, 3));
+matiter!(match_empty4, r"()*", "abc", (0, 0), (1, 1), (2, 2), (3, 3));
+matiter!(match_empty5, r"()+", "abc", (0, 0), (1, 1), (2, 2), (3, 3));
+matiter!(match_empty6, r"()?", "abc", (0, 0), (1, 1), (2, 2), (3, 3));
+matiter!(match_empty7, r"()()", "abc", (0, 0), (1, 1), (2, 2), (3, 3));
+matiter!(match_empty8, r"()+|z", "abc", (0, 0), (1, 1), (2, 2), (3, 3));
+matiter!(match_empty9, r"z|()+", "abc", (0, 0), (1, 1), (2, 2), (3, 3));
+matiter!(match_empty10, r"()+|b", "abc", (0, 0), (1, 1), (2, 2), (3, 3));
+matiter!(match_empty11, r"b|()+", "abc", (0, 0), (1, 2), (3, 3));
+matiter!(match_empty12, r"|b", "abc", (0, 0), (1, 1), (2, 2), (3, 3));
+matiter!(match_empty13, r"b|", "abc", (0, 0), (1, 2), (3, 3));
+matiter!(match_empty14, r"|z", "abc", (0, 0), (1, 1), (2, 2), (3, 3));
+matiter!(match_empty15, r"z|", "abc", (0, 0), (1, 1), (2, 2), (3, 3));
+matiter!(match_empty16, r"|", "abc", (0, 0), (1, 1), (2, 2), (3, 3));
+matiter!(match_empty17, r"||", "abc", (0, 0), (1, 1), (2, 2), (3, 3));
+matiter!(match_empty18, r"||z", "abc", (0, 0), (1, 1), (2, 2), (3, 3));
+matiter!(match_empty19, r"(?:)|b", "abc", (0, 0), (1, 1), (2, 2), (3, 3));
+matiter!(match_empty20, r"b|(?:)", "abc", (0, 0), (1, 2), (3, 3));
+matiter!(match_empty21, r"(?:|)", "abc", (0, 0), (1, 1), (2, 2), (3, 3));
+matiter!(match_empty22, r"(?:|)|z", "abc", (0, 0), (1, 1), (2, 2), (3, 3));
+matiter!(match_empty23, r"a(?:)|b", "abc", (0, 1), (1, 2));
+
+// Test that the DFA can handle pathological cases.
+// (This should result in the DFA's cache being flushed too frequently, which
+// should cause it to quit and fall back to the NFA algorithm.)
+#[test]
+fn dfa_handles_pathological_case() {
+    fn ones_and_zeroes(count: usize) -> String {
+        use rand::rngs::SmallRng;
+        use rand::{Rng, SeedableRng};
+
+        let mut rng = SmallRng::from_entropy();
+        let mut s = String::new();
+        for _ in 0..count {
+            if rng.gen() {
+                s.push('1');
+            } else {
+                s.push('0');
+            }
+        }
+        s
+    }
+
+    let re = regex!(r"[01]*1[01]{20}$");
+    let text = {
+        let mut pieces = ones_and_zeroes(100_000);
+        pieces.push('1');
+        pieces.push_str(&ones_and_zeroes(20));
+        pieces
+    };
+    assert!(re.is_match(text!(&*text)));
+}
+
+#[test]
+fn nest_limit_makes_it_parse() {
+    use regex::RegexBuilder;
+
+    RegexBuilder::new(
+        r#"(?-u)
+        2(?:
+          [45]\d{3}|
+          7(?:
+            1[0-267]|
+            2[0-289]|
+            3[0-29]|
+            4[01]|
+            5[1-3]|
+            6[013]|
+            7[0178]|
+            91
+          )|
+          8(?:
+            0[125]|
+            [139][1-6]|
+            2[0157-9]|
+            41|
+            6[1-35]|
+            7[1-5]|
+            8[1-8]|
+            90
+          )|
+          9(?:
+            0[0-2]|
+            1[0-4]|
+            2[568]|
+            3[3-6]|
+            5[5-7]|
+            6[0167]|
+            7[15]|
+            8[0146-9]
+          )
+        )\d{4}|
+        3(?:
+          12?[5-7]\d{2}|
+          0(?:
+            2(?:
+              [025-79]\d|
+              [348]\d{1,2}
+            )|
+            3(?:
+              [2-4]\d|
+              [56]\d?
+            )
+          )|
+          2(?:
+            1\d{2}|
+            2(?:
+              [12]\d|
+              [35]\d{1,2}|
+              4\d?
+            )
+          )|
+          3(?:
+            1\d{2}|
+            2(?:
+              [2356]\d|
+              4\d{1,2}
+            )
+          )|
+          4(?:
+            1\d{2}|
+            2(?:
+              2\d{1,2}|
+              [47]|
+              5\d{2}
+            )
+          )|
+          5(?:
+            1\d{2}|
+            29
+          )|
+          [67]1\d{2}|
+          8(?:
+            1\d{2}|
+            2(?:
+              2\d{2}|
+              3|
+              4\d
+            )
+          )
+        )\d{3}|
+        4(?:
+          0(?:
+            2(?:
+              [09]\d|
+              7
+            )|
+            33\d{2}
+          )|
+          1\d{3}|
+          2(?:
+            1\d{2}|
+            2(?:
+              [25]\d?|
+              [348]\d|
+              [67]\d{1,2}
+            )
+          )|
+          3(?:
+            1\d{2}(?:
+              \d{2}
+            )?|
+            2(?:
+              [045]\d|
+              [236-9]\d{1,2}
+            )|
+            32\d{2}
+          )|
+          4(?:
+            [18]\d{2}|
+            2(?:
+              [2-46]\d{2}|
+              3
+            )|
+            5[25]\d{2}
+          )|
+          5(?:
+            1\d{2}|
+            2(?:
+              3\d|
+              5
+            )
+          )|
+          6(?:
+            [18]\d{2}|
+            2(?:
+              3(?:
+                \d{2}
+              )?|
+              [46]\d{1,2}|
+              5\d{2}|
+              7\d
+            )|
+            5(?:
+              3\d?|
+              4\d|
+              [57]\d{1,2}|
+              6\d{2}|
+              8
+            )
+          )|
+          71\d{2}|
+          8(?:
+            [18]\d{2}|
+            23\d{2}|
+            54\d{2}
+          )|
+          9(?:
+            [18]\d{2}|
+            2[2-5]\d{2}|
+            53\d{1,2}
+          )
+        )\d{3}|
+        5(?:
+          02[03489]\d{2}|
+          1\d{2}|
+          2(?:
+            1\d{2}|
+            2(?:
+              2(?:
+                \d{2}
+              )?|
+              [457]\d{2}
+            )
+          )|
+          3(?:
+            1\d{2}|
+            2(?:
+              [37](?:
+                \d{2}
+              )?|
+              [569]\d{2}
+            )
+          )|
+          4(?:
+            1\d{2}|
+            2[46]\d{2}
+          )|
+          5(?:
+            1\d{2}|
+            26\d{1,2}
+          )|
+          6(?:
+            [18]\d{2}|
+            2|
+            53\d{2}
+          )|
+          7(?:
+            1|
+            24
+          )\d{2}|
+          8(?:
+            1|
+            26
+          )\d{2}|
+          91\d{2}
+        )\d{3}|
+        6(?:
+          0(?:
+            1\d{2}|
+            2(?:
+              3\d{2}|
+              4\d{1,2}
+            )
+          )|
+          2(?:
+            2[2-5]\d{2}|
+            5(?:
+              [3-5]\d{2}|
+              7
+            )|
+            8\d{2}
+          )|
+          3(?:
+            1|
+            2[3478]
+          )\d{2}|
+          4(?:
+            1|
+            2[34]
+          )\d{2}|
+          5(?:
+            1|
+            2[47]
+          )\d{2}|
+          6(?:
+            [18]\d{2}|
+            6(?:
+              2(?:
+                2\d|
+                [34]\d{2}
+              )|
+              5(?:
+                [24]\d{2}|
+                3\d|
+                5\d{1,2}
+              )
+            )
+          )|
+          72[2-5]\d{2}|
+          8(?:
+            1\d{2}|
+            2[2-5]\d{2}
+          )|
+          9(?:
+            1\d{2}|
+            2[2-6]\d{2}
+          )
+        )\d{3}|
+        7(?:
+          (?:
+            02|
+            [3-589]1|
+            6[12]|
+            72[24]
+          )\d{2}|
+          21\d{3}|
+          32
+        )\d{3}|
+        8(?:
+          (?:
+            4[12]|
+            [5-7]2|
+            1\d?
+          )|
+          (?:
+            0|
+            3[12]|
+            [5-7]1|
+            217
+          )\d
+        )\d{4}|
+        9(?:
+          [35]1|
+          (?:
+            [024]2|
+            81
+          )\d|
+          (?:
+            1|
+            [24]1
+          )\d{2}
+        )\d{3}
+        "#,
+    )
+    .build()
+    .unwrap();
+}
diff --git a/crates/regex/tests/flags.rs b/crates/regex/tests/flags.rs
new file mode 100644
index 0000000..c33b82d
--- /dev/null
+++ b/crates/regex/tests/flags.rs
@@ -0,0 +1,31 @@
+mat!(match_flag_case, "(?-u)(?i)abc", "ABC", Some((0, 3)));
+mat!(match_flag_weird_case, "(?-u)(?i)a(?-i)bc", "Abc", Some((0, 3)));
+mat!(match_flag_weird_case_not, "(?-u)(?i)a(?-i)bc", "ABC", None);
+mat!(match_flag_case_dotnl, "(?-u)(?is)a(?u:.)", "A\n", Some((0, 2)));
+mat!(
+    match_flag_case_dotnl_toggle,
+    "(?-u)(?is)a(?u:.)(?-is)a(?u:.)",
+    "A\nab",
+    Some((0, 4))
+);
+mat!(
+    match_flag_case_dotnl_toggle_not,
+    "(?-u)(?is)a(?u:.)(?-is)a(?u:.)",
+    "A\na\n",
+    None
+);
+mat!(
+    match_flag_case_dotnl_toggle_ok,
+    "(?-u)(?is)a(?u:.)(?-is:a(?u:.))?",
+    "A\na\n",
+    Some((0, 2))
+);
+mat!(
+    match_flag_multi,
+    r"(?-u)(?m)(?:^\d+$\n?)+",
+    "123\n456\n789",
+    Some((0, 11))
+);
+mat!(match_flag_ungreedy, "(?U)a+", "aa", Some((0, 1)));
+mat!(match_flag_ungreedy_greedy, "(?U)a+?", "aa", Some((0, 2)));
+mat!(match_flag_ungreedy_noop, "(?U)(?-U)a+", "aa", Some((0, 2)));
diff --git a/crates/regex/tests/fowler.rs b/crates/regex/tests/fowler.rs
new file mode 100644
index 0000000..7f56a75
--- /dev/null
+++ b/crates/regex/tests/fowler.rs
@@ -0,0 +1,1588 @@
+// DO NOT EDIT. Automatically generated by 'scripts/regex-match-tests.py'
+// on 2019-09-02 11:07:37.849994.
+
+// Tests from basic.dat
+mat!(match_basic_3, r"abracadabra$", r"abracadabracadabra", Some((7, 18)));
+mat!(match_basic_4, r"a...b", r"abababbb", Some((2, 7)));
+mat!(match_basic_5, r"XXXXXX", r"..XXXXXX", Some((2, 8)));
+mat!(match_basic_6, r"\)", r"()", Some((1, 2)));
+mat!(match_basic_7, r"a]", r"a]a", Some((0, 2)));
+mat!(match_basic_9, r"\}", r"}", Some((0, 1)));
+mat!(match_basic_10, r"\]", r"]", Some((0, 1)));
+mat!(match_basic_12, r"]", r"]", Some((0, 1)));
+mat!(match_basic_15, r"^a", r"ax", Some((0, 1)));
+mat!(match_basic_16, r"\^a", r"a^a", Some((1, 3)));
+mat!(match_basic_17, r"a\^", r"a^", Some((0, 2)));
+mat!(match_basic_18, r"a$", r"aa", Some((1, 2)));
+mat!(match_basic_19, r"a\$", r"a$", Some((0, 2)));
+mat!(match_basic_20, r"^$", r"", Some((0, 0)));
+mat!(match_basic_21, r"$^", r"", Some((0, 0)));
+mat!(match_basic_22, r"a($)", r"aa", Some((1, 2)), Some((2, 2)));
+mat!(match_basic_23, r"a*(^a)", r"aa", Some((0, 1)), Some((0, 1)));
+mat!(match_basic_24, r"(..)*(...)*", r"a", Some((0, 0)));
+mat!(match_basic_25, r"(..)*(...)*", r"abcd", Some((0, 4)), Some((2, 4)));
+mat!(
+    match_basic_26,
+    r"(ab|a)(bc|c)",
+    r"abc",
+    Some((0, 3)),
+    Some((0, 2)),
+    Some((2, 3))
+);
+mat!(match_basic_27, r"(ab)c|abc", r"abc", Some((0, 3)), Some((0, 2)));
+mat!(match_basic_28, r"a{0}b", r"ab", Some((1, 2)));
+mat!(
+    match_basic_29,
+    r"(a*)(b?)(b+)b{3}",
+    r"aaabbbbbbb",
+    Some((0, 10)),
+    Some((0, 3)),
+    Some((3, 4)),
+    Some((4, 7))
+);
+mat!(
+    match_basic_30,
+    r"(a*)(b{0,1})(b{1,})b{3}",
+    r"aaabbbbbbb",
+    Some((0, 10)),
+    Some((0, 3)),
+    Some((3, 4)),
+    Some((4, 7))
+);
+mat!(
+    match_basic_32,
+    r"((a|a)|a)",
+    r"a",
+    Some((0, 1)),
+    Some((0, 1)),
+    Some((0, 1))
+);
+mat!(
+    match_basic_33,
+    r"(a*)(a|aa)",
+    r"aaaa",
+    Some((0, 4)),
+    Some((0, 3)),
+    Some((3, 4))
+);
+mat!(match_basic_34, r"a*(a.|aa)", r"aaaa", Some((0, 4)), Some((2, 4)));
+mat!(
+    match_basic_35,
+    r"a(b)|c(d)|a(e)f",
+    r"aef",
+    Some((0, 3)),
+    None,
+    None,
+    Some((1, 2))
+);
+mat!(match_basic_36, r"(a|b)?.*", r"b", Some((0, 1)), Some((0, 1)));
+mat!(match_basic_37, r"(a|b)c|a(b|c)", r"ac", Some((0, 2)), Some((0, 1)));
+mat!(
+    match_basic_38,
+    r"(a|b)c|a(b|c)",
+    r"ab",
+    Some((0, 2)),
+    None,
+    Some((1, 2))
+);
+mat!(match_basic_39, r"(a|b)*c|(a|ab)*c", r"abc", Some((0, 3)), Some((1, 2)));
+mat!(match_basic_40, r"(a|b)*c|(a|ab)*c", r"xc", Some((1, 2)));
+mat!(
+    match_basic_41,
+    r"(.a|.b).*|.*(.a|.b)",
+    r"xa",
+    Some((0, 2)),
+    Some((0, 2))
+);
+mat!(match_basic_42, r"a?(ab|ba)ab", r"abab", Some((0, 4)), Some((0, 2)));
+mat!(match_basic_43, r"a?(ac{0}b|ba)ab", r"abab", Some((0, 4)), Some((0, 2)));
+mat!(match_basic_44, r"ab|abab", r"abbabab", Some((0, 2)));
+mat!(match_basic_45, r"aba|bab|bba", r"baaabbbaba", Some((5, 8)));
+mat!(match_basic_46, r"aba|bab", r"baaabbbaba", Some((6, 9)));
+mat!(
+    match_basic_47,
+    r"(aa|aaa)*|(a|aaaaa)",
+    r"aa",
+    Some((0, 2)),
+    Some((0, 2))
+);
+mat!(
+    match_basic_48,
+    r"(a.|.a.)*|(a|.a...)",
+    r"aa",
+    Some((0, 2)),
+    Some((0, 2))
+);
+mat!(match_basic_49, r"ab|a", r"xabc", Some((1, 3)));
+mat!(match_basic_50, r"ab|a", r"xxabc", Some((2, 4)));
+mat!(
+    match_basic_51,
+    r"(?i)(?-u)(Ab|cD)*",
+    r"aBcD",
+    Some((0, 4)),
+    Some((2, 4))
+);
+mat!(match_basic_52, r"[^-]", r"--a", Some((2, 3)));
+mat!(match_basic_53, r"[a-]*", r"--a", Some((0, 3)));
+mat!(match_basic_54, r"[a-m-]*", r"--amoma--", Some((0, 4)));
+mat!(
+    match_basic_55,
+    r":::1:::0:|:::1:1:0:",
+    r":::0:::1:::1:::0:",
+    Some((8, 17))
+);
+mat!(
+    match_basic_56,
+    r":::1:::0:|:::1:1:1:",
+    r":::0:::1:::1:::0:",
+    Some((8, 17))
+);
+mat!(match_basic_57, r"[[:upper:]]", r"A", Some((0, 1)));
+mat!(match_basic_58, r"[[:lower:]]+", r"`az{", Some((1, 3)));
+mat!(match_basic_59, r"[[:upper:]]+", r"@AZ[", Some((1, 3)));
+mat!(
+    match_basic_65,
+    r"
+",
+    r"
+",
+    Some((0, 1))
+);
+mat!(
+    match_basic_66,
+    r"
+",
+    r"
+",
+    Some((0, 1))
+);
+mat!(
+    match_basic_67,
+    r"[^a]",
+    r"
+",
+    Some((0, 1))
+);
+mat!(
+    match_basic_68,
+    r"
+a",
+    r"
+a",
+    Some((0, 2))
+);
+mat!(
+    match_basic_69,
+    r"(a)(b)(c)",
+    r"abc",
+    Some((0, 3)),
+    Some((0, 1)),
+    Some((1, 2)),
+    Some((2, 3))
+);
+mat!(match_basic_70, r"xxx", r"xxx", Some((0, 3)));
+mat!(
+    match_basic_71,
+    r"(^|[ (,;])((([Ff]eb[^ ]* *|0*2/|\* */?)0*[6-7]))([^0-9]|$)",
+    r"feb 6,",
+    Some((0, 6))
+);
+mat!(
+    match_basic_72,
+    r"(^|[ (,;])((([Ff]eb[^ ]* *|0*2/|\* */?)0*[6-7]))([^0-9]|$)",
+    r"2/7",
+    Some((0, 3))
+);
+mat!(
+    match_basic_73,
+    r"(^|[ (,;])((([Ff]eb[^ ]* *|0*2/|\* */?)0*[6-7]))([^0-9]|$)",
+    r"feb 1,Feb 6",
+    Some((5, 11))
+);
+mat!(
+    match_basic_74,
+    r"((((((((((((((((((((((((((((((x))))))))))))))))))))))))))))))",
+    r"x",
+    Some((0, 1)),
+    Some((0, 1)),
+    Some((0, 1))
+);
+mat!(
+    match_basic_75,
+    r"((((((((((((((((((((((((((((((x))))))))))))))))))))))))))))))*",
+    r"xx",
+    Some((0, 2)),
+    Some((1, 2)),
+    Some((1, 2))
+);
+mat!(
+    match_basic_76,
+    r"a?(ab|ba)*",
+    r"ababababababababababababababababababababababababababababababababababababababababa",
+    Some((0, 81)),
+    Some((79, 81))
+);
+mat!(
+    match_basic_77,
+    r"abaa|abbaa|abbbaa|abbbbaa",
+    r"ababbabbbabbbabbbbabbbbaa",
+    Some((18, 25))
+);
+mat!(
+    match_basic_78,
+    r"abaa|abbaa|abbbaa|abbbbaa",
+    r"ababbabbbabbbabbbbabaa",
+    Some((18, 22))
+);
+mat!(
+    match_basic_79,
+    r"aaac|aabc|abac|abbc|baac|babc|bbac|bbbc",
+    r"baaabbbabac",
+    Some((7, 11))
+);
+mat!(match_basic_80, r".*", r"", Some((0, 2)));
+mat!(
+    match_basic_81,
+    r"aaaa|bbbb|cccc|ddddd|eeeeee|fffffff|gggg|hhhh|iiiii|jjjjj|kkkkk|llll",
+    r"XaaaXbbbXcccXdddXeeeXfffXgggXhhhXiiiXjjjXkkkXlllXcbaXaaaa",
+    Some((53, 57))
+);
+mat!(match_basic_83, r"a*a*a*a*a*b", r"aaaaaaaaab", Some((0, 10)));
+mat!(match_basic_84, r"^", r"", Some((0, 0)));
+mat!(match_basic_85, r"$", r"", Some((0, 0)));
+mat!(match_basic_86, r"^$", r"", Some((0, 0)));
+mat!(match_basic_87, r"^a$", r"a", Some((0, 1)));
+mat!(match_basic_88, r"abc", r"abc", Some((0, 3)));
+mat!(match_basic_89, r"abc", r"xabcy", Some((1, 4)));
+mat!(match_basic_90, r"abc", r"ababc", Some((2, 5)));
+mat!(match_basic_91, r"ab*c", r"abc", Some((0, 3)));
+mat!(match_basic_92, r"ab*bc", r"abc", Some((0, 3)));
+mat!(match_basic_93, r"ab*bc", r"abbc", Some((0, 4)));
+mat!(match_basic_94, r"ab*bc", r"abbbbc", Some((0, 6)));
+mat!(match_basic_95, r"ab+bc", r"abbc", Some((0, 4)));
+mat!(match_basic_96, r"ab+bc", r"abbbbc", Some((0, 6)));
+mat!(match_basic_97, r"ab?bc", r"abbc", Some((0, 4)));
+mat!(match_basic_98, r"ab?bc", r"abc", Some((0, 3)));
+mat!(match_basic_99, r"ab?c", r"abc", Some((0, 3)));
+mat!(match_basic_100, r"^abc$", r"abc", Some((0, 3)));
+mat!(match_basic_101, r"^abc", r"abcc", Some((0, 3)));
+mat!(match_basic_102, r"abc$", r"aabc", Some((1, 4)));
+mat!(match_basic_103, r"^", r"abc", Some((0, 0)));
+mat!(match_basic_104, r"$", r"abc", Some((3, 3)));
+mat!(match_basic_105, r"a.c", r"abc", Some((0, 3)));
+mat!(match_basic_106, r"a.c", r"axc", Some((0, 3)));
+mat!(match_basic_107, r"a.*c", r"axyzc", Some((0, 5)));
+mat!(match_basic_108, r"a[bc]d", r"abd", Some((0, 3)));
+mat!(match_basic_109, r"a[b-d]e", r"ace", Some((0, 3)));
+mat!(match_basic_110, r"a[b-d]", r"aac", Some((1, 3)));
+mat!(match_basic_111, r"a[-b]", r"a-", Some((0, 2)));
+mat!(match_basic_112, r"a[b-]", r"a-", Some((0, 2)));
+mat!(match_basic_113, r"a]", r"a]", Some((0, 2)));
+mat!(match_basic_114, r"a[]]b", r"a]b", Some((0, 3)));
+mat!(match_basic_115, r"a[^bc]d", r"aed", Some((0, 3)));
+mat!(match_basic_116, r"a[^-b]c", r"adc", Some((0, 3)));
+mat!(match_basic_117, r"a[^]b]c", r"adc", Some((0, 3)));
+mat!(match_basic_118, r"ab|cd", r"abc", Some((0, 2)));
+mat!(match_basic_119, r"ab|cd", r"abcd", Some((0, 2)));
+mat!(match_basic_120, r"a\(b", r"a(b", Some((0, 3)));
+mat!(match_basic_121, r"a\(*b", r"ab", Some((0, 2)));
+mat!(match_basic_122, r"a\(*b", r"a((b", Some((0, 4)));
+mat!(
+    match_basic_123,
+    r"((a))",
+    r"abc",
+    Some((0, 1)),
+    Some((0, 1)),
+    Some((0, 1))
+);
+mat!(
+    match_basic_124,
+    r"(a)b(c)",
+    r"abc",
+    Some((0, 3)),
+    Some((0, 1)),
+    Some((2, 3))
+);
+mat!(match_basic_125, r"a+b+c", r"aabbabc", Some((4, 7)));
+mat!(match_basic_126, r"a*", r"aaa", Some((0, 3)));
+mat!(match_basic_128, r"(a*)*", r"-", Some((0, 0)), None);
+mat!(match_basic_129, r"(a*)+", r"-", Some((0, 0)), Some((0, 0)));
+mat!(match_basic_131, r"(a*|b)*", r"-", Some((0, 0)), None);
+mat!(match_basic_132, r"(a+|b)*", r"ab", Some((0, 2)), Some((1, 2)));
+mat!(match_basic_133, r"(a+|b)+", r"ab", Some((0, 2)), Some((1, 2)));
+mat!(match_basic_134, r"(a+|b)?", r"ab", Some((0, 1)), Some((0, 1)));
+mat!(match_basic_135, r"[^ab]*", r"cde", Some((0, 3)));
+mat!(match_basic_137, r"(^)*", r"-", Some((0, 0)), None);
+mat!(match_basic_138, r"a*", r"", Some((0, 0)));
+mat!(match_basic_139, r"([abc])*d", r"abbbcd", Some((0, 6)), Some((4, 5)));
+mat!(match_basic_140, r"([abc])*bcd", r"abcd", Some((0, 4)), Some((0, 1)));
+mat!(match_basic_141, r"a|b|c|d|e", r"e", Some((0, 1)));
+mat!(match_basic_142, r"(a|b|c|d|e)f", r"ef", Some((0, 2)), Some((0, 1)));
+mat!(match_basic_144, r"((a*|b))*", r"-", Some((0, 0)), None, None);
+mat!(match_basic_145, r"abcd*efg", r"abcdefg", Some((0, 7)));
+mat!(match_basic_146, r"ab*", r"xabyabbbz", Some((1, 3)));
+mat!(match_basic_147, r"ab*", r"xayabbbz", Some((1, 2)));
+mat!(match_basic_148, r"(ab|cd)e", r"abcde", Some((2, 5)), Some((2, 4)));
+mat!(match_basic_149, r"[abhgefdc]ij", r"hij", Some((0, 3)));
+mat!(match_basic_150, r"(a|b)c*d", r"abcd", Some((1, 4)), Some((1, 2)));
+mat!(match_basic_151, r"(ab|ab*)bc", r"abc", Some((0, 3)), Some((0, 1)));
+mat!(match_basic_152, r"a([bc]*)c*", r"abc", Some((0, 3)), Some((1, 3)));
+mat!(
+    match_basic_153,
+    r"a([bc]*)(c*d)",
+    r"abcd",
+    Some((0, 4)),
+    Some((1, 3)),
+    Some((3, 4))
+);
+mat!(
+    match_basic_154,
+    r"a([bc]+)(c*d)",
+    r"abcd",
+    Some((0, 4)),
+    Some((1, 3)),
+    Some((3, 4))
+);
+mat!(
+    match_basic_155,
+    r"a([bc]*)(c+d)",
+    r"abcd",
+    Some((0, 4)),
+    Some((1, 2)),
+    Some((2, 4))
+);
+mat!(match_basic_156, r"a[bcd]*dcdcde", r"adcdcde", Some((0, 7)));
+mat!(match_basic_157, r"(ab|a)b*c", r"abc", Some((0, 3)), Some((0, 2)));
+mat!(
+    match_basic_158,
+    r"((a)(b)c)(d)",
+    r"abcd",
+    Some((0, 4)),
+    Some((0, 3)),
+    Some((0, 1)),
+    Some((1, 2)),
+    Some((3, 4))
+);
+mat!(match_basic_159, r"[A-Za-z_][A-Za-z0-9_]*", r"alpha", Some((0, 5)));
+mat!(match_basic_160, r"^a(bc+|b[eh])g|.h$", r"abh", Some((1, 3)));
+mat!(
+    match_basic_161,
+    r"(bc+d$|ef*g.|h?i(j|k))",
+    r"effgz",
+    Some((0, 5)),
+    Some((0, 5))
+);
+mat!(
+    match_basic_162,
+    r"(bc+d$|ef*g.|h?i(j|k))",
+    r"ij",
+    Some((0, 2)),
+    Some((0, 2)),
+    Some((1, 2))
+);
+mat!(
+    match_basic_163,
+    r"(bc+d$|ef*g.|h?i(j|k))",
+    r"reffgz",
+    Some((1, 6)),
+    Some((1, 6))
+);
+mat!(
+    match_basic_164,
+    r"(((((((((a)))))))))",
+    r"a",
+    Some((0, 1)),
+    Some((0, 1)),
+    Some((0, 1)),
+    Some((0, 1)),
+    Some((0, 1)),
+    Some((0, 1)),
+    Some((0, 1)),
+    Some((0, 1)),
+    Some((0, 1)),
+    Some((0, 1))
+);
+mat!(
+    match_basic_165,
+    r"multiple words",
+    r"multiple words yeah",
+    Some((0, 14))
+);
+mat!(
+    match_basic_166,
+    r"(.*)c(.*)",
+    r"abcde",
+    Some((0, 5)),
+    Some((0, 2)),
+    Some((3, 5))
+);
+mat!(match_basic_167, r"abcd", r"abcd", Some((0, 4)));
+mat!(match_basic_168, r"a(bc)d", r"abcd", Some((0, 4)), Some((1, 3)));
+mat!(match_basic_169, r"a[-]?c", r"ac", Some((0, 3)));
+mat!(
+    match_basic_170,
+    r"M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]",
+    r"Muammar Qaddafi",
+    Some((0, 15)),
+    None,
+    Some((10, 12))
+);
+mat!(
+    match_basic_171,
+    r"M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]",
+    r"Mo'ammar Gadhafi",
+    Some((0, 16)),
+    None,
+    Some((11, 13))
+);
+mat!(
+    match_basic_172,
+    r"M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]",
+    r"Muammar Kaddafi",
+    Some((0, 15)),
+    None,
+    Some((10, 12))
+);
+mat!(
+    match_basic_173,
+    r"M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]",
+    r"Muammar Qadhafi",
+    Some((0, 15)),
+    None,
+    Some((10, 12))
+);
+mat!(
+    match_basic_174,
+    r"M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]",
+    r"Muammar Gadafi",
+    Some((0, 14)),
+    None,
+    Some((10, 11))
+);
+mat!(
+    match_basic_175,
+    r"M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]",
+    r"Mu'ammar Qadafi",
+    Some((0, 15)),
+    None,
+    Some((11, 12))
+);
+mat!(
+    match_basic_176,
+    r"M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]",
+    r"Moamar Gaddafi",
+    Some((0, 14)),
+    None,
+    Some((9, 11))
+);
+mat!(
+    match_basic_177,
+    r"M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]",
+    r"Mu'ammar Qadhdhafi",
+    Some((0, 18)),
+    None,
+    Some((13, 15))
+);
+mat!(
+    match_basic_178,
+    r"M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]",
+    r"Muammar Khaddafi",
+    Some((0, 16)),
+    None,
+    Some((11, 13))
+);
+mat!(
+    match_basic_179,
+    r"M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]",
+    r"Muammar Ghaddafy",
+    Some((0, 16)),
+    None,
+    Some((11, 13))
+);
+mat!(
+    match_basic_180,
+    r"M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]",
+    r"Muammar Ghadafi",
+    Some((0, 15)),
+    None,
+    Some((11, 12))
+);
+mat!(
+    match_basic_181,
+    r"M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]",
+    r"Muammar Ghaddafi",
+    Some((0, 16)),
+    None,
+    Some((11, 13))
+);
+mat!(
+    match_basic_182,
+    r"M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]",
+    r"Muamar Kaddafi",
+    Some((0, 14)),
+    None,
+    Some((9, 11))
+);
+mat!(
+    match_basic_183,
+    r"M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]",
+    r"Muammar Quathafi",
+    Some((0, 16)),
+    None,
+    Some((11, 13))
+);
+mat!(
+    match_basic_184,
+    r"M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]",
+    r"Muammar Gheddafi",
+    Some((0, 16)),
+    None,
+    Some((11, 13))
+);
+mat!(
+    match_basic_185,
+    r"M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]",
+    r"Moammar Khadafy",
+    Some((0, 15)),
+    None,
+    Some((11, 12))
+);
+mat!(
+    match_basic_186,
+    r"M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy]",
+    r"Moammar Qudhafi",
+    Some((0, 15)),
+    None,
+    Some((10, 12))
+);
+mat!(match_basic_187, r"a+(b|c)*d+", r"aabcdd", Some((0, 6)), Some((3, 4)));
+mat!(match_basic_188, r"^.+$", r"vivi", Some((0, 4)));
+mat!(match_basic_189, r"^(.+)$", r"vivi", Some((0, 4)), Some((0, 4)));
+mat!(
+    match_basic_190,
+    r"^([^!.]+).att.com!(.+)$",
+    r"gryphon.att.com!eby",
+    Some((0, 19)),
+    Some((0, 7)),
+    Some((16, 19))
+);
+mat!(
+    match_basic_191,
+    r"^([^!]+!)?([^!]+)$",
+    r"bas",
+    Some((0, 3)),
+    None,
+    Some((0, 3))
+);
+mat!(
+    match_basic_192,
+    r"^([^!]+!)?([^!]+)$",
+    r"bar!bas",
+    Some((0, 7)),
+    Some((0, 4)),
+    Some((4, 7))
+);
+mat!(
+    match_basic_193,
+    r"^([^!]+!)?([^!]+)$",
+    r"foo!bas",
+    Some((0, 7)),
+    Some((0, 4)),
+    Some((4, 7))
+);
+mat!(
+    match_basic_194,
+    r"^.+!([^!]+!)([^!]+)$",
+    r"foo!bar!bas",
+    Some((0, 11)),
+    Some((4, 8)),
+    Some((8, 11))
+);
+mat!(
+    match_basic_195,
+    r"((foo)|(bar))!bas",
+    r"bar!bas",
+    Some((0, 7)),
+    Some((0, 3)),
+    None,
+    Some((0, 3))
+);
+mat!(
+    match_basic_196,
+    r"((foo)|(bar))!bas",
+    r"foo!bar!bas",
+    Some((4, 11)),
+    Some((4, 7)),
+    None,
+    Some((4, 7))
+);
+mat!(
+    match_basic_197,
+    r"((foo)|(bar))!bas",
+    r"foo!bas",
+    Some((0, 7)),
+    Some((0, 3)),
+    Some((0, 3))
+);
+mat!(
+    match_basic_198,
+    r"((foo)|bar)!bas",
+    r"bar!bas",
+    Some((0, 7)),
+    Some((0, 3))
+);
+mat!(
+    match_basic_199,
+    r"((foo)|bar)!bas",
+    r"foo!bar!bas",
+    Some((4, 11)),
+    Some((4, 7))
+);
+mat!(
+    match_basic_200,
+    r"((foo)|bar)!bas",
+    r"foo!bas",
+    Some((0, 7)),
+    Some((0, 3)),
+    Some((0, 3))
+);
+mat!(
+    match_basic_201,
+    r"(foo|(bar))!bas",
+    r"bar!bas",
+    Some((0, 7)),
+    Some((0, 3)),
+    Some((0, 3))
+);
+mat!(
+    match_basic_202,
+    r"(foo|(bar))!bas",
+    r"foo!bar!bas",
+    Some((4, 11)),
+    Some((4, 7)),
+    Some((4, 7))
+);
+mat!(
+    match_basic_203,
+    r"(foo|(bar))!bas",
+    r"foo!bas",
+    Some((0, 7)),
+    Some((0, 3))
+);
+mat!(
+    match_basic_204,
+    r"(foo|bar)!bas",
+    r"bar!bas",
+    Some((0, 7)),
+    Some((0, 3))
+);
+mat!(
+    match_basic_205,
+    r"(foo|bar)!bas",
+    r"foo!bar!bas",
+    Some((4, 11)),
+    Some((4, 7))
+);
+mat!(
+    match_basic_206,
+    r"(foo|bar)!bas",
+    r"foo!bas",
+    Some((0, 7)),
+    Some((0, 3))
+);
+mat!(
+    match_basic_207,
+    r"^(([^!]+!)?([^!]+)|.+!([^!]+!)([^!]+))$",
+    r"foo!bar!bas",
+    Some((0, 11)),
+    Some((0, 11)),
+    None,
+    None,
+    Some((4, 8)),
+    Some((8, 11))
+);
+mat!(
+    match_basic_208,
+    r"^([^!]+!)?([^!]+)$|^.+!([^!]+!)([^!]+)$",
+    r"bas",
+    Some((0, 3)),
+    None,
+    Some((0, 3))
+);
+mat!(
+    match_basic_209,
+    r"^([^!]+!)?([^!]+)$|^.+!([^!]+!)([^!]+)$",
+    r"bar!bas",
+    Some((0, 7)),
+    Some((0, 4)),
+    Some((4, 7))
+);
+mat!(
+    match_basic_210,
+    r"^([^!]+!)?([^!]+)$|^.+!([^!]+!)([^!]+)$",
+    r"foo!bar!bas",
+    Some((0, 11)),
+    None,
+    None,
+    Some((4, 8)),
+    Some((8, 11))
+);
+mat!(
+    match_basic_211,
+    r"^([^!]+!)?([^!]+)$|^.+!([^!]+!)([^!]+)$",
+    r"foo!bas",
+    Some((0, 7)),
+    Some((0, 4)),
+    Some((4, 7))
+);
+mat!(
+    match_basic_212,
+    r"^(([^!]+!)?([^!]+)|.+!([^!]+!)([^!]+))$",
+    r"bas",
+    Some((0, 3)),
+    Some((0, 3)),
+    None,
+    Some((0, 3))
+);
+mat!(
+    match_basic_213,
+    r"^(([^!]+!)?([^!]+)|.+!([^!]+!)([^!]+))$",
+    r"bar!bas",
+    Some((0, 7)),
+    Some((0, 7)),
+    Some((0, 4)),
+    Some((4, 7))
+);
+mat!(
+    match_basic_214,
+    r"^(([^!]+!)?([^!]+)|.+!([^!]+!)([^!]+))$",
+    r"foo!bar!bas",
+    Some((0, 11)),
+    Some((0, 11)),
+    None,
+    None,
+    Some((4, 8)),
+    Some((8, 11))
+);
+mat!(
+    match_basic_215,
+    r"^(([^!]+!)?([^!]+)|.+!([^!]+!)([^!]+))$",
+    r"foo!bas",
+    Some((0, 7)),
+    Some((0, 7)),
+    Some((0, 4)),
+    Some((4, 7))
+);
+mat!(match_basic_216, r".*(/XXX).*", r"/XXX", Some((0, 4)), Some((0, 4)));
+mat!(match_basic_217, r".*(\\XXX).*", r"\XXX", Some((0, 4)), Some((0, 4)));
+mat!(match_basic_218, r"\\XXX", r"\XXX", Some((0, 4)));
+mat!(match_basic_219, r".*(/000).*", r"/000", Some((0, 4)), Some((0, 4)));
+mat!(match_basic_220, r".*(\\000).*", r"\000", Some((0, 4)), Some((0, 4)));
+mat!(match_basic_221, r"\\000", r"\000", Some((0, 4)));
+
+// Tests from nullsubexpr.dat
+mat!(match_nullsubexpr_3, r"(a*)*", r"a", Some((0, 1)), Some((0, 1)));
+mat!(match_nullsubexpr_5, r"(a*)*", r"x", Some((0, 0)), None);
+mat!(match_nullsubexpr_6, r"(a*)*", r"aaaaaa", Some((0, 6)), Some((0, 6)));
+mat!(match_nullsubexpr_7, r"(a*)*", r"aaaaaax", Some((0, 6)), Some((0, 6)));
+mat!(match_nullsubexpr_8, r"(a*)+", r"a", Some((0, 1)), Some((0, 1)));
+mat!(match_nullsubexpr_9, r"(a*)+", r"x", Some((0, 0)), Some((0, 0)));
+mat!(match_nullsubexpr_10, r"(a*)+", r"aaaaaa", Some((0, 6)), Some((0, 6)));
+mat!(match_nullsubexpr_11, r"(a*)+", r"aaaaaax", Some((0, 6)), Some((0, 6)));
+mat!(match_nullsubexpr_12, r"(a+)*", r"a", Some((0, 1)), Some((0, 1)));
+mat!(match_nullsubexpr_13, r"(a+)*", r"x", Some((0, 0)));
+mat!(match_nullsubexpr_14, r"(a+)*", r"aaaaaa", Some((0, 6)), Some((0, 6)));
+mat!(match_nullsubexpr_15, r"(a+)*", r"aaaaaax", Some((0, 6)), Some((0, 6)));
+mat!(match_nullsubexpr_16, r"(a+)+", r"a", Some((0, 1)), Some((0, 1)));
+mat!(match_nullsubexpr_17, r"(a+)+", r"x", None);
+mat!(match_nullsubexpr_18, r"(a+)+", r"aaaaaa", Some((0, 6)), Some((0, 6)));
+mat!(match_nullsubexpr_19, r"(a+)+", r"aaaaaax", Some((0, 6)), Some((0, 6)));
+mat!(match_nullsubexpr_21, r"([a]*)*", r"a", Some((0, 1)), Some((0, 1)));
+mat!(match_nullsubexpr_23, r"([a]*)*", r"x", Some((0, 0)), None);
+mat!(match_nullsubexpr_24, r"([a]*)*", r"aaaaaa", Some((0, 6)), Some((0, 6)));
+mat!(match_nullsubexpr_25, r"([a]*)*", r"aaaaaax", Some((0, 6)), Some((0, 6)));
+mat!(match_nullsubexpr_26, r"([a]*)+", r"a", Some((0, 1)), Some((0, 1)));
+mat!(match_nullsubexpr_27, r"([a]*)+", r"x", Some((0, 0)), Some((0, 0)));
+mat!(match_nullsubexpr_28, r"([a]*)+", r"aaaaaa", Some((0, 6)), Some((0, 6)));
+mat!(match_nullsubexpr_29, r"([a]*)+", r"aaaaaax", Some((0, 6)), Some((0, 6)));
+mat!(match_nullsubexpr_30, r"([^b]*)*", r"a", Some((0, 1)), Some((0, 1)));
+mat!(match_nullsubexpr_32, r"([^b]*)*", r"b", Some((0, 0)), None);
+mat!(match_nullsubexpr_33, r"([^b]*)*", r"aaaaaa", Some((0, 6)), Some((0, 6)));
+mat!(
+    match_nullsubexpr_34,
+    r"([^b]*)*",
+    r"aaaaaab",
+    Some((0, 6)),
+    Some((0, 6))
+);
+mat!(match_nullsubexpr_35, r"([ab]*)*", r"a", Some((0, 1)), Some((0, 1)));
+mat!(match_nullsubexpr_36, r"([ab]*)*", r"aaaaaa", Some((0, 6)), Some((0, 6)));
+mat!(match_nullsubexpr_37, r"([ab]*)*", r"ababab", Some((0, 6)), Some((0, 6)));
+mat!(match_nullsubexpr_38, r"([ab]*)*", r"bababa", Some((0, 6)), Some((0, 6)));
+mat!(match_nullsubexpr_39, r"([ab]*)*", r"b", Some((0, 1)), Some((0, 1)));
+mat!(match_nullsubexpr_40, r"([ab]*)*", r"bbbbbb", Some((0, 6)), Some((0, 6)));
+mat!(
+    match_nullsubexpr_41,
+    r"([ab]*)*",
+    r"aaaabcde",
+    Some((0, 5)),
+    Some((0, 5))
+);
+mat!(match_nullsubexpr_42, r"([^a]*)*", r"b", Some((0, 1)), Some((0, 1)));
+mat!(match_nullsubexpr_43, r"([^a]*)*", r"bbbbbb", Some((0, 6)), Some((0, 6)));
+mat!(match_nullsubexpr_45, r"([^a]*)*", r"aaaaaa", Some((0, 0)), None);
+mat!(
+    match_nullsubexpr_46,
+    r"([^ab]*)*",
+    r"ccccxx",
+    Some((0, 6)),
+    Some((0, 6))
+);
+mat!(match_nullsubexpr_48, r"([^ab]*)*", r"ababab", Some((0, 0)), None);
+mat!(
+    match_nullsubexpr_50,
+    r"((z)+|a)*",
+    r"zabcde",
+    Some((0, 2)),
+    Some((1, 2))
+);
+mat!(
+    match_nullsubexpr_69,
+    r"(a*)*(x)",
+    r"x",
+    Some((0, 1)),
+    None,
+    Some((0, 1))
+);
+mat!(
+    match_nullsubexpr_70,
+    r"(a*)*(x)",
+    r"ax",
+    Some((0, 2)),
+    Some((0, 1)),
+    Some((1, 2))
+);
+mat!(
+    match_nullsubexpr_71,
+    r"(a*)*(x)",
+    r"axa",
+    Some((0, 2)),
+    Some((0, 1)),
+    Some((1, 2))
+);
+mat!(
+    match_nullsubexpr_73,
+    r"(a*)+(x)",
+    r"x",
+    Some((0, 1)),
+    Some((0, 0)),
+    Some((0, 1))
+);
+mat!(
+    match_nullsubexpr_74,
+    r"(a*)+(x)",
+    r"ax",
+    Some((0, 2)),
+    Some((0, 1)),
+    Some((1, 2))
+);
+mat!(
+    match_nullsubexpr_75,
+    r"(a*)+(x)",
+    r"axa",
+    Some((0, 2)),
+    Some((0, 1)),
+    Some((1, 2))
+);
+mat!(
+    match_nullsubexpr_77,
+    r"(a*){2}(x)",
+    r"x",
+    Some((0, 1)),
+    Some((0, 0)),
+    Some((0, 1))
+);
+mat!(
+    match_nullsubexpr_78,
+    r"(a*){2}(x)",
+    r"ax",
+    Some((0, 2)),
+    Some((1, 1)),
+    Some((1, 2))
+);
+mat!(
+    match_nullsubexpr_79,
+    r"(a*){2}(x)",
+    r"axa",
+    Some((0, 2)),
+    Some((1, 1)),
+    Some((1, 2))
+);
+
+// Tests from repetition.dat
+mat!(match_repetition_10, r"((..)|(.))", r"", None);
+mat!(match_repetition_11, r"((..)|(.))((..)|(.))", r"", None);
+mat!(match_repetition_12, r"((..)|(.))((..)|(.))((..)|(.))", r"", None);
+mat!(match_repetition_14, r"((..)|(.)){1}", r"", None);
+mat!(match_repetition_15, r"((..)|(.)){2}", r"", None);
+mat!(match_repetition_16, r"((..)|(.)){3}", r"", None);
+mat!(match_repetition_18, r"((..)|(.))*", r"", Some((0, 0)));
+mat!(
+    match_repetition_20,
+    r"((..)|(.))",
+    r"a",
+    Some((0, 1)),
+    Some((0, 1)),
+    None,
+    Some((0, 1))
+);
+mat!(match_repetition_21, r"((..)|(.))((..)|(.))", r"a", None);
+mat!(match_repetition_22, r"((..)|(.))((..)|(.))((..)|(.))", r"a", None);
+mat!(
+    match_repetition_24,
+    r"((..)|(.)){1}",
+    r"a",
+    Some((0, 1)),
+    Some((0, 1)),
+    None,
+    Some((0, 1))
+);
+mat!(match_repetition_25, r"((..)|(.)){2}", r"a", None);
+mat!(match_repetition_26, r"((..)|(.)){3}", r"a", None);
+mat!(
+    match_repetition_28,
+    r"((..)|(.))*",
+    r"a",
+    Some((0, 1)),
+    Some((0, 1)),
+    None,
+    Some((0, 1))
+);
+mat!(
+    match_repetition_30,
+    r"((..)|(.))",
+    r"aa",
+    Some((0, 2)),
+    Some((0, 2)),
+    Some((0, 2)),
+    None
+);
+mat!(
+    match_repetition_31,
+    r"((..)|(.))((..)|(.))",
+    r"aa",
+    Some((0, 2)),
+    Some((0, 1)),
+    None,
+    Some((0, 1)),
+    Some((1, 2)),
+    None,
+    Some((1, 2))
+);
+mat!(match_repetition_32, r"((..)|(.))((..)|(.))((..)|(.))", r"aa", None);
+mat!(
+    match_repetition_34,
+    r"((..)|(.)){1}",
+    r"aa",
+    Some((0, 2)),
+    Some((0, 2)),
+    Some((0, 2)),
+    None
+);
+mat!(
+    match_repetition_35,
+    r"((..)|(.)){2}",
+    r"aa",
+    Some((0, 2)),
+    Some((1, 2)),
+    None,
+    Some((1, 2))
+);
+mat!(match_repetition_36, r"((..)|(.)){3}", r"aa", None);
+mat!(
+    match_repetition_38,
+    r"((..)|(.))*",
+    r"aa",
+    Some((0, 2)),
+    Some((0, 2)),
+    Some((0, 2)),
+    None
+);
+mat!(
+    match_repetition_40,
+    r"((..)|(.))",
+    r"aaa",
+    Some((0, 2)),
+    Some((0, 2)),
+    Some((0, 2)),
+    None
+);
+mat!(
+    match_repetition_41,
+    r"((..)|(.))((..)|(.))",
+    r"aaa",
+    Some((0, 3)),
+    Some((0, 2)),
+    Some((0, 2)),
+    None,
+    Some((2, 3)),
+    None,
+    Some((2, 3))
+);
+mat!(
+    match_repetition_42,
+    r"((..)|(.))((..)|(.))((..)|(.))",
+    r"aaa",
+    Some((0, 3)),
+    Some((0, 1)),
+    None,
+    Some((0, 1)),
+    Some((1, 2)),
+    None,
+    Some((1, 2)),
+    Some((2, 3)),
+    None,
+    Some((2, 3))
+);
+mat!(
+    match_repetition_44,
+    r"((..)|(.)){1}",
+    r"aaa",
+    Some((0, 2)),
+    Some((0, 2)),
+    Some((0, 2)),
+    None
+);
+mat!(
+    match_repetition_46,
+    r"((..)|(.)){2}",
+    r"aaa",
+    Some((0, 3)),
+    Some((2, 3)),
+    Some((0, 2)),
+    Some((2, 3))
+);
+mat!(
+    match_repetition_47,
+    r"((..)|(.)){3}",
+    r"aaa",
+    Some((0, 3)),
+    Some((2, 3)),
+    None,
+    Some((2, 3))
+);
+mat!(
+    match_repetition_50,
+    r"((..)|(.))*",
+    r"aaa",
+    Some((0, 3)),
+    Some((2, 3)),
+    Some((0, 2)),
+    Some((2, 3))
+);
+mat!(
+    match_repetition_52,
+    r"((..)|(.))",
+    r"aaaa",
+    Some((0, 2)),
+    Some((0, 2)),
+    Some((0, 2)),
+    None
+);
+mat!(
+    match_repetition_53,
+    r"((..)|(.))((..)|(.))",
+    r"aaaa",
+    Some((0, 4)),
+    Some((0, 2)),
+    Some((0, 2)),
+    None,
+    Some((2, 4)),
+    Some((2, 4)),
+    None
+);
+mat!(
+    match_repetition_54,
+    r"((..)|(.))((..)|(.))((..)|(.))",
+    r"aaaa",
+    Some((0, 4)),
+    Some((0, 2)),
+    Some((0, 2)),
+    None,
+    Some((2, 3)),
+    None,
+    Some((2, 3)),
+    Some((3, 4)),
+    None,
+    Some((3, 4))
+);
+mat!(
+    match_repetition_56,
+    r"((..)|(.)){1}",
+    r"aaaa",
+    Some((0, 2)),
+    Some((0, 2)),
+    Some((0, 2)),
+    None
+);
+mat!(
+    match_repetition_57,
+    r"((..)|(.)){2}",
+    r"aaaa",
+    Some((0, 4)),
+    Some((2, 4)),
+    Some((2, 4)),
+    None
+);
+mat!(
+    match_repetition_59,
+    r"((..)|(.)){3}",
+    r"aaaa",
+    Some((0, 4)),
+    Some((3, 4)),
+    Some((0, 2)),
+    Some((3, 4))
+);
+mat!(
+    match_repetition_61,
+    r"((..)|(.))*",
+    r"aaaa",
+    Some((0, 4)),
+    Some((2, 4)),
+    Some((2, 4)),
+    None
+);
+mat!(
+    match_repetition_63,
+    r"((..)|(.))",
+    r"aaaaa",
+    Some((0, 2)),
+    Some((0, 2)),
+    Some((0, 2)),
+    None
+);
+mat!(
+    match_repetition_64,
+    r"((..)|(.))((..)|(.))",
+    r"aaaaa",
+    Some((0, 4)),
+    Some((0, 2)),
+    Some((0, 2)),
+    None,
+    Some((2, 4)),
+    Some((2, 4)),
+    None
+);
+mat!(
+    match_repetition_65,
+    r"((..)|(.))((..)|(.))((..)|(.))",
+    r"aaaaa",
+    Some((0, 5)),
+    Some((0, 2)),
+    Some((0, 2)),
+    None,
+    Some((2, 4)),
+    Some((2, 4)),
+    None,
+    Some((4, 5)),
+    None,
+    Some((4, 5))
+);
+mat!(
+    match_repetition_67,
+    r"((..)|(.)){1}",
+    r"aaaaa",
+    Some((0, 2)),
+    Some((0, 2)),
+    Some((0, 2)),
+    None
+);
+mat!(
+    match_repetition_68,
+    r"((..)|(.)){2}",
+    r"aaaaa",
+    Some((0, 4)),
+    Some((2, 4)),
+    Some((2, 4)),
+    None
+);
+mat!(
+    match_repetition_70,
+    r"((..)|(.)){3}",
+    r"aaaaa",
+    Some((0, 5)),
+    Some((4, 5)),
+    Some((2, 4)),
+    Some((4, 5))
+);
+mat!(
+    match_repetition_73,
+    r"((..)|(.))*",
+    r"aaaaa",
+    Some((0, 5)),
+    Some((4, 5)),
+    Some((2, 4)),
+    Some((4, 5))
+);
+mat!(
+    match_repetition_75,
+    r"((..)|(.))",
+    r"aaaaaa",
+    Some((0, 2)),
+    Some((0, 2)),
+    Some((0, 2)),
+    None
+);
+mat!(
+    match_repetition_76,
+    r"((..)|(.))((..)|(.))",
+    r"aaaaaa",
+    Some((0, 4)),
+    Some((0, 2)),
+    Some((0, 2)),
+    None,
+    Some((2, 4)),
+    Some((2, 4)),
+    None
+);
+mat!(
+    match_repetition_77,
+    r"((..)|(.))((..)|(.))((..)|(.))",
+    r"aaaaaa",
+    Some((0, 6)),
+    Some((0, 2)),
+    Some((0, 2)),
+    None,
+    Some((2, 4)),
+    Some((2, 4)),
+    None,
+    Some((4, 6)),
+    Some((4, 6)),
+    None
+);
+mat!(
+    match_repetition_79,
+    r"((..)|(.)){1}",
+    r"aaaaaa",
+    Some((0, 2)),
+    Some((0, 2)),
+    Some((0, 2)),
+    None
+);
+mat!(
+    match_repetition_80,
+    r"((..)|(.)){2}",
+    r"aaaaaa",
+    Some((0, 4)),
+    Some((2, 4)),
+    Some((2, 4)),
+    None
+);
+mat!(
+    match_repetition_81,
+    r"((..)|(.)){3}",
+    r"aaaaaa",
+    Some((0, 6)),
+    Some((4, 6)),
+    Some((4, 6)),
+    None
+);
+mat!(
+    match_repetition_83,
+    r"((..)|(.))*",
+    r"aaaaaa",
+    Some((0, 6)),
+    Some((4, 6)),
+    Some((4, 6)),
+    None
+);
+mat!(
+    match_repetition_90,
+    r"X(.?){0,}Y",
+    r"X1234567Y",
+    Some((0, 9)),
+    Some((7, 8))
+);
+mat!(
+    match_repetition_91,
+    r"X(.?){1,}Y",
+    r"X1234567Y",
+    Some((0, 9)),
+    Some((7, 8))
+);
+mat!(
+    match_repetition_92,
+    r"X(.?){2,}Y",
+    r"X1234567Y",
+    Some((0, 9)),
+    Some((7, 8))
+);
+mat!(
+    match_repetition_93,
+    r"X(.?){3,}Y",
+    r"X1234567Y",
+    Some((0, 9)),
+    Some((7, 8))
+);
+mat!(
+    match_repetition_94,
+    r"X(.?){4,}Y",
+    r"X1234567Y",
+    Some((0, 9)),
+    Some((7, 8))
+);
+mat!(
+    match_repetition_95,
+    r"X(.?){5,}Y",
+    r"X1234567Y",
+    Some((0, 9)),
+    Some((7, 8))
+);
+mat!(
+    match_repetition_96,
+    r"X(.?){6,}Y",
+    r"X1234567Y",
+    Some((0, 9)),
+    Some((7, 8))
+);
+mat!(
+    match_repetition_97,
+    r"X(.?){7,}Y",
+    r"X1234567Y",
+    Some((0, 9)),
+    Some((7, 8))
+);
+mat!(
+    match_repetition_98,
+    r"X(.?){8,}Y",
+    r"X1234567Y",
+    Some((0, 9)),
+    Some((8, 8))
+);
+mat!(
+    match_repetition_100,
+    r"X(.?){0,8}Y",
+    r"X1234567Y",
+    Some((0, 9)),
+    Some((8, 8))
+);
+mat!(
+    match_repetition_102,
+    r"X(.?){1,8}Y",
+    r"X1234567Y",
+    Some((0, 9)),
+    Some((8, 8))
+);
+mat!(
+    match_repetition_104,
+    r"X(.?){2,8}Y",
+    r"X1234567Y",
+    Some((0, 9)),
+    Some((8, 8))
+);
+mat!(
+    match_repetition_106,
+    r"X(.?){3,8}Y",
+    r"X1234567Y",
+    Some((0, 9)),
+    Some((8, 8))
+);
+mat!(
+    match_repetition_108,
+    r"X(.?){4,8}Y",
+    r"X1234567Y",
+    Some((0, 9)),
+    Some((8, 8))
+);
+mat!(
+    match_repetition_110,
+    r"X(.?){5,8}Y",
+    r"X1234567Y",
+    Some((0, 9)),
+    Some((8, 8))
+);
+mat!(
+    match_repetition_112,
+    r"X(.?){6,8}Y",
+    r"X1234567Y",
+    Some((0, 9)),
+    Some((8, 8))
+);
+mat!(
+    match_repetition_114,
+    r"X(.?){7,8}Y",
+    r"X1234567Y",
+    Some((0, 9)),
+    Some((8, 8))
+);
+mat!(
+    match_repetition_115,
+    r"X(.?){8,8}Y",
+    r"X1234567Y",
+    Some((0, 9)),
+    Some((8, 8))
+);
+mat!(
+    match_repetition_126,
+    r"(a|ab|c|bcd){0,}(d*)",
+    r"ababcd",
+    Some((0, 1)),
+    Some((0, 1)),
+    Some((1, 1))
+);
+mat!(
+    match_repetition_127,
+    r"(a|ab|c|bcd){1,}(d*)",
+    r"ababcd",
+    Some((0, 1)),
+    Some((0, 1)),
+    Some((1, 1))
+);
+mat!(
+    match_repetition_128,
+    r"(a|ab|c|bcd){2,}(d*)",
+    r"ababcd",
+    Some((0, 6)),
+    Some((3, 6)),
+    Some((6, 6))
+);
+mat!(
+    match_repetition_129,
+    r"(a|ab|c|bcd){3,}(d*)",
+    r"ababcd",
+    Some((0, 6)),
+    Some((3, 6)),
+    Some((6, 6))
+);
+mat!(match_repetition_130, r"(a|ab|c|bcd){4,}(d*)", r"ababcd", None);
+mat!(
+    match_repetition_131,
+    r"(a|ab|c|bcd){0,10}(d*)",
+    r"ababcd",
+    Some((0, 1)),
+    Some((0, 1)),
+    Some((1, 1))
+);
+mat!(
+    match_repetition_132,
+    r"(a|ab|c|bcd){1,10}(d*)",
+    r"ababcd",
+    Some((0, 1)),
+    Some((0, 1)),
+    Some((1, 1))
+);
+mat!(
+    match_repetition_133,
+    r"(a|ab|c|bcd){2,10}(d*)",
+    r"ababcd",
+    Some((0, 6)),
+    Some((3, 6)),
+    Some((6, 6))
+);
+mat!(
+    match_repetition_134,
+    r"(a|ab|c|bcd){3,10}(d*)",
+    r"ababcd",
+    Some((0, 6)),
+    Some((3, 6)),
+    Some((6, 6))
+);
+mat!(match_repetition_135, r"(a|ab|c|bcd){4,10}(d*)", r"ababcd", None);
+mat!(
+    match_repetition_136,
+    r"(a|ab|c|bcd)*(d*)",
+    r"ababcd",
+    Some((0, 1)),
+    Some((0, 1)),
+    Some((1, 1))
+);
+mat!(
+    match_repetition_137,
+    r"(a|ab|c|bcd)+(d*)",
+    r"ababcd",
+    Some((0, 1)),
+    Some((0, 1)),
+    Some((1, 1))
+);
+mat!(
+    match_repetition_143,
+    r"(ab|a|c|bcd){0,}(d*)",
+    r"ababcd",
+    Some((0, 6)),
+    Some((4, 5)),
+    Some((5, 6))
+);
+mat!(
+    match_repetition_145,
+    r"(ab|a|c|bcd){1,}(d*)",
+    r"ababcd",
+    Some((0, 6)),
+    Some((4, 5)),
+    Some((5, 6))
+);
+mat!(
+    match_repetition_147,
+    r"(ab|a|c|bcd){2,}(d*)",
+    r"ababcd",
+    Some((0, 6)),
+    Some((4, 5)),
+    Some((5, 6))
+);
+mat!(
+    match_repetition_149,
+    r"(ab|a|c|bcd){3,}(d*)",
+    r"ababcd",
+    Some((0, 6)),
+    Some((4, 5)),
+    Some((5, 6))
+);
+mat!(match_repetition_150, r"(ab|a|c|bcd){4,}(d*)", r"ababcd", None);
+mat!(
+    match_repetition_152,
+    r"(ab|a|c|bcd){0,10}(d*)",
+    r"ababcd",
+    Some((0, 6)),
+    Some((4, 5)),
+    Some((5, 6))
+);
+mat!(
+    match_repetition_154,
+    r"(ab|a|c|bcd){1,10}(d*)",
+    r"ababcd",
+    Some((0, 6)),
+    Some((4, 5)),
+    Some((5, 6))
+);
+mat!(
+    match_repetition_156,
+    r"(ab|a|c|bcd){2,10}(d*)",
+    r"ababcd",
+    Some((0, 6)),
+    Some((4, 5)),
+    Some((5, 6))
+);
+mat!(
+    match_repetition_158,
+    r"(ab|a|c|bcd){3,10}(d*)",
+    r"ababcd",
+    Some((0, 6)),
+    Some((4, 5)),
+    Some((5, 6))
+);
+mat!(match_repetition_159, r"(ab|a|c|bcd){4,10}(d*)", r"ababcd", None);
+mat!(
+    match_repetition_161,
+    r"(ab|a|c|bcd)*(d*)",
+    r"ababcd",
+    Some((0, 6)),
+    Some((4, 5)),
+    Some((5, 6))
+);
+mat!(
+    match_repetition_163,
+    r"(ab|a|c|bcd)+(d*)",
+    r"ababcd",
+    Some((0, 6)),
+    Some((4, 5)),
+    Some((5, 6))
+);
diff --git a/crates/regex/tests/macros.rs b/crates/regex/tests/macros.rs
new file mode 100644
index 0000000..e70e948
--- /dev/null
+++ b/crates/regex/tests/macros.rs
@@ -0,0 +1,160 @@
+// Convenience macros.
+
+macro_rules! findall {
+    ($re:expr, $text:expr) => {{
+        $re.find_iter(text!($text))
+           .map(|m| (m.start(), m.end())).collect::<Vec<_>>()
+    }}
+}
+
+// Macros for automatically producing tests.
+
+macro_rules! ismatch {
+    ($name:ident, $re:expr, $text:expr, $ismatch:expr) => {
+        #[test]
+        fn $name() {
+            let re = regex!($re);
+            assert_eq!($ismatch, re.is_match(text!($text)));
+        }
+    };
+}
+
+macro_rules! mat(
+    ($name:ident, $re:expr, $text:expr, $($loc:tt)+) => (
+        #[test]
+        fn $name() {
+            let text = text!($text);
+            let expected: Vec<Option<_>> = vec![$($loc)+];
+            let r = regex!($re);
+            let got: Vec<Option<_>> = match r.captures(text) {
+                Some(c) => {
+                    assert!(r.is_match(text));
+                    assert!(r.shortest_match(text).is_some());
+                    r.capture_names()
+                     .enumerate()
+                     .map(|(i, _)| c.get(i).map(|m| (m.start(), m.end())))
+                     .collect()
+                }
+                None => vec![None],
+            };
+            // The test set sometimes leave out capture groups, so truncate
+            // actual capture groups to match test set.
+            let mut sgot = &got[..];
+            if sgot.len() > expected.len() {
+                sgot = &sgot[0..expected.len()]
+            }
+            if expected != sgot {
+                panic!("For RE '{}' against '{:?}', \
+                        expected '{:?}' but got '{:?}'",
+                       $re, text, expected, sgot);
+            }
+        }
+    );
+);
+
+macro_rules! matiter(
+    ($name:ident, $re:expr, $text:expr) => (
+        #[test]
+        fn $name() {
+            let text = text!($text);
+            let expected: Vec<(usize, usize)> = vec![];
+            let r = regex!($re);
+            let got: Vec<_> =
+                r.find_iter(text).map(|m| (m.start(), m.end())).collect();
+            if expected != got {
+                panic!("For RE '{}' against '{:?}', \
+                        expected '{:?}' but got '{:?}'",
+                       $re, text, expected, got);
+            }
+            let captures_got: Vec<_> =
+                r.captures_iter(text)
+                 .map(|c| c.get(0).unwrap())
+                 .map(|m| (m.start(), m.end()))
+                 .collect();
+            if captures_got != got {
+                panic!("For RE '{}' against '{:?}', \
+                        got '{:?}' using find_iter but got '{:?}' \
+                        using captures_iter",
+                       $re, text, got, captures_got);
+            }
+        }
+    );
+    ($name:ident, $re:expr, $text:expr, $($loc:tt)+) => (
+        #[test]
+        fn $name() {
+            let text = text!($text);
+            let expected: Vec<_> = vec![$($loc)+];
+            let r = regex!($re);
+            let got: Vec<_> =
+                r.find_iter(text).map(|m| (m.start(), m.end())).collect();
+            if expected != got {
+                panic!("For RE '{}' against '{:?}', \
+                        expected '{:?}' but got '{:?}'",
+                       $re, text, expected, got);
+            }
+            let captures_got: Vec<_> =
+                r.captures_iter(text)
+                 .map(|c| c.get(0).unwrap())
+                 .map(|m| (m.start(), m.end()))
+                 .collect();
+            if captures_got != got {
+                panic!("For RE '{}' against '{:?}', \
+                        got '{:?}' using find_iter but got '{:?}' \
+                        using captures_iter",
+                       $re, text, got, captures_got);
+            }
+        }
+    );
+);
+
+macro_rules! matset {
+    ($name:ident, $res:expr, $text:expr, $($match_index:expr),*) => {
+        #[test]
+        fn $name() {
+            let text = text!($text);
+            let set = regex_set!($res);
+            assert!(set.is_match(text));
+            let expected = vec![$($match_index),*];
+            let matches = set.matches(text);
+            assert!(matches.matched_any());
+            let got: Vec<_> = matches.into_iter().collect();
+            assert_eq!(expected, got);
+        }
+    }
+}
+
+macro_rules! nomatset {
+    ($name:ident, $res:expr, $text:expr) => {
+        #[test]
+        fn $name() {
+            let text = text!($text);
+            let set = regex_set!($res);
+            assert!(!set.is_match(text));
+            let matches = set.matches(text);
+            assert!(!matches.matched_any());
+            assert_eq!(0, matches.into_iter().count());
+        }
+    }
+}
+
+macro_rules! split {
+    ($name:ident, $re:expr, $text:expr, $expected:expr) => {
+        #[test]
+        fn $name() {
+            let re = regex!($re);
+            let splitted: Vec<_> = re.split(t!($text)).collect();
+            assert_eq!($expected, &*splitted);
+        }
+    }
+}
+
+macro_rules! splitn {
+    ($name:ident, $re:expr, $text:expr, $limit:expr, $expected:expr) => {
+        #[test]
+        fn $name() {
+            let re = regex!($re);
+            let splitted: Vec<_> = re.splitn(t!($text), $limit).collect();
+            assert_eq!($expected, &*splitted);
+        }
+    }
+}
diff --git a/crates/regex/tests/macros_bytes.rs b/crates/regex/tests/macros_bytes.rs
new file mode 100644
index 0000000..3d6c8c3
--- /dev/null
+++ b/crates/regex/tests/macros_bytes.rs
@@ -0,0 +1,39 @@
+// Macros for use in writing tests generic over &str/&[u8].
+macro_rules! text { ($text:expr) => { $text.as_bytes() } }
+macro_rules! t { ($re:expr) => { text!($re) } }
+macro_rules! match_text { ($text:expr) => { $text.as_bytes() } }
+macro_rules! use_ { ($($path: tt)*) => { use regex::bytes::$($path)*; } }
+macro_rules! empty_vec { () => { <Vec<&[u8]>>::new() } }
+macro_rules! bytes { ($text:expr) => { $text } }
+
+macro_rules! no_expand {
+    ($text:expr) => {{
+        use regex::bytes::NoExpand;
+        NoExpand(text!($text))
+    }}
+}
+
+macro_rules! show {
+    ($text:expr) => {{
+        use std::ascii::escape_default;
+        let mut s = vec![];
+        for &b in bytes!($text) {
+            s.extend(escape_default(b));
+        }
+        String::from_utf8(s).unwrap()
+    }}
+}
+
+macro_rules! expand {
+    ($name:ident, $re:expr, $text:expr, $expand:expr, $expected:expr) => {
+        #[test]
+        fn $name() {
+            let re = regex!($re);
+            let cap = re.captures(t!($text)).unwrap();
+
+            let mut got = vec![];
+            cap.expand(t!($expand), &mut got);
+            assert_eq!(show!(t!($expected)), show!(&*got));
+        }
+    }
+}
diff --git a/crates/regex/tests/macros_str.rs b/crates/regex/tests/macros_str.rs
new file mode 100644
index 0000000..7b7eb11
--- /dev/null
+++ b/crates/regex/tests/macros_str.rs
@@ -0,0 +1,38 @@
+// Macros for use in writing tests generic over &str/&[u8].
+macro_rules! text { ($text:expr) => { $text } }
+macro_rules! t { ($text:expr) => { text!($text) } }
+macro_rules! match_text { ($text:expr) => { $text.as_str() } }
+macro_rules! use_ { ($($path: tt)*) => { use regex::$($path)*; } }
+macro_rules! empty_vec { () => { <Vec<&str>>::new() } }
+macro_rules! bytes { ($text:expr) => { std::str::from_utf8($text.as_ref()).unwrap() } }
+
+macro_rules! no_expand {
+    ($text:expr) => {{
+        use regex::NoExpand;
+        NoExpand(text!($text))
+    }}
+}
+
+macro_rules! show { ($text:expr) => { $text } }
+
+// N.B. The expansion API for &str and &[u8] APIs differs slightly for now,
+// but they should be unified in 1.0. Then we can move this macro back into
+// tests/api.rs where it is used. ---AG
+macro_rules! expand {
+    ($name:ident, $re:expr, $text:expr, $expand:expr, $expected:expr) => {
+        #[test]
+        fn $name() {
+            let re = regex!($re);
+            let cap = re.captures(t!($text)).unwrap();
+
+            let mut got = String::new();
+            cap.expand(t!($expand), &mut got);
+            assert_eq!(show!(t!($expected)), show!(&*got));
+        }
+    }
+}
+
+#[cfg(feature = "pattern")]
+macro_rules! searcher_expr { ($e:expr) => ($e) }
+#[cfg(not(feature = "pattern"))]
+macro_rules! searcher_expr { ($e:expr) => ({}) }
diff --git a/crates/regex/tests/misc.rs b/crates/regex/tests/misc.rs
new file mode 100644
index 0000000..314811e
--- /dev/null
+++ b/crates/regex/tests/misc.rs
@@ -0,0 +1,4 @@
+mat!(prefix_literal_match, r"^abc", r"abc", Some((0, 3)));
+mat!(prefix_literal_nomatch, r"^abc", r"zabc", None);
+mat!(one_literal_edge, r"abc", r"xxxxxab", None);
+matiter!(terminates, r"a$", r"a", (0, 1));
diff --git a/crates/regex/tests/multiline.rs b/crates/regex/tests/multiline.rs
new file mode 100644
index 0000000..62ee47b
--- /dev/null
+++ b/crates/regex/tests/multiline.rs
@@ -0,0 +1,144 @@
+matiter!(
+    match_multi_1,
+    r"(?m)^[a-z]+$",
+    "abc\ndef\nxyz",
+    (0, 3),
+    (4, 7),
+    (8, 11)
+);
+matiter!(match_multi_2, r"(?m)^$", "abc\ndef\nxyz");
+matiter!(match_multi_3, r"(?m)^", "abc\ndef\nxyz", (0, 0), (4, 4), (8, 8));
+matiter!(match_multi_4, r"(?m)$", "abc\ndef\nxyz", (3, 3), (7, 7), (11, 11));
+matiter!(
+    match_multi_5,
+    r"(?m)^[a-z]",
+    "abc\ndef\nxyz",
+    (0, 1),
+    (4, 5),
+    (8, 9)
+);
+matiter!(match_multi_6, r"(?m)[a-z]^", "abc\ndef\nxyz");
+matiter!(
+    match_multi_7,
+    r"(?m)[a-z]$",
+    "abc\ndef\nxyz",
+    (2, 3),
+    (6, 7),
+    (10, 11)
+);
+matiter!(match_multi_8, r"(?m)$[a-z]", "abc\ndef\nxyz");
+matiter!(match_multi_9, r"(?m)^$", "", (0, 0));
+
+matiter!(
+    match_multi_rep_1,
+    r"(?m)(?:^$)*",
+    "a\nb\nc",
+    (0, 0),
+    (1, 1),
+    (2, 2),
+    (3, 3),
+    (4, 4),
+    (5, 5)
+);
+matiter!(
+    match_multi_rep_2,
+    r"(?m)(?:^|a)+",
+    "a\naaa\n",
+    (0, 0),
+    (2, 2),
+    (3, 5),
+    (6, 6)
+);
+matiter!(
+    match_multi_rep_3,
+    r"(?m)(?:^|a)*",
+    "a\naaa\n",
+    (0, 1),
+    (2, 5),
+    (6, 6)
+);
+matiter!(
+    match_multi_rep_4,
+    r"(?m)(?:^[a-z])+",
+    "abc\ndef\nxyz",
+    (0, 1),
+    (4, 5),
+    (8, 9)
+);
+matiter!(
+    match_multi_rep_5,
+    r"(?m)(?:^[a-z]{3}\n?)+",
+    "abc\ndef\nxyz",
+    (0, 11)
+);
+matiter!(
+    match_multi_rep_6,
+    r"(?m)(?:^[a-z]{3}\n?)*",
+    "abc\ndef\nxyz",
+    (0, 11)
+);
+matiter!(
+    match_multi_rep_7,
+    r"(?m)(?:\n?[a-z]{3}$)+",
+    "abc\ndef\nxyz",
+    (0, 11)
+);
+matiter!(
+    match_multi_rep_8,
+    r"(?m)(?:\n?[a-z]{3}$)*",
+    "abc\ndef\nxyz",
+    (0, 11)
+);
+matiter!(
+    match_multi_rep_9,
+    r"(?m)^*",
+    "\naa\n",
+    (0, 0),
+    (1, 1),
+    (2, 2),
+    (3, 3),
+    (4, 4)
+);
+matiter!(match_multi_rep_10, r"(?m)^+", "\naa\n", (0, 0), (1, 1), (4, 4));
+matiter!(
+    match_multi_rep_11,
+    r"(?m)$*",
+    "\naa\n",
+    (0, 0),
+    (1, 1),
+    (2, 2),
+    (3, 3),
+    (4, 4)
+);
+matiter!(match_multi_rep_12, r"(?m)$+", "\naa\n", (0, 0), (3, 3), (4, 4));
+matiter!(match_multi_rep_13, r"(?m)(?:$\n)+", "\n\naaa\n\n", (0, 2), (5, 7));
+matiter!(
+    match_multi_rep_14,
+    r"(?m)(?:$\n)*",
+    "\n\naaa\n\n",
+    (0, 2),
+    (3, 3),
+    (4, 4),
+    (5, 7)
+);
+matiter!(match_multi_rep_15, r"(?m)(?:$\n^)+", "\n\naaa\n\n", (0, 2), (5, 7));
+matiter!(
+    match_multi_rep_16,
+    r"(?m)(?:^|$)+",
+    "\n\naaa\n\n",
+    (0, 0),
+    (1, 1),
+    (2, 2),
+    (5, 5),
+    (6, 6),
+    (7, 7)
+);
+matiter!(
+    match_multi_rep_17,
+    r"(?m)(?:$\n)*",
+    "\n\naaa\n\n",
+    (0, 2),
+    (3, 3),
+    (4, 4),
+    (5, 7)
+);
diff --git a/crates/regex/tests/noparse.rs b/crates/regex/tests/noparse.rs
new file mode 100644
index 0000000..8ded1dc
--- /dev/null
+++ b/crates/regex/tests/noparse.rs
@@ -0,0 +1,45 @@
+macro_rules! noparse(
+    ($name:ident, $re:expr) => (
+        #[test]
+        fn $name() {
+            let re = $re;
+            match regex_new!(re) {
+                Err(_) => {},
+                Ok(_) => panic!("Regex '{}' should cause a parse error.", re),
+            }
+        }
+    );
+);
+
+noparse!(fail_no_repeat_arg, "*");
+noparse!(fail_incomplete_escape, "\\");
+noparse!(fail_class_incomplete, "[A-");
+noparse!(fail_class_not_closed, "[A");
+noparse!(fail_class_no_begin, r"[\A]");
+noparse!(fail_class_no_end, r"[\z]");
+noparse!(fail_class_no_boundary, r"[\b]");
+noparse!(fail_open_paren, "(");
+noparse!(fail_close_paren, ")");
+noparse!(fail_invalid_range, "[a-Z]");
+noparse!(fail_empty_capture_name, "(?P<>a)");
+noparse!(fail_bad_capture_name, "(?P<na-me>)");
+noparse!(fail_bad_flag, "(?a)a");
+noparse!(fail_too_big, "a{10000000}");
+noparse!(fail_counted_no_close, "a{1001");
+noparse!(fail_counted_decreasing, "a{2,1}");
+noparse!(fail_counted_nonnegative, "a{-1,1}");
+noparse!(fail_unfinished_cap, "(?");
+noparse!(fail_unfinished_escape, "\\");
+noparse!(fail_octal_digit, r"\8");
+noparse!(fail_hex_digit, r"\xG0");
+noparse!(fail_hex_short, r"\xF");
+noparse!(fail_hex_long_digits, r"\x{fffg}");
+noparse!(fail_flag_bad, "(?a)");
+noparse!(fail_flag_empty, "(?)");
+noparse!(fail_double_neg, "(?-i-i)");
+noparse!(fail_neg_empty, "(?i-)");
+noparse!(fail_dupe_named, "(?P<a>.)(?P<a>.)");
+noparse!(fail_range_end_no_class, "[a-[:lower:]]");
+noparse!(fail_range_end_no_begin, r"[a-\A]");
+noparse!(fail_range_end_no_end, r"[a-\z]");
+noparse!(fail_range_end_no_boundary, r"[a-\b]");
diff --git a/crates/regex/tests/regression.rs b/crates/regex/tests/regression.rs
new file mode 100644
index 0000000..e8b2525
--- /dev/null
+++ b/crates/regex/tests/regression.rs
@@ -0,0 +1,222 @@
+// See: https://github.com/rust-lang/regex/issues/48
+#[test]
+fn invalid_regexes_no_crash() {
+    assert!(regex_new!("(*)").is_err());
+    assert!(regex_new!("(?:?)").is_err());
+    assert!(regex_new!("(?)").is_err());
+    assert!(regex_new!("*").is_err());
+}
+
+// See: https://github.com/rust-lang/regex/issues/98
+#[test]
+fn regression_many_repeat_stack_overflow() {
+    let re = regex!("^.{1,2500}");
+    assert_eq!(vec![(0, 1)], findall!(re, "a"));
+}
+
+// See: https://github.com/rust-lang/regex/issues/555
+#[test]
+fn regression_invalid_repetition_expr() {
+    assert!(regex_new!("(?m){1,1}").is_err());
+}
+
+// See: https://github.com/rust-lang/regex/issues/527
+#[test]
+fn regression_invalid_flags_expression() {
+    assert!(regex_new!("(((?x)))").is_ok());
+}
+
+// See: https://github.com/rust-lang/regex/issues/75
+mat!(regression_unsorted_binary_search_1, r"(?i-u)[a_]+", "A_", Some((0, 2)));
+mat!(regression_unsorted_binary_search_2, r"(?i-u)[A_]+", "a_", Some((0, 2)));
+
+// See: https://github.com/rust-lang/regex/issues/99
+#[cfg(feature = "unicode-case")]
+mat!(regression_negated_char_class_1, r"(?i)[^x]", "x", None);
+#[cfg(feature = "unicode-case")]
+mat!(regression_negated_char_class_2, r"(?i)[^x]", "X", None);
+
+// See: https://github.com/rust-lang/regex/issues/101
+mat!(regression_ascii_word_underscore, r"[[:word:]]", "_", Some((0, 1)));
+
+// See: https://github.com/rust-lang/regex/issues/129
+#[test]
+fn regression_captures_rep() {
+    let re = regex!(r"([a-f]){2}(?P<foo>[x-z])");
+    let caps = re.captures(text!("abx")).unwrap();
+    assert_eq!(match_text!(caps.name("foo").unwrap()), text!("x"));
+}
+
+// See: https://github.com/rust-lang/regex/issues/153
+mat!(regression_alt_in_alt1, r"ab?|$", "az", Some((0, 1)));
+mat!(regression_alt_in_alt2, r"^(.*?)(\n|\r\n?|$)", "ab\rcd", Some((0, 3)));
+
+// See: https://github.com/rust-lang/regex/issues/169
+mat!(regression_leftmost_first_prefix, r"z*azb", "azb", Some((0, 3)));
+
+// See: https://github.com/rust-lang/regex/issues/76
+#[cfg(all(feature = "unicode-case", feature = "unicode-gencat"))]
+mat!(uni_case_lower_nocase_flag, r"(?i)\p{Ll}+", "ΛΘΓΔα", Some((0, 10)));
+
+// See: https://github.com/rust-lang/regex/issues/191
+mat!(many_alternates, r"1|2|3|4|5|6|7|8|9|10|int", "int", Some((0, 3)));
+
+// burntsushi was bad and didn't create an issue for this bug.
+mat!(anchored_prefix1, r"^a[[:^space:]]", "a ", None);
+mat!(anchored_prefix2, r"^a[[:^space:]]", "foo boo a ", None);
+mat!(anchored_prefix3, r"^-[a-z]", "r-f", None);
+
+// See: https://github.com/rust-lang/regex/issues/204
+#[cfg(feature = "unicode-perl")]
+split!(
+    split_on_word_boundary,
+    r"\b",
+    r"Should this (work?)",
+    &[
+        t!(""),
+        t!("Should"),
+        t!(" "),
+        t!("this"),
+        t!(" ("),
+        t!("work"),
+        t!("?)")
+    ]
+);
+#[cfg(feature = "unicode-perl")]
+matiter!(
+    word_boundary_dfa,
+    r"\b",
+    "a b c",
+    (0, 0),
+    (1, 1),
+    (2, 2),
+    (3, 3),
+    (4, 4),
+    (5, 5)
+);
+
+// See: https://github.com/rust-lang/regex/issues/268
+matiter!(partial_anchor, r"^a|b", "ba", (0, 1));
+
+// See: https://github.com/rust-lang/regex/issues/280
+ismatch!(partial_anchor_alternate_begin, r"^a|z", "yyyyya", false);
+ismatch!(partial_anchor_alternate_end, r"a$|z", "ayyyyy", false);
+
+// See: https://github.com/rust-lang/regex/issues/289
+mat!(lits_unambiguous1, r"(ABC|CDA|BC)X", "CDAX", Some((0, 4)));
+
+// See: https://github.com/rust-lang/regex/issues/291
+mat!(
+    lits_unambiguous2,
+    r"((IMG|CAM|MG|MB2)_|(DSCN|CIMG))(?P<n>[0-9]+)$",
+    "CIMG2341",
+    Some((0, 8)),
+    Some((0, 4)),
+    None,
+    Some((0, 4)),
+    Some((4, 8))
+);
+
+// See: https://github.com/rust-lang/regex/issues/271
+mat!(endl_or_wb, r"(?m:$)|(?-u:\b)", "\u{6084e}", Some((4, 4)));
+mat!(zero_or_end, r"(?i-u:\x00)|$", "\u{e682f}", Some((4, 4)));
+mat!(y_or_endl, r"(?i-u:y)|(?m:$)", "\u{b4331}", Some((4, 4)));
+#[cfg(feature = "unicode-perl")]
+mat!(wb_start_x, r"(?u:\b)^(?-u:X)", "X", Some((0, 1)));
+
+// See: https://github.com/rust-lang/regex/issues/321
+ismatch!(strange_anchor_non_complete_prefix, r"a^{2}", "", false);
+ismatch!(strange_anchor_non_complete_suffix, r"${2}a", "", false);
+
+// See: https://github.com/BurntSushi/ripgrep/issues/1203
+ismatch!(reverse_suffix1, r"[0-4][0-4][0-4]000", "153.230000", true);
+ismatch!(reverse_suffix2, r"[0-9][0-9][0-9]000", "153.230000\n", true);
+matiter!(reverse_suffix3, r"[0-9][0-9][0-9]000", "153.230000\n", (4, 10));
+
+// See: https://github.com/rust-lang/regex/issues/334
+// See: https://github.com/rust-lang/regex/issues/557
+mat!(
+    captures_after_dfa_premature_end1,
+    r"a(b*(X|$))?",
+    "abcbX",
+    Some((0, 1)),
+    None,
+    None
+);
+mat!(
+    captures_after_dfa_premature_end2,
+    r"a(bc*(X|$))?",
+    "abcbX",
+    Some((0, 1)),
+    None,
+    None
+);
+mat!(captures_after_dfa_premature_end3, r"(aa$)?", "aaz", Some((0, 0)));
+
+// See: https://github.com/rust-lang/regex/issues/437
+ismatch!(
+    literal_panic,
+    r"typename type\-parameter\-[0-9]+\-[0-9]+::.+",
+    "test",
+    false
+);
+
+// See: https://github.com/rust-lang/regex/issues/533
+ismatch!(
+    blank_matches_nothing_between_space_and_tab,
+    r"[[:blank:]]",
+    "\u{a}\u{b}\u{c}\u{d}\u{e}\u{f}\
+     \u{10}\u{11}\u{12}\u{13}\u{14}\u{15}\u{16}\u{17}\
+     \u{18}\u{19}\u{1a}\u{1b}\u{1c}\u{1d}\u{1e}\u{1f}",
+    false
+);
+
+ismatch!(
+    inverted_blank_matches_everything_between_space_and_tab,
+    r"^[[:^blank:]]+$",
+    "\u{a}\u{b}\u{c}\u{d}\u{e}\u{f}\
+     \u{10}\u{11}\u{12}\u{13}\u{14}\u{15}\u{16}\u{17}\
+     \u{18}\u{19}\u{1a}\u{1b}\u{1c}\u{1d}\u{1e}\u{1f}",
+    true
+);
+
+// Tests that our Aho-Corasick optimization works correctly. It only
+// kicks in when we have >32 literals. By "works correctly," we mean that
+// leftmost-first match semantics are properly respected. That is, samwise
+// should match, not sam.
+mat!(
+    ahocorasick1,
+    "samwise|sam|a|b|c|d|e|f|g|h|i|j|k|l|m|n|o|p|q|r|s|t|u|v|w|x|y|z|\
+     A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T|U|V|W|X|Y|Z",
+    "samwise",
+    Some((0, 7))
+);
+
+// See: https://github.com/BurntSushi/ripgrep/issues/1247
+#[test]
+#[cfg(feature = "unicode-perl")]
+fn regression_nfa_stops1() {
+    let re = ::regex::bytes::Regex::new(r"\bs(?:[ab])").unwrap();
+    assert_eq!(0, re.find_iter(b"s\xE4").count());
+}
+
+// See: https://github.com/rust-lang/regex/issues/640
+#[cfg(feature = "unicode-case")]
+matiter!(
+    flags_are_unset,
+    r"((?i)foo)|Bar",
+    "foo Foo bar Bar",
+    (0, 3),
+    (4, 7),
+    (12, 15)
+);
+
+// See: https://github.com/rust-lang/regex/issues/659
+//
+// Note that 'Ј' is not 'j', but cyrillic Je
+// https://en.wikipedia.org/wiki/Je_(Cyrillic)
+ismatch!(empty_group_match, r"()Ј01", "zЈ01", true);
+matiter!(empty_group_find, r"()Ј01", "zЈ01", (1, 5));
+
+// See: https://github.com/rust-lang/regex/issues/862
+mat!(non_greedy_question_literal, r"ab??", "ab", Some((0, 1)));
diff --git a/crates/regex/tests/regression_fuzz.rs b/crates/regex/tests/regression_fuzz.rs
new file mode 100644
index 0000000..4e76704
--- /dev/null
+++ b/crates/regex/tests/regression_fuzz.rs
@@ -0,0 +1,31 @@
+// These tests are only run for the "default" test target because some of them
+// can take quite a long time. Some of them take long enough that it's not
+// practical to run them in debug mode. :-/
+
+// See: https://oss-fuzz.com/testcase-detail/5673225499181056
+//
+// Ignored by default since it takes too long in debug mode (almost a minute).
+#[test]
+#[ignore]
+fn fuzz1() {
+    regex!(r"1}{55}{0}*{1}{55}{55}{5}*{1}{55}+{56}|;**");
+}
+
+// See: https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=26505
+// See: https://github.com/rust-lang/regex/issues/722
+#[test]
+fn empty_any_errors_no_panic() {
+    assert!(regex_new!(r"\P{any}").is_err());
+}
+
+// This tests that a very large regex errors during compilation instead of
+// using gratuitous amounts of memory. The specific problem is that the
+// compiler wasn't accounting for the memory used by Unicode character classes
+// correctly.
+//
+// See: https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=33579
+#[test]
+fn big_regex_fails_to_compile() {
+    let pat = "[\u{0}\u{e}\u{2}\\w~~>[l\t\u{0}]p?<]{971158}";
+    assert!(regex_new!(pat).is_err());
+}
diff --git a/crates/regex/tests/replace.rs b/crates/regex/tests/replace.rs
new file mode 100644
index 0000000..d65be07
--- /dev/null
+++ b/crates/regex/tests/replace.rs
@@ -0,0 +1,248 @@
+macro_rules! replace(
+    ($name:ident, $which:ident, $re:expr,
+     $search:expr, $replace:expr, $result:expr) => (
+        #[test]
+        fn $name() {
+            let re = regex!($re);
+            assert_eq!(re.$which(text!($search), $replace), text!($result));
+        }
+    );
+);
+
+replace!(first, replace, r"[0-9]", "age: 26", t!("Z"), "age: Z6");
+replace!(plus, replace, r"[0-9]+", "age: 26", t!("Z"), "age: Z");
+replace!(all, replace_all, r"[0-9]", "age: 26", t!("Z"), "age: ZZ");
+replace!(
+    groups,
+    replace,
+    r"(?-u)(\S+)\s+(\S+)",
+    "w1 w2",
+    t!("$2 $1"),
+    "w2 w1"
+);
+replace!(
+    double_dollar,
+    replace,
+    r"(?-u)(\S+)\s+(\S+)",
+    "w1 w2",
+    t!("$2 $$1"),
+    "w2 $1"
+);
+// replace!(adjacent_index, replace,
+// r"([^aeiouy])ies$", "skies", t!("$1y"), "sky");
+replace!(
+    named,
+    replace_all,
+    r"(?-u)(?P<first>\S+)\s+(?P<last>\S+)(?P<space>\s*)",
+    "w1 w2 w3 w4",
+    t!("$last $first$space"),
+    "w2 w1 w4 w3"
+);
+replace!(
+    trim,
+    replace_all,
+    "^[ \t]+|[ \t]+$",
+    " \t  trim me\t   \t",
+    t!(""),
+    "trim me"
+);
+replace!(number_hypen, replace, r"(.)(.)", "ab", t!("$1-$2"), "a-b");
+// replace!(number_underscore, replace, r"(.)(.)", "ab", t!("$1_$2"), "a_b");
+replace!(
+    simple_expand,
+    replace_all,
+    r"(?-u)(\w) (\w)",
+    "a b",
+    t!("$2 $1"),
+    "b a"
+);
+replace!(
+    literal_dollar1,
+    replace_all,
+    r"(?-u)(\w+) (\w+)",
+    "a b",
+    t!("$$1"),
+    "$1"
+);
+replace!(
+    literal_dollar2,
+    replace_all,
+    r"(?-u)(\w+) (\w+)",
+    "a b",
+    t!("$2 $$c $1"),
+    "b $c a"
+);
+replace!(
+    no_expand1,
+    replace,
+    r"(?-u)(\S+)\s+(\S+)",
+    "w1 w2",
+    no_expand!("$2 $1"),
+    "$2 $1"
+);
+replace!(
+    no_expand2,
+    replace,
+    r"(?-u)(\S+)\s+(\S+)",
+    "w1 w2",
+    no_expand!("$$1"),
+    "$$1"
+);
+use_!(Captures);
+replace!(
+    closure_returning_reference,
+    replace,
+    r"([0-9]+)",
+    "age: 26",
+    |captures: &Captures<'_>| {
+        match_text!(captures.get(1).unwrap())[0..1].to_owned()
+    },
+    "age: 2"
+);
+replace!(
+    closure_returning_value,
+    replace,
+    r"[0-9]+",
+    "age: 26",
+    |_captures: &Captures<'_>| t!("Z").to_owned(),
+    "age: Z"
+);
+
+// See https://github.com/rust-lang/regex/issues/314
+replace!(
+    match_at_start_replace_with_empty,
+    replace_all,
+    r"foo",
+    "foobar",
+    t!(""),
+    "bar"
+);
+
+// See https://github.com/rust-lang/regex/issues/393
+replace!(single_empty_match, replace, r"^", "bar", t!("foo"), "foobar");
+
+// See https://github.com/rust-lang/regex/issues/399
+replace!(
+    capture_longest_possible_name,
+    replace_all,
+    r"(.)",
+    "b",
+    t!("${1}a $1a"),
+    "ba "
+);
+
+replace!(
+    impl_string,
+    replace,
+    r"[0-9]",
+    "age: 26",
+    t!("Z".to_string()),
+    "age: Z6"
+);
+replace!(
+    impl_string_ref,
+    replace,
+    r"[0-9]",
+    "age: 26",
+    t!(&"Z".to_string()),
+    "age: Z6"
+);
+replace!(
+    impl_cow_str_borrowed,
+    replace,
+    r"[0-9]",
+    "age: 26",
+    t!(std::borrow::Cow::<'_, str>::Borrowed("Z")),
+    "age: Z6"
+);
+replace!(
+    impl_cow_str_borrowed_ref,
+    replace,
+    r"[0-9]",
+    "age: 26",
+    t!(&std::borrow::Cow::<'_, str>::Borrowed("Z")),
+    "age: Z6"
+);
+replace!(
+    impl_cow_str_owned,
+    replace,
+    r"[0-9]",
+    "age: 26",
+    t!(std::borrow::Cow::<'_, str>::Owned("Z".to_string())),
+    "age: Z6"
+);
+replace!(
+    impl_cow_str_owned_ref,
+    replace,
+    r"[0-9]",
+    "age: 26",
+    t!(&std::borrow::Cow::<'_, str>::Owned("Z".to_string())),
+    "age: Z6"
+);
+
+replace!(
+    impl_vec_u8,
+    replace,
+    r"[0-9]",
+    "age: 26",
+    bytes!(vec![b'Z']),
+    "age: Z6"
+);
+replace!(
+    impl_vec_u8_ref,
+    replace,
+    r"[0-9]",
+    "age: 26",
+    bytes!(&vec![b'Z']),
+    "age: Z6"
+);
+replace!(
+    impl_cow_slice_borrowed,
+    replace,
+    r"[0-9]",
+    "age: 26",
+    bytes!(std::borrow::Cow::<'_, [u8]>::Borrowed(&[b'Z'])),
+    "age: Z6"
+);
+replace!(
+    impl_cow_slice_borrowed_ref,
+    replace,
+    r"[0-9]",
+    "age: 26",
+    bytes!(&std::borrow::Cow::<'_, [u8]>::Borrowed(&[b'Z'])),
+    "age: Z6"
+);
+replace!(
+    impl_cow_slice_owned,
+    replace,
+    r"[0-9]",
+    "age: 26",
+    bytes!(std::borrow::Cow::<'_, [u8]>::Owned(vec![b'Z'])),
+    "age: Z6"
+);
+replace!(
+    impl_cow_slice_owned_ref,
+    replace,
+    r"[0-9]",
+    "age: 26",
+    bytes!(&std::borrow::Cow::<'_, [u8]>::Owned(vec![b'Z'])),
+    "age: Z6"
+);
+
+#[test]
+fn replacen_no_captures() {
+    let re = regex!(r"[0-9]");
+    assert_eq!(
+        re.replacen(text!("age: 1234"), 2, t!("Z")),
+        text!("age: ZZ34")
+    );
+}
+
+#[test]
+fn replacen_with_captures() {
+    let re = regex!(r"([0-9])");
+    assert_eq!(
+        re.replacen(text!("age: 1234"), 2, t!("${1}Z")),
+        text!("age: 1Z2Z34")
+    );
+}
diff --git a/crates/regex/tests/searcher.rs b/crates/regex/tests/searcher.rs
new file mode 100644
index 0000000..3779f54
--- /dev/null
+++ b/crates/regex/tests/searcher.rs
@@ -0,0 +1,95 @@
+macro_rules! searcher {
+    ($name:ident, $re:expr, $haystack:expr) => (
+        searcher!($name, $re, $haystack, vec vec![]);
+    );
+    ($name:ident, $re:expr, $haystack:expr, $($steps:expr,)*) => (
+        searcher!($name, $re, $haystack, vec vec![$($steps),*]);
+    );
+    ($name:ident, $re:expr, $haystack:expr, $($steps:expr),*) => (
+        searcher!($name, $re, $haystack, vec vec![$($steps),*]);
+    );
+    ($name:ident, $re:expr, $haystack:expr, vec $expect_steps:expr) => (
+        #[test]
+        #[allow(unused_imports)]
+        fn $name() {
+            searcher_expr! {{
+                use std::str::pattern::{Pattern, Searcher};
+                use std::str::pattern::SearchStep::{Match, Reject, Done};
+                let re = regex!($re);
+                let mut se = re.into_searcher($haystack);
+                let mut got_steps = vec![];
+                loop {
+                    match se.next() {
+                        Done => break,
+                        step => { got_steps.push(step); }
+                    }
+                }
+                assert_eq!(got_steps, $expect_steps);
+            }}
+        }
+    );
+}
+
+searcher!(searcher_empty_regex_empty_haystack, r"", "", Match(0, 0));
+searcher!(
+    searcher_empty_regex,
+    r"",
+    "ab",
+    Match(0, 0),
+    Reject(0, 1),
+    Match(1, 1),
+    Reject(1, 2),
+    Match(2, 2)
+);
+searcher!(searcher_empty_haystack, r"\d", "");
+searcher!(searcher_one_match, r"\d", "5", Match(0, 1));
+searcher!(searcher_no_match, r"\d", "a", Reject(0, 1));
+searcher!(
+    searcher_two_adjacent_matches,
+    r"\d",
+    "56",
+    Match(0, 1),
+    Match(1, 2)
+);
+searcher!(
+    searcher_two_non_adjacent_matches,
+    r"\d",
+    "5a6",
+    Match(0, 1),
+    Reject(1, 2),
+    Match(2, 3)
+);
+searcher!(searcher_reject_first, r"\d", "a6", Reject(0, 1), Match(1, 2));
+searcher!(
+    searcher_one_zero_length_matches,
+    r"\d*",
+    "a1b2",
+    Match(0, 0),  // ^
+    Reject(0, 1), // a
+    Match(1, 2),  // a1
+    Reject(2, 3), // a1b
+    Match(3, 4),  // a1b2
+);
+searcher!(
+    searcher_many_zero_length_matches,
+    r"\d*",
+    "a1bbb2",
+    Match(0, 0),  // ^
+    Reject(0, 1), // a
+    Match(1, 2),  // a1
+    Reject(2, 3), // a1b
+    Match(3, 3),  // a1bb
+    Reject(3, 4), // a1bb
+    Match(4, 4),  // a1bbb
+    Reject(4, 5), // a1bbb
+    Match(5, 6),  // a1bbba
+);
+searcher!(
+    searcher_unicode,
+    r".+?",
+    "Ⅰ1Ⅱ2",
+    Match(0, 3),
+    Match(3, 4),
+    Match(4, 7),
+    Match(7, 8)
+);
diff --git a/crates/regex/tests/set.rs b/crates/regex/tests/set.rs
new file mode 100644
index 0000000..37fcf87
--- /dev/null
+++ b/crates/regex/tests/set.rs
@@ -0,0 +1,67 @@
+matset!(set1, &["a", "a"], "a", 0, 1);
+matset!(set2, &["a", "a"], "ba", 0, 1);
+matset!(set3, &["a", "b"], "a", 0);
+matset!(set4, &["a", "b"], "b", 1);
+matset!(set5, &["a|b", "b|a"], "b", 0, 1);
+matset!(set6, &["foo", "oo"], "foo", 0, 1);
+matset!(set7, &["^foo", "bar$"], "foo", 0);
+matset!(set8, &["^foo", "bar$"], "foo bar", 0, 1);
+matset!(set9, &["^foo", "bar$"], "bar", 1);
+matset!(set10, &[r"[a-z]+$", "foo"], "01234 foo", 0, 1);
+matset!(set11, &[r"[a-z]+$", "foo"], "foo 01234", 1);
+matset!(set12, &[r".*?", "a"], "zzzzzza", 0, 1);
+matset!(set13, &[r".*", "a"], "zzzzzza", 0, 1);
+matset!(set14, &[r".*", "a"], "zzzzzz", 0);
+matset!(set15, &[r"(?-u)\ba\b"], "hello a bye", 0);
+matset!(set16, &["a"], "a", 0);
+matset!(set17, &[".*a"], "a", 0);
+matset!(set18, &["a", "β"], "β", 1);
+
+// regexes that match the empty string
+matset!(setempty1, &["", "a"], "abc", 0, 1);
+matset!(setempty2, &["", "b"], "abc", 0, 1);
+matset!(setempty3, &["", "z"], "abc", 0);
+matset!(setempty4, &["a", ""], "abc", 0, 1);
+matset!(setempty5, &["b", ""], "abc", 0, 1);
+matset!(setempty6, &["z", ""], "abc", 1);
+matset!(setempty7, &["b", "(?:)"], "abc", 0, 1);
+matset!(setempty8, &["(?:)", "b"], "abc", 0, 1);
+matset!(setempty9, &["c(?:)", "b"], "abc", 0, 1);
+
+nomatset!(nset1, &["a", "a"], "b");
+nomatset!(nset2, &["^foo", "bar$"], "bar foo");
+nomatset!(
+    nset3,
+    {
+        let xs: &[&str] = &[];
+        xs
+    },
+    "a"
+);
+nomatset!(nset4, &[r"^rooted$", r"\.log$"], "notrooted");
+
+// See: https://github.com/rust-lang/regex/issues/187
+#[test]
+fn regression_subsequent_matches() {
+    let set = regex_set!(&["ab", "b"]);
+    let text = text!("ba");
+    assert!(set.matches(text).matched(1));
+    assert!(set.matches(text).matched(1));
+}
+
+#[test]
+fn get_set_patterns() {
+    let set = regex_set!(&["a", "b"]);
+    assert_eq!(vec!["a", "b"], set.patterns());
+}
+
+#[test]
+fn len_and_empty() {
+    let empty = regex_set!(&[""; 0]);
+    assert_eq!(empty.len(), 0);
+    assert!(empty.is_empty());
+
+    let not_empty = regex_set!(&["ab", "b"]);
+    assert_eq!(not_empty.len(), 2);
+    assert!(!not_empty.is_empty());
+}
diff --git a/crates/regex/tests/shortest_match.rs b/crates/regex/tests/shortest_match.rs
new file mode 100644
index 0000000..f8b4fed
--- /dev/null
+++ b/crates/regex/tests/shortest_match.rs
@@ -0,0 +1,14 @@
+macro_rules! shortmat {
+    ($name:ident, $re:expr, $text:expr, $shortest_match:expr) => {
+        #[test]
+        fn $name() {
+            let text = text!($text);
+            let re = regex!($re);
+            assert_eq!($shortest_match, re.shortest_match(text));
+        }
+    };
+}
+
+shortmat!(t01, r"a+", r"aa", Some(1));
+// Test that the reverse suffix optimization gets it right.
+shortmat!(t02, r".*(?:abcd)+", r"abcdabcd", Some(4));
diff --git a/crates/regex/tests/suffix_reverse.rs b/crates/regex/tests/suffix_reverse.rs
new file mode 100644
index 0000000..774c9e8
--- /dev/null
+++ b/crates/regex/tests/suffix_reverse.rs
@@ -0,0 +1,6 @@
+mat!(t01, r".*abcd", r"abcd", Some((0, 4)));
+mat!(t02, r".*(?:abcd)+", r"abcd", Some((0, 4)));
+mat!(t03, r".*(?:abcd)+", r"abcdabcd", Some((0, 8)));
+mat!(t04, r".*(?:abcd)+", r"abcdxabcd", Some((0, 9)));
+mat!(t05, r".*x(?:abcd)+", r"abcdxabcd", Some((0, 9)));
+mat!(t06, r"[^abcd]*x(?:abcd)+", r"abcdxabcd", Some((4, 9)));
diff --git a/crates/regex/tests/test_backtrack.rs b/crates/regex/tests/test_backtrack.rs
new file mode 100644
index 0000000..fb934e2
--- /dev/null
+++ b/crates/regex/tests/test_backtrack.rs
@@ -0,0 +1,56 @@
+#![cfg_attr(feature = "pattern", feature(pattern))]
+
+macro_rules! regex_new {
+    ($re:expr) => {{
+        use regex::internal::ExecBuilder;
+        ExecBuilder::new($re)
+            .bounded_backtracking()
+            .build()
+            .map(|e| e.into_regex())
+    }};
+}
+
+macro_rules! regex {
+    ($re:expr) => {
+        regex_new!($re).unwrap()
+    };
+}
+
+macro_rules! regex_set_new {
+    ($re:expr) => {{
+        use regex::internal::ExecBuilder;
+        ExecBuilder::new_many($re)
+            .bounded_backtracking()
+            .build()
+            .map(|e| e.into_regex_set())
+    }};
+}
+
+macro_rules! regex_set {
+    ($res:expr) => {
+        regex_set_new!($res).unwrap()
+    };
+}
+
+// Must come before other module definitions.
+include!("macros_str.rs");
+include!("macros.rs");
+
+mod api;
+mod api_str;
+mod crazy;
+mod flags;
+mod fowler;
+mod multiline;
+mod noparse;
+mod regression;
+mod replace;
+mod searcher;
+mod set;
+mod suffix_reverse;
+#[cfg(feature = "unicode")]
+mod unicode;
+#[cfg(feature = "unicode-perl")]
+mod word_boundary;
+#[cfg(feature = "unicode-perl")]
+mod word_boundary_unicode;
diff --git a/crates/regex/tests/test_backtrack_bytes.rs b/crates/regex/tests/test_backtrack_bytes.rs
new file mode 100644
index 0000000..a59426c
--- /dev/null
+++ b/crates/regex/tests/test_backtrack_bytes.rs
@@ -0,0 +1,55 @@
+macro_rules! regex_new {
+    ($re:expr) => {{
+        use regex::internal::ExecBuilder;
+        ExecBuilder::new($re)
+            .bounded_backtracking()
+            .only_utf8(false)
+            .build()
+            .map(|e| e.into_byte_regex())
+    }};
+}
+
+macro_rules! regex {
+    ($re:expr) => {
+        regex_new!($re).unwrap()
+    };
+}
+
+macro_rules! regex_set_new {
+    ($re:expr) => {{
+        use regex::internal::ExecBuilder;
+        ExecBuilder::new_many($re)
+            .bounded_backtracking()
+            .only_utf8(false)
+            .build()
+            .map(|e| e.into_byte_regex_set())
+    }};
+}
+
+macro_rules! regex_set {
+    ($res:expr) => {
+        regex_set_new!($res).unwrap()
+    };
+}
+
+// Must come before other module definitions.
+include!("macros_bytes.rs");
+include!("macros.rs");
+
+mod api;
+mod bytes;
+mod crazy;
+mod flags;
+mod fowler;
+mod multiline;
+mod noparse;
+mod regression;
+mod replace;
+mod set;
+mod suffix_reverse;
+#[cfg(feature = "unicode")]
+mod unicode;
+#[cfg(feature = "unicode-perl")]
+mod word_boundary;
+#[cfg(feature = "unicode-perl")]
+mod word_boundary_ascii;
diff --git a/crates/regex/tests/test_backtrack_utf8bytes.rs b/crates/regex/tests/test_backtrack_utf8bytes.rs
new file mode 100644
index 0000000..6d308e9
--- /dev/null
+++ b/crates/regex/tests/test_backtrack_utf8bytes.rs
@@ -0,0 +1,58 @@
+#![cfg_attr(feature = "pattern", feature(pattern))]
+
+macro_rules! regex_new {
+    ($re:expr) => {{
+        use regex::internal::ExecBuilder;
+        ExecBuilder::new($re)
+            .bounded_backtracking()
+            .bytes(true)
+            .build()
+            .map(|e| e.into_regex())
+    }};
+}
+
+macro_rules! regex {
+    ($re:expr) => {
+        regex_new!($re).unwrap()
+    };
+}
+
+macro_rules! regex_set_new {
+    ($re:expr) => {{
+        use regex::internal::ExecBuilder;
+        ExecBuilder::new_many($re)
+            .bounded_backtracking()
+            .bytes(true)
+            .build()
+            .map(|e| e.into_regex_set())
+    }};
+}
+
+macro_rules! regex_set {
+    ($res:expr) => {
+        regex_set_new!($res).unwrap()
+    };
+}
+
+// Must come before other module definitions.
+include!("macros_str.rs");
+include!("macros.rs");
+
+mod api;
+mod api_str;
+mod crazy;
+mod flags;
+mod fowler;
+mod multiline;
+mod noparse;
+mod regression;
+mod replace;
+mod searcher;
+mod set;
+mod suffix_reverse;
+#[cfg(feature = "unicode")]
+mod unicode;
+#[cfg(feature = "unicode-perl")]
+mod word_boundary;
+#[cfg(feature = "unicode-perl")]
+mod word_boundary_unicode;
diff --git a/crates/regex/tests/test_crates_regex.rs b/crates/regex/tests/test_crates_regex.rs
new file mode 100644
index 0000000..a681604
--- /dev/null
+++ b/crates/regex/tests/test_crates_regex.rs
@@ -0,0 +1,54 @@
+/*
+ * This test is a minimal version of <rofl_0> and <subdiff_0>
+ *
+ * Once this bug gets fixed, uncomment rofl_0 and subdiff_0
+ * (in `tests/crates_regex.rs`).
+#[test]
+fn word_boundary_backtracking_default_mismatch() {
+    use regex::internal::ExecBuilder;
+
+    let backtrack_re = ExecBuilder::new(r"\b")
+        .bounded_backtracking()
+        .build()
+        .map(|exec| exec.into_regex())
+        .map_err(|err| format!("{}", err))
+        .unwrap();
+
+    let default_re = ExecBuilder::new(r"\b")
+        .build()
+        .map(|exec| exec.into_regex())
+        .map_err(|err| format!("{}", err))
+        .unwrap();
+
+    let input = "䅅\\u{a0}";
+
+    let fi1 = backtrack_re.find_iter(input);
+    let fi2 = default_re.find_iter(input);
+    for (m1, m2) in fi1.zip(fi2) {
+        assert_eq!(m1, m2);
+    }
+}
+*/
+
+mod consistent;
+
+mod crates_regex {
+
+    macro_rules! consistent {
+        ($test_name:ident, $regex_src:expr) => {
+            #[test]
+            fn $test_name() {
+                use super::consistent::backends_are_consistent;
+
+                if option_env!("RUST_REGEX_RANDOM_TEST").is_some() {
+                    match backends_are_consistent($regex_src) {
+                        Ok(_) => {}
+                        Err(err) => panic!("{}", err),
+                    }
+                }
+            }
+        };
+    }
+
+    include!("crates_regex.rs");
+}
diff --git a/crates/regex/tests/test_default.rs b/crates/regex/tests/test_default.rs
new file mode 100644
index 0000000..19a319a
--- /dev/null
+++ b/crates/regex/tests/test_default.rs
@@ -0,0 +1,232 @@
+#![cfg_attr(feature = "pattern", feature(pattern))]
+
+use regex;
+
+// Due to macro scoping rules, this definition only applies for the modules
+// defined below. Effectively, it allows us to use the same tests for both
+// native and dynamic regexes.
+//
+// This is also used to test the various matching engines. This one exercises
+// the normal code path which automatically chooses the engine based on the
+// regex and the input. Other dynamic tests explicitly set the engine to use.
+macro_rules! regex_new {
+    ($re:expr) => {{
+        use regex::Regex;
+        Regex::new($re)
+    }};
+}
+
+macro_rules! regex {
+    ($re:expr) => {
+        regex_new!($re).unwrap()
+    };
+}
+
+macro_rules! regex_set_new {
+    ($re:expr) => {{
+        use regex::RegexSet;
+        RegexSet::new($re)
+    }};
+}
+
+macro_rules! regex_set {
+    ($res:expr) => {
+        regex_set_new!($res).unwrap()
+    };
+}
+
+// Must come before other module definitions.
+include!("macros_str.rs");
+include!("macros.rs");
+
+mod api;
+mod api_str;
+mod crazy;
+mod flags;
+mod fowler;
+mod misc;
+mod multiline;
+mod noparse;
+mod regression;
+mod regression_fuzz;
+mod replace;
+mod searcher;
+mod set;
+mod shortest_match;
+mod suffix_reverse;
+#[cfg(feature = "unicode")]
+mod unicode;
+#[cfg(feature = "unicode-perl")]
+mod word_boundary;
+#[cfg(feature = "unicode-perl")]
+mod word_boundary_unicode;
+
+#[test]
+fn disallow_non_utf8() {
+    assert!(regex::Regex::new(r"(?-u)\xFF").is_err());
+    assert!(regex::Regex::new(r"(?-u).").is_err());
+    assert!(regex::Regex::new(r"(?-u)[\xFF]").is_err());
+    assert!(regex::Regex::new(r"(?-u)☃").is_err());
+}
+
+#[test]
+fn disallow_octal() {
+    assert!(regex::Regex::new(r"\0").is_err());
+}
+
+#[test]
+fn allow_octal() {
+    assert!(regex::RegexBuilder::new(r"\0").octal(true).build().is_ok());
+}
+
+#[test]
+fn oibits() {
+    use regex::bytes;
+    use regex::{Regex, RegexBuilder, RegexSet, RegexSetBuilder};
+    use std::panic::{RefUnwindSafe, UnwindSafe};
+
+    fn assert_send<T: Send>() {}
+    fn assert_sync<T: Sync>() {}
+    fn assert_unwind_safe<T: UnwindSafe>() {}
+    fn assert_ref_unwind_safe<T: RefUnwindSafe>() {}
+
+    assert_send::<Regex>();
+    assert_sync::<Regex>();
+    assert_unwind_safe::<Regex>();
+    assert_ref_unwind_safe::<Regex>();
+    assert_send::<RegexBuilder>();
+    assert_sync::<RegexBuilder>();
+    assert_unwind_safe::<RegexBuilder>();
+    assert_ref_unwind_safe::<RegexBuilder>();
+
+    assert_send::<bytes::Regex>();
+    assert_sync::<bytes::Regex>();
+    assert_unwind_safe::<bytes::Regex>();
+    assert_ref_unwind_safe::<bytes::Regex>();
+    assert_send::<bytes::RegexBuilder>();
+    assert_sync::<bytes::RegexBuilder>();
+    assert_unwind_safe::<bytes::RegexBuilder>();
+    assert_ref_unwind_safe::<bytes::RegexBuilder>();
+
+    assert_send::<RegexSet>();
+    assert_sync::<RegexSet>();
+    assert_unwind_safe::<RegexSet>();
+    assert_ref_unwind_safe::<RegexSet>();
+    assert_send::<RegexSetBuilder>();
+    assert_sync::<RegexSetBuilder>();
+    assert_unwind_safe::<RegexSetBuilder>();
+    assert_ref_unwind_safe::<RegexSetBuilder>();
+
+    assert_send::<bytes::RegexSet>();
+    assert_sync::<bytes::RegexSet>();
+    assert_unwind_safe::<bytes::RegexSet>();
+    assert_ref_unwind_safe::<bytes::RegexSet>();
+    assert_send::<bytes::RegexSetBuilder>();
+    assert_sync::<bytes::RegexSetBuilder>();
+    assert_unwind_safe::<bytes::RegexSetBuilder>();
+    assert_ref_unwind_safe::<bytes::RegexSetBuilder>();
+}
+
+// See: https://github.com/rust-lang/regex/issues/568
+#[test]
+fn oibits_regression() {
+    use regex::Regex;
+    use std::panic;
+
+    let _ = panic::catch_unwind(|| Regex::new("a").unwrap());
+}
+
+// See: https://github.com/rust-lang/regex/issues/750
+#[test]
+#[cfg(target_pointer_width = "64")]
+fn regex_is_reasonably_small() {
+    use std::mem::size_of;
+
+    use regex::bytes;
+    use regex::{Regex, RegexSet};
+
+    assert_eq!(16, size_of::<Regex>());
+    assert_eq!(16, size_of::<RegexSet>());
+    assert_eq!(16, size_of::<bytes::Regex>());
+    assert_eq!(16, size_of::<bytes::RegexSet>());
+}
+
+// See: https://github.com/rust-lang/regex/security/advisories/GHSA-m5pq-gvj9-9vr8
+// See: CVE-2022-24713
+//
+// We test that our regex compiler will correctly return a "too big" error when
+// we try to use a very large repetition on an *empty* sub-expression.
+//
+// At the time this test was written, the regex compiler does not represent
+// empty sub-expressions with any bytecode instructions. In effect, it's an
+// "optimization" to leave them out, since they would otherwise correspond
+// to an unconditional JUMP in the regex bytecode (i.e., an unconditional
+// epsilon transition in the NFA graph). Therefore, an empty sub-expression
+// represents an interesting case for the compiler's size limits. Since it
+// doesn't actually contribute any additional memory to the compiled regex
+// instructions, the size limit machinery never detects it. Instead, it just
+// dumbly tries to compile the empty sub-expression N times, where N is the
+// repetition size.
+//
+// When N is very large, this will cause the compiler to essentially spin and
+// do nothing for a decently large amount of time. It causes the regex to take
+// quite a bit of time to compile, despite the concrete syntax of the regex
+// being quite small.
+//
+// The degree to which this is actually a problem is somewhat of a judgment
+// call. Some regexes simply take a long time to compile. But in general, you
+// should be able to reasonably control this by setting lower or higher size
+// limits on the compiled object size. But this mitigation doesn't work at all
+// for this case.
+//
+// This particular test is somewhat narrow. It merely checks that regex
+// compilation will, at some point, return a "too big" error. Before the
+// fix landed, this test would eventually fail because the regex would be
+// successfully compiled (after enough time elapsed). So while this test
+// doesn't check that we exit in a reasonable amount of time, it does at least
+// check that we are properly returning an error at some point.
+#[test]
+fn big_empty_regex_fails() {
+    use regex::Regex;
+
+    let result = Regex::new("(?:){4294967295}");
+    assert!(result.is_err());
+}
+
+// Below is a "billion laughs" variant of the previous test case.
+#[test]
+fn big_empty_reps_chain_regex_fails() {
+    use regex::Regex;
+
+    let result = Regex::new("(?:){64}{64}{64}{64}{64}{64}");
+    assert!(result.is_err());
+}
+
+// Below is another situation where a zero-length sub-expression can be
+// introduced.
+#[test]
+fn big_zero_reps_regex_fails() {
+    use regex::Regex;
+
+    let result = Regex::new(r"x{0}{4294967295}");
+    assert!(result.is_err());
+}
+
+// Testing another case for completeness.
+#[test]
+fn empty_alt_regex_fails() {
+    use regex::Regex;
+
+    let result = Regex::new(r"(?:|){4294967295}");
+    assert!(result.is_err());
+}
+
+// Regression test for: https://github.com/rust-lang/regex/issues/969
+#[test]
+fn regression_i969() {
+    use regex::Regex;
+
+    let re = Regex::new(r"c.*d\z").unwrap();
+    assert_eq!(Some(6), re.shortest_match_at("ababcd", 4));
+    assert_eq!(Some(6), re.find_at("ababcd", 4).map(|m| m.end()));
+}
diff --git a/crates/regex/tests/test_default_bytes.rs b/crates/regex/tests/test_default_bytes.rs
new file mode 100644
index 0000000..f200596
--- /dev/null
+++ b/crates/regex/tests/test_default_bytes.rs
@@ -0,0 +1,75 @@
+macro_rules! regex_new {
+    ($re:expr) => {{
+        use regex::bytes::Regex;
+        Regex::new($re)
+    }};
+}
+
+macro_rules! regex_set_new {
+    ($res:expr) => {{
+        use regex::bytes::RegexSet;
+        RegexSet::new($res)
+    }};
+}
+
+macro_rules! regex {
+    ($re:expr) => {
+        regex_new!($re).unwrap()
+    };
+}
+
+macro_rules! regex_set {
+    ($res:expr) => {
+        regex_set_new!($res).unwrap()
+    };
+}
+
+// Must come before other module definitions.
+include!("macros_bytes.rs");
+include!("macros.rs");
+
+// A silly wrapper to make it possible to write and match raw bytes.
+struct R<'a>(&'a [u8]);
+impl<'a> R<'a> {
+    fn as_bytes(&self) -> &'a [u8] {
+        self.0
+    }
+}
+
+// See: https://github.com/rust-lang/regex/issues/321
+//
+// These tests are here because they do not have the same behavior in every
+// regex engine.
+mat!(invalid_utf8_nfa1, r".", R(b"\xD4\xC2\x65\x2B\x0E\xFE"), Some((2, 3)));
+mat!(invalid_utf8_nfa2, r"${2}ä", R(b"\xD4\xC2\x65\x2B\x0E\xFE"), None);
+mat!(
+    invalid_utf8_nfa3,
+    r".",
+    R(b"\x0A\xDB\x82\x6E\x33\x01\xDD\x33\xCD"),
+    Some((1, 3))
+);
+mat!(
+    invalid_utf8_nfa4,
+    r"${2}ä",
+    R(b"\x0A\xDB\x82\x6E\x33\x01\xDD\x33\xCD"),
+    None
+);
+
+mod api;
+mod bytes;
+mod crazy;
+mod flags;
+mod fowler;
+mod multiline;
+mod noparse;
+mod regression;
+mod replace;
+mod set;
+mod shortest_match;
+mod suffix_reverse;
+#[cfg(feature = "unicode")]
+mod unicode;
+#[cfg(feature = "unicode-perl")]
+mod word_boundary;
+#[cfg(feature = "unicode-perl")]
+mod word_boundary_unicode;
diff --git a/crates/regex/tests/test_nfa.rs b/crates/regex/tests/test_nfa.rs
new file mode 100644
index 0000000..e5a67d1
--- /dev/null
+++ b/crates/regex/tests/test_nfa.rs
@@ -0,0 +1,50 @@
+#![cfg_attr(feature = "pattern", feature(pattern))]
+
+macro_rules! regex_new {
+    ($re:expr) => {{
+        use regex::internal::ExecBuilder;
+        ExecBuilder::new($re).nfa().build().map(|e| e.into_regex())
+    }};
+}
+
+macro_rules! regex {
+    ($re:expr) => {
+        regex_new!($re).unwrap()
+    };
+}
+
+macro_rules! regex_set_new {
+    ($re:expr) => {{
+        use regex::internal::ExecBuilder;
+        ExecBuilder::new_many($re).nfa().build().map(|e| e.into_regex_set())
+    }};
+}
+
+macro_rules! regex_set {
+    ($res:expr) => {
+        regex_set_new!($res).unwrap()
+    };
+}
+
+// Must come before other module definitions.
+include!("macros_str.rs");
+include!("macros.rs");
+
+mod api;
+mod api_str;
+mod crazy;
+mod flags;
+mod fowler;
+mod multiline;
+mod noparse;
+mod regression;
+mod replace;
+mod searcher;
+mod set;
+mod suffix_reverse;
+#[cfg(feature = "unicode")]
+mod unicode;
+#[cfg(feature = "unicode-perl")]
+mod word_boundary;
+#[cfg(feature = "unicode-perl")]
+mod word_boundary_unicode;
diff --git a/crates/regex/tests/test_nfa_bytes.rs b/crates/regex/tests/test_nfa_bytes.rs
new file mode 100644
index 0000000..0a10e03
--- /dev/null
+++ b/crates/regex/tests/test_nfa_bytes.rs
@@ -0,0 +1,55 @@
+macro_rules! regex_new {
+    ($re:expr) => {{
+        use regex::internal::ExecBuilder;
+        ExecBuilder::new($re)
+            .nfa()
+            .only_utf8(false)
+            .build()
+            .map(|e| e.into_byte_regex())
+    }};
+}
+
+macro_rules! regex {
+    ($re:expr) => {
+        regex_new!($re).unwrap()
+    };
+}
+
+macro_rules! regex_set_new {
+    ($re:expr) => {{
+        use regex::internal::ExecBuilder;
+        ExecBuilder::new_many($re)
+            .nfa()
+            .only_utf8(false)
+            .build()
+            .map(|e| e.into_byte_regex_set())
+    }};
+}
+
+macro_rules! regex_set {
+    ($res:expr) => {
+        regex_set_new!($res).unwrap()
+    };
+}
+
+// Must come before other module definitions.
+include!("macros_bytes.rs");
+include!("macros.rs");
+
+mod api;
+mod bytes;
+mod crazy;
+mod flags;
+mod fowler;
+mod multiline;
+mod noparse;
+mod regression;
+mod replace;
+mod set;
+mod suffix_reverse;
+#[cfg(feature = "unicode")]
+mod unicode;
+#[cfg(feature = "unicode-perl")]
+mod word_boundary;
+#[cfg(feature = "unicode-perl")]
+mod word_boundary_unicode;
diff --git a/crates/regex/tests/test_nfa_utf8bytes.rs b/crates/regex/tests/test_nfa_utf8bytes.rs
new file mode 100644
index 0000000..36a572b
--- /dev/null
+++ b/crates/regex/tests/test_nfa_utf8bytes.rs
@@ -0,0 +1,54 @@
+#![cfg_attr(feature = "pattern", feature(pattern))]
+
+macro_rules! regex_new {
+    ($re:expr) => {{
+        use regex::internal::ExecBuilder;
+        ExecBuilder::new($re).nfa().bytes(true).build().map(|e| e.into_regex())
+    }};
+}
+
+macro_rules! regex {
+    ($re:expr) => {
+        regex_new!($re).unwrap()
+    };
+}
+
+macro_rules! regex_set_new {
+    ($re:expr) => {{
+        use regex::internal::ExecBuilder;
+        ExecBuilder::new_many($re)
+            .nfa()
+            .bytes(true)
+            .build()
+            .map(|e| e.into_regex_set())
+    }};
+}
+
+macro_rules! regex_set {
+    ($res:expr) => {
+        regex_set_new!($res).unwrap()
+    };
+}
+
+// Must come before other module definitions.
+include!("macros_str.rs");
+include!("macros.rs");
+
+mod api;
+mod api_str;
+mod crazy;
+mod flags;
+mod fowler;
+mod multiline;
+mod noparse;
+mod regression;
+mod replace;
+mod searcher;
+mod set;
+mod suffix_reverse;
+#[cfg(feature = "unicode")]
+mod unicode;
+#[cfg(feature = "unicode-perl")]
+mod word_boundary;
+#[cfg(feature = "unicode-perl")]
+mod word_boundary_unicode;
diff --git a/crates/regex/tests/unicode.rs b/crates/regex/tests/unicode.rs
new file mode 100644
index 0000000..9b32286
--- /dev/null
+++ b/crates/regex/tests/unicode.rs
@@ -0,0 +1,251 @@
+mat!(uni_literal, r"☃", "☃", Some((0, 3)));
+mat!(uni_literal_plus, r"☃+", "☃", Some((0, 3)));
+mat!(uni_literal_casei_plus, r"(?i)☃+", "☃", Some((0, 3)));
+mat!(uni_class_plus, r"[☃Ⅰ]+", "☃", Some((0, 3)));
+mat!(uni_one, r"\pN", "Ⅰ", Some((0, 3)));
+mat!(uni_mixed, r"\pN+", "Ⅰ1Ⅱ2", Some((0, 8)));
+mat!(uni_not, r"\PN+", "abⅠ", Some((0, 2)));
+mat!(uni_not_class, r"[\PN]+", "abⅠ", Some((0, 2)));
+mat!(uni_not_class_neg, r"[^\PN]+", "abⅠ", Some((2, 5)));
+mat!(uni_case, r"(?i)Δ", "δ", Some((0, 2)));
+mat!(uni_case_upper, r"\p{Lu}+", "ΛΘΓΔα", Some((0, 8)));
+mat!(uni_case_upper_nocase_flag, r"(?i)\p{Lu}+", "ΛΘΓΔα", Some((0, 10)));
+mat!(uni_case_upper_nocase, r"\p{L}+", "ΛΘΓΔα", Some((0, 10)));
+mat!(uni_case_lower, r"\p{Ll}+", "ΛΘΓΔα", Some((8, 10)));
+
+// Test the Unicode friendliness of Perl character classes.
+mat!(uni_perl_w, r"\w+", "dδd", Some((0, 4)));
+mat!(uni_perl_w_not, r"\w+", "⥡", None);
+mat!(uni_perl_w_neg, r"\W+", "⥡", Some((0, 3)));
+mat!(uni_perl_d, r"\d+", "1२३9", Some((0, 8)));
+mat!(uni_perl_d_not, r"\d+", "Ⅱ", None);
+mat!(uni_perl_d_neg, r"\D+", "Ⅱ", Some((0, 3)));
+mat!(uni_perl_s, r"\s+", " ", Some((0, 3)));
+mat!(uni_perl_s_not, r"\s+", "☃", None);
+mat!(uni_perl_s_neg, r"\S+", "☃", Some((0, 3)));
+
+// And do the same for word boundaries.
+mat!(uni_boundary_none, r"\d\b", "6δ", None);
+mat!(uni_boundary_ogham, r"\d\b", "6 ", Some((0, 1)));
+mat!(uni_not_boundary_none, r"\d\B", "6δ", Some((0, 1)));
+mat!(uni_not_boundary_ogham, r"\d\B", "6 ", None);
+
+// Test general categories.
+//
+// We should test more, but there's a lot. Write a script to generate more of
+// these tests.
+mat!(uni_class_gencat_cased_letter, r"\p{Cased_Letter}", "Ａ", Some((0, 3)));
+mat!(
+    uni_class_gencat_close_punctuation,
+    r"\p{Close_Punctuation}",
+    "❯",
+    Some((0, 3))
+);
+mat!(
+    uni_class_gencat_connector_punctuation,
+    r"\p{Connector_Punctuation}",
+    "⁀",
+    Some((0, 3))
+);
+mat!(uni_class_gencat_control, r"\p{Control}", "\u{9f}", Some((0, 2)));
+mat!(
+    uni_class_gencat_currency_symbol,
+    r"\p{Currency_Symbol}",
+    "￡",
+    Some((0, 3))
+);
+mat!(
+    uni_class_gencat_dash_punctuation,
+    r"\p{Dash_Punctuation}",
+    "〰",
+    Some((0, 3))
+);
+mat!(uni_class_gencat_decimal_numer, r"\p{Decimal_Number}", "𑓙", Some((0, 4)));
+mat!(
+    uni_class_gencat_enclosing_mark,
+    r"\p{Enclosing_Mark}",
+    "\u{A672}",
+    Some((0, 3))
+);
+mat!(
+    uni_class_gencat_final_punctuation,
+    r"\p{Final_Punctuation}",
+    "⸡",
+    Some((0, 3))
+);
+mat!(uni_class_gencat_format, r"\p{Format}", "\u{E007F}", Some((0, 4)));
+// See: https://github.com/rust-lang/regex/issues/719
+mat!(uni_class_gencat_format_abbrev1, r"\p{cf}", "\u{E007F}", Some((0, 4)));
+mat!(uni_class_gencat_format_abbrev2, r"\p{gc=cf}", "\u{E007F}", Some((0, 4)));
+mat!(
+    uni_class_gencat_initial_punctuation,
+    r"\p{Initial_Punctuation}",
+    "⸜",
+    Some((0, 3))
+);
+mat!(uni_class_gencat_letter, r"\p{Letter}", "Έ", Some((0, 2)));
+mat!(uni_class_gencat_letter_number, r"\p{Letter_Number}", "ↂ", Some((0, 3)));
+mat!(
+    uni_class_gencat_line_separator,
+    r"\p{Line_Separator}",
+    "\u{2028}",
+    Some((0, 3))
+);
+mat!(
+    uni_class_gencat_lowercase_letter,
+    r"\p{Lowercase_Letter}",
+    "ϛ",
+    Some((0, 2))
+);
+mat!(uni_class_gencat_mark, r"\p{Mark}", "\u{E01EF}", Some((0, 4)));
+mat!(uni_class_gencat_math, r"\p{Math}", "⋿", Some((0, 3)));
+mat!(
+    uni_class_gencat_modifier_letter,
+    r"\p{Modifier_Letter}",
+    "𖭃",
+    Some((0, 4))
+);
+mat!(
+    uni_class_gencat_modifier_symbol,
+    r"\p{Modifier_Symbol}",
+    "🏿",
+    Some((0, 4))
+);
+mat!(
+    uni_class_gencat_nonspacing_mark,
+    r"\p{Nonspacing_Mark}",
+    "\u{1E94A}",
+    Some((0, 4))
+);
+mat!(uni_class_gencat_number, r"\p{Number}", "⓿", Some((0, 3)));
+mat!(
+    uni_class_gencat_open_punctuation,
+    r"\p{Open_Punctuation}",
+    "｟",
+    Some((0, 3))
+);
+mat!(uni_class_gencat_other, r"\p{Other}", "\u{bc9}", Some((0, 3)));
+mat!(uni_class_gencat_other_letter, r"\p{Other_Letter}", "ꓷ", Some((0, 3)));
+mat!(uni_class_gencat_other_number, r"\p{Other_Number}", "㉏", Some((0, 3)));
+mat!(
+    uni_class_gencat_other_punctuation,
+    r"\p{Other_Punctuation}",
+    "𞥞",
+    Some((0, 4))
+);
+mat!(uni_class_gencat_other_symbol, r"\p{Other_Symbol}", "⅌", Some((0, 3)));
+mat!(
+    uni_class_gencat_paragraph_separator,
+    r"\p{Paragraph_Separator}",
+    "\u{2029}",
+    Some((0, 3))
+);
+mat!(
+    uni_class_gencat_private_use,
+    r"\p{Private_Use}",
+    "\u{10FFFD}",
+    Some((0, 4))
+);
+mat!(uni_class_gencat_punctuation, r"\p{Punctuation}", "𑁍", Some((0, 4)));
+mat!(uni_class_gencat_separator, r"\p{Separator}", "\u{3000}", Some((0, 3)));
+mat!(
+    uni_class_gencat_space_separator,
+    r"\p{Space_Separator}",
+    "\u{205F}",
+    Some((0, 3))
+);
+mat!(
+    uni_class_gencat_spacing_mark,
+    r"\p{Spacing_Mark}",
+    "\u{16F7E}",
+    Some((0, 4))
+);
+mat!(uni_class_gencat_symbol, r"\p{Symbol}", "⯈", Some((0, 3)));
+mat!(
+    uni_class_gencat_titlecase_letter,
+    r"\p{Titlecase_Letter}",
+    "ῼ",
+    Some((0, 3))
+);
+mat!(
+    uni_class_gencat_unassigned,
+    r"\p{Unassigned}",
+    "\u{10FFFF}",
+    Some((0, 4))
+);
+mat!(
+    uni_class_gencat_uppercase_letter,
+    r"\p{Uppercase_Letter}",
+    "Ꝋ",
+    Some((0, 3))
+);
+
+// Test a smattering of properties.
+mat!(uni_class_prop_emoji1, r"\p{Emoji}", "\u{23E9}", Some((0, 3)));
+mat!(uni_class_prop_emoji2, r"\p{emoji}", "\u{1F21A}", Some((0, 4)));
+mat!(
+    uni_class_prop_picto1,
+    r"\p{extendedpictographic}",
+    "\u{1FA6E}",
+    Some((0, 4))
+);
+mat!(
+    uni_class_prop_picto2,
+    r"\p{extendedpictographic}",
+    "\u{1FFFD}",
+    Some((0, 4))
+);
+
+// grapheme_cluster_break
+mat!(
+    uni_class_gcb_prepend,
+    r"\p{grapheme_cluster_break=prepend}",
+    "\u{11D46}",
+    Some((0, 4))
+);
+mat!(
+    uni_class_gcb_ri1,
+    r"\p{gcb=regional_indicator}",
+    "\u{1F1E6}",
+    Some((0, 4))
+);
+mat!(uni_class_gcb_ri2, r"\p{gcb=ri}", "\u{1F1E7}", Some((0, 4)));
+mat!(
+    uni_class_gcb_ri3,
+    r"\p{gcb=regionalindicator}",
+    "\u{1F1FF}",
+    Some((0, 4))
+);
+mat!(uni_class_gcb_lvt, r"\p{gcb=lvt}", "\u{C989}", Some((0, 3)));
+mat!(uni_class_gcb_zwj, r"\p{gcb=zwj}", "\u{200D}", Some((0, 3)));
+
+// word_break
+mat!(uni_class_wb1, r"\p{word_break=Hebrew_Letter}", "\u{FB46}", Some((0, 3)));
+mat!(uni_class_wb2, r"\p{wb=hebrewletter}", "\u{FB46}", Some((0, 3)));
+mat!(uni_class_wb3, r"\p{wb=ExtendNumLet}", "\u{FF3F}", Some((0, 3)));
+mat!(uni_class_wb4, r"\p{wb=WSegSpace}", "\u{3000}", Some((0, 3)));
+mat!(uni_class_wb5, r"\p{wb=numeric}", "\u{1E950}", Some((0, 4)));
+
+// sentence_break
+mat!(uni_class_sb1, r"\p{sentence_break=Lower}", "\u{0469}", Some((0, 2)));
+mat!(uni_class_sb2, r"\p{sb=lower}", "\u{0469}", Some((0, 2)));
+mat!(uni_class_sb3, r"\p{sb=Close}", "\u{FF60}", Some((0, 3)));
+mat!(uni_class_sb4, r"\p{sb=Close}", "\u{1F677}", Some((0, 4)));
+mat!(uni_class_sb5, r"\p{sb=SContinue}", "\u{FF64}", Some((0, 3)));
+
+// Test 'Vithkuqi' support, which was added in Unicode 14.
+// See: https://github.com/rust-lang/regex/issues/877
+mat!(
+    uni_vithkuqi_literal_upper,
+    r"(?i)^\u{10570}$",
+    "\u{10570}",
+    Some((0, 4))
+);
+mat!(
+    uni_vithkuqi_literal_lower,
+    r"(?i)^\u{10570}$",
+    "\u{10597}",
+    Some((0, 4))
+);
+mat!(uni_vithkuqi_word_upper, r"^\w$", "\u{10570}", Some((0, 4)));
+mat!(uni_vithkuqi_word_lower, r"^\w$", "\u{10597}", Some((0, 4)));
diff --git a/crates/regex/tests/word_boundary.rs b/crates/regex/tests/word_boundary.rs
new file mode 100644
index 0000000..7fe97a2
--- /dev/null
+++ b/crates/regex/tests/word_boundary.rs
@@ -0,0 +1,89 @@
+// Many of these are cribbed from RE2's test suite.
+
+matiter!(wb1, r"\b", "");
+matiter!(wb2, r"\b", "a", (0, 0), (1, 1));
+matiter!(wb3, r"\b", "ab", (0, 0), (2, 2));
+matiter!(wb4, r"^\b", "ab", (0, 0));
+matiter!(wb5, r"\b$", "ab", (2, 2));
+matiter!(wb6, r"^\b$", "ab");
+matiter!(wb7, r"\bbar\b", "nobar bar foo bar", (6, 9), (14, 17));
+matiter!(wb8, r"a\b", "faoa x", (3, 4));
+matiter!(wb9, r"\bbar", "bar x", (0, 3));
+matiter!(wb10, r"\bbar", "foo\nbar x", (4, 7));
+matiter!(wb11, r"bar\b", "foobar", (3, 6));
+matiter!(wb12, r"bar\b", "foobar\nxxx", (3, 6));
+matiter!(wb13, r"(foo|bar|[A-Z])\b", "foo", (0, 3));
+matiter!(wb14, r"(foo|bar|[A-Z])\b", "foo\n", (0, 3));
+matiter!(wb15, r"\b(foo|bar|[A-Z])", "foo", (0, 3));
+matiter!(wb16, r"\b(foo|bar|[A-Z])\b", "X", (0, 1));
+matiter!(wb17, r"\b(foo|bar|[A-Z])\b", "XY");
+matiter!(wb18, r"\b(foo|bar|[A-Z])\b", "bar", (0, 3));
+matiter!(wb19, r"\b(foo|bar|[A-Z])\b", "foo", (0, 3));
+matiter!(wb20, r"\b(foo|bar|[A-Z])\b", "foo\n", (0, 3));
+matiter!(wb21, r"\b(foo|bar|[A-Z])\b", "ffoo bbar N x", (10, 11));
+matiter!(wb22, r"\b(fo|foo)\b", "fo", (0, 2));
+matiter!(wb23, r"\b(fo|foo)\b", "foo", (0, 3));
+matiter!(wb24, r"\b\b", "");
+matiter!(wb25, r"\b\b", "a", (0, 0), (1, 1));
+matiter!(wb26, r"\b$", "");
+matiter!(wb27, r"\b$", "x", (1, 1));
+matiter!(wb28, r"\b$", "y x", (3, 3));
+matiter!(wb29, r"\b.$", "x", (0, 1));
+matiter!(wb30, r"^\b(fo|foo)\b", "fo", (0, 2));
+matiter!(wb31, r"^\b(fo|foo)\b", "foo", (0, 3));
+matiter!(wb32, r"^\b$", "");
+matiter!(wb33, r"^\b$", "x");
+matiter!(wb34, r"^\b.$", "x", (0, 1));
+matiter!(wb35, r"^\b.\b$", "x", (0, 1));
+matiter!(wb36, r"^^^^^\b$$$$$", "");
+matiter!(wb37, r"^^^^^\b.$$$$$", "x", (0, 1));
+matiter!(wb38, r"^^^^^\b$$$$$", "x");
+matiter!(wb39, r"^^^^^\b\b\b.\b\b\b$$$$$", "x", (0, 1));
+matiter!(wb40, r"\b.+\b", "$$abc$$", (2, 5));
+matiter!(wb41, r"\b", "a b c", (0, 0), (1, 1), (2, 2), (3, 3), (4, 4), (5, 5));
+
+matiter!(nb1, r"\Bfoo\B", "n foo xfoox that", (7, 10));
+matiter!(nb2, r"a\B", "faoa x", (1, 2));
+matiter!(nb3, r"\Bbar", "bar x");
+matiter!(nb4, r"\Bbar", "foo\nbar x");
+matiter!(nb5, r"bar\B", "foobar");
+matiter!(nb6, r"bar\B", "foobar\nxxx");
+matiter!(nb7, r"(foo|bar|[A-Z])\B", "foox", (0, 3));
+matiter!(nb8, r"(foo|bar|[A-Z])\B", "foo\n");
+matiter!(nb9, r"\B", "", (0, 0));
+matiter!(nb10, r"\B", "x");
+matiter!(nb11, r"\B(foo|bar|[A-Z])", "foo");
+matiter!(nb12, r"\B(foo|bar|[A-Z])\B", "xXy", (1, 2));
+matiter!(nb13, r"\B(foo|bar|[A-Z])\B", "XY");
+matiter!(nb14, r"\B(foo|bar|[A-Z])\B", "XYZ", (1, 2));
+matiter!(nb15, r"\B(foo|bar|[A-Z])\B", "abara", (1, 4));
+matiter!(nb16, r"\B(foo|bar|[A-Z])\B", "xfoo_", (1, 4));
+matiter!(nb17, r"\B(foo|bar|[A-Z])\B", "xfoo\n");
+matiter!(nb18, r"\B(foo|bar|[A-Z])\B", "foo bar vNX", (9, 10));
+matiter!(nb19, r"\B(fo|foo)\B", "xfoo", (1, 3));
+matiter!(nb20, r"\B(foo|fo)\B", "xfooo", (1, 4));
+matiter!(nb21, r"\B\B", "", (0, 0));
+matiter!(nb22, r"\B\B", "x");
+matiter!(nb23, r"\B$", "", (0, 0));
+matiter!(nb24, r"\B$", "x");
+matiter!(nb25, r"\B$", "y x");
+matiter!(nb26, r"\B.$", "x");
+matiter!(nb27, r"^\B(fo|foo)\B", "fo");
+matiter!(nb28, r"^\B(fo|foo)\B", "foo");
+matiter!(nb29, r"^\B", "", (0, 0));
+matiter!(nb30, r"^\B", "x");
+matiter!(nb31, r"^\B\B", "", (0, 0));
+matiter!(nb32, r"^\B\B", "x");
+matiter!(nb33, r"^\B$", "", (0, 0));
+matiter!(nb34, r"^\B$", "x");
+matiter!(nb35, r"^\B.$", "x");
+matiter!(nb36, r"^\B.\B$", "x");
+matiter!(nb37, r"^^^^^\B$$$$$", "", (0, 0));
+matiter!(nb38, r"^^^^^\B.$$$$$", "x");
+matiter!(nb39, r"^^^^^\B$$$$$", "x");
+
+// These work for both Unicode and ASCII because all matches are reported as
+// byte offsets, and « and » do not correspond to word boundaries at either
+// the character or byte level.
+matiter!(unicode1, r"\bx\b", "«x", (2, 3));
+matiter!(unicode2, r"\bx\b", "x»", (0, 1));
diff --git a/crates/regex/tests/word_boundary_ascii.rs b/crates/regex/tests/word_boundary_ascii.rs
new file mode 100644
index 0000000..5a3cf11
--- /dev/null
+++ b/crates/regex/tests/word_boundary_ascii.rs
@@ -0,0 +1,9 @@
+// ASCII word boundaries are completely oblivious to Unicode characters.
+// For Unicode word boundaries, the tests are precisely inverted.
+matiter!(ascii1, r"(?-u:\b)x(?-u:\b)", "áxβ", (2, 3));
+matiter!(ascii2, r"(?-u:\B)x(?-u:\B)", "áxβ");
+matiter!(ascii3, r"(?-u:\B)", "0\u{7EF5E}", (2, 2), (3, 3), (4, 4), (5, 5));
+
+// We still get Unicode word boundaries by default in byte regexes.
+matiter!(unicode1, r"\bx\b", "áxβ");
+matiter!(unicode2, r"\Bx\B", "áxβ", (2, 3));
diff --git a/crates/regex/tests/word_boundary_unicode.rs b/crates/regex/tests/word_boundary_unicode.rs
new file mode 100644
index 0000000..c41355f
--- /dev/null
+++ b/crates/regex/tests/word_boundary_unicode.rs
@@ -0,0 +1,6 @@
+// Unicode word boundaries know about Unicode characters.
+// For ASCII word boundaries, the tests are precisely inverted.
+matiter!(unicode1, r"\bx\b", "áxβ");
+matiter!(unicode2, r"\Bx\B", "áxβ", (2, 3));
+
+matiter!(ascii1, r"(?-u:\b)x(?-u:\b)", "áxβ", (2, 3));
diff --git a/crates/rusqlite/.cargo-checksum.json b/crates/rusqlite/.cargo-checksum.json
new file mode 100644
index 0000000..7634074
--- /dev/null
+++ b/crates/rusqlite/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"6518e8f2449d7014eefe83bdd0733c7d24d12da812cd5ac74bdde16cde06c070","LICENSE":"f59ba65550f2a5adff98ec6478d783402c8e0a3eb515025c0b3438f3d30dc39e","README.md":"4a43ecb9bbc50369389796b214ec58d81920b01e420433b77d2eab01cd5617a6","benches/cache.rs":"30459d8d7f65dd684909a53590f9be32e2e545a0775cd93ee0ce85dd08410955","benches/exec.rs":"a9f5e209dbfc73d1ee574608e0105a6c317b83f73d873ea8afd8b60e07cbc8d7","src/backup.rs":"d4b91a5d103e7f6d4607bd186108f3460c698b6740366a8e7224778ba3c3a883","src/blob/mod.rs":"e7c657319328f8f98ac10ed1d5327b0b4e0b9211179f4a479dfd5fc68228a614","src/blob/pos_io.rs":"688513c4ca0d64d79555cb6fd8e75c0b41dceae7b10ae95e37c106ee93411dac","src/busy.rs":"023126c083ef6788c1e0d2aac657cebf2a92613a47234065de7d7b8919eb7bb7","src/cache.rs":"8ec872e864fd1f8234ebab72f0b0dae63a6ea0a8ffe635652c3c079cfeb8f210","src/collation.rs":"5918eaa233acb6f205131a9ee0fc933d7b26a0c7f5965f30e8e2f9a0f34f9230","src/column.rs":"422082295810c9b4d2a90543e04b82e496a61f51cfb730d3a2171cd2c6ff3afc","src/config.rs":"3e50acaac069d89f0f045e31980816c6d9151b46321f2c5b07505933dedcfe5f","src/context.rs":"8dd0235e61c2c70617c14c8136dc8ae4ea3e61e6aca1177ce8c04edfbcbeebc3","src/error.rs":"26c74a93c8e16199b2d60f3c2d7b3f980a586e7a67bcacb1a17e69e6a13af5a0","src/functions.rs":"7a214b5480a4c0377d30993f2fbdc70c3cc451c6213406af88367739e541d914","src/hooks.rs":"bae0121290ed920c7e96f9d777cfeeb21a0f9cf9b281590d6831cce659babda8","src/inner_connection.rs":"2e412e428daa4b394aa1675bc2acb52a302c9b8845dad6efea138e2689a01677","src/lib.rs":"1daaea6bbfc9422581b2ee1259a0d154c0d88f9ed4c97c2c5672745c7c8ce6e6","src/limits.rs":"febcf841b690d82dd74c1704bc507c34d91f331714ef18cbba1b0236dc4f9897","src/load_extension_guard.rs":"9a75592bb26ccf22d4165b14779ca64a2f07d3358efbea60f7dea4b8c398e00a","src/params.rs":"c54d679576f795cacb8775d4eaefbe2b951d869c986e8245f37a98d9af0582ab","src/pragma.rs":"b906dc6034a57334b771766247147fc4088269f437064334cb94878d649ea53a","src/raw_statement.rs":"3bd688e59ad8285ea9a696a515b50f2a96468a1272d55e902a699616fbd746e3","src/row.rs":"d2590d133be5a40ce93f63c3204aab8c0ea4e6163bb61573ef95115edd5d93ef","src/session.rs":"52c530b56ec2ed0d78fd833ecf5dfbcfccdcc89ee02c0702f40ee711d3dd4349","src/statement.rs":"c31fcd7bd93fb8e841e8de990f7f4f17fa2073043fea9552f3ab2edebaebfce0","src/trace.rs":"f027c73c8b992ddc23b604e4c0af0b370ef2841bb6da200e4b3615fb02708f2a","src/transaction.rs":"62a2fa1eaf758898c0a59643c79d58c1c05b4c2b93c7f22111a19a539d838f0a","src/types/chrono.rs":"d924bbc2b6177d51ed02bb0f444a079b991040b6485dfaea11859c936ac679e6","src/types/from_sql.rs":"99d9f6dd87705d5a81237d4e5c2aebc389825356e392576a4fb03b4d2046c8ae","src/types/mod.rs":"f74a40bfbff4baf7154d5cee528d539c284b70e80bba923ea3702447a7acb913","src/types/serde_json.rs":"a50ce89fc59ae038ab4ff04f0dbdda467fb925b584419a727e04c9a293c6fe9b","src/types/time.rs":"5be63e2b7f7f559516c3c695a79593352f8e7190b43ded0c8bd68d9dcee9478e","src/types/to_sql.rs":"a654e432cdddd49bac08f8f31819cbec27f6a64473ec9193045f99e47e13991a","src/types/url.rs":"fbcbe2fc87a80259ea8356c712fe8e66a4c151c10aa882059577e66735658ee5","src/types/value.rs":"d39f51cfe31f57e6030927ed70e87150b466f4826e79281562645a574a4bc314","src/types/value_ref.rs":"baf9f005807871cffabe16465f4e145661e22798ca6c304f37ec182737d43858","src/unlock_notify.rs":"c5a7b3413d863b4c87b0ee42fa817c04a277022cd24facfcc0dd2c641c2ca3af","src/util/mod.rs":"e11b0f4f376bdc37233c969bef74170559ea45e05f129b9aa26462f16fd49f41","src/util/param_cache.rs":"efb480749cd74c09aeca28be074050e3a9aed7c8ed1371ca562342cba9c408dd","src/util/small_cstr.rs":"634f43a03d41ecb6515ff39303e01242b9dc774c17de9177a0a07a5812c0f777","src/util/sqlite_string.rs":"72b286d1941d7ee5522eeaa63dc4273998f0292cab2bc3c322b680fba730ba23","src/version.rs":"cafb486b8478260da2ff08c090e635511f4024516b6cc719abb2135e1e196a9d","src/vtab/array.rs":"a51ce401ed4029a22a93ac03f235a9349087581338edd46a8582e5bf869e4cc8","src/vtab/csvtab.rs":"89e61421b9f6703aa2f98131357dfa5a0510e60cdf54c51d4e7515ab10ed0a3e","src/vtab/mod.rs":"d581d7f3adf5f7ca675803a89e89c38ae21d54f6ac4ca7775517d83cf157d8d3","src/vtab/series.rs":"91a9f8936bcb8c3af38327c273844e51ef87fc3296663f666bdc46bd20c2a969","src/vtab/vtablog.rs":"a6ab41b0c2684c5b5487bd7576e2d43d5e4debf46e4240a285e499198f6b380c","test.csv":"3f5649d7b9f80468999b80d4d0e747c6f4f1bba80ade792689eeb4359dc1834a","tests/config_log.rs":"e786bb1a0ca1b560788b24a2091e7d294753a7bee8a39f0e6037b435809267df","tests/deny_single_threaded_sqlite_config.rs":"00ae6266bc3549bb5bf835297ded79fba55f60e3be9ee030a0ece3cbb7a59803","tests/vtab.rs":"a66ee6d79ea156585a10d770fff31f122d968c2f2f20790aa83a73b5cc8e6405"},"package":"549b9d036d571d42e6e85d1c1425e2ac83491075078ca9a15be021c56b1641f2"}
\ No newline at end of file
diff --git a/crates/rusqlite/Android.bp b/crates/rusqlite/Android.bp
new file mode 100644
index 0000000..47ebcb3
--- /dev/null
+++ b/crates/rusqlite/Android.bp
@@ -0,0 +1,42 @@
+// This file is generated by cargo_embargo.
+// Do not modify this file because the changes will be overridden on upgrade.
+
+package {
+    default_applicable_licenses: ["external_rust_crates_rusqlite_license"],
+    default_team: "trendy_team_android_rust",
+}
+
+license {
+    name: "external_rust_crates_rusqlite_license",
+    visibility: [":__subpackages__"],
+    license_kinds: ["SPDX-license-identifier-MIT"],
+    license_text: ["LICENSE"],
+}
+
+rust_library {
+    name: "librusqlite",
+    host_supported: true,
+    crate_name: "rusqlite",
+    cargo_env_compat: true,
+    cargo_pkg_version: "0.29.0",
+    crate_root: "src/lib.rs",
+    edition: "2018",
+    features: [
+        "modern_sqlite",
+        "trace",
+    ],
+    rustlibs: [
+        "libbitflags",
+        "libfallible_iterator",
+        "libfallible_streaming_iterator",
+        "libhashlink",
+        "liblibsqlite3_sys",
+        "libsmallvec",
+    ],
+    apex_available: [
+        "//apex_available:platform",
+        "//apex_available:anyapex",
+    ],
+    product_available: true,
+    vendor_available: true,
+}
diff --git a/crates/rusqlite/Cargo.lock b/crates/rusqlite/Cargo.lock
new file mode 100644
index 0000000..2ba0d43
--- /dev/null
+++ b/crates/rusqlite/Cargo.lock
@@ -0,0 +1,902 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "ahash"
+version = "0.8.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e89da841a80418a9b391ebaea17f5c112ffaaa96f621d2c285b5174da76b9011"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "version_check",
+ "zerocopy",
+]
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "allocator-api2"
+version = "0.2.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c6cb57a04249c6480766f7f7cef5467412af1490f8d1e243141daddada3264f"
+
+[[package]]
+name = "android-tzdata"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0"
+
+[[package]]
+name = "android_system_properties"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0"
+
+[[package]]
+name = "bencher"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7dfdb4953a096c551ce9ace855a604d702e6e62d77fac690575ae347571717f5"
+
+[[package]]
+name = "bindgen"
+version = "0.64.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4243e6031260db77ede97ad86c27e501d646a27ab57b59a574f725d98ab1fb4"
+dependencies = [
+ "bitflags 1.3.2",
+ "cexpr",
+ "clang-sys",
+ "lazy_static",
+ "lazycell",
+ "peeking_take_while",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "rustc-hash",
+ "shlex",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "bitflags"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
+
+[[package]]
+name = "bumpalo"
+version = "3.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c"
+
+[[package]]
+name = "cc"
+version = "1.1.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57b6a275aa2903740dc87da01c62040406b8812552e97129a63ea8850a17c6e6"
+dependencies = [
+ "shlex",
+]
+
+[[package]]
+name = "cexpr"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766"
+dependencies = [
+ "nom",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "chrono"
+version = "0.4.38"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a21f936df1771bf62b77f047b726c4625ff2e8aa607c01ec06e5a05bd8463401"
+dependencies = [
+ "android-tzdata",
+ "iana-time-zone",
+ "num-traits",
+ "windows-targets",
+]
+
+[[package]]
+name = "clang-sys"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b023947811758c97c59bf9d1c188fd619ad4718dcaa767947df1cadb14f39f4"
+dependencies = [
+ "glob",
+ "libc",
+ "libloading",
+]
+
+[[package]]
+name = "core-foundation-sys"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
+
+[[package]]
+name = "csv"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac574ff4d437a7b5ad237ef331c17ccca63c46479e5b5453eb8e10bb99a759fe"
+dependencies = [
+ "csv-core",
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "csv-core"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5efa2b3d7902f4b634a20cae3c9c4e6209dc4779feb6863329607560143efa70"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "deranged"
+version = "0.3.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4"
+dependencies = [
+ "powerfmt",
+]
+
+[[package]]
+name = "doc-comment"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fea41bba32d969b513997752735605054bc0dfa92b4c56bf1189f2e174be7a10"
+
+[[package]]
+name = "errno"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "534c5cf6194dfab3db3242765c03bbe257cf92f22b38f6bc0c58d59108a820ba"
+dependencies = [
+ "libc",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "fallible-iterator"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4443176a9f2c162692bd3d352d745ef9413eec5782a80d8fd6f8a1ac692a07f7"
+
+[[package]]
+name = "fallible-streaming-iterator"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a"
+
+[[package]]
+name = "fastrand"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e8c02a5121d4ea3eb16a80748c74f5549a5665e4c21333c6098f283870fbdea6"
+
+[[package]]
+name = "form_urlencoded"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e13624c2627564efccf4934284bdd98cbaa14e79b0b5a141218e507b3a823456"
+dependencies = [
+ "percent-encoding",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "glob"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"
+
+[[package]]
+name = "hashbrown"
+version = "0.14.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
+dependencies = [
+ "ahash",
+ "allocator-api2",
+]
+
+[[package]]
+name = "hashlink"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e8094feaf31ff591f651a2664fb9cfd92bba7a60ce3197265e9482ebe753c8f7"
+dependencies = [
+ "hashbrown",
+]
+
+[[package]]
+name = "iana-time-zone"
+version = "0.1.60"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7ffbb5a1b541ea2561f8c41c087286cc091e21e556a4f09a8f6cbf17b69b141"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "wasm-bindgen",
+ "windows-core",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "idna"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "634d9b1461af396cad843f47fdba5597a4f9e6ddd4bfb6ff5d85028c25cb12f6"
+dependencies = [
+ "unicode-bidi",
+ "unicode-normalization",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
+
+[[package]]
+name = "js-sys"
+version = "0.3.70"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1868808506b929d7b0cfa8f75951347aa71bb21144b7791bae35d9bccfcfe37a"
+dependencies = [
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+
+[[package]]
+name = "lazycell"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
+
+[[package]]
+name = "libc"
+version = "0.2.158"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439"
+
+[[package]]
+name = "libloading"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4979f22fdb869068da03c9f7528f8297c6fd2606bc3a4affe42e6a823fdb8da4"
+dependencies = [
+ "cfg-if",
+ "windows-targets",
+]
+
+[[package]]
+name = "libsqlite3-sys"
+version = "0.26.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "afc22eff61b133b115c6e8c74e818c628d6d5e7a502afea6f64dee076dd94326"
+dependencies = [
+ "bindgen",
+ "cc",
+ "openssl-sys",
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89"
+
+[[package]]
+name = "log"
+version = "0.4.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
+
+[[package]]
+name = "memchr"
+version = "2.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
+
+[[package]]
+name = "minimal-lexical"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
+
+[[package]]
+name = "nom"
+version = "7.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
+dependencies = [
+ "memchr",
+ "minimal-lexical",
+]
+
+[[package]]
+name = "num-conv"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
+
+[[package]]
+name = "openssl-src"
+version = "300.3.1+3.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7259953d42a81bf137fbbd73bd30a8e1914d6dce43c2b90ed575783a22608b91"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "openssl-sys"
+version = "0.9.103"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f9e8deee91df40a943c71b917e5874b951d32a802526c85721ce3b776c929d6"
+dependencies = [
+ "cc",
+ "libc",
+ "openssl-src",
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
+name = "peeking_take_while"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19b17cddbe7ec3f8bc800887bab5e717348c95ea2ca0b1bf0837fb964dc67099"
+
+[[package]]
+name = "percent-encoding"
+version = "2.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"
+
+[[package]]
+name = "pkg-config"
+version = "0.3.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec"
+
+[[package]]
+name = "powerfmt"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.86"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "regex"
+version = "1.10.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4219d74c6b67a3654a9fbebc4b419e22126d13d2f3c4a07ee0cb61ff79a79619"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38caf58cc5ef2fed281f89292ef23f6365465ed9a41b7a7754eb4e26496c92df"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a66a03ae7c801facd77a29370b4faec201768915ac14a721ba36f20bc9c209b"
+
+[[package]]
+name = "rusqlite"
+version = "0.29.0"
+dependencies = [
+ "bencher",
+ "bitflags 2.6.0",
+ "chrono",
+ "csv",
+ "doc-comment",
+ "fallible-iterator",
+ "fallible-streaming-iterator",
+ "hashlink",
+ "lazy_static",
+ "libsqlite3-sys",
+ "regex",
+ "serde_json",
+ "smallvec",
+ "tempfile",
+ "time",
+ "unicase",
+ "url",
+ "uuid",
+]
+
+[[package]]
+name = "rustc-hash"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
+
+[[package]]
+name = "rustix"
+version = "0.38.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a85d50532239da68e9addb745ba38ff4612a242c1c7ceea689c4bc7c2f43c36f"
+dependencies = [
+ "bitflags 2.6.0",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "ryu"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
+
+[[package]]
+name = "serde"
+version = "1.0.209"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "99fce0ffe7310761ca6bf9faf5115afbc19688edd00171d81b1bb1b116c63e09"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.209"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5831b979fd7b5439637af1752d535ff49f4860c0f341d1baeb6faf0f4242170"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.76",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.127"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8043c06d9f82bd7271361ed64f415fe5e12a77fdb52e573e7f06a516dea329ad"
+dependencies = [
+ "itoa",
+ "memchr",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "smallvec"
+version = "1.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
+
+[[package]]
+name = "syn"
+version = "1.0.109"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.76"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "578e081a14e0cefc3279b0472138c513f37b41a08d5a3cca9b6e4e8ceb6cd525"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "tempfile"
+version = "3.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04cbcdd0c794ebb0d4cf35e88edd2f7d2c4c3e9a5a6dab322839b321c6a87a64"
+dependencies = [
+ "cfg-if",
+ "fastrand",
+ "once_cell",
+ "rustix",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "time"
+version = "0.3.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5dfd88e563464686c916c7e46e623e520ddc6d79fa6641390f2e3fa86e83e885"
+dependencies = [
+ "deranged",
+ "itoa",
+ "num-conv",
+ "powerfmt",
+ "serde",
+ "time-core",
+ "time-macros",
+]
+
+[[package]]
+name = "time-core"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef927ca75afb808a4d64dd374f00a2adf8d0fcff8e7b184af886c3c87ec4a3f3"
+
+[[package]]
+name = "time-macros"
+version = "0.2.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f252a68540fde3a3877aeea552b832b40ab9a69e318efd078774a01ddee1ccf"
+dependencies = [
+ "num-conv",
+ "time-core",
+]
+
+[[package]]
+name = "tinyvec"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "445e881f4f6d382d5f27c034e25eb92edd7c784ceab92a0937db7f2e9471b938"
+dependencies = [
+ "tinyvec_macros",
+]
+
+[[package]]
+name = "tinyvec_macros"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
+
+[[package]]
+name = "unicase"
+version = "2.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7d2d4dafb69621809a81864c9c1b864479e1235c0dd4e199924b9742439ed89"
+dependencies = [
+ "version_check",
+]
+
+[[package]]
+name = "unicode-bidi"
+version = "0.3.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08f95100a766bf4f8f28f90d77e0a5461bbdb219042e7679bebe79004fed8d75"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
+
+[[package]]
+name = "unicode-normalization"
+version = "0.1.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a56d1686db2308d901306f92a263857ef59ea39678a5458e7cb17f01415101f5"
+dependencies = [
+ "tinyvec",
+]
+
+[[package]]
+name = "url"
+version = "2.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22784dbdf76fdde8af1aeda5622b546b422b6fc585325248a2bf9f5e41e94d6c"
+dependencies = [
+ "form_urlencoded",
+ "idna",
+ "percent-encoding",
+]
+
+[[package]]
+name = "uuid"
+version = "1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "81dfa00651efa65069b0b6b651f4aaa31ba9e3c3ce0137aaad053604ee7e0314"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "vcpkg"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.93"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a82edfc16a6c469f5f44dc7b571814045d60404b55a0ee849f9bcfa2e63dd9b5"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "wasm-bindgen-macro",
+]
+
+[[package]]
+name = "wasm-bindgen-backend"
+version = "0.2.93"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9de396da306523044d3302746f1208fa71d7532227f15e347e2d93e4145dd77b"
+dependencies = [
+ "bumpalo",
+ "log",
+ "once_cell",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.76",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.93"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "585c4c91a46b072c92e908d99cb1dcdf95c5218eeb6f3bf1efa991ee7a68cccf"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.93"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "afc340c74d9005395cf9dd098506f7f44e38f2b4a21c6aaacf9a105ea5e1e836"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.76",
+ "wasm-bindgen-backend",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.93"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c62a0a307cb4a311d3a07867860911ca130c3494e8c2719593806c08bc5d0484"
+
+[[package]]
+name = "windows-core"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
+dependencies = [
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+dependencies = [
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+
+[[package]]
+name = "zerocopy"
+version = "0.7.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.7.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.76",
+]
diff --git a/crates/rusqlite/Cargo.toml b/crates/rusqlite/Cargo.toml
new file mode 100644
index 0000000..28b8336
--- /dev/null
+++ b/crates/rusqlite/Cargo.toml
@@ -0,0 +1,229 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2018"
+name = "rusqlite"
+version = "0.29.0"
+authors = ["The rusqlite developers"]
+exclude = [
+    "/.github/*",
+    "/.gitattributes",
+    "/appveyor.yml",
+    "/Changelog.md",
+    "/clippy.toml",
+    "/codecov.yml",
+]
+description = "Ergonomic wrapper for SQLite"
+documentation = "http://docs.rs/rusqlite/"
+readme = "README.md"
+keywords = [
+    "sqlite",
+    "database",
+    "ffi",
+]
+categories = ["database"]
+license = "MIT"
+repository = "https://github.com/rusqlite/rusqlite"
+
+[package.metadata.docs.rs]
+all-features = false
+default-target = "x86_64-unknown-linux-gnu"
+features = ["modern-full"]
+no-default-features = true
+rustdoc-args = [
+    "--cfg",
+    "docsrs",
+]
+
+[package.metadata.playground]
+all-features = false
+features = ["bundled-full"]
+
+[lib]
+name = "rusqlite"
+
+[[test]]
+name = "config_log"
+harness = false
+
+[[test]]
+name = "deny_single_threaded_sqlite_config"
+
+[[test]]
+name = "vtab"
+
+[[bench]]
+name = "cache"
+harness = false
+
+[[bench]]
+name = "exec"
+harness = false
+
+[dependencies.bitflags]
+version = "2.0"
+
+[dependencies.chrono]
+version = "0.4"
+features = ["clock"]
+optional = true
+default-features = false
+
+[dependencies.csv]
+version = "1.1"
+optional = true
+
+[dependencies.fallible-iterator]
+version = "0.2"
+
+[dependencies.fallible-streaming-iterator]
+version = "0.1"
+
+[dependencies.hashlink]
+version = "0.8"
+
+[dependencies.libsqlite3-sys]
+version = "0.26.0"
+
+[dependencies.serde_json]
+version = "1.0"
+optional = true
+
+[dependencies.smallvec]
+version = "1.6.1"
+
+[dependencies.time]
+version = "0.3.0"
+features = [
+    "formatting",
+    "macros",
+    "parsing",
+]
+optional = true
+
+[dependencies.url]
+version = "2.1"
+optional = true
+
+[dependencies.uuid]
+version = "1.0"
+optional = true
+
+[dev-dependencies.bencher]
+version = "0.1"
+
+[dev-dependencies.doc-comment]
+version = "0.3"
+
+[dev-dependencies.lazy_static]
+version = "1.4"
+
+[dev-dependencies.regex]
+version = "1.5.5"
+
+[dev-dependencies.tempfile]
+version = "3.1.0"
+
+[dev-dependencies.unicase]
+version = "2.6.0"
+
+[dev-dependencies.uuid]
+version = "1.0"
+features = ["v4"]
+
+[features]
+array = ["vtab"]
+backup = []
+blob = []
+buildtime_bindgen = ["libsqlite3-sys/buildtime_bindgen"]
+bundled = [
+    "libsqlite3-sys/bundled",
+    "modern_sqlite",
+]
+bundled-full = [
+    "modern-full",
+    "bundled",
+]
+bundled-sqlcipher = [
+    "libsqlite3-sys/bundled-sqlcipher",
+    "bundled",
+]
+bundled-sqlcipher-vendored-openssl = [
+    "libsqlite3-sys/bundled-sqlcipher-vendored-openssl",
+    "bundled-sqlcipher",
+]
+bundled-windows = ["libsqlite3-sys/bundled-windows"]
+collation = []
+column_decltype = []
+csvtab = [
+    "csv",
+    "vtab",
+]
+extra_check = []
+functions = []
+hooks = []
+i128_blob = []
+in_gecko = [
+    "modern_sqlite",
+    "libsqlite3-sys/in_gecko",
+]
+limits = []
+load_extension = []
+modern-full = [
+    "array",
+    "backup",
+    "blob",
+    "modern_sqlite",
+    "chrono",
+    "collation",
+    "column_decltype",
+    "csvtab",
+    "extra_check",
+    "functions",
+    "hooks",
+    "i128_blob",
+    "limits",
+    "load_extension",
+    "serde_json",
+    "series",
+    "time",
+    "trace",
+    "unlock_notify",
+    "url",
+    "uuid",
+    "vtab",
+    "window",
+]
+modern_sqlite = ["libsqlite3-sys/bundled_bindings"]
+release_memory = []
+series = ["vtab"]
+session = [
+    "libsqlite3-sys/session",
+    "hooks",
+]
+sqlcipher = ["libsqlite3-sys/sqlcipher"]
+trace = []
+unlock_notify = ["libsqlite3-sys/unlock_notify"]
+vtab = []
+wasm32-wasi-vfs = ["libsqlite3-sys/wasm32-wasi-vfs"]
+window = ["functions"]
+winsqlite3 = ["libsqlite3-sys/winsqlite3"]
+with-asan = ["libsqlite3-sys/with-asan"]
+
+[badges.appveyor]
+repository = "rusqlite/rusqlite"
+
+[badges.codecov]
+repository = "rusqlite/rusqlite"
+
+[badges.maintenance]
+status = "actively-developed"
diff --git a/crates/rusqlite/LICENSE b/crates/rusqlite/LICENSE
new file mode 100644
index 0000000..9e5b9f7
--- /dev/null
+++ b/crates/rusqlite/LICENSE
@@ -0,0 +1,19 @@
+Copyright (c) 2014-2021 The rusqlite developers
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/crates/rusqlite/METADATA b/crates/rusqlite/METADATA
new file mode 100644
index 0000000..17cfd9b
--- /dev/null
+++ b/crates/rusqlite/METADATA
@@ -0,0 +1,23 @@
+# This project was upgraded with external_updater.
+# Usage: tools/external_updater/updater.sh update rust/crates/rusqlite
+# For more info, check https://cs.android.com/android/platform/superproject/+/master:tools/external_updater/README.md
+
+name: "rusqlite"
+description: "Ergonomic wrapper for SQLite"
+third_party {
+  url {
+    type: HOMEPAGE
+    value: "https://crates.io/crates/rusqlite"
+  }
+  url {
+    type: ARCHIVE
+    value: "https://static.crates.io/crates/rusqlite/rusqlite-0.29.0.crate"
+  }
+  version: "0.29.0"
+  license_type: NOTICE
+  last_upgrade_date {
+    year: 2023
+    month: 5
+    day: 25
+  }
+}
diff --git a/crates/rusqlite/MODULE_LICENSE_MIT b/crates/rusqlite/MODULE_LICENSE_MIT
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/crates/rusqlite/MODULE_LICENSE_MIT
diff --git a/crates/rusqlite/README.md b/crates/rusqlite/README.md
new file mode 100644
index 0000000..76013b8
--- /dev/null
+++ b/crates/rusqlite/README.md
@@ -0,0 +1,248 @@
+# Rusqlite
+
+[![Latest Version](https://img.shields.io/crates/v/rusqlite.svg)](https://crates.io/crates/rusqlite)
+[![Documentation](https://docs.rs/rusqlite/badge.svg)](https://docs.rs/rusqlite)
+[![Build Status (GitHub)](https://github.com/rusqlite/rusqlite/workflows/CI/badge.svg)](https://github.com/rusqlite/rusqlite/actions)
+[![Build Status (AppVeyor)](https://ci.appveyor.com/api/projects/status/github/rusqlite/rusqlite?branch=master&svg=true)](https://ci.appveyor.com/project/rusqlite/rusqlite)
+[![Code Coverage](https://codecov.io/gh/rusqlite/rusqlite/branch/master/graph/badge.svg)](https://codecov.io/gh/rusqlite/rusqlite)
+[![Dependency Status](https://deps.rs/repo/github/rusqlite/rusqlite/status.svg)](https://deps.rs/repo/github/rusqlite/rusqlite)
+[![Discord Chat](https://img.shields.io/discord/927966344266256434.svg?logo=discord)](https://discord.gg/nFYfGPB8g4)
+
+Rusqlite is an ergonomic wrapper for using SQLite from Rust.
+
+Historically, the API was based on the one from [`rust-postgres`](https://github.com/sfackler/rust-postgres). However, the two have diverged in many ways, and no compatibility between the two is intended.
+
+## Usage
+
+In your Cargo.toml:
+
+```toml
+[dependencies]
+# `bundled` causes us to automatically compile and link in an up to date
+# version of SQLite for you. This avoids many common build issues, and
+# avoids depending on the version of SQLite on the users system (or your
+# system), which may be old or missing. It's the right choice for most
+# programs that control their own SQLite databases.
+#
+# That said, it's not ideal for all scenarios and in particular, generic
+# libraries built around `rusqlite` should probably not enable it, which
+# is why it is not a default feature -- it could become hard to disable.
+rusqlite = { version = "0.29.0", features = ["bundled"] }
+```
+
+Simple example usage:
+
+```rust
+use rusqlite::{Connection, Result};
+
+#[derive(Debug)]
+struct Person {
+    id: i32,
+    name: String,
+    data: Option<Vec<u8>>,
+}
+
+fn main() -> Result<()> {
+    let conn = Connection::open_in_memory()?;
+
+    conn.execute(
+        "CREATE TABLE person (
+            id    INTEGER PRIMARY KEY,
+            name  TEXT NOT NULL,
+            data  BLOB
+        )",
+        (), // empty list of parameters.
+    )?;
+    let me = Person {
+        id: 0,
+        name: "Steven".to_string(),
+        data: None,
+    };
+    conn.execute(
+        "INSERT INTO person (name, data) VALUES (?1, ?2)",
+        (&me.name, &me.data),
+    )?;
+
+    let mut stmt = conn.prepare("SELECT id, name, data FROM person")?;
+    let person_iter = stmt.query_map([], |row| {
+        Ok(Person {
+            id: row.get(0)?,
+            name: row.get(1)?,
+            data: row.get(2)?,
+        })
+    })?;
+
+    for person in person_iter {
+        println!("Found person {:?}", person.unwrap());
+    }
+    Ok(())
+}
+```
+
+### Supported SQLite Versions
+
+The base `rusqlite` package supports SQLite version 3.14.0 or newer. If you need
+support for older versions, please file an issue. Some cargo features require a
+newer SQLite version; see details below.
+
+### Optional Features
+
+Rusqlite provides several features that are behind [Cargo
+features](https://doc.rust-lang.org/cargo/reference/manifest.html#the-features-section). They are:
+
+* [`load_extension`](https://docs.rs/rusqlite/~0/rusqlite/struct.LoadExtensionGuard.html)
+  allows loading dynamic library-based SQLite extensions.
+* [`backup`](https://docs.rs/rusqlite/~0/rusqlite/backup/index.html)
+  allows use of SQLite's online backup API. Note: This feature requires SQLite 3.6.11 or later.
+* [`functions`](https://docs.rs/rusqlite/~0/rusqlite/functions/index.html)
+  allows you to load Rust closures into SQLite connections for use in queries.
+  Note: This feature requires SQLite 3.7.3 or later.
+* `window` for [window function](https://www.sqlite.org/windowfunctions.html) support (`fun(...) OVER ...`). (Implies `functions`.)
+* [`trace`](https://docs.rs/rusqlite/~0/rusqlite/trace/index.html)
+  allows hooks into SQLite's tracing and profiling APIs. Note: This feature
+  requires SQLite 3.6.23 or later.
+* [`blob`](https://docs.rs/rusqlite/~0/rusqlite/blob/index.html)
+  gives `std::io::{Read, Write, Seek}` access to SQL BLOBs. Note: This feature
+  requires SQLite 3.7.4 or later.
+* [`limits`](https://docs.rs/rusqlite/~0/rusqlite/struct.Connection.html#method.limit)
+  allows you to set and retrieve SQLite's per connection limits.
+* `chrono` implements [`FromSql`](https://docs.rs/rusqlite/~0/rusqlite/types/trait.FromSql.html)
+  and [`ToSql`](https://docs.rs/rusqlite/~0/rusqlite/types/trait.ToSql.html) for various
+  types from the [`chrono` crate](https://crates.io/crates/chrono).
+* `serde_json` implements [`FromSql`](https://docs.rs/rusqlite/~0/rusqlite/types/trait.FromSql.html)
+  and [`ToSql`](https://docs.rs/rusqlite/~0/rusqlite/types/trait.ToSql.html) for the
+  `Value` type from the [`serde_json` crate](https://crates.io/crates/serde_json).
+* `time` implements [`FromSql`](https://docs.rs/rusqlite/~0/rusqlite/types/trait.FromSql.html)
+   and [`ToSql`](https://docs.rs/rusqlite/~0/rusqlite/types/trait.ToSql.html) for the
+   `time::OffsetDateTime` type from the [`time` crate](https://crates.io/crates/time).
+* `url` implements [`FromSql`](https://docs.rs/rusqlite/~0/rusqlite/types/trait.FromSql.html)
+  and [`ToSql`](https://docs.rs/rusqlite/~0/rusqlite/types/trait.ToSql.html) for the
+  `Url` type from the [`url` crate](https://crates.io/crates/url).
+* `bundled` uses a bundled version of SQLite.  This is a good option for cases where linking to SQLite is complicated, such as Windows.
+* `sqlcipher` looks for the SQLCipher library to link against instead of SQLite. This feature overrides `bundled`.
+* `bundled-sqlcipher` uses a bundled version of SQLCipher. This searches for and links against a system-installed crypto library to provide the crypto implementation.
+* `bundled-sqlcipher-vendored-openssl` allows using bundled-sqlcipher with a vendored version of OpenSSL (via the `openssl-sys` crate) as the crypto provider.
+  - As the name implies this depends on the `bundled-sqlcipher` feature, and automatically turns it on.
+  - If turned on, this uses the [`openssl-sys`](https://crates.io/crates/openssl-sys) crate, with the `vendored` feature enabled in order to build and bundle the OpenSSL crypto library.
+* `hooks` for [Commit, Rollback](http://sqlite.org/c3ref/commit_hook.html) and [Data Change](http://sqlite.org/c3ref/update_hook.html) notification callbacks.
+* `unlock_notify` for [Unlock](https://sqlite.org/unlock_notify.html) notification.
+* `vtab` for [virtual table](https://sqlite.org/vtab.html) support (allows you to write virtual table implementations in Rust). Currently, only read-only virtual tables are supported.
+* `series` exposes [`generate_series(...)`](https://www.sqlite.org/series.html) Table-Valued Function. (Implies `vtab`.)
+* [`csvtab`](https://sqlite.org/csv.html), CSV virtual table written in Rust. (Implies `vtab`.)
+* [`array`](https://sqlite.org/carray.html), The `rarray()` Table-Valued Function. (Implies `vtab`.)
+* `i128_blob` allows storing values of type `i128` type in SQLite databases. Internally, the data is stored as a 16 byte big-endian blob, with the most significant bit flipped, which allows ordering and comparison between different blobs storing i128s to work as expected.
+* `uuid` allows storing and retrieving `Uuid` values from the [`uuid`](https://docs.rs/uuid/) crate using blobs.
+* [`session`](https://sqlite.org/sessionintro.html), Session module extension. Requires `buildtime_bindgen` feature. (Implies `hooks`.)
+* `extra_check` fail when a query passed to execute is readonly or has a column count > 0.
+* `column_decltype` provides `columns()` method for Statements and Rows; omit if linking to a version of SQLite/SQLCipher compiled with `-DSQLITE_OMIT_DECLTYPE`.
+* `collation` exposes [`sqlite3_create_collation_v2`](https://sqlite.org/c3ref/create_collation.html).
+* `winsqlite3` allows linking against the SQLite present in newer versions of Windows
+
+## Notes on building rusqlite and libsqlite3-sys
+
+`libsqlite3-sys` is a separate crate from `rusqlite` that provides the Rust
+declarations for SQLite's C API. By default, `libsqlite3-sys` attempts to find a SQLite library that already exists on your system using pkg-config, or a
+[Vcpkg](https://github.com/Microsoft/vcpkg) installation for MSVC ABI builds.
+
+You can adjust this behavior in a number of ways:
+
+* If you use the `bundled`, `bundled-sqlcipher`, or `bundled-sqlcipher-vendored-openssl` features, `libsqlite3-sys` will use the
+  [cc](https://crates.io/crates/cc) crate to compile SQLite or SQLCipher from source and
+  link against that. This source is embedded in the `libsqlite3-sys` crate and
+  is currently SQLite 3.41.2 (as of `rusqlite` 0.29.0 / `libsqlite3-sys`
+  0.26.0).  This is probably the simplest solution to any build problems. You can enable this by adding the following in your `Cargo.toml` file:
+  ```toml
+  [dependencies.rusqlite]
+  version = "0.29.0"
+  features = ["bundled"]
+  ```
+* When using any of the `bundled` features, the build script will honor `SQLITE_MAX_VARIABLE_NUMBER` and `SQLITE_MAX_EXPR_DEPTH` variables. It will also honor a `LIBSQLITE3_FLAGS` variable, which can have a format like `"-USQLITE_ALPHA -DSQLITE_BETA SQLITE_GAMMA ..."`. That would disable the `SQLITE_ALPHA` flag, and set the `SQLITE_BETA` and `SQLITE_GAMMA` flags. (The initial `-D` can be omitted, as on the last one.)
+* When using `bundled-sqlcipher` (and not also using `bundled-sqlcipher-vendored-openssl`), `libsqlite3-sys` will need to
+  link against crypto libraries on the system. If the build script can find a `libcrypto` from OpenSSL or LibreSSL (it will consult `OPENSSL_LIB_DIR`/`OPENSSL_INCLUDE_DIR` and `OPENSSL_DIR` environment variables), it will use that. If building on and for Macs, and none of those variables are set, it will use the system's SecurityFramework instead.
+
+* When linking against a SQLite (or SQLCipher) library already on the system (so *not* using any of the `bundled` features), you can set the `SQLITE3_LIB_DIR` (or `SQLCIPHER_LIB_DIR`) environment variable to point to a directory containing the library. You can also set the `SQLITE3_INCLUDE_DIR` (or `SQLCIPHER_INCLUDE_DIR`) variable to point to the directory containing `sqlite3.h`.
+* Installing the sqlite3 development packages will usually be all that is required, but
+  the build helpers for [pkg-config](https://github.com/alexcrichton/pkg-config-rs)
+  and [vcpkg](https://github.com/mcgoo/vcpkg-rs) have some additional configuration
+  options. The default when using vcpkg is to dynamically link,
+  which must be enabled by setting `VCPKGRS_DYNAMIC=1` environment variable before build.
+  `vcpkg install sqlite3:x64-windows` will install the required library.
+* When linking against a SQLite (or SQLCipher) library already on the system, you can set the `SQLITE3_STATIC` (or `SQLCIPHER_STATIC`) environment variable to 1 to request that the library be statically instead of dynamically linked.
+
+
+### Binding generation
+
+We use [bindgen](https://crates.io/crates/bindgen) to generate the Rust
+declarations from SQLite's C header file. `bindgen`
+[recommends](https://github.com/servo/rust-bindgen#library-usage-with-buildrs)
+running this as part of the build process of libraries that used this. We tried
+this briefly (`rusqlite` 0.10.0, specifically), but it had some annoyances:
+
+* The build time for `libsqlite3-sys` (and therefore `rusqlite`) increased
+  dramatically.
+* Running `bindgen` requires a relatively-recent version of Clang, which many
+  systems do not have installed by default.
+* Running `bindgen` also requires the SQLite header file to be present.
+
+As of `rusqlite` 0.10.1, we avoid running `bindgen` at build-time by shipping
+pregenerated bindings for several versions of SQLite. When compiling
+`rusqlite`, we use your selected Cargo features to pick the bindings for the
+minimum SQLite version that supports your chosen features. If you are using
+`libsqlite3-sys` directly, you can use the same features to choose which
+pregenerated bindings are chosen:
+
+* `min_sqlite_version_3_14_0` - SQLite 3.14.0 bindings (this is the default)
+
+If you use any of the `bundled` features, you will get pregenerated bindings for the
+bundled version of SQLite/SQLCipher. If you need other specific pregenerated binding
+versions, please file an issue. If you want to run `bindgen` at buildtime to
+produce your own bindings, use the `buildtime_bindgen` Cargo feature.
+
+If you enable the `modern_sqlite` feature, we'll use the bindings we would have
+included with the bundled build. You generally should have `buildtime_bindgen`
+enabled if you turn this on, as otherwise you'll need to keep the version of
+SQLite you link with in sync with what rusqlite would have bundled, (usually the
+most recent release of SQLite). Failing to do this will cause a runtime error.
+
+## Contributing
+
+Rusqlite has many features, and many of them impact the build configuration in
+incompatible ways. This is unfortunate, and makes testing changes hard.
+
+To help here: you generally should ensure that you run tests/lint for
+`--features bundled`, and `--features "bundled-full session buildtime_bindgen"`.
+
+If running bindgen is problematic for you, `--features bundled-full` enables
+bundled and all features which don't require binding generation, and can be used
+instead.
+
+### Checklist
+
+- Run `cargo fmt` to ensure your Rust code is correctly formatted.
+- Ensure `cargo clippy --workspace --features bundled` passes without warnings.
+- Ensure `cargo clippy --workspace --features "bundled-full session buildtime_bindgen"` passes without warnings.
+- Ensure `cargo test --workspace --features bundled` reports no failures.
+- Ensure `cargo test --workspace --features "bundled-full session buildtime_bindgen"` reports no failures.
+
+## Author
+
+Rusqlite is the product of hard work by a number of people. A list is available
+here: https://github.com/rusqlite/rusqlite/graphs/contributors
+
+## Community
+
+Feel free to join the [Rusqlite Discord Server](https://discord.gg/nFYfGPB8g4) to discuss or get help with `rusqlite` or `libsqlite3-sys`.
+
+## License
+
+Rusqlite and libsqlite3-sys are available under the MIT license. See the LICENSE file for more info.
+
+### Licenses of Bundled Software
+
+Depending on the set of enabled cargo `features`, rusqlite and libsqlite3-sys will also bundle other libraries, which have their own licensing terms:
+
+- If `--features=bundled-sqlcipher` is enabled, the vendored source of [SQLcipher](https://github.com/sqlcipher/sqlcipher) will be compiled and statically linked in. SQLcipher is distributed under a BSD-style license, as described [here](libsqlite3-sys/sqlcipher/LICENSE).
+
+- If `--features=bundled` is enabled, the vendored source of SQLite will be compiled and linked in. SQLite is in the public domain, as described [here](https://www.sqlite.org/copyright.html).
+
+Both of these are quite permissive, have no bearing on the license of the code in `rusqlite` or `libsqlite3-sys` themselves, and can be entirely ignored if you do not use the feature in question.
diff --git a/crates/rusqlite/TEST_MAPPING b/crates/rusqlite/TEST_MAPPING
new file mode 100644
index 0000000..5953440
--- /dev/null
+++ b/crates/rusqlite/TEST_MAPPING
@@ -0,0 +1,11 @@
+// Generated by update_crate_tests.py for tests that depend on this crate.
+{
+  "imports": [
+    {
+      "path": "system/security/keystore2"
+    },
+    {
+      "path": "system/security/keystore2/legacykeystore"
+    }
+  ]
+}
diff --git a/crates/rusqlite/benches/cache.rs b/crates/rusqlite/benches/cache.rs
new file mode 100644
index 0000000..dd3683e
--- /dev/null
+++ b/crates/rusqlite/benches/cache.rs
@@ -0,0 +1,18 @@
+use bencher::{benchmark_group, benchmark_main, Bencher};
+use rusqlite::Connection;
+
+fn bench_no_cache(b: &mut Bencher) {
+    let db = Connection::open_in_memory().unwrap();
+    db.set_prepared_statement_cache_capacity(0);
+    let sql = "SELECT 1, 'test', 3.14 UNION SELECT 2, 'exp', 2.71";
+    b.iter(|| db.prepare(sql).unwrap());
+}
+
+fn bench_cache(b: &mut Bencher) {
+    let db = Connection::open_in_memory().unwrap();
+    let sql = "SELECT 1, 'test', 3.14 UNION SELECT 2, 'exp', 2.71";
+    b.iter(|| db.prepare_cached(sql).unwrap());
+}
+
+benchmark_group!(cache_benches, bench_no_cache, bench_cache);
+benchmark_main!(cache_benches);
diff --git a/crates/rusqlite/benches/exec.rs b/crates/rusqlite/benches/exec.rs
new file mode 100644
index 0000000..b95cb35
--- /dev/null
+++ b/crates/rusqlite/benches/exec.rs
@@ -0,0 +1,17 @@
+use bencher::{benchmark_group, benchmark_main, Bencher};
+use rusqlite::Connection;
+
+fn bench_execute(b: &mut Bencher) {
+    let db = Connection::open_in_memory().unwrap();
+    let sql = "PRAGMA user_version=1";
+    b.iter(|| db.execute(sql, []).unwrap());
+}
+
+fn bench_execute_batch(b: &mut Bencher) {
+    let db = Connection::open_in_memory().unwrap();
+    let sql = "PRAGMA user_version=1";
+    b.iter(|| db.execute_batch(sql).unwrap());
+}
+
+benchmark_group!(exec_benches, bench_execute, bench_execute_batch);
+benchmark_main!(exec_benches);
diff --git a/crates/rusqlite/cargo_embargo.json b/crates/rusqlite/cargo_embargo.json
new file mode 100644
index 0000000..4da5148
--- /dev/null
+++ b/crates/rusqlite/cargo_embargo.json
@@ -0,0 +1,9 @@
+{
+  "features": [
+    "modern_sqlite",
+    "trace"
+  ],
+  "product_available": true,
+  "run_cargo": false,
+  "vendor_available": true
+}
diff --git a/crates/rusqlite/src/backup.rs b/crates/rusqlite/src/backup.rs
new file mode 100644
index 0000000..f28ae9a
--- /dev/null
+++ b/crates/rusqlite/src/backup.rs
@@ -0,0 +1,428 @@
+//! Online SQLite backup API.
+//!
+//! To create a [`Backup`], you must have two distinct [`Connection`]s - one
+//! for the source (which can be used while the backup is running) and one for
+//! the destination (which cannot).  A [`Backup`] handle exposes three methods:
+//! [`step`](Backup::step) will attempt to back up a specified number of pages,
+//! [`progress`](Backup::progress) gets the current progress of the backup as of
+//! the last call to [`step`](Backup::step), and
+//! [`run_to_completion`](Backup::run_to_completion) will attempt to back up the
+//! entire source database, allowing you to specify how many pages are backed up
+//! at a time and how long the thread should sleep between chunks of pages.
+//!
+//! The following example is equivalent to "Example 2: Online Backup of a
+//! Running Database" from [SQLite's Online Backup API
+//! documentation](https://www.sqlite.org/backup.html).
+//!
+//! ```rust,no_run
+//! # use rusqlite::{backup, Connection, Result};
+//! # use std::path::Path;
+//! # use std::time;
+//!
+//! fn backup_db<P: AsRef<Path>>(
+//!     src: &Connection,
+//!     dst: P,
+//!     progress: fn(backup::Progress),
+//! ) -> Result<()> {
+//!     let mut dst = Connection::open(dst)?;
+//!     let backup = backup::Backup::new(src, &mut dst)?;
+//!     backup.run_to_completion(5, time::Duration::from_millis(250), Some(progress))
+//! }
+//! ```
+
+use std::marker::PhantomData;
+use std::path::Path;
+use std::ptr;
+
+use std::os::raw::c_int;
+use std::thread;
+use std::time::Duration;
+
+use crate::ffi;
+
+use crate::error::error_from_handle;
+use crate::{Connection, DatabaseName, Result};
+
+impl Connection {
+    /// Back up the `name` database to the given
+    /// destination path.
+    ///
+    /// If `progress` is not `None`, it will be called periodically
+    /// until the backup completes.
+    ///
+    /// For more fine-grained control over the backup process (e.g.,
+    /// to sleep periodically during the backup or to back up to an
+    /// already-open database connection), see the `backup` module.
+    ///
+    /// # Failure
+    ///
+    /// Will return `Err` if the destination path cannot be opened
+    /// or if the backup fails.
+    pub fn backup<P: AsRef<Path>>(
+        &self,
+        name: DatabaseName<'_>,
+        dst_path: P,
+        progress: Option<fn(Progress)>,
+    ) -> Result<()> {
+        use self::StepResult::{Busy, Done, Locked, More};
+        let mut dst = Connection::open(dst_path)?;
+        let backup = Backup::new_with_names(self, name, &mut dst, DatabaseName::Main)?;
+
+        let mut r = More;
+        while r == More {
+            r = backup.step(100)?;
+            if let Some(f) = progress {
+                f(backup.progress());
+            }
+        }
+
+        match r {
+            Done => Ok(()),
+            Busy => Err(unsafe { error_from_handle(ptr::null_mut(), ffi::SQLITE_BUSY) }),
+            Locked => Err(unsafe { error_from_handle(ptr::null_mut(), ffi::SQLITE_LOCKED) }),
+            More => unreachable!(),
+        }
+    }
+
+    /// Restore the given source path into the
+    /// `name` database. If `progress` is not `None`, it will be
+    /// called periodically until the restore completes.
+    ///
+    /// For more fine-grained control over the restore process (e.g.,
+    /// to sleep periodically during the restore or to restore from an
+    /// already-open database connection), see the `backup` module.
+    ///
+    /// # Failure
+    ///
+    /// Will return `Err` if the destination path cannot be opened
+    /// or if the restore fails.
+    pub fn restore<P: AsRef<Path>, F: Fn(Progress)>(
+        &mut self,
+        name: DatabaseName<'_>,
+        src_path: P,
+        progress: Option<F>,
+    ) -> Result<()> {
+        use self::StepResult::{Busy, Done, Locked, More};
+        let src = Connection::open(src_path)?;
+        let restore = Backup::new_with_names(&src, DatabaseName::Main, self, name)?;
+
+        let mut r = More;
+        let mut busy_count = 0_i32;
+        'restore_loop: while r == More || r == Busy {
+            r = restore.step(100)?;
+            if let Some(ref f) = progress {
+                f(restore.progress());
+            }
+            if r == Busy {
+                busy_count += 1;
+                if busy_count >= 3 {
+                    break 'restore_loop;
+                }
+                thread::sleep(Duration::from_millis(100));
+            }
+        }
+
+        match r {
+            Done => Ok(()),
+            Busy => Err(unsafe { error_from_handle(ptr::null_mut(), ffi::SQLITE_BUSY) }),
+            Locked => Err(unsafe { error_from_handle(ptr::null_mut(), ffi::SQLITE_LOCKED) }),
+            More => unreachable!(),
+        }
+    }
+}
+
+/// Possible successful results of calling
+/// [`Backup::step`].
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum StepResult {
+    /// The backup is complete.
+    Done,
+
+    /// The step was successful but there are still more pages that need to be
+    /// backed up.
+    More,
+
+    /// The step failed because appropriate locks could not be acquired. This is
+    /// not a fatal error - the step can be retried.
+    Busy,
+
+    /// The step failed because the source connection was writing to the
+    /// database. This is not a fatal error - the step can be retried.
+    Locked,
+}
+
+/// Struct specifying the progress of a backup. The
+/// percentage completion can be calculated as `(pagecount - remaining) /
+/// pagecount`. The progress of a backup is as of the last call to
+/// [`step`](Backup::step) - if the source database is modified after a call to
+/// [`step`](Backup::step), the progress value will become outdated and
+/// potentially incorrect.
+#[derive(Copy, Clone, Debug)]
+pub struct Progress {
+    /// Number of pages in the source database that still need to be backed up.
+    pub remaining: c_int,
+    /// Total number of pages in the source database.
+    pub pagecount: c_int,
+}
+
+/// A handle to an online backup.
+pub struct Backup<'a, 'b> {
+    phantom_from: PhantomData<&'a Connection>,
+    to: &'b Connection,
+    b: *mut ffi::sqlite3_backup,
+}
+
+impl Backup<'_, '_> {
+    /// Attempt to create a new handle that will allow backups from `from` to
+    /// `to`. Note that `to` is a `&mut` - this is because SQLite forbids any
+    /// API calls on the destination of a backup while the backup is taking
+    /// place.
+    ///
+    /// # Failure
+    ///
+    /// Will return `Err` if the underlying `sqlite3_backup_init` call returns
+    /// `NULL`.
+    #[inline]
+    pub fn new<'a, 'b>(from: &'a Connection, to: &'b mut Connection) -> Result<Backup<'a, 'b>> {
+        Backup::new_with_names(from, DatabaseName::Main, to, DatabaseName::Main)
+    }
+
+    /// Attempt to create a new handle that will allow backups from the
+    /// `from_name` database of `from` to the `to_name` database of `to`. Note
+    /// that `to` is a `&mut` - this is because SQLite forbids any API calls on
+    /// the destination of a backup while the backup is taking place.
+    ///
+    /// # Failure
+    ///
+    /// Will return `Err` if the underlying `sqlite3_backup_init` call returns
+    /// `NULL`.
+    pub fn new_with_names<'a, 'b>(
+        from: &'a Connection,
+        from_name: DatabaseName<'_>,
+        to: &'b mut Connection,
+        to_name: DatabaseName<'_>,
+    ) -> Result<Backup<'a, 'b>> {
+        let to_name = to_name.as_cstring()?;
+        let from_name = from_name.as_cstring()?;
+
+        let to_db = to.db.borrow_mut().db;
+
+        let b = unsafe {
+            let b = ffi::sqlite3_backup_init(
+                to_db,
+                to_name.as_ptr(),
+                from.db.borrow_mut().db,
+                from_name.as_ptr(),
+            );
+            if b.is_null() {
+                return Err(error_from_handle(to_db, ffi::sqlite3_errcode(to_db)));
+            }
+            b
+        };
+
+        Ok(Backup {
+            phantom_from: PhantomData,
+            to,
+            b,
+        })
+    }
+
+    /// Gets the progress of the backup as of the last call to
+    /// [`step`](Backup::step).
+    #[inline]
+    #[must_use]
+    pub fn progress(&self) -> Progress {
+        unsafe {
+            Progress {
+                remaining: ffi::sqlite3_backup_remaining(self.b),
+                pagecount: ffi::sqlite3_backup_pagecount(self.b),
+            }
+        }
+    }
+
+    /// Attempts to back up the given number of pages. If `num_pages` is
+    /// negative, will attempt to back up all remaining pages. This will hold a
+    /// lock on the source database for the duration, so it is probably not
+    /// what you want for databases that are currently active (see
+    /// [`run_to_completion`](Backup::run_to_completion) for a better
+    /// alternative).
+    ///
+    /// # Failure
+    ///
+    /// Will return `Err` if the underlying `sqlite3_backup_step` call returns
+    /// an error code other than `DONE`, `OK`, `BUSY`, or `LOCKED`. `BUSY` and
+    /// `LOCKED` are transient errors and are therefore returned as possible
+    /// `Ok` values.
+    #[inline]
+    pub fn step(&self, num_pages: c_int) -> Result<StepResult> {
+        use self::StepResult::{Busy, Done, Locked, More};
+
+        let rc = unsafe { ffi::sqlite3_backup_step(self.b, num_pages) };
+        match rc {
+            ffi::SQLITE_DONE => Ok(Done),
+            ffi::SQLITE_OK => Ok(More),
+            ffi::SQLITE_BUSY => Ok(Busy),
+            ffi::SQLITE_LOCKED => Ok(Locked),
+            _ => self.to.decode_result(rc).map(|_| More),
+        }
+    }
+
+    /// Attempts to run the entire backup. Will call
+    /// [`step(pages_per_step)`](Backup::step) as many times as necessary,
+    /// sleeping for `pause_between_pages` between each call to give the
+    /// source database time to process any pending queries. This is a
+    /// direct implementation of "Example 2: Online Backup of a Running
+    /// Database" from [SQLite's Online Backup API documentation](https://www.sqlite.org/backup.html).
+    ///
+    /// If `progress` is not `None`, it will be called after each step with the
+    /// current progress of the backup. Note that is possible the progress may
+    /// not change if the step returns `Busy` or `Locked` even though the
+    /// backup is still running.
+    ///
+    /// # Failure
+    ///
+    /// Will return `Err` if any of the calls to [`step`](Backup::step) return
+    /// `Err`.
+    pub fn run_to_completion(
+        &self,
+        pages_per_step: c_int,
+        pause_between_pages: Duration,
+        progress: Option<fn(Progress)>,
+    ) -> Result<()> {
+        use self::StepResult::{Busy, Done, Locked, More};
+
+        assert!(pages_per_step > 0, "pages_per_step must be positive");
+
+        loop {
+            let r = self.step(pages_per_step)?;
+            if let Some(progress) = progress {
+                progress(self.progress());
+            }
+            match r {
+                More | Busy | Locked => thread::sleep(pause_between_pages),
+                Done => return Ok(()),
+            }
+        }
+    }
+}
+
+impl Drop for Backup<'_, '_> {
+    #[inline]
+    fn drop(&mut self) {
+        unsafe { ffi::sqlite3_backup_finish(self.b) };
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::Backup;
+    use crate::{Connection, DatabaseName, Result};
+    use std::time::Duration;
+
+    #[test]
+    fn test_backup() -> Result<()> {
+        let src = Connection::open_in_memory()?;
+        let sql = "BEGIN;
+                   CREATE TABLE foo(x INTEGER);
+                   INSERT INTO foo VALUES(42);
+                   END;";
+        src.execute_batch(sql)?;
+
+        let mut dst = Connection::open_in_memory()?;
+
+        {
+            let backup = Backup::new(&src, &mut dst)?;
+            backup.step(-1)?;
+        }
+
+        let the_answer: i64 = dst.one_column("SELECT x FROM foo")?;
+        assert_eq!(42, the_answer);
+
+        src.execute_batch("INSERT INTO foo VALUES(43)")?;
+
+        {
+            let backup = Backup::new(&src, &mut dst)?;
+            backup.run_to_completion(5, Duration::from_millis(250), None)?;
+        }
+
+        let the_answer: i64 = dst.one_column("SELECT SUM(x) FROM foo")?;
+        assert_eq!(42 + 43, the_answer);
+        Ok(())
+    }
+
+    #[test]
+    fn test_backup_temp() -> Result<()> {
+        let src = Connection::open_in_memory()?;
+        let sql = "BEGIN;
+                   CREATE TEMPORARY TABLE foo(x INTEGER);
+                   INSERT INTO foo VALUES(42);
+                   END;";
+        src.execute_batch(sql)?;
+
+        let mut dst = Connection::open_in_memory()?;
+
+        {
+            let backup =
+                Backup::new_with_names(&src, DatabaseName::Temp, &mut dst, DatabaseName::Main)?;
+            backup.step(-1)?;
+        }
+
+        let the_answer: i64 = dst.one_column("SELECT x FROM foo")?;
+        assert_eq!(42, the_answer);
+
+        src.execute_batch("INSERT INTO foo VALUES(43)")?;
+
+        {
+            let backup =
+                Backup::new_with_names(&src, DatabaseName::Temp, &mut dst, DatabaseName::Main)?;
+            backup.run_to_completion(5, Duration::from_millis(250), None)?;
+        }
+
+        let the_answer: i64 = dst.one_column("SELECT SUM(x) FROM foo")?;
+        assert_eq!(42 + 43, the_answer);
+        Ok(())
+    }
+
+    #[test]
+    fn test_backup_attached() -> Result<()> {
+        let src = Connection::open_in_memory()?;
+        let sql = "ATTACH DATABASE ':memory:' AS my_attached;
+                   BEGIN;
+                   CREATE TABLE my_attached.foo(x INTEGER);
+                   INSERT INTO my_attached.foo VALUES(42);
+                   END;";
+        src.execute_batch(sql)?;
+
+        let mut dst = Connection::open_in_memory()?;
+
+        {
+            let backup = Backup::new_with_names(
+                &src,
+                DatabaseName::Attached("my_attached"),
+                &mut dst,
+                DatabaseName::Main,
+            )?;
+            backup.step(-1)?;
+        }
+
+        let the_answer: i64 = dst.one_column("SELECT x FROM foo")?;
+        assert_eq!(42, the_answer);
+
+        src.execute_batch("INSERT INTO foo VALUES(43)")?;
+
+        {
+            let backup = Backup::new_with_names(
+                &src,
+                DatabaseName::Attached("my_attached"),
+                &mut dst,
+                DatabaseName::Main,
+            )?;
+            backup.run_to_completion(5, Duration::from_millis(250), None)?;
+        }
+
+        let the_answer: i64 = dst.one_column("SELECT SUM(x) FROM foo")?;
+        assert_eq!(42 + 43, the_answer);
+        Ok(())
+    }
+}
diff --git a/crates/rusqlite/src/blob/mod.rs b/crates/rusqlite/src/blob/mod.rs
new file mode 100644
index 0000000..46e3ea8
--- /dev/null
+++ b/crates/rusqlite/src/blob/mod.rs
@@ -0,0 +1,551 @@
+//! Incremental BLOB I/O.
+//!
+//! Note that SQLite does not provide API-level access to change the size of a
+//! BLOB; that must be performed through SQL statements.
+//!
+//! There are two choices for how to perform IO on a [`Blob`].
+//!
+//! 1. The implementations it provides of the `std::io::Read`, `std::io::Write`,
+//!    and `std::io::Seek` traits.
+//!
+//! 2. A positional IO API, e.g. [`Blob::read_at`], [`Blob::write_at`] and
+//!    similar.
+//!
+//! Documenting these in order:
+//!
+//! ## 1. `std::io` trait implementations.
+//!
+//! `Blob` conforms to `std::io::Read`, `std::io::Write`, and `std::io::Seek`,
+//! so it plays nicely with other types that build on these (such as
+//! `std::io::BufReader` and `std::io::BufWriter`). However, you must be careful
+//! with the size of the blob. For example, when using a `BufWriter`, the
+//! `BufWriter` will accept more data than the `Blob` will allow, so make sure
+//! to call `flush` and check for errors. (See the unit tests in this module for
+//! an example.)
+//!
+//! ## 2. Positional IO
+//!
+//! `Blob`s also offer a `pread` / `pwrite`-style positional IO api in the form
+//! of [`Blob::read_at`], [`Blob::write_at`], [`Blob::raw_read_at`],
+//! [`Blob::read_at_exact`], and [`Blob::raw_read_at_exact`].
+//!
+//! These APIs all take the position to read from or write to from as a
+//! parameter, instead of using an internal `pos` value.
+//!
+//! ### Positional IO Read Variants
+//!
+//! For the `read` functions, there are several functions provided:
+//!
+//! - [`Blob::read_at`]
+//! - [`Blob::raw_read_at`]
+//! - [`Blob::read_at_exact`]
+//! - [`Blob::raw_read_at_exact`]
+//!
+//! These can be divided along two axes: raw/not raw, and exact/inexact:
+//!
+//! 1. Raw/not raw refers to the type of the destination buffer. The raw
+//!    functions take a `&mut [MaybeUninit<u8>]` as the destination buffer,
+//!    where the "normal" functions take a `&mut [u8]`.
+//!
+//!    Using `MaybeUninit` here can be more efficient in some cases, but is
+//!    often inconvenient, so both are provided.
+//!
+//! 2. Exact/inexact refers to to whether or not the entire buffer must be
+//!    filled in order for the call to be considered a success.
+//!
+//!    The "exact" functions require the provided buffer be entirely filled, or
+//!    they return an error, whereas the "inexact" functions read as much out of
+//!    the blob as is available, and return how much they were able to read.
+//!
+//!    The inexact functions are preferable if you do not know the size of the
+//!    blob already, and the exact functions are preferable if you do.
+//!
+//! ### Comparison to using the `std::io` traits:
+//!
+//! In general, the positional methods offer the following Pro/Cons compared to
+//! using the implementation `std::io::{Read, Write, Seek}` we provide for
+//! `Blob`:
+//!
+//! 1. (Pro) There is no need to first seek to a position in order to perform IO
+//!    on it as the position is a parameter.
+//!
+//! 2. (Pro) `Blob`'s positional read functions don't mutate the blob in any
+//!    way, and take `&self`. No `&mut` access required.
+//!
+//! 3. (Pro) Positional IO functions return `Err(rusqlite::Error)` on failure,
+//!    rather than `Err(std::io::Error)`. Returning `rusqlite::Error` is more
+//!    accurate and convenient.
+//!
+//!    Note that for the `std::io` API, no data is lost however, and it can be
+//!    recovered with `io_err.downcast::<rusqlite::Error>()` (this can be easy
+//!    to forget, though).
+//!
+//! 4. (Pro, for now). A `raw` version of the read API exists which can allow
+//!    reading into a `&mut [MaybeUninit<u8>]` buffer, which avoids a potential
+//!    costly initialization step. (However, `std::io` traits will certainly
+//!    gain this someday, which is why this is only a "Pro, for now").
+//!
+//! 5. (Con) The set of functions is more bare-bones than what is offered in
+//!    `std::io`, which has a number of adapters, handy algorithms, further
+//!    traits.
+//!
+//! 6. (Con) No meaningful interoperability with other crates, so if you need
+//!    that you must use `std::io`.
+//!
+//! To generalize: the `std::io` traits are useful because they conform to a
+//! standard interface that a lot of code knows how to handle, however that
+//! interface is not a perfect fit for [`Blob`], so another small set of
+//! functions is provided as well.
+//!
+//! # Example (`std::io`)
+//!
+//! ```rust
+//! # use rusqlite::blob::ZeroBlob;
+//! # use rusqlite::{Connection, DatabaseName};
+//! # use std::error::Error;
+//! # use std::io::{Read, Seek, SeekFrom, Write};
+//! # fn main() -> Result<(), Box<dyn Error>> {
+//! let db = Connection::open_in_memory()?;
+//! db.execute_batch("CREATE TABLE test_table (content BLOB);")?;
+//!
+//! // Insert a BLOB into the `content` column of `test_table`. Note that the Blob
+//! // I/O API provides no way of inserting or resizing BLOBs in the DB -- this
+//! // must be done via SQL.
+//! db.execute("INSERT INTO test_table (content) VALUES (ZEROBLOB(10))", [])?;
+//!
+//! // Get the row id off the BLOB we just inserted.
+//! let rowid = db.last_insert_rowid();
+//! // Open the BLOB we just inserted for IO.
+//! let mut blob = db.blob_open(DatabaseName::Main, "test_table", "content", rowid, false)?;
+//!
+//! // Write some data into the blob. Make sure to test that the number of bytes
+//! // written matches what you expect; if you try to write too much, the data
+//! // will be truncated to the size of the BLOB.
+//! let bytes_written = blob.write(b"01234567")?;
+//! assert_eq!(bytes_written, 8);
+//!
+//! // Move back to the start and read into a local buffer.
+//! // Same guidance - make sure you check the number of bytes read!
+//! blob.seek(SeekFrom::Start(0))?;
+//! let mut buf = [0u8; 20];
+//! let bytes_read = blob.read(&mut buf[..])?;
+//! assert_eq!(bytes_read, 10); // note we read 10 bytes because the blob has size 10
+//!
+//! // Insert another BLOB, this time using a parameter passed in from
+//! // rust (potentially with a dynamic size).
+//! db.execute(
+//!     "INSERT INTO test_table (content) VALUES (?1)",
+//!     [ZeroBlob(64)],
+//! )?;
+//!
+//! // given a new row ID, we can reopen the blob on that row
+//! let rowid = db.last_insert_rowid();
+//! blob.reopen(rowid)?;
+//! // Just check that the size is right.
+//! assert_eq!(blob.len(), 64);
+//! # Ok(())
+//! # }
+//! ```
+//!
+//! # Example (Positional)
+//!
+//! ```rust
+//! # use rusqlite::blob::ZeroBlob;
+//! # use rusqlite::{Connection, DatabaseName};
+//! # use std::error::Error;
+//! # fn main() -> Result<(), Box<dyn Error>> {
+//! let db = Connection::open_in_memory()?;
+//! db.execute_batch("CREATE TABLE test_table (content BLOB);")?;
+//! // Insert a blob into the `content` column of `test_table`. Note that the Blob
+//! // I/O API provides no way of inserting or resizing blobs in the DB -- this
+//! // must be done via SQL.
+//! db.execute("INSERT INTO test_table (content) VALUES (ZEROBLOB(10))", [])?;
+//! // Get the row id off the blob we just inserted.
+//! let rowid = db.last_insert_rowid();
+//! // Open the blob we just inserted for IO.
+//! let mut blob = db.blob_open(DatabaseName::Main, "test_table", "content", rowid, false)?;
+//! // Write some data into the blob.
+//! blob.write_at(b"ABCDEF", 2)?;
+//!
+//! // Read the whole blob into a local buffer.
+//! let mut buf = [0u8; 10];
+//! blob.read_at_exact(&mut buf, 0)?;
+//! assert_eq!(&buf, b"\0\0ABCDEF\0\0");
+//!
+//! // Insert another blob, this time using a parameter passed in from
+//! // rust (potentially with a dynamic size).
+//! db.execute(
+//!     "INSERT INTO test_table (content) VALUES (?1)",
+//!     [ZeroBlob(64)],
+//! )?;
+//!
+//! // given a new row ID, we can reopen the blob on that row
+//! let rowid = db.last_insert_rowid();
+//! blob.reopen(rowid)?;
+//! assert_eq!(blob.len(), 64);
+//! # Ok(())
+//! # }
+//! ```
+use std::cmp::min;
+use std::io;
+use std::ptr;
+
+use super::ffi;
+use super::types::{ToSql, ToSqlOutput};
+use crate::{Connection, DatabaseName, Result};
+
+mod pos_io;
+
+/// Handle to an open BLOB. See
+/// [`rusqlite::blob`](crate::blob) documentation for in-depth discussion.
+pub struct Blob<'conn> {
+    conn: &'conn Connection,
+    blob: *mut ffi::sqlite3_blob,
+    // used by std::io implementations,
+    pos: i32,
+}
+
+impl Connection {
+    /// Open a handle to the BLOB located in `row_id`,
+    /// `column`, `table` in database `db`.
+    ///
+    /// # Failure
+    ///
+    /// Will return `Err` if `db`/`table`/`column` cannot be converted to a
+    /// C-compatible string or if the underlying SQLite BLOB open call
+    /// fails.
+    #[inline]
+    pub fn blob_open<'a>(
+        &'a self,
+        db: DatabaseName<'_>,
+        table: &str,
+        column: &str,
+        row_id: i64,
+        read_only: bool,
+    ) -> Result<Blob<'a>> {
+        let c = self.db.borrow_mut();
+        let mut blob = ptr::null_mut();
+        let db = db.as_cstring()?;
+        let table = super::str_to_cstring(table)?;
+        let column = super::str_to_cstring(column)?;
+        let rc = unsafe {
+            ffi::sqlite3_blob_open(
+                c.db(),
+                db.as_ptr(),
+                table.as_ptr(),
+                column.as_ptr(),
+                row_id,
+                !read_only as std::os::raw::c_int,
+                &mut blob,
+            )
+        };
+        c.decode_result(rc).map(|_| Blob {
+            conn: self,
+            blob,
+            pos: 0,
+        })
+    }
+}
+
+impl Blob<'_> {
+    /// Move a BLOB handle to a new row.
+    ///
+    /// # Failure
+    ///
+    /// Will return `Err` if the underlying SQLite BLOB reopen call fails.
+    #[inline]
+    pub fn reopen(&mut self, row: i64) -> Result<()> {
+        let rc = unsafe { ffi::sqlite3_blob_reopen(self.blob, row) };
+        if rc != ffi::SQLITE_OK {
+            return self.conn.decode_result(rc);
+        }
+        self.pos = 0;
+        Ok(())
+    }
+
+    /// Return the size in bytes of the BLOB.
+    #[inline]
+    #[must_use]
+    pub fn size(&self) -> i32 {
+        unsafe { ffi::sqlite3_blob_bytes(self.blob) }
+    }
+
+    /// Return the current size in bytes of the BLOB.
+    #[inline]
+    #[must_use]
+    pub fn len(&self) -> usize {
+        use std::convert::TryInto;
+        self.size().try_into().unwrap()
+    }
+
+    /// Return true if the BLOB is empty.
+    #[inline]
+    #[must_use]
+    pub fn is_empty(&self) -> bool {
+        self.size() == 0
+    }
+
+    /// Close a BLOB handle.
+    ///
+    /// Calling `close` explicitly is not required (the BLOB will be closed
+    /// when the `Blob` is dropped), but it is available so you can get any
+    /// errors that occur.
+    ///
+    /// # Failure
+    ///
+    /// Will return `Err` if the underlying SQLite close call fails.
+    #[inline]
+    pub fn close(mut self) -> Result<()> {
+        self.close_()
+    }
+
+    #[inline]
+    fn close_(&mut self) -> Result<()> {
+        let rc = unsafe { ffi::sqlite3_blob_close(self.blob) };
+        self.blob = ptr::null_mut();
+        self.conn.decode_result(rc)
+    }
+}
+
+impl io::Read for Blob<'_> {
+    /// Read data from a BLOB incrementally. Will return Ok(0) if the end of
+    /// the blob has been reached.
+    ///
+    /// # Failure
+    ///
+    /// Will return `Err` if the underlying SQLite read call fails.
+    #[inline]
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        let max_allowed_len = (self.size() - self.pos) as usize;
+        let n = min(buf.len(), max_allowed_len) as i32;
+        if n <= 0 {
+            return Ok(0);
+        }
+        let rc = unsafe { ffi::sqlite3_blob_read(self.blob, buf.as_mut_ptr().cast(), n, self.pos) };
+        self.conn
+            .decode_result(rc)
+            .map(|_| {
+                self.pos += n;
+                n as usize
+            })
+            .map_err(|err| io::Error::new(io::ErrorKind::Other, err))
+    }
+}
+
+impl io::Write for Blob<'_> {
+    /// Write data into a BLOB incrementally. Will return `Ok(0)` if the end of
+    /// the blob has been reached; consider using `Write::write_all(buf)`
+    /// if you want to get an error if the entirety of the buffer cannot be
+    /// written.
+    ///
+    /// This function may only modify the contents of the BLOB; it is not
+    /// possible to increase the size of a BLOB using this API.
+    ///
+    /// # Failure
+    ///
+    /// Will return `Err` if the underlying SQLite write call fails.
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        let max_allowed_len = (self.size() - self.pos) as usize;
+        let n = min(buf.len(), max_allowed_len) as i32;
+        if n <= 0 {
+            return Ok(0);
+        }
+        let rc = unsafe { ffi::sqlite3_blob_write(self.blob, buf.as_ptr() as *mut _, n, self.pos) };
+        self.conn
+            .decode_result(rc)
+            .map(|_| {
+                self.pos += n;
+                n as usize
+            })
+            .map_err(|err| io::Error::new(io::ErrorKind::Other, err))
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+impl io::Seek for Blob<'_> {
+    /// Seek to an offset, in bytes, in BLOB.
+    #[inline]
+    fn seek(&mut self, pos: io::SeekFrom) -> io::Result<u64> {
+        let pos = match pos {
+            io::SeekFrom::Start(offset) => offset as i64,
+            io::SeekFrom::Current(offset) => i64::from(self.pos) + offset,
+            io::SeekFrom::End(offset) => i64::from(self.size()) + offset,
+        };
+
+        if pos < 0 {
+            Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "invalid seek to negative position",
+            ))
+        } else if pos > i64::from(self.size()) {
+            Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "invalid seek to position past end of blob",
+            ))
+        } else {
+            self.pos = pos as i32;
+            Ok(pos as u64)
+        }
+    }
+}
+
+#[allow(unused_must_use)]
+impl Drop for Blob<'_> {
+    #[inline]
+    fn drop(&mut self) {
+        self.close_();
+    }
+}
+
+/// BLOB of length N that is filled with zeroes.
+///
+/// Zeroblobs are intended to serve as placeholders for BLOBs whose content is
+/// later written using incremental BLOB I/O routines.
+///
+/// A negative value for the zeroblob results in a zero-length BLOB.
+#[derive(Copy, Clone)]
+pub struct ZeroBlob(pub i32);
+
+impl ToSql for ZeroBlob {
+    #[inline]
+    fn to_sql(&self) -> Result<ToSqlOutput<'_>> {
+        let ZeroBlob(length) = *self;
+        Ok(ToSqlOutput::ZeroBlob(length))
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::{Connection, DatabaseName, Result};
+    use std::io::{BufRead, BufReader, BufWriter, Read, Seek, SeekFrom, Write};
+
+    fn db_with_test_blob() -> Result<(Connection, i64)> {
+        let db = Connection::open_in_memory()?;
+        let sql = "BEGIN;
+                   CREATE TABLE test (content BLOB);
+                   INSERT INTO test VALUES (ZEROBLOB(10));
+                   END;";
+        db.execute_batch(sql)?;
+        let rowid = db.last_insert_rowid();
+        Ok((db, rowid))
+    }
+
+    #[test]
+    fn test_blob() -> Result<()> {
+        let (db, rowid) = db_with_test_blob()?;
+
+        let mut blob = db.blob_open(DatabaseName::Main, "test", "content", rowid, false)?;
+        assert_eq!(4, blob.write(b"Clob").unwrap());
+        assert_eq!(6, blob.write(b"567890xxxxxx").unwrap()); // cannot write past 10
+        assert_eq!(0, blob.write(b"5678").unwrap()); // still cannot write past 10
+
+        blob.reopen(rowid)?;
+        blob.close()?;
+
+        blob = db.blob_open(DatabaseName::Main, "test", "content", rowid, true)?;
+        let mut bytes = [0u8; 5];
+        assert_eq!(5, blob.read(&mut bytes[..]).unwrap());
+        assert_eq!(&bytes, b"Clob5");
+        assert_eq!(5, blob.read(&mut bytes[..]).unwrap());
+        assert_eq!(&bytes, b"67890");
+        assert_eq!(0, blob.read(&mut bytes[..]).unwrap());
+
+        blob.seek(SeekFrom::Start(2)).unwrap();
+        assert_eq!(5, blob.read(&mut bytes[..]).unwrap());
+        assert_eq!(&bytes, b"ob567");
+
+        // only first 4 bytes of `bytes` should be read into
+        blob.seek(SeekFrom::Current(-1)).unwrap();
+        assert_eq!(4, blob.read(&mut bytes[..]).unwrap());
+        assert_eq!(&bytes, b"78907");
+
+        blob.seek(SeekFrom::End(-6)).unwrap();
+        assert_eq!(5, blob.read(&mut bytes[..]).unwrap());
+        assert_eq!(&bytes, b"56789");
+
+        blob.reopen(rowid)?;
+        assert_eq!(5, blob.read(&mut bytes[..]).unwrap());
+        assert_eq!(&bytes, b"Clob5");
+
+        // should not be able to seek negative or past end
+        blob.seek(SeekFrom::Current(-20)).unwrap_err();
+        blob.seek(SeekFrom::End(0)).unwrap();
+        blob.seek(SeekFrom::Current(1)).unwrap_err();
+
+        // write_all should detect when we return Ok(0) because there is no space left,
+        // and return a write error
+        blob.reopen(rowid)?;
+        blob.write_all(b"0123456789x").unwrap_err();
+        Ok(())
+    }
+
+    #[test]
+    fn test_blob_in_bufreader() -> Result<()> {
+        let (db, rowid) = db_with_test_blob()?;
+
+        let mut blob = db.blob_open(DatabaseName::Main, "test", "content", rowid, false)?;
+        assert_eq!(8, blob.write(b"one\ntwo\n").unwrap());
+
+        blob.reopen(rowid)?;
+        let mut reader = BufReader::new(blob);
+
+        let mut line = String::new();
+        assert_eq!(4, reader.read_line(&mut line).unwrap());
+        assert_eq!("one\n", line);
+
+        line.truncate(0);
+        assert_eq!(4, reader.read_line(&mut line).unwrap());
+        assert_eq!("two\n", line);
+
+        line.truncate(0);
+        assert_eq!(2, reader.read_line(&mut line).unwrap());
+        assert_eq!("\0\0", line);
+        Ok(())
+    }
+
+    #[test]
+    fn test_blob_in_bufwriter() -> Result<()> {
+        let (db, rowid) = db_with_test_blob()?;
+
+        {
+            let blob = db.blob_open(DatabaseName::Main, "test", "content", rowid, false)?;
+            let mut writer = BufWriter::new(blob);
+
+            // trying to write too much and then flush should fail
+            assert_eq!(8, writer.write(b"01234567").unwrap());
+            assert_eq!(8, writer.write(b"01234567").unwrap());
+            writer.flush().unwrap_err();
+        }
+
+        {
+            // ... but it should've written the first 10 bytes
+            let mut blob = db.blob_open(DatabaseName::Main, "test", "content", rowid, false)?;
+            let mut bytes = [0u8; 10];
+            assert_eq!(10, blob.read(&mut bytes[..]).unwrap());
+            assert_eq!(b"0123456701", &bytes);
+        }
+
+        {
+            let blob = db.blob_open(DatabaseName::Main, "test", "content", rowid, false)?;
+            let mut writer = BufWriter::new(blob);
+
+            // trying to write_all too much should fail
+            writer.write_all(b"aaaaaaaaaabbbbb").unwrap();
+            writer.flush().unwrap_err();
+        }
+
+        {
+            // ... but it should've written the first 10 bytes
+            let mut blob = db.blob_open(DatabaseName::Main, "test", "content", rowid, false)?;
+            let mut bytes = [0u8; 10];
+            assert_eq!(10, blob.read(&mut bytes[..]).unwrap());
+            assert_eq!(b"aaaaaaaaaa", &bytes);
+            Ok(())
+        }
+    }
+}
diff --git a/crates/rusqlite/src/blob/pos_io.rs b/crates/rusqlite/src/blob/pos_io.rs
new file mode 100644
index 0000000..d970ab7
--- /dev/null
+++ b/crates/rusqlite/src/blob/pos_io.rs
@@ -0,0 +1,272 @@
+use super::Blob;
+
+use std::convert::TryFrom;
+use std::mem::MaybeUninit;
+use std::slice::from_raw_parts_mut;
+
+use crate::ffi;
+use crate::{Error, Result};
+
+impl<'conn> Blob<'conn> {
+    /// Write `buf` to `self` starting at `write_start`, returning an error if
+    /// `write_start + buf.len()` is past the end of the blob.
+    ///
+    /// If an error is returned, no data is written.
+    ///
+    /// Note: the blob cannot be resized using this function -- that must be
+    /// done using SQL (for example, an `UPDATE` statement).
+    ///
+    /// Note: This is part of the positional I/O API, and thus takes an absolute
+    /// position write to, instead of using the internal position that can be
+    /// manipulated by the `std::io` traits.
+    ///
+    /// Unlike the similarly named [`FileExt::write_at`][fext_write_at] function
+    /// (from `std::os::unix`), it's always an error to perform a "short write".
+    ///
+    /// [fext_write_at]: https://doc.rust-lang.org/std/os/unix/fs/trait.FileExt.html#tymethod.write_at
+    #[inline]
+    pub fn write_at(&mut self, buf: &[u8], write_start: usize) -> Result<()> {
+        let len = self.len();
+
+        if buf.len().saturating_add(write_start) > len {
+            return Err(Error::BlobSizeError);
+        }
+        // We know `len` fits in an `i32`, so either:
+        //
+        // 1. `buf.len() + write_start` overflows, in which case we'd hit the
+        //    return above (courtesy of `saturating_add`).
+        //
+        // 2. `buf.len() + write_start` doesn't overflow but is larger than len,
+        //    in which case ditto.
+        //
+        // 3. `buf.len() + write_start` doesn't overflow but is less than len.
+        //    This means that both `buf.len()` and `write_start` can also be
+        //    losslessly converted to i32, since `len` came from an i32.
+        // Sanity check the above.
+        debug_assert!(i32::try_from(write_start).is_ok() && i32::try_from(buf.len()).is_ok());
+        self.conn.decode_result(unsafe {
+            ffi::sqlite3_blob_write(
+                self.blob,
+                buf.as_ptr().cast(),
+                buf.len() as i32,
+                write_start as i32,
+            )
+        })
+    }
+
+    /// An alias for `write_at` provided for compatibility with the conceptually
+    /// equivalent [`std::os::unix::FileExt::write_all_at`][write_all_at]
+    /// function from libstd:
+    ///
+    /// [write_all_at]: https://doc.rust-lang.org/std/os/unix/fs/trait.FileExt.html#method.write_all_at
+    #[inline]
+    pub fn write_all_at(&mut self, buf: &[u8], write_start: usize) -> Result<()> {
+        self.write_at(buf, write_start)
+    }
+
+    /// Read as much as possible from `offset` to `offset + buf.len()` out of
+    /// `self`, writing into `buf`. On success, returns the number of bytes
+    /// written.
+    ///
+    /// If there's insufficient data in `self`, then the returned value will be
+    /// less than `buf.len()`.
+    ///
+    /// See also [`Blob::raw_read_at`], which can take an uninitialized buffer,
+    /// or [`Blob::read_at_exact`] which returns an error if the entire `buf` is
+    /// not read.
+    ///
+    /// Note: This is part of the positional I/O API, and thus takes an absolute
+    /// position to read from, instead of using the internal position that can
+    /// be manipulated by the `std::io` traits. Consequently, it does not change
+    /// that value either.
+    #[inline]
+    pub fn read_at(&self, buf: &mut [u8], read_start: usize) -> Result<usize> {
+        // Safety: this is safe because `raw_read_at` never stores uninitialized
+        // data into `as_uninit`.
+        let as_uninit: &mut [MaybeUninit<u8>] =
+            unsafe { from_raw_parts_mut(buf.as_mut_ptr().cast(), buf.len()) };
+        self.raw_read_at(as_uninit, read_start).map(|s| s.len())
+    }
+
+    /// Read as much as possible from `offset` to `offset + buf.len()` out of
+    /// `self`, writing into `buf`. On success, returns the portion of `buf`
+    /// which was initialized by this call.
+    ///
+    /// If there's insufficient data in `self`, then the returned value will be
+    /// shorter than `buf`.
+    ///
+    /// See also [`Blob::read_at`], which takes a `&mut [u8]` buffer instead of
+    /// a slice of `MaybeUninit<u8>`.
+    ///
+    /// Note: This is part of the positional I/O API, and thus takes an absolute
+    /// position to read from, instead of using the internal position that can
+    /// be manipulated by the `std::io` traits. Consequently, it does not change
+    /// that value either.
+    #[inline]
+    pub fn raw_read_at<'a>(
+        &self,
+        buf: &'a mut [MaybeUninit<u8>],
+        read_start: usize,
+    ) -> Result<&'a mut [u8]> {
+        let len = self.len();
+
+        let read_len = match len.checked_sub(read_start) {
+            None | Some(0) => 0,
+            Some(v) => v.min(buf.len()),
+        };
+
+        if read_len == 0 {
+            // We could return `Ok(&mut [])`, but it seems confusing that the
+            // pointers don't match, so fabricate a empty slice of u8 with the
+            // same base pointer as `buf`.
+            let empty = unsafe { from_raw_parts_mut(buf.as_mut_ptr().cast::<u8>(), 0) };
+            return Ok(empty);
+        }
+
+        // At this point we believe `read_start as i32` is lossless because:
+        //
+        // 1. `len as i32` is known to be lossless, since it comes from a SQLite
+        //    api returning an i32.
+        //
+        // 2. If we got here, `len.checked_sub(read_start)` was Some (or else
+        //    we'd have hit the `if read_len == 0` early return), so `len` must
+        //    be larger than `read_start`, and so it must fit in i32 as well.
+        debug_assert!(i32::try_from(read_start).is_ok());
+
+        // We also believe that `read_start + read_len <= len` because:
+        //
+        // 1. This is equivalent to `read_len <= len - read_start` via algebra.
+        // 2. We know that `read_len` is `min(len - read_start, buf.len())`
+        // 3. Expanding, this is `min(len - read_start, buf.len()) <= len - read_start`,
+        //    or `min(A, B) <= A` which is clearly true.
+        //
+        // Note that this stuff is in debug_assert so no need to use checked_add
+        // and such -- we'll always panic on overflow in debug builds.
+        debug_assert!(read_start + read_len <= len);
+
+        // These follow naturally.
+        debug_assert!(buf.len() >= read_len);
+        debug_assert!(i32::try_from(buf.len()).is_ok());
+        debug_assert!(i32::try_from(read_len).is_ok());
+
+        unsafe {
+            self.conn.decode_result(ffi::sqlite3_blob_read(
+                self.blob,
+                buf.as_mut_ptr().cast(),
+                read_len as i32,
+                read_start as i32,
+            ))?;
+
+            Ok(from_raw_parts_mut(buf.as_mut_ptr().cast::<u8>(), read_len))
+        }
+    }
+
+    /// Equivalent to [`Blob::read_at`], but returns a `BlobSizeError` if `buf`
+    /// is not fully initialized.
+    #[inline]
+    pub fn read_at_exact(&self, buf: &mut [u8], read_start: usize) -> Result<()> {
+        let n = self.read_at(buf, read_start)?;
+        if n != buf.len() {
+            Err(Error::BlobSizeError)
+        } else {
+            Ok(())
+        }
+    }
+
+    /// Equivalent to [`Blob::raw_read_at`], but returns a `BlobSizeError` if
+    /// `buf` is not fully initialized.
+    #[inline]
+    pub fn raw_read_at_exact<'a>(
+        &self,
+        buf: &'a mut [MaybeUninit<u8>],
+        read_start: usize,
+    ) -> Result<&'a mut [u8]> {
+        let buflen = buf.len();
+        let initted = self.raw_read_at(buf, read_start)?;
+        if initted.len() != buflen {
+            Err(Error::BlobSizeError)
+        } else {
+            Ok(initted)
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::{Connection, DatabaseName, Result};
+    // to ensure we don't modify seek pos
+    use std::io::Seek as _;
+
+    #[test]
+    fn test_pos_io() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        db.execute_batch("CREATE TABLE test_table(content BLOB);")?;
+        db.execute("INSERT INTO test_table(content) VALUES (ZEROBLOB(10))", [])?;
+
+        let rowid = db.last_insert_rowid();
+        let mut blob = db.blob_open(DatabaseName::Main, "test_table", "content", rowid, false)?;
+        // modify the seek pos to ensure we aren't using it or modifying it.
+        blob.seek(std::io::SeekFrom::Start(1)).unwrap();
+
+        let one2ten: [u8; 10] = [1u8, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+        blob.write_at(&one2ten, 0).unwrap();
+
+        let mut s = [0u8; 10];
+        blob.read_at_exact(&mut s, 0).unwrap();
+        assert_eq!(&s, &one2ten, "write should go through");
+        blob.read_at_exact(&mut s, 1).unwrap_err();
+
+        blob.read_at_exact(&mut s, 0).unwrap();
+        assert_eq!(&s, &one2ten, "should be unchanged");
+
+        let mut fives = [0u8; 5];
+        blob.read_at_exact(&mut fives, 0).unwrap();
+        assert_eq!(&fives, &[1u8, 2, 3, 4, 5]);
+
+        blob.read_at_exact(&mut fives, 5).unwrap();
+        assert_eq!(&fives, &[6u8, 7, 8, 9, 10]);
+        blob.read_at_exact(&mut fives, 7).unwrap_err();
+        blob.read_at_exact(&mut fives, 12).unwrap_err();
+        blob.read_at_exact(&mut fives, 10).unwrap_err();
+        blob.read_at_exact(&mut fives, i32::MAX as usize)
+            .unwrap_err();
+        blob.read_at_exact(&mut fives, i32::MAX as usize + 1)
+            .unwrap_err();
+
+        // zero length writes are fine if in bounds
+        blob.read_at_exact(&mut [], 10).unwrap();
+        blob.read_at_exact(&mut [], 0).unwrap();
+        blob.read_at_exact(&mut [], 5).unwrap();
+
+        blob.write_all_at(&[16, 17, 18, 19, 20], 5).unwrap();
+        blob.read_at_exact(&mut s, 0).unwrap();
+        assert_eq!(&s, &[1u8, 2, 3, 4, 5, 16, 17, 18, 19, 20]);
+
+        blob.write_at(&[100, 99, 98, 97, 96], 6).unwrap_err();
+        blob.write_at(&[100, 99, 98, 97, 96], i32::MAX as usize)
+            .unwrap_err();
+        blob.write_at(&[100, 99, 98, 97, 96], i32::MAX as usize + 1)
+            .unwrap_err();
+
+        blob.read_at_exact(&mut s, 0).unwrap();
+        assert_eq!(&s, &[1u8, 2, 3, 4, 5, 16, 17, 18, 19, 20]);
+
+        let mut s2: [std::mem::MaybeUninit<u8>; 10] = [std::mem::MaybeUninit::uninit(); 10];
+        {
+            let read = blob.raw_read_at_exact(&mut s2, 0).unwrap();
+            assert_eq!(read, &s);
+            assert!(std::ptr::eq(read.as_ptr(), s2.as_ptr().cast()));
+        }
+
+        let mut empty = [];
+        assert!(std::ptr::eq(
+            blob.raw_read_at_exact(&mut empty, 0).unwrap().as_ptr(),
+            empty.as_ptr().cast(),
+        ));
+        blob.raw_read_at_exact(&mut s2, 5).unwrap_err();
+
+        let end_pos = blob.stream_position().unwrap();
+        assert_eq!(end_pos, 1);
+        Ok(())
+    }
+}
diff --git a/crates/rusqlite/src/busy.rs b/crates/rusqlite/src/busy.rs
new file mode 100644
index 0000000..b9a5d40
--- /dev/null
+++ b/crates/rusqlite/src/busy.rs
@@ -0,0 +1,170 @@
+///! Busy handler (when the database is locked)
+use std::convert::TryInto;
+use std::mem;
+use std::os::raw::{c_int, c_void};
+use std::panic::catch_unwind;
+use std::ptr;
+use std::time::Duration;
+
+use crate::ffi;
+use crate::{Connection, InnerConnection, Result};
+
+impl Connection {
+    /// Set a busy handler that sleeps for a specified amount of time when a
+    /// table is locked. The handler will sleep multiple times until at
+    /// least "ms" milliseconds of sleeping have accumulated.
+    ///
+    /// Calling this routine with an argument equal to zero turns off all busy
+    /// handlers.
+    ///
+    /// There can only be a single busy handler for a particular database
+    /// connection at any given moment. If another busy handler was defined
+    /// (using [`busy_handler`](Connection::busy_handler)) prior to calling this
+    /// routine, that other busy handler is cleared.
+    ///
+    /// Newly created connections currently have a default busy timeout of
+    /// 5000ms, but this may be subject to change.
+    pub fn busy_timeout(&self, timeout: Duration) -> Result<()> {
+        let ms: i32 = timeout
+            .as_secs()
+            .checked_mul(1000)
+            .and_then(|t| t.checked_add(timeout.subsec_millis().into()))
+            .and_then(|t| t.try_into().ok())
+            .expect("too big");
+        self.db.borrow_mut().busy_timeout(ms)
+    }
+
+    /// Register a callback to handle `SQLITE_BUSY` errors.
+    ///
+    /// If the busy callback is `None`, then `SQLITE_BUSY` is returned
+    /// immediately upon encountering the lock. The argument to the busy
+    /// handler callback is the number of times that the
+    /// busy handler has been invoked previously for the
+    /// same locking event. If the busy callback returns `false`, then no
+    /// additional attempts are made to access the
+    /// database and `SQLITE_BUSY` is returned to the
+    /// application. If the callback returns `true`, then another attempt
+    /// is made to access the database and the cycle repeats.
+    ///
+    /// There can only be a single busy handler defined for each database
+    /// connection. Setting a new busy handler clears any previously set
+    /// handler. Note that calling [`busy_timeout()`](Connection::busy_timeout)
+    /// or evaluating `PRAGMA busy_timeout=N` will change the busy handler
+    /// and thus clear any previously set busy handler.
+    ///
+    /// Newly created connections default to a
+    /// [`busy_timeout()`](Connection::busy_timeout) handler with a timeout
+    /// of 5000ms, although this is subject to change.
+    pub fn busy_handler(&self, callback: Option<fn(i32) -> bool>) -> Result<()> {
+        unsafe extern "C" fn busy_handler_callback(p_arg: *mut c_void, count: c_int) -> c_int {
+            let handler_fn: fn(i32) -> bool = mem::transmute(p_arg);
+            c_int::from(catch_unwind(|| handler_fn(count)).unwrap_or_default())
+        }
+        let c = self.db.borrow_mut();
+        let r = match callback {
+            Some(f) => unsafe {
+                ffi::sqlite3_busy_handler(c.db(), Some(busy_handler_callback), f as *mut c_void)
+            },
+            None => unsafe { ffi::sqlite3_busy_handler(c.db(), None, ptr::null_mut()) },
+        };
+        c.decode_result(r)
+    }
+}
+
+impl InnerConnection {
+    #[inline]
+    fn busy_timeout(&mut self, timeout: c_int) -> Result<()> {
+        let r = unsafe { ffi::sqlite3_busy_timeout(self.db, timeout) };
+        self.decode_result(r)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use std::sync::atomic::{AtomicBool, Ordering};
+    use std::sync::mpsc::sync_channel;
+    use std::thread;
+    use std::time::Duration;
+
+    use crate::{Connection, ErrorCode, Result, TransactionBehavior};
+
+    #[test]
+    fn test_default_busy() -> Result<()> {
+        let temp_dir = tempfile::tempdir().unwrap();
+        let path = temp_dir.path().join("test.db3");
+
+        let mut db1 = Connection::open(&path)?;
+        let tx1 = db1.transaction_with_behavior(TransactionBehavior::Exclusive)?;
+        let db2 = Connection::open(&path)?;
+        let r: Result<()> = db2.query_row("PRAGMA schema_version", [], |_| unreachable!());
+        assert_eq!(
+            r.unwrap_err().sqlite_error_code(),
+            Some(ErrorCode::DatabaseBusy)
+        );
+        tx1.rollback()
+    }
+
+    #[test]
+    #[ignore] // FIXME: unstable
+    fn test_busy_timeout() {
+        let temp_dir = tempfile::tempdir().unwrap();
+        let path = temp_dir.path().join("test.db3");
+
+        let db2 = Connection::open(&path).unwrap();
+        db2.busy_timeout(Duration::from_secs(1)).unwrap();
+
+        let (rx, tx) = sync_channel(0);
+        let child = thread::spawn(move || {
+            let mut db1 = Connection::open(&path).unwrap();
+            let tx1 = db1
+                .transaction_with_behavior(TransactionBehavior::Exclusive)
+                .unwrap();
+            rx.send(1).unwrap();
+            thread::sleep(Duration::from_millis(100));
+            tx1.rollback().unwrap();
+        });
+
+        assert_eq!(tx.recv().unwrap(), 1);
+        let _ = db2
+            .query_row("PRAGMA schema_version", [], |row| row.get::<_, i32>(0))
+            .expect("unexpected error");
+
+        child.join().unwrap();
+    }
+
+    #[test]
+    #[ignore] // FIXME: unstable
+    fn test_busy_handler() {
+        static CALLED: AtomicBool = AtomicBool::new(false);
+        fn busy_handler(_: i32) -> bool {
+            CALLED.store(true, Ordering::Relaxed);
+            thread::sleep(Duration::from_millis(100));
+            true
+        }
+
+        let temp_dir = tempfile::tempdir().unwrap();
+        let path = temp_dir.path().join("test.db3");
+
+        let db2 = Connection::open(&path).unwrap();
+        db2.busy_handler(Some(busy_handler)).unwrap();
+
+        let (rx, tx) = sync_channel(0);
+        let child = thread::spawn(move || {
+            let mut db1 = Connection::open(&path).unwrap();
+            let tx1 = db1
+                .transaction_with_behavior(TransactionBehavior::Exclusive)
+                .unwrap();
+            rx.send(1).unwrap();
+            thread::sleep(Duration::from_millis(100));
+            tx1.rollback().unwrap();
+        });
+
+        assert_eq!(tx.recv().unwrap(), 1);
+        let _ = db2
+            .query_row("PRAGMA schema_version", [], |row| row.get::<_, i32>(0))
+            .expect("unexpected error");
+        assert!(CALLED.load(Ordering::Relaxed));
+
+        child.join().unwrap();
+    }
+}
diff --git a/crates/rusqlite/src/cache.rs b/crates/rusqlite/src/cache.rs
new file mode 100644
index 0000000..be15268
--- /dev/null
+++ b/crates/rusqlite/src/cache.rs
@@ -0,0 +1,350 @@
+//! Prepared statements cache for faster execution.
+
+use crate::raw_statement::RawStatement;
+use crate::{Connection, Result, Statement};
+use hashlink::LruCache;
+use std::cell::RefCell;
+use std::ops::{Deref, DerefMut};
+use std::sync::Arc;
+
+impl Connection {
+    /// Prepare a SQL statement for execution, returning a previously prepared
+    /// (but not currently in-use) statement if one is available. The
+    /// returned statement will be cached for reuse by future calls to
+    /// [`prepare_cached`](Connection::prepare_cached) once it is dropped.
+    ///
+    /// ```rust,no_run
+    /// # use rusqlite::{Connection, Result};
+    /// fn insert_new_people(conn: &Connection) -> Result<()> {
+    ///     {
+    ///         let mut stmt = conn.prepare_cached("INSERT INTO People (name) VALUES (?1)")?;
+    ///         stmt.execute(["Joe Smith"])?;
+    ///     }
+    ///     {
+    ///         // This will return the same underlying SQLite statement handle without
+    ///         // having to prepare it again.
+    ///         let mut stmt = conn.prepare_cached("INSERT INTO People (name) VALUES (?1)")?;
+    ///         stmt.execute(["Bob Jones"])?;
+    ///     }
+    ///     Ok(())
+    /// }
+    /// ```
+    ///
+    /// # Failure
+    ///
+    /// Will return `Err` if `sql` cannot be converted to a C-compatible string
+    /// or if the underlying SQLite call fails.
+    #[inline]
+    pub fn prepare_cached(&self, sql: &str) -> Result<CachedStatement<'_>> {
+        self.cache.get(self, sql)
+    }
+
+    /// Set the maximum number of cached prepared statements this connection
+    /// will hold. By default, a connection will hold a relatively small
+    /// number of cached statements. If you need more, or know that you
+    /// will not use cached statements, you
+    /// can set the capacity manually using this method.
+    #[inline]
+    pub fn set_prepared_statement_cache_capacity(&self, capacity: usize) {
+        self.cache.set_capacity(capacity);
+    }
+
+    /// Remove/finalize all prepared statements currently in the cache.
+    #[inline]
+    pub fn flush_prepared_statement_cache(&self) {
+        self.cache.flush();
+    }
+}
+
+/// Prepared statements LRU cache.
+// #[derive(Debug)] // FIXME: https://github.com/kyren/hashlink/pull/4
+pub struct StatementCache(RefCell<LruCache<Arc<str>, RawStatement>>);
+
+#[allow(clippy::non_send_fields_in_send_ty)]
+unsafe impl Send for StatementCache {}
+
+/// Cacheable statement.
+///
+/// Statement will return automatically to the cache by default.
+/// If you want the statement to be discarded, call
+/// [`discard()`](CachedStatement::discard) on it.
+pub struct CachedStatement<'conn> {
+    stmt: Option<Statement<'conn>>,
+    cache: &'conn StatementCache,
+}
+
+impl<'conn> Deref for CachedStatement<'conn> {
+    type Target = Statement<'conn>;
+
+    #[inline]
+    fn deref(&self) -> &Statement<'conn> {
+        self.stmt.as_ref().unwrap()
+    }
+}
+
+impl<'conn> DerefMut for CachedStatement<'conn> {
+    #[inline]
+    fn deref_mut(&mut self) -> &mut Statement<'conn> {
+        self.stmt.as_mut().unwrap()
+    }
+}
+
+impl Drop for CachedStatement<'_> {
+    #[allow(unused_must_use)]
+    #[inline]
+    fn drop(&mut self) {
+        if let Some(stmt) = self.stmt.take() {
+            self.cache.cache_stmt(unsafe { stmt.into_raw() });
+        }
+    }
+}
+
+impl CachedStatement<'_> {
+    #[inline]
+    fn new<'conn>(stmt: Statement<'conn>, cache: &'conn StatementCache) -> CachedStatement<'conn> {
+        CachedStatement {
+            stmt: Some(stmt),
+            cache,
+        }
+    }
+
+    /// Discard the statement, preventing it from being returned to its
+    /// [`Connection`]'s collection of cached statements.
+    #[inline]
+    pub fn discard(mut self) {
+        self.stmt = None;
+    }
+}
+
+impl StatementCache {
+    /// Create a statement cache.
+    #[inline]
+    pub fn with_capacity(capacity: usize) -> StatementCache {
+        StatementCache(RefCell::new(LruCache::new(capacity)))
+    }
+
+    #[inline]
+    fn set_capacity(&self, capacity: usize) {
+        self.0.borrow_mut().set_capacity(capacity);
+    }
+
+    // Search the cache for a prepared-statement object that implements `sql`.
+    // If no such prepared-statement can be found, allocate and prepare a new one.
+    //
+    // # Failure
+    //
+    // Will return `Err` if no cached statement can be found and the underlying
+    // SQLite prepare call fails.
+    fn get<'conn>(
+        &'conn self,
+        conn: &'conn Connection,
+        sql: &str,
+    ) -> Result<CachedStatement<'conn>> {
+        let trimmed = sql.trim();
+        let mut cache = self.0.borrow_mut();
+        let stmt = match cache.remove(trimmed) {
+            Some(raw_stmt) => Ok(Statement::new(conn, raw_stmt)),
+            None => conn.prepare(trimmed),
+        };
+        stmt.map(|mut stmt| {
+            stmt.stmt.set_statement_cache_key(trimmed);
+            CachedStatement::new(stmt, self)
+        })
+    }
+
+    // Return a statement to the cache.
+    fn cache_stmt(&self, stmt: RawStatement) {
+        if stmt.is_null() {
+            return;
+        }
+        let mut cache = self.0.borrow_mut();
+        stmt.clear_bindings();
+        if let Some(sql) = stmt.statement_cache_key() {
+            cache.insert(sql, stmt);
+        } else {
+            debug_assert!(
+                false,
+                "bug in statement cache code, statement returned to cache that without key"
+            );
+        }
+    }
+
+    #[inline]
+    fn flush(&self) {
+        let mut cache = self.0.borrow_mut();
+        cache.clear();
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::StatementCache;
+    use crate::{Connection, Result};
+    use fallible_iterator::FallibleIterator;
+
+    impl StatementCache {
+        fn clear(&self) {
+            self.0.borrow_mut().clear();
+        }
+
+        fn len(&self) -> usize {
+            self.0.borrow().len()
+        }
+
+        fn capacity(&self) -> usize {
+            self.0.borrow().capacity()
+        }
+    }
+
+    #[test]
+    fn test_cache() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        let cache = &db.cache;
+        let initial_capacity = cache.capacity();
+        assert_eq!(0, cache.len());
+        assert!(initial_capacity > 0);
+
+        let sql = "PRAGMA schema_version";
+        {
+            let mut stmt = db.prepare_cached(sql)?;
+            assert_eq!(0, cache.len());
+            assert_eq!(0, stmt.query_row([], |r| r.get::<_, i64>(0))?);
+        }
+        assert_eq!(1, cache.len());
+
+        {
+            let mut stmt = db.prepare_cached(sql)?;
+            assert_eq!(0, cache.len());
+            assert_eq!(0, stmt.query_row([], |r| r.get::<_, i64>(0))?);
+        }
+        assert_eq!(1, cache.len());
+
+        cache.clear();
+        assert_eq!(0, cache.len());
+        assert_eq!(initial_capacity, cache.capacity());
+        Ok(())
+    }
+
+    #[test]
+    fn test_set_capacity() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        let cache = &db.cache;
+
+        let sql = "PRAGMA schema_version";
+        {
+            let mut stmt = db.prepare_cached(sql)?;
+            assert_eq!(0, cache.len());
+            assert_eq!(0, stmt.query_row([], |r| r.get::<_, i64>(0))?);
+        }
+        assert_eq!(1, cache.len());
+
+        db.set_prepared_statement_cache_capacity(0);
+        assert_eq!(0, cache.len());
+
+        {
+            let mut stmt = db.prepare_cached(sql)?;
+            assert_eq!(0, cache.len());
+            assert_eq!(0, stmt.query_row([], |r| r.get::<_, i64>(0))?);
+        }
+        assert_eq!(0, cache.len());
+
+        db.set_prepared_statement_cache_capacity(8);
+        {
+            let mut stmt = db.prepare_cached(sql)?;
+            assert_eq!(0, cache.len());
+            assert_eq!(0, stmt.query_row([], |r| r.get::<_, i64>(0))?);
+        }
+        assert_eq!(1, cache.len());
+        Ok(())
+    }
+
+    #[test]
+    fn test_discard() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        let cache = &db.cache;
+
+        let sql = "PRAGMA schema_version";
+        {
+            let mut stmt = db.prepare_cached(sql)?;
+            assert_eq!(0, cache.len());
+            assert_eq!(0, stmt.query_row([], |r| r.get::<_, i64>(0))?);
+            stmt.discard();
+        }
+        assert_eq!(0, cache.len());
+        Ok(())
+    }
+
+    #[test]
+    fn test_ddl() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        db.execute_batch(
+            r#"
+            CREATE TABLE foo (x INT);
+            INSERT INTO foo VALUES (1);
+        "#,
+        )?;
+
+        let sql = "SELECT * FROM foo";
+
+        {
+            let mut stmt = db.prepare_cached(sql)?;
+            assert_eq!(Ok(Some(1i32)), stmt.query([])?.map(|r| r.get(0)).next());
+        }
+
+        db.execute_batch(
+            r#"
+            ALTER TABLE foo ADD COLUMN y INT;
+            UPDATE foo SET y = 2;
+        "#,
+        )?;
+
+        {
+            let mut stmt = db.prepare_cached(sql)?;
+            assert_eq!(
+                Ok(Some((1i32, 2i32))),
+                stmt.query([])?.map(|r| Ok((r.get(0)?, r.get(1)?))).next()
+            );
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn test_connection_close() -> Result<()> {
+        let conn = Connection::open_in_memory()?;
+        conn.prepare_cached("SELECT * FROM sqlite_master;")?;
+
+        conn.close().expect("connection not closed");
+        Ok(())
+    }
+
+    #[test]
+    fn test_cache_key() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        let cache = &db.cache;
+        assert_eq!(0, cache.len());
+
+        //let sql = " PRAGMA schema_version; -- comment";
+        let sql = "PRAGMA schema_version; ";
+        {
+            let mut stmt = db.prepare_cached(sql)?;
+            assert_eq!(0, cache.len());
+            assert_eq!(0, stmt.query_row([], |r| r.get::<_, i64>(0))?);
+        }
+        assert_eq!(1, cache.len());
+
+        {
+            let mut stmt = db.prepare_cached(sql)?;
+            assert_eq!(0, cache.len());
+            assert_eq!(0, stmt.query_row([], |r| r.get::<_, i64>(0))?);
+        }
+        assert_eq!(1, cache.len());
+        Ok(())
+    }
+
+    #[test]
+    fn test_empty_stmt() -> Result<()> {
+        let conn = Connection::open_in_memory()?;
+        conn.prepare_cached("")?;
+        Ok(())
+    }
+}
diff --git a/crates/rusqlite/src/collation.rs b/crates/rusqlite/src/collation.rs
new file mode 100644
index 0000000..c1fe3f7
--- /dev/null
+++ b/crates/rusqlite/src/collation.rs
@@ -0,0 +1,215 @@
+//! Add, remove, or modify a collation
+use std::cmp::Ordering;
+use std::os::raw::{c_char, c_int, c_void};
+use std::panic::{catch_unwind, UnwindSafe};
+use std::ptr;
+use std::slice;
+
+use crate::ffi;
+use crate::{str_to_cstring, Connection, InnerConnection, Result};
+
+// FIXME copy/paste from function.rs
+unsafe extern "C" fn free_boxed_value<T>(p: *mut c_void) {
+    drop(Box::from_raw(p.cast::<T>()));
+}
+
+impl Connection {
+    /// Add or modify a collation.
+    #[inline]
+    pub fn create_collation<C>(&self, collation_name: &str, x_compare: C) -> Result<()>
+    where
+        C: Fn(&str, &str) -> Ordering + Send + UnwindSafe + 'static,
+    {
+        self.db
+            .borrow_mut()
+            .create_collation(collation_name, x_compare)
+    }
+
+    /// Collation needed callback
+    #[inline]
+    pub fn collation_needed(
+        &self,
+        x_coll_needed: fn(&Connection, &str) -> Result<()>,
+    ) -> Result<()> {
+        self.db.borrow_mut().collation_needed(x_coll_needed)
+    }
+
+    /// Remove collation.
+    #[inline]
+    pub fn remove_collation(&self, collation_name: &str) -> Result<()> {
+        self.db.borrow_mut().remove_collation(collation_name)
+    }
+}
+
+impl InnerConnection {
+    fn create_collation<C>(&mut self, collation_name: &str, x_compare: C) -> Result<()>
+    where
+        C: Fn(&str, &str) -> Ordering + Send + UnwindSafe + 'static,
+    {
+        unsafe extern "C" fn call_boxed_closure<C>(
+            arg1: *mut c_void,
+            arg2: c_int,
+            arg3: *const c_void,
+            arg4: c_int,
+            arg5: *const c_void,
+        ) -> c_int
+        where
+            C: Fn(&str, &str) -> Ordering,
+        {
+            let r = catch_unwind(|| {
+                let boxed_f: *mut C = arg1.cast::<C>();
+                assert!(!boxed_f.is_null(), "Internal error - null function pointer");
+                let s1 = {
+                    let c_slice = slice::from_raw_parts(arg3.cast::<u8>(), arg2 as usize);
+                    String::from_utf8_lossy(c_slice)
+                };
+                let s2 = {
+                    let c_slice = slice::from_raw_parts(arg5.cast::<u8>(), arg4 as usize);
+                    String::from_utf8_lossy(c_slice)
+                };
+                (*boxed_f)(s1.as_ref(), s2.as_ref())
+            });
+            let t = match r {
+                Err(_) => {
+                    return -1; // FIXME How ?
+                }
+                Ok(r) => r,
+            };
+
+            match t {
+                Ordering::Less => -1,
+                Ordering::Equal => 0,
+                Ordering::Greater => 1,
+            }
+        }
+
+        let boxed_f: *mut C = Box::into_raw(Box::new(x_compare));
+        let c_name = str_to_cstring(collation_name)?;
+        let flags = ffi::SQLITE_UTF8;
+        let r = unsafe {
+            ffi::sqlite3_create_collation_v2(
+                self.db(),
+                c_name.as_ptr(),
+                flags,
+                boxed_f.cast::<c_void>(),
+                Some(call_boxed_closure::<C>),
+                Some(free_boxed_value::<C>),
+            )
+        };
+        let res = self.decode_result(r);
+        // The xDestroy callback is not called if the sqlite3_create_collation_v2()
+        // function fails.
+        if res.is_err() {
+            drop(unsafe { Box::from_raw(boxed_f) });
+        }
+        res
+    }
+
+    fn collation_needed(
+        &mut self,
+        x_coll_needed: fn(&Connection, &str) -> Result<()>,
+    ) -> Result<()> {
+        use std::mem;
+        #[allow(clippy::needless_return)]
+        unsafe extern "C" fn collation_needed_callback(
+            arg1: *mut c_void,
+            arg2: *mut ffi::sqlite3,
+            e_text_rep: c_int,
+            arg3: *const c_char,
+        ) {
+            use std::ffi::CStr;
+            use std::str;
+
+            if e_text_rep != ffi::SQLITE_UTF8 {
+                // TODO: validate
+                return;
+            }
+
+            let callback: fn(&Connection, &str) -> Result<()> = mem::transmute(arg1);
+            let res = catch_unwind(|| {
+                let conn = Connection::from_handle(arg2).unwrap();
+                let collation_name = {
+                    let c_slice = CStr::from_ptr(arg3).to_bytes();
+                    str::from_utf8(c_slice).expect("illegal collation sequence name")
+                };
+                callback(&conn, collation_name)
+            });
+            if res.is_err() {
+                return; // FIXME How ?
+            }
+        }
+
+        let r = unsafe {
+            ffi::sqlite3_collation_needed(
+                self.db(),
+                x_coll_needed as *mut c_void,
+                Some(collation_needed_callback),
+            )
+        };
+        self.decode_result(r)
+    }
+
+    #[inline]
+    fn remove_collation(&mut self, collation_name: &str) -> Result<()> {
+        let c_name = str_to_cstring(collation_name)?;
+        let r = unsafe {
+            ffi::sqlite3_create_collation_v2(
+                self.db(),
+                c_name.as_ptr(),
+                ffi::SQLITE_UTF8,
+                ptr::null_mut(),
+                None,
+                None,
+            )
+        };
+        self.decode_result(r)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::{Connection, Result};
+    use fallible_streaming_iterator::FallibleStreamingIterator;
+    use std::cmp::Ordering;
+    use unicase::UniCase;
+
+    fn unicase_compare(s1: &str, s2: &str) -> Ordering {
+        UniCase::new(s1).cmp(&UniCase::new(s2))
+    }
+
+    #[test]
+    fn test_unicase() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+
+        db.create_collation("unicase", unicase_compare)?;
+
+        collate(db)
+    }
+
+    fn collate(db: Connection) -> Result<()> {
+        db.execute_batch(
+            "CREATE TABLE foo (bar);
+             INSERT INTO foo (bar) VALUES ('Maße');
+             INSERT INTO foo (bar) VALUES ('MASSE');",
+        )?;
+        let mut stmt = db.prepare("SELECT DISTINCT bar COLLATE unicase FROM foo ORDER BY 1")?;
+        let rows = stmt.query([])?;
+        assert_eq!(rows.count()?, 1);
+        Ok(())
+    }
+
+    fn collation_needed(db: &Connection, collation_name: &str) -> Result<()> {
+        if "unicase" == collation_name {
+            db.create_collation(collation_name, unicase_compare)
+        } else {
+            Ok(())
+        }
+    }
+
+    #[test]
+    fn test_collation_needed() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        db.collation_needed(collation_needed)?;
+        collate(db)
+    }
+}
diff --git a/crates/rusqlite/src/column.rs b/crates/rusqlite/src/column.rs
new file mode 100644
index 0000000..4413a62
--- /dev/null
+++ b/crates/rusqlite/src/column.rs
@@ -0,0 +1,242 @@
+use std::str;
+
+use crate::{Error, Result, Statement};
+
+/// Information about a column of a SQLite query.
+#[derive(Debug)]
+pub struct Column<'stmt> {
+    name: &'stmt str,
+    decl_type: Option<&'stmt str>,
+}
+
+impl Column<'_> {
+    /// Returns the name of the column.
+    #[inline]
+    #[must_use]
+    pub fn name(&self) -> &str {
+        self.name
+    }
+
+    /// Returns the type of the column (`None` for expression).
+    #[inline]
+    #[must_use]
+    pub fn decl_type(&self) -> Option<&str> {
+        self.decl_type
+    }
+}
+
+impl Statement<'_> {
+    /// Get all the column names in the result set of the prepared statement.
+    ///
+    /// If associated DB schema can be altered concurrently, you should make
+    /// sure that current statement has already been stepped once before
+    /// calling this method.
+    pub fn column_names(&self) -> Vec<&str> {
+        let n = self.column_count();
+        let mut cols = Vec::with_capacity(n);
+        for i in 0..n {
+            let s = self.column_name_unwrap(i);
+            cols.push(s);
+        }
+        cols
+    }
+
+    /// Return the number of columns in the result set returned by the prepared
+    /// statement.
+    ///
+    /// If associated DB schema can be altered concurrently, you should make
+    /// sure that current statement has already been stepped once before
+    /// calling this method.
+    #[inline]
+    pub fn column_count(&self) -> usize {
+        self.stmt.column_count()
+    }
+
+    /// Check that column name reference lifetime is limited:
+    /// https://www.sqlite.org/c3ref/column_name.html
+    /// > The returned string pointer is valid...
+    ///
+    /// `column_name` reference can become invalid if `stmt` is reprepared
+    /// (because of schema change) when `query_row` is called. So we assert
+    /// that a compilation error happens if this reference is kept alive:
+    /// ```compile_fail
+    /// use rusqlite::{Connection, Result};
+    /// fn main() -> Result<()> {
+    ///     let db = Connection::open_in_memory()?;
+    ///     let mut stmt = db.prepare("SELECT 1 as x")?;
+    ///     let column_name = stmt.column_name(0)?;
+    ///     let x = stmt.query_row([], |r| r.get::<_, i64>(0))?; // E0502
+    ///     assert_eq!(1, x);
+    ///     assert_eq!("x", column_name);
+    ///     Ok(())
+    /// }
+    /// ```
+    #[inline]
+    pub(super) fn column_name_unwrap(&self, col: usize) -> &str {
+        // Just panic if the bounds are wrong for now, we never call this
+        // without checking first.
+        self.column_name(col).expect("Column out of bounds")
+    }
+
+    /// Returns the name assigned to a particular column in the result set
+    /// returned by the prepared statement.
+    ///
+    /// If associated DB schema can be altered concurrently, you should make
+    /// sure that current statement has already been stepped once before
+    /// calling this method.
+    ///
+    /// ## Failure
+    ///
+    /// Returns an `Error::InvalidColumnIndex` if `idx` is outside the valid
+    /// column range for this row.
+    ///
+    /// Panics when column name is not valid UTF-8.
+    #[inline]
+    pub fn column_name(&self, col: usize) -> Result<&str> {
+        self.stmt
+            .column_name(col)
+            // clippy::or_fun_call (nightly) vs clippy::unnecessary-lazy-evaluations (stable)
+            .ok_or(Error::InvalidColumnIndex(col))
+            .map(|slice| {
+                str::from_utf8(slice.to_bytes()).expect("Invalid UTF-8 sequence in column name")
+            })
+    }
+
+    /// Returns the column index in the result set for a given column name.
+    ///
+    /// If there is no AS clause then the name of the column is unspecified and
+    /// may change from one release of SQLite to the next.
+    ///
+    /// If associated DB schema can be altered concurrently, you should make
+    /// sure that current statement has already been stepped once before
+    /// calling this method.
+    ///
+    /// # Failure
+    ///
+    /// Will return an `Error::InvalidColumnName` when there is no column with
+    /// the specified `name`.
+    #[inline]
+    pub fn column_index(&self, name: &str) -> Result<usize> {
+        let bytes = name.as_bytes();
+        let n = self.column_count();
+        for i in 0..n {
+            // Note: `column_name` is only fallible if `i` is out of bounds,
+            // which we've already checked.
+            if bytes.eq_ignore_ascii_case(self.stmt.column_name(i).unwrap().to_bytes()) {
+                return Ok(i);
+            }
+        }
+        Err(Error::InvalidColumnName(String::from(name)))
+    }
+
+    /// Returns a slice describing the columns of the result of the query.
+    ///
+    /// If associated DB schema can be altered concurrently, you should make
+    /// sure that current statement has already been stepped once before
+    /// calling this method.
+    #[cfg(feature = "column_decltype")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "column_decltype")))]
+    pub fn columns(&self) -> Vec<Column> {
+        let n = self.column_count();
+        let mut cols = Vec::with_capacity(n);
+        for i in 0..n {
+            let name = self.column_name_unwrap(i);
+            let slice = self.stmt.column_decltype(i);
+            let decl_type = slice.map(|s| {
+                str::from_utf8(s.to_bytes()).expect("Invalid UTF-8 sequence in column declaration")
+            });
+            cols.push(Column { name, decl_type });
+        }
+        cols
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::{Connection, Result};
+
+    #[test]
+    #[cfg(feature = "column_decltype")]
+    fn test_columns() -> Result<()> {
+        use super::Column;
+
+        let db = Connection::open_in_memory()?;
+        let query = db.prepare("SELECT * FROM sqlite_master")?;
+        let columns = query.columns();
+        let column_names: Vec<&str> = columns.iter().map(Column::name).collect();
+        assert_eq!(
+            column_names.as_slice(),
+            &["type", "name", "tbl_name", "rootpage", "sql"]
+        );
+        let column_types: Vec<Option<String>> = columns
+            .iter()
+            .map(|col| col.decl_type().map(str::to_lowercase))
+            .collect();
+        assert_eq!(
+            &column_types[..3],
+            &[
+                Some("text".to_owned()),
+                Some("text".to_owned()),
+                Some("text".to_owned()),
+            ]
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_column_name_in_error() -> Result<()> {
+        use crate::{types::Type, Error};
+        let db = Connection::open_in_memory()?;
+        db.execute_batch(
+            "BEGIN;
+             CREATE TABLE foo(x INTEGER, y TEXT);
+             INSERT INTO foo VALUES(4, NULL);
+             END;",
+        )?;
+        let mut stmt = db.prepare("SELECT x as renamed, y FROM foo")?;
+        let mut rows = stmt.query([])?;
+        let row = rows.next()?.unwrap();
+        match row.get::<_, String>(0).unwrap_err() {
+            Error::InvalidColumnType(idx, name, ty) => {
+                assert_eq!(idx, 0);
+                assert_eq!(name, "renamed");
+                assert_eq!(ty, Type::Integer);
+            }
+            e => {
+                panic!("Unexpected error type: {:?}", e);
+            }
+        }
+        match row.get::<_, String>("y").unwrap_err() {
+            Error::InvalidColumnType(idx, name, ty) => {
+                assert_eq!(idx, 1);
+                assert_eq!(name, "y");
+                assert_eq!(ty, Type::Null);
+            }
+            e => {
+                panic!("Unexpected error type: {:?}", e);
+            }
+        }
+        Ok(())
+    }
+
+    /// `column_name` reference should stay valid until `stmt` is reprepared (or
+    /// reset) even if DB schema is altered (SQLite documentation is
+    /// ambiguous here because it says reference "is valid until (...) the next
+    /// call to sqlite3_column_name() or sqlite3_column_name16() on the same
+    /// column.". We assume that reference is valid if only
+    /// `sqlite3_column_name()` is used):
+    #[test]
+    #[cfg(feature = "modern_sqlite")]
+    fn test_column_name_reference() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        db.execute_batch("CREATE TABLE y (x);")?;
+        let stmt = db.prepare("SELECT x FROM y;")?;
+        let column_name = stmt.column_name(0)?;
+        assert_eq!("x", column_name);
+        db.execute_batch("ALTER TABLE y RENAME COLUMN x TO z;")?;
+        // column name is not refreshed until statement is re-prepared
+        let same_column_name = stmt.column_name(0)?;
+        assert_eq!(same_column_name, column_name);
+        Ok(())
+    }
+}
diff --git a/crates/rusqlite/src/config.rs b/crates/rusqlite/src/config.rs
new file mode 100644
index 0000000..d0fa41a
--- /dev/null
+++ b/crates/rusqlite/src/config.rs
@@ -0,0 +1,156 @@
+//! Configure database connections
+
+use std::os::raw::c_int;
+
+use crate::error::check;
+use crate::ffi;
+use crate::{Connection, Result};
+
+/// Database Connection Configuration Options
+/// See [Database Connection Configuration Options](https://sqlite.org/c3ref/c_dbconfig_enable_fkey.html) for details.
+#[repr(i32)]
+#[allow(non_snake_case, non_camel_case_types)]
+#[non_exhaustive]
+#[allow(clippy::upper_case_acronyms)]
+pub enum DbConfig {
+    //SQLITE_DBCONFIG_MAINDBNAME = 1000, /* const char* */
+    //SQLITE_DBCONFIG_LOOKASIDE = 1001,  /* void* int int */
+    /// Enable or disable the enforcement of foreign key constraints.
+    SQLITE_DBCONFIG_ENABLE_FKEY = ffi::SQLITE_DBCONFIG_ENABLE_FKEY,
+    /// Enable or disable triggers.
+    SQLITE_DBCONFIG_ENABLE_TRIGGER = ffi::SQLITE_DBCONFIG_ENABLE_TRIGGER,
+    /// Enable or disable the fts3_tokenizer() function which is part of the
+    /// FTS3 full-text search engine extension.
+    SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER = ffi::SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER, // 3.12.0
+    //SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION = 1005,
+    /// In WAL mode, enable or disable the checkpoint operation before closing
+    /// the connection.
+    SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE = 1006, // 3.16.2
+    /// Activates or deactivates the query planner stability guarantee (QPSG).
+    SQLITE_DBCONFIG_ENABLE_QPSG = 1007, // 3.20.0
+    /// Includes or excludes output for any operations performed by trigger
+    /// programs from the output of EXPLAIN QUERY PLAN commands.
+    SQLITE_DBCONFIG_TRIGGER_EQP = 1008, // 3.22.0
+    /// Activates or deactivates the "reset" flag for a database connection.
+    /// Run VACUUM with this flag set to reset the database.
+    SQLITE_DBCONFIG_RESET_DATABASE = 1009, // 3.24.0
+    /// Activates or deactivates the "defensive" flag for a database connection.
+    SQLITE_DBCONFIG_DEFENSIVE = 1010, // 3.26.0
+    /// Activates or deactivates the "writable_schema" flag.
+    #[cfg(feature = "modern_sqlite")]
+    SQLITE_DBCONFIG_WRITABLE_SCHEMA = 1011, // 3.28.0
+    /// Activates or deactivates the legacy behavior of the ALTER TABLE RENAME
+    /// command.
+    #[cfg(feature = "modern_sqlite")]
+    SQLITE_DBCONFIG_LEGACY_ALTER_TABLE = 1012, // 3.29
+    /// Activates or deactivates the legacy double-quoted string literal
+    /// misfeature for DML statements only.
+    #[cfg(feature = "modern_sqlite")]
+    SQLITE_DBCONFIG_DQS_DML = 1013, // 3.29.0
+    /// Activates or deactivates the legacy double-quoted string literal
+    /// misfeature for DDL statements.
+    #[cfg(feature = "modern_sqlite")]
+    SQLITE_DBCONFIG_DQS_DDL = 1014, // 3.29.0
+    /// Enable or disable views.
+    #[cfg(feature = "modern_sqlite")]
+    SQLITE_DBCONFIG_ENABLE_VIEW = 1015, // 3.30.0
+    /// Activates or deactivates the legacy file format flag.
+    #[cfg(feature = "modern_sqlite")]
+    SQLITE_DBCONFIG_LEGACY_FILE_FORMAT = 1016, // 3.31.0
+    /// Tells SQLite to assume that database schemas (the contents of the
+    /// sqlite_master tables) are untainted by malicious content.
+    #[cfg(feature = "modern_sqlite")]
+    SQLITE_DBCONFIG_TRUSTED_SCHEMA = 1017, // 3.31.0
+}
+
+impl Connection {
+    /// Returns the current value of a `config`.
+    ///
+    /// - `SQLITE_DBCONFIG_ENABLE_FKEY`: return `false` or `true` to indicate
+    ///   whether FK enforcement is off or on
+    /// - `SQLITE_DBCONFIG_ENABLE_TRIGGER`: return `false` or `true` to indicate
+    ///   whether triggers are disabled or enabled
+    /// - `SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER`: return `false` or `true` to
+    ///   indicate whether `fts3_tokenizer` are disabled or enabled
+    /// - `SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE`: return `false` to indicate
+    ///   checkpoints-on-close are not disabled or `true` if they are
+    /// - `SQLITE_DBCONFIG_ENABLE_QPSG`: return `false` or `true` to indicate
+    ///   whether the QPSG is disabled or enabled
+    /// - `SQLITE_DBCONFIG_TRIGGER_EQP`: return `false` to indicate
+    ///   output-for-trigger are not disabled or `true` if it is
+    #[inline]
+    pub fn db_config(&self, config: DbConfig) -> Result<bool> {
+        let c = self.db.borrow();
+        unsafe {
+            let mut val = 0;
+            check(ffi::sqlite3_db_config(
+                c.db(),
+                config as c_int,
+                -1,
+                &mut val,
+            ))?;
+            Ok(val != 0)
+        }
+    }
+
+    /// Make configuration changes to a database connection
+    ///
+    /// - `SQLITE_DBCONFIG_ENABLE_FKEY`: `false` to disable FK enforcement,
+    ///   `true` to enable FK enforcement
+    /// - `SQLITE_DBCONFIG_ENABLE_TRIGGER`: `false` to disable triggers, `true`
+    ///   to enable triggers
+    /// - `SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER`: `false` to disable
+    ///   `fts3_tokenizer()`, `true` to enable `fts3_tokenizer()`
+    /// - `SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE`: `false` (the default) to enable
+    ///   checkpoints-on-close, `true` to disable them
+    /// - `SQLITE_DBCONFIG_ENABLE_QPSG`: `false` to disable the QPSG, `true` to
+    ///   enable QPSG
+    /// - `SQLITE_DBCONFIG_TRIGGER_EQP`: `false` to disable output for trigger
+    ///   programs, `true` to enable it
+    #[inline]
+    pub fn set_db_config(&self, config: DbConfig, new_val: bool) -> Result<bool> {
+        let c = self.db.borrow_mut();
+        unsafe {
+            let mut val = 0;
+            check(ffi::sqlite3_db_config(
+                c.db(),
+                config as c_int,
+                new_val as c_int,
+                &mut val,
+            ))?;
+            Ok(val != 0)
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::DbConfig;
+    use crate::{Connection, Result};
+
+    #[test]
+    fn test_db_config() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+
+        let opposite = !db.db_config(DbConfig::SQLITE_DBCONFIG_ENABLE_FKEY)?;
+        assert_eq!(
+            db.set_db_config(DbConfig::SQLITE_DBCONFIG_ENABLE_FKEY, opposite),
+            Ok(opposite)
+        );
+        assert_eq!(
+            db.db_config(DbConfig::SQLITE_DBCONFIG_ENABLE_FKEY),
+            Ok(opposite)
+        );
+
+        let opposite = !db.db_config(DbConfig::SQLITE_DBCONFIG_ENABLE_TRIGGER)?;
+        assert_eq!(
+            db.set_db_config(DbConfig::SQLITE_DBCONFIG_ENABLE_TRIGGER, opposite),
+            Ok(opposite)
+        );
+        assert_eq!(
+            db.db_config(DbConfig::SQLITE_DBCONFIG_ENABLE_TRIGGER),
+            Ok(opposite)
+        );
+        Ok(())
+    }
+}
diff --git a/crates/rusqlite/src/context.rs b/crates/rusqlite/src/context.rs
new file mode 100644
index 0000000..bcaefc9
--- /dev/null
+++ b/crates/rusqlite/src/context.rs
@@ -0,0 +1,75 @@
+//! Code related to `sqlite3_context` common to `functions` and `vtab` modules.
+
+use std::os::raw::{c_int, c_void};
+#[cfg(feature = "array")]
+use std::rc::Rc;
+
+use crate::ffi;
+use crate::ffi::sqlite3_context;
+
+use crate::str_for_sqlite;
+use crate::types::{ToSqlOutput, ValueRef};
+#[cfg(feature = "array")]
+use crate::vtab::array::{free_array, ARRAY_TYPE};
+
+// This function is inline despite it's size because what's in the ToSqlOutput
+// is often known to the compiler, and thus const prop/DCE can substantially
+// simplify the function.
+#[inline]
+pub(super) unsafe fn set_result(ctx: *mut sqlite3_context, result: &ToSqlOutput<'_>) {
+    let value = match *result {
+        ToSqlOutput::Borrowed(v) => v,
+        ToSqlOutput::Owned(ref v) => ValueRef::from(v),
+
+        #[cfg(feature = "blob")]
+        ToSqlOutput::ZeroBlob(len) => {
+            // TODO sqlite3_result_zeroblob64 // 3.8.11
+            return ffi::sqlite3_result_zeroblob(ctx, len);
+        }
+        #[cfg(feature = "array")]
+        ToSqlOutput::Array(ref a) => {
+            return ffi::sqlite3_result_pointer(
+                ctx,
+                Rc::into_raw(a.clone()) as *mut c_void,
+                ARRAY_TYPE,
+                Some(free_array),
+            );
+        }
+    };
+
+    match value {
+        ValueRef::Null => ffi::sqlite3_result_null(ctx),
+        ValueRef::Integer(i) => ffi::sqlite3_result_int64(ctx, i),
+        ValueRef::Real(r) => ffi::sqlite3_result_double(ctx, r),
+        ValueRef::Text(s) => {
+            let length = s.len();
+            if length > c_int::MAX as usize {
+                ffi::sqlite3_result_error_toobig(ctx);
+            } else {
+                let (c_str, len, destructor) = match str_for_sqlite(s) {
+                    Ok(c_str) => c_str,
+                    // TODO sqlite3_result_error
+                    Err(_) => return ffi::sqlite3_result_error_code(ctx, ffi::SQLITE_MISUSE),
+                };
+                // TODO sqlite3_result_text64 // 3.8.7
+                ffi::sqlite3_result_text(ctx, c_str, len, destructor);
+            }
+        }
+        ValueRef::Blob(b) => {
+            let length = b.len();
+            if length > c_int::MAX as usize {
+                ffi::sqlite3_result_error_toobig(ctx);
+            } else if length == 0 {
+                ffi::sqlite3_result_zeroblob(ctx, 0);
+            } else {
+                // TODO sqlite3_result_blob64 // 3.8.7
+                ffi::sqlite3_result_blob(
+                    ctx,
+                    b.as_ptr().cast::<c_void>(),
+                    length as c_int,
+                    ffi::SQLITE_TRANSIENT(),
+                );
+            }
+        }
+    }
+}
diff --git a/crates/rusqlite/src/error.rs b/crates/rusqlite/src/error.rs
new file mode 100644
index 0000000..797a216
--- /dev/null
+++ b/crates/rusqlite/src/error.rs
@@ -0,0 +1,445 @@
+use crate::types::FromSqlError;
+use crate::types::Type;
+use crate::{errmsg_to_string, ffi, Result};
+use std::error;
+use std::fmt;
+use std::os::raw::c_int;
+use std::path::PathBuf;
+use std::str;
+
+/// Enum listing possible errors from rusqlite.
+#[derive(Debug)]
+#[allow(clippy::enum_variant_names)]
+#[non_exhaustive]
+pub enum Error {
+    /// An error from an underlying SQLite call.
+    SqliteFailure(ffi::Error, Option<String>),
+
+    /// Error reported when attempting to open a connection when SQLite was
+    /// configured to allow single-threaded use only.
+    SqliteSingleThreadedMode,
+
+    /// Error when the value of a particular column is requested, but it cannot
+    /// be converted to the requested Rust type.
+    FromSqlConversionFailure(usize, Type, Box<dyn error::Error + Send + Sync + 'static>),
+
+    /// Error when SQLite gives us an integral value outside the range of the
+    /// requested type (e.g., trying to get the value 1000 into a `u8`).
+    /// The associated `usize` is the column index,
+    /// and the associated `i64` is the value returned by SQLite.
+    IntegralValueOutOfRange(usize, i64),
+
+    /// Error converting a string to UTF-8.
+    Utf8Error(str::Utf8Error),
+
+    /// Error converting a string to a C-compatible string because it contained
+    /// an embedded nul.
+    NulError(std::ffi::NulError),
+
+    /// Error when using SQL named parameters and passing a parameter name not
+    /// present in the SQL.
+    InvalidParameterName(String),
+
+    /// Error converting a file path to a string.
+    InvalidPath(PathBuf),
+
+    /// Error returned when an [`execute`](crate::Connection::execute) call
+    /// returns rows.
+    ExecuteReturnedResults,
+
+    /// Error when a query that was expected to return at least one row (e.g.,
+    /// for [`query_row`](crate::Connection::query_row)) did not return any.
+    QueryReturnedNoRows,
+
+    /// Error when the value of a particular column is requested, but the index
+    /// is out of range for the statement.
+    InvalidColumnIndex(usize),
+
+    /// Error when the value of a named column is requested, but no column
+    /// matches the name for the statement.
+    InvalidColumnName(String),
+
+    /// Error when the value of a particular column is requested, but the type
+    /// of the result in that column cannot be converted to the requested
+    /// Rust type.
+    InvalidColumnType(usize, String, Type),
+
+    /// Error when a query that was expected to insert one row did not insert
+    /// any or insert many.
+    StatementChangedRows(usize),
+
+    /// Error returned by
+    /// [`functions::Context::get`](crate::functions::Context::get) when the
+    /// function argument cannot be converted to the requested type.
+    #[cfg(feature = "functions")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "functions")))]
+    InvalidFunctionParameterType(usize, Type),
+    /// Error returned by [`vtab::Values::get`](crate::vtab::Values::get) when
+    /// the filter argument cannot be converted to the requested type.
+    #[cfg(feature = "vtab")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "vtab")))]
+    InvalidFilterParameterType(usize, Type),
+
+    /// An error case available for implementors of custom user functions (e.g.,
+    /// [`create_scalar_function`](crate::Connection::create_scalar_function)).
+    #[cfg(feature = "functions")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "functions")))]
+    #[allow(dead_code)]
+    UserFunctionError(Box<dyn error::Error + Send + Sync + 'static>),
+
+    /// Error available for the implementors of the
+    /// [`ToSql`](crate::types::ToSql) trait.
+    ToSqlConversionFailure(Box<dyn error::Error + Send + Sync + 'static>),
+
+    /// Error when the SQL is not a `SELECT`, is not read-only.
+    InvalidQuery,
+
+    /// An error case available for implementors of custom modules (e.g.,
+    /// [`create_module`](crate::Connection::create_module)).
+    #[cfg(feature = "vtab")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "vtab")))]
+    #[allow(dead_code)]
+    ModuleError(String),
+
+    /// An unwinding panic occurs in an UDF (user-defined function).
+    #[cfg(feature = "functions")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "functions")))]
+    UnwindingPanic,
+
+    /// An error returned when
+    /// [`Context::get_aux`](crate::functions::Context::get_aux) attempts to
+    /// retrieve data of a different type than what had been stored using
+    /// [`Context::set_aux`](crate::functions::Context::set_aux).
+    #[cfg(feature = "functions")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "functions")))]
+    GetAuxWrongType,
+
+    /// Error when the SQL contains multiple statements.
+    MultipleStatement,
+    /// Error when the number of bound parameters does not match the number of
+    /// parameters in the query. The first `usize` is how many parameters were
+    /// given, the 2nd is how many were expected.
+    InvalidParameterCount(usize, usize),
+
+    /// Returned from various functions in the Blob IO positional API. For
+    /// example,
+    /// [`Blob::raw_read_at_exact`](crate::blob::Blob::raw_read_at_exact) will
+    /// return it if the blob has insufficient data.
+    #[cfg(feature = "blob")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "blob")))]
+    BlobSizeError,
+    /// Error referencing a specific token in the input SQL
+    #[cfg(feature = "modern_sqlite")] // 3.38.0
+    #[cfg_attr(docsrs, doc(cfg(feature = "modern_sqlite")))]
+    SqlInputError {
+        /// error code
+        error: ffi::Error,
+        /// error message
+        msg: String,
+        /// SQL input
+        sql: String,
+        /// byte offset of the start of invalid token
+        offset: c_int,
+    },
+}
+
+impl PartialEq for Error {
+    fn eq(&self, other: &Error) -> bool {
+        match (self, other) {
+            (Error::SqliteFailure(e1, s1), Error::SqliteFailure(e2, s2)) => e1 == e2 && s1 == s2,
+            (Error::SqliteSingleThreadedMode, Error::SqliteSingleThreadedMode) => true,
+            (Error::IntegralValueOutOfRange(i1, n1), Error::IntegralValueOutOfRange(i2, n2)) => {
+                i1 == i2 && n1 == n2
+            }
+            (Error::Utf8Error(e1), Error::Utf8Error(e2)) => e1 == e2,
+            (Error::NulError(e1), Error::NulError(e2)) => e1 == e2,
+            (Error::InvalidParameterName(n1), Error::InvalidParameterName(n2)) => n1 == n2,
+            (Error::InvalidPath(p1), Error::InvalidPath(p2)) => p1 == p2,
+            (Error::ExecuteReturnedResults, Error::ExecuteReturnedResults) => true,
+            (Error::QueryReturnedNoRows, Error::QueryReturnedNoRows) => true,
+            (Error::InvalidColumnIndex(i1), Error::InvalidColumnIndex(i2)) => i1 == i2,
+            (Error::InvalidColumnName(n1), Error::InvalidColumnName(n2)) => n1 == n2,
+            (Error::InvalidColumnType(i1, n1, t1), Error::InvalidColumnType(i2, n2, t2)) => {
+                i1 == i2 && t1 == t2 && n1 == n2
+            }
+            (Error::StatementChangedRows(n1), Error::StatementChangedRows(n2)) => n1 == n2,
+            #[cfg(feature = "functions")]
+            (
+                Error::InvalidFunctionParameterType(i1, t1),
+                Error::InvalidFunctionParameterType(i2, t2),
+            ) => i1 == i2 && t1 == t2,
+            #[cfg(feature = "vtab")]
+            (
+                Error::InvalidFilterParameterType(i1, t1),
+                Error::InvalidFilterParameterType(i2, t2),
+            ) => i1 == i2 && t1 == t2,
+            (Error::InvalidQuery, Error::InvalidQuery) => true,
+            #[cfg(feature = "vtab")]
+            (Error::ModuleError(s1), Error::ModuleError(s2)) => s1 == s2,
+            #[cfg(feature = "functions")]
+            (Error::UnwindingPanic, Error::UnwindingPanic) => true,
+            #[cfg(feature = "functions")]
+            (Error::GetAuxWrongType, Error::GetAuxWrongType) => true,
+            (Error::InvalidParameterCount(i1, n1), Error::InvalidParameterCount(i2, n2)) => {
+                i1 == i2 && n1 == n2
+            }
+            #[cfg(feature = "blob")]
+            (Error::BlobSizeError, Error::BlobSizeError) => true,
+            #[cfg(feature = "modern_sqlite")]
+            (
+                Error::SqlInputError {
+                    error: e1,
+                    msg: m1,
+                    sql: s1,
+                    offset: o1,
+                },
+                Error::SqlInputError {
+                    error: e2,
+                    msg: m2,
+                    sql: s2,
+                    offset: o2,
+                },
+            ) => e1 == e2 && m1 == m2 && s1 == s2 && o1 == o2,
+            (..) => false,
+        }
+    }
+}
+
+impl From<str::Utf8Error> for Error {
+    #[cold]
+    fn from(err: str::Utf8Error) -> Error {
+        Error::Utf8Error(err)
+    }
+}
+
+impl From<std::ffi::NulError> for Error {
+    #[cold]
+    fn from(err: std::ffi::NulError) -> Error {
+        Error::NulError(err)
+    }
+}
+
+const UNKNOWN_COLUMN: usize = usize::MAX;
+
+/// The conversion isn't precise, but it's convenient to have it
+/// to allow use of `get_raw(…).as_…()?` in callbacks that take `Error`.
+impl From<FromSqlError> for Error {
+    #[cold]
+    fn from(err: FromSqlError) -> Error {
+        // The error type requires index and type fields, but they aren't known in this
+        // context.
+        match err {
+            FromSqlError::OutOfRange(val) => Error::IntegralValueOutOfRange(UNKNOWN_COLUMN, val),
+            FromSqlError::InvalidBlobSize { .. } => {
+                Error::FromSqlConversionFailure(UNKNOWN_COLUMN, Type::Blob, Box::new(err))
+            }
+            FromSqlError::Other(source) => {
+                Error::FromSqlConversionFailure(UNKNOWN_COLUMN, Type::Null, source)
+            }
+            _ => Error::FromSqlConversionFailure(UNKNOWN_COLUMN, Type::Null, Box::new(err)),
+        }
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            Error::SqliteFailure(ref err, None) => err.fmt(f),
+            Error::SqliteFailure(_, Some(ref s)) => write!(f, "{s}"),
+            Error::SqliteSingleThreadedMode => write!(
+                f,
+                "SQLite was compiled or configured for single-threaded use only"
+            ),
+            Error::FromSqlConversionFailure(i, ref t, ref err) => {
+                if i != UNKNOWN_COLUMN {
+                    write!(
+                        f,
+                        "Conversion error from type {} at index: {}, {}",
+                        t, i, err
+                    )
+                } else {
+                    err.fmt(f)
+                }
+            }
+            Error::IntegralValueOutOfRange(col, val) => {
+                if col != UNKNOWN_COLUMN {
+                    write!(f, "Integer {val} out of range at index {col}")
+                } else {
+                    write!(f, "Integer {val} out of range")
+                }
+            }
+            Error::Utf8Error(ref err) => err.fmt(f),
+            Error::NulError(ref err) => err.fmt(f),
+            Error::InvalidParameterName(ref name) => write!(f, "Invalid parameter name: {name}"),
+            Error::InvalidPath(ref p) => write!(f, "Invalid path: {}", p.to_string_lossy()),
+            Error::ExecuteReturnedResults => {
+                write!(f, "Execute returned results - did you mean to call query?")
+            }
+            Error::QueryReturnedNoRows => write!(f, "Query returned no rows"),
+            Error::InvalidColumnIndex(i) => write!(f, "Invalid column index: {i}"),
+            Error::InvalidColumnName(ref name) => write!(f, "Invalid column name: {name}"),
+            Error::InvalidColumnType(i, ref name, ref t) => write!(
+                f,
+                "Invalid column type {} at index: {}, name: {}",
+                t, i, name
+            ),
+            Error::InvalidParameterCount(i1, n1) => write!(
+                f,
+                "Wrong number of parameters passed to query. Got {}, needed {}",
+                i1, n1
+            ),
+            Error::StatementChangedRows(i) => write!(f, "Query changed {i} rows"),
+
+            #[cfg(feature = "functions")]
+            Error::InvalidFunctionParameterType(i, ref t) => {
+                write!(f, "Invalid function parameter type {t} at index {i}")
+            }
+            #[cfg(feature = "vtab")]
+            Error::InvalidFilterParameterType(i, ref t) => {
+                write!(f, "Invalid filter parameter type {t} at index {i}")
+            }
+            #[cfg(feature = "functions")]
+            Error::UserFunctionError(ref err) => err.fmt(f),
+            Error::ToSqlConversionFailure(ref err) => err.fmt(f),
+            Error::InvalidQuery => write!(f, "Query is not read-only"),
+            #[cfg(feature = "vtab")]
+            Error::ModuleError(ref desc) => write!(f, "{desc}"),
+            #[cfg(feature = "functions")]
+            Error::UnwindingPanic => write!(f, "unwinding panic"),
+            #[cfg(feature = "functions")]
+            Error::GetAuxWrongType => write!(f, "get_aux called with wrong type"),
+            Error::MultipleStatement => write!(f, "Multiple statements provided"),
+            #[cfg(feature = "blob")]
+            Error::BlobSizeError => "Blob size is insufficient".fmt(f),
+            #[cfg(feature = "modern_sqlite")]
+            Error::SqlInputError {
+                ref msg,
+                offset,
+                ref sql,
+                ..
+            } => write!(f, "{msg} in {sql} at offset {offset}"),
+        }
+    }
+}
+
+impl error::Error for Error {
+    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
+        match *self {
+            Error::SqliteFailure(ref err, _) => Some(err),
+            Error::Utf8Error(ref err) => Some(err),
+            Error::NulError(ref err) => Some(err),
+
+            Error::IntegralValueOutOfRange(..)
+            | Error::SqliteSingleThreadedMode
+            | Error::InvalidParameterName(_)
+            | Error::ExecuteReturnedResults
+            | Error::QueryReturnedNoRows
+            | Error::InvalidColumnIndex(_)
+            | Error::InvalidColumnName(_)
+            | Error::InvalidColumnType(..)
+            | Error::InvalidPath(_)
+            | Error::InvalidParameterCount(..)
+            | Error::StatementChangedRows(_)
+            | Error::InvalidQuery
+            | Error::MultipleStatement => None,
+
+            #[cfg(feature = "functions")]
+            Error::InvalidFunctionParameterType(..) => None,
+            #[cfg(feature = "vtab")]
+            Error::InvalidFilterParameterType(..) => None,
+
+            #[cfg(feature = "functions")]
+            Error::UserFunctionError(ref err) => Some(&**err),
+
+            Error::FromSqlConversionFailure(_, _, ref err)
+            | Error::ToSqlConversionFailure(ref err) => Some(&**err),
+
+            #[cfg(feature = "vtab")]
+            Error::ModuleError(_) => None,
+
+            #[cfg(feature = "functions")]
+            Error::UnwindingPanic => None,
+
+            #[cfg(feature = "functions")]
+            Error::GetAuxWrongType => None,
+
+            #[cfg(feature = "blob")]
+            Error::BlobSizeError => None,
+            #[cfg(feature = "modern_sqlite")]
+            Error::SqlInputError { ref error, .. } => Some(error),
+        }
+    }
+}
+
+impl Error {
+    /// Returns the underlying SQLite error if this is [`Error::SqliteFailure`].
+    #[inline]
+    pub fn sqlite_error(&self) -> Option<&ffi::Error> {
+        match self {
+            Self::SqliteFailure(error, _) => Some(error),
+            _ => None,
+        }
+    }
+
+    /// Returns the underlying SQLite error code if this is
+    /// [`Error::SqliteFailure`].
+    #[inline]
+    pub fn sqlite_error_code(&self) -> Option<ffi::ErrorCode> {
+        self.sqlite_error().map(|error| error.code)
+    }
+}
+
+// These are public but not re-exported by lib.rs, so only visible within crate.
+
+#[cold]
+pub fn error_from_sqlite_code(code: c_int, message: Option<String>) -> Error {
+    // TODO sqlite3_error_offset // 3.38.0, #1130
+    Error::SqliteFailure(ffi::Error::new(code), message)
+}
+
+#[cold]
+pub unsafe fn error_from_handle(db: *mut ffi::sqlite3, code: c_int) -> Error {
+    let message = if db.is_null() {
+        None
+    } else {
+        Some(errmsg_to_string(ffi::sqlite3_errmsg(db)))
+    };
+    error_from_sqlite_code(code, message)
+}
+
+#[cold]
+#[cfg(not(feature = "modern_sqlite"))] // SQLite >= 3.38.0
+pub unsafe fn error_with_offset(db: *mut ffi::sqlite3, code: c_int, _sql: &str) -> Error {
+    error_from_handle(db, code)
+}
+
+#[cold]
+#[cfg(feature = "modern_sqlite")] // SQLite >= 3.38.0
+pub unsafe fn error_with_offset(db: *mut ffi::sqlite3, code: c_int, sql: &str) -> Error {
+    if db.is_null() {
+        error_from_sqlite_code(code, None)
+    } else {
+        let error = ffi::Error::new(code);
+        let msg = errmsg_to_string(ffi::sqlite3_errmsg(db));
+        if ffi::ErrorCode::Unknown == error.code {
+            let offset = ffi::sqlite3_error_offset(db);
+            if offset >= 0 {
+                return Error::SqlInputError {
+                    error,
+                    msg,
+                    sql: sql.to_owned(),
+                    offset,
+                };
+            }
+        }
+        Error::SqliteFailure(error, Some(msg))
+    }
+}
+
+pub fn check(code: c_int) -> Result<()> {
+    if code != crate::ffi::SQLITE_OK {
+        Err(error_from_sqlite_code(code, None))
+    } else {
+        Ok(())
+    }
+}
diff --git a/crates/rusqlite/src/functions.rs b/crates/rusqlite/src/functions.rs
new file mode 100644
index 0000000..2ae29a8
--- /dev/null
+++ b/crates/rusqlite/src/functions.rs
@@ -0,0 +1,1083 @@
+//! Create or redefine SQL functions.
+//!
+//! # Example
+//!
+//! Adding a `regexp` function to a connection in which compiled regular
+//! expressions are cached in a `HashMap`. For an alternative implementation
+//! that uses SQLite's [Function Auxiliary Data](https://www.sqlite.org/c3ref/get_auxdata.html) interface
+//! to avoid recompiling regular expressions, see the unit tests for this
+//! module.
+//!
+//! ```rust
+//! use regex::Regex;
+//! use rusqlite::functions::FunctionFlags;
+//! use rusqlite::{Connection, Error, Result};
+//! use std::sync::Arc;
+//! type BoxError = Box<dyn std::error::Error + Send + Sync + 'static>;
+//!
+//! fn add_regexp_function(db: &Connection) -> Result<()> {
+//!     db.create_scalar_function(
+//!         "regexp",
+//!         2,
+//!         FunctionFlags::SQLITE_UTF8 | FunctionFlags::SQLITE_DETERMINISTIC,
+//!         move |ctx| {
+//!             assert_eq!(ctx.len(), 2, "called with unexpected number of arguments");
+//!             let regexp: Arc<Regex> = ctx.get_or_create_aux(0, |vr| -> Result<_, BoxError> {
+//!                 Ok(Regex::new(vr.as_str()?)?)
+//!             })?;
+//!             let is_match = {
+//!                 let text = ctx
+//!                     .get_raw(1)
+//!                     .as_str()
+//!                     .map_err(|e| Error::UserFunctionError(e.into()))?;
+//!
+//!                 regexp.is_match(text)
+//!             };
+//!
+//!             Ok(is_match)
+//!         },
+//!     )
+//! }
+//!
+//! fn main() -> Result<()> {
+//!     let db = Connection::open_in_memory()?;
+//!     add_regexp_function(&db)?;
+//!
+//!     let is_match: bool =
+//!         db.query_row("SELECT regexp('[aeiou]*', 'aaaaeeeiii')", [], |row| {
+//!             row.get(0)
+//!         })?;
+//!
+//!     assert!(is_match);
+//!     Ok(())
+//! }
+//! ```
+use std::any::Any;
+use std::marker::PhantomData;
+use std::ops::Deref;
+use std::os::raw::{c_int, c_void};
+use std::panic::{catch_unwind, RefUnwindSafe, UnwindSafe};
+use std::ptr;
+use std::slice;
+use std::sync::Arc;
+
+use crate::ffi;
+use crate::ffi::sqlite3_context;
+use crate::ffi::sqlite3_value;
+
+use crate::context::set_result;
+use crate::types::{FromSql, FromSqlError, ToSql, ValueRef};
+
+use crate::{str_to_cstring, Connection, Error, InnerConnection, Result};
+
+unsafe fn report_error(ctx: *mut sqlite3_context, err: &Error) {
+    // Extended constraint error codes were added in SQLite 3.7.16. We don't have
+    // an explicit feature check for that, and this doesn't really warrant one.
+    // We'll use the extended code if we're on the bundled version (since it's
+    // at least 3.17.0) and the normal constraint error code if not.
+    fn constraint_error_code() -> i32 {
+        ffi::SQLITE_CONSTRAINT_FUNCTION
+    }
+
+    if let Error::SqliteFailure(ref err, ref s) = *err {
+        ffi::sqlite3_result_error_code(ctx, err.extended_code);
+        if let Some(Ok(cstr)) = s.as_ref().map(|s| str_to_cstring(s)) {
+            ffi::sqlite3_result_error(ctx, cstr.as_ptr(), -1);
+        }
+    } else {
+        ffi::sqlite3_result_error_code(ctx, constraint_error_code());
+        if let Ok(cstr) = str_to_cstring(&err.to_string()) {
+            ffi::sqlite3_result_error(ctx, cstr.as_ptr(), -1);
+        }
+    }
+}
+
+unsafe extern "C" fn free_boxed_value<T>(p: *mut c_void) {
+    drop(Box::from_raw(p.cast::<T>()));
+}
+
+/// Context is a wrapper for the SQLite function
+/// evaluation context.
+pub struct Context<'a> {
+    ctx: *mut sqlite3_context,
+    args: &'a [*mut sqlite3_value],
+}
+
+impl Context<'_> {
+    /// Returns the number of arguments to the function.
+    #[inline]
+    #[must_use]
+    pub fn len(&self) -> usize {
+        self.args.len()
+    }
+
+    /// Returns `true` when there is no argument.
+    #[inline]
+    #[must_use]
+    pub fn is_empty(&self) -> bool {
+        self.args.is_empty()
+    }
+
+    /// Returns the `idx`th argument as a `T`.
+    ///
+    /// # Failure
+    ///
+    /// Will panic if `idx` is greater than or equal to
+    /// [`self.len()`](Context::len).
+    ///
+    /// Will return Err if the underlying SQLite type cannot be converted to a
+    /// `T`.
+    pub fn get<T: FromSql>(&self, idx: usize) -> Result<T> {
+        let arg = self.args[idx];
+        let value = unsafe { ValueRef::from_value(arg) };
+        FromSql::column_result(value).map_err(|err| match err {
+            FromSqlError::InvalidType => {
+                Error::InvalidFunctionParameterType(idx, value.data_type())
+            }
+            FromSqlError::OutOfRange(i) => Error::IntegralValueOutOfRange(idx, i),
+            FromSqlError::Other(err) => {
+                Error::FromSqlConversionFailure(idx, value.data_type(), err)
+            }
+            FromSqlError::InvalidBlobSize { .. } => {
+                Error::FromSqlConversionFailure(idx, value.data_type(), Box::new(err))
+            }
+        })
+    }
+
+    /// Returns the `idx`th argument as a `ValueRef`.
+    ///
+    /// # Failure
+    ///
+    /// Will panic if `idx` is greater than or equal to
+    /// [`self.len()`](Context::len).
+    #[inline]
+    #[must_use]
+    pub fn get_raw(&self, idx: usize) -> ValueRef<'_> {
+        let arg = self.args[idx];
+        unsafe { ValueRef::from_value(arg) }
+    }
+
+    /// Returns the subtype of `idx`th argument.
+    ///
+    /// # Failure
+    ///
+    /// Will panic if `idx` is greater than or equal to
+    /// [`self.len()`](Context::len).
+    pub fn get_subtype(&self, idx: usize) -> std::os::raw::c_uint {
+        let arg = self.args[idx];
+        unsafe { ffi::sqlite3_value_subtype(arg) }
+    }
+
+    /// Fetch or insert the auxiliary data associated with a particular
+    /// parameter. This is intended to be an easier-to-use way of fetching it
+    /// compared to calling [`get_aux`](Context::get_aux) and
+    /// [`set_aux`](Context::set_aux) separately.
+    ///
+    /// See `https://www.sqlite.org/c3ref/get_auxdata.html` for a discussion of
+    /// this feature, or the unit tests of this module for an example.
+    pub fn get_or_create_aux<T, E, F>(&self, arg: c_int, func: F) -> Result<Arc<T>>
+    where
+        T: Send + Sync + 'static,
+        E: Into<Box<dyn std::error::Error + Send + Sync + 'static>>,
+        F: FnOnce(ValueRef<'_>) -> Result<T, E>,
+    {
+        if let Some(v) = self.get_aux(arg)? {
+            Ok(v)
+        } else {
+            let vr = self.get_raw(arg as usize);
+            self.set_aux(
+                arg,
+                func(vr).map_err(|e| Error::UserFunctionError(e.into()))?,
+            )
+        }
+    }
+
+    /// Sets the auxiliary data associated with a particular parameter. See
+    /// `https://www.sqlite.org/c3ref/get_auxdata.html` for a discussion of
+    /// this feature, or the unit tests of this module for an example.
+    pub fn set_aux<T: Send + Sync + 'static>(&self, arg: c_int, value: T) -> Result<Arc<T>> {
+        let orig: Arc<T> = Arc::new(value);
+        let inner: AuxInner = orig.clone();
+        let outer = Box::new(inner);
+        let raw: *mut AuxInner = Box::into_raw(outer);
+        unsafe {
+            ffi::sqlite3_set_auxdata(
+                self.ctx,
+                arg,
+                raw.cast(),
+                Some(free_boxed_value::<AuxInner>),
+            );
+        };
+        Ok(orig)
+    }
+
+    /// Gets the auxiliary data that was associated with a given parameter via
+    /// [`set_aux`](Context::set_aux). Returns `Ok(None)` if no data has been
+    /// associated, and Ok(Some(v)) if it has. Returns an error if the
+    /// requested type does not match.
+    pub fn get_aux<T: Send + Sync + 'static>(&self, arg: c_int) -> Result<Option<Arc<T>>> {
+        let p = unsafe { ffi::sqlite3_get_auxdata(self.ctx, arg) as *const AuxInner };
+        if p.is_null() {
+            Ok(None)
+        } else {
+            let v: AuxInner = AuxInner::clone(unsafe { &*p });
+            v.downcast::<T>()
+                .map(Some)
+                .map_err(|_| Error::GetAuxWrongType)
+        }
+    }
+
+    /// Get the db connection handle via [sqlite3_context_db_handle](https://www.sqlite.org/c3ref/context_db_handle.html)
+    ///
+    /// # Safety
+    ///
+    /// This function is marked unsafe because there is a potential for other
+    /// references to the connection to be sent across threads, [see this comment](https://github.com/rusqlite/rusqlite/issues/643#issuecomment-640181213).
+    pub unsafe fn get_connection(&self) -> Result<ConnectionRef<'_>> {
+        let handle = ffi::sqlite3_context_db_handle(self.ctx);
+        Ok(ConnectionRef {
+            conn: Connection::from_handle(handle)?,
+            phantom: PhantomData,
+        })
+    }
+
+    /// Set the Subtype of an SQL function
+    pub fn set_result_subtype(&self, sub_type: std::os::raw::c_uint) {
+        unsafe { ffi::sqlite3_result_subtype(self.ctx, sub_type) };
+    }
+}
+
+/// A reference to a connection handle with a lifetime bound to something.
+pub struct ConnectionRef<'ctx> {
+    // comes from Connection::from_handle(sqlite3_context_db_handle(...))
+    // and is non-owning
+    conn: Connection,
+    phantom: PhantomData<&'ctx Context<'ctx>>,
+}
+
+impl Deref for ConnectionRef<'_> {
+    type Target = Connection;
+
+    #[inline]
+    fn deref(&self) -> &Connection {
+        &self.conn
+    }
+}
+
+type AuxInner = Arc<dyn Any + Send + Sync + 'static>;
+
+/// Aggregate is the callback interface for user-defined
+/// aggregate function.
+///
+/// `A` is the type of the aggregation context and `T` is the type of the final
+/// result. Implementations should be stateless.
+pub trait Aggregate<A, T>
+where
+    A: RefUnwindSafe + UnwindSafe,
+    T: ToSql,
+{
+    /// Initializes the aggregation context. Will be called prior to the first
+    /// call to [`step()`](Aggregate::step) to set up the context for an
+    /// invocation of the function. (Note: `init()` will not be called if
+    /// there are no rows.)
+    fn init(&self, _: &mut Context<'_>) -> Result<A>;
+
+    /// "step" function called once for each row in an aggregate group. May be
+    /// called 0 times if there are no rows.
+    fn step(&self, _: &mut Context<'_>, _: &mut A) -> Result<()>;
+
+    /// Computes and returns the final result. Will be called exactly once for
+    /// each invocation of the function. If [`step()`](Aggregate::step) was
+    /// called at least once, will be given `Some(A)` (the same `A` as was
+    /// created by [`init`](Aggregate::init) and given to
+    /// [`step`](Aggregate::step)); if [`step()`](Aggregate::step) was not
+    /// called (because the function is running against 0 rows), will be
+    /// given `None`.
+    ///
+    /// The passed context will have no arguments.
+    fn finalize(&self, _: &mut Context<'_>, _: Option<A>) -> Result<T>;
+}
+
+/// `WindowAggregate` is the callback interface for
+/// user-defined aggregate window function.
+#[cfg(feature = "window")]
+#[cfg_attr(docsrs, doc(cfg(feature = "window")))]
+pub trait WindowAggregate<A, T>: Aggregate<A, T>
+where
+    A: RefUnwindSafe + UnwindSafe,
+    T: ToSql,
+{
+    /// Returns the current value of the aggregate. Unlike xFinal, the
+    /// implementation should not delete any context.
+    fn value(&self, _: Option<&A>) -> Result<T>;
+
+    /// Removes a row from the current window.
+    fn inverse(&self, _: &mut Context<'_>, _: &mut A) -> Result<()>;
+}
+
+bitflags::bitflags! {
+    /// Function Flags.
+    /// See [sqlite3_create_function](https://sqlite.org/c3ref/create_function.html)
+    /// and [Function Flags](https://sqlite.org/c3ref/c_deterministic.html) for details.
+    #[repr(C)]
+    pub struct FunctionFlags: ::std::os::raw::c_int {
+        /// Specifies UTF-8 as the text encoding this SQL function prefers for its parameters.
+        const SQLITE_UTF8     = ffi::SQLITE_UTF8;
+        /// Specifies UTF-16 using little-endian byte order as the text encoding this SQL function prefers for its parameters.
+        const SQLITE_UTF16LE  = ffi::SQLITE_UTF16LE;
+        /// Specifies UTF-16 using big-endian byte order as the text encoding this SQL function prefers for its parameters.
+        const SQLITE_UTF16BE  = ffi::SQLITE_UTF16BE;
+        /// Specifies UTF-16 using native byte order as the text encoding this SQL function prefers for its parameters.
+        const SQLITE_UTF16    = ffi::SQLITE_UTF16;
+        /// Means that the function always gives the same output when the input parameters are the same.
+        const SQLITE_DETERMINISTIC = ffi::SQLITE_DETERMINISTIC; // 3.8.3
+        /// Means that the function may only be invoked from top-level SQL.
+        const SQLITE_DIRECTONLY    = 0x0000_0008_0000; // 3.30.0
+        /// Indicates to SQLite that a function may call `sqlite3_value_subtype()` to inspect the sub-types of its arguments.
+        const SQLITE_SUBTYPE       = 0x0000_0010_0000; // 3.30.0
+        /// Means that the function is unlikely to cause problems even if misused.
+        const SQLITE_INNOCUOUS     = 0x0000_0020_0000; // 3.31.0
+    }
+}
+
+impl Default for FunctionFlags {
+    #[inline]
+    fn default() -> FunctionFlags {
+        FunctionFlags::SQLITE_UTF8
+    }
+}
+
+impl Connection {
+    /// Attach a user-defined scalar function to
+    /// this database connection.
+    ///
+    /// `fn_name` is the name the function will be accessible from SQL.
+    /// `n_arg` is the number of arguments to the function. Use `-1` for a
+    /// variable number. If the function always returns the same value
+    /// given the same input, `deterministic` should be `true`.
+    ///
+    /// The function will remain available until the connection is closed or
+    /// until it is explicitly removed via
+    /// [`remove_function`](Connection::remove_function).
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # use rusqlite::{Connection, Result};
+    /// # use rusqlite::functions::FunctionFlags;
+    /// fn scalar_function_example(db: Connection) -> Result<()> {
+    ///     db.create_scalar_function(
+    ///         "halve",
+    ///         1,
+    ///         FunctionFlags::SQLITE_UTF8 | FunctionFlags::SQLITE_DETERMINISTIC,
+    ///         |ctx| {
+    ///             let value = ctx.get::<f64>(0)?;
+    ///             Ok(value / 2f64)
+    ///         },
+    ///     )?;
+    ///
+    ///     let six_halved: f64 = db.query_row("SELECT halve(6)", [], |r| r.get(0))?;
+    ///     assert_eq!(six_halved, 3f64);
+    ///     Ok(())
+    /// }
+    /// ```
+    ///
+    /// # Failure
+    ///
+    /// Will return Err if the function could not be attached to the connection.
+    #[inline]
+    pub fn create_scalar_function<F, T>(
+        &self,
+        fn_name: &str,
+        n_arg: c_int,
+        flags: FunctionFlags,
+        x_func: F,
+    ) -> Result<()>
+    where
+        F: FnMut(&Context<'_>) -> Result<T> + Send + UnwindSafe + 'static,
+        T: ToSql,
+    {
+        self.db
+            .borrow_mut()
+            .create_scalar_function(fn_name, n_arg, flags, x_func)
+    }
+
+    /// Attach a user-defined aggregate function to this
+    /// database connection.
+    ///
+    /// # Failure
+    ///
+    /// Will return Err if the function could not be attached to the connection.
+    #[inline]
+    pub fn create_aggregate_function<A, D, T>(
+        &self,
+        fn_name: &str,
+        n_arg: c_int,
+        flags: FunctionFlags,
+        aggr: D,
+    ) -> Result<()>
+    where
+        A: RefUnwindSafe + UnwindSafe,
+        D: Aggregate<A, T> + 'static,
+        T: ToSql,
+    {
+        self.db
+            .borrow_mut()
+            .create_aggregate_function(fn_name, n_arg, flags, aggr)
+    }
+
+    /// Attach a user-defined aggregate window function to
+    /// this database connection.
+    ///
+    /// See `https://sqlite.org/windowfunctions.html#udfwinfunc` for more
+    /// information.
+    #[cfg(feature = "window")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "window")))]
+    #[inline]
+    pub fn create_window_function<A, W, T>(
+        &self,
+        fn_name: &str,
+        n_arg: c_int,
+        flags: FunctionFlags,
+        aggr: W,
+    ) -> Result<()>
+    where
+        A: RefUnwindSafe + UnwindSafe,
+        W: WindowAggregate<A, T> + 'static,
+        T: ToSql,
+    {
+        self.db
+            .borrow_mut()
+            .create_window_function(fn_name, n_arg, flags, aggr)
+    }
+
+    /// Removes a user-defined function from this
+    /// database connection.
+    ///
+    /// `fn_name` and `n_arg` should match the name and number of arguments
+    /// given to [`create_scalar_function`](Connection::create_scalar_function)
+    /// or [`create_aggregate_function`](Connection::create_aggregate_function).
+    ///
+    /// # Failure
+    ///
+    /// Will return Err if the function could not be removed.
+    #[inline]
+    pub fn remove_function(&self, fn_name: &str, n_arg: c_int) -> Result<()> {
+        self.db.borrow_mut().remove_function(fn_name, n_arg)
+    }
+}
+
+impl InnerConnection {
+    fn create_scalar_function<F, T>(
+        &mut self,
+        fn_name: &str,
+        n_arg: c_int,
+        flags: FunctionFlags,
+        x_func: F,
+    ) -> Result<()>
+    where
+        F: FnMut(&Context<'_>) -> Result<T> + Send + UnwindSafe + 'static,
+        T: ToSql,
+    {
+        unsafe extern "C" fn call_boxed_closure<F, T>(
+            ctx: *mut sqlite3_context,
+            argc: c_int,
+            argv: *mut *mut sqlite3_value,
+        ) where
+            F: FnMut(&Context<'_>) -> Result<T>,
+            T: ToSql,
+        {
+            let r = catch_unwind(|| {
+                let boxed_f: *mut F = ffi::sqlite3_user_data(ctx).cast::<F>();
+                assert!(!boxed_f.is_null(), "Internal error - null function pointer");
+                let ctx = Context {
+                    ctx,
+                    args: slice::from_raw_parts(argv, argc as usize),
+                };
+                (*boxed_f)(&ctx)
+            });
+            let t = match r {
+                Err(_) => {
+                    report_error(ctx, &Error::UnwindingPanic);
+                    return;
+                }
+                Ok(r) => r,
+            };
+            let t = t.as_ref().map(|t| ToSql::to_sql(t));
+
+            match t {
+                Ok(Ok(ref value)) => set_result(ctx, value),
+                Ok(Err(err)) => report_error(ctx, &err),
+                Err(err) => report_error(ctx, err),
+            }
+        }
+
+        let boxed_f: *mut F = Box::into_raw(Box::new(x_func));
+        let c_name = str_to_cstring(fn_name)?;
+        let r = unsafe {
+            ffi::sqlite3_create_function_v2(
+                self.db(),
+                c_name.as_ptr(),
+                n_arg,
+                flags.bits(),
+                boxed_f.cast::<c_void>(),
+                Some(call_boxed_closure::<F, T>),
+                None,
+                None,
+                Some(free_boxed_value::<F>),
+            )
+        };
+        self.decode_result(r)
+    }
+
+    fn create_aggregate_function<A, D, T>(
+        &mut self,
+        fn_name: &str,
+        n_arg: c_int,
+        flags: FunctionFlags,
+        aggr: D,
+    ) -> Result<()>
+    where
+        A: RefUnwindSafe + UnwindSafe,
+        D: Aggregate<A, T> + 'static,
+        T: ToSql,
+    {
+        let boxed_aggr: *mut D = Box::into_raw(Box::new(aggr));
+        let c_name = str_to_cstring(fn_name)?;
+        let r = unsafe {
+            ffi::sqlite3_create_function_v2(
+                self.db(),
+                c_name.as_ptr(),
+                n_arg,
+                flags.bits(),
+                boxed_aggr.cast::<c_void>(),
+                None,
+                Some(call_boxed_step::<A, D, T>),
+                Some(call_boxed_final::<A, D, T>),
+                Some(free_boxed_value::<D>),
+            )
+        };
+        self.decode_result(r)
+    }
+
+    #[cfg(feature = "window")]
+    fn create_window_function<A, W, T>(
+        &mut self,
+        fn_name: &str,
+        n_arg: c_int,
+        flags: FunctionFlags,
+        aggr: W,
+    ) -> Result<()>
+    where
+        A: RefUnwindSafe + UnwindSafe,
+        W: WindowAggregate<A, T> + 'static,
+        T: ToSql,
+    {
+        let boxed_aggr: *mut W = Box::into_raw(Box::new(aggr));
+        let c_name = str_to_cstring(fn_name)?;
+        let r = unsafe {
+            ffi::sqlite3_create_window_function(
+                self.db(),
+                c_name.as_ptr(),
+                n_arg,
+                flags.bits(),
+                boxed_aggr.cast::<c_void>(),
+                Some(call_boxed_step::<A, W, T>),
+                Some(call_boxed_final::<A, W, T>),
+                Some(call_boxed_value::<A, W, T>),
+                Some(call_boxed_inverse::<A, W, T>),
+                Some(free_boxed_value::<W>),
+            )
+        };
+        self.decode_result(r)
+    }
+
+    fn remove_function(&mut self, fn_name: &str, n_arg: c_int) -> Result<()> {
+        let c_name = str_to_cstring(fn_name)?;
+        let r = unsafe {
+            ffi::sqlite3_create_function_v2(
+                self.db(),
+                c_name.as_ptr(),
+                n_arg,
+                ffi::SQLITE_UTF8,
+                ptr::null_mut(),
+                None,
+                None,
+                None,
+                None,
+            )
+        };
+        self.decode_result(r)
+    }
+}
+
+unsafe fn aggregate_context<A>(ctx: *mut sqlite3_context, bytes: usize) -> Option<*mut *mut A> {
+    let pac = ffi::sqlite3_aggregate_context(ctx, bytes as c_int) as *mut *mut A;
+    if pac.is_null() {
+        return None;
+    }
+    Some(pac)
+}
+
+unsafe extern "C" fn call_boxed_step<A, D, T>(
+    ctx: *mut sqlite3_context,
+    argc: c_int,
+    argv: *mut *mut sqlite3_value,
+) where
+    A: RefUnwindSafe + UnwindSafe,
+    D: Aggregate<A, T>,
+    T: ToSql,
+{
+    let pac = if let Some(pac) = aggregate_context(ctx, std::mem::size_of::<*mut A>()) {
+        pac
+    } else {
+        ffi::sqlite3_result_error_nomem(ctx);
+        return;
+    };
+
+    let r = catch_unwind(|| {
+        let boxed_aggr: *mut D = ffi::sqlite3_user_data(ctx).cast::<D>();
+        assert!(
+            !boxed_aggr.is_null(),
+            "Internal error - null aggregate pointer"
+        );
+        let mut ctx = Context {
+            ctx,
+            args: slice::from_raw_parts(argv, argc as usize),
+        };
+
+        if (*pac as *mut A).is_null() {
+            *pac = Box::into_raw(Box::new((*boxed_aggr).init(&mut ctx)?));
+        }
+
+        (*boxed_aggr).step(&mut ctx, &mut **pac)
+    });
+    let r = match r {
+        Err(_) => {
+            report_error(ctx, &Error::UnwindingPanic);
+            return;
+        }
+        Ok(r) => r,
+    };
+    match r {
+        Ok(_) => {}
+        Err(err) => report_error(ctx, &err),
+    };
+}
+
+#[cfg(feature = "window")]
+unsafe extern "C" fn call_boxed_inverse<A, W, T>(
+    ctx: *mut sqlite3_context,
+    argc: c_int,
+    argv: *mut *mut sqlite3_value,
+) where
+    A: RefUnwindSafe + UnwindSafe,
+    W: WindowAggregate<A, T>,
+    T: ToSql,
+{
+    let pac = if let Some(pac) = aggregate_context(ctx, std::mem::size_of::<*mut A>()) {
+        pac
+    } else {
+        ffi::sqlite3_result_error_nomem(ctx);
+        return;
+    };
+
+    let r = catch_unwind(|| {
+        let boxed_aggr: *mut W = ffi::sqlite3_user_data(ctx).cast::<W>();
+        assert!(
+            !boxed_aggr.is_null(),
+            "Internal error - null aggregate pointer"
+        );
+        let mut ctx = Context {
+            ctx,
+            args: slice::from_raw_parts(argv, argc as usize),
+        };
+        (*boxed_aggr).inverse(&mut ctx, &mut **pac)
+    });
+    let r = match r {
+        Err(_) => {
+            report_error(ctx, &Error::UnwindingPanic);
+            return;
+        }
+        Ok(r) => r,
+    };
+    match r {
+        Ok(_) => {}
+        Err(err) => report_error(ctx, &err),
+    };
+}
+
+unsafe extern "C" fn call_boxed_final<A, D, T>(ctx: *mut sqlite3_context)
+where
+    A: RefUnwindSafe + UnwindSafe,
+    D: Aggregate<A, T>,
+    T: ToSql,
+{
+    // Within the xFinal callback, it is customary to set N=0 in calls to
+    // sqlite3_aggregate_context(C,N) so that no pointless memory allocations occur.
+    let a: Option<A> = match aggregate_context(ctx, 0) {
+        Some(pac) => {
+            if (*pac as *mut A).is_null() {
+                None
+            } else {
+                let a = Box::from_raw(*pac);
+                Some(*a)
+            }
+        }
+        None => None,
+    };
+
+    let r = catch_unwind(|| {
+        let boxed_aggr: *mut D = ffi::sqlite3_user_data(ctx).cast::<D>();
+        assert!(
+            !boxed_aggr.is_null(),
+            "Internal error - null aggregate pointer"
+        );
+        let mut ctx = Context { ctx, args: &mut [] };
+        (*boxed_aggr).finalize(&mut ctx, a)
+    });
+    let t = match r {
+        Err(_) => {
+            report_error(ctx, &Error::UnwindingPanic);
+            return;
+        }
+        Ok(r) => r,
+    };
+    let t = t.as_ref().map(|t| ToSql::to_sql(t));
+    match t {
+        Ok(Ok(ref value)) => set_result(ctx, value),
+        Ok(Err(err)) => report_error(ctx, &err),
+        Err(err) => report_error(ctx, err),
+    }
+}
+
+#[cfg(feature = "window")]
+unsafe extern "C" fn call_boxed_value<A, W, T>(ctx: *mut sqlite3_context)
+where
+    A: RefUnwindSafe + UnwindSafe,
+    W: WindowAggregate<A, T>,
+    T: ToSql,
+{
+    // Within the xValue callback, it is customary to set N=0 in calls to
+    // sqlite3_aggregate_context(C,N) so that no pointless memory allocations occur.
+    let a: Option<&A> = match aggregate_context(ctx, 0) {
+        Some(pac) => {
+            if (*pac as *mut A).is_null() {
+                None
+            } else {
+                let a = &**pac;
+                Some(a)
+            }
+        }
+        None => None,
+    };
+
+    let r = catch_unwind(|| {
+        let boxed_aggr: *mut W = ffi::sqlite3_user_data(ctx).cast::<W>();
+        assert!(
+            !boxed_aggr.is_null(),
+            "Internal error - null aggregate pointer"
+        );
+        (*boxed_aggr).value(a)
+    });
+    let t = match r {
+        Err(_) => {
+            report_error(ctx, &Error::UnwindingPanic);
+            return;
+        }
+        Ok(r) => r,
+    };
+    let t = t.as_ref().map(|t| ToSql::to_sql(t));
+    match t {
+        Ok(Ok(ref value)) => set_result(ctx, value),
+        Ok(Err(err)) => report_error(ctx, &err),
+        Err(err) => report_error(ctx, err),
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use regex::Regex;
+    use std::os::raw::c_double;
+
+    #[cfg(feature = "window")]
+    use crate::functions::WindowAggregate;
+    use crate::functions::{Aggregate, Context, FunctionFlags};
+    use crate::{Connection, Error, Result};
+
+    fn half(ctx: &Context<'_>) -> Result<c_double> {
+        assert_eq!(ctx.len(), 1, "called with unexpected number of arguments");
+        let value = ctx.get::<c_double>(0)?;
+        Ok(value / 2f64)
+    }
+
+    #[test]
+    fn test_function_half() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        db.create_scalar_function(
+            "half",
+            1,
+            FunctionFlags::SQLITE_UTF8 | FunctionFlags::SQLITE_DETERMINISTIC,
+            half,
+        )?;
+        let result: f64 = db.one_column("SELECT half(6)")?;
+
+        assert!((3f64 - result).abs() < f64::EPSILON);
+        Ok(())
+    }
+
+    #[test]
+    fn test_remove_function() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        db.create_scalar_function(
+            "half",
+            1,
+            FunctionFlags::SQLITE_UTF8 | FunctionFlags::SQLITE_DETERMINISTIC,
+            half,
+        )?;
+        let result: f64 = db.one_column("SELECT half(6)")?;
+        assert!((3f64 - result).abs() < f64::EPSILON);
+
+        db.remove_function("half", 1)?;
+        let result: Result<f64> = db.one_column("SELECT half(6)");
+        result.unwrap_err();
+        Ok(())
+    }
+
+    // This implementation of a regexp scalar function uses SQLite's auxiliary data
+    // (https://www.sqlite.org/c3ref/get_auxdata.html) to avoid recompiling the regular
+    // expression multiple times within one query.
+    fn regexp_with_auxilliary(ctx: &Context<'_>) -> Result<bool> {
+        assert_eq!(ctx.len(), 2, "called with unexpected number of arguments");
+        type BoxError = Box<dyn std::error::Error + Send + Sync + 'static>;
+        let regexp: std::sync::Arc<Regex> = ctx
+            .get_or_create_aux(0, |vr| -> Result<_, BoxError> {
+                Ok(Regex::new(vr.as_str()?)?)
+            })?;
+
+        let is_match = {
+            let text = ctx
+                .get_raw(1)
+                .as_str()
+                .map_err(|e| Error::UserFunctionError(e.into()))?;
+
+            regexp.is_match(text)
+        };
+
+        Ok(is_match)
+    }
+
+    #[test]
+    fn test_function_regexp_with_auxilliary() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        db.execute_batch(
+            "BEGIN;
+             CREATE TABLE foo (x string);
+             INSERT INTO foo VALUES ('lisa');
+             INSERT INTO foo VALUES ('lXsi');
+             INSERT INTO foo VALUES ('lisX');
+             END;",
+        )?;
+        db.create_scalar_function(
+            "regexp",
+            2,
+            FunctionFlags::SQLITE_UTF8 | FunctionFlags::SQLITE_DETERMINISTIC,
+            regexp_with_auxilliary,
+        )?;
+
+        let result: bool = db.one_column("SELECT regexp('l.s[aeiouy]', 'lisa')")?;
+
+        assert!(result);
+
+        let result: i64 =
+            db.one_column("SELECT COUNT(*) FROM foo WHERE regexp('l.s[aeiouy]', x) == 1")?;
+
+        assert_eq!(2, result);
+        Ok(())
+    }
+
+    #[test]
+    fn test_varargs_function() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        db.create_scalar_function(
+            "my_concat",
+            -1,
+            FunctionFlags::SQLITE_UTF8 | FunctionFlags::SQLITE_DETERMINISTIC,
+            |ctx| {
+                let mut ret = String::new();
+
+                for idx in 0..ctx.len() {
+                    let s = ctx.get::<String>(idx)?;
+                    ret.push_str(&s);
+                }
+
+                Ok(ret)
+            },
+        )?;
+
+        for &(expected, query) in &[
+            ("", "SELECT my_concat()"),
+            ("onetwo", "SELECT my_concat('one', 'two')"),
+            ("abc", "SELECT my_concat('a', 'b', 'c')"),
+        ] {
+            let result: String = db.one_column(query)?;
+            assert_eq!(expected, result);
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn test_get_aux_type_checking() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        db.create_scalar_function("example", 2, FunctionFlags::default(), |ctx| {
+            if !ctx.get::<bool>(1)? {
+                ctx.set_aux::<i64>(0, 100)?;
+            } else {
+                assert_eq!(ctx.get_aux::<String>(0), Err(Error::GetAuxWrongType));
+                assert_eq!(*ctx.get_aux::<i64>(0)?.unwrap(), 100);
+            }
+            Ok(true)
+        })?;
+
+        let res: bool =
+            db.one_column("SELECT example(0, i) FROM (SELECT 0 as i UNION SELECT 1)")?;
+        // Doesn't actually matter, we'll assert in the function if there's a problem.
+        assert!(res);
+        Ok(())
+    }
+
+    struct Sum;
+    struct Count;
+
+    impl Aggregate<i64, Option<i64>> for Sum {
+        fn init(&self, _: &mut Context<'_>) -> Result<i64> {
+            Ok(0)
+        }
+
+        fn step(&self, ctx: &mut Context<'_>, sum: &mut i64) -> Result<()> {
+            *sum += ctx.get::<i64>(0)?;
+            Ok(())
+        }
+
+        fn finalize(&self, _: &mut Context<'_>, sum: Option<i64>) -> Result<Option<i64>> {
+            Ok(sum)
+        }
+    }
+
+    impl Aggregate<i64, i64> for Count {
+        fn init(&self, _: &mut Context<'_>) -> Result<i64> {
+            Ok(0)
+        }
+
+        fn step(&self, _ctx: &mut Context<'_>, sum: &mut i64) -> Result<()> {
+            *sum += 1;
+            Ok(())
+        }
+
+        fn finalize(&self, _: &mut Context<'_>, sum: Option<i64>) -> Result<i64> {
+            Ok(sum.unwrap_or(0))
+        }
+    }
+
+    #[test]
+    fn test_sum() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        db.create_aggregate_function(
+            "my_sum",
+            1,
+            FunctionFlags::SQLITE_UTF8 | FunctionFlags::SQLITE_DETERMINISTIC,
+            Sum,
+        )?;
+
+        // sum should return NULL when given no columns (contrast with count below)
+        let no_result = "SELECT my_sum(i) FROM (SELECT 2 AS i WHERE 1 <> 1)";
+        let result: Option<i64> = db.one_column(no_result)?;
+        assert!(result.is_none());
+
+        let single_sum = "SELECT my_sum(i) FROM (SELECT 2 AS i UNION ALL SELECT 2)";
+        let result: i64 = db.one_column(single_sum)?;
+        assert_eq!(4, result);
+
+        let dual_sum = "SELECT my_sum(i), my_sum(j) FROM (SELECT 2 AS i, 1 AS j UNION ALL SELECT \
+                        2, 1)";
+        let result: (i64, i64) = db.query_row(dual_sum, [], |r| Ok((r.get(0)?, r.get(1)?)))?;
+        assert_eq!((4, 2), result);
+        Ok(())
+    }
+
+    #[test]
+    fn test_count() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        db.create_aggregate_function(
+            "my_count",
+            -1,
+            FunctionFlags::SQLITE_UTF8 | FunctionFlags::SQLITE_DETERMINISTIC,
+            Count,
+        )?;
+
+        // count should return 0 when given no columns (contrast with sum above)
+        let no_result = "SELECT my_count(i) FROM (SELECT 2 AS i WHERE 1 <> 1)";
+        let result: i64 = db.one_column(no_result)?;
+        assert_eq!(result, 0);
+
+        let single_sum = "SELECT my_count(i) FROM (SELECT 2 AS i UNION ALL SELECT 2)";
+        let result: i64 = db.one_column(single_sum)?;
+        assert_eq!(2, result);
+        Ok(())
+    }
+
+    #[cfg(feature = "window")]
+    impl WindowAggregate<i64, Option<i64>> for Sum {
+        fn inverse(&self, ctx: &mut Context<'_>, sum: &mut i64) -> Result<()> {
+            *sum -= ctx.get::<i64>(0)?;
+            Ok(())
+        }
+
+        fn value(&self, sum: Option<&i64>) -> Result<Option<i64>> {
+            Ok(sum.copied())
+        }
+    }
+
+    #[test]
+    #[cfg(feature = "window")]
+    fn test_window() -> Result<()> {
+        use fallible_iterator::FallibleIterator;
+
+        let db = Connection::open_in_memory()?;
+        db.create_window_function(
+            "sumint",
+            1,
+            FunctionFlags::SQLITE_UTF8 | FunctionFlags::SQLITE_DETERMINISTIC,
+            Sum,
+        )?;
+        db.execute_batch(
+            "CREATE TABLE t3(x, y);
+             INSERT INTO t3 VALUES('a', 4),
+                     ('b', 5),
+                     ('c', 3),
+                     ('d', 8),
+                     ('e', 1);",
+        )?;
+
+        let mut stmt = db.prepare(
+            "SELECT x, sumint(y) OVER (
+                   ORDER BY x ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING
+                 ) AS sum_y
+                 FROM t3 ORDER BY x;",
+        )?;
+
+        let results: Vec<(String, i64)> = stmt
+            .query([])?
+            .map(|row| Ok((row.get("x")?, row.get("sum_y")?)))
+            .collect()?;
+        let expected = vec![
+            ("a".to_owned(), 9),
+            ("b".to_owned(), 12),
+            ("c".to_owned(), 16),
+            ("d".to_owned(), 12),
+            ("e".to_owned(), 9),
+        ];
+        assert_eq!(expected, results);
+        Ok(())
+    }
+}
diff --git a/crates/rusqlite/src/hooks.rs b/crates/rusqlite/src/hooks.rs
new file mode 100644
index 0000000..7a87bc3
--- /dev/null
+++ b/crates/rusqlite/src/hooks.rs
@@ -0,0 +1,805 @@
+//! Commit, Data Change and Rollback Notification Callbacks
+#![allow(non_camel_case_types)]
+
+use std::os::raw::{c_char, c_int, c_void};
+use std::panic::{catch_unwind, RefUnwindSafe};
+use std::ptr;
+
+use crate::ffi;
+
+use crate::{Connection, InnerConnection};
+
+/// Action Codes
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[repr(i32)]
+#[non_exhaustive]
+#[allow(clippy::upper_case_acronyms)]
+pub enum Action {
+    /// Unsupported / unexpected action
+    UNKNOWN = -1,
+    /// DELETE command
+    SQLITE_DELETE = ffi::SQLITE_DELETE,
+    /// INSERT command
+    SQLITE_INSERT = ffi::SQLITE_INSERT,
+    /// UPDATE command
+    SQLITE_UPDATE = ffi::SQLITE_UPDATE,
+}
+
+impl From<i32> for Action {
+    #[inline]
+    fn from(code: i32) -> Action {
+        match code {
+            ffi::SQLITE_DELETE => Action::SQLITE_DELETE,
+            ffi::SQLITE_INSERT => Action::SQLITE_INSERT,
+            ffi::SQLITE_UPDATE => Action::SQLITE_UPDATE,
+            _ => Action::UNKNOWN,
+        }
+    }
+}
+
+/// The context received by an authorizer hook.
+///
+/// See <https://sqlite.org/c3ref/set_authorizer.html> for more info.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct AuthContext<'c> {
+    /// The action to be authorized.
+    pub action: AuthAction<'c>,
+
+    /// The database name, if applicable.
+    pub database_name: Option<&'c str>,
+
+    /// The inner-most trigger or view responsible for the access attempt.
+    /// `None` if the access attempt was made by top-level SQL code.
+    pub accessor: Option<&'c str>,
+}
+
+/// Actions and arguments found within a statement during
+/// preparation.
+///
+/// See <https://sqlite.org/c3ref/c_alter_table.html> for more info.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[non_exhaustive]
+#[allow(missing_docs)]
+pub enum AuthAction<'c> {
+    /// This variant is not normally produced by SQLite. You may encounter it
+    // if you're using a different version than what's supported by this library.
+    Unknown {
+        /// The unknown authorization action code.
+        code: i32,
+        /// The third arg to the authorizer callback.
+        arg1: Option<&'c str>,
+        /// The fourth arg to the authorizer callback.
+        arg2: Option<&'c str>,
+    },
+    CreateIndex {
+        index_name: &'c str,
+        table_name: &'c str,
+    },
+    CreateTable {
+        table_name: &'c str,
+    },
+    CreateTempIndex {
+        index_name: &'c str,
+        table_name: &'c str,
+    },
+    CreateTempTable {
+        table_name: &'c str,
+    },
+    CreateTempTrigger {
+        trigger_name: &'c str,
+        table_name: &'c str,
+    },
+    CreateTempView {
+        view_name: &'c str,
+    },
+    CreateTrigger {
+        trigger_name: &'c str,
+        table_name: &'c str,
+    },
+    CreateView {
+        view_name: &'c str,
+    },
+    Delete {
+        table_name: &'c str,
+    },
+    DropIndex {
+        index_name: &'c str,
+        table_name: &'c str,
+    },
+    DropTable {
+        table_name: &'c str,
+    },
+    DropTempIndex {
+        index_name: &'c str,
+        table_name: &'c str,
+    },
+    DropTempTable {
+        table_name: &'c str,
+    },
+    DropTempTrigger {
+        trigger_name: &'c str,
+        table_name: &'c str,
+    },
+    DropTempView {
+        view_name: &'c str,
+    },
+    DropTrigger {
+        trigger_name: &'c str,
+        table_name: &'c str,
+    },
+    DropView {
+        view_name: &'c str,
+    },
+    Insert {
+        table_name: &'c str,
+    },
+    Pragma {
+        pragma_name: &'c str,
+        /// The pragma value, if present (e.g., `PRAGMA name = value;`).
+        pragma_value: Option<&'c str>,
+    },
+    Read {
+        table_name: &'c str,
+        column_name: &'c str,
+    },
+    Select,
+    Transaction {
+        operation: TransactionOperation,
+    },
+    Update {
+        table_name: &'c str,
+        column_name: &'c str,
+    },
+    Attach {
+        filename: &'c str,
+    },
+    Detach {
+        database_name: &'c str,
+    },
+    AlterTable {
+        database_name: &'c str,
+        table_name: &'c str,
+    },
+    Reindex {
+        index_name: &'c str,
+    },
+    Analyze {
+        table_name: &'c str,
+    },
+    CreateVtable {
+        table_name: &'c str,
+        module_name: &'c str,
+    },
+    DropVtable {
+        table_name: &'c str,
+        module_name: &'c str,
+    },
+    Function {
+        function_name: &'c str,
+    },
+    Savepoint {
+        operation: TransactionOperation,
+        savepoint_name: &'c str,
+    },
+    Recursive,
+}
+
+impl<'c> AuthAction<'c> {
+    fn from_raw(code: i32, arg1: Option<&'c str>, arg2: Option<&'c str>) -> Self {
+        match (code, arg1, arg2) {
+            (ffi::SQLITE_CREATE_INDEX, Some(index_name), Some(table_name)) => Self::CreateIndex {
+                index_name,
+                table_name,
+            },
+            (ffi::SQLITE_CREATE_TABLE, Some(table_name), _) => Self::CreateTable { table_name },
+            (ffi::SQLITE_CREATE_TEMP_INDEX, Some(index_name), Some(table_name)) => {
+                Self::CreateTempIndex {
+                    index_name,
+                    table_name,
+                }
+            }
+            (ffi::SQLITE_CREATE_TEMP_TABLE, Some(table_name), _) => {
+                Self::CreateTempTable { table_name }
+            }
+            (ffi::SQLITE_CREATE_TEMP_TRIGGER, Some(trigger_name), Some(table_name)) => {
+                Self::CreateTempTrigger {
+                    trigger_name,
+                    table_name,
+                }
+            }
+            (ffi::SQLITE_CREATE_TEMP_VIEW, Some(view_name), _) => {
+                Self::CreateTempView { view_name }
+            }
+            (ffi::SQLITE_CREATE_TRIGGER, Some(trigger_name), Some(table_name)) => {
+                Self::CreateTrigger {
+                    trigger_name,
+                    table_name,
+                }
+            }
+            (ffi::SQLITE_CREATE_VIEW, Some(view_name), _) => Self::CreateView { view_name },
+            (ffi::SQLITE_DELETE, Some(table_name), None) => Self::Delete { table_name },
+            (ffi::SQLITE_DROP_INDEX, Some(index_name), Some(table_name)) => Self::DropIndex {
+                index_name,
+                table_name,
+            },
+            (ffi::SQLITE_DROP_TABLE, Some(table_name), _) => Self::DropTable { table_name },
+            (ffi::SQLITE_DROP_TEMP_INDEX, Some(index_name), Some(table_name)) => {
+                Self::DropTempIndex {
+                    index_name,
+                    table_name,
+                }
+            }
+            (ffi::SQLITE_DROP_TEMP_TABLE, Some(table_name), _) => {
+                Self::DropTempTable { table_name }
+            }
+            (ffi::SQLITE_DROP_TEMP_TRIGGER, Some(trigger_name), Some(table_name)) => {
+                Self::DropTempTrigger {
+                    trigger_name,
+                    table_name,
+                }
+            }
+            (ffi::SQLITE_DROP_TEMP_VIEW, Some(view_name), _) => Self::DropTempView { view_name },
+            (ffi::SQLITE_DROP_TRIGGER, Some(trigger_name), Some(table_name)) => Self::DropTrigger {
+                trigger_name,
+                table_name,
+            },
+            (ffi::SQLITE_DROP_VIEW, Some(view_name), _) => Self::DropView { view_name },
+            (ffi::SQLITE_INSERT, Some(table_name), _) => Self::Insert { table_name },
+            (ffi::SQLITE_PRAGMA, Some(pragma_name), pragma_value) => Self::Pragma {
+                pragma_name,
+                pragma_value,
+            },
+            (ffi::SQLITE_READ, Some(table_name), Some(column_name)) => Self::Read {
+                table_name,
+                column_name,
+            },
+            (ffi::SQLITE_SELECT, ..) => Self::Select,
+            (ffi::SQLITE_TRANSACTION, Some(operation_str), _) => Self::Transaction {
+                operation: TransactionOperation::from_str(operation_str),
+            },
+            (ffi::SQLITE_UPDATE, Some(table_name), Some(column_name)) => Self::Update {
+                table_name,
+                column_name,
+            },
+            (ffi::SQLITE_ATTACH, Some(filename), _) => Self::Attach { filename },
+            (ffi::SQLITE_DETACH, Some(database_name), _) => Self::Detach { database_name },
+            (ffi::SQLITE_ALTER_TABLE, Some(database_name), Some(table_name)) => Self::AlterTable {
+                database_name,
+                table_name,
+            },
+            (ffi::SQLITE_REINDEX, Some(index_name), _) => Self::Reindex { index_name },
+            (ffi::SQLITE_ANALYZE, Some(table_name), _) => Self::Analyze { table_name },
+            (ffi::SQLITE_CREATE_VTABLE, Some(table_name), Some(module_name)) => {
+                Self::CreateVtable {
+                    table_name,
+                    module_name,
+                }
+            }
+            (ffi::SQLITE_DROP_VTABLE, Some(table_name), Some(module_name)) => Self::DropVtable {
+                table_name,
+                module_name,
+            },
+            (ffi::SQLITE_FUNCTION, _, Some(function_name)) => Self::Function { function_name },
+            (ffi::SQLITE_SAVEPOINT, Some(operation_str), Some(savepoint_name)) => Self::Savepoint {
+                operation: TransactionOperation::from_str(operation_str),
+                savepoint_name,
+            },
+            (ffi::SQLITE_RECURSIVE, ..) => Self::Recursive,
+            (code, arg1, arg2) => Self::Unknown { code, arg1, arg2 },
+        }
+    }
+}
+
+pub(crate) type BoxedAuthorizer =
+    Box<dyn for<'c> FnMut(AuthContext<'c>) -> Authorization + Send + 'static>;
+
+/// A transaction operation.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[non_exhaustive]
+#[allow(missing_docs)]
+pub enum TransactionOperation {
+    Unknown,
+    Begin,
+    Release,
+    Rollback,
+}
+
+impl TransactionOperation {
+    fn from_str(op_str: &str) -> Self {
+        match op_str {
+            "BEGIN" => Self::Begin,
+            "RELEASE" => Self::Release,
+            "ROLLBACK" => Self::Rollback,
+            _ => Self::Unknown,
+        }
+    }
+}
+
+/// [`authorizer`](Connection::authorizer) return code
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[non_exhaustive]
+pub enum Authorization {
+    /// Authorize the action.
+    Allow,
+    /// Don't allow access, but don't trigger an error either.
+    Ignore,
+    /// Trigger an error.
+    Deny,
+}
+
+impl Authorization {
+    fn into_raw(self) -> c_int {
+        match self {
+            Self::Allow => ffi::SQLITE_OK,
+            Self::Ignore => ffi::SQLITE_IGNORE,
+            Self::Deny => ffi::SQLITE_DENY,
+        }
+    }
+}
+
+impl Connection {
+    /// Register a callback function to be invoked whenever
+    /// a transaction is committed.
+    ///
+    /// The callback returns `true` to rollback.
+    #[inline]
+    pub fn commit_hook<F>(&self, hook: Option<F>)
+    where
+        F: FnMut() -> bool + Send + 'static,
+    {
+        self.db.borrow_mut().commit_hook(hook);
+    }
+
+    /// Register a callback function to be invoked whenever
+    /// a transaction is committed.
+    #[inline]
+    pub fn rollback_hook<F>(&self, hook: Option<F>)
+    where
+        F: FnMut() + Send + 'static,
+    {
+        self.db.borrow_mut().rollback_hook(hook);
+    }
+
+    /// Register a callback function to be invoked whenever
+    /// a row is updated, inserted or deleted in a rowid table.
+    ///
+    /// The callback parameters are:
+    ///
+    /// - the type of database update (`SQLITE_INSERT`, `SQLITE_UPDATE` or
+    /// `SQLITE_DELETE`),
+    /// - the name of the database ("main", "temp", ...),
+    /// - the name of the table that is updated,
+    /// - the ROWID of the row that is updated.
+    #[inline]
+    pub fn update_hook<F>(&self, hook: Option<F>)
+    where
+        F: FnMut(Action, &str, &str, i64) + Send + 'static,
+    {
+        self.db.borrow_mut().update_hook(hook);
+    }
+
+    /// Register a query progress callback.
+    ///
+    /// The parameter `num_ops` is the approximate number of virtual machine
+    /// instructions that are evaluated between successive invocations of the
+    /// `handler`. If `num_ops` is less than one then the progress handler
+    /// is disabled.
+    ///
+    /// If the progress callback returns `true`, the operation is interrupted.
+    pub fn progress_handler<F>(&self, num_ops: c_int, handler: Option<F>)
+    where
+        F: FnMut() -> bool + Send + RefUnwindSafe + 'static,
+    {
+        self.db.borrow_mut().progress_handler(num_ops, handler);
+    }
+
+    /// Register an authorizer callback that's invoked
+    /// as a statement is being prepared.
+    #[inline]
+    pub fn authorizer<'c, F>(&self, hook: Option<F>)
+    where
+        F: for<'r> FnMut(AuthContext<'r>) -> Authorization + Send + RefUnwindSafe + 'static,
+    {
+        self.db.borrow_mut().authorizer(hook);
+    }
+}
+
+impl InnerConnection {
+    #[inline]
+    pub fn remove_hooks(&mut self) {
+        self.update_hook(None::<fn(Action, &str, &str, i64)>);
+        self.commit_hook(None::<fn() -> bool>);
+        self.rollback_hook(None::<fn()>);
+        self.progress_handler(0, None::<fn() -> bool>);
+        self.authorizer(None::<fn(AuthContext<'_>) -> Authorization>);
+    }
+
+    fn commit_hook<F>(&mut self, hook: Option<F>)
+    where
+        F: FnMut() -> bool + Send + 'static,
+    {
+        unsafe extern "C" fn call_boxed_closure<F>(p_arg: *mut c_void) -> c_int
+        where
+            F: FnMut() -> bool,
+        {
+            let r = catch_unwind(|| {
+                let boxed_hook: *mut F = p_arg.cast::<F>();
+                (*boxed_hook)()
+            });
+            c_int::from(r.unwrap_or_default())
+        }
+
+        // unlike `sqlite3_create_function_v2`, we cannot specify a `xDestroy` with
+        // `sqlite3_commit_hook`. so we keep the `xDestroy` function in
+        // `InnerConnection.free_boxed_hook`.
+        let free_commit_hook = if hook.is_some() {
+            Some(free_boxed_hook::<F> as unsafe fn(*mut c_void))
+        } else {
+            None
+        };
+
+        let previous_hook = match hook {
+            Some(hook) => {
+                let boxed_hook: *mut F = Box::into_raw(Box::new(hook));
+                unsafe {
+                    ffi::sqlite3_commit_hook(
+                        self.db(),
+                        Some(call_boxed_closure::<F>),
+                        boxed_hook.cast(),
+                    )
+                }
+            }
+            _ => unsafe { ffi::sqlite3_commit_hook(self.db(), None, ptr::null_mut()) },
+        };
+        if !previous_hook.is_null() {
+            if let Some(free_boxed_hook) = self.free_commit_hook {
+                unsafe { free_boxed_hook(previous_hook) };
+            }
+        }
+        self.free_commit_hook = free_commit_hook;
+    }
+
+    fn rollback_hook<F>(&mut self, hook: Option<F>)
+    where
+        F: FnMut() + Send + 'static,
+    {
+        unsafe extern "C" fn call_boxed_closure<F>(p_arg: *mut c_void)
+        where
+            F: FnMut(),
+        {
+            drop(catch_unwind(|| {
+                let boxed_hook: *mut F = p_arg.cast::<F>();
+                (*boxed_hook)();
+            }));
+        }
+
+        let free_rollback_hook = if hook.is_some() {
+            Some(free_boxed_hook::<F> as unsafe fn(*mut c_void))
+        } else {
+            None
+        };
+
+        let previous_hook = match hook {
+            Some(hook) => {
+                let boxed_hook: *mut F = Box::into_raw(Box::new(hook));
+                unsafe {
+                    ffi::sqlite3_rollback_hook(
+                        self.db(),
+                        Some(call_boxed_closure::<F>),
+                        boxed_hook.cast(),
+                    )
+                }
+            }
+            _ => unsafe { ffi::sqlite3_rollback_hook(self.db(), None, ptr::null_mut()) },
+        };
+        if !previous_hook.is_null() {
+            if let Some(free_boxed_hook) = self.free_rollback_hook {
+                unsafe { free_boxed_hook(previous_hook) };
+            }
+        }
+        self.free_rollback_hook = free_rollback_hook;
+    }
+
+    fn update_hook<F>(&mut self, hook: Option<F>)
+    where
+        F: FnMut(Action, &str, &str, i64) + Send + 'static,
+    {
+        unsafe extern "C" fn call_boxed_closure<F>(
+            p_arg: *mut c_void,
+            action_code: c_int,
+            p_db_name: *const c_char,
+            p_table_name: *const c_char,
+            row_id: i64,
+        ) where
+            F: FnMut(Action, &str, &str, i64),
+        {
+            let action = Action::from(action_code);
+            drop(catch_unwind(|| {
+                let boxed_hook: *mut F = p_arg.cast::<F>();
+                (*boxed_hook)(
+                    action,
+                    expect_utf8(p_db_name, "database name"),
+                    expect_utf8(p_table_name, "table name"),
+                    row_id,
+                );
+            }));
+        }
+
+        let free_update_hook = if hook.is_some() {
+            Some(free_boxed_hook::<F> as unsafe fn(*mut c_void))
+        } else {
+            None
+        };
+
+        let previous_hook = match hook {
+            Some(hook) => {
+                let boxed_hook: *mut F = Box::into_raw(Box::new(hook));
+                unsafe {
+                    ffi::sqlite3_update_hook(
+                        self.db(),
+                        Some(call_boxed_closure::<F>),
+                        boxed_hook.cast(),
+                    )
+                }
+            }
+            _ => unsafe { ffi::sqlite3_update_hook(self.db(), None, ptr::null_mut()) },
+        };
+        if !previous_hook.is_null() {
+            if let Some(free_boxed_hook) = self.free_update_hook {
+                unsafe { free_boxed_hook(previous_hook) };
+            }
+        }
+        self.free_update_hook = free_update_hook;
+    }
+
+    fn progress_handler<F>(&mut self, num_ops: c_int, handler: Option<F>)
+    where
+        F: FnMut() -> bool + Send + RefUnwindSafe + 'static,
+    {
+        unsafe extern "C" fn call_boxed_closure<F>(p_arg: *mut c_void) -> c_int
+        where
+            F: FnMut() -> bool,
+        {
+            let r = catch_unwind(|| {
+                let boxed_handler: *mut F = p_arg.cast::<F>();
+                (*boxed_handler)()
+            });
+            c_int::from(r.unwrap_or_default())
+        }
+
+        if let Some(handler) = handler {
+            let boxed_handler = Box::new(handler);
+            unsafe {
+                ffi::sqlite3_progress_handler(
+                    self.db(),
+                    num_ops,
+                    Some(call_boxed_closure::<F>),
+                    &*boxed_handler as *const F as *mut _,
+                );
+            }
+            self.progress_handler = Some(boxed_handler);
+        } else {
+            unsafe { ffi::sqlite3_progress_handler(self.db(), num_ops, None, ptr::null_mut()) }
+            self.progress_handler = None;
+        };
+    }
+
+    fn authorizer<'c, F>(&'c mut self, authorizer: Option<F>)
+    where
+        F: for<'r> FnMut(AuthContext<'r>) -> Authorization + Send + RefUnwindSafe + 'static,
+    {
+        unsafe extern "C" fn call_boxed_closure<'c, F>(
+            p_arg: *mut c_void,
+            action_code: c_int,
+            param1: *const c_char,
+            param2: *const c_char,
+            db_name: *const c_char,
+            trigger_or_view_name: *const c_char,
+        ) -> c_int
+        where
+            F: FnMut(AuthContext<'c>) -> Authorization + Send + 'static,
+        {
+            catch_unwind(|| {
+                let action = AuthAction::from_raw(
+                    action_code,
+                    expect_optional_utf8(param1, "authorizer param 1"),
+                    expect_optional_utf8(param2, "authorizer param 2"),
+                );
+                let auth_ctx = AuthContext {
+                    action,
+                    database_name: expect_optional_utf8(db_name, "database name"),
+                    accessor: expect_optional_utf8(
+                        trigger_or_view_name,
+                        "accessor (inner-most trigger or view)",
+                    ),
+                };
+                let boxed_hook: *mut F = p_arg.cast::<F>();
+                (*boxed_hook)(auth_ctx)
+            })
+            .map_or_else(|_| ffi::SQLITE_ERROR, Authorization::into_raw)
+        }
+
+        let callback_fn = authorizer
+            .as_ref()
+            .map(|_| call_boxed_closure::<'c, F> as unsafe extern "C" fn(_, _, _, _, _, _) -> _);
+        let boxed_authorizer = authorizer.map(Box::new);
+
+        match unsafe {
+            ffi::sqlite3_set_authorizer(
+                self.db(),
+                callback_fn,
+                boxed_authorizer
+                    .as_ref()
+                    .map_or_else(ptr::null_mut, |f| &**f as *const F as *mut _),
+            )
+        } {
+            ffi::SQLITE_OK => {
+                self.authorizer = boxed_authorizer.map(|ba| ba as _);
+            }
+            err_code => {
+                // The only error that `sqlite3_set_authorizer` returns is `SQLITE_MISUSE`
+                // when compiled with `ENABLE_API_ARMOR` and the db pointer is invalid.
+                // This library does not allow constructing a null db ptr, so if this branch
+                // is hit, something very bad has happened. Panicking instead of returning
+                // `Result` keeps this hook's API consistent with the others.
+                panic!("unexpectedly failed to set_authorizer: {}", unsafe {
+                    crate::error::error_from_handle(self.db(), err_code)
+                });
+            }
+        }
+    }
+}
+
+unsafe fn free_boxed_hook<F>(p: *mut c_void) {
+    drop(Box::from_raw(p.cast::<F>()));
+}
+
+unsafe fn expect_utf8<'a>(p_str: *const c_char, description: &'static str) -> &'a str {
+    expect_optional_utf8(p_str, description)
+        .unwrap_or_else(|| panic!("received empty {}", description))
+}
+
+unsafe fn expect_optional_utf8<'a>(
+    p_str: *const c_char,
+    description: &'static str,
+) -> Option<&'a str> {
+    if p_str.is_null() {
+        return None;
+    }
+    std::str::from_utf8(std::ffi::CStr::from_ptr(p_str).to_bytes())
+        .unwrap_or_else(|_| panic!("received non-utf8 string as {}", description))
+        .into()
+}
+
+#[cfg(test)]
+mod test {
+    use super::Action;
+    use crate::{Connection, Result};
+    use std::sync::atomic::{AtomicBool, Ordering};
+
+    #[test]
+    fn test_commit_hook() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+
+        static CALLED: AtomicBool = AtomicBool::new(false);
+        db.commit_hook(Some(|| {
+            CALLED.store(true, Ordering::Relaxed);
+            false
+        }));
+        db.execute_batch("BEGIN; CREATE TABLE foo (t TEXT); COMMIT;")?;
+        assert!(CALLED.load(Ordering::Relaxed));
+        Ok(())
+    }
+
+    #[test]
+    fn test_fn_commit_hook() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+
+        fn hook() -> bool {
+            true
+        }
+
+        db.commit_hook(Some(hook));
+        db.execute_batch("BEGIN; CREATE TABLE foo (t TEXT); COMMIT;")
+            .unwrap_err();
+        Ok(())
+    }
+
+    #[test]
+    fn test_rollback_hook() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+
+        static CALLED: AtomicBool = AtomicBool::new(false);
+        db.rollback_hook(Some(|| {
+            CALLED.store(true, Ordering::Relaxed);
+        }));
+        db.execute_batch("BEGIN; CREATE TABLE foo (t TEXT); ROLLBACK;")?;
+        assert!(CALLED.load(Ordering::Relaxed));
+        Ok(())
+    }
+
+    #[test]
+    fn test_update_hook() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+
+        static CALLED: AtomicBool = AtomicBool::new(false);
+        db.update_hook(Some(|action, db: &str, tbl: &str, row_id| {
+            assert_eq!(Action::SQLITE_INSERT, action);
+            assert_eq!("main", db);
+            assert_eq!("foo", tbl);
+            assert_eq!(1, row_id);
+            CALLED.store(true, Ordering::Relaxed);
+        }));
+        db.execute_batch("CREATE TABLE foo (t TEXT)")?;
+        db.execute_batch("INSERT INTO foo VALUES ('lisa')")?;
+        assert!(CALLED.load(Ordering::Relaxed));
+        Ok(())
+    }
+
+    #[test]
+    fn test_progress_handler() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+
+        static CALLED: AtomicBool = AtomicBool::new(false);
+        db.progress_handler(
+            1,
+            Some(|| {
+                CALLED.store(true, Ordering::Relaxed);
+                false
+            }),
+        );
+        db.execute_batch("BEGIN; CREATE TABLE foo (t TEXT); COMMIT;")?;
+        assert!(CALLED.load(Ordering::Relaxed));
+        Ok(())
+    }
+
+    #[test]
+    fn test_progress_handler_interrupt() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+
+        fn handler() -> bool {
+            true
+        }
+
+        db.progress_handler(1, Some(handler));
+        db.execute_batch("BEGIN; CREATE TABLE foo (t TEXT); COMMIT;")
+            .unwrap_err();
+        Ok(())
+    }
+
+    #[test]
+    fn test_authorizer() -> Result<()> {
+        use super::{AuthAction, AuthContext, Authorization};
+
+        let db = Connection::open_in_memory()?;
+        db.execute_batch("CREATE TABLE foo (public TEXT, private TEXT)")
+            .unwrap();
+
+        let authorizer = move |ctx: AuthContext<'_>| match ctx.action {
+            AuthAction::Read { column_name, .. } if column_name == "private" => {
+                Authorization::Ignore
+            }
+            AuthAction::DropTable { .. } => Authorization::Deny,
+            AuthAction::Pragma { .. } => panic!("shouldn't be called"),
+            _ => Authorization::Allow,
+        };
+
+        db.authorizer(Some(authorizer));
+        db.execute_batch(
+            "BEGIN TRANSACTION; INSERT INTO foo VALUES ('pub txt', 'priv txt'); COMMIT;",
+        )
+        .unwrap();
+        db.query_row_and_then("SELECT * FROM foo", [], |row| -> Result<()> {
+            assert_eq!(row.get::<_, String>("public")?, "pub txt");
+            assert!(row.get::<_, Option<String>>("private")?.is_none());
+            Ok(())
+        })
+        .unwrap();
+        db.execute_batch("DROP TABLE foo").unwrap_err();
+
+        db.authorizer(None::<fn(AuthContext<'_>) -> Authorization>);
+        db.execute_batch("PRAGMA user_version=1").unwrap(); // Disallowed by first authorizer, but it's now removed.
+
+        Ok(())
+    }
+}
diff --git a/crates/rusqlite/src/inner_connection.rs b/crates/rusqlite/src/inner_connection.rs
new file mode 100644
index 0000000..275e846
--- /dev/null
+++ b/crates/rusqlite/src/inner_connection.rs
@@ -0,0 +1,445 @@
+use std::ffi::CStr;
+use std::os::raw::{c_char, c_int};
+#[cfg(feature = "load_extension")]
+use std::path::Path;
+use std::ptr;
+use std::str;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex};
+
+use super::ffi;
+use super::str_for_sqlite;
+use super::{Connection, InterruptHandle, OpenFlags, Result};
+use crate::error::{error_from_handle, error_from_sqlite_code, error_with_offset, Error};
+use crate::raw_statement::RawStatement;
+use crate::statement::Statement;
+use crate::version::version_number;
+
+pub struct InnerConnection {
+    pub db: *mut ffi::sqlite3,
+    // It's unsafe to call `sqlite3_close` while another thread is performing
+    // a `sqlite3_interrupt`, and vice versa, so we take this mutex during
+    // those functions. This protects a copy of the `db` pointer (which is
+    // cleared on closing), however the main copy, `db`, is unprotected.
+    // Otherwise, a long running query would prevent calling interrupt, as
+    // interrupt would only acquire the lock after the query's completion.
+    interrupt_lock: Arc<Mutex<*mut ffi::sqlite3>>,
+    #[cfg(feature = "hooks")]
+    pub free_commit_hook: Option<unsafe fn(*mut std::os::raw::c_void)>,
+    #[cfg(feature = "hooks")]
+    pub free_rollback_hook: Option<unsafe fn(*mut std::os::raw::c_void)>,
+    #[cfg(feature = "hooks")]
+    pub free_update_hook: Option<unsafe fn(*mut std::os::raw::c_void)>,
+    #[cfg(feature = "hooks")]
+    pub progress_handler: Option<Box<dyn FnMut() -> bool + Send>>,
+    #[cfg(feature = "hooks")]
+    pub authorizer: Option<crate::hooks::BoxedAuthorizer>,
+    owned: bool,
+}
+
+unsafe impl Send for InnerConnection {}
+
+impl InnerConnection {
+    #[allow(clippy::mutex_atomic)]
+    #[inline]
+    pub unsafe fn new(db: *mut ffi::sqlite3, owned: bool) -> InnerConnection {
+        InnerConnection {
+            db,
+            interrupt_lock: Arc::new(Mutex::new(db)),
+            #[cfg(feature = "hooks")]
+            free_commit_hook: None,
+            #[cfg(feature = "hooks")]
+            free_rollback_hook: None,
+            #[cfg(feature = "hooks")]
+            free_update_hook: None,
+            #[cfg(feature = "hooks")]
+            progress_handler: None,
+            #[cfg(feature = "hooks")]
+            authorizer: None,
+            owned,
+        }
+    }
+
+    pub fn open_with_flags(
+        c_path: &CStr,
+        flags: OpenFlags,
+        vfs: Option<&CStr>,
+    ) -> Result<InnerConnection> {
+        ensure_safe_sqlite_threading_mode()?;
+
+        // Replicate the check for sane open flags from SQLite, because the check in
+        // SQLite itself wasn't added until version 3.7.3.
+        debug_assert_eq!(1 << OpenFlags::SQLITE_OPEN_READ_ONLY.bits(), 0x02);
+        debug_assert_eq!(1 << OpenFlags::SQLITE_OPEN_READ_WRITE.bits(), 0x04);
+        debug_assert_eq!(
+            1 << (OpenFlags::SQLITE_OPEN_READ_WRITE | OpenFlags::SQLITE_OPEN_CREATE).bits(),
+            0x40
+        );
+        if (1 << (flags.bits() & 0x7)) & 0x46 == 0 {
+            return Err(Error::SqliteFailure(
+                ffi::Error::new(ffi::SQLITE_MISUSE),
+                None,
+            ));
+        }
+
+        let z_vfs = match vfs {
+            Some(c_vfs) => c_vfs.as_ptr(),
+            None => ptr::null(),
+        };
+
+        unsafe {
+            let mut db: *mut ffi::sqlite3 = ptr::null_mut();
+            let r = ffi::sqlite3_open_v2(c_path.as_ptr(), &mut db, flags.bits(), z_vfs);
+            if r != ffi::SQLITE_OK {
+                let e = if db.is_null() {
+                    error_from_sqlite_code(r, Some(c_path.to_string_lossy().to_string()))
+                } else {
+                    let mut e = error_from_handle(db, r);
+                    if let Error::SqliteFailure(
+                        ffi::Error {
+                            code: ffi::ErrorCode::CannotOpen,
+                            ..
+                        },
+                        Some(msg),
+                    ) = e
+                    {
+                        e = Error::SqliteFailure(
+                            ffi::Error::new(r),
+                            Some(format!("{msg}: {}", c_path.to_string_lossy())),
+                        );
+                    }
+                    ffi::sqlite3_close(db);
+                    e
+                };
+
+                return Err(e);
+            }
+
+            // attempt to turn on extended results code; don't fail if we can't.
+            ffi::sqlite3_extended_result_codes(db, 1);
+
+            let r = ffi::sqlite3_busy_timeout(db, 5000);
+            if r != ffi::SQLITE_OK {
+                let e = error_from_handle(db, r);
+                ffi::sqlite3_close(db);
+                return Err(e);
+            }
+
+            Ok(InnerConnection::new(db, true))
+        }
+    }
+
+    #[inline]
+    pub fn db(&self) -> *mut ffi::sqlite3 {
+        self.db
+    }
+
+    #[inline]
+    pub fn decode_result(&self, code: c_int) -> Result<()> {
+        unsafe { InnerConnection::decode_result_raw(self.db(), code) }
+    }
+
+    #[inline]
+    unsafe fn decode_result_raw(db: *mut ffi::sqlite3, code: c_int) -> Result<()> {
+        if code == ffi::SQLITE_OK {
+            Ok(())
+        } else {
+            Err(error_from_handle(db, code))
+        }
+    }
+
+    #[allow(clippy::mutex_atomic)]
+    pub fn close(&mut self) -> Result<()> {
+        if self.db.is_null() {
+            return Ok(());
+        }
+        self.remove_hooks();
+        let mut shared_handle = self.interrupt_lock.lock().unwrap();
+        assert!(
+            !shared_handle.is_null(),
+            "Bug: Somehow interrupt_lock was cleared before the DB was closed"
+        );
+        if !self.owned {
+            self.db = ptr::null_mut();
+            return Ok(());
+        }
+        unsafe {
+            let r = ffi::sqlite3_close(self.db);
+            // Need to use _raw because _guard has a reference out, and
+            // decode_result takes &mut self.
+            let r = InnerConnection::decode_result_raw(self.db, r);
+            if r.is_ok() {
+                *shared_handle = ptr::null_mut();
+                self.db = ptr::null_mut();
+            }
+            r
+        }
+    }
+
+    #[inline]
+    pub fn get_interrupt_handle(&self) -> InterruptHandle {
+        InterruptHandle {
+            db_lock: Arc::clone(&self.interrupt_lock),
+        }
+    }
+
+    #[inline]
+    #[cfg(feature = "load_extension")]
+    pub unsafe fn enable_load_extension(&mut self, onoff: c_int) -> Result<()> {
+        let r = ffi::sqlite3_enable_load_extension(self.db, onoff);
+        self.decode_result(r)
+    }
+
+    #[cfg(feature = "load_extension")]
+    pub unsafe fn load_extension(
+        &self,
+        dylib_path: &Path,
+        entry_point: Option<&str>,
+    ) -> Result<()> {
+        let dylib_str = super::path_to_cstring(dylib_path)?;
+        let mut errmsg: *mut c_char = ptr::null_mut();
+        let r = if let Some(entry_point) = entry_point {
+            let c_entry = crate::str_to_cstring(entry_point)?;
+            ffi::sqlite3_load_extension(self.db, dylib_str.as_ptr(), c_entry.as_ptr(), &mut errmsg)
+        } else {
+            ffi::sqlite3_load_extension(self.db, dylib_str.as_ptr(), ptr::null(), &mut errmsg)
+        };
+        if r == ffi::SQLITE_OK {
+            Ok(())
+        } else {
+            let message = super::errmsg_to_string(errmsg);
+            ffi::sqlite3_free(errmsg.cast::<std::os::raw::c_void>());
+            Err(error_from_sqlite_code(r, Some(message)))
+        }
+    }
+
+    #[inline]
+    pub fn last_insert_rowid(&self) -> i64 {
+        unsafe { ffi::sqlite3_last_insert_rowid(self.db()) }
+    }
+
+    pub fn prepare<'a>(&mut self, conn: &'a Connection, sql: &str) -> Result<Statement<'a>> {
+        let mut c_stmt = ptr::null_mut();
+        let (c_sql, len, _) = str_for_sqlite(sql.as_bytes())?;
+        let mut c_tail = ptr::null();
+        // TODO sqlite3_prepare_v3 (https://sqlite.org/c3ref/c_prepare_normalize.html) // 3.20.0, #728
+        #[cfg(not(feature = "unlock_notify"))]
+        let r = unsafe {
+            ffi::sqlite3_prepare_v2(
+                self.db(),
+                c_sql,
+                len,
+                &mut c_stmt as *mut *mut ffi::sqlite3_stmt,
+                &mut c_tail as *mut *const c_char,
+            )
+        };
+        #[cfg(feature = "unlock_notify")]
+        let r = unsafe {
+            use crate::unlock_notify;
+            let mut rc;
+            loop {
+                rc = ffi::sqlite3_prepare_v2(
+                    self.db(),
+                    c_sql,
+                    len,
+                    &mut c_stmt as *mut *mut ffi::sqlite3_stmt,
+                    &mut c_tail as *mut *const c_char,
+                );
+                if !unlock_notify::is_locked(self.db, rc) {
+                    break;
+                }
+                rc = unlock_notify::wait_for_unlock_notify(self.db);
+                if rc != ffi::SQLITE_OK {
+                    break;
+                }
+            }
+            rc
+        };
+        // If there is an error, *ppStmt is set to NULL.
+        if r != ffi::SQLITE_OK {
+            return Err(unsafe { error_with_offset(self.db, r, sql) });
+        }
+        // If the input text contains no SQL (if the input is an empty string or a
+        // comment) then *ppStmt is set to NULL.
+        let c_stmt: *mut ffi::sqlite3_stmt = c_stmt;
+        let c_tail: *const c_char = c_tail;
+        let tail = if c_tail.is_null() {
+            0
+        } else {
+            let n = (c_tail as isize) - (c_sql as isize);
+            if n <= 0 || n >= len as isize {
+                0
+            } else {
+                n as usize
+            }
+        };
+        Ok(Statement::new(conn, unsafe {
+            RawStatement::new(c_stmt, tail)
+        }))
+    }
+
+    #[inline]
+    pub fn changes(&self) -> u64 {
+        #[cfg(not(feature = "modern_sqlite"))]
+        unsafe {
+            ffi::sqlite3_changes(self.db()) as u64
+        }
+        #[cfg(feature = "modern_sqlite")] // 3.37.0
+        unsafe {
+            ffi::sqlite3_changes64(self.db()) as u64
+        }
+    }
+
+    #[inline]
+    pub fn is_autocommit(&self) -> bool {
+        unsafe { ffi::sqlite3_get_autocommit(self.db()) != 0 }
+    }
+
+    pub fn is_busy(&self) -> bool {
+        let db = self.db();
+        unsafe {
+            let mut stmt = ffi::sqlite3_next_stmt(db, ptr::null_mut());
+            while !stmt.is_null() {
+                if ffi::sqlite3_stmt_busy(stmt) != 0 {
+                    return true;
+                }
+                stmt = ffi::sqlite3_next_stmt(db, stmt);
+            }
+        }
+        false
+    }
+
+    pub fn cache_flush(&mut self) -> Result<()> {
+        crate::error::check(unsafe { ffi::sqlite3_db_cacheflush(self.db()) })
+    }
+
+    #[cfg(not(feature = "hooks"))]
+    #[inline]
+    fn remove_hooks(&mut self) {}
+
+    pub fn db_readonly(&self, db_name: super::DatabaseName<'_>) -> Result<bool> {
+        let name = db_name.as_cstring()?;
+        let r = unsafe { ffi::sqlite3_db_readonly(self.db, name.as_ptr()) };
+        match r {
+            0 => Ok(false),
+            1 => Ok(true),
+            -1 => Err(Error::SqliteFailure(
+                ffi::Error::new(ffi::SQLITE_MISUSE),
+                Some(format!("{db_name:?} is not the name of a database")),
+            )),
+            _ => Err(error_from_sqlite_code(
+                r,
+                Some("Unexpected result".to_owned()),
+            )),
+        }
+    }
+
+    #[cfg(feature = "modern_sqlite")] // 3.37.0
+    pub fn txn_state(
+        &self,
+        db_name: Option<super::DatabaseName<'_>>,
+    ) -> Result<super::transaction::TransactionState> {
+        let r = if let Some(ref name) = db_name {
+            let name = name.as_cstring()?;
+            unsafe { ffi::sqlite3_txn_state(self.db, name.as_ptr()) }
+        } else {
+            unsafe { ffi::sqlite3_txn_state(self.db, ptr::null()) }
+        };
+        match r {
+            0 => Ok(super::transaction::TransactionState::None),
+            1 => Ok(super::transaction::TransactionState::Read),
+            2 => Ok(super::transaction::TransactionState::Write),
+            -1 => Err(Error::SqliteFailure(
+                ffi::Error::new(ffi::SQLITE_MISUSE),
+                Some(format!("{db_name:?} is not the name of a valid schema")),
+            )),
+            _ => Err(error_from_sqlite_code(
+                r,
+                Some("Unexpected result".to_owned()),
+            )),
+        }
+    }
+
+    #[inline]
+    #[cfg(feature = "release_memory")]
+    pub fn release_memory(&self) -> Result<()> {
+        self.decode_result(unsafe { ffi::sqlite3_db_release_memory(self.db) })
+    }
+}
+
+impl Drop for InnerConnection {
+    #[allow(unused_must_use)]
+    #[inline]
+    fn drop(&mut self) {
+        self.close();
+    }
+}
+
+#[cfg(not(any(target_arch = "wasm32")))]
+static SQLITE_INIT: std::sync::Once = std::sync::Once::new();
+
+pub static BYPASS_SQLITE_INIT: AtomicBool = AtomicBool::new(false);
+
+// threading mode checks are not necessary (and do not work) on target
+// platforms that do not have threading (such as webassembly)
+#[cfg(any(target_arch = "wasm32"))]
+fn ensure_safe_sqlite_threading_mode() -> Result<()> {
+    Ok(())
+}
+
+#[cfg(not(any(target_arch = "wasm32")))]
+fn ensure_safe_sqlite_threading_mode() -> Result<()> {
+    // Ensure SQLite was compiled in threadsafe mode.
+    if unsafe { ffi::sqlite3_threadsafe() == 0 } {
+        return Err(Error::SqliteSingleThreadedMode);
+    }
+
+    // Now we know SQLite is _capable_ of being in Multi-thread of Serialized mode,
+    // but it's possible someone configured it to be in Single-thread mode
+    // before calling into us. That would mean we're exposing an unsafe API via
+    // a safe one (in Rust terminology), which is no good. We have two options
+    // to protect against this, depending on the version of SQLite we're linked
+    // with:
+    //
+    // 1. If we're on 3.7.0 or later, we can ask SQLite for a mutex and check for
+    //    the magic value 8. This isn't documented, but it's what SQLite
+    //    returns for its mutex allocation function in Single-thread mode.
+    // 2. If we're prior to SQLite 3.7.0, AFAIK there's no way to check the
+    //    threading mode. The check we perform for >= 3.7.0 will segfault.
+    //    Instead, we insist on being able to call sqlite3_config and
+    //    sqlite3_initialize ourself, ensuring we know the threading
+    //    mode. This will fail if someone else has already initialized SQLite
+    //    even if they initialized it safely. That's not ideal either, which is
+    //    why we expose bypass_sqlite_initialization    above.
+    if version_number() >= 3_007_000 {
+        const SQLITE_SINGLETHREADED_MUTEX_MAGIC: usize = 8;
+        let is_singlethreaded = unsafe {
+            let mutex_ptr = ffi::sqlite3_mutex_alloc(0);
+            let is_singlethreaded = mutex_ptr as usize == SQLITE_SINGLETHREADED_MUTEX_MAGIC;
+            ffi::sqlite3_mutex_free(mutex_ptr);
+            is_singlethreaded
+        };
+        if is_singlethreaded {
+            Err(Error::SqliteSingleThreadedMode)
+        } else {
+            Ok(())
+        }
+    } else {
+        SQLITE_INIT.call_once(|| {
+            if BYPASS_SQLITE_INIT.load(Ordering::Relaxed) {
+                return;
+            }
+
+            unsafe {
+                assert!(ffi::sqlite3_config(ffi::SQLITE_CONFIG_MULTITHREAD) == ffi::SQLITE_OK && ffi::sqlite3_initialize() == ffi::SQLITE_OK,
+                        "Could not ensure safe initialization of SQLite.\n\
+                         To fix this, either:\n\
+                         * Upgrade SQLite to at least version 3.7.0\n\
+                         * Ensure that SQLite has been initialized in Multi-thread or Serialized mode and call\n\
+                           rusqlite::bypass_sqlite_initialization() prior to your first connection attempt."
+                    );
+            }
+        });
+        Ok(())
+    }
+}
diff --git a/crates/rusqlite/src/lib.rs b/crates/rusqlite/src/lib.rs
new file mode 100644
index 0000000..1d982f6
--- /dev/null
+++ b/crates/rusqlite/src/lib.rs
@@ -0,0 +1,2089 @@
+//! Rusqlite is an ergonomic wrapper for using SQLite from Rust.
+//!
+//! Historically, the API was based on the one from
+//! [`rust-postgres`](https://github.com/sfackler/rust-postgres). However, the
+//! two have diverged in many ways, and no compatibility between the two is
+//! intended.
+//!
+//! ```rust
+//! use rusqlite::{params, Connection, Result};
+//!
+//! #[derive(Debug)]
+//! struct Person {
+//!     id: i32,
+//!     name: String,
+//!     data: Option<Vec<u8>>,
+//! }
+//!
+//! fn main() -> Result<()> {
+//!     let conn = Connection::open_in_memory()?;
+//!
+//!     conn.execute(
+//!         "CREATE TABLE person (
+//!             id   INTEGER PRIMARY KEY,
+//!             name TEXT NOT NULL,
+//!             data BLOB
+//!         )",
+//!         (), // empty list of parameters.
+//!     )?;
+//!     let me = Person {
+//!         id: 0,
+//!         name: "Steven".to_string(),
+//!         data: None,
+//!     };
+//!     conn.execute(
+//!         "INSERT INTO person (name, data) VALUES (?1, ?2)",
+//!         (&me.name, &me.data),
+//!     )?;
+//!
+//!     let mut stmt = conn.prepare("SELECT id, name, data FROM person")?;
+//!     let person_iter = stmt.query_map([], |row| {
+//!         Ok(Person {
+//!             id: row.get(0)?,
+//!             name: row.get(1)?,
+//!             data: row.get(2)?,
+//!         })
+//!     })?;
+//!
+//!     for person in person_iter {
+//!         println!("Found person {:?}", person.unwrap());
+//!     }
+//!     Ok(())
+//! }
+//! ```
+#![warn(missing_docs)]
+#![cfg_attr(docsrs, feature(doc_cfg))]
+
+pub use libsqlite3_sys as ffi;
+
+use std::cell::RefCell;
+use std::default::Default;
+use std::ffi::{CStr, CString};
+use std::fmt;
+use std::os::raw::{c_char, c_int};
+
+use std::path::Path;
+use std::result;
+use std::str;
+use std::sync::atomic::Ordering;
+use std::sync::{Arc, Mutex};
+
+use crate::cache::StatementCache;
+use crate::inner_connection::{InnerConnection, BYPASS_SQLITE_INIT};
+use crate::raw_statement::RawStatement;
+use crate::types::ValueRef;
+
+pub use crate::cache::CachedStatement;
+pub use crate::column::Column;
+pub use crate::error::Error;
+pub use crate::ffi::ErrorCode;
+#[cfg(feature = "load_extension")]
+pub use crate::load_extension_guard::LoadExtensionGuard;
+pub use crate::params::{params_from_iter, Params, ParamsFromIter};
+pub use crate::row::{AndThenRows, Map, MappedRows, Row, RowIndex, Rows};
+pub use crate::statement::{Statement, StatementStatus};
+pub use crate::transaction::{DropBehavior, Savepoint, Transaction, TransactionBehavior};
+pub use crate::types::ToSql;
+pub use crate::version::*;
+
+mod error;
+
+#[cfg(feature = "backup")]
+#[cfg_attr(docsrs, doc(cfg(feature = "backup")))]
+pub mod backup;
+#[cfg(feature = "blob")]
+#[cfg_attr(docsrs, doc(cfg(feature = "blob")))]
+pub mod blob;
+mod busy;
+mod cache;
+#[cfg(feature = "collation")]
+#[cfg_attr(docsrs, doc(cfg(feature = "collation")))]
+mod collation;
+mod column;
+pub mod config;
+#[cfg(any(feature = "functions", feature = "vtab"))]
+mod context;
+#[cfg(feature = "functions")]
+#[cfg_attr(docsrs, doc(cfg(feature = "functions")))]
+pub mod functions;
+#[cfg(feature = "hooks")]
+#[cfg_attr(docsrs, doc(cfg(feature = "hooks")))]
+pub mod hooks;
+mod inner_connection;
+#[cfg(feature = "limits")]
+#[cfg_attr(docsrs, doc(cfg(feature = "limits")))]
+pub mod limits;
+#[cfg(feature = "load_extension")]
+mod load_extension_guard;
+mod params;
+mod pragma;
+mod raw_statement;
+mod row;
+#[cfg(feature = "session")]
+#[cfg_attr(docsrs, doc(cfg(feature = "session")))]
+pub mod session;
+mod statement;
+#[cfg(feature = "trace")]
+#[cfg_attr(docsrs, doc(cfg(feature = "trace")))]
+pub mod trace;
+mod transaction;
+pub mod types;
+#[cfg(feature = "unlock_notify")]
+mod unlock_notify;
+mod version;
+#[cfg(feature = "vtab")]
+#[cfg_attr(docsrs, doc(cfg(feature = "vtab")))]
+pub mod vtab;
+
+pub(crate) mod util;
+pub(crate) use util::SmallCString;
+
+// Number of cached prepared statements we'll hold on to.
+const STATEMENT_CACHE_DEFAULT_CAPACITY: usize = 16;
+
+/// A macro making it more convenient to longer lists of
+/// parameters as a `&[&dyn ToSql]`.
+///
+/// # Example
+///
+/// ```rust,no_run
+/// # use rusqlite::{Result, Connection, params};
+///
+/// struct Person {
+///     name: String,
+///     age_in_years: u8,
+///     data: Option<Vec<u8>>,
+/// }
+///
+/// fn add_person(conn: &Connection, person: &Person) -> Result<()> {
+///     conn.execute(
+///         "INSERT INTO person(name, age_in_years, data) VALUES (?1, ?2, ?3)",
+///         params![person.name, person.age_in_years, person.data],
+///     )?;
+///     Ok(())
+/// }
+/// ```
+#[macro_export]
+macro_rules! params {
+    () => {
+        &[] as &[&dyn $crate::ToSql]
+    };
+    ($($param:expr),+ $(,)?) => {
+        &[$(&$param as &dyn $crate::ToSql),+] as &[&dyn $crate::ToSql]
+    };
+}
+
+/// A macro making it more convenient to pass lists of named parameters
+/// as a `&[(&str, &dyn ToSql)]`.
+///
+/// # Example
+///
+/// ```rust,no_run
+/// # use rusqlite::{Result, Connection, named_params};
+///
+/// struct Person {
+///     name: String,
+///     age_in_years: u8,
+///     data: Option<Vec<u8>>,
+/// }
+///
+/// fn add_person(conn: &Connection, person: &Person) -> Result<()> {
+///     conn.execute(
+///         "INSERT INTO person (name, age_in_years, data)
+///          VALUES (:name, :age, :data)",
+///         named_params! {
+///             ":name": person.name,
+///             ":age": person.age_in_years,
+///             ":data": person.data,
+///         },
+///     )?;
+///     Ok(())
+/// }
+/// ```
+#[macro_export]
+macro_rules! named_params {
+    () => {
+        &[] as &[(&str, &dyn $crate::ToSql)]
+    };
+    // Note: It's a lot more work to support this as part of the same macro as
+    // `params!`, unfortunately.
+    ($($param_name:literal: $param_val:expr),+ $(,)?) => {
+        &[$(($param_name, &$param_val as &dyn $crate::ToSql)),+] as &[(&str, &dyn $crate::ToSql)]
+    };
+}
+
+/// A typedef of the result returned by many methods.
+pub type Result<T, E = Error> = result::Result<T, E>;
+
+/// See the [method documentation](#tymethod.optional).
+pub trait OptionalExtension<T> {
+    /// Converts a `Result<T>` into a `Result<Option<T>>`.
+    ///
+    /// By default, Rusqlite treats 0 rows being returned from a query that is
+    /// expected to return 1 row as an error. This method will
+    /// handle that error, and give you back an `Option<T>` instead.
+    fn optional(self) -> Result<Option<T>>;
+}
+
+impl<T> OptionalExtension<T> for Result<T> {
+    fn optional(self) -> Result<Option<T>> {
+        match self {
+            Ok(value) => Ok(Some(value)),
+            Err(Error::QueryReturnedNoRows) => Ok(None),
+            Err(e) => Err(e),
+        }
+    }
+}
+
+unsafe fn errmsg_to_string(errmsg: *const c_char) -> String {
+    let c_slice = CStr::from_ptr(errmsg).to_bytes();
+    String::from_utf8_lossy(c_slice).into_owned()
+}
+
+fn str_to_cstring(s: &str) -> Result<SmallCString> {
+    Ok(SmallCString::new(s)?)
+}
+
+/// Returns `Ok((string ptr, len as c_int, SQLITE_STATIC | SQLITE_TRANSIENT))`
+/// normally.
+/// Returns error if the string is too large for sqlite.
+/// The `sqlite3_destructor_type` item is always `SQLITE_TRANSIENT` unless
+/// the string was empty (in which case it's `SQLITE_STATIC`, and the ptr is
+/// static).
+fn str_for_sqlite(s: &[u8]) -> Result<(*const c_char, c_int, ffi::sqlite3_destructor_type)> {
+    let len = len_as_c_int(s.len())?;
+    let (ptr, dtor_info) = if len != 0 {
+        (s.as_ptr().cast::<c_char>(), ffi::SQLITE_TRANSIENT())
+    } else {
+        // Return a pointer guaranteed to live forever
+        ("".as_ptr().cast::<c_char>(), ffi::SQLITE_STATIC())
+    };
+    Ok((ptr, len, dtor_info))
+}
+
+// Helper to cast to c_int safely, returning the correct error type if the cast
+// failed.
+fn len_as_c_int(len: usize) -> Result<c_int> {
+    if len >= (c_int::MAX as usize) {
+        Err(Error::SqliteFailure(
+            ffi::Error::new(ffi::SQLITE_TOOBIG),
+            None,
+        ))
+    } else {
+        Ok(len as c_int)
+    }
+}
+
+#[cfg(unix)]
+fn path_to_cstring(p: &Path) -> Result<CString> {
+    use std::os::unix::ffi::OsStrExt;
+    Ok(CString::new(p.as_os_str().as_bytes())?)
+}
+
+#[cfg(not(unix))]
+fn path_to_cstring(p: &Path) -> Result<CString> {
+    let s = p.to_str().ok_or_else(|| Error::InvalidPath(p.to_owned()))?;
+    Ok(CString::new(s)?)
+}
+
+/// Name for a database within a SQLite connection.
+#[derive(Copy, Clone, Debug)]
+pub enum DatabaseName<'a> {
+    /// The main database.
+    Main,
+
+    /// The temporary database (e.g., any "CREATE TEMPORARY TABLE" tables).
+    Temp,
+
+    /// A database that has been attached via "ATTACH DATABASE ...".
+    Attached(&'a str),
+}
+
+/// Shorthand for [`DatabaseName::Main`].
+pub const MAIN_DB: DatabaseName<'static> = DatabaseName::Main;
+
+/// Shorthand for [`DatabaseName::Temp`].
+pub const TEMP_DB: DatabaseName<'static> = DatabaseName::Temp;
+
+// Currently DatabaseName is only used by the backup and blob mods, so hide
+// this (private) impl to avoid dead code warnings.
+impl DatabaseName<'_> {
+    #[inline]
+    fn as_cstring(&self) -> Result<SmallCString> {
+        use self::DatabaseName::{Attached, Main, Temp};
+        match *self {
+            Main => str_to_cstring("main"),
+            Temp => str_to_cstring("temp"),
+            Attached(s) => str_to_cstring(s),
+        }
+    }
+}
+
+/// A connection to a SQLite database.
+pub struct Connection {
+    db: RefCell<InnerConnection>,
+    cache: StatementCache,
+}
+
+unsafe impl Send for Connection {}
+
+impl Drop for Connection {
+    #[inline]
+    fn drop(&mut self) {
+        self.flush_prepared_statement_cache();
+    }
+}
+
+impl Connection {
+    /// Open a new connection to a SQLite database. If a database does not exist
+    /// at the path, one is created.
+    ///
+    /// ```rust,no_run
+    /// # use rusqlite::{Connection, Result};
+    /// fn open_my_db() -> Result<()> {
+    ///     let path = "./my_db.db3";
+    ///     let db = Connection::open(path)?;
+    ///     // Use the database somehow...
+    ///     println!("{}", db.is_autocommit());
+    ///     Ok(())
+    /// }
+    /// ```
+    ///
+    /// # Flags
+    ///
+    /// `Connection::open(path)` is equivalent to using
+    /// [`Connection::open_with_flags`] with the default [`OpenFlags`]. That is,
+    /// it's equivalent to:
+    ///
+    /// ```ignore
+    /// Connection::open_with_flags(
+    ///     path,
+    ///     OpenFlags::SQLITE_OPEN_READ_WRITE
+    ///         | OpenFlags::SQLITE_OPEN_CREATE
+    ///         | OpenFlags::SQLITE_OPEN_URI
+    ///         | OpenFlags::SQLITE_OPEN_NO_MUTEX,
+    /// )
+    /// ```
+    ///
+    /// These flags have the following effects:
+    ///
+    /// - Open the database for both reading or writing.
+    /// - Create the database if one does not exist at the path.
+    /// - Allow the filename to be interpreted as a URI (see <https://www.sqlite.org/uri.html#uri_filenames_in_sqlite>
+    ///   for details).
+    /// - Disables the use of a per-connection mutex.
+    ///
+    ///     Rusqlite enforces thread-safety at compile time, so additional
+    ///     locking is not needed and provides no benefit. (See the
+    ///     documentation on [`OpenFlags::SQLITE_OPEN_FULL_MUTEX`] for some
+    ///     additional discussion about this).
+    ///
+    /// Most of these are also the default settings for the C API, although
+    /// technically the default locking behavior is controlled by the flags used
+    /// when compiling SQLite -- rather than let it vary, we choose `NO_MUTEX`
+    /// because it's a fairly clearly the best choice for users of this library.
+    ///
+    /// # Failure
+    ///
+    /// Will return `Err` if `path` cannot be converted to a C-compatible string
+    /// or if the underlying SQLite open call fails.
+    #[inline]
+    pub fn open<P: AsRef<Path>>(path: P) -> Result<Connection> {
+        let flags = OpenFlags::default();
+        Connection::open_with_flags(path, flags)
+    }
+
+    /// Open a new connection to an in-memory SQLite database.
+    ///
+    /// # Failure
+    ///
+    /// Will return `Err` if the underlying SQLite open call fails.
+    #[inline]
+    pub fn open_in_memory() -> Result<Connection> {
+        let flags = OpenFlags::default();
+        Connection::open_in_memory_with_flags(flags)
+    }
+
+    /// Open a new connection to a SQLite database.
+    ///
+    /// [Database Connection](http://www.sqlite.org/c3ref/open.html) for a description of valid
+    /// flag combinations.
+    ///
+    /// # Failure
+    ///
+    /// Will return `Err` if `path` cannot be converted to a C-compatible
+    /// string or if the underlying SQLite open call fails.
+    #[inline]
+    pub fn open_with_flags<P: AsRef<Path>>(path: P, flags: OpenFlags) -> Result<Connection> {
+        let c_path = path_to_cstring(path.as_ref())?;
+        InnerConnection::open_with_flags(&c_path, flags, None).map(|db| Connection {
+            db: RefCell::new(db),
+            cache: StatementCache::with_capacity(STATEMENT_CACHE_DEFAULT_CAPACITY),
+        })
+    }
+
+    /// Open a new connection to a SQLite database using the specific flags and
+    /// vfs name.
+    ///
+    /// [Database Connection](http://www.sqlite.org/c3ref/open.html) for a description of valid
+    /// flag combinations.
+    ///
+    /// # Failure
+    ///
+    /// Will return `Err` if either `path` or `vfs` cannot be converted to a
+    /// C-compatible string or if the underlying SQLite open call fails.
+    #[inline]
+    pub fn open_with_flags_and_vfs<P: AsRef<Path>>(
+        path: P,
+        flags: OpenFlags,
+        vfs: &str,
+    ) -> Result<Connection> {
+        let c_path = path_to_cstring(path.as_ref())?;
+        let c_vfs = str_to_cstring(vfs)?;
+        InnerConnection::open_with_flags(&c_path, flags, Some(&c_vfs)).map(|db| Connection {
+            db: RefCell::new(db),
+            cache: StatementCache::with_capacity(STATEMENT_CACHE_DEFAULT_CAPACITY),
+        })
+    }
+
+    /// Open a new connection to an in-memory SQLite database.
+    ///
+    /// [Database Connection](http://www.sqlite.org/c3ref/open.html) for a description of valid
+    /// flag combinations.
+    ///
+    /// # Failure
+    ///
+    /// Will return `Err` if the underlying SQLite open call fails.
+    #[inline]
+    pub fn open_in_memory_with_flags(flags: OpenFlags) -> Result<Connection> {
+        Connection::open_with_flags(":memory:", flags)
+    }
+
+    /// Open a new connection to an in-memory SQLite database using the specific
+    /// flags and vfs name.
+    ///
+    /// [Database Connection](http://www.sqlite.org/c3ref/open.html) for a description of valid
+    /// flag combinations.
+    ///
+    /// # Failure
+    ///
+    /// Will return `Err` if `vfs` cannot be converted to a C-compatible
+    /// string or if the underlying SQLite open call fails.
+    #[inline]
+    pub fn open_in_memory_with_flags_and_vfs(flags: OpenFlags, vfs: &str) -> Result<Connection> {
+        Connection::open_with_flags_and_vfs(":memory:", flags, vfs)
+    }
+
+    /// Convenience method to run multiple SQL statements (that cannot take any
+    /// parameters).
+    ///
+    /// ## Example
+    ///
+    /// ```rust,no_run
+    /// # use rusqlite::{Connection, Result};
+    /// fn create_tables(conn: &Connection) -> Result<()> {
+    ///     conn.execute_batch(
+    ///         "BEGIN;
+    ///          CREATE TABLE foo(x INTEGER);
+    ///          CREATE TABLE bar(y TEXT);
+    ///          COMMIT;",
+    ///     )
+    /// }
+    /// ```
+    ///
+    /// # Failure
+    ///
+    /// Will return `Err` if `sql` cannot be converted to a C-compatible string
+    /// or if the underlying SQLite call fails.
+    pub fn execute_batch(&self, sql: &str) -> Result<()> {
+        let mut sql = sql;
+        while !sql.is_empty() {
+            let stmt = self.prepare(sql)?;
+            if !stmt.stmt.is_null() && stmt.step()? && cfg!(feature = "extra_check") {
+                // Some PRAGMA may return rows
+                return Err(Error::ExecuteReturnedResults);
+            }
+            let tail = stmt.stmt.tail();
+            if tail == 0 || tail >= sql.len() {
+                break;
+            }
+            sql = &sql[tail..];
+        }
+        Ok(())
+    }
+
+    /// Convenience method to prepare and execute a single SQL statement.
+    ///
+    /// On success, returns the number of rows that were changed or inserted or
+    /// deleted (via `sqlite3_changes`).
+    ///
+    /// ## Example
+    ///
+    /// ### With positional params
+    ///
+    /// ```rust,no_run
+    /// # use rusqlite::{Connection};
+    /// fn update_rows(conn: &Connection) {
+    ///     match conn.execute("UPDATE foo SET bar = 'baz' WHERE qux = ?1", [1i32]) {
+    ///         Ok(updated) => println!("{} rows were updated", updated),
+    ///         Err(err) => println!("update failed: {}", err),
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// ### With positional params of varying types
+    ///
+    /// ```rust,no_run
+    /// # use rusqlite::{params, Connection};
+    /// fn update_rows(conn: &Connection) {
+    ///     match conn.execute(
+    ///         "UPDATE foo SET bar = 'baz' WHERE qux = ?1 AND quux = ?2",
+    ///         params![1i32, 1.5f64],
+    ///     ) {
+    ///         Ok(updated) => println!("{} rows were updated", updated),
+    ///         Err(err) => println!("update failed: {}", err),
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// ### With named params
+    ///
+    /// ```rust,no_run
+    /// # use rusqlite::{Connection, Result};
+    /// fn insert(conn: &Connection) -> Result<usize> {
+    ///     conn.execute(
+    ///         "INSERT INTO test (name) VALUES (:name)",
+    ///         &[(":name", "one")],
+    ///     )
+    /// }
+    /// ```
+    ///
+    /// # Failure
+    ///
+    /// Will return `Err` if `sql` cannot be converted to a C-compatible string
+    /// or if the underlying SQLite call fails.
+    #[inline]
+    pub fn execute<P: Params>(&self, sql: &str, params: P) -> Result<usize> {
+        self.prepare(sql)
+            .and_then(|mut stmt| stmt.check_no_tail().and_then(|_| stmt.execute(params)))
+    }
+
+    /// Returns the path to the database file, if one exists and is known.
+    ///
+    /// Returns `Some("")` for a temporary or in-memory database.
+    ///
+    /// Note that in some cases [PRAGMA
+    /// database_list](https://sqlite.org/pragma.html#pragma_database_list) is
+    /// likely to be more robust.
+    #[inline]
+    pub fn path(&self) -> Option<&str> {
+        unsafe {
+            let db = self.handle();
+            let db_name = DatabaseName::Main.as_cstring().unwrap();
+            let db_filename = ffi::sqlite3_db_filename(db, db_name.as_ptr());
+            if db_filename.is_null() {
+                None
+            } else {
+                CStr::from_ptr(db_filename).to_str().ok()
+            }
+        }
+    }
+
+    /// Attempts to free as much heap memory as possible from the database
+    /// connection.
+    ///
+    /// This calls [`sqlite3_db_release_memory`](https://www.sqlite.org/c3ref/db_release_memory.html).
+    #[inline]
+    #[cfg(feature = "release_memory")]
+    pub fn release_memory(&self) -> Result<()> {
+        self.db.borrow_mut().release_memory()
+    }
+
+    /// Get the SQLite rowid of the most recent successful INSERT.
+    ///
+    /// Uses [sqlite3_last_insert_rowid](https://www.sqlite.org/c3ref/last_insert_rowid.html) under
+    /// the hood.
+    #[inline]
+    pub fn last_insert_rowid(&self) -> i64 {
+        self.db.borrow_mut().last_insert_rowid()
+    }
+
+    /// Convenience method to execute a query that is expected to return a
+    /// single row.
+    ///
+    /// ## Example
+    ///
+    /// ```rust,no_run
+    /// # use rusqlite::{Result, Connection};
+    /// fn preferred_locale(conn: &Connection) -> Result<String> {
+    ///     conn.query_row(
+    ///         "SELECT value FROM preferences WHERE name='locale'",
+    ///         [],
+    ///         |row| row.get(0),
+    ///     )
+    /// }
+    /// ```
+    ///
+    /// If the query returns more than one row, all rows except the first are
+    /// ignored.
+    ///
+    /// Returns `Err(QueryReturnedNoRows)` if no results are returned. If the
+    /// query truly is optional, you can call `.optional()` on the result of
+    /// this to get a `Result<Option<T>>`.
+    ///
+    /// # Failure
+    ///
+    /// Will return `Err` if `sql` cannot be converted to a C-compatible string
+    /// or if the underlying SQLite call fails.
+    #[inline]
+    pub fn query_row<T, P, F>(&self, sql: &str, params: P, f: F) -> Result<T>
+    where
+        P: Params,
+        F: FnOnce(&Row<'_>) -> Result<T>,
+    {
+        let mut stmt = self.prepare(sql)?;
+        stmt.check_no_tail()?;
+        stmt.query_row(params, f)
+    }
+
+    // https://sqlite.org/tclsqlite.html#onecolumn
+    #[cfg(test)]
+    pub(crate) fn one_column<T: crate::types::FromSql>(&self, sql: &str) -> Result<T> {
+        self.query_row(sql, [], |r| r.get(0))
+    }
+
+    /// Convenience method to execute a query that is expected to return a
+    /// single row, and execute a mapping via `f` on that returned row with
+    /// the possibility of failure. The `Result` type of `f` must implement
+    /// `std::convert::From<Error>`.
+    ///
+    /// ## Example
+    ///
+    /// ```rust,no_run
+    /// # use rusqlite::{Result, Connection};
+    /// fn preferred_locale(conn: &Connection) -> Result<String> {
+    ///     conn.query_row_and_then(
+    ///         "SELECT value FROM preferences WHERE name='locale'",
+    ///         [],
+    ///         |row| row.get(0),
+    ///     )
+    /// }
+    /// ```
+    ///
+    /// If the query returns more than one row, all rows except the first are
+    /// ignored.
+    ///
+    /// # Failure
+    ///
+    /// Will return `Err` if `sql` cannot be converted to a C-compatible string
+    /// or if the underlying SQLite call fails.
+    #[inline]
+    pub fn query_row_and_then<T, E, P, F>(&self, sql: &str, params: P, f: F) -> Result<T, E>
+    where
+        P: Params,
+        F: FnOnce(&Row<'_>) -> Result<T, E>,
+        E: From<Error>,
+    {
+        let mut stmt = self.prepare(sql)?;
+        stmt.check_no_tail()?;
+        let mut rows = stmt.query(params)?;
+
+        rows.get_expected_row().map_err(E::from).and_then(f)
+    }
+
+    /// Prepare a SQL statement for execution.
+    ///
+    /// ## Example
+    ///
+    /// ```rust,no_run
+    /// # use rusqlite::{Connection, Result};
+    /// fn insert_new_people(conn: &Connection) -> Result<()> {
+    ///     let mut stmt = conn.prepare("INSERT INTO People (name) VALUES (?1)")?;
+    ///     stmt.execute(["Joe Smith"])?;
+    ///     stmt.execute(["Bob Jones"])?;
+    ///     Ok(())
+    /// }
+    /// ```
+    ///
+    /// # Failure
+    ///
+    /// Will return `Err` if `sql` cannot be converted to a C-compatible string
+    /// or if the underlying SQLite call fails.
+    #[inline]
+    pub fn prepare(&self, sql: &str) -> Result<Statement<'_>> {
+        self.db.borrow_mut().prepare(self, sql)
+    }
+
+    /// Close the SQLite connection.
+    ///
+    /// This is functionally equivalent to the `Drop` implementation for
+    /// `Connection` except that on failure, it returns an error and the
+    /// connection itself (presumably so closing can be attempted again).
+    ///
+    /// # Failure
+    ///
+    /// Will return `Err` if the underlying SQLite call fails.
+    #[inline]
+    pub fn close(self) -> Result<(), (Connection, Error)> {
+        self.flush_prepared_statement_cache();
+        let r = self.db.borrow_mut().close();
+        r.map_err(move |err| (self, err))
+    }
+
+    /// Enable loading of SQLite extensions from both SQL queries and Rust.
+    ///
+    /// You must call [`Connection::load_extension_disable`] when you're
+    /// finished loading extensions (failure to call it can lead to bad things,
+    /// see "Safety"), so you should strongly consider using
+    /// [`LoadExtensionGuard`] instead of this function, automatically disables
+    /// extension loading when it goes out of scope.
+    ///
+    /// # Example
+    ///
+    /// ```rust,no_run
+    /// # use rusqlite::{Connection, Result};
+    /// fn load_my_extension(conn: &Connection) -> Result<()> {
+    ///     // Safety: We fully trust the loaded extension and execute no untrusted SQL
+    ///     // while extension loading is enabled.
+    ///     unsafe {
+    ///         conn.load_extension_enable()?;
+    ///         let r = conn.load_extension("my/trusted/extension", None);
+    ///         conn.load_extension_disable()?;
+    ///         r
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// # Failure
+    ///
+    /// Will return `Err` if the underlying SQLite call fails.
+    ///
+    /// # Safety
+    ///
+    /// TLDR: Don't execute any untrusted queries between this call and
+    /// [`Connection::load_extension_disable`].
+    ///
+    /// Perhaps surprisingly, this function does not only allow the use of
+    /// [`Connection::load_extension`] from Rust, but it also allows SQL queries
+    /// to perform [the same operation][loadext]. For example, in the period
+    /// between `load_extension_enable` and `load_extension_disable`, the
+    /// following operation will load and call some function in some dynamic
+    /// library:
+    ///
+    /// ```sql
+    /// SELECT load_extension('why_is_this_possible.dll', 'dubious_func');
+    /// ```
+    ///
+    /// This means that while this is enabled a carefully crafted SQL query can
+    /// be used to escalate a SQL injection attack into code execution.
+    ///
+    /// Safely using this function requires that you trust all SQL queries run
+    /// between when it is called, and when loading is disabled (by
+    /// [`Connection::load_extension_disable`]).
+    ///
+    /// [loadext]: https://www.sqlite.org/lang_corefunc.html#load_extension
+    #[cfg(feature = "load_extension")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "load_extension")))]
+    #[inline]
+    pub unsafe fn load_extension_enable(&self) -> Result<()> {
+        self.db.borrow_mut().enable_load_extension(1)
+    }
+
+    /// Disable loading of SQLite extensions.
+    ///
+    /// See [`Connection::load_extension_enable`] for an example.
+    ///
+    /// # Failure
+    ///
+    /// Will return `Err` if the underlying SQLite call fails.
+    #[cfg(feature = "load_extension")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "load_extension")))]
+    #[inline]
+    pub fn load_extension_disable(&self) -> Result<()> {
+        // It's always safe to turn off extension loading.
+        unsafe { self.db.borrow_mut().enable_load_extension(0) }
+    }
+
+    /// Load the SQLite extension at `dylib_path`. `dylib_path` is passed
+    /// through to `sqlite3_load_extension`, which may attempt OS-specific
+    /// modifications if the file cannot be loaded directly (for example
+    /// converting `"some/ext"` to `"some/ext.so"`, `"some\\ext.dll"`, ...).
+    ///
+    /// If `entry_point` is `None`, SQLite will attempt to find the entry point.
+    /// If it is not `None`, the entry point will be passed through to
+    /// `sqlite3_load_extension`.
+    ///
+    /// ## Example
+    ///
+    /// ```rust,no_run
+    /// # use rusqlite::{Connection, Result, LoadExtensionGuard};
+    /// fn load_my_extension(conn: &Connection) -> Result<()> {
+    ///     // Safety: we don't execute any SQL statements while
+    ///     // extension loading is enabled.
+    ///     let _guard = unsafe { LoadExtensionGuard::new(conn)? };
+    ///     // Safety: `my_sqlite_extension` is highly trustworthy.
+    ///     unsafe { conn.load_extension("my_sqlite_extension", None) }
+    /// }
+    /// ```
+    ///
+    /// # Failure
+    ///
+    /// Will return `Err` if the underlying SQLite call fails.
+    ///
+    /// # Safety
+    ///
+    /// This is equivalent to performing a `dlopen`/`LoadLibrary` on a shared
+    /// library, and calling a function inside, and thus requires that you trust
+    /// the library that you're loading.
+    ///
+    /// That is to say: to safely use this, the code in the extension must be
+    /// sound, trusted, correctly use the SQLite APIs, and not contain any
+    /// memory or thread safety errors.
+    #[cfg(feature = "load_extension")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "load_extension")))]
+    #[inline]
+    pub unsafe fn load_extension<P: AsRef<Path>>(
+        &self,
+        dylib_path: P,
+        entry_point: Option<&str>,
+    ) -> Result<()> {
+        self.db
+            .borrow_mut()
+            .load_extension(dylib_path.as_ref(), entry_point)
+    }
+
+    /// Get access to the underlying SQLite database connection handle.
+    ///
+    /// # Warning
+    ///
+    /// You should not need to use this function. If you do need to, please
+    /// [open an issue on the rusqlite repository](https://github.com/rusqlite/rusqlite/issues) and describe
+    /// your use case.
+    ///
+    /// # Safety
+    ///
+    /// This function is unsafe because it gives you raw access
+    /// to the SQLite connection, and what you do with it could impact the
+    /// safety of this `Connection`.
+    #[inline]
+    pub unsafe fn handle(&self) -> *mut ffi::sqlite3 {
+        self.db.borrow().db()
+    }
+
+    /// Create a `Connection` from a raw handle.
+    ///
+    /// The underlying SQLite database connection handle will not be closed when
+    /// the returned connection is dropped/closed.
+    ///
+    /// # Safety
+    ///
+    /// This function is unsafe because improper use may impact the Connection.
+    #[inline]
+    pub unsafe fn from_handle(db: *mut ffi::sqlite3) -> Result<Connection> {
+        let db = InnerConnection::new(db, false);
+        Ok(Connection {
+            db: RefCell::new(db),
+            cache: StatementCache::with_capacity(STATEMENT_CACHE_DEFAULT_CAPACITY),
+        })
+    }
+
+    /// Create a `Connection` from a raw owned handle.
+    ///
+    /// The returned connection will attempt to close the inner connection
+    /// when dropped/closed. This function should only be called on connections
+    /// owned by the caller.
+    ///
+    /// # Safety
+    ///
+    /// This function is unsafe because improper use may impact the Connection.
+    /// In particular, it should only be called on connections created
+    /// and owned by the caller, e.g. as a result of calling ffi::sqlite3_open().
+    #[inline]
+    pub unsafe fn from_handle_owned(db: *mut ffi::sqlite3) -> Result<Connection> {
+        let db = InnerConnection::new(db, true);
+        Ok(Connection {
+            db: RefCell::new(db),
+            cache: StatementCache::with_capacity(STATEMENT_CACHE_DEFAULT_CAPACITY),
+        })
+    }
+
+    /// Get access to a handle that can be used to interrupt long running
+    /// queries from another thread.
+    #[inline]
+    pub fn get_interrupt_handle(&self) -> InterruptHandle {
+        self.db.borrow().get_interrupt_handle()
+    }
+
+    #[inline]
+    fn decode_result(&self, code: c_int) -> Result<()> {
+        self.db.borrow().decode_result(code)
+    }
+
+    /// Return the number of rows modified, inserted or deleted by the most
+    /// recently completed INSERT, UPDATE or DELETE statement on the database
+    /// connection.
+    ///
+    /// See <https://www.sqlite.org/c3ref/changes.html>
+    #[inline]
+    pub fn changes(&self) -> u64 {
+        self.db.borrow().changes()
+    }
+
+    /// Test for auto-commit mode.
+    /// Autocommit mode is on by default.
+    #[inline]
+    pub fn is_autocommit(&self) -> bool {
+        self.db.borrow().is_autocommit()
+    }
+
+    /// Determine if all associated prepared statements have been reset.
+    #[inline]
+    pub fn is_busy(&self) -> bool {
+        self.db.borrow().is_busy()
+    }
+
+    /// Flush caches to disk mid-transaction
+    pub fn cache_flush(&self) -> Result<()> {
+        self.db.borrow_mut().cache_flush()
+    }
+
+    /// Determine if a database is read-only
+    pub fn is_readonly(&self, db_name: DatabaseName<'_>) -> Result<bool> {
+        self.db.borrow().db_readonly(db_name)
+    }
+}
+
+impl fmt::Debug for Connection {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Connection")
+            .field("path", &self.path())
+            .finish()
+    }
+}
+
+/// Batch iterator
+/// ```rust
+/// use rusqlite::{Batch, Connection, Result};
+///
+/// fn main() -> Result<()> {
+///     let conn = Connection::open_in_memory()?;
+///     let sql = r"
+///     CREATE TABLE tbl1 (col);
+///     CREATE TABLE tbl2 (col);
+///     ";
+///     let mut batch = Batch::new(&conn, sql);
+///     while let Some(mut stmt) = batch.next()? {
+///         stmt.execute([])?;
+///     }
+///     Ok(())
+/// }
+/// ```
+#[derive(Debug)]
+pub struct Batch<'conn, 'sql> {
+    conn: &'conn Connection,
+    sql: &'sql str,
+    tail: usize,
+}
+
+impl<'conn, 'sql> Batch<'conn, 'sql> {
+    /// Constructor
+    pub fn new(conn: &'conn Connection, sql: &'sql str) -> Batch<'conn, 'sql> {
+        Batch { conn, sql, tail: 0 }
+    }
+
+    /// Iterates on each batch statements.
+    ///
+    /// Returns `Ok(None)` when batch is completed.
+    #[allow(clippy::should_implement_trait)] // fallible iterator
+    pub fn next(&mut self) -> Result<Option<Statement<'conn>>> {
+        while self.tail < self.sql.len() {
+            let sql = &self.sql[self.tail..];
+            let next = self.conn.prepare(sql)?;
+            let tail = next.stmt.tail();
+            if tail == 0 {
+                self.tail = self.sql.len();
+            } else {
+                self.tail += tail;
+            }
+            if next.stmt.is_null() {
+                continue;
+            }
+            return Ok(Some(next));
+        }
+        Ok(None)
+    }
+}
+
+impl<'conn> Iterator for Batch<'conn, '_> {
+    type Item = Result<Statement<'conn>>;
+
+    fn next(&mut self) -> Option<Result<Statement<'conn>>> {
+        self.next().transpose()
+    }
+}
+
+bitflags::bitflags! {
+    /// Flags for opening SQLite database connections. See
+    /// [sqlite3_open_v2](http://www.sqlite.org/c3ref/open.html) for details.
+    ///
+    /// The default open flags are `SQLITE_OPEN_READ_WRITE | SQLITE_OPEN_CREATE
+    /// | SQLITE_OPEN_URI | SQLITE_OPEN_NO_MUTEX`. See [`Connection::open`] for
+    /// some discussion about these flags.
+    #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+    #[repr(C)]
+    pub struct OpenFlags: ::std::os::raw::c_int {
+        /// The database is opened in read-only mode.
+        /// If the database does not already exist, an error is returned.
+        const SQLITE_OPEN_READ_ONLY = ffi::SQLITE_OPEN_READONLY;
+        /// The database is opened for reading and writing if possible,
+        /// or reading only if the file is write protected by the operating system.
+        /// In either case the database must already exist, otherwise an error is returned.
+        const SQLITE_OPEN_READ_WRITE = ffi::SQLITE_OPEN_READWRITE;
+        /// The database is created if it does not already exist
+        const SQLITE_OPEN_CREATE = ffi::SQLITE_OPEN_CREATE;
+        /// The filename can be interpreted as a URI if this flag is set.
+        const SQLITE_OPEN_URI = ffi::SQLITE_OPEN_URI;
+        /// The database will be opened as an in-memory database.
+        const SQLITE_OPEN_MEMORY = ffi::SQLITE_OPEN_MEMORY;
+        /// The new database connection will not use a per-connection mutex (the
+        /// connection will use the "multi-thread" threading mode, in SQLite
+        /// parlance).
+        ///
+        /// This is used by default, as proper `Send`/`Sync` usage (in
+        /// particular, the fact that [`Connection`] does not implement `Sync`)
+        /// ensures thread-safety without the need to perform locking around all
+        /// calls.
+        const SQLITE_OPEN_NO_MUTEX = ffi::SQLITE_OPEN_NOMUTEX;
+        /// The new database connection will use a per-connection mutex -- the
+        /// "serialized" threading mode, in SQLite parlance.
+        ///
+        /// # Caveats
+        ///
+        /// This flag should probably never be used with `rusqlite`, as we
+        /// ensure thread-safety statically (we implement [`Send`] and not
+        /// [`Sync`]). That said
+        ///
+        /// Critically, even if this flag is used, the [`Connection`] is not
+        /// safe to use across multiple threads simultaneously. To access a
+        /// database from multiple threads, you should either create multiple
+        /// connections, one for each thread (if you have very many threads,
+        /// wrapping the `rusqlite::Connection` in a mutex is also reasonable).
+        ///
+        /// This is both because of the additional per-connection state stored
+        /// by `rusqlite` (for example, the prepared statement cache), and
+        /// because not all of SQLites functions are fully thread safe, even in
+        /// serialized/`SQLITE_OPEN_FULLMUTEX` mode.
+        ///
+        /// All that said, it's fairly harmless to enable this flag with
+        /// `rusqlite`, it will just slow things down while providing no
+        /// benefit.
+        const SQLITE_OPEN_FULL_MUTEX = ffi::SQLITE_OPEN_FULLMUTEX;
+        /// The database is opened with shared cache enabled.
+        ///
+        /// This is frequently useful for in-memory connections, but note that
+        /// broadly speaking it's discouraged by SQLite itself, which states
+        /// "Any use of shared cache is discouraged" in the official
+        /// [documentation](https://www.sqlite.org/c3ref/enable_shared_cache.html).
+        const SQLITE_OPEN_SHARED_CACHE = 0x0002_0000;
+        /// The database is opened shared cache disabled.
+        const SQLITE_OPEN_PRIVATE_CACHE = 0x0004_0000;
+        /// The database filename is not allowed to be a symbolic link. (3.31.0)
+        const SQLITE_OPEN_NOFOLLOW = 0x0100_0000;
+        /// Extended result codes. (3.37.0)
+        const SQLITE_OPEN_EXRESCODE = 0x0200_0000;
+    }
+}
+
+impl Default for OpenFlags {
+    #[inline]
+    fn default() -> OpenFlags {
+        // Note: update the `Connection::open` and top-level `OpenFlags` docs if
+        // you change these.
+        OpenFlags::SQLITE_OPEN_READ_WRITE
+            | OpenFlags::SQLITE_OPEN_CREATE
+            | OpenFlags::SQLITE_OPEN_NO_MUTEX
+            | OpenFlags::SQLITE_OPEN_URI
+    }
+}
+
+/// rusqlite's check for a safe SQLite threading mode requires SQLite 3.7.0 or
+/// later. If you are running against a SQLite older than that, rusqlite
+/// attempts to ensure safety by performing configuration and initialization of
+/// SQLite itself the first time you
+/// attempt to open a connection. By default, rusqlite panics if that
+/// initialization fails, since that could mean SQLite has been initialized in
+/// single-thread mode.
+///
+/// If you are encountering that panic _and_ can ensure that SQLite has been
+/// initialized in either multi-thread or serialized mode, call this function
+/// prior to attempting to open a connection and rusqlite's initialization
+/// process will by skipped.
+///
+/// # Safety
+///
+/// This function is unsafe because if you call it and SQLite has actually been
+/// configured to run in single-thread mode,
+/// you may encounter memory errors or data corruption or any number of terrible
+/// things that should not be possible when you're using Rust.
+pub unsafe fn bypass_sqlite_initialization() {
+    BYPASS_SQLITE_INIT.store(true, Ordering::Relaxed);
+}
+
+/// Allows interrupting a long-running computation.
+pub struct InterruptHandle {
+    db_lock: Arc<Mutex<*mut ffi::sqlite3>>,
+}
+
+unsafe impl Send for InterruptHandle {}
+unsafe impl Sync for InterruptHandle {}
+
+impl InterruptHandle {
+    /// Interrupt the query currently executing on another thread. This will
+    /// cause that query to fail with a `SQLITE3_INTERRUPT` error.
+    pub fn interrupt(&self) {
+        let db_handle = self.db_lock.lock().unwrap();
+        if !db_handle.is_null() {
+            unsafe { ffi::sqlite3_interrupt(*db_handle) }
+        }
+    }
+}
+
+#[cfg(doctest)]
+doc_comment::doctest!("../README.md");
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::ffi;
+    use fallible_iterator::FallibleIterator;
+    use std::error::Error as StdError;
+    use std::fmt;
+
+    // this function is never called, but is still type checked; in
+    // particular, calls with specific instantiations will require
+    // that those types are `Send`.
+    #[allow(dead_code, unconditional_recursion)]
+    fn ensure_send<T: Send>() {
+        ensure_send::<Connection>();
+        ensure_send::<InterruptHandle>();
+    }
+
+    #[allow(dead_code, unconditional_recursion)]
+    fn ensure_sync<T: Sync>() {
+        ensure_sync::<InterruptHandle>();
+    }
+
+    fn checked_memory_handle() -> Connection {
+        Connection::open_in_memory().unwrap()
+    }
+
+    #[test]
+    fn test_concurrent_transactions_busy_commit() -> Result<()> {
+        use std::time::Duration;
+        let tmp = tempfile::tempdir().unwrap();
+        let path = tmp.path().join("transactions.db3");
+
+        Connection::open(&path)?.execute_batch(
+            "
+            BEGIN; CREATE TABLE foo(x INTEGER);
+            INSERT INTO foo VALUES(42); END;",
+        )?;
+
+        let mut db1 = Connection::open_with_flags(&path, OpenFlags::SQLITE_OPEN_READ_WRITE)?;
+        let mut db2 = Connection::open_with_flags(&path, OpenFlags::SQLITE_OPEN_READ_ONLY)?;
+
+        db1.busy_timeout(Duration::from_millis(0))?;
+        db2.busy_timeout(Duration::from_millis(0))?;
+
+        {
+            let tx1 = db1.transaction()?;
+            let tx2 = db2.transaction()?;
+
+            // SELECT first makes sqlite lock with a shared lock
+            tx1.query_row("SELECT x FROM foo LIMIT 1", [], |_| Ok(()))?;
+            tx2.query_row("SELECT x FROM foo LIMIT 1", [], |_| Ok(()))?;
+
+            tx1.execute("INSERT INTO foo VALUES(?1)", [1])?;
+            let _ = tx2.execute("INSERT INTO foo VALUES(?1)", [2]);
+
+            let _ = tx1.commit();
+            let _ = tx2.commit();
+        }
+
+        let _ = db1
+            .transaction()
+            .expect("commit should have closed transaction");
+        let _ = db2
+            .transaction()
+            .expect("commit should have closed transaction");
+        Ok(())
+    }
+
+    #[test]
+    fn test_persistence() -> Result<()> {
+        let temp_dir = tempfile::tempdir().unwrap();
+        let path = temp_dir.path().join("test.db3");
+
+        {
+            let db = Connection::open(&path)?;
+            let sql = "BEGIN;
+                   CREATE TABLE foo(x INTEGER);
+                   INSERT INTO foo VALUES(42);
+                   END;";
+            db.execute_batch(sql)?;
+        }
+
+        let path_string = path.to_str().unwrap();
+        let db = Connection::open(path_string)?;
+        let the_answer: i64 = db.one_column("SELECT x FROM foo")?;
+
+        assert_eq!(42i64, the_answer);
+        Ok(())
+    }
+
+    #[test]
+    fn test_open() {
+        Connection::open_in_memory().unwrap();
+
+        let db = checked_memory_handle();
+        db.close().unwrap();
+    }
+
+    #[test]
+    fn test_path() -> Result<()> {
+        let tmp = tempfile::tempdir().unwrap();
+        let db = Connection::open("")?;
+        assert_eq!(Some(""), db.path());
+        let db = Connection::open_in_memory()?;
+        assert_eq!(Some(""), db.path());
+        let db = Connection::open("file:dummy.db?mode=memory&cache=shared")?;
+        assert_eq!(Some(""), db.path());
+        let path = tmp.path().join("file.db");
+        let db = Connection::open(path)?;
+        assert!(db.path().map(|p| p.ends_with("file.db")).unwrap_or(false));
+        Ok(())
+    }
+
+    #[test]
+    fn test_open_failure() {
+        let filename = "no_such_file.db";
+        let result = Connection::open_with_flags(filename, OpenFlags::SQLITE_OPEN_READ_ONLY);
+        let err = result.unwrap_err();
+        if let Error::SqliteFailure(e, Some(msg)) = err {
+            assert_eq!(ErrorCode::CannotOpen, e.code);
+            assert_eq!(ffi::SQLITE_CANTOPEN, e.extended_code);
+            assert!(
+                msg.contains(filename),
+                "error message '{}' does not contain '{}'",
+                msg,
+                filename
+            );
+        } else {
+            panic!("SqliteFailure expected");
+        }
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn test_invalid_unicode_file_names() -> Result<()> {
+        use std::ffi::OsStr;
+        use std::fs::File;
+        use std::os::unix::ffi::OsStrExt;
+        let temp_dir = tempfile::tempdir().unwrap();
+
+        let path = temp_dir.path();
+        if File::create(path.join(OsStr::from_bytes(&[0xFE]))).is_err() {
+            // Skip test, filesystem doesn't support invalid Unicode
+            return Ok(());
+        }
+        let db_path = path.join(OsStr::from_bytes(&[0xFF]));
+        {
+            let db = Connection::open(&db_path)?;
+            let sql = "BEGIN;
+                   CREATE TABLE foo(x INTEGER);
+                   INSERT INTO foo VALUES(42);
+                   END;";
+            db.execute_batch(sql)?;
+        }
+
+        let db = Connection::open(&db_path)?;
+        let the_answer: i64 = db.one_column("SELECT x FROM foo")?;
+
+        assert_eq!(42i64, the_answer);
+        Ok(())
+    }
+
+    #[test]
+    fn test_close_retry() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+
+        // force the DB to be busy by preparing a statement; this must be done at the
+        // FFI level to allow us to call .close() without dropping the prepared
+        // statement first.
+        let raw_stmt = {
+            use super::str_to_cstring;
+            use std::os::raw::c_int;
+            use std::ptr;
+
+            let raw_db = db.db.borrow_mut().db;
+            let sql = "SELECT 1";
+            let mut raw_stmt: *mut ffi::sqlite3_stmt = ptr::null_mut();
+            let cstring = str_to_cstring(sql)?;
+            let rc = unsafe {
+                ffi::sqlite3_prepare_v2(
+                    raw_db,
+                    cstring.as_ptr(),
+                    (sql.len() + 1) as c_int,
+                    &mut raw_stmt,
+                    ptr::null_mut(),
+                )
+            };
+            assert_eq!(rc, ffi::SQLITE_OK);
+            raw_stmt
+        };
+
+        // now that we have an open statement, trying (and retrying) to close should
+        // fail.
+        let (db, _) = db.close().unwrap_err();
+        let (db, _) = db.close().unwrap_err();
+        let (db, _) = db.close().unwrap_err();
+
+        // finalize the open statement so a final close will succeed
+        assert_eq!(ffi::SQLITE_OK, unsafe { ffi::sqlite3_finalize(raw_stmt) });
+
+        db.close().unwrap();
+        Ok(())
+    }
+
+    #[test]
+    fn test_open_with_flags() {
+        for bad_flags in &[
+            OpenFlags::empty(),
+            OpenFlags::SQLITE_OPEN_READ_ONLY | OpenFlags::SQLITE_OPEN_READ_WRITE,
+            OpenFlags::SQLITE_OPEN_READ_ONLY | OpenFlags::SQLITE_OPEN_CREATE,
+        ] {
+            Connection::open_in_memory_with_flags(*bad_flags).unwrap_err();
+        }
+    }
+
+    #[test]
+    fn test_execute_batch() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        let sql = "BEGIN;
+                   CREATE TABLE foo(x INTEGER);
+                   INSERT INTO foo VALUES(1);
+                   INSERT INTO foo VALUES(2);
+                   INSERT INTO foo VALUES(3);
+                   INSERT INTO foo VALUES(4);
+                   END;";
+        db.execute_batch(sql)?;
+
+        db.execute_batch("UPDATE foo SET x = 3 WHERE x < 3")?;
+
+        db.execute_batch("INVALID SQL").unwrap_err();
+        Ok(())
+    }
+
+    #[test]
+    fn test_execute() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        db.execute_batch("CREATE TABLE foo(x INTEGER)")?;
+
+        assert_eq!(1, db.execute("INSERT INTO foo(x) VALUES (?1)", [1i32])?);
+        assert_eq!(1, db.execute("INSERT INTO foo(x) VALUES (?1)", [2i32])?);
+
+        assert_eq!(3i32, db.one_column::<i32>("SELECT SUM(x) FROM foo")?);
+        Ok(())
+    }
+
+    #[test]
+    #[cfg(feature = "extra_check")]
+    fn test_execute_select() {
+        let db = checked_memory_handle();
+        let err = db.execute("SELECT 1 WHERE 1 < ?1", [1i32]).unwrap_err();
+        assert_eq!(
+            err,
+            Error::ExecuteReturnedResults,
+            "Unexpected error: {}",
+            err
+        );
+    }
+
+    #[test]
+    #[cfg(feature = "extra_check")]
+    fn test_execute_multiple() {
+        let db = checked_memory_handle();
+        let err = db
+            .execute(
+                "CREATE TABLE foo(x INTEGER); CREATE TABLE foo(x INTEGER)",
+                [],
+            )
+            .unwrap_err();
+        match err {
+            Error::MultipleStatement => (),
+            _ => panic!("Unexpected error: {}", err),
+        }
+    }
+
+    #[test]
+    fn test_prepare_column_names() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        db.execute_batch("CREATE TABLE foo(x INTEGER);")?;
+
+        let stmt = db.prepare("SELECT * FROM foo")?;
+        assert_eq!(stmt.column_count(), 1);
+        assert_eq!(stmt.column_names(), vec!["x"]);
+
+        let stmt = db.prepare("SELECT x AS a, x AS b FROM foo")?;
+        assert_eq!(stmt.column_count(), 2);
+        assert_eq!(stmt.column_names(), vec!["a", "b"]);
+        Ok(())
+    }
+
+    #[test]
+    fn test_prepare_execute() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        db.execute_batch("CREATE TABLE foo(x INTEGER);")?;
+
+        let mut insert_stmt = db.prepare("INSERT INTO foo(x) VALUES(?1)")?;
+        assert_eq!(insert_stmt.execute([1i32])?, 1);
+        assert_eq!(insert_stmt.execute([2i32])?, 1);
+        assert_eq!(insert_stmt.execute([3i32])?, 1);
+
+        assert_eq!(insert_stmt.execute(["hello"])?, 1);
+        assert_eq!(insert_stmt.execute(["goodbye"])?, 1);
+        assert_eq!(insert_stmt.execute([types::Null])?, 1);
+
+        let mut update_stmt = db.prepare("UPDATE foo SET x=?1 WHERE x<?2")?;
+        assert_eq!(update_stmt.execute([3i32, 3i32])?, 2);
+        assert_eq!(update_stmt.execute([3i32, 3i32])?, 0);
+        assert_eq!(update_stmt.execute([8i32, 8i32])?, 3);
+        Ok(())
+    }
+
+    #[test]
+    fn test_prepare_query() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        db.execute_batch("CREATE TABLE foo(x INTEGER);")?;
+
+        let mut insert_stmt = db.prepare("INSERT INTO foo(x) VALUES(?1)")?;
+        assert_eq!(insert_stmt.execute([1i32])?, 1);
+        assert_eq!(insert_stmt.execute([2i32])?, 1);
+        assert_eq!(insert_stmt.execute([3i32])?, 1);
+
+        let mut query = db.prepare("SELECT x FROM foo WHERE x < ?1 ORDER BY x DESC")?;
+        {
+            let mut rows = query.query([4i32])?;
+            let mut v = Vec::<i32>::new();
+
+            while let Some(row) = rows.next()? {
+                v.push(row.get(0)?);
+            }
+
+            assert_eq!(v, [3i32, 2, 1]);
+        }
+
+        {
+            let mut rows = query.query([3i32])?;
+            let mut v = Vec::<i32>::new();
+
+            while let Some(row) = rows.next()? {
+                v.push(row.get(0)?);
+            }
+
+            assert_eq!(v, [2i32, 1]);
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn test_query_map() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        let sql = "BEGIN;
+                   CREATE TABLE foo(x INTEGER, y TEXT);
+                   INSERT INTO foo VALUES(4, \"hello\");
+                   INSERT INTO foo VALUES(3, \", \");
+                   INSERT INTO foo VALUES(2, \"world\");
+                   INSERT INTO foo VALUES(1, \"!\");
+                   END;";
+        db.execute_batch(sql)?;
+
+        let mut query = db.prepare("SELECT x, y FROM foo ORDER BY x DESC")?;
+        let results: Result<Vec<String>> = query.query([])?.map(|row| row.get(1)).collect();
+
+        assert_eq!(results?.concat(), "hello, world!");
+        Ok(())
+    }
+
+    #[test]
+    fn test_query_row() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        let sql = "BEGIN;
+                   CREATE TABLE foo(x INTEGER);
+                   INSERT INTO foo VALUES(1);
+                   INSERT INTO foo VALUES(2);
+                   INSERT INTO foo VALUES(3);
+                   INSERT INTO foo VALUES(4);
+                   END;";
+        db.execute_batch(sql)?;
+
+        assert_eq!(10i64, db.one_column::<i64>("SELECT SUM(x) FROM foo")?);
+
+        let result: Result<i64> = db.one_column("SELECT x FROM foo WHERE x > 5");
+        match result.unwrap_err() {
+            Error::QueryReturnedNoRows => (),
+            err => panic!("Unexpected error {}", err),
+        }
+
+        let bad_query_result = db.query_row("NOT A PROPER QUERY; test123", [], |_| Ok(()));
+
+        bad_query_result.unwrap_err();
+        Ok(())
+    }
+
+    #[test]
+    fn test_optional() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+
+        let result: Result<i64> = db.one_column("SELECT 1 WHERE 0 <> 0");
+        let result = result.optional();
+        match result? {
+            None => (),
+            _ => panic!("Unexpected result"),
+        }
+
+        let result: Result<i64> = db.one_column("SELECT 1 WHERE 0 == 0");
+        let result = result.optional();
+        match result? {
+            Some(1) => (),
+            _ => panic!("Unexpected result"),
+        }
+
+        let bad_query_result: Result<i64> = db.one_column("NOT A PROPER QUERY");
+        let bad_query_result = bad_query_result.optional();
+        bad_query_result.unwrap_err();
+        Ok(())
+    }
+
+    #[test]
+    fn test_pragma_query_row() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        assert_eq!("memory", db.one_column::<String>("PRAGMA journal_mode")?);
+        let mode = db.one_column::<String>("PRAGMA journal_mode=off")?;
+        if cfg!(features = "bundled") {
+            assert_eq!(mode, "off");
+        } else {
+            // Note: system SQLite on macOS defaults to "off" rather than
+            // "memory" for the journal mode (which cannot be changed for
+            // in-memory connections). This seems like it's *probably* legal
+            // according to the docs below, so we relax this test when not
+            // bundling:
+            //
+            // From https://www.sqlite.org/pragma.html#pragma_journal_mode
+            // > Note that the journal_mode for an in-memory database is either
+            // > MEMORY or OFF and can not be changed to a different value. An
+            // > attempt to change the journal_mode of an in-memory database to
+            // > any setting other than MEMORY or OFF is ignored.
+            assert!(mode == "memory" || mode == "off", "Got mode {:?}", mode);
+        }
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_prepare_failures() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        db.execute_batch("CREATE TABLE foo(x INTEGER);")?;
+
+        let err = db.prepare("SELECT * FROM does_not_exist").unwrap_err();
+        assert!(format!("{err}").contains("does_not_exist"));
+        Ok(())
+    }
+
+    #[test]
+    fn test_last_insert_rowid() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        db.execute_batch("CREATE TABLE foo(x INTEGER PRIMARY KEY)")?;
+        db.execute_batch("INSERT INTO foo DEFAULT VALUES")?;
+
+        assert_eq!(db.last_insert_rowid(), 1);
+
+        let mut stmt = db.prepare("INSERT INTO foo DEFAULT VALUES")?;
+        for _ in 0i32..9 {
+            stmt.execute([])?;
+        }
+        assert_eq!(db.last_insert_rowid(), 10);
+        Ok(())
+    }
+
+    #[test]
+    fn test_is_autocommit() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        assert!(
+            db.is_autocommit(),
+            "autocommit expected to be active by default"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_is_busy() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        assert!(!db.is_busy());
+        let mut stmt = db.prepare("PRAGMA schema_version")?;
+        assert!(!db.is_busy());
+        {
+            let mut rows = stmt.query([])?;
+            assert!(!db.is_busy());
+            let row = rows.next()?;
+            assert!(db.is_busy());
+            assert!(row.is_some());
+        }
+        assert!(!db.is_busy());
+        Ok(())
+    }
+
+    #[test]
+    fn test_statement_debugging() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        let query = "SELECT 12345";
+        let stmt = db.prepare(query)?;
+
+        assert!(format!("{stmt:?}").contains(query));
+        Ok(())
+    }
+
+    #[test]
+    fn test_notnull_constraint_error() -> Result<()> {
+        // extended error codes for constraints were added in SQLite 3.7.16; if we're
+        // running on our bundled version, we know the extended error code exists.
+        fn check_extended_code(extended_code: c_int) {
+            assert_eq!(extended_code, ffi::SQLITE_CONSTRAINT_NOTNULL);
+        }
+
+        let db = Connection::open_in_memory()?;
+        db.execute_batch("CREATE TABLE foo(x NOT NULL)")?;
+
+        let result = db.execute("INSERT INTO foo (x) VALUES (NULL)", []);
+
+        match result.unwrap_err() {
+            Error::SqliteFailure(err, _) => {
+                assert_eq!(err.code, ErrorCode::ConstraintViolation);
+                check_extended_code(err.extended_code);
+            }
+            err => panic!("Unexpected error {}", err),
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn test_version_string() {
+        let n = version_number();
+        let major = n / 1_000_000;
+        let minor = (n % 1_000_000) / 1_000;
+        let patch = n % 1_000;
+
+        assert!(version().contains(&format!("{major}.{minor}.{patch}")));
+    }
+
+    #[test]
+    #[cfg(feature = "functions")]
+    fn test_interrupt() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+
+        let interrupt_handle = db.get_interrupt_handle();
+
+        db.create_scalar_function(
+            "interrupt",
+            0,
+            functions::FunctionFlags::default(),
+            move |_| {
+                interrupt_handle.interrupt();
+                Ok(0)
+            },
+        )?;
+
+        let mut stmt =
+            db.prepare("SELECT interrupt() FROM (SELECT 1 UNION SELECT 2 UNION SELECT 3)")?;
+
+        let result: Result<Vec<i32>> = stmt.query([])?.map(|r| r.get(0)).collect();
+
+        assert_eq!(
+            result.unwrap_err().sqlite_error_code(),
+            Some(ErrorCode::OperationInterrupted)
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_interrupt_close() {
+        let db = checked_memory_handle();
+        let handle = db.get_interrupt_handle();
+        handle.interrupt();
+        db.close().unwrap();
+        handle.interrupt();
+
+        // Look at it's internals to see if we cleared it out properly.
+        let db_guard = handle.db_lock.lock().unwrap();
+        assert!(db_guard.is_null());
+        // It would be nice to test that we properly handle close/interrupt
+        // running at the same time, but it seems impossible to do with any
+        // degree of reliability.
+    }
+
+    #[test]
+    fn test_get_raw() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        db.execute_batch("CREATE TABLE foo(i, x);")?;
+        let vals = ["foobar", "1234", "qwerty"];
+        let mut insert_stmt = db.prepare("INSERT INTO foo(i, x) VALUES(?1, ?2)")?;
+        for (i, v) in vals.iter().enumerate() {
+            let i_to_insert = i as i64;
+            assert_eq!(insert_stmt.execute(params![i_to_insert, v])?, 1);
+        }
+
+        let mut query = db.prepare("SELECT i, x FROM foo")?;
+        let mut rows = query.query([])?;
+
+        while let Some(row) = rows.next()? {
+            let i = row.get_ref(0)?.as_i64()?;
+            let expect = vals[i as usize];
+            let x = row.get_ref("x")?.as_str()?;
+            assert_eq!(x, expect);
+        }
+
+        let mut query = db.prepare("SELECT x FROM foo")?;
+        let rows = query.query_map([], |row| {
+            let x = row.get_ref(0)?.as_str()?; // check From<FromSqlError> for Error
+            Ok(x[..].to_owned())
+        })?;
+
+        for (i, row) in rows.enumerate() {
+            assert_eq!(row?, vals[i]);
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn test_from_handle() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        let handle = unsafe { db.handle() };
+        {
+            let db = unsafe { Connection::from_handle(handle) }?;
+            db.execute_batch("PRAGMA VACUUM")?;
+        }
+        db.close().unwrap();
+        Ok(())
+    }
+
+    #[test]
+    fn test_from_handle_owned() -> Result<()> {
+        let mut handle: *mut ffi::sqlite3 = std::ptr::null_mut();
+        let r = unsafe { ffi::sqlite3_open(":memory:\0".as_ptr() as *const i8, &mut handle) };
+        assert_eq!(r, ffi::SQLITE_OK);
+        let db = unsafe { Connection::from_handle_owned(handle) }?;
+        db.execute_batch("PRAGMA VACUUM")?;
+        Ok(())
+    }
+
+    mod query_and_then_tests {
+
+        use super::*;
+
+        #[derive(Debug)]
+        enum CustomError {
+            SomeError,
+            Sqlite(Error),
+        }
+
+        impl fmt::Display for CustomError {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+                match *self {
+                    CustomError::SomeError => write!(f, "my custom error"),
+                    CustomError::Sqlite(ref se) => write!(f, "my custom error: {se}"),
+                }
+            }
+        }
+
+        impl StdError for CustomError {
+            fn description(&self) -> &str {
+                "my custom error"
+            }
+
+            fn cause(&self) -> Option<&dyn StdError> {
+                match *self {
+                    CustomError::SomeError => None,
+                    CustomError::Sqlite(ref se) => Some(se),
+                }
+            }
+        }
+
+        impl From<Error> for CustomError {
+            fn from(se: Error) -> CustomError {
+                CustomError::Sqlite(se)
+            }
+        }
+
+        type CustomResult<T> = Result<T, CustomError>;
+
+        #[test]
+        fn test_query_and_then() -> Result<()> {
+            let db = Connection::open_in_memory()?;
+            let sql = "BEGIN;
+                       CREATE TABLE foo(x INTEGER, y TEXT);
+                       INSERT INTO foo VALUES(4, \"hello\");
+                       INSERT INTO foo VALUES(3, \", \");
+                       INSERT INTO foo VALUES(2, \"world\");
+                       INSERT INTO foo VALUES(1, \"!\");
+                       END;";
+            db.execute_batch(sql)?;
+
+            let mut query = db.prepare("SELECT x, y FROM foo ORDER BY x DESC")?;
+            let results: Result<Vec<String>> =
+                query.query_and_then([], |row| row.get(1))?.collect();
+
+            assert_eq!(results?.concat(), "hello, world!");
+            Ok(())
+        }
+
+        #[test]
+        fn test_query_and_then_fails() -> Result<()> {
+            let db = Connection::open_in_memory()?;
+            let sql = "BEGIN;
+                       CREATE TABLE foo(x INTEGER, y TEXT);
+                       INSERT INTO foo VALUES(4, \"hello\");
+                       INSERT INTO foo VALUES(3, \", \");
+                       INSERT INTO foo VALUES(2, \"world\");
+                       INSERT INTO foo VALUES(1, \"!\");
+                       END;";
+            db.execute_batch(sql)?;
+
+            let mut query = db.prepare("SELECT x, y FROM foo ORDER BY x DESC")?;
+            let bad_type: Result<Vec<f64>> = query.query_and_then([], |row| row.get(1))?.collect();
+
+            match bad_type.unwrap_err() {
+                Error::InvalidColumnType(..) => (),
+                err => panic!("Unexpected error {}", err),
+            }
+
+            let bad_idx: Result<Vec<String>> =
+                query.query_and_then([], |row| row.get(3))?.collect();
+
+            match bad_idx.unwrap_err() {
+                Error::InvalidColumnIndex(_) => (),
+                err => panic!("Unexpected error {}", err),
+            }
+            Ok(())
+        }
+
+        #[test]
+        fn test_query_and_then_custom_error() -> CustomResult<()> {
+            let db = Connection::open_in_memory()?;
+            let sql = "BEGIN;
+                       CREATE TABLE foo(x INTEGER, y TEXT);
+                       INSERT INTO foo VALUES(4, \"hello\");
+                       INSERT INTO foo VALUES(3, \", \");
+                       INSERT INTO foo VALUES(2, \"world\");
+                       INSERT INTO foo VALUES(1, \"!\");
+                       END;";
+            db.execute_batch(sql)?;
+
+            let mut query = db.prepare("SELECT x, y FROM foo ORDER BY x DESC")?;
+            let results: CustomResult<Vec<String>> = query
+                .query_and_then([], |row| row.get(1).map_err(CustomError::Sqlite))?
+                .collect();
+
+            assert_eq!(results?.concat(), "hello, world!");
+            Ok(())
+        }
+
+        #[test]
+        fn test_query_and_then_custom_error_fails() -> Result<()> {
+            let db = Connection::open_in_memory()?;
+            let sql = "BEGIN;
+                       CREATE TABLE foo(x INTEGER, y TEXT);
+                       INSERT INTO foo VALUES(4, \"hello\");
+                       INSERT INTO foo VALUES(3, \", \");
+                       INSERT INTO foo VALUES(2, \"world\");
+                       INSERT INTO foo VALUES(1, \"!\");
+                       END;";
+            db.execute_batch(sql)?;
+
+            let mut query = db.prepare("SELECT x, y FROM foo ORDER BY x DESC")?;
+            let bad_type: CustomResult<Vec<f64>> = query
+                .query_and_then([], |row| row.get(1).map_err(CustomError::Sqlite))?
+                .collect();
+
+            match bad_type.unwrap_err() {
+                CustomError::Sqlite(Error::InvalidColumnType(..)) => (),
+                err => panic!("Unexpected error {}", err),
+            }
+
+            let bad_idx: CustomResult<Vec<String>> = query
+                .query_and_then([], |row| row.get(3).map_err(CustomError::Sqlite))?
+                .collect();
+
+            match bad_idx.unwrap_err() {
+                CustomError::Sqlite(Error::InvalidColumnIndex(_)) => (),
+                err => panic!("Unexpected error {}", err),
+            }
+
+            let non_sqlite_err: CustomResult<Vec<String>> = query
+                .query_and_then([], |_| Err(CustomError::SomeError))?
+                .collect();
+
+            match non_sqlite_err.unwrap_err() {
+                CustomError::SomeError => (),
+                err => panic!("Unexpected error {}", err),
+            }
+            Ok(())
+        }
+
+        #[test]
+        fn test_query_row_and_then_custom_error() -> CustomResult<()> {
+            let db = Connection::open_in_memory()?;
+            let sql = "BEGIN;
+                       CREATE TABLE foo(x INTEGER, y TEXT);
+                       INSERT INTO foo VALUES(4, \"hello\");
+                       END;";
+            db.execute_batch(sql)?;
+
+            let query = "SELECT x, y FROM foo ORDER BY x DESC";
+            let results: CustomResult<String> =
+                db.query_row_and_then(query, [], |row| row.get(1).map_err(CustomError::Sqlite));
+
+            assert_eq!(results?, "hello");
+            Ok(())
+        }
+
+        #[test]
+        fn test_query_row_and_then_custom_error_fails() -> Result<()> {
+            let db = Connection::open_in_memory()?;
+            let sql = "BEGIN;
+                       CREATE TABLE foo(x INTEGER, y TEXT);
+                       INSERT INTO foo VALUES(4, \"hello\");
+                       END;";
+            db.execute_batch(sql)?;
+
+            let query = "SELECT x, y FROM foo ORDER BY x DESC";
+            let bad_type: CustomResult<f64> =
+                db.query_row_and_then(query, [], |row| row.get(1).map_err(CustomError::Sqlite));
+
+            match bad_type.unwrap_err() {
+                CustomError::Sqlite(Error::InvalidColumnType(..)) => (),
+                err => panic!("Unexpected error {}", err),
+            }
+
+            let bad_idx: CustomResult<String> =
+                db.query_row_and_then(query, [], |row| row.get(3).map_err(CustomError::Sqlite));
+
+            match bad_idx.unwrap_err() {
+                CustomError::Sqlite(Error::InvalidColumnIndex(_)) => (),
+                err => panic!("Unexpected error {}", err),
+            }
+
+            let non_sqlite_err: CustomResult<String> =
+                db.query_row_and_then(query, [], |_| Err(CustomError::SomeError));
+
+            match non_sqlite_err.unwrap_err() {
+                CustomError::SomeError => (),
+                err => panic!("Unexpected error {}", err),
+            }
+            Ok(())
+        }
+    }
+
+    #[test]
+    fn test_dynamic() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        let sql = "BEGIN;
+                       CREATE TABLE foo(x INTEGER, y TEXT);
+                       INSERT INTO foo VALUES(4, \"hello\");
+                       END;";
+        db.execute_batch(sql)?;
+
+        db.query_row("SELECT * FROM foo", [], |r| {
+            assert_eq!(2, r.as_ref().column_count());
+            Ok(())
+        })
+    }
+    #[test]
+    fn test_dyn_box() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        db.execute_batch("CREATE TABLE foo(x INTEGER);")?;
+        let b: Box<dyn ToSql> = Box::new(5);
+        db.execute("INSERT INTO foo VALUES(?1)", [b])?;
+        db.query_row("SELECT x FROM foo", [], |r| {
+            assert_eq!(5, r.get_unwrap::<_, i32>(0));
+            Ok(())
+        })
+    }
+
+    #[test]
+    fn test_params() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        db.query_row(
+            "SELECT
+            ?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10,
+            ?11, ?12, ?13, ?14, ?15, ?16, ?17, ?18, ?19, ?20,
+            ?21, ?22, ?23, ?24, ?25, ?26, ?27, ?28, ?29, ?30,
+            ?31, ?32, ?33, ?34;",
+            params![
+                1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+                1, 1, 1, 1, 1, 1,
+            ],
+            |r| {
+                assert_eq!(1, r.get_unwrap::<_, i32>(0));
+                Ok(())
+            },
+        )
+    }
+
+    #[test]
+    #[cfg(not(feature = "extra_check"))]
+    fn test_alter_table() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        db.execute_batch("CREATE TABLE x(t);")?;
+        // `execute_batch` should be used but `execute` should also work
+        db.execute("ALTER TABLE x RENAME TO y;", [])?;
+        Ok(())
+    }
+
+    #[test]
+    fn test_batch() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        let sql = r"
+             CREATE TABLE tbl1 (col);
+             CREATE TABLE tbl2 (col);
+             ";
+        let batch = Batch::new(&db, sql);
+        for stmt in batch {
+            let mut stmt = stmt?;
+            stmt.execute([])?;
+        }
+        Ok(())
+    }
+
+    #[test]
+    #[cfg(feature = "modern_sqlite")]
+    fn test_returning() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        db.execute_batch("CREATE TABLE foo(x INTEGER PRIMARY KEY)")?;
+        let row_id = db.one_column::<i64>("INSERT INTO foo DEFAULT VALUES RETURNING ROWID")?;
+        assert_eq!(row_id, 1);
+        Ok(())
+    }
+
+    #[test]
+    fn test_cache_flush() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        db.cache_flush()
+    }
+
+    #[test]
+    pub fn db_readonly() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        assert!(!db.is_readonly(MAIN_DB)?);
+        Ok(())
+    }
+}
diff --git a/crates/rusqlite/src/limits.rs b/crates/rusqlite/src/limits.rs
new file mode 100644
index 0000000..d0694e3
--- /dev/null
+++ b/crates/rusqlite/src/limits.rs
@@ -0,0 +1,163 @@
+//! Run-Time Limits
+
+use crate::{ffi, Connection};
+use std::os::raw::c_int;
+
+/// Run-Time limit categories, for use with [`Connection::limit`] and
+/// [`Connection::set_limit`].
+///
+/// See the official documentation for more information:
+/// - <https://www.sqlite.org/c3ref/c_limit_attached.html>
+/// - <https://www.sqlite.org/limits.html>
+#[repr(i32)]
+#[non_exhaustive]
+#[allow(clippy::upper_case_acronyms, non_camel_case_types)]
+#[cfg_attr(docsrs, doc(cfg(feature = "limits")))]
+pub enum Limit {
+    /// The maximum size of any string or BLOB or table row, in bytes.
+    SQLITE_LIMIT_LENGTH = ffi::SQLITE_LIMIT_LENGTH,
+    /// The maximum length of an SQL statement, in bytes.
+    SQLITE_LIMIT_SQL_LENGTH = ffi::SQLITE_LIMIT_SQL_LENGTH,
+    /// The maximum number of columns in a table definition or in the result set
+    /// of a SELECT or the maximum number of columns in an index or in an
+    /// ORDER BY or GROUP BY clause.
+    SQLITE_LIMIT_COLUMN = ffi::SQLITE_LIMIT_COLUMN,
+    /// The maximum depth of the parse tree on any expression.
+    SQLITE_LIMIT_EXPR_DEPTH = ffi::SQLITE_LIMIT_EXPR_DEPTH,
+    /// The maximum number of terms in a compound SELECT statement.
+    SQLITE_LIMIT_COMPOUND_SELECT = ffi::SQLITE_LIMIT_COMPOUND_SELECT,
+    /// The maximum number of instructions in a virtual machine program used to
+    /// implement an SQL statement.
+    SQLITE_LIMIT_VDBE_OP = ffi::SQLITE_LIMIT_VDBE_OP,
+    /// The maximum number of arguments on a function.
+    SQLITE_LIMIT_FUNCTION_ARG = ffi::SQLITE_LIMIT_FUNCTION_ARG,
+    /// The maximum number of attached databases.
+    SQLITE_LIMIT_ATTACHED = ffi::SQLITE_LIMIT_ATTACHED,
+    /// The maximum length of the pattern argument to the LIKE or GLOB
+    /// operators.
+    SQLITE_LIMIT_LIKE_PATTERN_LENGTH = ffi::SQLITE_LIMIT_LIKE_PATTERN_LENGTH,
+    /// The maximum index number of any parameter in an SQL statement.
+    SQLITE_LIMIT_VARIABLE_NUMBER = ffi::SQLITE_LIMIT_VARIABLE_NUMBER,
+    /// The maximum depth of recursion for triggers.
+    SQLITE_LIMIT_TRIGGER_DEPTH = ffi::SQLITE_LIMIT_TRIGGER_DEPTH,
+    /// The maximum number of auxiliary worker threads that a single prepared
+    /// statement may start.
+    SQLITE_LIMIT_WORKER_THREADS = ffi::SQLITE_LIMIT_WORKER_THREADS,
+}
+
+impl Connection {
+    /// Returns the current value of a [`Limit`].
+    #[inline]
+    #[cfg_attr(docsrs, doc(cfg(feature = "limits")))]
+    pub fn limit(&self, limit: Limit) -> i32 {
+        let c = self.db.borrow();
+        unsafe { ffi::sqlite3_limit(c.db(), limit as c_int, -1) }
+    }
+
+    /// Changes the [`Limit`] to `new_val`, returning the prior
+    /// value of the limit.
+    #[inline]
+    #[cfg_attr(docsrs, doc(cfg(feature = "limits")))]
+    pub fn set_limit(&self, limit: Limit, new_val: i32) -> i32 {
+        let c = self.db.borrow_mut();
+        unsafe { ffi::sqlite3_limit(c.db(), limit as c_int, new_val) }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::{Connection, Result};
+
+    #[test]
+    fn test_limit_values() {
+        assert_eq!(Limit::SQLITE_LIMIT_LENGTH as i32, ffi::SQLITE_LIMIT_LENGTH,);
+        assert_eq!(
+            Limit::SQLITE_LIMIT_SQL_LENGTH as i32,
+            ffi::SQLITE_LIMIT_SQL_LENGTH,
+        );
+        assert_eq!(Limit::SQLITE_LIMIT_COLUMN as i32, ffi::SQLITE_LIMIT_COLUMN,);
+        assert_eq!(
+            Limit::SQLITE_LIMIT_EXPR_DEPTH as i32,
+            ffi::SQLITE_LIMIT_EXPR_DEPTH,
+        );
+        assert_eq!(
+            Limit::SQLITE_LIMIT_COMPOUND_SELECT as i32,
+            ffi::SQLITE_LIMIT_COMPOUND_SELECT,
+        );
+        assert_eq!(
+            Limit::SQLITE_LIMIT_VDBE_OP as i32,
+            ffi::SQLITE_LIMIT_VDBE_OP,
+        );
+        assert_eq!(
+            Limit::SQLITE_LIMIT_FUNCTION_ARG as i32,
+            ffi::SQLITE_LIMIT_FUNCTION_ARG,
+        );
+        assert_eq!(
+            Limit::SQLITE_LIMIT_ATTACHED as i32,
+            ffi::SQLITE_LIMIT_ATTACHED,
+        );
+        assert_eq!(
+            Limit::SQLITE_LIMIT_LIKE_PATTERN_LENGTH as i32,
+            ffi::SQLITE_LIMIT_LIKE_PATTERN_LENGTH,
+        );
+        assert_eq!(
+            Limit::SQLITE_LIMIT_VARIABLE_NUMBER as i32,
+            ffi::SQLITE_LIMIT_VARIABLE_NUMBER,
+        );
+        #[cfg(feature = "bundled")]
+        assert_eq!(
+            Limit::SQLITE_LIMIT_TRIGGER_DEPTH as i32,
+            ffi::SQLITE_LIMIT_TRIGGER_DEPTH,
+        );
+        #[cfg(feature = "bundled")]
+        assert_eq!(
+            Limit::SQLITE_LIMIT_WORKER_THREADS as i32,
+            ffi::SQLITE_LIMIT_WORKER_THREADS,
+        );
+    }
+
+    #[test]
+    fn test_limit() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        db.set_limit(Limit::SQLITE_LIMIT_LENGTH, 1024);
+        assert_eq!(1024, db.limit(Limit::SQLITE_LIMIT_LENGTH));
+
+        db.set_limit(Limit::SQLITE_LIMIT_SQL_LENGTH, 1024);
+        assert_eq!(1024, db.limit(Limit::SQLITE_LIMIT_SQL_LENGTH));
+
+        db.set_limit(Limit::SQLITE_LIMIT_COLUMN, 64);
+        assert_eq!(64, db.limit(Limit::SQLITE_LIMIT_COLUMN));
+
+        db.set_limit(Limit::SQLITE_LIMIT_EXPR_DEPTH, 256);
+        assert_eq!(256, db.limit(Limit::SQLITE_LIMIT_EXPR_DEPTH));
+
+        db.set_limit(Limit::SQLITE_LIMIT_COMPOUND_SELECT, 32);
+        assert_eq!(32, db.limit(Limit::SQLITE_LIMIT_COMPOUND_SELECT));
+
+        db.set_limit(Limit::SQLITE_LIMIT_FUNCTION_ARG, 32);
+        assert_eq!(32, db.limit(Limit::SQLITE_LIMIT_FUNCTION_ARG));
+
+        db.set_limit(Limit::SQLITE_LIMIT_ATTACHED, 2);
+        assert_eq!(2, db.limit(Limit::SQLITE_LIMIT_ATTACHED));
+
+        db.set_limit(Limit::SQLITE_LIMIT_LIKE_PATTERN_LENGTH, 128);
+        assert_eq!(128, db.limit(Limit::SQLITE_LIMIT_LIKE_PATTERN_LENGTH));
+
+        db.set_limit(Limit::SQLITE_LIMIT_VARIABLE_NUMBER, 99);
+        assert_eq!(99, db.limit(Limit::SQLITE_LIMIT_VARIABLE_NUMBER));
+
+        // SQLITE_LIMIT_TRIGGER_DEPTH was added in SQLite 3.6.18.
+        if crate::version_number() >= 3_006_018 {
+            db.set_limit(Limit::SQLITE_LIMIT_TRIGGER_DEPTH, 32);
+            assert_eq!(32, db.limit(Limit::SQLITE_LIMIT_TRIGGER_DEPTH));
+        }
+
+        // SQLITE_LIMIT_WORKER_THREADS was added in SQLite 3.8.7.
+        if crate::version_number() >= 3_008_007 {
+            db.set_limit(Limit::SQLITE_LIMIT_WORKER_THREADS, 2);
+            assert_eq!(2, db.limit(Limit::SQLITE_LIMIT_WORKER_THREADS));
+        }
+        Ok(())
+    }
+}
diff --git a/crates/rusqlite/src/load_extension_guard.rs b/crates/rusqlite/src/load_extension_guard.rs
new file mode 100644
index 0000000..deed3b4
--- /dev/null
+++ b/crates/rusqlite/src/load_extension_guard.rs
@@ -0,0 +1,46 @@
+use crate::{Connection, Result};
+
+/// RAII guard temporarily enabling SQLite extensions to be loaded.
+///
+/// ## Example
+///
+/// ```rust,no_run
+/// # use rusqlite::{Connection, Result, LoadExtensionGuard};
+/// # use std::path::{Path};
+/// fn load_my_extension(conn: &Connection) -> Result<()> {
+///     unsafe {
+///         let _guard = LoadExtensionGuard::new(conn)?;
+///         conn.load_extension("trusted/sqlite/extension", None)
+///     }
+/// }
+/// ```
+#[cfg_attr(docsrs, doc(cfg(feature = "load_extension")))]
+pub struct LoadExtensionGuard<'conn> {
+    conn: &'conn Connection,
+}
+
+impl LoadExtensionGuard<'_> {
+    /// Attempt to enable loading extensions. Loading extensions will be
+    /// disabled when this guard goes out of scope. Cannot be meaningfully
+    /// nested.
+    ///
+    /// # Safety
+    ///
+    /// You must not run untrusted queries while extension loading is enabled.
+    ///
+    /// See the safety comment on [`Connection::load_extension_enable`] for more
+    /// details.
+    #[inline]
+    pub unsafe fn new(conn: &Connection) -> Result<LoadExtensionGuard<'_>> {
+        conn.load_extension_enable()
+            .map(|_| LoadExtensionGuard { conn })
+    }
+}
+
+#[allow(unused_must_use)]
+impl Drop for LoadExtensionGuard<'_> {
+    #[inline]
+    fn drop(&mut self) {
+        self.conn.load_extension_disable();
+    }
+}
diff --git a/crates/rusqlite/src/params.rs b/crates/rusqlite/src/params.rs
new file mode 100644
index 0000000..a4c5066
--- /dev/null
+++ b/crates/rusqlite/src/params.rs
@@ -0,0 +1,455 @@
+use crate::{Result, Statement, ToSql};
+
+mod sealed {
+    /// This trait exists just to ensure that the only impls of `trait Params`
+    /// that are allowed are ones in this crate.
+    pub trait Sealed {}
+}
+use sealed::Sealed;
+
+/// Trait used for [sets of parameter][params] passed into SQL
+/// statements/queries.
+///
+/// [params]: https://www.sqlite.org/c3ref/bind_blob.html
+///
+/// Note: Currently, this trait can only be implemented inside this crate.
+/// Additionally, it's methods (which are `doc(hidden)`) should currently not be
+/// considered part of the stable API, although it's possible they will
+/// stabilize in the future.
+///
+/// # Passing parameters to SQLite
+///
+/// Many functions in this library let you pass parameters to SQLite. Doing this
+/// lets you avoid any risk of SQL injection, and is simpler than escaping
+/// things manually. Aside from deprecated functions and a few helpers, this is
+/// indicated by the function taking a generic argument that implements `Params`
+/// (this trait).
+///
+/// ## Positional parameters
+///
+/// For cases where you want to pass a list of parameters where the number of
+/// parameters is known at compile time, this can be done in one of the
+/// following ways:
+///
+/// - For small lists of parameters up to 16 items, they may alternatively be
+///   passed as a tuple, as in `thing.query((1, "foo"))`.
+///
+///     This is somewhat inconvenient for a single item, since you need a
+///     weird-looking trailing comma: `thing.query(("example",))`. That case is
+///     perhaps more cleanly expressed as `thing.query(["example"])`.
+///
+/// - Using the [`rusqlite::params!`](crate::params!) macro, e.g.
+///   `thing.query(rusqlite::params![1, "foo", bar])`. This is mostly useful for
+///   heterogeneous lists where the number of parameters greater than 16, or
+///   homogenous lists of parameters where the number of parameters exceeds 32.
+///
+/// - For small homogeneous lists of parameters, they can either be passed as:
+///
+///     - an array, as in `thing.query([1i32, 2, 3, 4])` or `thing.query(["foo",
+///       "bar", "baz"])`.
+///
+///     - a reference to an array of references, as in `thing.query(&["foo",
+///       "bar", "baz"])` or `thing.query(&[&1i32, &2, &3])`.
+///
+///         (Note: in this case we don't implement this for slices for coherence
+///         reasons, so it really is only for the "reference to array" types —
+///         hence why the number of parameters must be <= 32 or you need to
+///         reach for `rusqlite::params!`)
+///
+///     Unfortunately, in the current design it's not possible to allow this for
+///     references to arrays of non-references (e.g. `&[1i32, 2, 3]`). Code like
+///     this should instead either use `params!`, an array literal, a `&[&dyn
+///     ToSql]` or if none of those work, [`ParamsFromIter`].
+///
+/// - As a slice of `ToSql` trait object references, e.g. `&[&dyn ToSql]`. This
+///   is mostly useful for passing parameter lists around as arguments without
+///   having every function take a generic `P: Params`.
+///
+/// ### Example (positional)
+///
+/// ```rust,no_run
+/// # use rusqlite::{Connection, Result, params};
+/// fn update_rows(conn: &Connection) -> Result<()> {
+///     let mut stmt = conn.prepare("INSERT INTO test (a, b) VALUES (?1, ?2)")?;
+///
+///     // Using a tuple:
+///     stmt.execute((0, "foobar"))?;
+///
+///     // Using `rusqlite::params!`:
+///     stmt.execute(params![1i32, "blah"])?;
+///
+///     // array literal — non-references
+///     stmt.execute([2i32, 3i32])?;
+///
+///     // array literal — references
+///     stmt.execute(["foo", "bar"])?;
+///
+///     // Slice literal, references:
+///     stmt.execute(&[&2i32, &3i32])?;
+///
+///     // Note: The types behind the references don't have to be `Sized`
+///     stmt.execute(&["foo", "bar"])?;
+///
+///     // However, this doesn't work (see above):
+///     // stmt.execute(&[1i32, 2i32])?;
+///     Ok(())
+/// }
+/// ```
+///
+/// ## Named parameters
+///
+/// SQLite lets you name parameters using a number of conventions (":foo",
+/// "@foo", "$foo"). You can pass named parameters in to SQLite using rusqlite
+/// in a few ways:
+///
+/// - Using the [`rusqlite::named_params!`](crate::named_params!) macro, as in
+///   `stmt.execute(named_params!{ ":name": "foo", ":age": 99 })`. Similar to
+///   the `params` macro, this is most useful for heterogeneous lists of
+///   parameters, or lists where the number of parameters exceeds 32.
+///
+/// - As a slice of `&[(&str, &dyn ToSql)]`. This is what essentially all of
+///   these boil down to in the end, conceptually at least. In theory you can
+///   pass this as `stmt`.
+///
+/// - As array references, similar to the positional params. This looks like
+///   `thing.query(&[(":foo", &1i32), (":bar", &2i32)])` or
+///   `thing.query(&[(":foo", "abc"), (":bar", "def")])`.
+///
+/// Note: Unbound named parameters will be left to the value they previously
+/// were bound with, falling back to `NULL` for parameters which have never been
+/// bound.
+///
+/// ### Example (named)
+///
+/// ```rust,no_run
+/// # use rusqlite::{Connection, Result, named_params};
+/// fn insert(conn: &Connection) -> Result<()> {
+///     let mut stmt = conn.prepare("INSERT INTO test (key, value) VALUES (:key, :value)")?;
+///     // Using `rusqlite::params!`:
+///     stmt.execute(named_params! { ":key": "one", ":val": 2 })?;
+///     // Alternatively:
+///     stmt.execute(&[(":key", "three"), (":val", "four")])?;
+///     // Or:
+///     stmt.execute(&[(":key", &100), (":val", &200)])?;
+///     Ok(())
+/// }
+/// ```
+///
+/// ## No parameters
+///
+/// You can just use an empty tuple or the empty array literal to run a query
+/// that accepts no parameters.
+///
+/// ### Example (no parameters)
+///
+/// The empty tuple:
+///
+/// ```rust,no_run
+/// # use rusqlite::{Connection, Result, params};
+/// fn delete_all_users(conn: &Connection) -> Result<()> {
+///     // You may also use `()`.
+///     conn.execute("DELETE FROM users", ())?;
+///     Ok(())
+/// }
+/// ```
+///
+/// The empty array:
+///
+/// ```rust,no_run
+/// # use rusqlite::{Connection, Result, params};
+/// fn delete_all_users(conn: &Connection) -> Result<()> {
+///     // Just use an empty array (e.g. `[]`) for no params.
+///     conn.execute("DELETE FROM users", [])?;
+///     Ok(())
+/// }
+/// ```
+///
+/// ## Dynamic parameter list
+///
+/// If you have a number of parameters which is unknown at compile time (for
+/// example, building a dynamic query at runtime), you have two choices:
+///
+/// - Use a `&[&dyn ToSql]`. This is often annoying to construct if you don't
+///   already have this type on-hand.
+/// - Use the [`ParamsFromIter`] type. This essentially lets you wrap an
+///   iterator some `T: ToSql` with something that implements `Params`. The
+///   usage of this looks like `rusqlite::params_from_iter(something)`.
+///
+/// A lot of the considerations here are similar either way, so you should see
+/// the [`ParamsFromIter`] documentation for more info / examples.
+pub trait Params: Sealed {
+    // XXX not public api, might not need to expose.
+    //
+    // Binds the parameters to the statement. It is unlikely calling this
+    // explicitly will do what you want. Please use `Statement::query` or
+    // similar directly.
+    //
+    // For now, just hide the function in the docs...
+    #[doc(hidden)]
+    fn __bind_in(self, stmt: &mut Statement<'_>) -> Result<()>;
+}
+
+// Explicitly impl for empty array. Critically, for `conn.execute([])` to be
+// unambiguous, this must be the *only* implementation for an empty array.
+//
+// This sadly prevents `impl<T: ToSql, const N: usize> Params for [T; N]`, which
+// forces people to use `params![...]` or `rusqlite::params_from_iter` for long
+// homogenous lists of parameters. This is not that big of a deal, but is
+// unfortunate, especially because I mostly did it because I wanted a simple
+// syntax for no-params that didnt require importing -- the empty tuple fits
+// that nicely, but I didn't think of it until much later.
+//
+// Admittedly, if we did have the generic impl, then we *wouldn't* support the
+// empty array literal as a parameter, since the `T` there would fail to be
+// inferred. The error message here would probably be quite bad, and so on
+// further thought, probably would end up causing *more* surprises, not less.
+impl Sealed for [&(dyn ToSql + Send + Sync); 0] {}
+impl Params for [&(dyn ToSql + Send + Sync); 0] {
+    #[inline]
+    fn __bind_in(self, stmt: &mut Statement<'_>) -> Result<()> {
+        stmt.ensure_parameter_count(0)
+    }
+}
+
+impl Sealed for &[&dyn ToSql] {}
+impl Params for &[&dyn ToSql] {
+    #[inline]
+    fn __bind_in(self, stmt: &mut Statement<'_>) -> Result<()> {
+        stmt.bind_parameters(self)
+    }
+}
+
+impl Sealed for &[(&str, &dyn ToSql)] {}
+impl Params for &[(&str, &dyn ToSql)] {
+    #[inline]
+    fn __bind_in(self, stmt: &mut Statement<'_>) -> Result<()> {
+        stmt.bind_parameters_named(self)
+    }
+}
+
+// Manual impls for the empty and singleton tuple, although the rest are covered
+// by macros.
+impl Sealed for () {}
+impl Params for () {
+    #[inline]
+    fn __bind_in(self, stmt: &mut Statement<'_>) -> Result<()> {
+        stmt.ensure_parameter_count(0)
+    }
+}
+
+// I'm pretty sure you could tweak the `single_tuple_impl` to accept this.
+impl<T: ToSql> Sealed for (T,) {}
+impl<T: ToSql> Params for (T,) {
+    #[inline]
+    fn __bind_in(self, stmt: &mut Statement<'_>) -> Result<()> {
+        stmt.ensure_parameter_count(1)?;
+        stmt.raw_bind_parameter(1, self.0)?;
+        Ok(())
+    }
+}
+
+macro_rules! single_tuple_impl {
+    ($count:literal : $(($field:tt $ftype:ident)),* $(,)?) => {
+        impl<$($ftype,)*> Sealed for ($($ftype,)*) where $($ftype: ToSql,)* {}
+        impl<$($ftype,)*> Params for ($($ftype,)*) where $($ftype: ToSql,)* {
+            fn __bind_in(self, stmt: &mut Statement<'_>) -> Result<()> {
+                stmt.ensure_parameter_count($count)?;
+                $({
+                    debug_assert!($field < $count);
+                    stmt.raw_bind_parameter($field + 1, self.$field)?;
+                })+
+                Ok(())
+            }
+        }
+    }
+}
+
+// We use a the macro for the rest, but don't bother with trying to implement it
+// in a single invocation (it's possible to do, but my attempts were almost the
+// same amount of code as just writing it out this way, and much more dense --
+// it is a more complicated case than the TryFrom macro we have for row->tuple).
+//
+// Note that going up to 16 (rather than the 12 that the impls in the stdlib
+// usually support) is just because we did the same in the `TryFrom<Row>` impl.
+// I didn't catch that then, but there's no reason to remove it, and it seems
+// nice to be consistent here; this way putting data in the database and getting
+// data out of the database are more symmetric in a (mostly superficial) sense.
+single_tuple_impl!(2: (0 A), (1 B));
+single_tuple_impl!(3: (0 A), (1 B), (2 C));
+single_tuple_impl!(4: (0 A), (1 B), (2 C), (3 D));
+single_tuple_impl!(5: (0 A), (1 B), (2 C), (3 D), (4 E));
+single_tuple_impl!(6: (0 A), (1 B), (2 C), (3 D), (4 E), (5 F));
+single_tuple_impl!(7: (0 A), (1 B), (2 C), (3 D), (4 E), (5 F), (6 G));
+single_tuple_impl!(8: (0 A), (1 B), (2 C), (3 D), (4 E), (5 F), (6 G), (7 H));
+single_tuple_impl!(9: (0 A), (1 B), (2 C), (3 D), (4 E), (5 F), (6 G), (7 H), (8 I));
+single_tuple_impl!(10: (0 A), (1 B), (2 C), (3 D), (4 E), (5 F), (6 G), (7 H), (8 I), (9 J));
+single_tuple_impl!(11: (0 A), (1 B), (2 C), (3 D), (4 E), (5 F), (6 G), (7 H), (8 I), (9 J), (10 K));
+single_tuple_impl!(12: (0 A), (1 B), (2 C), (3 D), (4 E), (5 F), (6 G), (7 H), (8 I), (9 J), (10 K), (11 L));
+single_tuple_impl!(13: (0 A), (1 B), (2 C), (3 D), (4 E), (5 F), (6 G), (7 H), (8 I), (9 J), (10 K), (11 L), (12 M));
+single_tuple_impl!(14: (0 A), (1 B), (2 C), (3 D), (4 E), (5 F), (6 G), (7 H), (8 I), (9 J), (10 K), (11 L), (12 M), (13 N));
+single_tuple_impl!(15: (0 A), (1 B), (2 C), (3 D), (4 E), (5 F), (6 G), (7 H), (8 I), (9 J), (10 K), (11 L), (12 M), (13 N), (14 O));
+single_tuple_impl!(16: (0 A), (1 B), (2 C), (3 D), (4 E), (5 F), (6 G), (7 H), (8 I), (9 J), (10 K), (11 L), (12 M), (13 N), (14 O), (15 P));
+
+macro_rules! impl_for_array_ref {
+    ($($N:literal)+) => {$(
+        // These are already generic, and there's a shedload of them, so lets
+        // avoid the compile time hit from making them all inline for now.
+        impl<T: ToSql + ?Sized> Sealed for &[&T; $N] {}
+        impl<T: ToSql + ?Sized> Params for &[&T; $N] {
+            fn __bind_in(self, stmt: &mut Statement<'_>) -> Result<()> {
+                stmt.bind_parameters(self)
+            }
+        }
+        impl<T: ToSql + ?Sized> Sealed for &[(&str, &T); $N] {}
+        impl<T: ToSql + ?Sized> Params for &[(&str, &T); $N] {
+            fn __bind_in(self, stmt: &mut Statement<'_>) -> Result<()> {
+                stmt.bind_parameters_named(self)
+            }
+        }
+        impl<T: ToSql> Sealed for [T; $N] {}
+        impl<T: ToSql> Params for [T; $N] {
+            #[inline]
+            fn __bind_in(self, stmt: &mut Statement<'_>) -> Result<()> {
+                stmt.bind_parameters(&self)
+            }
+        }
+    )+};
+}
+
+// Following libstd/libcore's (old) lead, implement this for arrays up to `[_;
+// 32]`. Note `[_; 0]` is intentionally omitted for coherence reasons, see the
+// note above the impl of `[&dyn ToSql; 0]` for more information.
+//
+// Note that this unfortunately means we can't use const generics here, but I
+// don't really think it matters -- users who hit that can use `params!` anyway.
+impl_for_array_ref!(
+    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
+    18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
+);
+
+/// Adapter type which allows any iterator over [`ToSql`] values to implement
+/// [`Params`].
+///
+/// This struct is created by the [`params_from_iter`] function.
+///
+/// This can be useful if you have something like an `&[String]` (of unknown
+/// length), and you want to use them with an API that wants something
+/// implementing `Params`. This way, you can avoid having to allocate storage
+/// for something like a `&[&dyn ToSql]`.
+///
+/// This essentially is only ever actually needed when dynamically generating
+/// SQL — static SQL (by definition) has the number of parameters known
+/// statically. As dynamically generating SQL is itself pretty advanced, this
+/// API is itself for advanced use cases (See "Realistic use case" in the
+/// examples).
+///
+/// # Example
+///
+/// ## Basic usage
+///
+/// ```rust,no_run
+/// use rusqlite::{params_from_iter, Connection, Result};
+/// use std::collections::BTreeSet;
+///
+/// fn query(conn: &Connection, ids: &BTreeSet<String>) -> Result<()> {
+///     assert_eq!(ids.len(), 3, "Unrealistic sample code");
+///
+///     let mut stmt = conn.prepare("SELECT * FROM users WHERE id IN (?1, ?2, ?3)")?;
+///     let _rows = stmt.query(params_from_iter(ids.iter()))?;
+///
+///     // use _rows...
+///     Ok(())
+/// }
+/// ```
+///
+/// ## Realistic use case
+///
+/// Here's how you'd use `ParamsFromIter` to call [`Statement::exists`] with a
+/// dynamic number of parameters.
+///
+/// ```rust,no_run
+/// use rusqlite::{Connection, Result};
+///
+/// pub fn any_active_users(conn: &Connection, usernames: &[String]) -> Result<bool> {
+///     if usernames.is_empty() {
+///         return Ok(false);
+///     }
+///
+///     // Note: `repeat_vars` never returns anything attacker-controlled, so
+///     // it's fine to use it in a dynamically-built SQL string.
+///     let vars = repeat_vars(usernames.len());
+///
+///     let sql = format!(
+///         // In practice this would probably be better as an `EXISTS` query.
+///         "SELECT 1 FROM user WHERE is_active AND name IN ({}) LIMIT 1",
+///         vars,
+///     );
+///     let mut stmt = conn.prepare(&sql)?;
+///     stmt.exists(rusqlite::params_from_iter(usernames))
+/// }
+///
+/// // Helper function to return a comma-separated sequence of `?`.
+/// // - `repeat_vars(0) => panic!(...)`
+/// // - `repeat_vars(1) => "?"`
+/// // - `repeat_vars(2) => "?,?"`
+/// // - `repeat_vars(3) => "?,?,?"`
+/// // - ...
+/// fn repeat_vars(count: usize) -> String {
+///     assert_ne!(count, 0);
+///     let mut s = "?,".repeat(count);
+///     // Remove trailing comma
+///     s.pop();
+///     s
+/// }
+/// ```
+///
+/// That is fairly complex, and even so would need even more work to be fully
+/// production-ready:
+///
+/// - production code should ensure `usernames` isn't so large that it will
+///   surpass [`conn.limit(Limit::SQLITE_LIMIT_VARIABLE_NUMBER)`][limits]),
+///   chunking if too large. (Note that the limits api requires rusqlite to have
+///   the "limits" feature).
+///
+/// - `repeat_vars` can be implemented in a way that avoids needing to allocate
+///   a String.
+///
+/// - Etc...
+///
+/// [limits]: crate::Connection::limit
+///
+/// This complexity reflects the fact that `ParamsFromIter` is mainly intended
+/// for advanced use cases — most of the time you should know how many
+/// parameters you have statically (and if you don't, you're either doing
+/// something tricky, or should take a moment to think about the design).
+#[derive(Clone, Debug)]
+pub struct ParamsFromIter<I>(I);
+
+/// Constructor function for a [`ParamsFromIter`]. See its documentation for
+/// more.
+#[inline]
+pub fn params_from_iter<I>(iter: I) -> ParamsFromIter<I>
+where
+    I: IntoIterator,
+    I::Item: ToSql,
+{
+    ParamsFromIter(iter)
+}
+
+impl<I> Sealed for ParamsFromIter<I>
+where
+    I: IntoIterator,
+    I::Item: ToSql,
+{
+}
+
+impl<I> Params for ParamsFromIter<I>
+where
+    I: IntoIterator,
+    I::Item: ToSql,
+{
+    #[inline]
+    fn __bind_in(self, stmt: &mut Statement<'_>) -> Result<()> {
+        stmt.bind_parameters(self.0)
+    }
+}
diff --git a/crates/rusqlite/src/pragma.rs b/crates/rusqlite/src/pragma.rs
new file mode 100644
index 0000000..338be5f
--- /dev/null
+++ b/crates/rusqlite/src/pragma.rs
@@ -0,0 +1,456 @@
+//! Pragma helpers
+
+use std::ops::Deref;
+
+use crate::error::Error;
+use crate::ffi;
+use crate::types::{ToSql, ToSqlOutput, ValueRef};
+use crate::{Connection, DatabaseName, Result, Row};
+
+pub struct Sql {
+    buf: String,
+}
+
+impl Sql {
+    pub fn new() -> Sql {
+        Sql { buf: String::new() }
+    }
+
+    pub fn push_pragma(
+        &mut self,
+        schema_name: Option<DatabaseName<'_>>,
+        pragma_name: &str,
+    ) -> Result<()> {
+        self.push_keyword("PRAGMA")?;
+        self.push_space();
+        if let Some(schema_name) = schema_name {
+            self.push_schema_name(schema_name);
+            self.push_dot();
+        }
+        self.push_keyword(pragma_name)
+    }
+
+    pub fn push_keyword(&mut self, keyword: &str) -> Result<()> {
+        if !keyword.is_empty() && is_identifier(keyword) {
+            self.buf.push_str(keyword);
+            Ok(())
+        } else {
+            Err(Error::SqliteFailure(
+                ffi::Error::new(ffi::SQLITE_MISUSE),
+                Some(format!("Invalid keyword \"{keyword}\"")),
+            ))
+        }
+    }
+
+    pub fn push_schema_name(&mut self, schema_name: DatabaseName<'_>) {
+        match schema_name {
+            DatabaseName::Main => self.buf.push_str("main"),
+            DatabaseName::Temp => self.buf.push_str("temp"),
+            DatabaseName::Attached(s) => self.push_identifier(s),
+        };
+    }
+
+    pub fn push_identifier(&mut self, s: &str) {
+        if is_identifier(s) {
+            self.buf.push_str(s);
+        } else {
+            self.wrap_and_escape(s, '"');
+        }
+    }
+
+    pub fn push_value(&mut self, value: &dyn ToSql) -> Result<()> {
+        let value = value.to_sql()?;
+        let value = match value {
+            ToSqlOutput::Borrowed(v) => v,
+            ToSqlOutput::Owned(ref v) => ValueRef::from(v),
+            #[cfg(feature = "blob")]
+            ToSqlOutput::ZeroBlob(_) => {
+                return Err(Error::SqliteFailure(
+                    ffi::Error::new(ffi::SQLITE_MISUSE),
+                    Some(format!("Unsupported value \"{value:?}\"")),
+                ));
+            }
+            #[cfg(feature = "array")]
+            ToSqlOutput::Array(_) => {
+                return Err(Error::SqliteFailure(
+                    ffi::Error::new(ffi::SQLITE_MISUSE),
+                    Some(format!("Unsupported value \"{value:?}\"")),
+                ));
+            }
+        };
+        match value {
+            ValueRef::Integer(i) => {
+                self.push_int(i);
+            }
+            ValueRef::Real(r) => {
+                self.push_real(r);
+            }
+            ValueRef::Text(s) => {
+                let s = std::str::from_utf8(s)?;
+                self.push_string_literal(s);
+            }
+            _ => {
+                return Err(Error::SqliteFailure(
+                    ffi::Error::new(ffi::SQLITE_MISUSE),
+                    Some(format!("Unsupported value \"{value:?}\"")),
+                ));
+            }
+        };
+        Ok(())
+    }
+
+    pub fn push_string_literal(&mut self, s: &str) {
+        self.wrap_and_escape(s, '\'');
+    }
+
+    pub fn push_int(&mut self, i: i64) {
+        self.buf.push_str(&i.to_string());
+    }
+
+    pub fn push_real(&mut self, f: f64) {
+        self.buf.push_str(&f.to_string());
+    }
+
+    pub fn push_space(&mut self) {
+        self.buf.push(' ');
+    }
+
+    pub fn push_dot(&mut self) {
+        self.buf.push('.');
+    }
+
+    pub fn push_equal_sign(&mut self) {
+        self.buf.push('=');
+    }
+
+    pub fn open_brace(&mut self) {
+        self.buf.push('(');
+    }
+
+    pub fn close_brace(&mut self) {
+        self.buf.push(')');
+    }
+
+    pub fn as_str(&self) -> &str {
+        &self.buf
+    }
+
+    fn wrap_and_escape(&mut self, s: &str, quote: char) {
+        self.buf.push(quote);
+        let chars = s.chars();
+        for ch in chars {
+            // escape `quote` by doubling it
+            if ch == quote {
+                self.buf.push(ch);
+            }
+            self.buf.push(ch);
+        }
+        self.buf.push(quote);
+    }
+}
+
+impl Deref for Sql {
+    type Target = str;
+
+    fn deref(&self) -> &str {
+        self.as_str()
+    }
+}
+
+impl Connection {
+    /// Query the current value of `pragma_name`.
+    ///
+    /// Some pragmas will return multiple rows/values which cannot be retrieved
+    /// with this method.
+    ///
+    /// Prefer [PRAGMA function](https://sqlite.org/pragma.html#pragfunc) introduced in SQLite 3.20:
+    /// `SELECT user_version FROM pragma_user_version;`
+    pub fn pragma_query_value<T, F>(
+        &self,
+        schema_name: Option<DatabaseName<'_>>,
+        pragma_name: &str,
+        f: F,
+    ) -> Result<T>
+    where
+        F: FnOnce(&Row<'_>) -> Result<T>,
+    {
+        let mut query = Sql::new();
+        query.push_pragma(schema_name, pragma_name)?;
+        self.query_row(&query, [], f)
+    }
+
+    /// Query the current rows/values of `pragma_name`.
+    ///
+    /// Prefer [PRAGMA function](https://sqlite.org/pragma.html#pragfunc) introduced in SQLite 3.20:
+    /// `SELECT * FROM pragma_collation_list;`
+    pub fn pragma_query<F>(
+        &self,
+        schema_name: Option<DatabaseName<'_>>,
+        pragma_name: &str,
+        mut f: F,
+    ) -> Result<()>
+    where
+        F: FnMut(&Row<'_>) -> Result<()>,
+    {
+        let mut query = Sql::new();
+        query.push_pragma(schema_name, pragma_name)?;
+        let mut stmt = self.prepare(&query)?;
+        let mut rows = stmt.query([])?;
+        while let Some(result_row) = rows.next()? {
+            let row = result_row;
+            f(row)?;
+        }
+        Ok(())
+    }
+
+    /// Query the current value(s) of `pragma_name` associated to
+    /// `pragma_value`.
+    ///
+    /// This method can be used with query-only pragmas which need an argument
+    /// (e.g. `table_info('one_tbl')`) or pragmas which returns value(s)
+    /// (e.g. `integrity_check`).
+    ///
+    /// Prefer [PRAGMA function](https://sqlite.org/pragma.html#pragfunc) introduced in SQLite 3.20:
+    /// `SELECT * FROM pragma_table_info(?1);`
+    pub fn pragma<F, V>(
+        &self,
+        schema_name: Option<DatabaseName<'_>>,
+        pragma_name: &str,
+        pragma_value: V,
+        mut f: F,
+    ) -> Result<()>
+    where
+        F: FnMut(&Row<'_>) -> Result<()>,
+        V: ToSql,
+    {
+        let mut sql = Sql::new();
+        sql.push_pragma(schema_name, pragma_name)?;
+        // The argument may be either in parentheses
+        // or it may be separated from the pragma name by an equal sign.
+        // The two syntaxes yield identical results.
+        sql.open_brace();
+        sql.push_value(&pragma_value)?;
+        sql.close_brace();
+        let mut stmt = self.prepare(&sql)?;
+        let mut rows = stmt.query([])?;
+        while let Some(result_row) = rows.next()? {
+            let row = result_row;
+            f(row)?;
+        }
+        Ok(())
+    }
+
+    /// Set a new value to `pragma_name`.
+    ///
+    /// Some pragmas will return the updated value which cannot be retrieved
+    /// with this method.
+    pub fn pragma_update<V>(
+        &self,
+        schema_name: Option<DatabaseName<'_>>,
+        pragma_name: &str,
+        pragma_value: V,
+    ) -> Result<()>
+    where
+        V: ToSql,
+    {
+        let mut sql = Sql::new();
+        sql.push_pragma(schema_name, pragma_name)?;
+        // The argument may be either in parentheses
+        // or it may be separated from the pragma name by an equal sign.
+        // The two syntaxes yield identical results.
+        sql.push_equal_sign();
+        sql.push_value(&pragma_value)?;
+        self.execute_batch(&sql)
+    }
+
+    /// Set a new value to `pragma_name` and return the updated value.
+    ///
+    /// Only few pragmas automatically return the updated value.
+    pub fn pragma_update_and_check<F, T, V>(
+        &self,
+        schema_name: Option<DatabaseName<'_>>,
+        pragma_name: &str,
+        pragma_value: V,
+        f: F,
+    ) -> Result<T>
+    where
+        F: FnOnce(&Row<'_>) -> Result<T>,
+        V: ToSql,
+    {
+        let mut sql = Sql::new();
+        sql.push_pragma(schema_name, pragma_name)?;
+        // The argument may be either in parentheses
+        // or it may be separated from the pragma name by an equal sign.
+        // The two syntaxes yield identical results.
+        sql.push_equal_sign();
+        sql.push_value(&pragma_value)?;
+        self.query_row(&sql, [], f)
+    }
+}
+
+fn is_identifier(s: &str) -> bool {
+    let chars = s.char_indices();
+    for (i, ch) in chars {
+        if i == 0 {
+            if !is_identifier_start(ch) {
+                return false;
+            }
+        } else if !is_identifier_continue(ch) {
+            return false;
+        }
+    }
+    true
+}
+
+fn is_identifier_start(c: char) -> bool {
+    c.is_ascii_uppercase() || c == '_' || c.is_ascii_lowercase() || c > '\x7F'
+}
+
+fn is_identifier_continue(c: char) -> bool {
+    c == '$'
+        || c.is_ascii_digit()
+        || c.is_ascii_uppercase()
+        || c == '_'
+        || c.is_ascii_lowercase()
+        || c > '\x7F'
+}
+
+#[cfg(test)]
+mod test {
+    use super::Sql;
+    use crate::pragma;
+    use crate::{Connection, DatabaseName, Result};
+
+    #[test]
+    fn pragma_query_value() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        let user_version: i32 = db.pragma_query_value(None, "user_version", |row| row.get(0))?;
+        assert_eq!(0, user_version);
+        Ok(())
+    }
+
+    #[test]
+    #[cfg(feature = "modern_sqlite")]
+    fn pragma_func_query_value() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        let user_version: i32 = db.one_column("SELECT user_version FROM pragma_user_version")?;
+        assert_eq!(0, user_version);
+        Ok(())
+    }
+
+    #[test]
+    fn pragma_query_no_schema() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        let mut user_version = -1;
+        db.pragma_query(None, "user_version", |row| {
+            user_version = row.get(0)?;
+            Ok(())
+        })?;
+        assert_eq!(0, user_version);
+        Ok(())
+    }
+
+    #[test]
+    fn pragma_query_with_schema() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        let mut user_version = -1;
+        db.pragma_query(Some(DatabaseName::Main), "user_version", |row| {
+            user_version = row.get(0)?;
+            Ok(())
+        })?;
+        assert_eq!(0, user_version);
+        Ok(())
+    }
+
+    #[test]
+    fn pragma() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        let mut columns = Vec::new();
+        db.pragma(None, "table_info", "sqlite_master", |row| {
+            let column: String = row.get(1)?;
+            columns.push(column);
+            Ok(())
+        })?;
+        assert_eq!(5, columns.len());
+        Ok(())
+    }
+
+    #[test]
+    #[cfg(feature = "modern_sqlite")]
+    fn pragma_func() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        let mut table_info = db.prepare("SELECT * FROM pragma_table_info(?1)")?;
+        let mut columns = Vec::new();
+        let mut rows = table_info.query(["sqlite_master"])?;
+
+        while let Some(row) = rows.next()? {
+            let row = row;
+            let column: String = row.get(1)?;
+            columns.push(column);
+        }
+        assert_eq!(5, columns.len());
+        Ok(())
+    }
+
+    #[test]
+    fn pragma_update() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        db.pragma_update(None, "user_version", 1)
+    }
+
+    #[test]
+    fn pragma_update_and_check() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        let journal_mode: String =
+            db.pragma_update_and_check(None, "journal_mode", "OFF", |row| row.get(0))?;
+        assert!(
+            journal_mode == "off" || journal_mode == "memory",
+            "mode: {:?}",
+            journal_mode,
+        );
+        // Sanity checks to ensure the move to a generic `ToSql` wasn't breaking
+        let mode =
+            db.pragma_update_and_check(None, "journal_mode", "OFF", |row| row.get::<_, String>(0))?;
+        assert!(mode == "off" || mode == "memory", "mode: {:?}", mode);
+
+        let param: &dyn crate::ToSql = &"OFF";
+        let mode =
+            db.pragma_update_and_check(None, "journal_mode", param, |row| row.get::<_, String>(0))?;
+        assert!(mode == "off" || mode == "memory", "mode: {:?}", mode);
+        Ok(())
+    }
+
+    #[test]
+    fn is_identifier() {
+        assert!(pragma::is_identifier("full"));
+        assert!(pragma::is_identifier("r2d2"));
+        assert!(!pragma::is_identifier("sp ce"));
+        assert!(!pragma::is_identifier("semi;colon"));
+    }
+
+    #[test]
+    fn double_quote() {
+        let mut sql = Sql::new();
+        sql.push_schema_name(DatabaseName::Attached(r#"schema";--"#));
+        assert_eq!(r#""schema"";--""#, sql.as_str());
+    }
+
+    #[test]
+    fn wrap_and_escape() {
+        let mut sql = Sql::new();
+        sql.push_string_literal("value'; --");
+        assert_eq!("'value''; --'", sql.as_str());
+    }
+
+    #[test]
+    fn locking_mode() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        let r = db.pragma_update(None, "locking_mode", "exclusive");
+        if cfg!(feature = "extra_check") {
+            r.unwrap_err();
+        } else {
+            r?;
+        }
+        Ok(())
+    }
+}
diff --git a/crates/rusqlite/src/raw_statement.rs b/crates/rusqlite/src/raw_statement.rs
new file mode 100644
index 0000000..1683c7b
--- /dev/null
+++ b/crates/rusqlite/src/raw_statement.rs
@@ -0,0 +1,240 @@
+use super::ffi;
+use super::StatementStatus;
+use crate::util::ParamIndexCache;
+use crate::util::SqliteMallocString;
+use std::ffi::CStr;
+use std::os::raw::c_int;
+use std::ptr;
+use std::sync::Arc;
+
+// Private newtype for raw sqlite3_stmts that finalize themselves when dropped.
+#[derive(Debug)]
+pub struct RawStatement {
+    ptr: *mut ffi::sqlite3_stmt,
+    tail: usize,
+    // Cached indices of named parameters, computed on the fly.
+    cache: ParamIndexCache,
+    // Cached SQL (trimmed) that we use as the key when we're in the statement
+    // cache. This is None for statements which didn't come from the statement
+    // cache.
+    //
+    // This is probably the same as `self.sql()` in most cases, but we don't
+    // care either way -- It's a better cache key as it is anyway since it's the
+    // actual source we got from rust.
+    //
+    // One example of a case where the result of `sqlite_sql` and the value in
+    // `statement_cache_key` might differ is if the statement has a `tail`.
+    statement_cache_key: Option<Arc<str>>,
+}
+
+impl RawStatement {
+    #[inline]
+    pub unsafe fn new(stmt: *mut ffi::sqlite3_stmt, tail: usize) -> RawStatement {
+        RawStatement {
+            ptr: stmt,
+            tail,
+            cache: ParamIndexCache::default(),
+            statement_cache_key: None,
+        }
+    }
+
+    #[inline]
+    pub fn is_null(&self) -> bool {
+        self.ptr.is_null()
+    }
+
+    #[inline]
+    pub(crate) fn set_statement_cache_key(&mut self, p: impl Into<Arc<str>>) {
+        self.statement_cache_key = Some(p.into());
+    }
+
+    #[inline]
+    pub(crate) fn statement_cache_key(&self) -> Option<Arc<str>> {
+        self.statement_cache_key.clone()
+    }
+
+    #[inline]
+    pub unsafe fn ptr(&self) -> *mut ffi::sqlite3_stmt {
+        self.ptr
+    }
+
+    #[inline]
+    pub fn column_count(&self) -> usize {
+        // Note: Can't cache this as it changes if the schema is altered.
+        unsafe { ffi::sqlite3_column_count(self.ptr) as usize }
+    }
+
+    #[inline]
+    pub fn column_type(&self, idx: usize) -> c_int {
+        unsafe { ffi::sqlite3_column_type(self.ptr, idx as c_int) }
+    }
+
+    #[inline]
+    #[cfg(feature = "column_decltype")]
+    pub fn column_decltype(&self, idx: usize) -> Option<&CStr> {
+        unsafe {
+            let decltype = ffi::sqlite3_column_decltype(self.ptr, idx as c_int);
+            if decltype.is_null() {
+                None
+            } else {
+                Some(CStr::from_ptr(decltype))
+            }
+        }
+    }
+
+    #[inline]
+    pub fn column_name(&self, idx: usize) -> Option<&CStr> {
+        let idx = idx as c_int;
+        if idx < 0 || idx >= self.column_count() as c_int {
+            return None;
+        }
+        unsafe {
+            let ptr = ffi::sqlite3_column_name(self.ptr, idx);
+            // If ptr is null here, it's an OOM, so there's probably nothing
+            // meaningful we can do. Just assert instead of returning None.
+            assert!(
+                !ptr.is_null(),
+                "Null pointer from sqlite3_column_name: Out of memory?"
+            );
+            Some(CStr::from_ptr(ptr))
+        }
+    }
+
+    #[inline]
+    #[cfg(not(feature = "unlock_notify"))]
+    pub fn step(&self) -> c_int {
+        unsafe { ffi::sqlite3_step(self.ptr) }
+    }
+
+    #[cfg(feature = "unlock_notify")]
+    pub fn step(&self) -> c_int {
+        use crate::unlock_notify;
+        let mut db = ptr::null_mut::<ffi::sqlite3>();
+        loop {
+            unsafe {
+                let mut rc = ffi::sqlite3_step(self.ptr);
+                // Bail out early for success and errors unrelated to locking. We
+                // still need check `is_locked` after this, but checking now lets us
+                // avoid one or two (admittedly cheap) calls into SQLite that we
+                // don't need to make.
+                if (rc & 0xff) != ffi::SQLITE_LOCKED {
+                    break rc;
+                }
+                if db.is_null() {
+                    db = ffi::sqlite3_db_handle(self.ptr);
+                }
+                if !unlock_notify::is_locked(db, rc) {
+                    break rc;
+                }
+                rc = unlock_notify::wait_for_unlock_notify(db);
+                if rc != ffi::SQLITE_OK {
+                    break rc;
+                }
+                self.reset();
+            }
+        }
+    }
+
+    #[inline]
+    pub fn reset(&self) -> c_int {
+        unsafe { ffi::sqlite3_reset(self.ptr) }
+    }
+
+    #[inline]
+    pub fn bind_parameter_count(&self) -> usize {
+        unsafe { ffi::sqlite3_bind_parameter_count(self.ptr) as usize }
+    }
+
+    #[inline]
+    pub fn bind_parameter_index(&self, name: &str) -> Option<usize> {
+        self.cache.get_or_insert_with(name, |param_cstr| {
+            let r = unsafe { ffi::sqlite3_bind_parameter_index(self.ptr, param_cstr.as_ptr()) };
+            match r {
+                0 => None,
+                i => Some(i as usize),
+            }
+        })
+    }
+
+    #[inline]
+    pub fn bind_parameter_name(&self, index: i32) -> Option<&CStr> {
+        unsafe {
+            let name = ffi::sqlite3_bind_parameter_name(self.ptr, index);
+            if name.is_null() {
+                None
+            } else {
+                Some(CStr::from_ptr(name))
+            }
+        }
+    }
+
+    #[inline]
+    pub fn clear_bindings(&self) {
+        unsafe {
+            ffi::sqlite3_clear_bindings(self.ptr);
+        } // rc is always SQLITE_OK
+    }
+
+    #[inline]
+    pub fn sql(&self) -> Option<&CStr> {
+        if self.ptr.is_null() {
+            None
+        } else {
+            Some(unsafe { CStr::from_ptr(ffi::sqlite3_sql(self.ptr)) })
+        }
+    }
+
+    #[inline]
+    pub fn finalize(mut self) -> c_int {
+        self.finalize_()
+    }
+
+    #[inline]
+    fn finalize_(&mut self) -> c_int {
+        let r = unsafe { ffi::sqlite3_finalize(self.ptr) };
+        self.ptr = ptr::null_mut();
+        r
+    }
+
+    // does not work for PRAGMA
+    #[inline]
+    pub fn readonly(&self) -> bool {
+        unsafe { ffi::sqlite3_stmt_readonly(self.ptr) != 0 }
+    }
+
+    #[inline]
+    pub(crate) fn expanded_sql(&self) -> Option<SqliteMallocString> {
+        unsafe { SqliteMallocString::from_raw(ffi::sqlite3_expanded_sql(self.ptr)) }
+    }
+
+    #[inline]
+    pub fn get_status(&self, status: StatementStatus, reset: bool) -> i32 {
+        assert!(!self.ptr.is_null());
+        unsafe { ffi::sqlite3_stmt_status(self.ptr, status as i32, reset as i32) }
+    }
+
+    #[inline]
+    #[cfg(feature = "extra_check")]
+    pub fn has_tail(&self) -> bool {
+        self.tail != 0
+    }
+
+    #[inline]
+    pub fn tail(&self) -> usize {
+        self.tail
+    }
+
+    #[inline]
+    #[cfg(feature = "modern_sqlite")] // 3.28.0
+    pub fn is_explain(&self) -> i32 {
+        unsafe { ffi::sqlite3_stmt_isexplain(self.ptr) }
+    }
+
+    // TODO sqlite3_normalized_sql (https://sqlite.org/c3ref/expanded_sql.html) // 3.27.0 + SQLITE_ENABLE_NORMALIZE
+}
+
+impl Drop for RawStatement {
+    fn drop(&mut self) {
+        self.finalize_();
+    }
+}
diff --git a/crates/rusqlite/src/row.rs b/crates/rusqlite/src/row.rs
new file mode 100644
index 0000000..93cf824
--- /dev/null
+++ b/crates/rusqlite/src/row.rs
@@ -0,0 +1,585 @@
+use fallible_iterator::FallibleIterator;
+use fallible_streaming_iterator::FallibleStreamingIterator;
+use std::convert;
+
+use super::{Error, Result, Statement};
+use crate::types::{FromSql, FromSqlError, ValueRef};
+
+/// An handle for the resulting rows of a query.
+#[must_use = "Rows is lazy and will do nothing unless consumed"]
+pub struct Rows<'stmt> {
+    pub(crate) stmt: Option<&'stmt Statement<'stmt>>,
+    row: Option<Row<'stmt>>,
+}
+
+impl<'stmt> Rows<'stmt> {
+    #[inline]
+    fn reset(&mut self) {
+        if let Some(stmt) = self.stmt.take() {
+            stmt.reset();
+        }
+    }
+
+    /// Attempt to get the next row from the query. Returns `Ok(Some(Row))` if
+    /// there is another row, `Err(...)` if there was an error
+    /// getting the next row, and `Ok(None)` if all rows have been retrieved.
+    ///
+    /// ## Note
+    ///
+    /// This interface is not compatible with Rust's `Iterator` trait, because
+    /// the lifetime of the returned row is tied to the lifetime of `self`.
+    /// This is a fallible "streaming iterator". For a more natural interface,
+    /// consider using [`query_map`](crate::Statement::query_map) or
+    /// [`query_and_then`](crate::Statement::query_and_then) instead, which
+    /// return types that implement `Iterator`.
+    #[allow(clippy::should_implement_trait)] // cannot implement Iterator
+    #[inline]
+    pub fn next(&mut self) -> Result<Option<&Row<'stmt>>> {
+        self.advance()?;
+        Ok((*self).get())
+    }
+
+    /// Map over this `Rows`, converting it to a [`Map`], which
+    /// implements `FallibleIterator`.
+    /// ```rust,no_run
+    /// use fallible_iterator::FallibleIterator;
+    /// # use rusqlite::{Result, Statement};
+    /// fn query(stmt: &mut Statement) -> Result<Vec<i64>> {
+    ///     let rows = stmt.query([])?;
+    ///     rows.map(|r| r.get(0)).collect()
+    /// }
+    /// ```
+    // FIXME Hide FallibleStreamingIterator::map
+    #[inline]
+    pub fn map<F, B>(self, f: F) -> Map<'stmt, F>
+    where
+        F: FnMut(&Row<'_>) -> Result<B>,
+    {
+        Map { rows: self, f }
+    }
+
+    /// Map over this `Rows`, converting it to a [`MappedRows`], which
+    /// implements `Iterator`.
+    #[inline]
+    pub fn mapped<F, B>(self, f: F) -> MappedRows<'stmt, F>
+    where
+        F: FnMut(&Row<'_>) -> Result<B>,
+    {
+        MappedRows { rows: self, map: f }
+    }
+
+    /// Map over this `Rows` with a fallible function, converting it to a
+    /// [`AndThenRows`], which implements `Iterator` (instead of
+    /// `FallibleStreamingIterator`).
+    #[inline]
+    pub fn and_then<F, T, E>(self, f: F) -> AndThenRows<'stmt, F>
+    where
+        F: FnMut(&Row<'_>) -> Result<T, E>,
+    {
+        AndThenRows { rows: self, map: f }
+    }
+
+    /// Give access to the underlying statement
+    #[must_use]
+    pub fn as_ref(&self) -> Option<&Statement<'stmt>> {
+        self.stmt
+    }
+}
+
+impl<'stmt> Rows<'stmt> {
+    #[inline]
+    pub(crate) fn new(stmt: &'stmt Statement<'stmt>) -> Rows<'stmt> {
+        Rows {
+            stmt: Some(stmt),
+            row: None,
+        }
+    }
+
+    #[inline]
+    pub(crate) fn get_expected_row(&mut self) -> Result<&Row<'stmt>> {
+        match self.next()? {
+            Some(row) => Ok(row),
+            None => Err(Error::QueryReturnedNoRows),
+        }
+    }
+}
+
+impl Drop for Rows<'_> {
+    #[inline]
+    fn drop(&mut self) {
+        self.reset();
+    }
+}
+
+/// `F` is used to transform the _streaming_ iterator into a _fallible_
+/// iterator.
+#[must_use = "iterators are lazy and do nothing unless consumed"]
+pub struct Map<'stmt, F> {
+    rows: Rows<'stmt>,
+    f: F,
+}
+
+impl<F, B> FallibleIterator for Map<'_, F>
+where
+    F: FnMut(&Row<'_>) -> Result<B>,
+{
+    type Error = Error;
+    type Item = B;
+
+    #[inline]
+    fn next(&mut self) -> Result<Option<B>> {
+        match self.rows.next()? {
+            Some(v) => Ok(Some((self.f)(v)?)),
+            None => Ok(None),
+        }
+    }
+}
+
+/// An iterator over the mapped resulting rows of a query.
+///
+/// `F` is used to transform the _streaming_ iterator into a _standard_
+/// iterator.
+#[must_use = "iterators are lazy and do nothing unless consumed"]
+pub struct MappedRows<'stmt, F> {
+    rows: Rows<'stmt>,
+    map: F,
+}
+
+impl<T, F> Iterator for MappedRows<'_, F>
+where
+    F: FnMut(&Row<'_>) -> Result<T>,
+{
+    type Item = Result<T>;
+
+    #[inline]
+    fn next(&mut self) -> Option<Result<T>> {
+        let map = &mut self.map;
+        self.rows
+            .next()
+            .transpose()
+            .map(|row_result| row_result.and_then(map))
+    }
+}
+
+/// An iterator over the mapped resulting rows of a query, with an Error type
+/// unifying with Error.
+#[must_use = "iterators are lazy and do nothing unless consumed"]
+pub struct AndThenRows<'stmt, F> {
+    rows: Rows<'stmt>,
+    map: F,
+}
+
+impl<T, E, F> Iterator for AndThenRows<'_, F>
+where
+    E: From<Error>,
+    F: FnMut(&Row<'_>) -> Result<T, E>,
+{
+    type Item = Result<T, E>;
+
+    #[inline]
+    fn next(&mut self) -> Option<Self::Item> {
+        let map = &mut self.map;
+        self.rows
+            .next()
+            .transpose()
+            .map(|row_result| row_result.map_err(E::from).and_then(map))
+    }
+}
+
+/// `FallibleStreamingIterator` differs from the standard library's `Iterator`
+/// in two ways:
+/// * each call to `next` (`sqlite3_step`) can fail.
+/// * returned `Row` is valid until `next` is called again or `Statement` is
+///   reset or finalized.
+///
+/// While these iterators cannot be used with Rust `for` loops, `while let`
+/// loops offer a similar level of ergonomics:
+/// ```rust,no_run
+/// # use rusqlite::{Result, Statement};
+/// fn query(stmt: &mut Statement) -> Result<()> {
+///     let mut rows = stmt.query([])?;
+///     while let Some(row) = rows.next()? {
+///         // scan columns value
+///     }
+///     Ok(())
+/// }
+/// ```
+impl<'stmt> FallibleStreamingIterator for Rows<'stmt> {
+    type Error = Error;
+    type Item = Row<'stmt>;
+
+    #[inline]
+    fn advance(&mut self) -> Result<()> {
+        if let Some(stmt) = self.stmt {
+            match stmt.step() {
+                Ok(true) => {
+                    self.row = Some(Row { stmt });
+                    Ok(())
+                }
+                Ok(false) => {
+                    self.reset();
+                    self.row = None;
+                    Ok(())
+                }
+                Err(e) => {
+                    self.reset();
+                    self.row = None;
+                    Err(e)
+                }
+            }
+        } else {
+            self.row = None;
+            Ok(())
+        }
+    }
+
+    #[inline]
+    fn get(&self) -> Option<&Row<'stmt>> {
+        self.row.as_ref()
+    }
+}
+
+/// A single result row of a query.
+pub struct Row<'stmt> {
+    pub(crate) stmt: &'stmt Statement<'stmt>,
+}
+
+impl<'stmt> Row<'stmt> {
+    /// Get the value of a particular column of the result row.
+    ///
+    /// ## Failure
+    ///
+    /// Panics if calling [`row.get(idx)`](Row::get) would return an error,
+    /// including:
+    ///
+    /// * If the underlying SQLite column type is not a valid type as a source
+    ///   for `T`
+    /// * If the underlying SQLite integral value is outside the range
+    ///   representable by `T`
+    /// * If `idx` is outside the range of columns in the returned query
+    pub fn get_unwrap<I: RowIndex, T: FromSql>(&self, idx: I) -> T {
+        self.get(idx).unwrap()
+    }
+
+    /// Get the value of a particular column of the result row.
+    ///
+    /// ## Failure
+    ///
+    /// Returns an `Error::InvalidColumnType` if the underlying SQLite column
+    /// type is not a valid type as a source for `T`.
+    ///
+    /// Returns an `Error::InvalidColumnIndex` if `idx` is outside the valid
+    /// column range for this row.
+    ///
+    /// Returns an `Error::InvalidColumnName` if `idx` is not a valid column
+    /// name for this row.
+    ///
+    /// If the result type is i128 (which requires the `i128_blob` feature to be
+    /// enabled), and the underlying SQLite column is a blob whose size is not
+    /// 16 bytes, `Error::InvalidColumnType` will also be returned.
+    pub fn get<I: RowIndex, T: FromSql>(&self, idx: I) -> Result<T> {
+        let idx = idx.idx(self.stmt)?;
+        let value = self.stmt.value_ref(idx);
+        FromSql::column_result(value).map_err(|err| match err {
+            FromSqlError::InvalidType => Error::InvalidColumnType(
+                idx,
+                self.stmt.column_name_unwrap(idx).into(),
+                value.data_type(),
+            ),
+            FromSqlError::OutOfRange(i) => Error::IntegralValueOutOfRange(idx, i),
+            FromSqlError::Other(err) => {
+                Error::FromSqlConversionFailure(idx, value.data_type(), err)
+            }
+            FromSqlError::InvalidBlobSize { .. } => {
+                Error::FromSqlConversionFailure(idx, value.data_type(), Box::new(err))
+            }
+        })
+    }
+
+    /// Get the value of a particular column of the result row as a `ValueRef`,
+    /// allowing data to be read out of a row without copying.
+    ///
+    /// This `ValueRef` is valid only as long as this Row, which is enforced by
+    /// it's lifetime. This means that while this method is completely safe,
+    /// it can be somewhat difficult to use, and most callers will be better
+    /// served by [`get`](Row::get) or [`get_unwrap`](Row::get_unwrap).
+    ///
+    /// ## Failure
+    ///
+    /// Returns an `Error::InvalidColumnIndex` if `idx` is outside the valid
+    /// column range for this row.
+    ///
+    /// Returns an `Error::InvalidColumnName` if `idx` is not a valid column
+    /// name for this row.
+    pub fn get_ref<I: RowIndex>(&self, idx: I) -> Result<ValueRef<'_>> {
+        let idx = idx.idx(self.stmt)?;
+        // Narrowing from `ValueRef<'stmt>` (which `self.stmt.value_ref(idx)`
+        // returns) to `ValueRef<'a>` is needed because it's only valid until
+        // the next call to sqlite3_step.
+        let val_ref = self.stmt.value_ref(idx);
+        Ok(val_ref)
+    }
+
+    /// Get the value of a particular column of the result row as a `ValueRef`,
+    /// allowing data to be read out of a row without copying.
+    ///
+    /// This `ValueRef` is valid only as long as this Row, which is enforced by
+    /// it's lifetime. This means that while this method is completely safe,
+    /// it can be difficult to use, and most callers will be better served by
+    /// [`get`](Row::get) or [`get_unwrap`](Row::get_unwrap).
+    ///
+    /// ## Failure
+    ///
+    /// Panics if calling [`row.get_ref(idx)`](Row::get_ref) would return an
+    /// error, including:
+    ///
+    /// * If `idx` is outside the range of columns in the returned query.
+    /// * If `idx` is not a valid column name for this row.
+    pub fn get_ref_unwrap<I: RowIndex>(&self, idx: I) -> ValueRef<'_> {
+        self.get_ref(idx).unwrap()
+    }
+}
+
+impl<'stmt> AsRef<Statement<'stmt>> for Row<'stmt> {
+    fn as_ref(&self) -> &Statement<'stmt> {
+        self.stmt
+    }
+}
+
+/// Debug `Row` like an ordered `Map<Result<&str>, Result<(Type, ValueRef)>>`
+/// with column name as key except that for `Type::Blob` only its size is
+/// printed (not its content).
+impl<'stmt> std::fmt::Debug for Row<'stmt> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let mut dm = f.debug_map();
+        for c in 0..self.stmt.column_count() {
+            let name = self.stmt.column_name(c);
+            dm.key(&name);
+            let value = self.get_ref(c);
+            match value {
+                Ok(value) => {
+                    let dt = value.data_type();
+                    match value {
+                        ValueRef::Null => {
+                            dm.value(&(dt, ()));
+                        }
+                        ValueRef::Integer(i) => {
+                            dm.value(&(dt, i));
+                        }
+                        ValueRef::Real(f) => {
+                            dm.value(&(dt, f));
+                        }
+                        ValueRef::Text(s) => {
+                            dm.value(&(dt, String::from_utf8_lossy(s)));
+                        }
+                        ValueRef::Blob(b) => {
+                            dm.value(&(dt, b.len()));
+                        }
+                    }
+                }
+                Err(ref _err) => {
+                    dm.value(&value);
+                }
+            }
+        }
+        dm.finish()
+    }
+}
+
+mod sealed {
+    /// This trait exists just to ensure that the only impls of `trait Params`
+    /// that are allowed are ones in this crate.
+    pub trait Sealed {}
+    impl Sealed for usize {}
+    impl Sealed for &str {}
+}
+
+/// A trait implemented by types that can index into columns of a row.
+///
+/// It is only implemented for `usize` and `&str`.
+pub trait RowIndex: sealed::Sealed {
+    /// Returns the index of the appropriate column, or `None` if no such
+    /// column exists.
+    fn idx(&self, stmt: &Statement<'_>) -> Result<usize>;
+}
+
+impl RowIndex for usize {
+    #[inline]
+    fn idx(&self, stmt: &Statement<'_>) -> Result<usize> {
+        if *self >= stmt.column_count() {
+            Err(Error::InvalidColumnIndex(*self))
+        } else {
+            Ok(*self)
+        }
+    }
+}
+
+impl RowIndex for &'_ str {
+    #[inline]
+    fn idx(&self, stmt: &Statement<'_>) -> Result<usize> {
+        stmt.column_index(self)
+    }
+}
+
+macro_rules! tuple_try_from_row {
+    ($($field:ident),*) => {
+        impl<'a, $($field,)*> convert::TryFrom<&'a Row<'a>> for ($($field,)*) where $($field: FromSql,)* {
+            type Error = crate::Error;
+
+            // we end with index += 1, which rustc warns about
+            // unused_variables and unused_mut are allowed for ()
+            #[allow(unused_assignments, unused_variables, unused_mut)]
+            fn try_from(row: &'a Row<'a>) -> Result<Self> {
+                let mut index = 0;
+                $(
+                    #[allow(non_snake_case)]
+                    let $field = row.get::<_, $field>(index)?;
+                    index += 1;
+                )*
+                Ok(($($field,)*))
+            }
+        }
+    }
+}
+
+macro_rules! tuples_try_from_row {
+    () => {
+        // not very useful, but maybe some other macro users will find this helpful
+        tuple_try_from_row!();
+    };
+    ($first:ident $(, $remaining:ident)*) => {
+        tuple_try_from_row!($first $(, $remaining)*);
+        tuples_try_from_row!($($remaining),*);
+    };
+}
+
+tuples_try_from_row!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P);
+
+#[cfg(test)]
+mod tests {
+    #![allow(clippy::redundant_closure)] // false positives due to lifetime issues; clippy issue #5594
+    use crate::{Connection, Result};
+
+    #[test]
+    fn test_try_from_row_for_tuple_1() -> Result<()> {
+        use crate::ToSql;
+        use std::convert::TryFrom;
+
+        let conn = Connection::open_in_memory()?;
+        conn.execute(
+            "CREATE TABLE test (a INTEGER)",
+            crate::params_from_iter(std::iter::empty::<&dyn ToSql>()),
+        )?;
+        conn.execute("INSERT INTO test VALUES (42)", [])?;
+        let val = conn.query_row("SELECT a FROM test", [], |row| <(u32,)>::try_from(row))?;
+        assert_eq!(val, (42,));
+        let fail = conn.query_row("SELECT a FROM test", [], |row| <(u32, u32)>::try_from(row));
+        fail.unwrap_err();
+        Ok(())
+    }
+
+    #[test]
+    fn test_try_from_row_for_tuple_2() -> Result<()> {
+        use std::convert::TryFrom;
+
+        let conn = Connection::open_in_memory()?;
+        conn.execute("CREATE TABLE test (a INTEGER, b INTEGER)", [])?;
+        conn.execute("INSERT INTO test VALUES (42, 47)", [])?;
+        let val = conn.query_row("SELECT a, b FROM test", [], |row| {
+            <(u32, u32)>::try_from(row)
+        })?;
+        assert_eq!(val, (42, 47));
+        let fail = conn.query_row("SELECT a, b FROM test", [], |row| {
+            <(u32, u32, u32)>::try_from(row)
+        });
+        fail.unwrap_err();
+        Ok(())
+    }
+
+    #[test]
+    fn test_try_from_row_for_tuple_16() -> Result<()> {
+        use std::convert::TryFrom;
+
+        let create_table = "CREATE TABLE test (
+            a INTEGER,
+            b INTEGER,
+            c INTEGER,
+            d INTEGER,
+            e INTEGER,
+            f INTEGER,
+            g INTEGER,
+            h INTEGER,
+            i INTEGER,
+            j INTEGER,
+            k INTEGER,
+            l INTEGER,
+            m INTEGER,
+            n INTEGER,
+            o INTEGER,
+            p INTEGER
+        )";
+
+        let insert_values = "INSERT INTO test VALUES (
+            0,
+            1,
+            2,
+            3,
+            4,
+            5,
+            6,
+            7,
+            8,
+            9,
+            10,
+            11,
+            12,
+            13,
+            14,
+            15
+        )";
+
+        type BigTuple = (
+            u32,
+            u32,
+            u32,
+            u32,
+            u32,
+            u32,
+            u32,
+            u32,
+            u32,
+            u32,
+            u32,
+            u32,
+            u32,
+            u32,
+            u32,
+            u32,
+        );
+
+        let conn = Connection::open_in_memory()?;
+        conn.execute(create_table, [])?;
+        conn.execute(insert_values, [])?;
+        let val = conn.query_row("SELECT * FROM test", [], |row| BigTuple::try_from(row))?;
+        // Debug is not implemented for tuples of 16
+        assert_eq!(val.0, 0);
+        assert_eq!(val.1, 1);
+        assert_eq!(val.2, 2);
+        assert_eq!(val.3, 3);
+        assert_eq!(val.4, 4);
+        assert_eq!(val.5, 5);
+        assert_eq!(val.6, 6);
+        assert_eq!(val.7, 7);
+        assert_eq!(val.8, 8);
+        assert_eq!(val.9, 9);
+        assert_eq!(val.10, 10);
+        assert_eq!(val.11, 11);
+        assert_eq!(val.12, 12);
+        assert_eq!(val.13, 13);
+        assert_eq!(val.14, 14);
+        assert_eq!(val.15, 15);
+
+        // We don't test one bigger because it's unimplemented
+        Ok(())
+    }
+}
diff --git a/crates/rusqlite/src/session.rs b/crates/rusqlite/src/session.rs
new file mode 100644
index 0000000..c42bbd6
--- /dev/null
+++ b/crates/rusqlite/src/session.rs
@@ -0,0 +1,933 @@
+//! [Session Extension](https://sqlite.org/sessionintro.html)
+#![allow(non_camel_case_types)]
+
+use std::ffi::CStr;
+use std::io::{Read, Write};
+use std::marker::PhantomData;
+use std::os::raw::{c_char, c_int, c_uchar, c_void};
+use std::panic::{catch_unwind, RefUnwindSafe};
+use std::ptr;
+use std::slice::{from_raw_parts, from_raw_parts_mut};
+
+use fallible_streaming_iterator::FallibleStreamingIterator;
+
+use crate::error::{check, error_from_sqlite_code};
+use crate::ffi;
+use crate::hooks::Action;
+use crate::types::ValueRef;
+use crate::{errmsg_to_string, str_to_cstring, Connection, DatabaseName, Result};
+
+// https://sqlite.org/session.html
+
+type Filter = Option<Box<dyn Fn(&str) -> bool>>;
+
+/// An instance of this object is a session that can be
+/// used to record changes to a database.
+pub struct Session<'conn> {
+    phantom: PhantomData<&'conn Connection>,
+    s: *mut ffi::sqlite3_session,
+    filter: Filter,
+}
+
+impl Session<'_> {
+    /// Create a new session object
+    #[inline]
+    pub fn new(db: &Connection) -> Result<Session<'_>> {
+        Session::new_with_name(db, DatabaseName::Main)
+    }
+
+    /// Create a new session object
+    #[inline]
+    pub fn new_with_name<'conn>(
+        db: &'conn Connection,
+        name: DatabaseName<'_>,
+    ) -> Result<Session<'conn>> {
+        let name = name.as_cstring()?;
+
+        let db = db.db.borrow_mut().db;
+
+        let mut s: *mut ffi::sqlite3_session = ptr::null_mut();
+        check(unsafe { ffi::sqlite3session_create(db, name.as_ptr(), &mut s) })?;
+
+        Ok(Session {
+            phantom: PhantomData,
+            s,
+            filter: None,
+        })
+    }
+
+    /// Set a table filter
+    pub fn table_filter<F>(&mut self, filter: Option<F>)
+    where
+        F: Fn(&str) -> bool + Send + RefUnwindSafe + 'static,
+    {
+        unsafe extern "C" fn call_boxed_closure<F>(
+            p_arg: *mut c_void,
+            tbl_str: *const c_char,
+        ) -> c_int
+        where
+            F: Fn(&str) -> bool + RefUnwindSafe,
+        {
+            use std::str;
+
+            let boxed_filter: *mut F = p_arg as *mut F;
+            let tbl_name = {
+                let c_slice = CStr::from_ptr(tbl_str).to_bytes();
+                str::from_utf8(c_slice)
+            };
+            c_int::from(
+                catch_unwind(|| (*boxed_filter)(tbl_name.expect("non-utf8 table name")))
+                    .unwrap_or_default(),
+            )
+        }
+
+        match filter {
+            Some(filter) => {
+                let boxed_filter = Box::new(filter);
+                unsafe {
+                    ffi::sqlite3session_table_filter(
+                        self.s,
+                        Some(call_boxed_closure::<F>),
+                        &*boxed_filter as *const F as *mut _,
+                    );
+                }
+                self.filter = Some(boxed_filter);
+            }
+            _ => {
+                unsafe { ffi::sqlite3session_table_filter(self.s, None, ptr::null_mut()) }
+                self.filter = None;
+            }
+        };
+    }
+
+    /// Attach a table. `None` means all tables.
+    pub fn attach(&mut self, table: Option<&str>) -> Result<()> {
+        let table = if let Some(table) = table {
+            Some(str_to_cstring(table)?)
+        } else {
+            None
+        };
+        let table = table.as_ref().map(|s| s.as_ptr()).unwrap_or(ptr::null());
+        check(unsafe { ffi::sqlite3session_attach(self.s, table) })
+    }
+
+    /// Generate a Changeset
+    pub fn changeset(&mut self) -> Result<Changeset> {
+        let mut n = 0;
+        let mut cs: *mut c_void = ptr::null_mut();
+        check(unsafe { ffi::sqlite3session_changeset(self.s, &mut n, &mut cs) })?;
+        Ok(Changeset { cs, n })
+    }
+
+    /// Write the set of changes represented by this session to `output`.
+    #[inline]
+    pub fn changeset_strm(&mut self, output: &mut dyn Write) -> Result<()> {
+        let output_ref = &output;
+        check(unsafe {
+            ffi::sqlite3session_changeset_strm(
+                self.s,
+                Some(x_output),
+                output_ref as *const &mut dyn Write as *mut c_void,
+            )
+        })
+    }
+
+    /// Generate a Patchset
+    #[inline]
+    pub fn patchset(&mut self) -> Result<Changeset> {
+        let mut n = 0;
+        let mut ps: *mut c_void = ptr::null_mut();
+        check(unsafe { ffi::sqlite3session_patchset(self.s, &mut n, &mut ps) })?;
+        // TODO Validate: same struct
+        Ok(Changeset { cs: ps, n })
+    }
+
+    /// Write the set of patches represented by this session to `output`.
+    #[inline]
+    pub fn patchset_strm(&mut self, output: &mut dyn Write) -> Result<()> {
+        let output_ref = &output;
+        check(unsafe {
+            ffi::sqlite3session_patchset_strm(
+                self.s,
+                Some(x_output),
+                output_ref as *const &mut dyn Write as *mut c_void,
+            )
+        })
+    }
+
+    /// Load the difference between tables.
+    pub fn diff(&mut self, from: DatabaseName<'_>, table: &str) -> Result<()> {
+        let from = from.as_cstring()?;
+        let table = str_to_cstring(table)?;
+        let table = table.as_ptr();
+        unsafe {
+            let mut errmsg = ptr::null_mut();
+            let r =
+                ffi::sqlite3session_diff(self.s, from.as_ptr(), table, &mut errmsg as *mut *mut _);
+            if r != ffi::SQLITE_OK {
+                let errmsg: *mut c_char = errmsg;
+                let message = errmsg_to_string(&*errmsg);
+                ffi::sqlite3_free(errmsg as *mut c_void);
+                return Err(error_from_sqlite_code(r, Some(message)));
+            }
+        }
+        Ok(())
+    }
+
+    /// Test if a changeset has recorded any changes
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        unsafe { ffi::sqlite3session_isempty(self.s) != 0 }
+    }
+
+    /// Query the current state of the session
+    #[inline]
+    pub fn is_enabled(&self) -> bool {
+        unsafe { ffi::sqlite3session_enable(self.s, -1) != 0 }
+    }
+
+    /// Enable or disable the recording of changes
+    #[inline]
+    pub fn set_enabled(&mut self, enabled: bool) {
+        unsafe {
+            ffi::sqlite3session_enable(self.s, c_int::from(enabled));
+        }
+    }
+
+    /// Query the current state of the indirect flag
+    #[inline]
+    pub fn is_indirect(&self) -> bool {
+        unsafe { ffi::sqlite3session_indirect(self.s, -1) != 0 }
+    }
+
+    /// Set or clear the indirect change flag
+    #[inline]
+    pub fn set_indirect(&mut self, indirect: bool) {
+        unsafe {
+            ffi::sqlite3session_indirect(self.s, c_int::from(indirect));
+        }
+    }
+}
+
+impl Drop for Session<'_> {
+    #[inline]
+    fn drop(&mut self) {
+        if self.filter.is_some() {
+            self.table_filter(None::<fn(&str) -> bool>);
+        }
+        unsafe { ffi::sqlite3session_delete(self.s) };
+    }
+}
+
+/// Invert a changeset
+#[inline]
+pub fn invert_strm(input: &mut dyn Read, output: &mut dyn Write) -> Result<()> {
+    let input_ref = &input;
+    let output_ref = &output;
+    check(unsafe {
+        ffi::sqlite3changeset_invert_strm(
+            Some(x_input),
+            input_ref as *const &mut dyn Read as *mut c_void,
+            Some(x_output),
+            output_ref as *const &mut dyn Write as *mut c_void,
+        )
+    })
+}
+
+/// Combine two changesets
+#[inline]
+pub fn concat_strm(
+    input_a: &mut dyn Read,
+    input_b: &mut dyn Read,
+    output: &mut dyn Write,
+) -> Result<()> {
+    let input_a_ref = &input_a;
+    let input_b_ref = &input_b;
+    let output_ref = &output;
+    check(unsafe {
+        ffi::sqlite3changeset_concat_strm(
+            Some(x_input),
+            input_a_ref as *const &mut dyn Read as *mut c_void,
+            Some(x_input),
+            input_b_ref as *const &mut dyn Read as *mut c_void,
+            Some(x_output),
+            output_ref as *const &mut dyn Write as *mut c_void,
+        )
+    })
+}
+
+/// Changeset or Patchset
+pub struct Changeset {
+    cs: *mut c_void,
+    n: c_int,
+}
+
+impl Changeset {
+    /// Invert a changeset
+    #[inline]
+    pub fn invert(&self) -> Result<Changeset> {
+        let mut n = 0;
+        let mut cs = ptr::null_mut();
+        check(unsafe {
+            ffi::sqlite3changeset_invert(self.n, self.cs, &mut n, &mut cs as *mut *mut _)
+        })?;
+        Ok(Changeset { cs, n })
+    }
+
+    /// Create an iterator to traverse a changeset
+    #[inline]
+    pub fn iter(&self) -> Result<ChangesetIter<'_>> {
+        let mut it = ptr::null_mut();
+        check(unsafe { ffi::sqlite3changeset_start(&mut it as *mut *mut _, self.n, self.cs) })?;
+        Ok(ChangesetIter {
+            phantom: PhantomData,
+            it,
+            item: None,
+        })
+    }
+
+    /// Concatenate two changeset objects
+    #[inline]
+    pub fn concat(a: &Changeset, b: &Changeset) -> Result<Changeset> {
+        let mut n = 0;
+        let mut cs = ptr::null_mut();
+        check(unsafe {
+            ffi::sqlite3changeset_concat(a.n, a.cs, b.n, b.cs, &mut n, &mut cs as *mut *mut _)
+        })?;
+        Ok(Changeset { cs, n })
+    }
+}
+
+impl Drop for Changeset {
+    #[inline]
+    fn drop(&mut self) {
+        unsafe {
+            ffi::sqlite3_free(self.cs);
+        }
+    }
+}
+
+/// Cursor for iterating over the elements of a changeset
+/// or patchset.
+pub struct ChangesetIter<'changeset> {
+    phantom: PhantomData<&'changeset Changeset>,
+    it: *mut ffi::sqlite3_changeset_iter,
+    item: Option<ChangesetItem>,
+}
+
+impl ChangesetIter<'_> {
+    /// Create an iterator on `input`
+    #[inline]
+    pub fn start_strm<'input>(input: &&'input mut dyn Read) -> Result<ChangesetIter<'input>> {
+        let mut it = ptr::null_mut();
+        check(unsafe {
+            ffi::sqlite3changeset_start_strm(
+                &mut it as *mut *mut _,
+                Some(x_input),
+                input as *const &mut dyn Read as *mut c_void,
+            )
+        })?;
+        Ok(ChangesetIter {
+            phantom: PhantomData,
+            it,
+            item: None,
+        })
+    }
+}
+
+impl FallibleStreamingIterator for ChangesetIter<'_> {
+    type Error = crate::error::Error;
+    type Item = ChangesetItem;
+
+    #[inline]
+    fn advance(&mut self) -> Result<()> {
+        let rc = unsafe { ffi::sqlite3changeset_next(self.it) };
+        match rc {
+            ffi::SQLITE_ROW => {
+                self.item = Some(ChangesetItem { it: self.it });
+                Ok(())
+            }
+            ffi::SQLITE_DONE => {
+                self.item = None;
+                Ok(())
+            }
+            code => Err(error_from_sqlite_code(code, None)),
+        }
+    }
+
+    #[inline]
+    fn get(&self) -> Option<&ChangesetItem> {
+        self.item.as_ref()
+    }
+}
+
+/// Operation
+pub struct Operation<'item> {
+    table_name: &'item str,
+    number_of_columns: i32,
+    code: Action,
+    indirect: bool,
+}
+
+impl Operation<'_> {
+    /// Returns the table name.
+    #[inline]
+    pub fn table_name(&self) -> &str {
+        self.table_name
+    }
+
+    /// Returns the number of columns in table
+    #[inline]
+    pub fn number_of_columns(&self) -> i32 {
+        self.number_of_columns
+    }
+
+    /// Returns the action code.
+    #[inline]
+    pub fn code(&self) -> Action {
+        self.code
+    }
+
+    /// Returns `true` for an 'indirect' change.
+    #[inline]
+    pub fn indirect(&self) -> bool {
+        self.indirect
+    }
+}
+
+impl Drop for ChangesetIter<'_> {
+    #[inline]
+    fn drop(&mut self) {
+        unsafe {
+            ffi::sqlite3changeset_finalize(self.it);
+        }
+    }
+}
+
+/// An item passed to a conflict-handler by
+/// [`Connection::apply`](crate::Connection::apply), or an item generated by
+/// [`ChangesetIter::next`](ChangesetIter::next).
+// TODO enum ? Delete, Insert, Update, ...
+pub struct ChangesetItem {
+    it: *mut ffi::sqlite3_changeset_iter,
+}
+
+impl ChangesetItem {
+    /// Obtain conflicting row values
+    ///
+    /// May only be called with an `SQLITE_CHANGESET_DATA` or
+    /// `SQLITE_CHANGESET_CONFLICT` conflict handler callback.
+    #[inline]
+    pub fn conflict(&self, col: usize) -> Result<ValueRef<'_>> {
+        unsafe {
+            let mut p_value: *mut ffi::sqlite3_value = ptr::null_mut();
+            check(ffi::sqlite3changeset_conflict(
+                self.it,
+                col as i32,
+                &mut p_value,
+            ))?;
+            Ok(ValueRef::from_value(p_value))
+        }
+    }
+
+    /// Determine the number of foreign key constraint violations
+    ///
+    /// May only be called with an `SQLITE_CHANGESET_FOREIGN_KEY` conflict
+    /// handler callback.
+    #[inline]
+    pub fn fk_conflicts(&self) -> Result<i32> {
+        unsafe {
+            let mut p_out = 0;
+            check(ffi::sqlite3changeset_fk_conflicts(self.it, &mut p_out))?;
+            Ok(p_out)
+        }
+    }
+
+    /// Obtain new.* Values
+    ///
+    /// May only be called if the type of change is either `SQLITE_UPDATE` or
+    /// `SQLITE_INSERT`.
+    #[inline]
+    pub fn new_value(&self, col: usize) -> Result<ValueRef<'_>> {
+        unsafe {
+            let mut p_value: *mut ffi::sqlite3_value = ptr::null_mut();
+            check(ffi::sqlite3changeset_new(self.it, col as i32, &mut p_value))?;
+            Ok(ValueRef::from_value(p_value))
+        }
+    }
+
+    /// Obtain old.* Values
+    ///
+    /// May only be called if the type of change is either `SQLITE_DELETE` or
+    /// `SQLITE_UPDATE`.
+    #[inline]
+    pub fn old_value(&self, col: usize) -> Result<ValueRef<'_>> {
+        unsafe {
+            let mut p_value: *mut ffi::sqlite3_value = ptr::null_mut();
+            check(ffi::sqlite3changeset_old(self.it, col as i32, &mut p_value))?;
+            Ok(ValueRef::from_value(p_value))
+        }
+    }
+
+    /// Obtain the current operation
+    #[inline]
+    pub fn op(&self) -> Result<Operation<'_>> {
+        let mut number_of_columns = 0;
+        let mut code = 0;
+        let mut indirect = 0;
+        let tab = unsafe {
+            let mut pz_tab: *const c_char = ptr::null();
+            check(ffi::sqlite3changeset_op(
+                self.it,
+                &mut pz_tab,
+                &mut number_of_columns,
+                &mut code,
+                &mut indirect,
+            ))?;
+            CStr::from_ptr(pz_tab)
+        };
+        let table_name = tab.to_str()?;
+        Ok(Operation {
+            table_name,
+            number_of_columns,
+            code: Action::from(code),
+            indirect: indirect != 0,
+        })
+    }
+
+    /// Obtain the primary key definition of a table
+    #[inline]
+    pub fn pk(&self) -> Result<&[u8]> {
+        let mut number_of_columns = 0;
+        unsafe {
+            let mut pks: *mut c_uchar = ptr::null_mut();
+            check(ffi::sqlite3changeset_pk(
+                self.it,
+                &mut pks,
+                &mut number_of_columns,
+            ))?;
+            Ok(from_raw_parts(pks, number_of_columns as usize))
+        }
+    }
+}
+
+/// Used to combine two or more changesets or
+/// patchsets
+pub struct Changegroup {
+    cg: *mut ffi::sqlite3_changegroup,
+}
+
+impl Changegroup {
+    /// Create a new change group.
+    #[inline]
+    pub fn new() -> Result<Self> {
+        let mut cg = ptr::null_mut();
+        check(unsafe { ffi::sqlite3changegroup_new(&mut cg) })?;
+        Ok(Changegroup { cg })
+    }
+
+    /// Add a changeset
+    #[inline]
+    pub fn add(&mut self, cs: &Changeset) -> Result<()> {
+        check(unsafe { ffi::sqlite3changegroup_add(self.cg, cs.n, cs.cs) })
+    }
+
+    /// Add a changeset read from `input` to this change group.
+    #[inline]
+    pub fn add_stream(&mut self, input: &mut dyn Read) -> Result<()> {
+        let input_ref = &input;
+        check(unsafe {
+            ffi::sqlite3changegroup_add_strm(
+                self.cg,
+                Some(x_input),
+                input_ref as *const &mut dyn Read as *mut c_void,
+            )
+        })
+    }
+
+    /// Obtain a composite Changeset
+    #[inline]
+    pub fn output(&mut self) -> Result<Changeset> {
+        let mut n = 0;
+        let mut output: *mut c_void = ptr::null_mut();
+        check(unsafe { ffi::sqlite3changegroup_output(self.cg, &mut n, &mut output) })?;
+        Ok(Changeset { cs: output, n })
+    }
+
+    /// Write the combined set of changes to `output`.
+    #[inline]
+    pub fn output_strm(&mut self, output: &mut dyn Write) -> Result<()> {
+        let output_ref = &output;
+        check(unsafe {
+            ffi::sqlite3changegroup_output_strm(
+                self.cg,
+                Some(x_output),
+                output_ref as *const &mut dyn Write as *mut c_void,
+            )
+        })
+    }
+}
+
+impl Drop for Changegroup {
+    #[inline]
+    fn drop(&mut self) {
+        unsafe {
+            ffi::sqlite3changegroup_delete(self.cg);
+        }
+    }
+}
+
+impl Connection {
+    /// Apply a changeset to a database
+    pub fn apply<F, C>(&self, cs: &Changeset, filter: Option<F>, conflict: C) -> Result<()>
+    where
+        F: Fn(&str) -> bool + Send + RefUnwindSafe + 'static,
+        C: Fn(ConflictType, ChangesetItem) -> ConflictAction + Send + RefUnwindSafe + 'static,
+    {
+        let db = self.db.borrow_mut().db;
+
+        let filtered = filter.is_some();
+        let tuple = &mut (filter, conflict);
+        check(unsafe {
+            if filtered {
+                ffi::sqlite3changeset_apply(
+                    db,
+                    cs.n,
+                    cs.cs,
+                    Some(call_filter::<F, C>),
+                    Some(call_conflict::<F, C>),
+                    tuple as *mut (Option<F>, C) as *mut c_void,
+                )
+            } else {
+                ffi::sqlite3changeset_apply(
+                    db,
+                    cs.n,
+                    cs.cs,
+                    None,
+                    Some(call_conflict::<F, C>),
+                    tuple as *mut (Option<F>, C) as *mut c_void,
+                )
+            }
+        })
+    }
+
+    /// Apply a changeset to a database
+    pub fn apply_strm<F, C>(
+        &self,
+        input: &mut dyn Read,
+        filter: Option<F>,
+        conflict: C,
+    ) -> Result<()>
+    where
+        F: Fn(&str) -> bool + Send + RefUnwindSafe + 'static,
+        C: Fn(ConflictType, ChangesetItem) -> ConflictAction + Send + RefUnwindSafe + 'static,
+    {
+        let input_ref = &input;
+        let db = self.db.borrow_mut().db;
+
+        let filtered = filter.is_some();
+        let tuple = &mut (filter, conflict);
+        check(unsafe {
+            if filtered {
+                ffi::sqlite3changeset_apply_strm(
+                    db,
+                    Some(x_input),
+                    input_ref as *const &mut dyn Read as *mut c_void,
+                    Some(call_filter::<F, C>),
+                    Some(call_conflict::<F, C>),
+                    tuple as *mut (Option<F>, C) as *mut c_void,
+                )
+            } else {
+                ffi::sqlite3changeset_apply_strm(
+                    db,
+                    Some(x_input),
+                    input_ref as *const &mut dyn Read as *mut c_void,
+                    None,
+                    Some(call_conflict::<F, C>),
+                    tuple as *mut (Option<F>, C) as *mut c_void,
+                )
+            }
+        })
+    }
+}
+
+/// Constants passed to the conflict handler
+/// See [here](https://sqlite.org/session.html#SQLITE_CHANGESET_CONFLICT) for details.
+#[allow(missing_docs)]
+#[repr(i32)]
+#[derive(Debug, PartialEq, Eq)]
+#[non_exhaustive]
+#[allow(clippy::upper_case_acronyms)]
+pub enum ConflictType {
+    UNKNOWN = -1,
+    SQLITE_CHANGESET_DATA = ffi::SQLITE_CHANGESET_DATA,
+    SQLITE_CHANGESET_NOTFOUND = ffi::SQLITE_CHANGESET_NOTFOUND,
+    SQLITE_CHANGESET_CONFLICT = ffi::SQLITE_CHANGESET_CONFLICT,
+    SQLITE_CHANGESET_CONSTRAINT = ffi::SQLITE_CHANGESET_CONSTRAINT,
+    SQLITE_CHANGESET_FOREIGN_KEY = ffi::SQLITE_CHANGESET_FOREIGN_KEY,
+}
+impl From<i32> for ConflictType {
+    fn from(code: i32) -> ConflictType {
+        match code {
+            ffi::SQLITE_CHANGESET_DATA => ConflictType::SQLITE_CHANGESET_DATA,
+            ffi::SQLITE_CHANGESET_NOTFOUND => ConflictType::SQLITE_CHANGESET_NOTFOUND,
+            ffi::SQLITE_CHANGESET_CONFLICT => ConflictType::SQLITE_CHANGESET_CONFLICT,
+            ffi::SQLITE_CHANGESET_CONSTRAINT => ConflictType::SQLITE_CHANGESET_CONSTRAINT,
+            ffi::SQLITE_CHANGESET_FOREIGN_KEY => ConflictType::SQLITE_CHANGESET_FOREIGN_KEY,
+            _ => ConflictType::UNKNOWN,
+        }
+    }
+}
+
+/// Constants returned by the conflict handler
+/// See [here](https://sqlite.org/session.html#SQLITE_CHANGESET_ABORT) for details.
+#[allow(missing_docs)]
+#[repr(i32)]
+#[derive(Debug, PartialEq, Eq)]
+#[non_exhaustive]
+#[allow(clippy::upper_case_acronyms)]
+pub enum ConflictAction {
+    SQLITE_CHANGESET_OMIT = ffi::SQLITE_CHANGESET_OMIT,
+    SQLITE_CHANGESET_REPLACE = ffi::SQLITE_CHANGESET_REPLACE,
+    SQLITE_CHANGESET_ABORT = ffi::SQLITE_CHANGESET_ABORT,
+}
+
+unsafe extern "C" fn call_filter<F, C>(p_ctx: *mut c_void, tbl_str: *const c_char) -> c_int
+where
+    F: Fn(&str) -> bool + Send + RefUnwindSafe + 'static,
+    C: Fn(ConflictType, ChangesetItem) -> ConflictAction + Send + RefUnwindSafe + 'static,
+{
+    use std::str;
+
+    let tuple: *mut (Option<F>, C) = p_ctx as *mut (Option<F>, C);
+    let tbl_name = {
+        let c_slice = CStr::from_ptr(tbl_str).to_bytes();
+        str::from_utf8(c_slice)
+    };
+    match *tuple {
+        (Some(ref filter), _) => c_int::from(
+            catch_unwind(|| filter(tbl_name.expect("illegal table name"))).unwrap_or_default(),
+        ),
+        _ => unimplemented!(),
+    }
+}
+
+unsafe extern "C" fn call_conflict<F, C>(
+    p_ctx: *mut c_void,
+    e_conflict: c_int,
+    p: *mut ffi::sqlite3_changeset_iter,
+) -> c_int
+where
+    F: Fn(&str) -> bool + Send + RefUnwindSafe + 'static,
+    C: Fn(ConflictType, ChangesetItem) -> ConflictAction + Send + RefUnwindSafe + 'static,
+{
+    let tuple: *mut (Option<F>, C) = p_ctx as *mut (Option<F>, C);
+    let conflict_type = ConflictType::from(e_conflict);
+    let item = ChangesetItem { it: p };
+    if let Ok(action) = catch_unwind(|| (*tuple).1(conflict_type, item)) {
+        action as c_int
+    } else {
+        ffi::SQLITE_CHANGESET_ABORT
+    }
+}
+
+unsafe extern "C" fn x_input(p_in: *mut c_void, data: *mut c_void, len: *mut c_int) -> c_int {
+    if p_in.is_null() {
+        return ffi::SQLITE_MISUSE;
+    }
+    let bytes: &mut [u8] = from_raw_parts_mut(data as *mut u8, *len as usize);
+    let input = p_in as *mut &mut dyn Read;
+    match (*input).read(bytes) {
+        Ok(n) => {
+            *len = n as i32; // TODO Validate: n = 0 may not mean the reader will always no longer be able to
+                             // produce bytes.
+            ffi::SQLITE_OK
+        }
+        Err(_) => ffi::SQLITE_IOERR_READ, // TODO check if err is a (ru)sqlite Error => propagate
+    }
+}
+
+unsafe extern "C" fn x_output(p_out: *mut c_void, data: *const c_void, len: c_int) -> c_int {
+    if p_out.is_null() {
+        return ffi::SQLITE_MISUSE;
+    }
+    // The sessions module never invokes an xOutput callback with the third
+    // parameter set to a value less than or equal to zero.
+    let bytes: &[u8] = from_raw_parts(data as *const u8, len as usize);
+    let output = p_out as *mut &mut dyn Write;
+    match (*output).write_all(bytes) {
+        Ok(_) => ffi::SQLITE_OK,
+        Err(_) => ffi::SQLITE_IOERR_WRITE, // TODO check if err is a (ru)sqlite Error => propagate
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use fallible_streaming_iterator::FallibleStreamingIterator;
+    use std::io::Read;
+    use std::sync::atomic::{AtomicBool, Ordering};
+
+    use super::{Changeset, ChangesetIter, ConflictAction, ConflictType, Session};
+    use crate::hooks::Action;
+    use crate::{Connection, Result};
+
+    fn one_changeset() -> Result<Changeset> {
+        let db = Connection::open_in_memory()?;
+        db.execute_batch("CREATE TABLE foo(t TEXT PRIMARY KEY NOT NULL);")?;
+
+        let mut session = Session::new(&db)?;
+        assert!(session.is_empty());
+
+        session.attach(None)?;
+        db.execute("INSERT INTO foo (t) VALUES (?1);", ["bar"])?;
+
+        session.changeset()
+    }
+
+    fn one_changeset_strm() -> Result<Vec<u8>> {
+        let db = Connection::open_in_memory()?;
+        db.execute_batch("CREATE TABLE foo(t TEXT PRIMARY KEY NOT NULL);")?;
+
+        let mut session = Session::new(&db)?;
+        assert!(session.is_empty());
+
+        session.attach(None)?;
+        db.execute("INSERT INTO foo (t) VALUES (?1);", ["bar"])?;
+
+        let mut output = Vec::new();
+        session.changeset_strm(&mut output)?;
+        Ok(output)
+    }
+
+    #[test]
+    fn test_changeset() -> Result<()> {
+        let changeset = one_changeset()?;
+        let mut iter = changeset.iter()?;
+        let item = iter.next()?;
+        assert!(item.is_some());
+
+        let item = item.unwrap();
+        let op = item.op()?;
+        assert_eq!("foo", op.table_name());
+        assert_eq!(1, op.number_of_columns());
+        assert_eq!(Action::SQLITE_INSERT, op.code());
+        assert!(!op.indirect());
+
+        let pk = item.pk()?;
+        assert_eq!(&[1], pk);
+
+        let new_value = item.new_value(0)?;
+        assert_eq!(Ok("bar"), new_value.as_str());
+        Ok(())
+    }
+
+    #[test]
+    fn test_changeset_strm() -> Result<()> {
+        let output = one_changeset_strm()?;
+        assert!(!output.is_empty());
+        assert_eq!(14, output.len());
+
+        let input: &mut dyn Read = &mut output.as_slice();
+        let mut iter = ChangesetIter::start_strm(&input)?;
+        let item = iter.next()?;
+        assert!(item.is_some());
+        Ok(())
+    }
+
+    #[test]
+    fn test_changeset_apply() -> Result<()> {
+        let changeset = one_changeset()?;
+
+        let db = Connection::open_in_memory()?;
+        db.execute_batch("CREATE TABLE foo(t TEXT PRIMARY KEY NOT NULL);")?;
+
+        static CALLED: AtomicBool = AtomicBool::new(false);
+        db.apply(
+            &changeset,
+            None::<fn(&str) -> bool>,
+            |_conflict_type, _item| {
+                CALLED.store(true, Ordering::Relaxed);
+                ConflictAction::SQLITE_CHANGESET_OMIT
+            },
+        )?;
+
+        assert!(!CALLED.load(Ordering::Relaxed));
+        let check = db.query_row("SELECT 1 FROM foo WHERE t = ?1", ["bar"], |row| {
+            row.get::<_, i32>(0)
+        })?;
+        assert_eq!(1, check);
+
+        // conflict expected when same changeset applied again on the same db
+        db.apply(
+            &changeset,
+            None::<fn(&str) -> bool>,
+            |conflict_type, item| {
+                CALLED.store(true, Ordering::Relaxed);
+                assert_eq!(ConflictType::SQLITE_CHANGESET_CONFLICT, conflict_type);
+                let conflict = item.conflict(0).unwrap();
+                assert_eq!(Ok("bar"), conflict.as_str());
+                ConflictAction::SQLITE_CHANGESET_OMIT
+            },
+        )?;
+        assert!(CALLED.load(Ordering::Relaxed));
+        Ok(())
+    }
+
+    #[test]
+    fn test_changeset_apply_strm() -> Result<()> {
+        let output = one_changeset_strm()?;
+
+        let db = Connection::open_in_memory()?;
+        db.execute_batch("CREATE TABLE foo(t TEXT PRIMARY KEY NOT NULL);")?;
+
+        let mut input = output.as_slice();
+        db.apply_strm(
+            &mut input,
+            None::<fn(&str) -> bool>,
+            |_conflict_type, _item| ConflictAction::SQLITE_CHANGESET_OMIT,
+        )?;
+
+        let check = db.query_row("SELECT 1 FROM foo WHERE t = ?1", ["bar"], |row| {
+            row.get::<_, i32>(0)
+        })?;
+        assert_eq!(1, check);
+        Ok(())
+    }
+
+    #[test]
+    fn test_session_empty() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        db.execute_batch("CREATE TABLE foo(t TEXT PRIMARY KEY NOT NULL);")?;
+
+        let mut session = Session::new(&db)?;
+        assert!(session.is_empty());
+
+        session.attach(None)?;
+        db.execute("INSERT INTO foo (t) VALUES (?1);", ["bar"])?;
+
+        assert!(!session.is_empty());
+        Ok(())
+    }
+
+    #[test]
+    fn test_session_set_enabled() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+
+        let mut session = Session::new(&db)?;
+        assert!(session.is_enabled());
+        session.set_enabled(false);
+        assert!(!session.is_enabled());
+        Ok(())
+    }
+
+    #[test]
+    fn test_session_set_indirect() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+
+        let mut session = Session::new(&db)?;
+        assert!(!session.is_indirect());
+        session.set_indirect(true);
+        assert!(session.is_indirect());
+        Ok(())
+    }
+}
diff --git a/crates/rusqlite/src/statement.rs b/crates/rusqlite/src/statement.rs
new file mode 100644
index 0000000..982567a
--- /dev/null
+++ b/crates/rusqlite/src/statement.rs
@@ -0,0 +1,1356 @@
+use std::iter::IntoIterator;
+use std::os::raw::{c_int, c_void};
+#[cfg(feature = "array")]
+use std::rc::Rc;
+use std::slice::from_raw_parts;
+use std::{fmt, mem, ptr, str};
+
+use super::ffi;
+use super::{len_as_c_int, str_for_sqlite};
+use super::{
+    AndThenRows, Connection, Error, MappedRows, Params, RawStatement, Result, Row, Rows, ValueRef,
+};
+use crate::types::{ToSql, ToSqlOutput};
+#[cfg(feature = "array")]
+use crate::vtab::array::{free_array, ARRAY_TYPE};
+
+/// A prepared statement.
+pub struct Statement<'conn> {
+    conn: &'conn Connection,
+    pub(crate) stmt: RawStatement,
+}
+
+impl Statement<'_> {
+    /// Execute the prepared statement.
+    ///
+    /// On success, returns the number of rows that were changed or inserted or
+    /// deleted (via `sqlite3_changes`).
+    ///
+    /// ## Example
+    ///
+    /// ### Use with positional parameters
+    ///
+    /// ```rust,no_run
+    /// # use rusqlite::{Connection, Result, params};
+    /// fn update_rows(conn: &Connection) -> Result<()> {
+    ///     let mut stmt = conn.prepare("UPDATE foo SET bar = ?1 WHERE qux = ?2")?;
+    ///     // For a single parameter, or a parameter where all the values have
+    ///     // the same type, just passing an array is simplest.
+    ///     stmt.execute([2i32])?;
+    ///     // The `rusqlite::params!` macro is mostly useful when the parameters do not
+    ///     // all have the same type, or if there are more than 32 parameters
+    ///     // at once, but it can be used in other cases.
+    ///     stmt.execute(params![1i32])?;
+    ///     // However, it's not required, many cases are fine as:
+    ///     stmt.execute(&[&2i32])?;
+    ///     // Or even:
+    ///     stmt.execute([2i32])?;
+    ///     // If you really want to, this is an option as well.
+    ///     stmt.execute((2i32,))?;
+    ///     Ok(())
+    /// }
+    /// ```
+    ///
+    /// #### Heterogeneous positional parameters
+    ///
+    /// ```
+    /// use rusqlite::{Connection, Result};
+    /// fn store_file(conn: &Connection, path: &str, data: &[u8]) -> Result<()> {
+    ///     # // no need to do it for real.
+    ///     # fn sha256(_: &[u8]) -> [u8; 32] { [0; 32] }
+    ///     let query = "INSERT OR REPLACE INTO files(path, hash, data) VALUES (?1, ?2, ?3)";
+    ///     let mut stmt = conn.prepare_cached(query)?;
+    ///     let hash: [u8; 32] = sha256(data);
+    ///     // The easiest way to pass positional parameters of have several
+    ///     // different types is by using a tuple.
+    ///     stmt.execute((path, hash, data))?;
+    ///     // Using the `params!` macro also works, and supports longer parameter lists:
+    ///     stmt.execute(rusqlite::params![path, hash, data])?;
+    ///     Ok(())
+    /// }
+    /// # let c = Connection::open_in_memory().unwrap();
+    /// # c.execute_batch("CREATE TABLE files(path TEXT PRIMARY KEY, hash BLOB, data BLOB)").unwrap();
+    /// # store_file(&c, "foo/bar.txt", b"bibble").unwrap();
+    /// # store_file(&c, "foo/baz.txt", b"bobble").unwrap();
+    /// ```
+    ///
+    /// ### Use with named parameters
+    ///
+    /// ```rust,no_run
+    /// # use rusqlite::{Connection, Result, named_params};
+    /// fn insert(conn: &Connection) -> Result<()> {
+    ///     let mut stmt = conn.prepare("INSERT INTO test (key, value) VALUES (:key, :value)")?;
+    ///     // The `rusqlite::named_params!` macro (like `params!`) is useful for heterogeneous
+    ///     // sets of parameters (where all parameters are not the same type), or for queries
+    ///     // with many (more than 32) statically known parameters.
+    ///     stmt.execute(named_params! { ":key": "one", ":val": 2 })?;
+    ///     // However, named parameters can also be passed like:
+    ///     stmt.execute(&[(":key", "three"), (":val", "four")])?;
+    ///     // Or even: (note that a &T is required for the value type, currently)
+    ///     stmt.execute(&[(":key", &100), (":val", &200)])?;
+    ///     Ok(())
+    /// }
+    /// ```
+    ///
+    /// ### Use without parameters
+    ///
+    /// ```rust,no_run
+    /// # use rusqlite::{Connection, Result, params};
+    /// fn delete_all(conn: &Connection) -> Result<()> {
+    ///     let mut stmt = conn.prepare("DELETE FROM users")?;
+    ///     stmt.execute([])?;
+    ///     Ok(())
+    /// }
+    /// ```
+    ///
+    /// # Failure
+    ///
+    /// Will return `Err` if binding parameters fails, the executed statement
+    /// returns rows (in which case `query` should be used instead), or the
+    /// underlying SQLite call fails.
+    #[inline]
+    pub fn execute<P: Params>(&mut self, params: P) -> Result<usize> {
+        params.__bind_in(self)?;
+        self.execute_with_bound_parameters()
+    }
+
+    /// Execute an INSERT and return the ROWID.
+    ///
+    /// # Note
+    ///
+    /// This function is a convenience wrapper around
+    /// [`execute()`](Statement::execute) intended for queries that insert a
+    /// single item. It is possible to misuse this function in a way that it
+    /// cannot detect, such as by calling it on a statement which _updates_
+    /// a single item rather than inserting one. Please don't do that.
+    ///
+    /// # Failure
+    ///
+    /// Will return `Err` if no row is inserted or many rows are inserted.
+    #[inline]
+    pub fn insert<P: Params>(&mut self, params: P) -> Result<i64> {
+        let changes = self.execute(params)?;
+        match changes {
+            1 => Ok(self.conn.last_insert_rowid()),
+            _ => Err(Error::StatementChangedRows(changes)),
+        }
+    }
+
+    /// Execute the prepared statement, returning a handle to the resulting
+    /// rows.
+    ///
+    /// Due to lifetime restrictions, the rows handle returned by `query` does
+    /// not implement the `Iterator` trait. Consider using
+    /// [`query_map`](Statement::query_map) or
+    /// [`query_and_then`](Statement::query_and_then) instead, which do.
+    ///
+    /// ## Example
+    ///
+    /// ### Use without parameters
+    ///
+    /// ```rust,no_run
+    /// # use rusqlite::{Connection, Result};
+    /// fn get_names(conn: &Connection) -> Result<Vec<String>> {
+    ///     let mut stmt = conn.prepare("SELECT name FROM people")?;
+    ///     let mut rows = stmt.query([])?;
+    ///
+    ///     let mut names = Vec::new();
+    ///     while let Some(row) = rows.next()? {
+    ///         names.push(row.get(0)?);
+    ///     }
+    ///
+    ///     Ok(names)
+    /// }
+    /// ```
+    ///
+    /// ### Use with positional parameters
+    ///
+    /// ```rust,no_run
+    /// # use rusqlite::{Connection, Result};
+    /// fn query(conn: &Connection, name: &str) -> Result<()> {
+    ///     let mut stmt = conn.prepare("SELECT * FROM test where name = ?1")?;
+    ///     let mut rows = stmt.query(rusqlite::params![name])?;
+    ///     while let Some(row) = rows.next()? {
+    ///         // ...
+    ///     }
+    ///     Ok(())
+    /// }
+    /// ```
+    ///
+    /// Or, equivalently (but without the [`crate::params!`] macro).
+    ///
+    /// ```rust,no_run
+    /// # use rusqlite::{Connection, Result};
+    /// fn query(conn: &Connection, name: &str) -> Result<()> {
+    ///     let mut stmt = conn.prepare("SELECT * FROM test where name = ?1")?;
+    ///     let mut rows = stmt.query([name])?;
+    ///     while let Some(row) = rows.next()? {
+    ///         // ...
+    ///     }
+    ///     Ok(())
+    /// }
+    /// ```
+    ///
+    /// ### Use with named parameters
+    ///
+    /// ```rust,no_run
+    /// # use rusqlite::{Connection, Result};
+    /// fn query(conn: &Connection) -> Result<()> {
+    ///     let mut stmt = conn.prepare("SELECT * FROM test where name = :name")?;
+    ///     let mut rows = stmt.query(&[(":name", "one")])?;
+    ///     while let Some(row) = rows.next()? {
+    ///         // ...
+    ///     }
+    ///     Ok(())
+    /// }
+    /// ```
+    ///
+    /// Note, the `named_params!` macro is provided for syntactic convenience,
+    /// and so the above example could also be written as:
+    ///
+    /// ```rust,no_run
+    /// # use rusqlite::{Connection, Result, named_params};
+    /// fn query(conn: &Connection) -> Result<()> {
+    ///     let mut stmt = conn.prepare("SELECT * FROM test where name = :name")?;
+    ///     let mut rows = stmt.query(named_params! { ":name": "one" })?;
+    ///     while let Some(row) = rows.next()? {
+    ///         // ...
+    ///     }
+    ///     Ok(())
+    /// }
+    /// ```
+    ///
+    /// ## Failure
+    ///
+    /// Will return `Err` if binding parameters fails.
+    #[inline]
+    pub fn query<P: Params>(&mut self, params: P) -> Result<Rows<'_>> {
+        params.__bind_in(self)?;
+        Ok(Rows::new(self))
+    }
+
+    /// Executes the prepared statement and maps a function over the resulting
+    /// rows, returning an iterator over the mapped function results.
+    ///
+    /// `f` is used to transform the _streaming_ iterator into a _standard_
+    /// iterator.
+    ///
+    /// This is equivalent to `stmt.query(params)?.mapped(f)`.
+    ///
+    /// ## Example
+    ///
+    /// ### Use with positional params
+    ///
+    /// ```rust,no_run
+    /// # use rusqlite::{Connection, Result};
+    /// fn get_names(conn: &Connection) -> Result<Vec<String>> {
+    ///     let mut stmt = conn.prepare("SELECT name FROM people")?;
+    ///     let rows = stmt.query_map([], |row| row.get(0))?;
+    ///
+    ///     let mut names = Vec::new();
+    ///     for name_result in rows {
+    ///         names.push(name_result?);
+    ///     }
+    ///
+    ///     Ok(names)
+    /// }
+    /// ```
+    ///
+    /// ### Use with named params
+    ///
+    /// ```rust,no_run
+    /// # use rusqlite::{Connection, Result};
+    /// fn get_names(conn: &Connection) -> Result<Vec<String>> {
+    ///     let mut stmt = conn.prepare("SELECT name FROM people WHERE id = :id")?;
+    ///     let rows = stmt.query_map(&[(":id", &"one")], |row| row.get(0))?;
+    ///
+    ///     let mut names = Vec::new();
+    ///     for name_result in rows {
+    ///         names.push(name_result?);
+    ///     }
+    ///
+    ///     Ok(names)
+    /// }
+    /// ```
+    /// ## Failure
+    ///
+    /// Will return `Err` if binding parameters fails.
+    pub fn query_map<T, P, F>(&mut self, params: P, f: F) -> Result<MappedRows<'_, F>>
+    where
+        P: Params,
+        F: FnMut(&Row<'_>) -> Result<T>,
+    {
+        self.query(params).map(|rows| rows.mapped(f))
+    }
+
+    /// Executes the prepared statement and maps a function over the resulting
+    /// rows, where the function returns a `Result` with `Error` type
+    /// implementing `std::convert::From<Error>` (so errors can be unified).
+    ///
+    /// This is equivalent to `stmt.query(params)?.and_then(f)`.
+    ///
+    /// ## Example
+    ///
+    /// ### Use with named params
+    ///
+    /// ```rust,no_run
+    /// # use rusqlite::{Connection, Result};
+    /// struct Person {
+    ///     name: String,
+    /// };
+    ///
+    /// fn name_to_person(name: String) -> Result<Person> {
+    ///     // ... check for valid name
+    ///     Ok(Person { name })
+    /// }
+    ///
+    /// fn get_names(conn: &Connection) -> Result<Vec<Person>> {
+    ///     let mut stmt = conn.prepare("SELECT name FROM people WHERE id = :id")?;
+    ///     let rows = stmt.query_and_then(&[(":id", "one")], |row| name_to_person(row.get(0)?))?;
+    ///
+    ///     let mut persons = Vec::new();
+    ///     for person_result in rows {
+    ///         persons.push(person_result?);
+    ///     }
+    ///
+    ///     Ok(persons)
+    /// }
+    /// ```
+    ///
+    /// ### Use with positional params
+    ///
+    /// ```rust,no_run
+    /// # use rusqlite::{Connection, Result};
+    /// fn get_names(conn: &Connection) -> Result<Vec<String>> {
+    ///     let mut stmt = conn.prepare("SELECT name FROM people WHERE id = ?1")?;
+    ///     let rows = stmt.query_and_then(["one"], |row| row.get::<_, String>(0))?;
+    ///
+    ///     let mut persons = Vec::new();
+    ///     for person_result in rows {
+    ///         persons.push(person_result?);
+    ///     }
+    ///
+    ///     Ok(persons)
+    /// }
+    /// ```
+    ///
+    /// # Failure
+    ///
+    /// Will return `Err` if binding parameters fails.
+    #[inline]
+    pub fn query_and_then<T, E, P, F>(&mut self, params: P, f: F) -> Result<AndThenRows<'_, F>>
+    where
+        P: Params,
+        E: From<Error>,
+        F: FnMut(&Row<'_>) -> Result<T, E>,
+    {
+        self.query(params).map(|rows| rows.and_then(f))
+    }
+
+    /// Return `true` if a query in the SQL statement it executes returns one
+    /// or more rows and `false` if the SQL returns an empty set.
+    #[inline]
+    pub fn exists<P: Params>(&mut self, params: P) -> Result<bool> {
+        let mut rows = self.query(params)?;
+        let exists = rows.next()?.is_some();
+        Ok(exists)
+    }
+
+    /// Convenience method to execute a query that is expected to return a
+    /// single row.
+    ///
+    /// If the query returns more than one row, all rows except the first are
+    /// ignored.
+    ///
+    /// Returns `Err(QueryReturnedNoRows)` if no results are returned. If the
+    /// query truly is optional, you can call
+    /// [`.optional()`](crate::OptionalExtension::optional) on the result of
+    /// this to get a `Result<Option<T>>` (requires that the trait
+    /// `rusqlite::OptionalExtension` is imported).
+    ///
+    /// # Failure
+    ///
+    /// Will return `Err` if the underlying SQLite call fails.
+    pub fn query_row<T, P, F>(&mut self, params: P, f: F) -> Result<T>
+    where
+        P: Params,
+        F: FnOnce(&Row<'_>) -> Result<T>,
+    {
+        let mut rows = self.query(params)?;
+
+        rows.get_expected_row().and_then(f)
+    }
+
+    /// Consumes the statement.
+    ///
+    /// Functionally equivalent to the `Drop` implementation, but allows
+    /// callers to see any errors that occur.
+    ///
+    /// # Failure
+    ///
+    /// Will return `Err` if the underlying SQLite call fails.
+    #[inline]
+    pub fn finalize(mut self) -> Result<()> {
+        self.finalize_()
+    }
+
+    /// Return the (one-based) index of an SQL parameter given its name.
+    ///
+    /// Note that the initial ":" or "$" or "@" or "?" used to specify the
+    /// parameter is included as part of the name.
+    ///
+    /// ```rust,no_run
+    /// # use rusqlite::{Connection, Result};
+    /// fn example(conn: &Connection) -> Result<()> {
+    ///     let stmt = conn.prepare("SELECT * FROM test WHERE name = :example")?;
+    ///     let index = stmt.parameter_index(":example")?;
+    ///     assert_eq!(index, Some(1));
+    ///     Ok(())
+    /// }
+    /// ```
+    ///
+    /// # Failure
+    ///
+    /// Will return Err if `name` is invalid. Will return Ok(None) if the name
+    /// is valid but not a bound parameter of this statement.
+    #[inline]
+    pub fn parameter_index(&self, name: &str) -> Result<Option<usize>> {
+        Ok(self.stmt.bind_parameter_index(name))
+    }
+
+    /// Return the SQL parameter name given its (one-based) index (the inverse
+    /// of [`Statement::parameter_index`]).
+    ///
+    /// ```rust,no_run
+    /// # use rusqlite::{Connection, Result};
+    /// fn example(conn: &Connection) -> Result<()> {
+    ///     let stmt = conn.prepare("SELECT * FROM test WHERE name = :example")?;
+    ///     let index = stmt.parameter_name(1);
+    ///     assert_eq!(index, Some(":example"));
+    ///     Ok(())
+    /// }
+    /// ```
+    ///
+    /// # Failure
+    ///
+    /// Will return `None` if the column index is out of bounds or if the
+    /// parameter is positional.
+    #[inline]
+    pub fn parameter_name(&self, index: usize) -> Option<&'_ str> {
+        self.stmt.bind_parameter_name(index as i32).map(|name| {
+            str::from_utf8(name.to_bytes()).expect("Invalid UTF-8 sequence in parameter name")
+        })
+    }
+
+    #[inline]
+    pub(crate) fn bind_parameters<P>(&mut self, params: P) -> Result<()>
+    where
+        P: IntoIterator,
+        P::Item: ToSql,
+    {
+        let expected = self.stmt.bind_parameter_count();
+        let mut index = 0;
+        for p in params.into_iter() {
+            index += 1; // The leftmost SQL parameter has an index of 1.
+            if index > expected {
+                break;
+            }
+            self.bind_parameter(&p, index)?;
+        }
+        if index != expected {
+            Err(Error::InvalidParameterCount(index, expected))
+        } else {
+            Ok(())
+        }
+    }
+
+    #[inline]
+    pub(crate) fn ensure_parameter_count(&self, n: usize) -> Result<()> {
+        let count = self.parameter_count();
+        if count != n {
+            Err(Error::InvalidParameterCount(n, count))
+        } else {
+            Ok(())
+        }
+    }
+
+    #[inline]
+    pub(crate) fn bind_parameters_named<T: ?Sized + ToSql>(
+        &mut self,
+        params: &[(&str, &T)],
+    ) -> Result<()> {
+        for &(name, value) in params {
+            if let Some(i) = self.parameter_index(name)? {
+                let ts: &dyn ToSql = &value;
+                self.bind_parameter(ts, i)?;
+            } else {
+                return Err(Error::InvalidParameterName(name.into()));
+            }
+        }
+        Ok(())
+    }
+
+    /// Return the number of parameters that can be bound to this statement.
+    #[inline]
+    pub fn parameter_count(&self) -> usize {
+        self.stmt.bind_parameter_count()
+    }
+
+    /// Low level API to directly bind a parameter to a given index.
+    ///
+    /// Note that the index is one-based, that is, the first parameter index is
+    /// 1 and not 0. This is consistent with the SQLite API and the values given
+    /// to parameters bound as `?NNN`.
+    ///
+    /// The valid values for `one_based_col_index` begin at `1`, and end at
+    /// [`Statement::parameter_count`], inclusive.
+    ///
+    /// # Caveats
+    ///
+    /// This should not generally be used, but is available for special cases
+    /// such as:
+    ///
+    /// - binding parameters where a gap exists.
+    /// - binding named and positional parameters in the same query.
+    /// - separating parameter binding from query execution.
+    ///
+    /// In general, statements that have had *any* parameters bound this way
+    /// should have *all* parameters bound this way, and be queried or executed
+    /// by [`Statement::raw_query`] or [`Statement::raw_execute`], other usage
+    /// is unsupported and will likely, probably in surprising ways.
+    ///
+    /// That is: Do not mix the "raw" statement functions with the rest of the
+    /// API, or the results may be surprising, and may even change in future
+    /// versions without comment.
+    ///
+    /// # Example
+    ///
+    /// ```rust,no_run
+    /// # use rusqlite::{Connection, Result};
+    /// fn query(conn: &Connection) -> Result<()> {
+    ///     let mut stmt = conn.prepare("SELECT * FROM test WHERE name = :name AND value > ?2")?;
+    ///     let name_index = stmt.parameter_index(":name")?.expect("No such parameter");
+    ///     stmt.raw_bind_parameter(name_index, "foo")?;
+    ///     stmt.raw_bind_parameter(2, 100)?;
+    ///     let mut rows = stmt.raw_query();
+    ///     while let Some(row) = rows.next()? {
+    ///         // ...
+    ///     }
+    ///     Ok(())
+    /// }
+    /// ```
+    #[inline]
+    pub fn raw_bind_parameter<T: ToSql>(
+        &mut self,
+        one_based_col_index: usize,
+        param: T,
+    ) -> Result<()> {
+        // This is the same as `bind_parameter` but slightly more ergonomic and
+        // correctly takes `&mut self`.
+        self.bind_parameter(&param, one_based_col_index)
+    }
+
+    /// Low level API to execute a statement given that all parameters were
+    /// bound explicitly with the [`Statement::raw_bind_parameter`] API.
+    ///
+    /// # Caveats
+    ///
+    /// Any unbound parameters will have `NULL` as their value.
+    ///
+    /// This should not generally be used outside of special cases, and
+    /// functions in the [`Statement::execute`] family should be preferred.
+    ///
+    /// # Failure
+    ///
+    /// Will return `Err` if the executed statement returns rows (in which case
+    /// `query` should be used instead), or the underlying SQLite call fails.
+    #[inline]
+    pub fn raw_execute(&mut self) -> Result<usize> {
+        self.execute_with_bound_parameters()
+    }
+
+    /// Low level API to get `Rows` for this query given that all parameters
+    /// were bound explicitly with the [`Statement::raw_bind_parameter`] API.
+    ///
+    /// # Caveats
+    ///
+    /// Any unbound parameters will have `NULL` as their value.
+    ///
+    /// This should not generally be used outside of special cases, and
+    /// functions in the [`Statement::query`] family should be preferred.
+    ///
+    /// Note that if the SQL does not return results, [`Statement::raw_execute`]
+    /// should be used instead.
+    #[inline]
+    pub fn raw_query(&mut self) -> Rows<'_> {
+        Rows::new(self)
+    }
+
+    // generic because many of these branches can constant fold away.
+    fn bind_parameter<P: ?Sized + ToSql>(&self, param: &P, col: usize) -> Result<()> {
+        let value = param.to_sql()?;
+
+        let ptr = unsafe { self.stmt.ptr() };
+        let value = match value {
+            ToSqlOutput::Borrowed(v) => v,
+            ToSqlOutput::Owned(ref v) => ValueRef::from(v),
+
+            #[cfg(feature = "blob")]
+            ToSqlOutput::ZeroBlob(len) => {
+                // TODO sqlite3_bind_zeroblob64 // 3.8.11
+                return self
+                    .conn
+                    .decode_result(unsafe { ffi::sqlite3_bind_zeroblob(ptr, col as c_int, len) });
+            }
+            #[cfg(feature = "array")]
+            ToSqlOutput::Array(a) => {
+                return self.conn.decode_result(unsafe {
+                    ffi::sqlite3_bind_pointer(
+                        ptr,
+                        col as c_int,
+                        Rc::into_raw(a) as *mut c_void,
+                        ARRAY_TYPE,
+                        Some(free_array),
+                    )
+                });
+            }
+        };
+        self.conn.decode_result(match value {
+            ValueRef::Null => unsafe { ffi::sqlite3_bind_null(ptr, col as c_int) },
+            ValueRef::Integer(i) => unsafe { ffi::sqlite3_bind_int64(ptr, col as c_int, i) },
+            ValueRef::Real(r) => unsafe { ffi::sqlite3_bind_double(ptr, col as c_int, r) },
+            ValueRef::Text(s) => unsafe {
+                let (c_str, len, destructor) = str_for_sqlite(s)?;
+                // TODO sqlite3_bind_text64 // 3.8.7
+                ffi::sqlite3_bind_text(ptr, col as c_int, c_str, len, destructor)
+            },
+            ValueRef::Blob(b) => unsafe {
+                let length = len_as_c_int(b.len())?;
+                if length == 0 {
+                    ffi::sqlite3_bind_zeroblob(ptr, col as c_int, 0)
+                } else {
+                    // TODO sqlite3_bind_blob64 // 3.8.7
+                    ffi::sqlite3_bind_blob(
+                        ptr,
+                        col as c_int,
+                        b.as_ptr().cast::<c_void>(),
+                        length,
+                        ffi::SQLITE_TRANSIENT(),
+                    )
+                }
+            },
+        })
+    }
+
+    #[inline]
+    fn execute_with_bound_parameters(&mut self) -> Result<usize> {
+        self.check_update()?;
+        let r = self.stmt.step();
+        self.stmt.reset();
+        match r {
+            ffi::SQLITE_DONE => Ok(self.conn.changes() as usize),
+            ffi::SQLITE_ROW => Err(Error::ExecuteReturnedResults),
+            _ => Err(self.conn.decode_result(r).unwrap_err()),
+        }
+    }
+
+    #[inline]
+    fn finalize_(&mut self) -> Result<()> {
+        let mut stmt = unsafe { RawStatement::new(ptr::null_mut(), 0) };
+        mem::swap(&mut stmt, &mut self.stmt);
+        self.conn.decode_result(stmt.finalize())
+    }
+
+    #[cfg(feature = "extra_check")]
+    #[inline]
+    fn check_update(&self) -> Result<()> {
+        // sqlite3_column_count works for DML but not for DDL (ie ALTER)
+        if self.column_count() > 0 && self.stmt.readonly() {
+            return Err(Error::ExecuteReturnedResults);
+        }
+        Ok(())
+    }
+
+    #[cfg(not(feature = "extra_check"))]
+    #[inline]
+    #[allow(clippy::unnecessary_wraps)]
+    fn check_update(&self) -> Result<()> {
+        Ok(())
+    }
+
+    /// Returns a string containing the SQL text of prepared statement with
+    /// bound parameters expanded.
+    pub fn expanded_sql(&self) -> Option<String> {
+        self.stmt
+            .expanded_sql()
+            .map(|s| s.to_string_lossy().to_string())
+    }
+
+    /// Get the value for one of the status counters for this statement.
+    #[inline]
+    pub fn get_status(&self, status: StatementStatus) -> i32 {
+        self.stmt.get_status(status, false)
+    }
+
+    /// Reset the value of one of the status counters for this statement,
+    #[inline]
+    /// returning the value it had before resetting.
+    pub fn reset_status(&self, status: StatementStatus) -> i32 {
+        self.stmt.get_status(status, true)
+    }
+
+    /// Returns 1 if the prepared statement is an EXPLAIN statement,
+    /// or 2 if the statement is an EXPLAIN QUERY PLAN,
+    /// or 0 if it is an ordinary statement or a NULL pointer.
+    #[inline]
+    #[cfg(feature = "modern_sqlite")] // 3.28.0
+    #[cfg_attr(docsrs, doc(cfg(feature = "modern_sqlite")))]
+    pub fn is_explain(&self) -> i32 {
+        self.stmt.is_explain()
+    }
+
+    /// Returns true if the statement is read only.
+    #[inline]
+    pub fn readonly(&self) -> bool {
+        self.stmt.readonly()
+    }
+
+    #[cfg(feature = "extra_check")]
+    #[inline]
+    pub(crate) fn check_no_tail(&self) -> Result<()> {
+        if self.stmt.has_tail() {
+            Err(Error::MultipleStatement)
+        } else {
+            Ok(())
+        }
+    }
+
+    #[cfg(not(feature = "extra_check"))]
+    #[inline]
+    #[allow(clippy::unnecessary_wraps)]
+    pub(crate) fn check_no_tail(&self) -> Result<()> {
+        Ok(())
+    }
+
+    /// Safety: This is unsafe, because using `sqlite3_stmt` after the
+    /// connection has closed is illegal, but `RawStatement` does not enforce
+    /// this, as it loses our protective `'conn` lifetime bound.
+    #[inline]
+    pub(crate) unsafe fn into_raw(mut self) -> RawStatement {
+        let mut stmt = RawStatement::new(ptr::null_mut(), 0);
+        mem::swap(&mut stmt, &mut self.stmt);
+        stmt
+    }
+
+    /// Reset all bindings
+    pub fn clear_bindings(&mut self) {
+        self.stmt.clear_bindings()
+    }
+}
+
+impl fmt::Debug for Statement<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let sql = if self.stmt.is_null() {
+            Ok("")
+        } else {
+            str::from_utf8(self.stmt.sql().unwrap().to_bytes())
+        };
+        f.debug_struct("Statement")
+            .field("conn", self.conn)
+            .field("stmt", &self.stmt)
+            .field("sql", &sql)
+            .finish()
+    }
+}
+
+impl Drop for Statement<'_> {
+    #[allow(unused_must_use)]
+    #[inline]
+    fn drop(&mut self) {
+        self.finalize_();
+    }
+}
+
+impl Statement<'_> {
+    #[inline]
+    pub(super) fn new(conn: &Connection, stmt: RawStatement) -> Statement<'_> {
+        Statement { conn, stmt }
+    }
+
+    pub(super) fn value_ref(&self, col: usize) -> ValueRef<'_> {
+        let raw = unsafe { self.stmt.ptr() };
+
+        match self.stmt.column_type(col) {
+            ffi::SQLITE_NULL => ValueRef::Null,
+            ffi::SQLITE_INTEGER => {
+                ValueRef::Integer(unsafe { ffi::sqlite3_column_int64(raw, col as c_int) })
+            }
+            ffi::SQLITE_FLOAT => {
+                ValueRef::Real(unsafe { ffi::sqlite3_column_double(raw, col as c_int) })
+            }
+            ffi::SQLITE_TEXT => {
+                let s = unsafe {
+                    // Quoting from "Using SQLite" book:
+                    // To avoid problems, an application should first extract the desired type using
+                    // a sqlite3_column_xxx() function, and then call the
+                    // appropriate sqlite3_column_bytes() function.
+                    let text = ffi::sqlite3_column_text(raw, col as c_int);
+                    let len = ffi::sqlite3_column_bytes(raw, col as c_int);
+                    assert!(
+                        !text.is_null(),
+                        "unexpected SQLITE_TEXT column type with NULL data"
+                    );
+                    from_raw_parts(text.cast::<u8>(), len as usize)
+                };
+
+                ValueRef::Text(s)
+            }
+            ffi::SQLITE_BLOB => {
+                let (blob, len) = unsafe {
+                    (
+                        ffi::sqlite3_column_blob(raw, col as c_int),
+                        ffi::sqlite3_column_bytes(raw, col as c_int),
+                    )
+                };
+
+                assert!(
+                    len >= 0,
+                    "unexpected negative return from sqlite3_column_bytes"
+                );
+                if len > 0 {
+                    assert!(
+                        !blob.is_null(),
+                        "unexpected SQLITE_BLOB column type with NULL data"
+                    );
+                    ValueRef::Blob(unsafe { from_raw_parts(blob.cast::<u8>(), len as usize) })
+                } else {
+                    // The return value from sqlite3_column_blob() for a zero-length BLOB
+                    // is a NULL pointer.
+                    ValueRef::Blob(&[])
+                }
+            }
+            _ => unreachable!("sqlite3_column_type returned invalid value"),
+        }
+    }
+
+    #[inline]
+    pub(super) fn step(&self) -> Result<bool> {
+        match self.stmt.step() {
+            ffi::SQLITE_ROW => Ok(true),
+            ffi::SQLITE_DONE => Ok(false),
+            code => Err(self.conn.decode_result(code).unwrap_err()),
+        }
+    }
+
+    #[inline]
+    pub(super) fn reset(&self) -> c_int {
+        self.stmt.reset()
+    }
+}
+
+/// Prepared statement status counters.
+///
+/// See `https://www.sqlite.org/c3ref/c_stmtstatus_counter.html`
+/// for explanations of each.
+///
+/// Note that depending on your version of SQLite, all of these
+/// may not be available.
+#[repr(i32)]
+#[derive(Clone, Copy, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum StatementStatus {
+    /// Equivalent to SQLITE_STMTSTATUS_FULLSCAN_STEP
+    FullscanStep = 1,
+    /// Equivalent to SQLITE_STMTSTATUS_SORT
+    Sort = 2,
+    /// Equivalent to SQLITE_STMTSTATUS_AUTOINDEX
+    AutoIndex = 3,
+    /// Equivalent to SQLITE_STMTSTATUS_VM_STEP
+    VmStep = 4,
+    /// Equivalent to SQLITE_STMTSTATUS_REPREPARE (3.20.0)
+    RePrepare = 5,
+    /// Equivalent to SQLITE_STMTSTATUS_RUN (3.20.0)
+    Run = 6,
+    /// Equivalent to SQLITE_STMTSTATUS_FILTER_MISS
+    FilterMiss = 7,
+    /// Equivalent to SQLITE_STMTSTATUS_FILTER_HIT
+    FilterHit = 8,
+    /// Equivalent to SQLITE_STMTSTATUS_MEMUSED (3.20.0)
+    MemUsed = 99,
+}
+
+#[cfg(test)]
+mod test {
+    use crate::types::ToSql;
+    use crate::{params_from_iter, Connection, Error, Result};
+
+    #[test]
+    fn test_execute_named() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        db.execute_batch("CREATE TABLE foo(x INTEGER)")?;
+
+        assert_eq!(
+            db.execute("INSERT INTO foo(x) VALUES (:x)", &[(":x", &1i32)])?,
+            1
+        );
+        assert_eq!(
+            db.execute("INSERT INTO foo(x) VALUES (:x)", &[(":x", &2i32)])?,
+            1
+        );
+        assert_eq!(
+            db.execute(
+                "INSERT INTO foo(x) VALUES (:x)",
+                crate::named_params! {":x": 3i32}
+            )?,
+            1
+        );
+
+        assert_eq!(
+            6i32,
+            db.query_row::<i32, _, _>(
+                "SELECT SUM(x) FROM foo WHERE x > :x",
+                &[(":x", &0i32)],
+                |r| r.get(0)
+            )?
+        );
+        assert_eq!(
+            5i32,
+            db.query_row::<i32, _, _>(
+                "SELECT SUM(x) FROM foo WHERE x > :x",
+                &[(":x", &1i32)],
+                |r| r.get(0)
+            )?
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_stmt_execute_named() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        let sql = "CREATE TABLE test (id INTEGER PRIMARY KEY NOT NULL, name TEXT NOT NULL, flag \
+                   INTEGER)";
+        db.execute_batch(sql)?;
+
+        let mut stmt = db.prepare("INSERT INTO test (name) VALUES (:name)")?;
+        stmt.execute(&[(":name", &"one")])?;
+
+        let mut stmt = db.prepare("SELECT COUNT(*) FROM test WHERE name = :name")?;
+        assert_eq!(
+            1i32,
+            stmt.query_row::<i32, _, _>(&[(":name", "one")], |r| r.get(0))?
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_query_named() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        let sql = r#"
+        CREATE TABLE test (id INTEGER PRIMARY KEY NOT NULL, name TEXT NOT NULL, flag INTEGER);
+        INSERT INTO test(id, name) VALUES (1, "one");
+        "#;
+        db.execute_batch(sql)?;
+
+        let mut stmt = db.prepare("SELECT id FROM test where name = :name")?;
+        let mut rows = stmt.query(&[(":name", "one")])?;
+        let id: Result<i32> = rows.next()?.unwrap().get(0);
+        assert_eq!(Ok(1), id);
+        Ok(())
+    }
+
+    #[test]
+    fn test_query_map_named() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        let sql = r#"
+        CREATE TABLE test (id INTEGER PRIMARY KEY NOT NULL, name TEXT NOT NULL, flag INTEGER);
+        INSERT INTO test(id, name) VALUES (1, "one");
+        "#;
+        db.execute_batch(sql)?;
+
+        let mut stmt = db.prepare("SELECT id FROM test where name = :name")?;
+        let mut rows = stmt.query_map(&[(":name", "one")], |row| {
+            let id: Result<i32> = row.get(0);
+            id.map(|i| 2 * i)
+        })?;
+
+        let doubled_id: i32 = rows.next().unwrap()?;
+        assert_eq!(2, doubled_id);
+        Ok(())
+    }
+
+    #[test]
+    fn test_query_and_then_by_name() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        let sql = r#"
+        CREATE TABLE test (id INTEGER PRIMARY KEY NOT NULL, name TEXT NOT NULL, flag INTEGER);
+        INSERT INTO test(id, name) VALUES (1, "one");
+        INSERT INTO test(id, name) VALUES (2, "one");
+        "#;
+        db.execute_batch(sql)?;
+
+        let mut stmt = db.prepare("SELECT id FROM test where name = :name ORDER BY id ASC")?;
+        let mut rows = stmt.query_and_then(&[(":name", "one")], |row| {
+            let id: i32 = row.get(0)?;
+            if id == 1 {
+                Ok(id)
+            } else {
+                Err(Error::SqliteSingleThreadedMode)
+            }
+        })?;
+
+        // first row should be Ok
+        let doubled_id: i32 = rows.next().unwrap()?;
+        assert_eq!(1, doubled_id);
+
+        // second row should be Err
+        #[allow(clippy::match_wild_err_arm)]
+        match rows.next().unwrap() {
+            Ok(_) => panic!("invalid Ok"),
+            Err(Error::SqliteSingleThreadedMode) => (),
+            Err(_) => panic!("invalid Err"),
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn test_unbound_parameters_are_null() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        let sql = "CREATE TABLE test (x TEXT, y TEXT)";
+        db.execute_batch(sql)?;
+
+        let mut stmt = db.prepare("INSERT INTO test (x, y) VALUES (:x, :y)")?;
+        stmt.execute(&[(":x", &"one")])?;
+
+        let result: Option<String> = db.one_column("SELECT y FROM test WHERE x = 'one'")?;
+        assert!(result.is_none());
+        Ok(())
+    }
+
+    #[test]
+    fn test_raw_binding() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        db.execute_batch("CREATE TABLE test (name TEXT, value INTEGER)")?;
+        {
+            let mut stmt = db.prepare("INSERT INTO test (name, value) VALUES (:name, ?3)")?;
+
+            let name_idx = stmt.parameter_index(":name")?.unwrap();
+            stmt.raw_bind_parameter(name_idx, "example")?;
+            stmt.raw_bind_parameter(3, 50i32)?;
+            let n = stmt.raw_execute()?;
+            assert_eq!(n, 1);
+        }
+
+        {
+            let mut stmt = db.prepare("SELECT name, value FROM test WHERE value = ?2")?;
+            stmt.raw_bind_parameter(2, 50)?;
+            let mut rows = stmt.raw_query();
+            {
+                let row = rows.next()?.unwrap();
+                let name: String = row.get(0)?;
+                assert_eq!(name, "example");
+                let value: i32 = row.get(1)?;
+                assert_eq!(value, 50);
+            }
+            assert!(rows.next()?.is_none());
+        }
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_unbound_parameters_are_reused() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        let sql = "CREATE TABLE test (x TEXT, y TEXT)";
+        db.execute_batch(sql)?;
+
+        let mut stmt = db.prepare("INSERT INTO test (x, y) VALUES (:x, :y)")?;
+        stmt.execute(&[(":x", "one")])?;
+        stmt.execute(&[(":y", "two")])?;
+
+        let result: String = db.one_column("SELECT x FROM test WHERE y = 'two'")?;
+        assert_eq!(result, "one");
+        Ok(())
+    }
+
+    #[test]
+    fn test_insert() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        db.execute_batch("CREATE TABLE foo(x INTEGER UNIQUE)")?;
+        let mut stmt = db.prepare("INSERT OR IGNORE INTO foo (x) VALUES (?1)")?;
+        assert_eq!(stmt.insert([1i32])?, 1);
+        assert_eq!(stmt.insert([2i32])?, 2);
+        match stmt.insert([1i32]).unwrap_err() {
+            Error::StatementChangedRows(0) => (),
+            err => panic!("Unexpected error {}", err),
+        }
+        let mut multi = db.prepare("INSERT INTO foo (x) SELECT 3 UNION ALL SELECT 4")?;
+        match multi.insert([]).unwrap_err() {
+            Error::StatementChangedRows(2) => (),
+            err => panic!("Unexpected error {}", err),
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn test_insert_different_tables() -> Result<()> {
+        // Test for https://github.com/rusqlite/rusqlite/issues/171
+        let db = Connection::open_in_memory()?;
+        db.execute_batch(
+            r"
+            CREATE TABLE foo(x INTEGER);
+            CREATE TABLE bar(x INTEGER);
+        ",
+        )?;
+
+        assert_eq!(db.prepare("INSERT INTO foo VALUES (10)")?.insert([])?, 1);
+        assert_eq!(db.prepare("INSERT INTO bar VALUES (10)")?.insert([])?, 1);
+        Ok(())
+    }
+
+    #[test]
+    fn test_exists() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        let sql = "BEGIN;
+                   CREATE TABLE foo(x INTEGER);
+                   INSERT INTO foo VALUES(1);
+                   INSERT INTO foo VALUES(2);
+                   END;";
+        db.execute_batch(sql)?;
+        let mut stmt = db.prepare("SELECT 1 FROM foo WHERE x = ?1")?;
+        assert!(stmt.exists([1i32])?);
+        assert!(stmt.exists([2i32])?);
+        assert!(!stmt.exists([0i32])?);
+        Ok(())
+    }
+    #[test]
+    fn test_tuple_params() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        let s = db.query_row("SELECT printf('[%s]', ?1)", ("abc",), |r| {
+            r.get::<_, String>(0)
+        })?;
+        assert_eq!(s, "[abc]");
+        let s = db.query_row(
+            "SELECT printf('%d %s %d', ?1, ?2, ?3)",
+            (1i32, "abc", 2i32),
+            |r| r.get::<_, String>(0),
+        )?;
+        assert_eq!(s, "1 abc 2");
+        let s = db.query_row(
+            "SELECT printf('%d %s %d %d', ?1, ?2, ?3, ?4)",
+            (1, "abc", 2i32, 4i64),
+            |r| r.get::<_, String>(0),
+        )?;
+        assert_eq!(s, "1 abc 2 4");
+        #[rustfmt::skip]
+        let bigtup = (
+            0, "a", 1, "b", 2, "c", 3, "d",
+            4, "e", 5, "f", 6, "g", 7, "h",
+        );
+        let query = "SELECT printf(
+            '%d %s | %d %s | %d %s | %d %s || %d %s | %d %s | %d %s | %d %s',
+            ?1, ?2, ?3, ?4,
+            ?5, ?6, ?7, ?8,
+            ?9, ?10, ?11, ?12,
+            ?13, ?14, ?15, ?16
+        )";
+        let s = db.query_row(query, bigtup, |r| r.get::<_, String>(0))?;
+        assert_eq!(s, "0 a | 1 b | 2 c | 3 d || 4 e | 5 f | 6 g | 7 h");
+        Ok(())
+    }
+
+    #[test]
+    fn test_query_row() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        let sql = "BEGIN;
+                   CREATE TABLE foo(x INTEGER, y INTEGER);
+                   INSERT INTO foo VALUES(1, 3);
+                   INSERT INTO foo VALUES(2, 4);
+                   END;";
+        db.execute_batch(sql)?;
+        let mut stmt = db.prepare("SELECT y FROM foo WHERE x = ?1")?;
+        let y: Result<i64> = stmt.query_row([1i32], |r| r.get(0));
+        assert_eq!(3i64, y?);
+        Ok(())
+    }
+
+    #[test]
+    fn test_query_by_column_name() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        let sql = "BEGIN;
+                   CREATE TABLE foo(x INTEGER, y INTEGER);
+                   INSERT INTO foo VALUES(1, 3);
+                   END;";
+        db.execute_batch(sql)?;
+        let mut stmt = db.prepare("SELECT y FROM foo")?;
+        let y: Result<i64> = stmt.query_row([], |r| r.get("y"));
+        assert_eq!(3i64, y?);
+        Ok(())
+    }
+
+    #[test]
+    fn test_query_by_column_name_ignore_case() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        let sql = "BEGIN;
+                   CREATE TABLE foo(x INTEGER, y INTEGER);
+                   INSERT INTO foo VALUES(1, 3);
+                   END;";
+        db.execute_batch(sql)?;
+        let mut stmt = db.prepare("SELECT y as Y FROM foo")?;
+        let y: Result<i64> = stmt.query_row([], |r| r.get("y"));
+        assert_eq!(3i64, y?);
+        Ok(())
+    }
+
+    #[test]
+    fn test_expanded_sql() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        let stmt = db.prepare("SELECT ?1")?;
+        stmt.bind_parameter(&1, 1)?;
+        assert_eq!(Some("SELECT 1".to_owned()), stmt.expanded_sql());
+        Ok(())
+    }
+
+    #[test]
+    fn test_bind_parameters() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        // dynamic slice:
+        db.query_row(
+            "SELECT ?1, ?2, ?3",
+            [&1u8 as &dyn ToSql, &"one", &Some("one")],
+            |row| row.get::<_, u8>(0),
+        )?;
+        // existing collection:
+        let data = vec![1, 2, 3];
+        db.query_row("SELECT ?1, ?2, ?3", params_from_iter(&data), |row| {
+            row.get::<_, u8>(0)
+        })?;
+        db.query_row(
+            "SELECT ?1, ?2, ?3",
+            params_from_iter(data.as_slice()),
+            |row| row.get::<_, u8>(0),
+        )?;
+        db.query_row("SELECT ?1, ?2, ?3", params_from_iter(data), |row| {
+            row.get::<_, u8>(0)
+        })?;
+
+        use std::collections::BTreeSet;
+        let data: BTreeSet<String> = ["one", "two", "three"]
+            .iter()
+            .map(|s| (*s).to_string())
+            .collect();
+        db.query_row("SELECT ?1, ?2, ?3", params_from_iter(&data), |row| {
+            row.get::<_, String>(0)
+        })?;
+
+        let data = [0; 3];
+        db.query_row("SELECT ?1, ?2, ?3", params_from_iter(&data), |row| {
+            row.get::<_, u8>(0)
+        })?;
+        db.query_row("SELECT ?1, ?2, ?3", params_from_iter(data.iter()), |row| {
+            row.get::<_, u8>(0)
+        })?;
+        Ok(())
+    }
+
+    #[test]
+    fn test_parameter_name() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        db.execute_batch("CREATE TABLE test (name TEXT, value INTEGER)")?;
+        let stmt = db.prepare("INSERT INTO test (name, value) VALUES (:name, ?3)")?;
+        assert_eq!(stmt.parameter_name(0), None);
+        assert_eq!(stmt.parameter_name(1), Some(":name"));
+        assert_eq!(stmt.parameter_name(2), None);
+        Ok(())
+    }
+
+    #[test]
+    fn test_empty_stmt() -> Result<()> {
+        let conn = Connection::open_in_memory()?;
+        let mut stmt = conn.prepare("")?;
+        assert_eq!(0, stmt.column_count());
+        stmt.parameter_index("test").unwrap();
+        stmt.step().unwrap_err();
+        stmt.reset();
+        stmt.execute([]).unwrap_err();
+        Ok(())
+    }
+
+    #[test]
+    fn test_comment_stmt() -> Result<()> {
+        let conn = Connection::open_in_memory()?;
+        conn.prepare("/*SELECT 1;*/")?;
+        Ok(())
+    }
+
+    #[test]
+    fn test_comment_and_sql_stmt() -> Result<()> {
+        let conn = Connection::open_in_memory()?;
+        let stmt = conn.prepare("/*...*/ SELECT 1;")?;
+        assert_eq!(1, stmt.column_count());
+        Ok(())
+    }
+
+    #[test]
+    fn test_semi_colon_stmt() -> Result<()> {
+        let conn = Connection::open_in_memory()?;
+        let stmt = conn.prepare(";")?;
+        assert_eq!(0, stmt.column_count());
+        Ok(())
+    }
+
+    #[test]
+    fn test_utf16_conversion() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        db.pragma_update(None, "encoding", "UTF-16le")?;
+        let encoding: String = db.pragma_query_value(None, "encoding", |row| row.get(0))?;
+        assert_eq!("UTF-16le", encoding);
+        db.execute_batch("CREATE TABLE foo(x TEXT)")?;
+        let expected = "テスト";
+        db.execute("INSERT INTO foo(x) VALUES (?1)", [&expected])?;
+        let actual: String = db.one_column("SELECT x FROM foo")?;
+        assert_eq!(expected, actual);
+        Ok(())
+    }
+
+    #[test]
+    fn test_nul_byte() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        let expected = "a\x00b";
+        let actual: String = db.query_row("SELECT ?1", [expected], |row| row.get(0))?;
+        assert_eq!(expected, actual);
+        Ok(())
+    }
+
+    #[test]
+    #[cfg(feature = "modern_sqlite")]
+    fn is_explain() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        let stmt = db.prepare("SELECT 1;")?;
+        assert_eq!(0, stmt.is_explain());
+        Ok(())
+    }
+
+    #[test]
+    fn readonly() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        let stmt = db.prepare("SELECT 1;")?;
+        assert!(stmt.readonly());
+        Ok(())
+    }
+
+    #[test]
+    #[cfg(feature = "modern_sqlite")] // SQLite >= 3.38.0
+    fn test_error_offset() -> Result<()> {
+        use crate::ffi::ErrorCode;
+        let db = Connection::open_in_memory()?;
+        let r = db.execute_batch("SELECT CURRENT_TIMESTANP;");
+        match r.unwrap_err() {
+            Error::SqlInputError { error, offset, .. } => {
+                assert_eq!(error.code, ErrorCode::Unknown);
+                assert_eq!(offset, 7);
+            }
+            err => panic!("Unexpected error {}", err),
+        }
+        Ok(())
+    }
+}
diff --git a/crates/rusqlite/src/trace.rs b/crates/rusqlite/src/trace.rs
new file mode 100644
index 0000000..ce4c80b
--- /dev/null
+++ b/crates/rusqlite/src/trace.rs
@@ -0,0 +1,184 @@
+//! Tracing and profiling functions. Error and warning log.
+
+use std::ffi::{CStr, CString};
+use std::mem;
+use std::os::raw::{c_char, c_int, c_void};
+use std::panic::catch_unwind;
+use std::ptr;
+use std::time::Duration;
+
+use super::ffi;
+use crate::error::error_from_sqlite_code;
+use crate::{Connection, Result};
+
+/// Set up the process-wide SQLite error logging callback.
+///
+/// # Safety
+///
+/// This function is marked unsafe for two reasons:
+///
+/// * The function is not threadsafe. No other SQLite calls may be made while
+///   `config_log` is running, and multiple threads may not call `config_log`
+///   simultaneously.
+/// * The provided `callback` itself function has two requirements:
+///     * It must not invoke any SQLite calls.
+///     * It must be threadsafe if SQLite is used in a multithreaded way.
+///
+/// cf [The Error And Warning Log](http://sqlite.org/errlog.html).
+pub unsafe fn config_log(callback: Option<fn(c_int, &str)>) -> Result<()> {
+    extern "C" fn log_callback(p_arg: *mut c_void, err: c_int, msg: *const c_char) {
+        let c_slice = unsafe { CStr::from_ptr(msg).to_bytes() };
+        let callback: fn(c_int, &str) = unsafe { mem::transmute(p_arg) };
+
+        let s = String::from_utf8_lossy(c_slice);
+        drop(catch_unwind(|| callback(err, &s)));
+    }
+
+    let rc = if let Some(f) = callback {
+        ffi::sqlite3_config(
+            ffi::SQLITE_CONFIG_LOG,
+            log_callback as extern "C" fn(_, _, _),
+            f as *mut c_void,
+        )
+    } else {
+        let nullptr: *mut c_void = ptr::null_mut();
+        ffi::sqlite3_config(ffi::SQLITE_CONFIG_LOG, nullptr, nullptr)
+    };
+
+    if rc == ffi::SQLITE_OK {
+        Ok(())
+    } else {
+        Err(error_from_sqlite_code(rc, None))
+    }
+}
+
+/// Write a message into the error log established by
+/// `config_log`.
+#[inline]
+pub fn log(err_code: c_int, msg: &str) {
+    let msg = CString::new(msg).expect("SQLite log messages cannot contain embedded zeroes");
+    unsafe {
+        ffi::sqlite3_log(err_code, b"%s\0" as *const _ as *const c_char, msg.as_ptr());
+    }
+}
+
+impl Connection {
+    /// Register or clear a callback function that can be
+    /// used for tracing the execution of SQL statements.
+    ///
+    /// Prepared statement placeholders are replaced/logged with their assigned
+    /// values. There can only be a single tracer defined for each database
+    /// connection. Setting a new tracer clears the old one.
+    pub fn trace(&mut self, trace_fn: Option<fn(&str)>) {
+        unsafe extern "C" fn trace_callback(p_arg: *mut c_void, z_sql: *const c_char) {
+            let trace_fn: fn(&str) = mem::transmute(p_arg);
+            let c_slice = CStr::from_ptr(z_sql).to_bytes();
+            let s = String::from_utf8_lossy(c_slice);
+            drop(catch_unwind(|| trace_fn(&s)));
+        }
+
+        let c = self.db.borrow_mut();
+        match trace_fn {
+            Some(f) => unsafe {
+                ffi::sqlite3_trace(c.db(), Some(trace_callback), f as *mut c_void);
+            },
+            None => unsafe {
+                ffi::sqlite3_trace(c.db(), None, ptr::null_mut());
+            },
+        }
+    }
+
+    /// Register or clear a callback function that can be
+    /// used for profiling the execution of SQL statements.
+    ///
+    /// There can only be a single profiler defined for each database
+    /// connection. Setting a new profiler clears the old one.
+    pub fn profile(&mut self, profile_fn: Option<fn(&str, Duration)>) {
+        unsafe extern "C" fn profile_callback(
+            p_arg: *mut c_void,
+            z_sql: *const c_char,
+            nanoseconds: u64,
+        ) {
+            let profile_fn: fn(&str, Duration) = mem::transmute(p_arg);
+            let c_slice = CStr::from_ptr(z_sql).to_bytes();
+            let s = String::from_utf8_lossy(c_slice);
+            const NANOS_PER_SEC: u64 = 1_000_000_000;
+
+            let duration = Duration::new(
+                nanoseconds / NANOS_PER_SEC,
+                (nanoseconds % NANOS_PER_SEC) as u32,
+            );
+            drop(catch_unwind(|| profile_fn(&s, duration)));
+        }
+
+        let c = self.db.borrow_mut();
+        match profile_fn {
+            Some(f) => unsafe {
+                ffi::sqlite3_profile(c.db(), Some(profile_callback), f as *mut c_void)
+            },
+            None => unsafe { ffi::sqlite3_profile(c.db(), None, ptr::null_mut()) },
+        };
+    }
+
+    // TODO sqlite3_trace_v2 (https://sqlite.org/c3ref/trace_v2.html) // 3.14.0, #977
+}
+
+#[cfg(test)]
+mod test {
+    use lazy_static::lazy_static;
+    use std::sync::Mutex;
+    use std::time::Duration;
+
+    use crate::{Connection, Result};
+
+    #[test]
+    fn test_trace() -> Result<()> {
+        lazy_static! {
+            static ref TRACED_STMTS: Mutex<Vec<String>> = Mutex::new(Vec::new());
+        }
+        fn tracer(s: &str) {
+            let mut traced_stmts = TRACED_STMTS.lock().unwrap();
+            traced_stmts.push(s.to_owned());
+        }
+
+        let mut db = Connection::open_in_memory()?;
+        db.trace(Some(tracer));
+        {
+            let _ = db.query_row("SELECT ?1", [1i32], |_| Ok(()));
+            let _ = db.query_row("SELECT ?1", ["hello"], |_| Ok(()));
+        }
+        db.trace(None);
+        {
+            let _ = db.query_row("SELECT ?1", [2i32], |_| Ok(()));
+            let _ = db.query_row("SELECT ?1", ["goodbye"], |_| Ok(()));
+        }
+
+        let traced_stmts = TRACED_STMTS.lock().unwrap();
+        assert_eq!(traced_stmts.len(), 2);
+        assert_eq!(traced_stmts[0], "SELECT 1");
+        assert_eq!(traced_stmts[1], "SELECT 'hello'");
+        Ok(())
+    }
+
+    #[test]
+    fn test_profile() -> Result<()> {
+        lazy_static! {
+            static ref PROFILED: Mutex<Vec<(String, Duration)>> = Mutex::new(Vec::new());
+        }
+        fn profiler(s: &str, d: Duration) {
+            let mut profiled = PROFILED.lock().unwrap();
+            profiled.push((s.to_owned(), d));
+        }
+
+        let mut db = Connection::open_in_memory()?;
+        db.profile(Some(profiler));
+        db.execute_batch("PRAGMA application_id = 1")?;
+        db.profile(None);
+        db.execute_batch("PRAGMA application_id = 2")?;
+
+        let profiled = PROFILED.lock().unwrap();
+        assert_eq!(profiled.len(), 1);
+        assert_eq!(profiled[0].0, "PRAGMA application_id = 1");
+        Ok(())
+    }
+}
diff --git a/crates/rusqlite/src/transaction.rs b/crates/rusqlite/src/transaction.rs
new file mode 100644
index 0000000..5cf26a4
--- /dev/null
+++ b/crates/rusqlite/src/transaction.rs
@@ -0,0 +1,750 @@
+use crate::{Connection, Result};
+use std::ops::Deref;
+
+/// Options for transaction behavior. See [BEGIN
+/// TRANSACTION](http://www.sqlite.org/lang_transaction.html) for details.
+#[derive(Copy, Clone)]
+#[non_exhaustive]
+pub enum TransactionBehavior {
+    /// DEFERRED means that the transaction does not actually start until the
+    /// database is first accessed.
+    Deferred,
+    /// IMMEDIATE cause the database connection to start a new write
+    /// immediately, without waiting for a writes statement.
+    Immediate,
+    /// EXCLUSIVE prevents other database connections from reading the database
+    /// while the transaction is underway.
+    Exclusive,
+}
+
+/// Options for how a Transaction or Savepoint should behave when it is dropped.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum DropBehavior {
+    /// Roll back the changes. This is the default.
+    Rollback,
+
+    /// Commit the changes.
+    Commit,
+
+    /// Do not commit or roll back changes - this will leave the transaction or
+    /// savepoint open, so should be used with care.
+    Ignore,
+
+    /// Panic. Used to enforce intentional behavior during development.
+    Panic,
+}
+
+/// Represents a transaction on a database connection.
+///
+/// ## Note
+///
+/// Transactions will roll back by default. Use `commit` method to explicitly
+/// commit the transaction, or use `set_drop_behavior` to change what happens
+/// when the transaction is dropped.
+///
+/// ## Example
+///
+/// ```rust,no_run
+/// # use rusqlite::{Connection, Result};
+/// # fn do_queries_part_1(_conn: &Connection) -> Result<()> { Ok(()) }
+/// # fn do_queries_part_2(_conn: &Connection) -> Result<()> { Ok(()) }
+/// fn perform_queries(conn: &mut Connection) -> Result<()> {
+///     let tx = conn.transaction()?;
+///
+///     do_queries_part_1(&tx)?; // tx causes rollback if this fails
+///     do_queries_part_2(&tx)?; // tx causes rollback if this fails
+///
+///     tx.commit()
+/// }
+/// ```
+#[derive(Debug)]
+pub struct Transaction<'conn> {
+    conn: &'conn Connection,
+    drop_behavior: DropBehavior,
+}
+
+/// Represents a savepoint on a database connection.
+///
+/// ## Note
+///
+/// Savepoints will roll back by default. Use `commit` method to explicitly
+/// commit the savepoint, or use `set_drop_behavior` to change what happens
+/// when the savepoint is dropped.
+///
+/// ## Example
+///
+/// ```rust,no_run
+/// # use rusqlite::{Connection, Result};
+/// # fn do_queries_part_1(_conn: &Connection) -> Result<()> { Ok(()) }
+/// # fn do_queries_part_2(_conn: &Connection) -> Result<()> { Ok(()) }
+/// fn perform_queries(conn: &mut Connection) -> Result<()> {
+///     let sp = conn.savepoint()?;
+///
+///     do_queries_part_1(&sp)?; // sp causes rollback if this fails
+///     do_queries_part_2(&sp)?; // sp causes rollback if this fails
+///
+///     sp.commit()
+/// }
+/// ```
+#[derive(Debug)]
+pub struct Savepoint<'conn> {
+    conn: &'conn Connection,
+    name: String,
+    depth: u32,
+    drop_behavior: DropBehavior,
+    committed: bool,
+}
+
+impl Transaction<'_> {
+    /// Begin a new transaction. Cannot be nested; see `savepoint` for nested
+    /// transactions.
+    ///
+    /// Even though we don't mutate the connection, we take a `&mut Connection`
+    /// so as to prevent nested transactions on the same connection. For cases
+    /// where this is unacceptable, [`Transaction::new_unchecked`] is available.
+    #[inline]
+    pub fn new(conn: &mut Connection, behavior: TransactionBehavior) -> Result<Transaction<'_>> {
+        Self::new_unchecked(conn, behavior)
+    }
+
+    /// Begin a new transaction, failing if a transaction is open.
+    ///
+    /// If a transaction is already open, this will return an error. Where
+    /// possible, [`Transaction::new`] should be preferred, as it provides a
+    /// compile-time guarantee that transactions are not nested.
+    #[inline]
+    pub fn new_unchecked(
+        conn: &Connection,
+        behavior: TransactionBehavior,
+    ) -> Result<Transaction<'_>> {
+        let query = match behavior {
+            TransactionBehavior::Deferred => "BEGIN DEFERRED",
+            TransactionBehavior::Immediate => "BEGIN IMMEDIATE",
+            TransactionBehavior::Exclusive => "BEGIN EXCLUSIVE",
+        };
+        conn.execute_batch(query).map(move |_| Transaction {
+            conn,
+            drop_behavior: DropBehavior::Rollback,
+        })
+    }
+
+    /// Starts a new [savepoint](http://www.sqlite.org/lang_savepoint.html), allowing nested
+    /// transactions.
+    ///
+    /// ## Note
+    ///
+    /// Just like outer level transactions, savepoint transactions rollback by
+    /// default.
+    ///
+    /// ## Example
+    ///
+    /// ```rust,no_run
+    /// # use rusqlite::{Connection, Result};
+    /// # fn perform_queries_part_1_succeeds(_conn: &Connection) -> bool { true }
+    /// fn perform_queries(conn: &mut Connection) -> Result<()> {
+    ///     let mut tx = conn.transaction()?;
+    ///
+    ///     {
+    ///         let sp = tx.savepoint()?;
+    ///         if perform_queries_part_1_succeeds(&sp) {
+    ///             sp.commit()?;
+    ///         }
+    ///         // otherwise, sp will rollback
+    ///     }
+    ///
+    ///     tx.commit()
+    /// }
+    /// ```
+    #[inline]
+    pub fn savepoint(&mut self) -> Result<Savepoint<'_>> {
+        Savepoint::with_depth(self.conn, 1)
+    }
+
+    /// Create a new savepoint with a custom savepoint name. See `savepoint()`.
+    #[inline]
+    pub fn savepoint_with_name<T: Into<String>>(&mut self, name: T) -> Result<Savepoint<'_>> {
+        Savepoint::with_depth_and_name(self.conn, 1, name)
+    }
+
+    /// Get the current setting for what happens to the transaction when it is
+    /// dropped.
+    #[inline]
+    #[must_use]
+    pub fn drop_behavior(&self) -> DropBehavior {
+        self.drop_behavior
+    }
+
+    /// Configure the transaction to perform the specified action when it is
+    /// dropped.
+    #[inline]
+    pub fn set_drop_behavior(&mut self, drop_behavior: DropBehavior) {
+        self.drop_behavior = drop_behavior;
+    }
+
+    /// A convenience method which consumes and commits a transaction.
+    #[inline]
+    pub fn commit(mut self) -> Result<()> {
+        self.commit_()
+    }
+
+    #[inline]
+    fn commit_(&mut self) -> Result<()> {
+        self.conn.execute_batch("COMMIT")?;
+        Ok(())
+    }
+
+    /// A convenience method which consumes and rolls back a transaction.
+    #[inline]
+    pub fn rollback(mut self) -> Result<()> {
+        self.rollback_()
+    }
+
+    #[inline]
+    fn rollback_(&mut self) -> Result<()> {
+        self.conn.execute_batch("ROLLBACK")?;
+        Ok(())
+    }
+
+    /// Consumes the transaction, committing or rolling back according to the
+    /// current setting (see `drop_behavior`).
+    ///
+    /// Functionally equivalent to the `Drop` implementation, but allows
+    /// callers to see any errors that occur.
+    #[inline]
+    pub fn finish(mut self) -> Result<()> {
+        self.finish_()
+    }
+
+    #[inline]
+    fn finish_(&mut self) -> Result<()> {
+        if self.conn.is_autocommit() {
+            return Ok(());
+        }
+        match self.drop_behavior() {
+            DropBehavior::Commit => self.commit_().or_else(|_| self.rollback_()),
+            DropBehavior::Rollback => self.rollback_(),
+            DropBehavior::Ignore => Ok(()),
+            DropBehavior::Panic => panic!("Transaction dropped unexpectedly."),
+        }
+    }
+}
+
+impl Deref for Transaction<'_> {
+    type Target = Connection;
+
+    #[inline]
+    fn deref(&self) -> &Connection {
+        self.conn
+    }
+}
+
+#[allow(unused_must_use)]
+impl Drop for Transaction<'_> {
+    #[inline]
+    fn drop(&mut self) {
+        self.finish_();
+    }
+}
+
+impl Savepoint<'_> {
+    #[inline]
+    fn with_depth_and_name<T: Into<String>>(
+        conn: &Connection,
+        depth: u32,
+        name: T,
+    ) -> Result<Savepoint<'_>> {
+        let name = name.into();
+        conn.execute_batch(&format!("SAVEPOINT {name}"))
+            .map(|_| Savepoint {
+                conn,
+                name,
+                depth,
+                drop_behavior: DropBehavior::Rollback,
+                committed: false,
+            })
+    }
+
+    #[inline]
+    fn with_depth(conn: &Connection, depth: u32) -> Result<Savepoint<'_>> {
+        let name = format!("_rusqlite_sp_{depth}");
+        Savepoint::with_depth_and_name(conn, depth, name)
+    }
+
+    /// Begin a new savepoint. Can be nested.
+    #[inline]
+    pub fn new(conn: &mut Connection) -> Result<Savepoint<'_>> {
+        Savepoint::with_depth(conn, 0)
+    }
+
+    /// Begin a new savepoint with a user-provided savepoint name.
+    #[inline]
+    pub fn with_name<T: Into<String>>(conn: &mut Connection, name: T) -> Result<Savepoint<'_>> {
+        Savepoint::with_depth_and_name(conn, 0, name)
+    }
+
+    /// Begin a nested savepoint.
+    #[inline]
+    pub fn savepoint(&mut self) -> Result<Savepoint<'_>> {
+        Savepoint::with_depth(self.conn, self.depth + 1)
+    }
+
+    /// Begin a nested savepoint with a user-provided savepoint name.
+    #[inline]
+    pub fn savepoint_with_name<T: Into<String>>(&mut self, name: T) -> Result<Savepoint<'_>> {
+        Savepoint::with_depth_and_name(self.conn, self.depth + 1, name)
+    }
+
+    /// Get the current setting for what happens to the savepoint when it is
+    /// dropped.
+    #[inline]
+    #[must_use]
+    pub fn drop_behavior(&self) -> DropBehavior {
+        self.drop_behavior
+    }
+
+    /// Configure the savepoint to perform the specified action when it is
+    /// dropped.
+    #[inline]
+    pub fn set_drop_behavior(&mut self, drop_behavior: DropBehavior) {
+        self.drop_behavior = drop_behavior;
+    }
+
+    /// A convenience method which consumes and commits a savepoint.
+    #[inline]
+    pub fn commit(mut self) -> Result<()> {
+        self.commit_()
+    }
+
+    #[inline]
+    fn commit_(&mut self) -> Result<()> {
+        self.conn.execute_batch(&format!("RELEASE {}", self.name))?;
+        self.committed = true;
+        Ok(())
+    }
+
+    /// A convenience method which rolls back a savepoint.
+    ///
+    /// ## Note
+    ///
+    /// Unlike `Transaction`s, savepoints remain active after they have been
+    /// rolled back, and can be rolled back again or committed.
+    #[inline]
+    pub fn rollback(&mut self) -> Result<()> {
+        self.conn
+            .execute_batch(&format!("ROLLBACK TO {}", self.name))
+    }
+
+    /// Consumes the savepoint, committing or rolling back according to the
+    /// current setting (see `drop_behavior`).
+    ///
+    /// Functionally equivalent to the `Drop` implementation, but allows
+    /// callers to see any errors that occur.
+    #[inline]
+    pub fn finish(mut self) -> Result<()> {
+        self.finish_()
+    }
+
+    #[inline]
+    fn finish_(&mut self) -> Result<()> {
+        if self.committed {
+            return Ok(());
+        }
+        match self.drop_behavior() {
+            DropBehavior::Commit => self.commit_().or_else(|_| self.rollback()),
+            DropBehavior::Rollback => self.rollback(),
+            DropBehavior::Ignore => Ok(()),
+            DropBehavior::Panic => panic!("Savepoint dropped unexpectedly."),
+        }
+    }
+}
+
+impl Deref for Savepoint<'_> {
+    type Target = Connection;
+
+    #[inline]
+    fn deref(&self) -> &Connection {
+        self.conn
+    }
+}
+
+#[allow(unused_must_use)]
+impl Drop for Savepoint<'_> {
+    #[inline]
+    fn drop(&mut self) {
+        self.finish_();
+    }
+}
+
+/// Transaction state of a database
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+#[cfg(feature = "modern_sqlite")] // 3.37.0
+#[cfg_attr(docsrs, doc(cfg(feature = "modern_sqlite")))]
+pub enum TransactionState {
+    /// Equivalent to SQLITE_TXN_NONE
+    None,
+    /// Equivalent to SQLITE_TXN_READ
+    Read,
+    /// Equivalent to SQLITE_TXN_WRITE
+    Write,
+}
+
+impl Connection {
+    /// Begin a new transaction with the default behavior (DEFERRED).
+    ///
+    /// The transaction defaults to rolling back when it is dropped. If you
+    /// want the transaction to commit, you must call
+    /// [`commit`](Transaction::commit) or
+    /// [`set_drop_behavior(DropBehavior::Commit)`](Transaction::set_drop_behavior).
+    ///
+    /// ## Example
+    ///
+    /// ```rust,no_run
+    /// # use rusqlite::{Connection, Result};
+    /// # fn do_queries_part_1(_conn: &Connection) -> Result<()> { Ok(()) }
+    /// # fn do_queries_part_2(_conn: &Connection) -> Result<()> { Ok(()) }
+    /// fn perform_queries(conn: &mut Connection) -> Result<()> {
+    ///     let tx = conn.transaction()?;
+    ///
+    ///     do_queries_part_1(&tx)?; // tx causes rollback if this fails
+    ///     do_queries_part_2(&tx)?; // tx causes rollback if this fails
+    ///
+    ///     tx.commit()
+    /// }
+    /// ```
+    ///
+    /// # Failure
+    ///
+    /// Will return `Err` if the underlying SQLite call fails.
+    #[inline]
+    pub fn transaction(&mut self) -> Result<Transaction<'_>> {
+        Transaction::new(self, TransactionBehavior::Deferred)
+    }
+
+    /// Begin a new transaction with a specified behavior.
+    ///
+    /// See [`transaction`](Connection::transaction).
+    ///
+    /// # Failure
+    ///
+    /// Will return `Err` if the underlying SQLite call fails.
+    #[inline]
+    pub fn transaction_with_behavior(
+        &mut self,
+        behavior: TransactionBehavior,
+    ) -> Result<Transaction<'_>> {
+        Transaction::new(self, behavior)
+    }
+
+    /// Begin a new transaction with the default behavior (DEFERRED).
+    ///
+    /// Attempt to open a nested transaction will result in a SQLite error.
+    /// `Connection::transaction` prevents this at compile time by taking `&mut
+    /// self`, but `Connection::unchecked_transaction()` may be used to defer
+    /// the checking until runtime.
+    ///
+    /// See [`Connection::transaction`] and [`Transaction::new_unchecked`]
+    /// (which can be used if the default transaction behavior is undesirable).
+    ///
+    /// ## Example
+    ///
+    /// ```rust,no_run
+    /// # use rusqlite::{Connection, Result};
+    /// # use std::rc::Rc;
+    /// # fn do_queries_part_1(_conn: &Connection) -> Result<()> { Ok(()) }
+    /// # fn do_queries_part_2(_conn: &Connection) -> Result<()> { Ok(()) }
+    /// fn perform_queries(conn: Rc<Connection>) -> Result<()> {
+    ///     let tx = conn.unchecked_transaction()?;
+    ///
+    ///     do_queries_part_1(&tx)?; // tx causes rollback if this fails
+    ///     do_queries_part_2(&tx)?; // tx causes rollback if this fails
+    ///
+    ///     tx.commit()
+    /// }
+    /// ```
+    ///
+    /// # Failure
+    ///
+    /// Will return `Err` if the underlying SQLite call fails. The specific
+    /// error returned if transactions are nested is currently unspecified.
+    pub fn unchecked_transaction(&self) -> Result<Transaction<'_>> {
+        Transaction::new_unchecked(self, TransactionBehavior::Deferred)
+    }
+
+    /// Begin a new savepoint with the default behavior (DEFERRED).
+    ///
+    /// The savepoint defaults to rolling back when it is dropped. If you want
+    /// the savepoint to commit, you must call [`commit`](Savepoint::commit) or
+    /// [`set_drop_behavior(DropBehavior::Commit)`](Savepoint::
+    /// set_drop_behavior).
+    ///
+    /// ## Example
+    ///
+    /// ```rust,no_run
+    /// # use rusqlite::{Connection, Result};
+    /// # fn do_queries_part_1(_conn: &Connection) -> Result<()> { Ok(()) }
+    /// # fn do_queries_part_2(_conn: &Connection) -> Result<()> { Ok(()) }
+    /// fn perform_queries(conn: &mut Connection) -> Result<()> {
+    ///     let sp = conn.savepoint()?;
+    ///
+    ///     do_queries_part_1(&sp)?; // sp causes rollback if this fails
+    ///     do_queries_part_2(&sp)?; // sp causes rollback if this fails
+    ///
+    ///     sp.commit()
+    /// }
+    /// ```
+    ///
+    /// # Failure
+    ///
+    /// Will return `Err` if the underlying SQLite call fails.
+    #[inline]
+    pub fn savepoint(&mut self) -> Result<Savepoint<'_>> {
+        Savepoint::new(self)
+    }
+
+    /// Begin a new savepoint with a specified name.
+    ///
+    /// See [`savepoint`](Connection::savepoint).
+    ///
+    /// # Failure
+    ///
+    /// Will return `Err` if the underlying SQLite call fails.
+    #[inline]
+    pub fn savepoint_with_name<T: Into<String>>(&mut self, name: T) -> Result<Savepoint<'_>> {
+        Savepoint::with_name(self, name)
+    }
+
+    /// Determine the transaction state of a database
+    #[cfg(feature = "modern_sqlite")] // 3.37.0
+    #[cfg_attr(docsrs, doc(cfg(feature = "modern_sqlite")))]
+    pub fn transaction_state(
+        &self,
+        db_name: Option<crate::DatabaseName<'_>>,
+    ) -> Result<TransactionState> {
+        self.db.borrow().txn_state(db_name)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::DropBehavior;
+    use crate::{Connection, Error, Result};
+
+    fn checked_memory_handle() -> Result<Connection> {
+        let db = Connection::open_in_memory()?;
+        db.execute_batch("CREATE TABLE foo (x INTEGER)")?;
+        Ok(db)
+    }
+
+    #[test]
+    fn test_drop() -> Result<()> {
+        let mut db = checked_memory_handle()?;
+        {
+            let tx = db.transaction()?;
+            tx.execute_batch("INSERT INTO foo VALUES(1)")?;
+            // default: rollback
+        }
+        {
+            let mut tx = db.transaction()?;
+            tx.execute_batch("INSERT INTO foo VALUES(2)")?;
+            tx.set_drop_behavior(DropBehavior::Commit)
+        }
+        {
+            let tx = db.transaction()?;
+            assert_eq!(2i32, tx.one_column::<i32>("SELECT SUM(x) FROM foo")?);
+        }
+        Ok(())
+    }
+    fn assert_nested_tx_error(e: Error) {
+        if let Error::SqliteFailure(e, Some(m)) = &e {
+            assert_eq!(e.extended_code, crate::ffi::SQLITE_ERROR);
+            // FIXME: Not ideal...
+            assert_eq!(e.code, crate::ErrorCode::Unknown);
+            assert!(m.contains("transaction"));
+        } else {
+            panic!("Unexpected error type: {:?}", e);
+        }
+    }
+
+    #[test]
+    fn test_unchecked_nesting() -> Result<()> {
+        let db = checked_memory_handle()?;
+
+        {
+            let tx = db.unchecked_transaction()?;
+            let e = tx.unchecked_transaction().unwrap_err();
+            assert_nested_tx_error(e);
+            // default: rollback
+        }
+        {
+            let tx = db.unchecked_transaction()?;
+            tx.execute_batch("INSERT INTO foo VALUES(1)")?;
+            // Ensure this doesn't interfere with ongoing transaction
+            let e = tx.unchecked_transaction().unwrap_err();
+            assert_nested_tx_error(e);
+
+            tx.execute_batch("INSERT INTO foo VALUES(1)")?;
+            tx.commit()?;
+        }
+
+        assert_eq!(2i32, db.one_column::<i32>("SELECT SUM(x) FROM foo")?);
+        Ok(())
+    }
+
+    #[test]
+    fn test_explicit_rollback_commit() -> Result<()> {
+        let mut db = checked_memory_handle()?;
+        {
+            let mut tx = db.transaction()?;
+            {
+                let mut sp = tx.savepoint()?;
+                sp.execute_batch("INSERT INTO foo VALUES(1)")?;
+                sp.rollback()?;
+                sp.execute_batch("INSERT INTO foo VALUES(2)")?;
+                sp.commit()?;
+            }
+            tx.commit()?;
+        }
+        {
+            let tx = db.transaction()?;
+            tx.execute_batch("INSERT INTO foo VALUES(4)")?;
+            tx.commit()?;
+        }
+        {
+            let tx = db.transaction()?;
+            assert_eq!(6i32, tx.one_column::<i32>("SELECT SUM(x) FROM foo")?);
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn test_savepoint() -> Result<()> {
+        let mut db = checked_memory_handle()?;
+        {
+            let mut tx = db.transaction()?;
+            tx.execute_batch("INSERT INTO foo VALUES(1)")?;
+            assert_current_sum(1, &tx)?;
+            tx.set_drop_behavior(DropBehavior::Commit);
+            {
+                let mut sp1 = tx.savepoint()?;
+                sp1.execute_batch("INSERT INTO foo VALUES(2)")?;
+                assert_current_sum(3, &sp1)?;
+                // will rollback sp1
+                {
+                    let mut sp2 = sp1.savepoint()?;
+                    sp2.execute_batch("INSERT INTO foo VALUES(4)")?;
+                    assert_current_sum(7, &sp2)?;
+                    // will rollback sp2
+                    {
+                        let sp3 = sp2.savepoint()?;
+                        sp3.execute_batch("INSERT INTO foo VALUES(8)")?;
+                        assert_current_sum(15, &sp3)?;
+                        sp3.commit()?;
+                        // committed sp3, but will be erased by sp2 rollback
+                    }
+                    assert_current_sum(15, &sp2)?;
+                }
+                assert_current_sum(3, &sp1)?;
+            }
+            assert_current_sum(1, &tx)?;
+        }
+        assert_current_sum(1, &db)?;
+        Ok(())
+    }
+
+    #[test]
+    fn test_ignore_drop_behavior() -> Result<()> {
+        let mut db = checked_memory_handle()?;
+
+        let mut tx = db.transaction()?;
+        {
+            let mut sp1 = tx.savepoint()?;
+            insert(1, &sp1)?;
+            sp1.rollback()?;
+            insert(2, &sp1)?;
+            {
+                let mut sp2 = sp1.savepoint()?;
+                sp2.set_drop_behavior(DropBehavior::Ignore);
+                insert(4, &sp2)?;
+            }
+            assert_current_sum(6, &sp1)?;
+            sp1.commit()?;
+        }
+        assert_current_sum(6, &tx)?;
+        Ok(())
+    }
+
+    #[test]
+    fn test_savepoint_names() -> Result<()> {
+        let mut db = checked_memory_handle()?;
+
+        {
+            let mut sp1 = db.savepoint_with_name("my_sp")?;
+            insert(1, &sp1)?;
+            assert_current_sum(1, &sp1)?;
+            {
+                let mut sp2 = sp1.savepoint_with_name("my_sp")?;
+                sp2.set_drop_behavior(DropBehavior::Commit);
+                insert(2, &sp2)?;
+                assert_current_sum(3, &sp2)?;
+                sp2.rollback()?;
+                assert_current_sum(1, &sp2)?;
+                insert(4, &sp2)?;
+            }
+            assert_current_sum(5, &sp1)?;
+            sp1.rollback()?;
+            {
+                let mut sp2 = sp1.savepoint_with_name("my_sp")?;
+                sp2.set_drop_behavior(DropBehavior::Ignore);
+                insert(8, &sp2)?;
+            }
+            assert_current_sum(8, &sp1)?;
+            sp1.commit()?;
+        }
+        assert_current_sum(8, &db)?;
+        Ok(())
+    }
+
+    #[test]
+    fn test_rc() -> Result<()> {
+        use std::rc::Rc;
+        let mut conn = Connection::open_in_memory()?;
+        let rc_txn = Rc::new(conn.transaction()?);
+
+        // This will compile only if Transaction is Debug
+        Rc::try_unwrap(rc_txn).unwrap();
+        Ok(())
+    }
+
+    fn insert(x: i32, conn: &Connection) -> Result<usize> {
+        conn.execute("INSERT INTO foo VALUES(?1)", [x])
+    }
+
+    fn assert_current_sum(x: i32, conn: &Connection) -> Result<()> {
+        let i = conn.one_column::<i32>("SELECT SUM(x) FROM foo")?;
+        assert_eq!(x, i);
+        Ok(())
+    }
+
+    #[test]
+    #[cfg(feature = "modern_sqlite")]
+    fn txn_state() -> Result<()> {
+        use super::TransactionState;
+        use crate::DatabaseName;
+        let db = Connection::open_in_memory()?;
+        assert_eq!(
+            TransactionState::None,
+            db.transaction_state(Some(DatabaseName::Main))?
+        );
+        assert_eq!(TransactionState::None, db.transaction_state(None)?);
+        db.execute_batch("BEGIN")?;
+        assert_eq!(TransactionState::None, db.transaction_state(None)?);
+        let _: i32 = db.pragma_query_value(None, "user_version", |row| row.get(0))?;
+        assert_eq!(TransactionState::Read, db.transaction_state(None)?);
+        db.pragma_update(None, "user_version", 1)?;
+        assert_eq!(TransactionState::Write, db.transaction_state(None)?);
+        db.execute_batch("ROLLBACK")?;
+        Ok(())
+    }
+}
diff --git a/crates/rusqlite/src/types/chrono.rs b/crates/rusqlite/src/types/chrono.rs
new file mode 100644
index 0000000..6b50e01
--- /dev/null
+++ b/crates/rusqlite/src/types/chrono.rs
@@ -0,0 +1,319 @@
+//! Convert most of the [Time Strings](http://sqlite.org/lang_datefunc.html) to chrono types.
+
+use chrono::{DateTime, FixedOffset, Local, NaiveDate, NaiveDateTime, NaiveTime, TimeZone, Utc};
+
+use crate::types::{FromSql, FromSqlError, FromSqlResult, ToSql, ToSqlOutput, ValueRef};
+use crate::Result;
+
+/// ISO 8601 calendar date without timezone => "YYYY-MM-DD"
+impl ToSql for NaiveDate {
+    #[inline]
+    fn to_sql(&self) -> Result<ToSqlOutput<'_>> {
+        let date_str = self.format("%F").to_string();
+        Ok(ToSqlOutput::from(date_str))
+    }
+}
+
+/// "YYYY-MM-DD" => ISO 8601 calendar date without timezone.
+impl FromSql for NaiveDate {
+    #[inline]
+    fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self> {
+        value
+            .as_str()
+            .and_then(|s| match NaiveDate::parse_from_str(s, "%F") {
+                Ok(dt) => Ok(dt),
+                Err(err) => Err(FromSqlError::Other(Box::new(err))),
+            })
+    }
+}
+
+/// ISO 8601 time without timezone => "HH:MM:SS.SSS"
+impl ToSql for NaiveTime {
+    #[inline]
+    fn to_sql(&self) -> Result<ToSqlOutput<'_>> {
+        let date_str = self.format("%T%.f").to_string();
+        Ok(ToSqlOutput::from(date_str))
+    }
+}
+
+/// "HH:MM"/"HH:MM:SS"/"HH:MM:SS.SSS" => ISO 8601 time without timezone.
+impl FromSql for NaiveTime {
+    fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self> {
+        value.as_str().and_then(|s| {
+            let fmt = match s.len() {
+                5 => "%H:%M",
+                8 => "%T",
+                _ => "%T%.f",
+            };
+            match NaiveTime::parse_from_str(s, fmt) {
+                Ok(dt) => Ok(dt),
+                Err(err) => Err(FromSqlError::Other(Box::new(err))),
+            }
+        })
+    }
+}
+
+/// ISO 8601 combined date and time without timezone =>
+/// "YYYY-MM-DD HH:MM:SS.SSS"
+impl ToSql for NaiveDateTime {
+    #[inline]
+    fn to_sql(&self) -> Result<ToSqlOutput<'_>> {
+        let date_str = self.format("%F %T%.f").to_string();
+        Ok(ToSqlOutput::from(date_str))
+    }
+}
+
+/// "YYYY-MM-DD HH:MM:SS"/"YYYY-MM-DD HH:MM:SS.SSS" => ISO 8601 combined date
+/// and time without timezone. ("YYYY-MM-DDTHH:MM:SS"/"YYYY-MM-DDTHH:MM:SS.SSS"
+/// also supported)
+impl FromSql for NaiveDateTime {
+    fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self> {
+        value.as_str().and_then(|s| {
+            let fmt = if s.len() >= 11 && s.as_bytes()[10] == b'T' {
+                "%FT%T%.f"
+            } else {
+                "%F %T%.f"
+            };
+
+            match NaiveDateTime::parse_from_str(s, fmt) {
+                Ok(dt) => Ok(dt),
+                Err(err) => Err(FromSqlError::Other(Box::new(err))),
+            }
+        })
+    }
+}
+
+/// UTC time => UTC RFC3339 timestamp
+/// ("YYYY-MM-DD HH:MM:SS.SSS+00:00").
+impl ToSql for DateTime<Utc> {
+    #[inline]
+    fn to_sql(&self) -> Result<ToSqlOutput<'_>> {
+        let date_str = self.format("%F %T%.f%:z").to_string();
+        Ok(ToSqlOutput::from(date_str))
+    }
+}
+
+/// Local time => UTC RFC3339 timestamp
+/// ("YYYY-MM-DD HH:MM:SS.SSS+00:00").
+impl ToSql for DateTime<Local> {
+    #[inline]
+    fn to_sql(&self) -> Result<ToSqlOutput<'_>> {
+        let date_str = self.with_timezone(&Utc).format("%F %T%.f%:z").to_string();
+        Ok(ToSqlOutput::from(date_str))
+    }
+}
+
+/// Date and time with time zone => RFC3339 timestamp
+/// ("YYYY-MM-DD HH:MM:SS.SSS[+-]HH:MM").
+impl ToSql for DateTime<FixedOffset> {
+    #[inline]
+    fn to_sql(&self) -> Result<ToSqlOutput<'_>> {
+        let date_str = self.format("%F %T%.f%:z").to_string();
+        Ok(ToSqlOutput::from(date_str))
+    }
+}
+
+/// RFC3339 ("YYYY-MM-DD HH:MM:SS.SSS[+-]HH:MM") into `DateTime<Utc>`.
+impl FromSql for DateTime<Utc> {
+    fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self> {
+        {
+            // Try to parse value as rfc3339 first.
+            let s = value.as_str()?;
+
+            let fmt = if s.len() >= 11 && s.as_bytes()[10] == b'T' {
+                "%FT%T%.f%#z"
+            } else {
+                "%F %T%.f%#z"
+            };
+
+            if let Ok(dt) = DateTime::parse_from_str(s, fmt) {
+                return Ok(dt.with_timezone(&Utc));
+            }
+        }
+
+        // Couldn't parse as rfc3339 - fall back to NaiveDateTime.
+        NaiveDateTime::column_result(value).map(|dt| Utc.from_utc_datetime(&dt))
+    }
+}
+
+/// RFC3339 ("YYYY-MM-DD HH:MM:SS.SSS[+-]HH:MM") into `DateTime<Local>`.
+impl FromSql for DateTime<Local> {
+    #[inline]
+    fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self> {
+        let utc_dt = DateTime::<Utc>::column_result(value)?;
+        Ok(utc_dt.with_timezone(&Local))
+    }
+}
+
+/// RFC3339 ("YYYY-MM-DD HH:MM:SS.SSS[+-]HH:MM") into `DateTime<FixedOffset>`.
+impl FromSql for DateTime<FixedOffset> {
+    #[inline]
+    fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self> {
+        let s = String::column_result(value)?;
+        Self::parse_from_rfc3339(s.as_str())
+            .or_else(|_| Self::parse_from_str(s.as_str(), "%F %T%.f%:z"))
+            .map_err(|e| FromSqlError::Other(Box::new(e)))
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::{
+        types::{FromSql, ValueRef},
+        Connection, Result,
+    };
+    use chrono::{
+        DateTime, Duration, FixedOffset, Local, NaiveDate, NaiveDateTime, NaiveTime, TimeZone, Utc,
+    };
+
+    fn checked_memory_handle() -> Result<Connection> {
+        let db = Connection::open_in_memory()?;
+        db.execute_batch("CREATE TABLE foo (t TEXT, i INTEGER, f FLOAT, b BLOB)")?;
+        Ok(db)
+    }
+
+    #[test]
+    fn test_naive_date() -> Result<()> {
+        let db = checked_memory_handle()?;
+        let date = NaiveDate::from_ymd_opt(2016, 2, 23).unwrap();
+        db.execute("INSERT INTO foo (t) VALUES (?1)", [date])?;
+
+        let s: String = db.one_column("SELECT t FROM foo")?;
+        assert_eq!("2016-02-23", s);
+        let t: NaiveDate = db.one_column("SELECT t FROM foo")?;
+        assert_eq!(date, t);
+        Ok(())
+    }
+
+    #[test]
+    fn test_naive_time() -> Result<()> {
+        let db = checked_memory_handle()?;
+        let time = NaiveTime::from_hms_opt(23, 56, 4).unwrap();
+        db.execute("INSERT INTO foo (t) VALUES (?1)", [time])?;
+
+        let s: String = db.one_column("SELECT t FROM foo")?;
+        assert_eq!("23:56:04", s);
+        let v: NaiveTime = db.one_column("SELECT t FROM foo")?;
+        assert_eq!(time, v);
+        Ok(())
+    }
+
+    #[test]
+    fn test_naive_date_time() -> Result<()> {
+        let db = checked_memory_handle()?;
+        let date = NaiveDate::from_ymd_opt(2016, 2, 23).unwrap();
+        let time = NaiveTime::from_hms_opt(23, 56, 4).unwrap();
+        let dt = NaiveDateTime::new(date, time);
+
+        db.execute("INSERT INTO foo (t) VALUES (?1)", [dt])?;
+
+        let s: String = db.one_column("SELECT t FROM foo")?;
+        assert_eq!("2016-02-23 23:56:04", s);
+        let v: NaiveDateTime = db.one_column("SELECT t FROM foo")?;
+        assert_eq!(dt, v);
+
+        db.execute("UPDATE foo set b = datetime(t)", [])?; // "YYYY-MM-DD HH:MM:SS"
+        let hms: NaiveDateTime = db.one_column("SELECT b FROM foo")?;
+        assert_eq!(dt, hms);
+        Ok(())
+    }
+
+    #[test]
+    fn test_date_time_utc() -> Result<()> {
+        let db = checked_memory_handle()?;
+        let date = NaiveDate::from_ymd_opt(2016, 2, 23).unwrap();
+        let time = NaiveTime::from_hms_milli_opt(23, 56, 4, 789).unwrap();
+        let dt = NaiveDateTime::new(date, time);
+        let utc = Utc.from_utc_datetime(&dt);
+
+        db.execute("INSERT INTO foo (t) VALUES (?1)", [utc])?;
+
+        let s: String = db.one_column("SELECT t FROM foo")?;
+        assert_eq!("2016-02-23 23:56:04.789+00:00", s);
+
+        let v1: DateTime<Utc> = db.one_column("SELECT t FROM foo")?;
+        assert_eq!(utc, v1);
+
+        let v2: DateTime<Utc> = db.one_column("SELECT '2016-02-23 23:56:04.789'")?;
+        assert_eq!(utc, v2);
+
+        let v3: DateTime<Utc> = db.one_column("SELECT '2016-02-23 23:56:04'")?;
+        assert_eq!(utc - Duration::milliseconds(789), v3);
+
+        let v4: DateTime<Utc> = db.one_column("SELECT '2016-02-23 23:56:04.789+00:00'")?;
+        assert_eq!(utc, v4);
+        Ok(())
+    }
+
+    #[test]
+    fn test_date_time_local() -> Result<()> {
+        let db = checked_memory_handle()?;
+        let date = NaiveDate::from_ymd_opt(2016, 2, 23).unwrap();
+        let time = NaiveTime::from_hms_milli_opt(23, 56, 4, 789).unwrap();
+        let dt = NaiveDateTime::new(date, time);
+        let local = Local.from_local_datetime(&dt).single().unwrap();
+
+        db.execute("INSERT INTO foo (t) VALUES (?1)", [local])?;
+
+        // Stored string should be in UTC
+        let s: String = db.one_column("SELECT t FROM foo")?;
+        assert!(s.ends_with("+00:00"));
+
+        let v: DateTime<Local> = db.one_column("SELECT t FROM foo")?;
+        assert_eq!(local, v);
+        Ok(())
+    }
+
+    #[test]
+    fn test_date_time_fixed() -> Result<()> {
+        let db = checked_memory_handle()?;
+        let time = DateTime::parse_from_rfc3339("2020-04-07T11:23:45+04:00").unwrap();
+
+        db.execute("INSERT INTO foo (t) VALUES (?1)", [time])?;
+
+        // Stored string should preserve timezone offset
+        let s: String = db.one_column("SELECT t FROM foo")?;
+        assert!(s.ends_with("+04:00"));
+
+        let v: DateTime<FixedOffset> = db.one_column("SELECT t FROM foo")?;
+        assert_eq!(time.offset(), v.offset());
+        assert_eq!(time, v);
+        Ok(())
+    }
+
+    #[test]
+    fn test_sqlite_functions() -> Result<()> {
+        let db = checked_memory_handle()?;
+        let result: Result<NaiveTime> = db.one_column("SELECT CURRENT_TIME");
+        result.unwrap();
+        let result: Result<NaiveDate> = db.one_column("SELECT CURRENT_DATE");
+        result.unwrap();
+        let result: Result<NaiveDateTime> = db.one_column("SELECT CURRENT_TIMESTAMP");
+        result.unwrap();
+        let result: Result<DateTime<Utc>> = db.one_column("SELECT CURRENT_TIMESTAMP");
+        result.unwrap();
+        Ok(())
+    }
+
+    #[test]
+    fn test_naive_date_time_param() -> Result<()> {
+        let db = checked_memory_handle()?;
+        let result: Result<bool> = db.query_row("SELECT 1 WHERE ?1 BETWEEN datetime('now', '-1 minute') AND datetime('now', '+1 minute')", [Utc::now().naive_utc()], |r| r.get(0));
+        result.unwrap();
+        Ok(())
+    }
+
+    #[test]
+    fn test_date_time_param() -> Result<()> {
+        let db = checked_memory_handle()?;
+        let result: Result<bool> = db.query_row("SELECT 1 WHERE ?1 BETWEEN datetime('now', '-1 minute') AND datetime('now', '+1 minute')", [Utc::now()], |r| r.get(0));
+        result.unwrap();
+        Ok(())
+    }
+
+    #[test]
+    fn test_lenient_parse_timezone() {
+        DateTime::<Utc>::column_result(ValueRef::Text(b"1970-01-01T00:00:00Z")).unwrap();
+        DateTime::<Utc>::column_result(ValueRef::Text(b"1970-01-01T00:00:00+00")).unwrap();
+    }
+}
diff --git a/crates/rusqlite/src/types/from_sql.rs b/crates/rusqlite/src/types/from_sql.rs
new file mode 100644
index 0000000..91eed09
--- /dev/null
+++ b/crates/rusqlite/src/types/from_sql.rs
@@ -0,0 +1,276 @@
+use super::{Value, ValueRef};
+use std::convert::TryInto;
+use std::error::Error;
+use std::fmt;
+
+/// Enum listing possible errors from [`FromSql`] trait.
+#[derive(Debug)]
+#[non_exhaustive]
+pub enum FromSqlError {
+    /// Error when an SQLite value is requested, but the type of the result
+    /// cannot be converted to the requested Rust type.
+    InvalidType,
+
+    /// Error when the i64 value returned by SQLite cannot be stored into the
+    /// requested type.
+    OutOfRange(i64),
+
+    /// Error when the blob result returned by SQLite cannot be stored into the
+    /// requested type due to a size mismatch.
+    InvalidBlobSize {
+        /// The expected size of the blob.
+        expected_size: usize,
+        /// The actual size of the blob that was returned.
+        blob_size: usize,
+    },
+
+    /// An error case available for implementors of the [`FromSql`] trait.
+    Other(Box<dyn Error + Send + Sync + 'static>),
+}
+
+impl PartialEq for FromSqlError {
+    fn eq(&self, other: &FromSqlError) -> bool {
+        match (self, other) {
+            (FromSqlError::InvalidType, FromSqlError::InvalidType) => true,
+            (FromSqlError::OutOfRange(n1), FromSqlError::OutOfRange(n2)) => n1 == n2,
+            (
+                FromSqlError::InvalidBlobSize {
+                    expected_size: es1,
+                    blob_size: bs1,
+                },
+                FromSqlError::InvalidBlobSize {
+                    expected_size: es2,
+                    blob_size: bs2,
+                },
+            ) => es1 == es2 && bs1 == bs2,
+            (..) => false,
+        }
+    }
+}
+
+impl fmt::Display for FromSqlError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            FromSqlError::InvalidType => write!(f, "Invalid type"),
+            FromSqlError::OutOfRange(i) => write!(f, "Value {i} out of range"),
+            FromSqlError::InvalidBlobSize {
+                expected_size,
+                blob_size,
+            } => {
+                write!(
+                    f,
+                    "Cannot read {} byte value out of {} byte blob",
+                    expected_size, blob_size
+                )
+            }
+            FromSqlError::Other(ref err) => err.fmt(f),
+        }
+    }
+}
+
+impl Error for FromSqlError {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        if let FromSqlError::Other(ref err) = self {
+            Some(&**err)
+        } else {
+            None
+        }
+    }
+}
+
+/// Result type for implementors of the [`FromSql`] trait.
+pub type FromSqlResult<T> = Result<T, FromSqlError>;
+
+/// A trait for types that can be created from a SQLite value.
+pub trait FromSql: Sized {
+    /// Converts SQLite value into Rust value.
+    fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self>;
+}
+
+macro_rules! from_sql_integral(
+    ($t:ident) => (
+        impl FromSql for $t {
+            #[inline]
+            fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self> {
+                let i = i64::column_result(value)?;
+                i.try_into().map_err(|_| FromSqlError::OutOfRange(i))
+            }
+        }
+    )
+);
+
+from_sql_integral!(i8);
+from_sql_integral!(i16);
+from_sql_integral!(i32);
+// from_sql_integral!(i64); // Not needed because the native type is i64.
+from_sql_integral!(isize);
+from_sql_integral!(u8);
+from_sql_integral!(u16);
+from_sql_integral!(u32);
+from_sql_integral!(u64);
+from_sql_integral!(usize);
+
+impl FromSql for i64 {
+    #[inline]
+    fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self> {
+        value.as_i64()
+    }
+}
+
+impl FromSql for f32 {
+    #[inline]
+    fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self> {
+        match value {
+            ValueRef::Integer(i) => Ok(i as f32),
+            ValueRef::Real(f) => Ok(f as f32),
+            _ => Err(FromSqlError::InvalidType),
+        }
+    }
+}
+
+impl FromSql for f64 {
+    #[inline]
+    fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self> {
+        match value {
+            ValueRef::Integer(i) => Ok(i as f64),
+            ValueRef::Real(f) => Ok(f),
+            _ => Err(FromSqlError::InvalidType),
+        }
+    }
+}
+
+impl FromSql for bool {
+    #[inline]
+    fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self> {
+        i64::column_result(value).map(|i| i != 0)
+    }
+}
+
+impl FromSql for String {
+    #[inline]
+    fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self> {
+        value.as_str().map(ToString::to_string)
+    }
+}
+
+impl FromSql for Box<str> {
+    #[inline]
+    fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self> {
+        value.as_str().map(Into::into)
+    }
+}
+
+impl FromSql for std::rc::Rc<str> {
+    #[inline]
+    fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self> {
+        value.as_str().map(Into::into)
+    }
+}
+
+impl FromSql for std::sync::Arc<str> {
+    #[inline]
+    fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self> {
+        value.as_str().map(Into::into)
+    }
+}
+
+impl FromSql for Vec<u8> {
+    #[inline]
+    fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self> {
+        value.as_blob().map(<[u8]>::to_vec)
+    }
+}
+
+impl<const N: usize> FromSql for [u8; N] {
+    #[inline]
+    fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self> {
+        let slice = value.as_blob()?;
+        slice.try_into().map_err(|_| FromSqlError::InvalidBlobSize {
+            expected_size: N,
+            blob_size: slice.len(),
+        })
+    }
+}
+
+#[cfg(feature = "i128_blob")]
+#[cfg_attr(docsrs, doc(cfg(feature = "i128_blob")))]
+impl FromSql for i128 {
+    #[inline]
+    fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self> {
+        let bytes = <[u8; 16]>::column_result(value)?;
+        Ok(i128::from_be_bytes(bytes) ^ (1_i128 << 127))
+    }
+}
+
+#[cfg(feature = "uuid")]
+#[cfg_attr(docsrs, doc(cfg(feature = "uuid")))]
+impl FromSql for uuid::Uuid {
+    #[inline]
+    fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self> {
+        let bytes = <[u8; 16]>::column_result(value)?;
+        Ok(uuid::Uuid::from_u128(u128::from_be_bytes(bytes)))
+    }
+}
+
+impl<T: FromSql> FromSql for Option<T> {
+    #[inline]
+    fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self> {
+        match value {
+            ValueRef::Null => Ok(None),
+            _ => FromSql::column_result(value).map(Some),
+        }
+    }
+}
+
+impl FromSql for Value {
+    #[inline]
+    fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self> {
+        Ok(value.into())
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::FromSql;
+    use crate::{Connection, Error, Result};
+
+    #[test]
+    fn test_integral_ranges() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+
+        fn check_ranges<T>(db: &Connection, out_of_range: &[i64], in_range: &[i64])
+        where
+            T: Into<i64> + FromSql + std::fmt::Debug,
+        {
+            for n in out_of_range {
+                let err = db
+                    .query_row("SELECT ?1", [n], |r| r.get::<_, T>(0))
+                    .unwrap_err();
+                match err {
+                    Error::IntegralValueOutOfRange(_, value) => assert_eq!(*n, value),
+                    _ => panic!("unexpected error: {}", err),
+                }
+            }
+            for n in in_range {
+                assert_eq!(
+                    *n,
+                    db.query_row("SELECT ?1", [n], |r| r.get::<_, T>(0))
+                        .unwrap()
+                        .into()
+                );
+            }
+        }
+
+        check_ranges::<i8>(&db, &[-129, 128], &[-128, 0, 1, 127]);
+        check_ranges::<i16>(&db, &[-32769, 32768], &[-32768, -1, 0, 1, 32767]);
+        check_ranges::<i32>(
+            &db,
+            &[-2_147_483_649, 2_147_483_648],
+            &[-2_147_483_648, -1, 0, 1, 2_147_483_647],
+        );
+        check_ranges::<u8>(&db, &[-2, -1, 256], &[0, 1, 255]);
+        check_ranges::<u16>(&db, &[-2, -1, 65536], &[0, 1, 65535]);
+        check_ranges::<u32>(&db, &[-2, -1, 4_294_967_296], &[0, 1, 4_294_967_295]);
+        Ok(())
+    }
+}
diff --git a/crates/rusqlite/src/types/mod.rs b/crates/rusqlite/src/types/mod.rs
new file mode 100644
index 0000000..eece984
--- /dev/null
+++ b/crates/rusqlite/src/types/mod.rs
@@ -0,0 +1,446 @@
+//! Traits dealing with SQLite data types.
+//!
+//! SQLite uses a [dynamic type system](https://www.sqlite.org/datatype3.html). Implementations of
+//! the [`ToSql`] and [`FromSql`] traits are provided for the basic types that
+//! SQLite provides methods for:
+//!
+//! * Strings (`String` and `&str`)
+//! * Blobs (`Vec<u8>` and `&[u8]`)
+//! * Numbers
+//!
+//! The number situation is a little complicated due to the fact that all
+//! numbers in SQLite are stored as `INTEGER` (`i64`) or `REAL` (`f64`).
+//!
+//! [`ToSql`] and [`FromSql`] are implemented for all primitive number types.
+//! [`FromSql`] has different behaviour depending on the SQL and Rust types, and
+//! the value.
+//!
+//! * `INTEGER` to integer: returns an
+//!   [`Error::IntegralValueOutOfRange`](crate::Error::IntegralValueOutOfRange)
+//!   error if the value does not fit in the Rust type.
+//! * `REAL` to integer: always returns an
+//!   [`Error::InvalidColumnType`](crate::Error::InvalidColumnType) error.
+//! * `INTEGER` to float: casts using `as` operator. Never fails.
+//! * `REAL` to float: casts using `as` operator. Never fails.
+//!
+//! [`ToSql`] always succeeds except when storing a `u64` or `usize` value that
+//! cannot fit in an `INTEGER` (`i64`). Also note that SQLite ignores column
+//! types, so if you store an `i64` in a column with type `REAL` it will be
+//! stored as an `INTEGER`, not a `REAL`.
+//!
+//! If the `time` feature is enabled, implementations are
+//! provided for `time::OffsetDateTime` that use the RFC 3339 date/time format,
+//! `"%Y-%m-%dT%H:%M:%S.%fZ"`, to store time values as strings.  These values
+//! can be parsed by SQLite's builtin
+//! [datetime](https://www.sqlite.org/lang_datefunc.html) functions.  If you
+//! want different storage for datetimes, you can use a newtype.
+#![cfg_attr(
+    feature = "time",
+    doc = r##"
+For example, to store datetimes as `i64`s counting the number of seconds since
+the Unix epoch:
+
+```
+use rusqlite::types::{FromSql, FromSqlError, FromSqlResult, ToSql, ToSqlOutput, ValueRef};
+use rusqlite::Result;
+
+pub struct DateTimeSql(pub time::OffsetDateTime);
+
+impl FromSql for DateTimeSql {
+    fn column_result(value: ValueRef) -> FromSqlResult<Self> {
+        i64::column_result(value).and_then(|as_i64| {
+            time::OffsetDateTime::from_unix_timestamp(as_i64)
+            .map(|odt| DateTimeSql(odt))
+            .map_err(|err| FromSqlError::Other(Box::new(err)))
+        })
+    }
+}
+
+impl ToSql for DateTimeSql {
+    fn to_sql(&self) -> Result<ToSqlOutput> {
+        Ok(self.0.unix_timestamp().into())
+    }
+}
+```
+
+"##
+)]
+//! [`ToSql`] and [`FromSql`] are also implemented for `Option<T>` where `T`
+//! implements [`ToSql`] or [`FromSql`] for the cases where you want to know if
+//! a value was NULL (which gets translated to `None`).
+
+pub use self::from_sql::{FromSql, FromSqlError, FromSqlResult};
+pub use self::to_sql::{ToSql, ToSqlOutput};
+pub use self::value::Value;
+pub use self::value_ref::ValueRef;
+
+use std::fmt;
+
+#[cfg(feature = "chrono")]
+#[cfg_attr(docsrs, doc(cfg(feature = "chrono")))]
+mod chrono;
+mod from_sql;
+#[cfg(feature = "serde_json")]
+#[cfg_attr(docsrs, doc(cfg(feature = "serde_json")))]
+mod serde_json;
+#[cfg(feature = "time")]
+#[cfg_attr(docsrs, doc(cfg(feature = "time")))]
+mod time;
+mod to_sql;
+#[cfg(feature = "url")]
+#[cfg_attr(docsrs, doc(cfg(feature = "url")))]
+mod url;
+mod value;
+mod value_ref;
+
+/// Empty struct that can be used to fill in a query parameter as `NULL`.
+///
+/// ## Example
+///
+/// ```rust,no_run
+/// # use rusqlite::{Connection, Result};
+/// # use rusqlite::types::{Null};
+///
+/// fn insert_null(conn: &Connection) -> Result<usize> {
+///     conn.execute("INSERT INTO people (name) VALUES (?1)", [Null])
+/// }
+/// ```
+#[derive(Copy, Clone)]
+pub struct Null;
+
+/// SQLite data types.
+/// See [Fundamental Datatypes](https://sqlite.org/c3ref/c_blob.html).
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum Type {
+    /// NULL
+    Null,
+    /// 64-bit signed integer
+    Integer,
+    /// 64-bit IEEE floating point number
+    Real,
+    /// String
+    Text,
+    /// BLOB
+    Blob,
+}
+
+impl fmt::Display for Type {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            Type::Null => f.pad("Null"),
+            Type::Integer => f.pad("Integer"),
+            Type::Real => f.pad("Real"),
+            Type::Text => f.pad("Text"),
+            Type::Blob => f.pad("Blob"),
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::Value;
+    use crate::{params, Connection, Error, Result, Statement};
+    use std::os::raw::{c_double, c_int};
+
+    fn checked_memory_handle() -> Result<Connection> {
+        let db = Connection::open_in_memory()?;
+        db.execute_batch("CREATE TABLE foo (b BLOB, t TEXT, i INTEGER, f FLOAT, n)")?;
+        Ok(db)
+    }
+
+    #[test]
+    fn test_blob() -> Result<()> {
+        let db = checked_memory_handle()?;
+
+        let v1234 = vec![1u8, 2, 3, 4];
+        db.execute("INSERT INTO foo(b) VALUES (?1)", [&v1234])?;
+
+        let v: Vec<u8> = db.one_column("SELECT b FROM foo")?;
+        assert_eq!(v, v1234);
+        Ok(())
+    }
+
+    #[test]
+    fn test_empty_blob() -> Result<()> {
+        let db = checked_memory_handle()?;
+
+        let empty = vec![];
+        db.execute("INSERT INTO foo(b) VALUES (?1)", [&empty])?;
+
+        let v: Vec<u8> = db.one_column("SELECT b FROM foo")?;
+        assert_eq!(v, empty);
+        Ok(())
+    }
+
+    #[test]
+    fn test_str() -> Result<()> {
+        let db = checked_memory_handle()?;
+
+        let s = "hello, world!";
+        db.execute("INSERT INTO foo(t) VALUES (?1)", [&s])?;
+
+        let from: String = db.one_column("SELECT t FROM foo")?;
+        assert_eq!(from, s);
+        Ok(())
+    }
+
+    #[test]
+    fn test_string() -> Result<()> {
+        let db = checked_memory_handle()?;
+
+        let s = "hello, world!";
+        db.execute("INSERT INTO foo(t) VALUES (?1)", [s.to_owned()])?;
+
+        let from: String = db.one_column("SELECT t FROM foo")?;
+        assert_eq!(from, s);
+        Ok(())
+    }
+
+    #[test]
+    fn test_value() -> Result<()> {
+        let db = checked_memory_handle()?;
+
+        db.execute("INSERT INTO foo(i) VALUES (?1)", [Value::Integer(10)])?;
+
+        assert_eq!(10i64, db.one_column::<i64>("SELECT i FROM foo")?);
+        Ok(())
+    }
+
+    #[test]
+    fn test_option() -> Result<()> {
+        let db = checked_memory_handle()?;
+
+        let s = Some("hello, world!");
+        let b = Some(vec![1u8, 2, 3, 4]);
+
+        db.execute("INSERT INTO foo(t) VALUES (?1)", [&s])?;
+        db.execute("INSERT INTO foo(b) VALUES (?1)", [&b])?;
+
+        let mut stmt = db.prepare("SELECT t, b FROM foo ORDER BY ROWID ASC")?;
+        let mut rows = stmt.query([])?;
+
+        {
+            let row1 = rows.next()?.unwrap();
+            let s1: Option<String> = row1.get_unwrap(0);
+            let b1: Option<Vec<u8>> = row1.get_unwrap(1);
+            assert_eq!(s.unwrap(), s1.unwrap());
+            assert!(b1.is_none());
+        }
+
+        {
+            let row2 = rows.next()?.unwrap();
+            let s2: Option<String> = row2.get_unwrap(0);
+            let b2: Option<Vec<u8>> = row2.get_unwrap(1);
+            assert!(s2.is_none());
+            assert_eq!(b, b2);
+        }
+        Ok(())
+    }
+
+    #[test]
+    #[allow(clippy::cognitive_complexity)]
+    fn test_mismatched_types() -> Result<()> {
+        fn is_invalid_column_type(err: Error) -> bool {
+            matches!(err, Error::InvalidColumnType(..))
+        }
+
+        let db = checked_memory_handle()?;
+
+        db.execute(
+            "INSERT INTO foo(b, t, i, f) VALUES (X'0102', 'text', 1, 1.5)",
+            [],
+        )?;
+
+        let mut stmt = db.prepare("SELECT b, t, i, f, n FROM foo")?;
+        let mut rows = stmt.query([])?;
+
+        let row = rows.next()?.unwrap();
+
+        // check the correct types come back as expected
+        assert_eq!(vec![1, 2], row.get::<_, Vec<u8>>(0)?);
+        assert_eq!("text", row.get::<_, String>(1)?);
+        assert_eq!(1, row.get::<_, c_int>(2)?);
+        assert!((1.5 - row.get::<_, c_double>(3)?).abs() < f64::EPSILON);
+        assert_eq!(row.get::<_, Option<c_int>>(4)?, None);
+        assert_eq!(row.get::<_, Option<c_double>>(4)?, None);
+        assert_eq!(row.get::<_, Option<String>>(4)?, None);
+
+        // check some invalid types
+
+        // 0 is actually a blob (Vec<u8>)
+        assert!(is_invalid_column_type(row.get::<_, c_int>(0).unwrap_err()));
+        assert!(is_invalid_column_type(row.get::<_, c_int>(0).unwrap_err()));
+        assert!(is_invalid_column_type(row.get::<_, i64>(0).err().unwrap()));
+        assert!(is_invalid_column_type(
+            row.get::<_, c_double>(0).unwrap_err()
+        ));
+        assert!(is_invalid_column_type(row.get::<_, String>(0).unwrap_err()));
+        #[cfg(feature = "time")]
+        assert!(is_invalid_column_type(
+            row.get::<_, time::OffsetDateTime>(0).unwrap_err()
+        ));
+        assert!(is_invalid_column_type(
+            row.get::<_, Option<c_int>>(0).unwrap_err()
+        ));
+
+        // 1 is actually a text (String)
+        assert!(is_invalid_column_type(row.get::<_, c_int>(1).unwrap_err()));
+        assert!(is_invalid_column_type(row.get::<_, i64>(1).err().unwrap()));
+        assert!(is_invalid_column_type(
+            row.get::<_, c_double>(1).unwrap_err()
+        ));
+        assert!(is_invalid_column_type(
+            row.get::<_, Vec<u8>>(1).unwrap_err()
+        ));
+        assert!(is_invalid_column_type(
+            row.get::<_, Option<c_int>>(1).unwrap_err()
+        ));
+
+        // 2 is actually an integer
+        assert!(is_invalid_column_type(row.get::<_, String>(2).unwrap_err()));
+        assert!(is_invalid_column_type(
+            row.get::<_, Vec<u8>>(2).unwrap_err()
+        ));
+        assert!(is_invalid_column_type(
+            row.get::<_, Option<String>>(2).unwrap_err()
+        ));
+
+        // 3 is actually a float (c_double)
+        assert!(is_invalid_column_type(row.get::<_, c_int>(3).unwrap_err()));
+        assert!(is_invalid_column_type(row.get::<_, i64>(3).err().unwrap()));
+        assert!(is_invalid_column_type(row.get::<_, String>(3).unwrap_err()));
+        assert!(is_invalid_column_type(
+            row.get::<_, Vec<u8>>(3).unwrap_err()
+        ));
+        assert!(is_invalid_column_type(
+            row.get::<_, Option<c_int>>(3).unwrap_err()
+        ));
+
+        // 4 is actually NULL
+        assert!(is_invalid_column_type(row.get::<_, c_int>(4).unwrap_err()));
+        assert!(is_invalid_column_type(row.get::<_, i64>(4).err().unwrap()));
+        assert!(is_invalid_column_type(
+            row.get::<_, c_double>(4).unwrap_err()
+        ));
+        assert!(is_invalid_column_type(row.get::<_, String>(4).unwrap_err()));
+        assert!(is_invalid_column_type(
+            row.get::<_, Vec<u8>>(4).unwrap_err()
+        ));
+        #[cfg(feature = "time")]
+        assert!(is_invalid_column_type(
+            row.get::<_, time::OffsetDateTime>(4).unwrap_err()
+        ));
+        Ok(())
+    }
+
+    #[test]
+    fn test_dynamic_type() -> Result<()> {
+        use super::Value;
+        let db = checked_memory_handle()?;
+
+        db.execute(
+            "INSERT INTO foo(b, t, i, f) VALUES (X'0102', 'text', 1, 1.5)",
+            [],
+        )?;
+
+        let mut stmt = db.prepare("SELECT b, t, i, f, n FROM foo")?;
+        let mut rows = stmt.query([])?;
+
+        let row = rows.next()?.unwrap();
+        assert_eq!(Value::Blob(vec![1, 2]), row.get::<_, Value>(0)?);
+        assert_eq!(Value::Text(String::from("text")), row.get::<_, Value>(1)?);
+        assert_eq!(Value::Integer(1), row.get::<_, Value>(2)?);
+        match row.get::<_, Value>(3)? {
+            Value::Real(val) => assert!((1.5 - val).abs() < f64::EPSILON),
+            x => panic!("Invalid Value {:?}", x),
+        }
+        assert_eq!(Value::Null, row.get::<_, Value>(4)?);
+        Ok(())
+    }
+
+    macro_rules! test_conversion {
+        ($db_etc:ident, $insert_value:expr, $get_type:ty,expect $expected_value:expr) => {
+            $db_etc.insert_statement.execute(params![$insert_value])?;
+            let res = $db_etc
+                .query_statement
+                .query_row([], |row| row.get::<_, $get_type>(0));
+            assert_eq!(res?, $expected_value);
+            $db_etc.delete_statement.execute([])?;
+        };
+        ($db_etc:ident, $insert_value:expr, $get_type:ty,expect_from_sql_error) => {
+            $db_etc.insert_statement.execute(params![$insert_value])?;
+            let res = $db_etc
+                .query_statement
+                .query_row([], |row| row.get::<_, $get_type>(0));
+            res.unwrap_err();
+            $db_etc.delete_statement.execute([])?;
+        };
+        ($db_etc:ident, $insert_value:expr, $get_type:ty,expect_to_sql_error) => {
+            $db_etc
+                .insert_statement
+                .execute(params![$insert_value])
+                .unwrap_err();
+        };
+    }
+
+    #[test]
+    fn test_numeric_conversions() -> Result<()> {
+        #![allow(clippy::float_cmp)]
+
+        // Test what happens when we store an f32 and retrieve an i32 etc.
+        let db = Connection::open_in_memory()?;
+        db.execute_batch("CREATE TABLE foo (x)")?;
+
+        // SQLite actually ignores the column types, so we just need to test
+        // different numeric values.
+
+        struct DbEtc<'conn> {
+            insert_statement: Statement<'conn>,
+            query_statement: Statement<'conn>,
+            delete_statement: Statement<'conn>,
+        }
+
+        let mut db_etc = DbEtc {
+            insert_statement: db.prepare("INSERT INTO foo VALUES (?1)")?,
+            query_statement: db.prepare("SELECT x FROM foo")?,
+            delete_statement: db.prepare("DELETE FROM foo")?,
+        };
+
+        // Basic non-converting test.
+        test_conversion!(db_etc, 0u8, u8, expect 0u8);
+
+        // In-range integral conversions.
+        test_conversion!(db_etc, 100u8, i8, expect 100i8);
+        test_conversion!(db_etc, 200u8, u8, expect 200u8);
+        test_conversion!(db_etc, 100u16, i8, expect 100i8);
+        test_conversion!(db_etc, 200u16, u8, expect 200u8);
+        test_conversion!(db_etc, u32::MAX, u64, expect u32::MAX as u64);
+        test_conversion!(db_etc, i64::MIN, i64, expect i64::MIN);
+        test_conversion!(db_etc, i64::MAX, i64, expect i64::MAX);
+        test_conversion!(db_etc, i64::MAX, u64, expect i64::MAX as u64);
+        test_conversion!(db_etc, 100usize, usize, expect 100usize);
+        test_conversion!(db_etc, 100u64, u64, expect 100u64);
+        test_conversion!(db_etc, i64::MAX as u64, u64, expect i64::MAX as u64);
+
+        // Out-of-range integral conversions.
+        test_conversion!(db_etc, 200u8, i8, expect_from_sql_error);
+        test_conversion!(db_etc, 400u16, i8, expect_from_sql_error);
+        test_conversion!(db_etc, 400u16, u8, expect_from_sql_error);
+        test_conversion!(db_etc, -1i8, u8, expect_from_sql_error);
+        test_conversion!(db_etc, i64::MIN, u64, expect_from_sql_error);
+        test_conversion!(db_etc, u64::MAX, i64, expect_to_sql_error);
+        test_conversion!(db_etc, u64::MAX, u64, expect_to_sql_error);
+        test_conversion!(db_etc, i64::MAX as u64 + 1, u64, expect_to_sql_error);
+
+        // FromSql integer to float, always works.
+        test_conversion!(db_etc, i64::MIN, f32, expect i64::MIN as f32);
+        test_conversion!(db_etc, i64::MAX, f32, expect i64::MAX as f32);
+        test_conversion!(db_etc, i64::MIN, f64, expect i64::MIN as f64);
+        test_conversion!(db_etc, i64::MAX, f64, expect i64::MAX as f64);
+
+        // FromSql float to int conversion, never works even if the actual value
+        // is an integer.
+        test_conversion!(db_etc, 0f64, i64, expect_from_sql_error);
+        Ok(())
+    }
+}
diff --git a/crates/rusqlite/src/types/serde_json.rs b/crates/rusqlite/src/types/serde_json.rs
new file mode 100644
index 0000000..6e38ba3
--- /dev/null
+++ b/crates/rusqlite/src/types/serde_json.rs
@@ -0,0 +1,135 @@
+//! [`ToSql`] and [`FromSql`] implementation for JSON `Value`.
+
+use serde_json::{Number, Value};
+
+use crate::types::{FromSql, FromSqlError, FromSqlResult, ToSql, ToSqlOutput, ValueRef};
+use crate::{Error, Result};
+
+/// Serialize JSON `Value` to text:
+///
+///
+/// | JSON   | SQLite    |
+/// |----------|---------|
+/// | Null     | NULL    |
+/// | Bool     | 'true' / 'false' |
+/// | Number   | INT or REAL except u64 |
+/// | _ | TEXT |
+impl ToSql for Value {
+    #[inline]
+    fn to_sql(&self) -> Result<ToSqlOutput<'_>> {
+        match self {
+            Value::Null => Ok(ToSqlOutput::Borrowed(ValueRef::Null)),
+            Value::Number(n) if n.is_i64() => Ok(ToSqlOutput::from(n.as_i64().unwrap())),
+            Value::Number(n) if n.is_f64() => Ok(ToSqlOutput::from(n.as_f64().unwrap())),
+            _ => serde_json::to_string(self)
+                .map(ToSqlOutput::from)
+                .map_err(|err| Error::ToSqlConversionFailure(err.into())),
+        }
+    }
+}
+
+/// Deserialize SQLite value to JSON `Value`:
+///
+/// | SQLite   | JSON    |
+/// |----------|---------|
+/// | NULL     | Null    |
+/// | 'null'   | Null    |
+/// | 'true'   | Bool    |
+/// | 1        | Number  |
+/// | 0.1      | Number  |
+/// | '"text"' | String  |
+/// | 'text'   | _Error_ |
+/// | '[0, 1]' | Array   |
+/// | '{"x": 1}' | Object  |
+impl FromSql for Value {
+    #[inline]
+    fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self> {
+        match value {
+            ValueRef::Text(s) => serde_json::from_slice(s), // KO for b"text"
+            ValueRef::Blob(b) => serde_json::from_slice(b),
+            ValueRef::Integer(i) => Ok(Value::Number(Number::from(i))),
+            ValueRef::Real(f) => {
+                match Number::from_f64(f) {
+                    Some(n) => Ok(Value::Number(n)),
+                    _ => return Err(FromSqlError::InvalidType), // FIXME
+                }
+            }
+            ValueRef::Null => Ok(Value::Null),
+        }
+        .map_err(|err| FromSqlError::Other(Box::new(err)))
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::types::ToSql;
+    use crate::{Connection, Result};
+    use serde_json::{Number, Value};
+
+    fn checked_memory_handle() -> Result<Connection> {
+        let db = Connection::open_in_memory()?;
+        db.execute_batch("CREATE TABLE foo (t TEXT, b BLOB)")?;
+        Ok(db)
+    }
+
+    #[test]
+    fn test_json_value() -> Result<()> {
+        let db = checked_memory_handle()?;
+
+        let json = r#"{"foo": 13, "bar": "baz"}"#;
+        let data: Value = serde_json::from_str(json).unwrap();
+        db.execute(
+            "INSERT INTO foo (t, b) VALUES (?1, ?2)",
+            [&data as &dyn ToSql, &json.as_bytes()],
+        )?;
+
+        let t: Value = db.one_column("SELECT t FROM foo")?;
+        assert_eq!(data, t);
+        let b: Value = db.one_column("SELECT b FROM foo")?;
+        assert_eq!(data, b);
+        Ok(())
+    }
+
+    #[test]
+    fn test_to_sql() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+
+        let v: Option<String> = db.query_row("SELECT ?", [Value::Null], |r| r.get(0))?;
+        assert_eq!(None, v);
+        let v: String = db.query_row("SELECT ?", [Value::Bool(true)], |r| r.get(0))?;
+        assert_eq!("true", v);
+        let v: i64 = db.query_row("SELECT ?", [Value::Number(Number::from(1))], |r| r.get(0))?;
+        assert_eq!(1, v);
+        let v: f64 = db.query_row(
+            "SELECT ?",
+            [Value::Number(Number::from_f64(0.1).unwrap())],
+            |r| r.get(0),
+        )?;
+        assert_eq!(0.1, v);
+        let v: String =
+            db.query_row("SELECT ?", [Value::String("text".to_owned())], |r| r.get(0))?;
+        assert_eq!("\"text\"", v);
+        Ok(())
+    }
+
+    #[test]
+    fn test_from_sql() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+
+        let v: Value = db.one_column("SELECT NULL")?;
+        assert_eq!(Value::Null, v);
+        let v: Value = db.one_column("SELECT 'null'")?;
+        assert_eq!(Value::Null, v);
+        let v: Value = db.one_column("SELECT 'true'")?;
+        assert_eq!(Value::Bool(true), v);
+        let v: Value = db.one_column("SELECT 1")?;
+        assert_eq!(Value::Number(Number::from(1)), v);
+        let v: Value = db.one_column("SELECT 0.1")?;
+        assert_eq!(Value::Number(Number::from_f64(0.1).unwrap()), v);
+        let v: Value = db.one_column("SELECT '\"text\"'")?;
+        assert_eq!(Value::String("text".to_owned()), v);
+        let v: Result<Value> = db.one_column("SELECT 'text'");
+        assert!(v.is_err());
+        Ok(())
+    }
+}
diff --git a/crates/rusqlite/src/types/time.rs b/crates/rusqlite/src/types/time.rs
new file mode 100644
index 0000000..03b2d61
--- /dev/null
+++ b/crates/rusqlite/src/types/time.rs
@@ -0,0 +1,167 @@
+//! [`ToSql`] and [`FromSql`] implementation for [`time::OffsetDateTime`].
+use crate::types::{FromSql, FromSqlError, FromSqlResult, ToSql, ToSqlOutput, ValueRef};
+use crate::{Error, Result};
+use time::format_description::well_known::Rfc3339;
+use time::format_description::FormatItem;
+use time::macros::format_description;
+use time::{OffsetDateTime, PrimitiveDateTime, UtcOffset};
+
+const PRIMITIVE_SHORT_DATE_TIME_FORMAT: &[FormatItem<'_>] =
+    format_description!("[year]-[month]-[day] [hour]:[minute]:[second]");
+const PRIMITIVE_DATE_TIME_FORMAT: &[FormatItem<'_>] =
+    format_description!("[year]-[month]-[day] [hour]:[minute]:[second].[subsecond]");
+const PRIMITIVE_DATE_TIME_Z_FORMAT: &[FormatItem<'_>] =
+    format_description!("[year]-[month]-[day] [hour]:[minute]:[second].[subsecond]Z");
+const OFFSET_SHORT_DATE_TIME_FORMAT: &[FormatItem<'_>] = format_description!(
+    "[year]-[month]-[day] [hour]:[minute]:[second][offset_hour sign:mandatory]:[offset_minute]"
+);
+const OFFSET_DATE_TIME_FORMAT: &[FormatItem<'_>] = format_description!(
+    "[year]-[month]-[day] [hour]:[minute]:[second].[subsecond][offset_hour sign:mandatory]:[offset_minute]"
+);
+const LEGACY_DATE_TIME_FORMAT: &[FormatItem<'_>] = format_description!(
+    "[year]-[month]-[day] [hour]:[minute]:[second]:[subsecond] [offset_hour sign:mandatory]:[offset_minute]"
+);
+
+impl ToSql for OffsetDateTime {
+    #[inline]
+    fn to_sql(&self) -> Result<ToSqlOutput<'_>> {
+        // FIXME keep original offset
+        let time_string = self
+            .to_offset(UtcOffset::UTC)
+            .format(&PRIMITIVE_DATE_TIME_Z_FORMAT)
+            .map_err(|err| Error::ToSqlConversionFailure(err.into()))?;
+        Ok(ToSqlOutput::from(time_string))
+    }
+}
+
+impl FromSql for OffsetDateTime {
+    fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self> {
+        value.as_str().and_then(|s| {
+            if s.len() > 10 && s.as_bytes()[10] == b'T' {
+                // YYYY-MM-DDTHH:MM:SS.SSS[+-]HH:MM
+                return OffsetDateTime::parse(s, &Rfc3339)
+                    .map_err(|err| FromSqlError::Other(Box::new(err)));
+            }
+            let s = s.strip_suffix('Z').unwrap_or(s);
+            match s.len() {
+                len if len <= 19 => {
+                    // TODO YYYY-MM-DDTHH:MM:SS
+                    PrimitiveDateTime::parse(s, &PRIMITIVE_SHORT_DATE_TIME_FORMAT)
+                        .map(PrimitiveDateTime::assume_utc)
+                }
+                _ if s.as_bytes()[19] == b':' => {
+                    // legacy
+                    OffsetDateTime::parse(s, &LEGACY_DATE_TIME_FORMAT)
+                }
+                _ if s.as_bytes()[19] == b'.' => OffsetDateTime::parse(s, &OFFSET_DATE_TIME_FORMAT)
+                    .or_else(|err| {
+                        PrimitiveDateTime::parse(s, &PRIMITIVE_DATE_TIME_FORMAT)
+                            .map(PrimitiveDateTime::assume_utc)
+                            .map_err(|_| err)
+                    }),
+                _ => OffsetDateTime::parse(s, &OFFSET_SHORT_DATE_TIME_FORMAT),
+            }
+            .map_err(|err| FromSqlError::Other(Box::new(err)))
+        })
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::{Connection, Result};
+    use time::format_description::well_known::Rfc3339;
+    use time::OffsetDateTime;
+
+    #[test]
+    fn test_offset_date_time() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        db.execute_batch("CREATE TABLE foo (t TEXT, i INTEGER, f FLOAT)")?;
+
+        let mut ts_vec = vec![];
+
+        let make_datetime = |secs: i128, nanos: i128| {
+            OffsetDateTime::from_unix_timestamp_nanos(1_000_000_000 * secs + nanos).unwrap()
+        };
+
+        ts_vec.push(make_datetime(10_000, 0)); //January 1, 1970 2:46:40 AM
+        ts_vec.push(make_datetime(10_000, 1000)); //January 1, 1970 2:46:40 AM (and one microsecond)
+        ts_vec.push(make_datetime(1_500_391_124, 1_000_000)); //July 18, 2017
+        ts_vec.push(make_datetime(2_000_000_000, 2_000_000)); //May 18, 2033
+        ts_vec.push(make_datetime(3_000_000_000, 999_999_999)); //January 24, 2065
+        ts_vec.push(make_datetime(10_000_000_000, 0)); //November 20, 2286
+
+        for ts in ts_vec {
+            db.execute("INSERT INTO foo(t) VALUES (?1)", [ts])?;
+
+            let from: OffsetDateTime = db.one_column("SELECT t FROM foo")?;
+
+            db.execute("DELETE FROM foo", [])?;
+
+            assert_eq!(from, ts);
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn test_string_values() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        for (s, t) in vec![
+            (
+                "2013-10-07 08:23:19",
+                Ok(OffsetDateTime::parse("2013-10-07T08:23:19Z", &Rfc3339).unwrap()),
+            ),
+            (
+                "2013-10-07 08:23:19Z",
+                Ok(OffsetDateTime::parse("2013-10-07T08:23:19Z", &Rfc3339).unwrap()),
+            ),
+            (
+                "2013-10-07T08:23:19Z",
+                Ok(OffsetDateTime::parse("2013-10-07T08:23:19Z", &Rfc3339).unwrap()),
+            ),
+            (
+                "2013-10-07 08:23:19.120",
+                Ok(OffsetDateTime::parse("2013-10-07T08:23:19.120Z", &Rfc3339).unwrap()),
+            ),
+            (
+                "2013-10-07 08:23:19.120Z",
+                Ok(OffsetDateTime::parse("2013-10-07T08:23:19.120Z", &Rfc3339).unwrap()),
+            ),
+            (
+                "2013-10-07T08:23:19.120Z",
+                Ok(OffsetDateTime::parse("2013-10-07T08:23:19.120Z", &Rfc3339).unwrap()),
+            ),
+            (
+                "2013-10-07 04:23:19-04:00",
+                Ok(OffsetDateTime::parse("2013-10-07T04:23:19-04:00", &Rfc3339).unwrap()),
+            ),
+            (
+                "2013-10-07 04:23:19.120-04:00",
+                Ok(OffsetDateTime::parse("2013-10-07T04:23:19.120-04:00", &Rfc3339).unwrap()),
+            ),
+            (
+                "2013-10-07T04:23:19.120-04:00",
+                Ok(OffsetDateTime::parse("2013-10-07T04:23:19.120-04:00", &Rfc3339).unwrap()),
+            ),
+        ] {
+            let result: Result<OffsetDateTime> = db.query_row("SELECT ?1", [s], |r| r.get(0));
+            assert_eq!(result, t);
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn test_sqlite_functions() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        let result: Result<OffsetDateTime> = db.one_column("SELECT CURRENT_TIMESTAMP");
+        result.unwrap();
+        Ok(())
+    }
+
+    #[test]
+    fn test_param() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        let result: Result<bool> = db.query_row("SELECT 1 WHERE ?1 BETWEEN datetime('now', '-1 minute') AND datetime('now', '+1 minute')", [OffsetDateTime::now_utc()], |r| r.get(0));
+        result.unwrap();
+        Ok(())
+    }
+}
diff --git a/crates/rusqlite/src/types/to_sql.rs b/crates/rusqlite/src/types/to_sql.rs
new file mode 100644
index 0000000..c2bc007
--- /dev/null
+++ b/crates/rusqlite/src/types/to_sql.rs
@@ -0,0 +1,429 @@
+use super::{Null, Value, ValueRef};
+#[cfg(feature = "array")]
+use crate::vtab::array::Array;
+use crate::{Error, Result};
+use std::borrow::Cow;
+use std::convert::TryFrom;
+
+/// `ToSqlOutput` represents the possible output types for implementers of the
+/// [`ToSql`] trait.
+#[derive(Clone, Debug, PartialEq)]
+#[non_exhaustive]
+pub enum ToSqlOutput<'a> {
+    /// A borrowed SQLite-representable value.
+    Borrowed(ValueRef<'a>),
+
+    /// An owned SQLite-representable value.
+    Owned(Value),
+
+    /// A BLOB of the given length that is filled with
+    /// zeroes.
+    #[cfg(feature = "blob")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "blob")))]
+    ZeroBlob(i32),
+
+    /// `feature = "array"`
+    #[cfg(feature = "array")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "array")))]
+    Array(Array),
+}
+
+// Generically allow any type that can be converted into a ValueRef
+// to be converted into a ToSqlOutput as well.
+impl<'a, T: ?Sized> From<&'a T> for ToSqlOutput<'a>
+where
+    &'a T: Into<ValueRef<'a>>,
+{
+    #[inline]
+    fn from(t: &'a T) -> Self {
+        ToSqlOutput::Borrowed(t.into())
+    }
+}
+
+// We cannot also generically allow any type that can be converted
+// into a Value to be converted into a ToSqlOutput because of
+// coherence rules (https://github.com/rust-lang/rust/pull/46192),
+// so we'll manually implement it for all the types we know can
+// be converted into Values.
+macro_rules! from_value(
+    ($t:ty) => (
+        impl From<$t> for ToSqlOutput<'_> {
+            #[inline]
+            fn from(t: $t) -> Self { ToSqlOutput::Owned(t.into())}
+        }
+    )
+);
+from_value!(String);
+from_value!(Null);
+from_value!(bool);
+from_value!(i8);
+from_value!(i16);
+from_value!(i32);
+from_value!(i64);
+from_value!(isize);
+from_value!(u8);
+from_value!(u16);
+from_value!(u32);
+from_value!(f32);
+from_value!(f64);
+from_value!(Vec<u8>);
+
+// It would be nice if we could avoid the heap allocation (of the `Vec`) that
+// `i128` needs in `Into<Value>`, but it's probably fine for the moment, and not
+// worth adding another case to Value.
+#[cfg(feature = "i128_blob")]
+#[cfg_attr(docsrs, doc(cfg(feature = "i128_blob")))]
+from_value!(i128);
+
+#[cfg(feature = "uuid")]
+#[cfg_attr(docsrs, doc(cfg(feature = "uuid")))]
+from_value!(uuid::Uuid);
+
+impl ToSql for ToSqlOutput<'_> {
+    #[inline]
+    fn to_sql(&self) -> Result<ToSqlOutput<'_>> {
+        Ok(match *self {
+            ToSqlOutput::Borrowed(v) => ToSqlOutput::Borrowed(v),
+            ToSqlOutput::Owned(ref v) => ToSqlOutput::Borrowed(ValueRef::from(v)),
+
+            #[cfg(feature = "blob")]
+            ToSqlOutput::ZeroBlob(i) => ToSqlOutput::ZeroBlob(i),
+            #[cfg(feature = "array")]
+            ToSqlOutput::Array(ref a) => ToSqlOutput::Array(a.clone()),
+        })
+    }
+}
+
+/// A trait for types that can be converted into SQLite values. Returns
+/// [`Error::ToSqlConversionFailure`] if the conversion fails.
+pub trait ToSql {
+    /// Converts Rust value to SQLite value
+    fn to_sql(&self) -> Result<ToSqlOutput<'_>>;
+}
+
+impl<T: ToSql + ToOwned + ?Sized> ToSql for Cow<'_, T> {
+    #[inline]
+    fn to_sql(&self) -> Result<ToSqlOutput<'_>> {
+        self.as_ref().to_sql()
+    }
+}
+
+impl<T: ToSql + ?Sized> ToSql for Box<T> {
+    #[inline]
+    fn to_sql(&self) -> Result<ToSqlOutput<'_>> {
+        self.as_ref().to_sql()
+    }
+}
+
+impl<T: ToSql + ?Sized> ToSql for std::rc::Rc<T> {
+    #[inline]
+    fn to_sql(&self) -> Result<ToSqlOutput<'_>> {
+        self.as_ref().to_sql()
+    }
+}
+
+impl<T: ToSql + ?Sized> ToSql for std::sync::Arc<T> {
+    #[inline]
+    fn to_sql(&self) -> Result<ToSqlOutput<'_>> {
+        self.as_ref().to_sql()
+    }
+}
+
+// We should be able to use a generic impl like this:
+//
+// impl<T: Copy> ToSql for T where T: Into<Value> {
+//     fn to_sql(&self) -> Result<ToSqlOutput> {
+//         Ok(ToSqlOutput::from((*self).into()))
+//     }
+// }
+//
+// instead of the following macro, but this runs afoul of
+// https://github.com/rust-lang/rust/issues/30191 and reports conflicting
+// implementations even when there aren't any.
+
+macro_rules! to_sql_self(
+    ($t:ty) => (
+        impl ToSql for $t {
+            #[inline]
+            fn to_sql(&self) -> Result<ToSqlOutput<'_>> {
+                Ok(ToSqlOutput::from(*self))
+            }
+        }
+    )
+);
+
+to_sql_self!(Null);
+to_sql_self!(bool);
+to_sql_self!(i8);
+to_sql_self!(i16);
+to_sql_self!(i32);
+to_sql_self!(i64);
+to_sql_self!(isize);
+to_sql_self!(u8);
+to_sql_self!(u16);
+to_sql_self!(u32);
+to_sql_self!(f32);
+to_sql_self!(f64);
+
+#[cfg(feature = "i128_blob")]
+#[cfg_attr(docsrs, doc(cfg(feature = "i128_blob")))]
+to_sql_self!(i128);
+
+#[cfg(feature = "uuid")]
+#[cfg_attr(docsrs, doc(cfg(feature = "uuid")))]
+to_sql_self!(uuid::Uuid);
+
+macro_rules! to_sql_self_fallible(
+    ($t:ty) => (
+        impl ToSql for $t {
+            #[inline]
+            fn to_sql(&self) -> Result<ToSqlOutput<'_>> {
+                Ok(ToSqlOutput::Owned(Value::Integer(
+                    i64::try_from(*self).map_err(
+                        // TODO: Include the values in the error message.
+                        |err| Error::ToSqlConversionFailure(err.into())
+                    )?
+                )))
+            }
+        }
+    )
+);
+
+// Special implementations for usize and u64 because these conversions can fail.
+to_sql_self_fallible!(u64);
+to_sql_self_fallible!(usize);
+
+impl<T: ?Sized> ToSql for &'_ T
+where
+    T: ToSql,
+{
+    #[inline]
+    fn to_sql(&self) -> Result<ToSqlOutput<'_>> {
+        (*self).to_sql()
+    }
+}
+
+impl ToSql for String {
+    #[inline]
+    fn to_sql(&self) -> Result<ToSqlOutput<'_>> {
+        Ok(ToSqlOutput::from(self.as_str()))
+    }
+}
+
+impl ToSql for str {
+    #[inline]
+    fn to_sql(&self) -> Result<ToSqlOutput<'_>> {
+        Ok(ToSqlOutput::from(self))
+    }
+}
+
+impl ToSql for Vec<u8> {
+    #[inline]
+    fn to_sql(&self) -> Result<ToSqlOutput<'_>> {
+        Ok(ToSqlOutput::from(self.as_slice()))
+    }
+}
+
+impl<const N: usize> ToSql for [u8; N] {
+    #[inline]
+    fn to_sql(&self) -> Result<ToSqlOutput<'_>> {
+        Ok(ToSqlOutput::from(&self[..]))
+    }
+}
+
+impl ToSql for [u8] {
+    #[inline]
+    fn to_sql(&self) -> Result<ToSqlOutput<'_>> {
+        Ok(ToSqlOutput::from(self))
+    }
+}
+
+impl ToSql for Value {
+    #[inline]
+    fn to_sql(&self) -> Result<ToSqlOutput<'_>> {
+        Ok(ToSqlOutput::from(self))
+    }
+}
+
+impl<T: ToSql> ToSql for Option<T> {
+    #[inline]
+    fn to_sql(&self) -> Result<ToSqlOutput<'_>> {
+        match *self {
+            None => Ok(ToSqlOutput::from(Null)),
+            Some(ref t) => t.to_sql(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::ToSql;
+
+    fn is_to_sql<T: ToSql>() {}
+
+    #[test]
+    fn test_integral_types() {
+        is_to_sql::<i8>();
+        is_to_sql::<i16>();
+        is_to_sql::<i32>();
+        is_to_sql::<i64>();
+        is_to_sql::<u8>();
+        is_to_sql::<u16>();
+        is_to_sql::<u32>();
+    }
+
+    #[test]
+    fn test_u8_array() {
+        let a: [u8; 99] = [0u8; 99];
+        let _a: &[&dyn ToSql] = crate::params![a];
+        let r = ToSql::to_sql(&a);
+
+        r.unwrap();
+    }
+
+    #[test]
+    fn test_cow_str() {
+        use std::borrow::Cow;
+        let s = "str";
+        let cow: Cow<str> = Cow::Borrowed(s);
+        let r = cow.to_sql();
+        r.unwrap();
+        let cow: Cow<str> = Cow::Owned::<str>(String::from(s));
+        let r = cow.to_sql();
+        r.unwrap();
+        // Ensure this compiles.
+        let _p: &[&dyn ToSql] = crate::params![cow];
+    }
+
+    #[test]
+    fn test_box_dyn() {
+        let s: Box<dyn ToSql> = Box::new("Hello world!");
+        let _s: &[&dyn ToSql] = crate::params![s];
+        let r = ToSql::to_sql(&s);
+
+        r.unwrap();
+    }
+
+    #[test]
+    fn test_box_deref() {
+        let s: Box<str> = "Hello world!".into();
+        let _s: &[&dyn ToSql] = crate::params![s];
+        let r = s.to_sql();
+
+        r.unwrap();
+    }
+
+    #[test]
+    fn test_box_direct() {
+        let s: Box<str> = "Hello world!".into();
+        let _s: &[&dyn ToSql] = crate::params![s];
+        let r = ToSql::to_sql(&s);
+
+        r.unwrap();
+    }
+
+    #[test]
+    fn test_cells() {
+        use std::{rc::Rc, sync::Arc};
+
+        let source_str: Box<str> = "Hello world!".into();
+
+        let s: Rc<Box<str>> = Rc::new(source_str.clone());
+        let _s: &[&dyn ToSql] = crate::params![s];
+        let r = s.to_sql();
+        r.unwrap();
+
+        let s: Arc<Box<str>> = Arc::new(source_str.clone());
+        let _s: &[&dyn ToSql] = crate::params![s];
+        let r = s.to_sql();
+        r.unwrap();
+
+        let s: Arc<str> = Arc::from(&*source_str);
+        let _s: &[&dyn ToSql] = crate::params![s];
+        let r = s.to_sql();
+        r.unwrap();
+
+        let s: Arc<dyn ToSql> = Arc::new(source_str.clone());
+        let _s: &[&dyn ToSql] = crate::params![s];
+        let r = s.to_sql();
+        r.unwrap();
+
+        let s: Rc<str> = Rc::from(&*source_str);
+        let _s: &[&dyn ToSql] = crate::params![s];
+        let r = s.to_sql();
+        r.unwrap();
+
+        let s: Rc<dyn ToSql> = Rc::new(source_str);
+        let _s: &[&dyn ToSql] = crate::params![s];
+        let r = s.to_sql();
+        r.unwrap();
+    }
+
+    #[cfg(feature = "i128_blob")]
+    #[test]
+    fn test_i128() -> crate::Result<()> {
+        use crate::Connection;
+        let db = Connection::open_in_memory()?;
+        db.execute_batch("CREATE TABLE foo (i128 BLOB, desc TEXT)")?;
+        db.execute(
+            "
+            INSERT INTO foo(i128, desc) VALUES
+                (?1, 'zero'),
+                (?2, 'neg one'), (?3, 'neg two'),
+                (?4, 'pos one'), (?5, 'pos two'),
+                (?6, 'min'), (?7, 'max')",
+            [0i128, -1i128, -2i128, 1i128, 2i128, i128::MIN, i128::MAX],
+        )?;
+
+        let mut stmt = db.prepare("SELECT i128, desc FROM foo ORDER BY i128 ASC")?;
+
+        let res = stmt
+            .query_map([], |row| {
+                Ok((row.get::<_, i128>(0)?, row.get::<_, String>(1)?))
+            })?
+            .collect::<Result<Vec<_>, _>>()?;
+
+        assert_eq!(
+            res,
+            &[
+                (i128::MIN, "min".to_owned()),
+                (-2, "neg two".to_owned()),
+                (-1, "neg one".to_owned()),
+                (0, "zero".to_owned()),
+                (1, "pos one".to_owned()),
+                (2, "pos two".to_owned()),
+                (i128::MAX, "max".to_owned()),
+            ]
+        );
+        Ok(())
+    }
+
+    #[cfg(feature = "uuid")]
+    #[test]
+    fn test_uuid() -> crate::Result<()> {
+        use crate::{params, Connection};
+        use uuid::Uuid;
+
+        let db = Connection::open_in_memory()?;
+        db.execute_batch("CREATE TABLE foo (id BLOB CHECK(length(id) = 16), label TEXT);")?;
+
+        let id = Uuid::new_v4();
+
+        db.execute(
+            "INSERT INTO foo (id, label) VALUES (?1, ?2)",
+            params![id, "target"],
+        )?;
+
+        let mut stmt = db.prepare("SELECT id, label FROM foo WHERE id = ?1")?;
+
+        let mut rows = stmt.query(params![id])?;
+        let row = rows.next()?.unwrap();
+
+        let found_id: Uuid = row.get_unwrap(0);
+        let found_label: String = row.get_unwrap(1);
+
+        assert_eq!(found_id, id);
+        assert_eq!(found_label, "target");
+        Ok(())
+    }
+}
diff --git a/crates/rusqlite/src/types/url.rs b/crates/rusqlite/src/types/url.rs
new file mode 100644
index 0000000..0ebb59b
--- /dev/null
+++ b/crates/rusqlite/src/types/url.rs
@@ -0,0 +1,82 @@
+//! [`ToSql`] and [`FromSql`] implementation for [`url::Url`].
+use crate::types::{FromSql, FromSqlError, FromSqlResult, ToSql, ToSqlOutput, ValueRef};
+use crate::Result;
+use url::Url;
+
+/// Serialize `Url` to text.
+impl ToSql for Url {
+    #[inline]
+    fn to_sql(&self) -> Result<ToSqlOutput<'_>> {
+        Ok(ToSqlOutput::from(self.as_str()))
+    }
+}
+
+/// Deserialize text to `Url`.
+impl FromSql for Url {
+    #[inline]
+    fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self> {
+        match value {
+            ValueRef::Text(s) => {
+                let s = std::str::from_utf8(s).map_err(|e| FromSqlError::Other(Box::new(e)))?;
+                Url::parse(s).map_err(|e| FromSqlError::Other(Box::new(e)))
+            }
+            _ => Err(FromSqlError::InvalidType),
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::{params, Connection, Error, Result};
+    use url::{ParseError, Url};
+
+    fn checked_memory_handle() -> Result<Connection> {
+        let db = Connection::open_in_memory()?;
+        db.execute_batch("CREATE TABLE urls (i INTEGER, v TEXT)")?;
+        Ok(db)
+    }
+
+    fn get_url(db: &Connection, id: i64) -> Result<Url> {
+        db.query_row("SELECT v FROM urls WHERE i = ?", [id], |r| r.get(0))
+    }
+
+    #[test]
+    fn test_sql_url() -> Result<()> {
+        let db = &checked_memory_handle()?;
+
+        let url0 = Url::parse("http://www.example1.com").unwrap();
+        let url1 = Url::parse("http://www.example1.com/👌").unwrap();
+        let url2 = "http://www.example2.com/👌";
+
+        db.execute(
+            "INSERT INTO urls (i, v) VALUES (0, ?1), (1, ?2), (2, ?3), (3, ?4)",
+            // also insert a non-hex encoded url (which might be present if it was
+            // inserted separately)
+            params![url0, url1, url2, "illegal"],
+        )?;
+
+        assert_eq!(get_url(db, 0)?, url0);
+
+        assert_eq!(get_url(db, 1)?, url1);
+
+        // Should successfully read it, even though it wasn't inserted as an
+        // escaped url.
+        let out_url2: Url = get_url(db, 2)?;
+        assert_eq!(out_url2, Url::parse(url2).unwrap());
+
+        // Make sure the conversion error comes through correctly.
+        let err = get_url(db, 3).unwrap_err();
+        match err {
+            Error::FromSqlConversionFailure(_, _, e) => {
+                assert_eq!(
+                    *e.downcast::<ParseError>().unwrap(),
+                    ParseError::RelativeUrlWithoutBase,
+                );
+            }
+            e => {
+                panic!("Expected conversion failure, got {}", e);
+            }
+        }
+        Ok(())
+    }
+}
diff --git a/crates/rusqlite/src/types/value.rs b/crates/rusqlite/src/types/value.rs
new file mode 100644
index 0000000..ca3ee9f
--- /dev/null
+++ b/crates/rusqlite/src/types/value.rs
@@ -0,0 +1,142 @@
+use super::{Null, Type};
+
+/// Owning [dynamic type value](http://sqlite.org/datatype3.html). Value's type is typically
+/// dictated by SQLite (not by the caller).
+///
+/// See [`ValueRef`](crate::types::ValueRef) for a non-owning dynamic type
+/// value.
+#[derive(Clone, Debug, PartialEq)]
+pub enum Value {
+    /// The value is a `NULL` value.
+    Null,
+    /// The value is a signed integer.
+    Integer(i64),
+    /// The value is a floating point number.
+    Real(f64),
+    /// The value is a text string.
+    Text(String),
+    /// The value is a blob of data
+    Blob(Vec<u8>),
+}
+
+impl From<Null> for Value {
+    #[inline]
+    fn from(_: Null) -> Value {
+        Value::Null
+    }
+}
+
+impl From<bool> for Value {
+    #[inline]
+    fn from(i: bool) -> Value {
+        Value::Integer(i as i64)
+    }
+}
+
+impl From<isize> for Value {
+    #[inline]
+    fn from(i: isize) -> Value {
+        Value::Integer(i as i64)
+    }
+}
+
+#[cfg(feature = "i128_blob")]
+#[cfg_attr(docsrs, doc(cfg(feature = "i128_blob")))]
+impl From<i128> for Value {
+    #[inline]
+    fn from(i: i128) -> Value {
+        // We store these biased (e.g. with the most significant bit flipped)
+        // so that comparisons with negative numbers work properly.
+        Value::Blob(i128::to_be_bytes(i ^ (1_i128 << 127)).to_vec())
+    }
+}
+
+#[cfg(feature = "uuid")]
+#[cfg_attr(docsrs, doc(cfg(feature = "uuid")))]
+impl From<uuid::Uuid> for Value {
+    #[inline]
+    fn from(id: uuid::Uuid) -> Value {
+        Value::Blob(id.as_bytes().to_vec())
+    }
+}
+
+macro_rules! from_i64(
+    ($t:ty) => (
+        impl From<$t> for Value {
+            #[inline]
+            fn from(i: $t) -> Value {
+                Value::Integer(i64::from(i))
+            }
+        }
+    )
+);
+
+from_i64!(i8);
+from_i64!(i16);
+from_i64!(i32);
+from_i64!(u8);
+from_i64!(u16);
+from_i64!(u32);
+
+impl From<i64> for Value {
+    #[inline]
+    fn from(i: i64) -> Value {
+        Value::Integer(i)
+    }
+}
+
+impl From<f32> for Value {
+    #[inline]
+    fn from(f: f32) -> Value {
+        Value::Real(f.into())
+    }
+}
+
+impl From<f64> for Value {
+    #[inline]
+    fn from(f: f64) -> Value {
+        Value::Real(f)
+    }
+}
+
+impl From<String> for Value {
+    #[inline]
+    fn from(s: String) -> Value {
+        Value::Text(s)
+    }
+}
+
+impl From<Vec<u8>> for Value {
+    #[inline]
+    fn from(v: Vec<u8>) -> Value {
+        Value::Blob(v)
+    }
+}
+
+impl<T> From<Option<T>> for Value
+where
+    T: Into<Value>,
+{
+    #[inline]
+    fn from(v: Option<T>) -> Value {
+        match v {
+            Some(x) => x.into(),
+            None => Value::Null,
+        }
+    }
+}
+
+impl Value {
+    /// Returns SQLite fundamental datatype.
+    #[inline]
+    #[must_use]
+    pub fn data_type(&self) -> Type {
+        match *self {
+            Value::Null => Type::Null,
+            Value::Integer(_) => Type::Integer,
+            Value::Real(_) => Type::Real,
+            Value::Text(_) => Type::Text,
+            Value::Blob(_) => Type::Blob,
+        }
+    }
+}
diff --git a/crates/rusqlite/src/types/value_ref.rs b/crates/rusqlite/src/types/value_ref.rs
new file mode 100644
index 0000000..12806f8
--- /dev/null
+++ b/crates/rusqlite/src/types/value_ref.rs
@@ -0,0 +1,263 @@
+use super::{Type, Value};
+use crate::types::{FromSqlError, FromSqlResult};
+
+/// A non-owning [dynamic type value](http://sqlite.org/datatype3.html). Typically the
+/// memory backing this value is owned by SQLite.
+///
+/// See [`Value`](Value) for an owning dynamic type value.
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub enum ValueRef<'a> {
+    /// The value is a `NULL` value.
+    Null,
+    /// The value is a signed integer.
+    Integer(i64),
+    /// The value is a floating point number.
+    Real(f64),
+    /// The value is a text string.
+    Text(&'a [u8]),
+    /// The value is a blob of data
+    Blob(&'a [u8]),
+}
+
+impl ValueRef<'_> {
+    /// Returns SQLite fundamental datatype.
+    #[inline]
+    #[must_use]
+    pub fn data_type(&self) -> Type {
+        match *self {
+            ValueRef::Null => Type::Null,
+            ValueRef::Integer(_) => Type::Integer,
+            ValueRef::Real(_) => Type::Real,
+            ValueRef::Text(_) => Type::Text,
+            ValueRef::Blob(_) => Type::Blob,
+        }
+    }
+}
+
+impl<'a> ValueRef<'a> {
+    /// If `self` is case `Integer`, returns the integral value. Otherwise,
+    /// returns [`Err(Error::InvalidColumnType)`](crate::Error::
+    /// InvalidColumnType).
+    #[inline]
+    pub fn as_i64(&self) -> FromSqlResult<i64> {
+        match *self {
+            ValueRef::Integer(i) => Ok(i),
+            _ => Err(FromSqlError::InvalidType),
+        }
+    }
+
+    /// If `self` is case `Null` returns None.
+    /// If `self` is case `Integer`, returns the integral value.
+    /// Otherwise returns [`Err(Error::InvalidColumnType)`](crate::Error::
+    /// InvalidColumnType).
+    #[inline]
+    pub fn as_i64_or_null(&self) -> FromSqlResult<Option<i64>> {
+        match *self {
+            ValueRef::Null => Ok(None),
+            ValueRef::Integer(i) => Ok(Some(i)),
+            _ => Err(FromSqlError::InvalidType),
+        }
+    }
+
+    /// If `self` is case `Real`, returns the floating point value. Otherwise,
+    /// returns [`Err(Error::InvalidColumnType)`](crate::Error::
+    /// InvalidColumnType).
+    #[inline]
+    pub fn as_f64(&self) -> FromSqlResult<f64> {
+        match *self {
+            ValueRef::Real(f) => Ok(f),
+            _ => Err(FromSqlError::InvalidType),
+        }
+    }
+
+    /// If `self` is case `Null` returns None.
+    /// If `self` is case `Real`, returns the floating point value.
+    /// Otherwise returns [`Err(Error::InvalidColumnType)`](crate::Error::
+    /// InvalidColumnType).
+    #[inline]
+    pub fn as_f64_or_null(&self) -> FromSqlResult<Option<f64>> {
+        match *self {
+            ValueRef::Null => Ok(None),
+            ValueRef::Real(f) => Ok(Some(f)),
+            _ => Err(FromSqlError::InvalidType),
+        }
+    }
+
+    /// If `self` is case `Text`, returns the string value. Otherwise, returns
+    /// [`Err(Error::InvalidColumnType)`](crate::Error::InvalidColumnType).
+    #[inline]
+    pub fn as_str(&self) -> FromSqlResult<&'a str> {
+        match *self {
+            ValueRef::Text(t) => {
+                std::str::from_utf8(t).map_err(|e| FromSqlError::Other(Box::new(e)))
+            }
+            _ => Err(FromSqlError::InvalidType),
+        }
+    }
+
+    /// If `self` is case `Null` returns None.
+    /// If `self` is case `Text`, returns the string value.
+    /// Otherwise returns [`Err(Error::InvalidColumnType)`](crate::Error::
+    /// InvalidColumnType).
+    #[inline]
+    pub fn as_str_or_null(&self) -> FromSqlResult<Option<&'a str>> {
+        match *self {
+            ValueRef::Null => Ok(None),
+            ValueRef::Text(t) => std::str::from_utf8(t)
+                .map_err(|e| FromSqlError::Other(Box::new(e)))
+                .map(Some),
+            _ => Err(FromSqlError::InvalidType),
+        }
+    }
+
+    /// If `self` is case `Blob`, returns the byte slice. Otherwise, returns
+    /// [`Err(Error::InvalidColumnType)`](crate::Error::InvalidColumnType).
+    #[inline]
+    pub fn as_blob(&self) -> FromSqlResult<&'a [u8]> {
+        match *self {
+            ValueRef::Blob(b) => Ok(b),
+            _ => Err(FromSqlError::InvalidType),
+        }
+    }
+
+    /// If `self` is case `Null` returns None.
+    /// If `self` is case `Blob`, returns the byte slice.
+    /// Otherwise returns [`Err(Error::InvalidColumnType)`](crate::Error::
+    /// InvalidColumnType).
+    #[inline]
+    pub fn as_blob_or_null(&self) -> FromSqlResult<Option<&'a [u8]>> {
+        match *self {
+            ValueRef::Null => Ok(None),
+            ValueRef::Blob(b) => Ok(Some(b)),
+            _ => Err(FromSqlError::InvalidType),
+        }
+    }
+
+    /// Returns the byte slice that makes up this ValueRef if it's either
+    /// [`ValueRef::Blob`] or [`ValueRef::Text`].
+    #[inline]
+    pub fn as_bytes(&self) -> FromSqlResult<&'a [u8]> {
+        match self {
+            ValueRef::Text(s) | ValueRef::Blob(s) => Ok(s),
+            _ => Err(FromSqlError::InvalidType),
+        }
+    }
+
+    /// If `self` is case `Null` returns None.
+    /// If `self` is [`ValueRef::Blob`] or [`ValueRef::Text`] returns the byte
+    /// slice that makes up this value
+    #[inline]
+    pub fn as_bytes_or_null(&self) -> FromSqlResult<Option<&'a [u8]>> {
+        match *self {
+            ValueRef::Null => Ok(None),
+            ValueRef::Text(s) | ValueRef::Blob(s) => Ok(Some(s)),
+            _ => Err(FromSqlError::InvalidType),
+        }
+    }
+}
+
+impl From<ValueRef<'_>> for Value {
+    #[inline]
+    fn from(borrowed: ValueRef<'_>) -> Value {
+        match borrowed {
+            ValueRef::Null => Value::Null,
+            ValueRef::Integer(i) => Value::Integer(i),
+            ValueRef::Real(r) => Value::Real(r),
+            ValueRef::Text(s) => {
+                let s = std::str::from_utf8(s).expect("invalid UTF-8");
+                Value::Text(s.to_string())
+            }
+            ValueRef::Blob(b) => Value::Blob(b.to_vec()),
+        }
+    }
+}
+
+impl<'a> From<&'a str> for ValueRef<'a> {
+    #[inline]
+    fn from(s: &str) -> ValueRef<'_> {
+        ValueRef::Text(s.as_bytes())
+    }
+}
+
+impl<'a> From<&'a [u8]> for ValueRef<'a> {
+    #[inline]
+    fn from(s: &[u8]) -> ValueRef<'_> {
+        ValueRef::Blob(s)
+    }
+}
+
+impl<'a> From<&'a Value> for ValueRef<'a> {
+    #[inline]
+    fn from(value: &'a Value) -> ValueRef<'a> {
+        match *value {
+            Value::Null => ValueRef::Null,
+            Value::Integer(i) => ValueRef::Integer(i),
+            Value::Real(r) => ValueRef::Real(r),
+            Value::Text(ref s) => ValueRef::Text(s.as_bytes()),
+            Value::Blob(ref b) => ValueRef::Blob(b),
+        }
+    }
+}
+
+impl<'a, T> From<Option<T>> for ValueRef<'a>
+where
+    T: Into<ValueRef<'a>>,
+{
+    #[inline]
+    fn from(s: Option<T>) -> ValueRef<'a> {
+        match s {
+            Some(x) => x.into(),
+            None => ValueRef::Null,
+        }
+    }
+}
+
+#[cfg(any(feature = "functions", feature = "session", feature = "vtab"))]
+impl<'a> ValueRef<'a> {
+    pub(crate) unsafe fn from_value(value: *mut crate::ffi::sqlite3_value) -> ValueRef<'a> {
+        use crate::ffi;
+        use std::slice::from_raw_parts;
+
+        match ffi::sqlite3_value_type(value) {
+            ffi::SQLITE_NULL => ValueRef::Null,
+            ffi::SQLITE_INTEGER => ValueRef::Integer(ffi::sqlite3_value_int64(value)),
+            ffi::SQLITE_FLOAT => ValueRef::Real(ffi::sqlite3_value_double(value)),
+            ffi::SQLITE_TEXT => {
+                let text = ffi::sqlite3_value_text(value);
+                let len = ffi::sqlite3_value_bytes(value);
+                assert!(
+                    !text.is_null(),
+                    "unexpected SQLITE_TEXT value type with NULL data"
+                );
+                let s = from_raw_parts(text.cast::<u8>(), len as usize);
+                ValueRef::Text(s)
+            }
+            ffi::SQLITE_BLOB => {
+                let (blob, len) = (
+                    ffi::sqlite3_value_blob(value),
+                    ffi::sqlite3_value_bytes(value),
+                );
+
+                assert!(
+                    len >= 0,
+                    "unexpected negative return from sqlite3_value_bytes"
+                );
+                if len > 0 {
+                    assert!(
+                        !blob.is_null(),
+                        "unexpected SQLITE_BLOB value type with NULL data"
+                    );
+                    ValueRef::Blob(from_raw_parts(blob.cast::<u8>(), len as usize))
+                } else {
+                    // The return value from sqlite3_value_blob() for a zero-length BLOB
+                    // is a NULL pointer.
+                    ValueRef::Blob(&[])
+                }
+            }
+            _ => unreachable!("sqlite3_value_type returned invalid value"),
+        }
+    }
+
+    // TODO sqlite3_value_nochange // 3.22.0 & VTab xUpdate
+    // TODO sqlite3_value_frombind // 3.28.0
+}
diff --git a/crates/rusqlite/src/unlock_notify.rs b/crates/rusqlite/src/unlock_notify.rs
new file mode 100644
index 0000000..065c52d
--- /dev/null
+++ b/crates/rusqlite/src/unlock_notify.rs
@@ -0,0 +1,117 @@
+//! [Unlock Notification](http://sqlite.org/unlock_notify.html)
+
+use std::os::raw::c_int;
+use std::os::raw::c_void;
+use std::panic::catch_unwind;
+use std::sync::{Condvar, Mutex};
+
+use crate::ffi;
+
+struct UnlockNotification {
+    cond: Condvar,      // Condition variable to wait on
+    mutex: Mutex<bool>, // Mutex to protect structure
+}
+
+#[allow(clippy::mutex_atomic)]
+impl UnlockNotification {
+    fn new() -> UnlockNotification {
+        UnlockNotification {
+            cond: Condvar::new(),
+            mutex: Mutex::new(false),
+        }
+    }
+
+    fn fired(&self) {
+        let mut flag = unpoison(self.mutex.lock());
+        *flag = true;
+        self.cond.notify_one();
+    }
+
+    fn wait(&self) {
+        let mut fired = unpoison(self.mutex.lock());
+        while !*fired {
+            fired = unpoison(self.cond.wait(fired));
+        }
+    }
+}
+
+#[inline]
+fn unpoison<T>(r: Result<T, std::sync::PoisonError<T>>) -> T {
+    r.unwrap_or_else(std::sync::PoisonError::into_inner)
+}
+
+/// This function is an unlock-notify callback
+unsafe extern "C" fn unlock_notify_cb(ap_arg: *mut *mut c_void, n_arg: c_int) {
+    use std::slice::from_raw_parts;
+    let args = from_raw_parts(ap_arg as *const &UnlockNotification, n_arg as usize);
+    for un in args {
+        drop(catch_unwind(std::panic::AssertUnwindSafe(|| un.fired())));
+    }
+}
+
+pub unsafe fn is_locked(db: *mut ffi::sqlite3, rc: c_int) -> bool {
+    rc == ffi::SQLITE_LOCKED_SHAREDCACHE
+        || (rc & 0xFF) == ffi::SQLITE_LOCKED
+            && ffi::sqlite3_extended_errcode(db) == ffi::SQLITE_LOCKED_SHAREDCACHE
+}
+
+/// This function assumes that an SQLite API call (either `sqlite3_prepare_v2()`
+/// or `sqlite3_step()`) has just returned `SQLITE_LOCKED`. The argument is the
+/// associated database connection.
+///
+/// This function calls `sqlite3_unlock_notify()` to register for an
+/// unlock-notify callback, then blocks until that callback is delivered
+/// and returns `SQLITE_OK`. The caller should then retry the failed operation.
+///
+/// Or, if `sqlite3_unlock_notify()` indicates that to block would deadlock
+/// the system, then this function returns `SQLITE_LOCKED` immediately. In
+/// this case the caller should not retry the operation and should roll
+/// back the current transaction (if any).
+#[cfg(feature = "unlock_notify")]
+pub unsafe fn wait_for_unlock_notify(db: *mut ffi::sqlite3) -> c_int {
+    let un = UnlockNotification::new();
+    /* Register for an unlock-notify callback. */
+    let rc = ffi::sqlite3_unlock_notify(
+        db,
+        Some(unlock_notify_cb),
+        &un as *const UnlockNotification as *mut c_void,
+    );
+    debug_assert!(
+        rc == ffi::SQLITE_LOCKED || rc == ffi::SQLITE_LOCKED_SHAREDCACHE || rc == ffi::SQLITE_OK
+    );
+    if rc == ffi::SQLITE_OK {
+        un.wait();
+    }
+    rc
+}
+
+#[cfg(test)]
+mod test {
+    use crate::{Connection, OpenFlags, Result, Transaction, TransactionBehavior};
+    use std::sync::mpsc::sync_channel;
+    use std::thread;
+    use std::time;
+
+    #[test]
+    fn test_unlock_notify() -> Result<()> {
+        let url = "file::memory:?cache=shared";
+        let flags = OpenFlags::SQLITE_OPEN_READ_WRITE | OpenFlags::SQLITE_OPEN_URI;
+        let db1 = Connection::open_with_flags(url, flags)?;
+        db1.execute_batch("CREATE TABLE foo (x)")?;
+        let (rx, tx) = sync_channel(0);
+        let child = thread::spawn(move || {
+            let mut db2 = Connection::open_with_flags(url, flags).unwrap();
+            let tx2 = Transaction::new(&mut db2, TransactionBehavior::Immediate).unwrap();
+            tx2.execute_batch("INSERT INTO foo VALUES (42)").unwrap();
+            rx.send(1).unwrap();
+            let ten_millis = time::Duration::from_millis(10);
+            thread::sleep(ten_millis);
+            tx2.commit().unwrap();
+        });
+        assert_eq!(tx.recv().unwrap(), 1);
+        let the_answer: i64 = db1.one_column("SELECT x FROM foo")?;
+        assert_eq!(42i64, the_answer);
+        child.join().unwrap();
+        Ok(())
+    }
+}
diff --git a/crates/rusqlite/src/util/mod.rs b/crates/rusqlite/src/util/mod.rs
new file mode 100644
index 0000000..e81e3c0
--- /dev/null
+++ b/crates/rusqlite/src/util/mod.rs
@@ -0,0 +1,9 @@
+// Internal utilities
+pub(crate) mod param_cache;
+mod small_cstr;
+pub(crate) use param_cache::ParamIndexCache;
+pub(crate) use small_cstr::SmallCString;
+
+// Doesn't use any modern features or vtab stuff, but is only used by them.
+mod sqlite_string;
+pub(crate) use sqlite_string::SqliteMallocString;
diff --git a/crates/rusqlite/src/util/param_cache.rs b/crates/rusqlite/src/util/param_cache.rs
new file mode 100644
index 0000000..6faced9
--- /dev/null
+++ b/crates/rusqlite/src/util/param_cache.rs
@@ -0,0 +1,60 @@
+use super::SmallCString;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+
+/// Maps parameter names to parameter indices.
+#[derive(Default, Clone, Debug)]
+// BTreeMap seems to do better here unless we want to pull in a custom hash
+// function.
+pub(crate) struct ParamIndexCache(RefCell<BTreeMap<SmallCString, usize>>);
+
+impl ParamIndexCache {
+    pub fn get_or_insert_with<F>(&self, s: &str, func: F) -> Option<usize>
+    where
+        F: FnOnce(&std::ffi::CStr) -> Option<usize>,
+    {
+        let mut cache = self.0.borrow_mut();
+        // Avoid entry API, needs allocation to test membership.
+        if let Some(v) = cache.get(s) {
+            return Some(*v);
+        }
+        // If there's an internal nul in the name it couldn't have been a
+        // parameter, so early return here is ok.
+        let name = SmallCString::new(s).ok()?;
+        let val = func(&name)?;
+        cache.insert(name, val);
+        Some(val)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    #[test]
+    fn test_cache() {
+        let p = ParamIndexCache::default();
+        let v = p.get_or_insert_with("foo", |cstr| {
+            assert_eq!(cstr.to_str().unwrap(), "foo");
+            Some(3)
+        });
+        assert_eq!(v, Some(3));
+        let v = p.get_or_insert_with("foo", |_| {
+            panic!("shouldn't be called this time");
+        });
+        assert_eq!(v, Some(3));
+        let v = p.get_or_insert_with("gar\0bage", |_| {
+            panic!("shouldn't be called here either");
+        });
+        assert_eq!(v, None);
+        let v = p.get_or_insert_with("bar", |cstr| {
+            assert_eq!(cstr.to_str().unwrap(), "bar");
+            None
+        });
+        assert_eq!(v, None);
+        let v = p.get_or_insert_with("bar", |cstr| {
+            assert_eq!(cstr.to_str().unwrap(), "bar");
+            Some(30)
+        });
+        assert_eq!(v, Some(30));
+    }
+}
diff --git a/crates/rusqlite/src/util/small_cstr.rs b/crates/rusqlite/src/util/small_cstr.rs
new file mode 100644
index 0000000..1ec7374
--- /dev/null
+++ b/crates/rusqlite/src/util/small_cstr.rs
@@ -0,0 +1,170 @@
+use smallvec::{smallvec, SmallVec};
+use std::ffi::{CStr, CString, NulError};
+
+/// Similar to `std::ffi::CString`, but avoids heap allocating if the string is
+/// small enough. Also guarantees it's input is UTF-8 -- used for cases where we
+/// need to pass a NUL-terminated string to SQLite, and we have a `&str`.
+#[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub(crate) struct SmallCString(SmallVec<[u8; 16]>);
+
+impl SmallCString {
+    #[inline]
+    pub fn new(s: &str) -> Result<Self, NulError> {
+        if s.as_bytes().contains(&0_u8) {
+            return Err(Self::fabricate_nul_error(s));
+        }
+        let mut buf = SmallVec::with_capacity(s.len() + 1);
+        buf.extend_from_slice(s.as_bytes());
+        buf.push(0);
+        let res = Self(buf);
+        res.debug_checks();
+        Ok(res)
+    }
+
+    #[inline]
+    pub fn as_str(&self) -> &str {
+        self.debug_checks();
+        // Constructor takes a &str so this is safe.
+        unsafe { std::str::from_utf8_unchecked(self.as_bytes_without_nul()) }
+    }
+
+    /// Get the bytes not including the NUL terminator. E.g. the bytes which
+    /// make up our `str`:
+    /// - `SmallCString::new("foo").as_bytes_without_nul() == b"foo"`
+    /// - `SmallCString::new("foo").as_bytes_with_nul() == b"foo\0"`
+    #[inline]
+    pub fn as_bytes_without_nul(&self) -> &[u8] {
+        self.debug_checks();
+        &self.0[..self.len()]
+    }
+
+    /// Get the bytes behind this str *including* the NUL terminator. This
+    /// should never return an empty slice.
+    #[inline]
+    pub fn as_bytes_with_nul(&self) -> &[u8] {
+        self.debug_checks();
+        &self.0
+    }
+
+    #[inline]
+    #[cfg(debug_assertions)]
+    fn debug_checks(&self) {
+        debug_assert_ne!(self.0.len(), 0);
+        debug_assert_eq!(self.0[self.0.len() - 1], 0);
+        let strbytes = &self.0[..(self.0.len() - 1)];
+        debug_assert!(!strbytes.contains(&0));
+        debug_assert!(std::str::from_utf8(strbytes).is_ok());
+    }
+
+    #[inline]
+    #[cfg(not(debug_assertions))]
+    fn debug_checks(&self) {}
+
+    #[inline]
+    pub fn len(&self) -> usize {
+        debug_assert_ne!(self.0.len(), 0);
+        self.0.len() - 1
+    }
+
+    #[inline]
+    #[allow(unused)] // clippy wants this function.
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    #[inline]
+    pub fn as_cstr(&self) -> &CStr {
+        let bytes = self.as_bytes_with_nul();
+        debug_assert!(CStr::from_bytes_with_nul(bytes).is_ok());
+        unsafe { CStr::from_bytes_with_nul_unchecked(bytes) }
+    }
+
+    #[cold]
+    fn fabricate_nul_error(b: &str) -> NulError {
+        CString::new(b).unwrap_err()
+    }
+}
+
+impl Default for SmallCString {
+    #[inline]
+    fn default() -> Self {
+        Self(smallvec![0])
+    }
+}
+
+impl std::fmt::Debug for SmallCString {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_tuple("SmallCString").field(&self.as_str()).finish()
+    }
+}
+
+impl std::ops::Deref for SmallCString {
+    type Target = CStr;
+
+    #[inline]
+    fn deref(&self) -> &CStr {
+        self.as_cstr()
+    }
+}
+
+impl PartialEq<SmallCString> for str {
+    #[inline]
+    fn eq(&self, s: &SmallCString) -> bool {
+        s.as_bytes_without_nul() == self.as_bytes()
+    }
+}
+
+impl PartialEq<str> for SmallCString {
+    #[inline]
+    fn eq(&self, s: &str) -> bool {
+        self.as_bytes_without_nul() == s.as_bytes()
+    }
+}
+
+impl std::borrow::Borrow<str> for SmallCString {
+    #[inline]
+    fn borrow(&self) -> &str {
+        self.as_str()
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_small_cstring() {
+        // We don't go through the normal machinery for default, so make sure
+        // things work.
+        assert_eq!(SmallCString::default().0, SmallCString::new("").unwrap().0);
+        assert_eq!(SmallCString::new("foo").unwrap().len(), 3);
+        assert_eq!(
+            SmallCString::new("foo").unwrap().as_bytes_with_nul(),
+            b"foo\0"
+        );
+        assert_eq!(
+            SmallCString::new("foo").unwrap().as_bytes_without_nul(),
+            b"foo",
+        );
+
+        assert_eq!(SmallCString::new("😀").unwrap().len(), 4);
+        assert_eq!(
+            SmallCString::new("😀").unwrap().0.as_slice(),
+            b"\xf0\x9f\x98\x80\0",
+        );
+        assert_eq!(
+            SmallCString::new("😀").unwrap().as_bytes_without_nul(),
+            b"\xf0\x9f\x98\x80",
+        );
+
+        assert_eq!(SmallCString::new("").unwrap().len(), 0);
+        assert!(SmallCString::new("").unwrap().is_empty());
+
+        assert_eq!(SmallCString::new("").unwrap().0.as_slice(), b"\0");
+        assert_eq!(SmallCString::new("").unwrap().as_bytes_without_nul(), b"");
+
+        SmallCString::new("\0").unwrap_err();
+        SmallCString::new("\0abc").unwrap_err();
+        SmallCString::new("abc\0").unwrap_err();
+    }
+}
diff --git a/crates/rusqlite/src/util/sqlite_string.rs b/crates/rusqlite/src/util/sqlite_string.rs
new file mode 100644
index 0000000..ae24c28
--- /dev/null
+++ b/crates/rusqlite/src/util/sqlite_string.rs
@@ -0,0 +1,234 @@
+// This is used when either vtab or modern-sqlite is on. Different methods are
+// used in each feature. Avoid having to track this for each function. We will
+// still warn for anything that's not used by either, though.
+#![cfg_attr(not(feature = "vtab"), allow(dead_code))]
+use crate::ffi;
+use std::marker::PhantomData;
+use std::os::raw::{c_char, c_int};
+use std::ptr::NonNull;
+
+/// A string we own that's allocated on the SQLite heap. Automatically calls
+/// `sqlite3_free` when dropped, unless `into_raw` (or `into_inner`) is called
+/// on it. If constructed from a rust string, `sqlite3_malloc` is used.
+///
+/// It has identical representation to a nonnull `*mut c_char`, so you can use
+/// it transparently as one. It's nonnull, so Option<SqliteMallocString> can be
+/// used for nullable ones (it's still just one pointer).
+///
+/// Most strings shouldn't use this! Only places where the string needs to be
+/// freed with `sqlite3_free`. This includes `sqlite3_extended_sql` results,
+/// some error message pointers... Note that misuse is extremely dangerous!
+///
+/// Note that this is *not* a lossless interface. Incoming strings with internal
+/// NULs are modified, and outgoing strings which are non-UTF8 are modified.
+/// This seems unavoidable -- it tries very hard to not panic.
+#[repr(transparent)]
+pub(crate) struct SqliteMallocString {
+    ptr: NonNull<c_char>,
+    _boo: PhantomData<Box<[c_char]>>,
+}
+// This is owned data for a primitive type, and thus it's safe to implement
+// these. That said, nothing needs them, and they make things easier to misuse.
+
+// unsafe impl Send for SqliteMallocString {}
+// unsafe impl Sync for SqliteMallocString {}
+
+impl SqliteMallocString {
+    /// SAFETY: Caller must be certain that `m` a nul-terminated c string
+    /// allocated by `sqlite3_malloc`, and that SQLite expects us to free it!
+    #[inline]
+    pub(crate) unsafe fn from_raw_nonnull(ptr: NonNull<c_char>) -> Self {
+        Self {
+            ptr,
+            _boo: PhantomData,
+        }
+    }
+
+    /// SAFETY: Caller must be certain that `m` a nul-terminated c string
+    /// allocated by `sqlite3_malloc`, and that SQLite expects us to free it!
+    #[inline]
+    pub(crate) unsafe fn from_raw(ptr: *mut c_char) -> Option<Self> {
+        NonNull::new(ptr).map(|p| Self::from_raw_nonnull(p))
+    }
+
+    /// Get the pointer behind `self`. After this is called, we no longer manage
+    /// it.
+    #[inline]
+    pub(crate) fn into_inner(self) -> NonNull<c_char> {
+        let p = self.ptr;
+        std::mem::forget(self);
+        p
+    }
+
+    /// Get the pointer behind `self`. After this is called, we no longer manage
+    /// it.
+    #[inline]
+    pub(crate) fn into_raw(self) -> *mut c_char {
+        self.into_inner().as_ptr()
+    }
+
+    /// Borrow the pointer behind `self`. We still manage it when this function
+    /// returns. If you want to relinquish ownership, use `into_raw`.
+    #[inline]
+    pub(crate) fn as_ptr(&self) -> *const c_char {
+        self.ptr.as_ptr()
+    }
+
+    #[inline]
+    pub(crate) fn as_cstr(&self) -> &std::ffi::CStr {
+        unsafe { std::ffi::CStr::from_ptr(self.as_ptr()) }
+    }
+
+    #[inline]
+    pub(crate) fn to_string_lossy(&self) -> std::borrow::Cow<'_, str> {
+        self.as_cstr().to_string_lossy()
+    }
+
+    /// Convert `s` into a SQLite string.
+    ///
+    /// This should almost never be done except for cases like error messages or
+    /// other strings that SQLite frees.
+    ///
+    /// If `s` contains internal NULs, we'll replace them with
+    /// `NUL_REPLACE_CHAR`.
+    ///
+    /// Except for `debug_assert`s which may trigger during testing, this
+    /// function never panics. If we hit integer overflow or the allocation
+    /// fails, we call `handle_alloc_error` which aborts the program after
+    /// calling a global hook.
+    ///
+    /// This means it's safe to use in extern "C" functions even outside of
+    /// `catch_unwind`.
+    pub(crate) fn from_str(s: &str) -> Self {
+        use std::convert::TryFrom;
+        let s = if s.as_bytes().contains(&0) {
+            std::borrow::Cow::Owned(make_nonnull(s))
+        } else {
+            std::borrow::Cow::Borrowed(s)
+        };
+        debug_assert!(!s.as_bytes().contains(&0));
+        let bytes: &[u8] = s.as_ref().as_bytes();
+        let src_ptr: *const c_char = bytes.as_ptr().cast();
+        let src_len = bytes.len();
+        let maybe_len_plus_1 = s.len().checked_add(1).and_then(|v| c_int::try_from(v).ok());
+        unsafe {
+            let res_ptr = maybe_len_plus_1
+                .and_then(|len_to_alloc| {
+                    // `>` because we added 1.
+                    debug_assert!(len_to_alloc > 0);
+                    debug_assert_eq!((len_to_alloc - 1) as usize, src_len);
+                    NonNull::new(ffi::sqlite3_malloc(len_to_alloc).cast::<c_char>())
+                })
+                .unwrap_or_else(|| {
+                    use std::alloc::{handle_alloc_error, Layout};
+                    // Report via handle_alloc_error so that it can be handled with any
+                    // other allocation errors and properly diagnosed.
+                    //
+                    // This is safe:
+                    // - `align` is never 0
+                    // - `align` is always a power of 2.
+                    // - `size` needs no realignment because it's guaranteed to be aligned
+                    //   (everything is aligned to 1)
+                    // - `size` is also never zero, although this function doesn't actually require
+                    //   it now.
+                    let len = s.len().saturating_add(1).min(isize::MAX as usize);
+                    let layout = Layout::from_size_align_unchecked(len, 1);
+                    // Note: This call does not return.
+                    handle_alloc_error(layout);
+                });
+            let buf: *mut c_char = res_ptr.as_ptr().cast::<c_char>();
+            src_ptr.copy_to_nonoverlapping(buf, src_len);
+            buf.add(src_len).write(0);
+            debug_assert_eq!(std::ffi::CStr::from_ptr(res_ptr.as_ptr()).to_bytes(), bytes);
+            Self::from_raw_nonnull(res_ptr)
+        }
+    }
+}
+
+const NUL_REPLACE: &str = "␀";
+
+#[cold]
+fn make_nonnull(v: &str) -> String {
+    v.replace('\0', NUL_REPLACE)
+}
+
+impl Drop for SqliteMallocString {
+    #[inline]
+    fn drop(&mut self) {
+        unsafe { ffi::sqlite3_free(self.ptr.as_ptr().cast()) };
+    }
+}
+
+impl std::fmt::Debug for SqliteMallocString {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.to_string_lossy().fmt(f)
+    }
+}
+
+impl std::fmt::Display for SqliteMallocString {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.to_string_lossy().fmt(f)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    #[test]
+    fn test_from_str() {
+        let to_check = [
+            ("", ""),
+            ("\0", "␀"),
+            ("␀", "␀"),
+            ("\0bar", "␀bar"),
+            ("foo\0bar", "foo␀bar"),
+            ("foo\0", "foo␀"),
+            ("a\0b\0c\0\0d", "a␀b␀c␀␀d"),
+            ("foobar0123", "foobar0123"),
+        ];
+
+        for &(input, output) in &to_check {
+            let s = SqliteMallocString::from_str(input);
+            assert_eq!(s.to_string_lossy(), output);
+            assert_eq!(s.as_cstr().to_str().unwrap(), output);
+        }
+    }
+
+    // This will trigger an asan error if into_raw still freed the ptr.
+    #[test]
+    fn test_lossy() {
+        let p = SqliteMallocString::from_str("abcd").into_raw();
+        // Make invalid
+        let s = unsafe {
+            p.cast::<u8>().write(b'\xff');
+            SqliteMallocString::from_raw(p).unwrap()
+        };
+        assert_eq!(s.to_string_lossy().as_ref(), "\u{FFFD}bcd");
+    }
+
+    // This will trigger an asan error if into_raw still freed the ptr.
+    #[test]
+    fn test_into_raw() {
+        let mut v = vec![];
+        for i in 0..1000 {
+            v.push(SqliteMallocString::from_str(&i.to_string()).into_raw());
+            v.push(SqliteMallocString::from_str(&format!("abc {i} 😀")).into_raw());
+        }
+        unsafe {
+            for (i, s) in v.chunks_mut(2).enumerate() {
+                let s0 = std::mem::replace(&mut s[0], std::ptr::null_mut());
+                let s1 = std::mem::replace(&mut s[1], std::ptr::null_mut());
+                assert_eq!(
+                    std::ffi::CStr::from_ptr(s0).to_str().unwrap(),
+                    &i.to_string()
+                );
+                assert_eq!(
+                    std::ffi::CStr::from_ptr(s1).to_str().unwrap(),
+                    &format!("abc {i} 😀")
+                );
+                let _ = SqliteMallocString::from_raw(s0).unwrap();
+                let _ = SqliteMallocString::from_raw(s1).unwrap();
+            }
+        }
+    }
+}
diff --git a/crates/rusqlite/src/version.rs b/crates/rusqlite/src/version.rs
new file mode 100644
index 0000000..d70af7e
--- /dev/null
+++ b/crates/rusqlite/src/version.rs
@@ -0,0 +1,23 @@
+use crate::ffi;
+use std::ffi::CStr;
+
+/// Returns the SQLite version as an integer; e.g., `3016002` for version
+/// 3.16.2.
+///
+/// See [`sqlite3_libversion_number()`](https://www.sqlite.org/c3ref/libversion.html).
+#[inline]
+#[must_use]
+pub fn version_number() -> i32 {
+    unsafe { ffi::sqlite3_libversion_number() }
+}
+
+/// Returns the SQLite version as a string; e.g., `"3.16.2"` for version 3.16.2.
+///
+/// See [`sqlite3_libversion()`](https://www.sqlite.org/c3ref/libversion.html).
+#[inline]
+#[must_use]
+pub fn version() -> &'static str {
+    let cstr = unsafe { CStr::from_ptr(ffi::sqlite3_libversion()) };
+    cstr.to_str()
+        .expect("SQLite version string is not valid UTF8 ?!")
+}
diff --git a/crates/rusqlite/src/vtab/array.rs b/crates/rusqlite/src/vtab/array.rs
new file mode 100644
index 0000000..be19a3e
--- /dev/null
+++ b/crates/rusqlite/src/vtab/array.rs
@@ -0,0 +1,223 @@
+//! Array Virtual Table.
+//!
+//! Note: `rarray`, not `carray` is the name of the table valued function we
+//! define.
+//!
+//! Port of [carray](http://www.sqlite.org/cgi/src/finfo?name=ext/misc/carray.c)
+//! C extension: `https://www.sqlite.org/carray.html`
+//!
+//! # Example
+//!
+//! ```rust,no_run
+//! # use rusqlite::{types::Value, Connection, Result, params};
+//! # use std::rc::Rc;
+//! fn example(db: &Connection) -> Result<()> {
+//!     // Note: This should be done once (usually when opening the DB).
+//!     rusqlite::vtab::array::load_module(&db)?;
+//!     let v = [1i64, 2, 3, 4];
+//!     // Note: A `Rc<Vec<Value>>` must be used as the parameter.
+//!     let values = Rc::new(v.iter().copied().map(Value::from).collect::<Vec<Value>>());
+//!     let mut stmt = db.prepare("SELECT value from rarray(?1);")?;
+//!     let rows = stmt.query_map([values], |row| row.get::<_, i64>(0))?;
+//!     for value in rows {
+//!         println!("{}", value?);
+//!     }
+//!     Ok(())
+//! }
+//! ```
+
+use std::default::Default;
+use std::marker::PhantomData;
+use std::os::raw::{c_char, c_int, c_void};
+use std::rc::Rc;
+
+use crate::ffi;
+use crate::types::{ToSql, ToSqlOutput, Value};
+use crate::vtab::{
+    eponymous_only_module, Context, IndexConstraintOp, IndexInfo, VTab, VTabConnection, VTabCursor,
+    Values,
+};
+use crate::{Connection, Result};
+
+// http://sqlite.org/bindptr.html
+
+pub(crate) const ARRAY_TYPE: *const c_char = (b"rarray\0" as *const u8).cast::<c_char>();
+
+pub(crate) unsafe extern "C" fn free_array(p: *mut c_void) {
+    drop(Rc::from_raw(p as *const Vec<Value>));
+}
+
+/// Array parameter / pointer
+pub type Array = Rc<Vec<Value>>;
+
+impl ToSql for Array {
+    #[inline]
+    fn to_sql(&self) -> Result<ToSqlOutput<'_>> {
+        Ok(ToSqlOutput::Array(self.clone()))
+    }
+}
+
+/// Register the "rarray" module.
+pub fn load_module(conn: &Connection) -> Result<()> {
+    let aux: Option<()> = None;
+    conn.create_module("rarray", eponymous_only_module::<ArrayTab>(), aux)
+}
+
+// Column numbers
+// const CARRAY_COLUMN_VALUE : c_int = 0;
+const CARRAY_COLUMN_POINTER: c_int = 1;
+
+/// An instance of the Array virtual table
+#[repr(C)]
+struct ArrayTab {
+    /// Base class. Must be first
+    base: ffi::sqlite3_vtab,
+}
+
+unsafe impl<'vtab> VTab<'vtab> for ArrayTab {
+    type Aux = ();
+    type Cursor = ArrayTabCursor<'vtab>;
+
+    fn connect(
+        _: &mut VTabConnection,
+        _aux: Option<&()>,
+        _args: &[&[u8]],
+    ) -> Result<(String, ArrayTab)> {
+        let vtab = ArrayTab {
+            base: ffi::sqlite3_vtab::default(),
+        };
+        Ok(("CREATE TABLE x(value,pointer hidden)".to_owned(), vtab))
+    }
+
+    fn best_index(&self, info: &mut IndexInfo) -> Result<()> {
+        // Index of the pointer= constraint
+        let mut ptr_idx = false;
+        for (constraint, mut constraint_usage) in info.constraints_and_usages() {
+            if !constraint.is_usable() {
+                continue;
+            }
+            if constraint.operator() != IndexConstraintOp::SQLITE_INDEX_CONSTRAINT_EQ {
+                continue;
+            }
+            if let CARRAY_COLUMN_POINTER = constraint.column() {
+                ptr_idx = true;
+                constraint_usage.set_argv_index(1);
+                constraint_usage.set_omit(true);
+            }
+        }
+        if ptr_idx {
+            info.set_estimated_cost(1_f64);
+            info.set_estimated_rows(100);
+            info.set_idx_num(1);
+        } else {
+            info.set_estimated_cost(2_147_483_647_f64);
+            info.set_estimated_rows(2_147_483_647);
+            info.set_idx_num(0);
+        }
+        Ok(())
+    }
+
+    fn open(&mut self) -> Result<ArrayTabCursor<'_>> {
+        Ok(ArrayTabCursor::new())
+    }
+}
+
+/// A cursor for the Array virtual table
+#[repr(C)]
+struct ArrayTabCursor<'vtab> {
+    /// Base class. Must be first
+    base: ffi::sqlite3_vtab_cursor,
+    /// The rowid
+    row_id: i64,
+    /// Pointer to the array of values ("pointer")
+    ptr: Option<Array>,
+    phantom: PhantomData<&'vtab ArrayTab>,
+}
+
+impl ArrayTabCursor<'_> {
+    fn new<'vtab>() -> ArrayTabCursor<'vtab> {
+        ArrayTabCursor {
+            base: ffi::sqlite3_vtab_cursor::default(),
+            row_id: 0,
+            ptr: None,
+            phantom: PhantomData,
+        }
+    }
+
+    fn len(&self) -> i64 {
+        match self.ptr {
+            Some(ref a) => a.len() as i64,
+            _ => 0,
+        }
+    }
+}
+unsafe impl VTabCursor for ArrayTabCursor<'_> {
+    fn filter(&mut self, idx_num: c_int, _idx_str: Option<&str>, args: &Values<'_>) -> Result<()> {
+        if idx_num > 0 {
+            self.ptr = args.get_array(0);
+        } else {
+            self.ptr = None;
+        }
+        self.row_id = 1;
+        Ok(())
+    }
+
+    fn next(&mut self) -> Result<()> {
+        self.row_id += 1;
+        Ok(())
+    }
+
+    fn eof(&self) -> bool {
+        self.row_id > self.len()
+    }
+
+    fn column(&self, ctx: &mut Context, i: c_int) -> Result<()> {
+        match i {
+            CARRAY_COLUMN_POINTER => Ok(()),
+            _ => {
+                if let Some(ref array) = self.ptr {
+                    let value = &array[(self.row_id - 1) as usize];
+                    ctx.set_result(&value)
+                } else {
+                    Ok(())
+                }
+            }
+        }
+    }
+
+    fn rowid(&self) -> Result<i64> {
+        Ok(self.row_id)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::types::Value;
+    use crate::vtab::array;
+    use crate::{Connection, Result};
+    use std::rc::Rc;
+
+    #[test]
+    fn test_array_module() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        array::load_module(&db)?;
+
+        let v = vec![1i64, 2, 3, 4];
+        let values: Vec<Value> = v.into_iter().map(Value::from).collect();
+        let ptr = Rc::new(values);
+        {
+            let mut stmt = db.prepare("SELECT value from rarray(?1);")?;
+
+            let rows = stmt.query_map([&ptr], |row| row.get::<_, i64>(0))?;
+            assert_eq!(2, Rc::strong_count(&ptr));
+            let mut count = 0;
+            for (i, value) in rows.enumerate() {
+                assert_eq!(i as i64, value? - 1);
+                count += 1;
+            }
+            assert_eq!(4, count);
+        }
+        assert_eq!(1, Rc::strong_count(&ptr));
+        Ok(())
+    }
+}
diff --git a/crates/rusqlite/src/vtab/csvtab.rs b/crates/rusqlite/src/vtab/csvtab.rs
new file mode 100644
index 0000000..843363c
--- /dev/null
+++ b/crates/rusqlite/src/vtab/csvtab.rs
@@ -0,0 +1,396 @@
+//! CSV Virtual Table.
+//!
+//! Port of [csv](http://www.sqlite.org/cgi/src/finfo?name=ext/misc/csv.c) C
+//! extension: `https://www.sqlite.org/csv.html`
+//!
+//! # Example
+//!
+//! ```rust,no_run
+//! # use rusqlite::{Connection, Result};
+//! fn example() -> Result<()> {
+//!     // Note: This should be done once (usually when opening the DB).
+//!     let db = Connection::open_in_memory()?;
+//!     rusqlite::vtab::csvtab::load_module(&db)?;
+//!     // Assume my_csv.csv
+//!     let schema = "
+//!         CREATE VIRTUAL TABLE my_csv_data
+//!         USING csv(filename = 'my_csv.csv')
+//!     ";
+//!     db.execute_batch(schema)?;
+//!     // Now the `my_csv_data` (virtual) table can be queried as normal...
+//!     Ok(())
+//! }
+//! ```
+use std::fs::File;
+use std::marker::PhantomData;
+use std::os::raw::c_int;
+use std::path::Path;
+use std::str;
+
+use crate::ffi;
+use crate::types::Null;
+use crate::vtab::{
+    escape_double_quote, parse_boolean, read_only_module, Context, CreateVTab, IndexInfo, VTab,
+    VTabConfig, VTabConnection, VTabCursor, VTabKind, Values,
+};
+use crate::{Connection, Error, Result};
+
+/// Register the "csv" module.
+/// ```sql
+/// CREATE VIRTUAL TABLE vtab USING csv(
+///   filename=FILENAME -- Name of file containing CSV content
+///   [, schema=SCHEMA] -- Alternative CSV schema. 'CREATE TABLE x(col1 TEXT NOT NULL, col2 INT, ...);'
+///   [, header=YES|NO] -- First row of CSV defines the names of columns if "yes". Default "no".
+///   [, columns=N] -- Assume the CSV file contains N columns.
+///   [, delimiter=C] -- CSV delimiter. Default ','.
+///   [, quote=C] -- CSV quote. Default '"'. 0 means no quote.
+/// );
+/// ```
+pub fn load_module(conn: &Connection) -> Result<()> {
+    let aux: Option<()> = None;
+    conn.create_module("csv", read_only_module::<CsvTab>(), aux)
+}
+
+/// An instance of the CSV virtual table
+#[repr(C)]
+struct CsvTab {
+    /// Base class. Must be first
+    base: ffi::sqlite3_vtab,
+    /// Name of the CSV file
+    filename: String,
+    has_headers: bool,
+    delimiter: u8,
+    quote: u8,
+    /// Offset to start of data
+    offset_first_row: csv::Position,
+}
+
+impl CsvTab {
+    fn reader(&self) -> Result<csv::Reader<File>, csv::Error> {
+        csv::ReaderBuilder::new()
+            .has_headers(self.has_headers)
+            .delimiter(self.delimiter)
+            .quote(self.quote)
+            .from_path(&self.filename)
+    }
+
+    fn parse_byte(arg: &str) -> Option<u8> {
+        if arg.len() == 1 {
+            arg.bytes().next()
+        } else {
+            None
+        }
+    }
+}
+
+unsafe impl<'vtab> VTab<'vtab> for CsvTab {
+    type Aux = ();
+    type Cursor = CsvTabCursor<'vtab>;
+
+    fn connect(
+        db: &mut VTabConnection,
+        _aux: Option<&()>,
+        args: &[&[u8]],
+    ) -> Result<(String, CsvTab)> {
+        if args.len() < 4 {
+            return Err(Error::ModuleError("no CSV file specified".to_owned()));
+        }
+
+        let mut vtab = CsvTab {
+            base: ffi::sqlite3_vtab::default(),
+            filename: "".to_owned(),
+            has_headers: false,
+            delimiter: b',',
+            quote: b'"',
+            offset_first_row: csv::Position::new(),
+        };
+        let mut schema = None;
+        let mut n_col = None;
+
+        let args = &args[3..];
+        for c_slice in args {
+            let (param, value) = super::parameter(c_slice)?;
+            match param {
+                "filename" => {
+                    if !Path::new(value).exists() {
+                        return Err(Error::ModuleError(format!(
+                            "file '{}' does not exist",
+                            value
+                        )));
+                    }
+                    vtab.filename = value.to_owned();
+                }
+                "schema" => {
+                    schema = Some(value.to_owned());
+                }
+                "columns" => {
+                    if let Ok(n) = value.parse::<u16>() {
+                        if n_col.is_some() {
+                            return Err(Error::ModuleError(
+                                "more than one 'columns' parameter".to_owned(),
+                            ));
+                        } else if n == 0 {
+                            return Err(Error::ModuleError(
+                                "must have at least one column".to_owned(),
+                            ));
+                        }
+                        n_col = Some(n);
+                    } else {
+                        return Err(Error::ModuleError(format!(
+                            "unrecognized argument to 'columns': {}",
+                            value
+                        )));
+                    }
+                }
+                "header" => {
+                    if let Some(b) = parse_boolean(value) {
+                        vtab.has_headers = b;
+                    } else {
+                        return Err(Error::ModuleError(format!(
+                            "unrecognized argument to 'header': {}",
+                            value
+                        )));
+                    }
+                }
+                "delimiter" => {
+                    if let Some(b) = CsvTab::parse_byte(value) {
+                        vtab.delimiter = b;
+                    } else {
+                        return Err(Error::ModuleError(format!(
+                            "unrecognized argument to 'delimiter': {}",
+                            value
+                        )));
+                    }
+                }
+                "quote" => {
+                    if let Some(b) = CsvTab::parse_byte(value) {
+                        if b == b'0' {
+                            vtab.quote = 0;
+                        } else {
+                            vtab.quote = b;
+                        }
+                    } else {
+                        return Err(Error::ModuleError(format!(
+                            "unrecognized argument to 'quote': {}",
+                            value
+                        )));
+                    }
+                }
+                _ => {
+                    return Err(Error::ModuleError(format!(
+                        "unrecognized parameter '{}'",
+                        param
+                    )));
+                }
+            }
+        }
+
+        if vtab.filename.is_empty() {
+            return Err(Error::ModuleError("no CSV file specified".to_owned()));
+        }
+
+        let mut cols: Vec<String> = Vec::new();
+        if vtab.has_headers || (n_col.is_none() && schema.is_none()) {
+            let mut reader = vtab.reader()?;
+            if vtab.has_headers {
+                {
+                    let headers = reader.headers()?;
+                    // headers ignored if cols is not empty
+                    if n_col.is_none() && schema.is_none() {
+                        cols = headers
+                            .into_iter()
+                            .map(|header| escape_double_quote(header).into_owned())
+                            .collect();
+                    }
+                }
+                vtab.offset_first_row = reader.position().clone();
+            } else {
+                let mut record = csv::ByteRecord::new();
+                if reader.read_byte_record(&mut record)? {
+                    for (i, _) in record.iter().enumerate() {
+                        cols.push(format!("c{i}"));
+                    }
+                }
+            }
+        } else if let Some(n_col) = n_col {
+            for i in 0..n_col {
+                cols.push(format!("c{i}"));
+            }
+        }
+
+        if cols.is_empty() && schema.is_none() {
+            return Err(Error::ModuleError("no column specified".to_owned()));
+        }
+
+        if schema.is_none() {
+            let mut sql = String::from("CREATE TABLE x(");
+            for (i, col) in cols.iter().enumerate() {
+                sql.push('"');
+                sql.push_str(col);
+                sql.push_str("\" TEXT");
+                if i == cols.len() - 1 {
+                    sql.push_str(");");
+                } else {
+                    sql.push_str(", ");
+                }
+            }
+            schema = Some(sql);
+        }
+        db.config(VTabConfig::DirectOnly)?;
+        Ok((schema.unwrap(), vtab))
+    }
+
+    // Only a forward full table scan is supported.
+    fn best_index(&self, info: &mut IndexInfo) -> Result<()> {
+        info.set_estimated_cost(1_000_000.);
+        Ok(())
+    }
+
+    fn open(&mut self) -> Result<CsvTabCursor<'_>> {
+        Ok(CsvTabCursor::new(self.reader()?))
+    }
+}
+
+impl CreateVTab<'_> for CsvTab {
+    const KIND: VTabKind = VTabKind::Default;
+}
+
+/// A cursor for the CSV virtual table
+#[repr(C)]
+struct CsvTabCursor<'vtab> {
+    /// Base class. Must be first
+    base: ffi::sqlite3_vtab_cursor,
+    /// The CSV reader object
+    reader: csv::Reader<File>,
+    /// Current cursor position used as rowid
+    row_number: usize,
+    /// Values of the current row
+    cols: csv::StringRecord,
+    eof: bool,
+    phantom: PhantomData<&'vtab CsvTab>,
+}
+
+impl CsvTabCursor<'_> {
+    fn new<'vtab>(reader: csv::Reader<File>) -> CsvTabCursor<'vtab> {
+        CsvTabCursor {
+            base: ffi::sqlite3_vtab_cursor::default(),
+            reader,
+            row_number: 0,
+            cols: csv::StringRecord::new(),
+            eof: false,
+            phantom: PhantomData,
+        }
+    }
+
+    /// Accessor to the associated virtual table.
+    fn vtab(&self) -> &CsvTab {
+        unsafe { &*(self.base.pVtab as *const CsvTab) }
+    }
+}
+
+unsafe impl VTabCursor for CsvTabCursor<'_> {
+    // Only a full table scan is supported.  So `filter` simply rewinds to
+    // the beginning.
+    fn filter(
+        &mut self,
+        _idx_num: c_int,
+        _idx_str: Option<&str>,
+        _args: &Values<'_>,
+    ) -> Result<()> {
+        {
+            let offset_first_row = self.vtab().offset_first_row.clone();
+            self.reader.seek(offset_first_row)?;
+        }
+        self.row_number = 0;
+        self.next()
+    }
+
+    fn next(&mut self) -> Result<()> {
+        {
+            self.eof = self.reader.is_done();
+            if self.eof {
+                return Ok(());
+            }
+
+            self.eof = !self.reader.read_record(&mut self.cols)?;
+        }
+
+        self.row_number += 1;
+        Ok(())
+    }
+
+    fn eof(&self) -> bool {
+        self.eof
+    }
+
+    fn column(&self, ctx: &mut Context, col: c_int) -> Result<()> {
+        if col < 0 || col as usize >= self.cols.len() {
+            return Err(Error::ModuleError(format!(
+                "column index out of bounds: {}",
+                col
+            )));
+        }
+        if self.cols.is_empty() {
+            return ctx.set_result(&Null);
+        }
+        // TODO Affinity
+        ctx.set_result(&self.cols[col as usize].to_owned())
+    }
+
+    fn rowid(&self) -> Result<i64> {
+        Ok(self.row_number as i64)
+    }
+}
+
+impl From<csv::Error> for Error {
+    #[cold]
+    fn from(err: csv::Error) -> Error {
+        Error::ModuleError(err.to_string())
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::vtab::csvtab;
+    use crate::{Connection, Result};
+    use fallible_iterator::FallibleIterator;
+
+    #[test]
+    fn test_csv_module() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        csvtab::load_module(&db)?;
+        db.execute_batch("CREATE VIRTUAL TABLE vtab USING csv(filename='test.csv', header=yes)")?;
+
+        {
+            let mut s = db.prepare("SELECT rowid, * FROM vtab")?;
+            {
+                let headers = s.column_names();
+                assert_eq!(vec!["rowid", "colA", "colB", "colC"], headers);
+            }
+
+            let ids: Result<Vec<i32>> = s.query([])?.map(|row| row.get::<_, i32>(0)).collect();
+            let sum = ids?.iter().sum::<i32>();
+            assert_eq!(sum, 15);
+        }
+        db.execute_batch("DROP TABLE vtab")
+    }
+
+    #[test]
+    fn test_csv_cursor() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        csvtab::load_module(&db)?;
+        db.execute_batch("CREATE VIRTUAL TABLE vtab USING csv(filename='test.csv', header=yes)")?;
+
+        {
+            let mut s = db.prepare(
+                "SELECT v1.rowid, v1.* FROM vtab v1 NATURAL JOIN vtab v2 WHERE \
+                     v1.rowid < v2.rowid",
+            )?;
+
+            let mut rows = s.query([])?;
+            let row = rows.next()?.unwrap();
+            assert_eq!(row.get_unwrap::<_, i32>(0), 2);
+        }
+        db.execute_batch("DROP TABLE vtab")
+    }
+}
diff --git a/crates/rusqlite/src/vtab/mod.rs b/crates/rusqlite/src/vtab/mod.rs
new file mode 100644
index 0000000..f070e3a
--- /dev/null
+++ b/crates/rusqlite/src/vtab/mod.rs
@@ -0,0 +1,1356 @@
+//! Create virtual tables.
+//!
+//! Follow these steps to create your own virtual table:
+//! 1. Write implementation of [`VTab`] and [`VTabCursor`] traits.
+//! 2. Create an instance of the [`Module`] structure specialized for [`VTab`]
+//! impl. from step 1.
+//! 3. Register your [`Module`] structure using [`Connection::create_module`].
+//! 4. Run a `CREATE VIRTUAL TABLE` command that specifies the new module in the
+//! `USING` clause.
+//!
+//! (See [SQLite doc](http://sqlite.org/vtab.html))
+use std::borrow::Cow::{self, Borrowed, Owned};
+use std::marker::PhantomData;
+use std::marker::Sync;
+use std::os::raw::{c_char, c_int, c_void};
+use std::ptr;
+use std::slice;
+
+use crate::context::set_result;
+use crate::error::error_from_sqlite_code;
+use crate::ffi;
+pub use crate::ffi::{sqlite3_vtab, sqlite3_vtab_cursor};
+use crate::types::{FromSql, FromSqlError, ToSql, ValueRef};
+use crate::{str_to_cstring, Connection, Error, InnerConnection, Result};
+
+// let conn: Connection = ...;
+// let mod: Module = ...; // VTab builder
+// conn.create_module("module", mod);
+//
+// conn.execute("CREATE VIRTUAL TABLE foo USING module(...)");
+// \-> Module::xcreate
+//  |-> let vtab: VTab = ...; // on the heap
+//  \-> conn.declare_vtab("CREATE TABLE foo (...)");
+// conn = Connection::open(...);
+// \-> Module::xconnect
+//  |-> let vtab: VTab = ...; // on the heap
+//  \-> conn.declare_vtab("CREATE TABLE foo (...)");
+//
+// conn.close();
+// \-> vtab.xdisconnect
+// conn.execute("DROP TABLE foo");
+// \-> vtab.xDestroy
+//
+// let stmt = conn.prepare("SELECT ... FROM foo WHERE ...");
+// \-> vtab.xbestindex
+// stmt.query().next();
+// \-> vtab.xopen
+//  |-> let cursor: VTabCursor = ...; // on the heap
+//  |-> cursor.xfilter or xnext
+//  |-> cursor.xeof
+//  \-> if not eof { cursor.column or xrowid } else { cursor.xclose }
+//
+
+// db: *mut ffi::sqlite3 => VTabConnection
+// module: *const ffi::sqlite3_module => Module
+// aux: *mut c_void => Module::Aux
+// ffi::sqlite3_vtab => VTab
+// ffi::sqlite3_vtab_cursor => VTabCursor
+
+/// Virtual table kind
+pub enum VTabKind {
+    /// Non-eponymous
+    Default,
+    /// [`create`](CreateVTab::create) == [`connect`](VTab::connect)
+    ///
+    /// See [SQLite doc](https://sqlite.org/vtab.html#eponymous_virtual_tables)
+    Eponymous,
+    /// No [`create`](CreateVTab::create) / [`destroy`](CreateVTab::destroy) or
+    /// not used
+    ///
+    /// SQLite >= 3.9.0
+    ///
+    /// See [SQLite doc](https://sqlite.org/vtab.html#eponymous_only_virtual_tables)
+    EponymousOnly,
+}
+
+/// Virtual table module
+///
+/// (See [SQLite doc](https://sqlite.org/c3ref/module.html))
+#[repr(transparent)]
+pub struct Module<'vtab, T: VTab<'vtab>> {
+    base: ffi::sqlite3_module,
+    phantom: PhantomData<&'vtab T>,
+}
+
+unsafe impl<'vtab, T: VTab<'vtab>> Send for Module<'vtab, T> {}
+unsafe impl<'vtab, T: VTab<'vtab>> Sync for Module<'vtab, T> {}
+
+union ModuleZeroHack {
+    bytes: [u8; std::mem::size_of::<ffi::sqlite3_module>()],
+    module: ffi::sqlite3_module,
+}
+
+// Used as a trailing initializer for sqlite3_module -- this way we avoid having
+// the build fail if buildtime_bindgen is on. This is safe, as bindgen-generated
+// structs are allowed to be zeroed.
+const ZERO_MODULE: ffi::sqlite3_module = unsafe {
+    ModuleZeroHack {
+        bytes: [0_u8; std::mem::size_of::<ffi::sqlite3_module>()],
+    }
+    .module
+};
+
+macro_rules! module {
+    ($lt:lifetime, $vt:ty, $ct:ty, $xc:expr, $xd:expr, $xu:expr) => {
+    #[allow(clippy::needless_update)]
+    &Module {
+        base: ffi::sqlite3_module {
+            // We don't use V3
+            iVersion: 2,
+            xCreate: $xc,
+            xConnect: Some(rust_connect::<$vt>),
+            xBestIndex: Some(rust_best_index::<$vt>),
+            xDisconnect: Some(rust_disconnect::<$vt>),
+            xDestroy: $xd,
+            xOpen: Some(rust_open::<$vt>),
+            xClose: Some(rust_close::<$ct>),
+            xFilter: Some(rust_filter::<$ct>),
+            xNext: Some(rust_next::<$ct>),
+            xEof: Some(rust_eof::<$ct>),
+            xColumn: Some(rust_column::<$ct>),
+            xRowid: Some(rust_rowid::<$ct>), // FIXME optional
+            xUpdate: $xu,
+            xBegin: None,
+            xSync: None,
+            xCommit: None,
+            xRollback: None,
+            xFindFunction: None,
+            xRename: None,
+            xSavepoint: None,
+            xRelease: None,
+            xRollbackTo: None,
+            ..ZERO_MODULE
+        },
+        phantom: PhantomData::<&$lt $vt>,
+    }
+    };
+}
+
+/// Create an modifiable virtual table implementation.
+///
+/// Step 2 of [Creating New Virtual Table Implementations](https://sqlite.org/vtab.html#creating_new_virtual_table_implementations).
+#[must_use]
+pub fn update_module<'vtab, T: UpdateVTab<'vtab>>() -> &'static Module<'vtab, T> {
+    match T::KIND {
+        VTabKind::EponymousOnly => {
+            module!('vtab, T, T::Cursor, None, None, Some(rust_update::<T>))
+        }
+        VTabKind::Eponymous => {
+            module!('vtab, T, T::Cursor, Some(rust_connect::<T>), Some(rust_disconnect::<T>), Some(rust_update::<T>))
+        }
+        _ => {
+            module!('vtab, T, T::Cursor, Some(rust_create::<T>), Some(rust_destroy::<T>), Some(rust_update::<T>))
+        }
+    }
+}
+
+/// Create a read-only virtual table implementation.
+///
+/// Step 2 of [Creating New Virtual Table Implementations](https://sqlite.org/vtab.html#creating_new_virtual_table_implementations).
+#[must_use]
+pub fn read_only_module<'vtab, T: CreateVTab<'vtab>>() -> &'static Module<'vtab, T> {
+    match T::KIND {
+        VTabKind::EponymousOnly => eponymous_only_module(),
+        VTabKind::Eponymous => {
+            // A virtual table is eponymous if its xCreate method is the exact same function
+            // as the xConnect method
+            module!('vtab, T, T::Cursor, Some(rust_connect::<T>), Some(rust_disconnect::<T>), None)
+        }
+        _ => {
+            // The xConnect and xCreate methods may do the same thing, but they must be
+            // different so that the virtual table is not an eponymous virtual table.
+            module!('vtab, T, T::Cursor, Some(rust_create::<T>), Some(rust_destroy::<T>), None)
+        }
+    }
+}
+
+/// Create an eponymous only virtual table implementation.
+///
+/// Step 2 of [Creating New Virtual Table Implementations](https://sqlite.org/vtab.html#creating_new_virtual_table_implementations).
+#[must_use]
+pub fn eponymous_only_module<'vtab, T: VTab<'vtab>>() -> &'static Module<'vtab, T> {
+    //  For eponymous-only virtual tables, the xCreate method is NULL
+    module!('vtab, T, T::Cursor, None, None, None)
+}
+
+/// Virtual table configuration options
+#[repr(i32)]
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+pub enum VTabConfig {
+    /// Equivalent to SQLITE_VTAB_CONSTRAINT_SUPPORT
+    ConstraintSupport = 1,
+    /// Equivalent to SQLITE_VTAB_INNOCUOUS
+    Innocuous = 2,
+    /// Equivalent to SQLITE_VTAB_DIRECTONLY
+    DirectOnly = 3,
+}
+
+/// `feature = "vtab"`
+pub struct VTabConnection(*mut ffi::sqlite3);
+
+impl VTabConnection {
+    /// Configure various facets of the virtual table interface
+    pub fn config(&mut self, config: VTabConfig) -> Result<()> {
+        crate::error::check(unsafe { ffi::sqlite3_vtab_config(self.0, config as c_int) })
+    }
+
+    // TODO sqlite3_vtab_on_conflict (http://sqlite.org/c3ref/vtab_on_conflict.html) & xUpdate
+
+    /// Get access to the underlying SQLite database connection handle.
+    ///
+    /// # Warning
+    ///
+    /// You should not need to use this function. If you do need to, please
+    /// [open an issue on the rusqlite repository](https://github.com/rusqlite/rusqlite/issues) and describe
+    /// your use case.
+    ///
+    /// # Safety
+    ///
+    /// This function is unsafe because it gives you raw access
+    /// to the SQLite connection, and what you do with it could impact the
+    /// safety of this `Connection`.
+    pub unsafe fn handle(&mut self) -> *mut ffi::sqlite3 {
+        self.0
+    }
+}
+
+/// Eponymous-only virtual table instance trait.
+///
+/// # Safety
+///
+/// The first item in a struct implementing `VTab` must be
+/// `rusqlite::sqlite3_vtab`, and the struct must be `#[repr(C)]`.
+///
+/// ```rust,ignore
+/// #[repr(C)]
+/// struct MyTab {
+///    /// Base class. Must be first
+///    base: rusqlite::vtab::sqlite3_vtab,
+///    /* Virtual table implementations will typically add additional fields */
+/// }
+/// ```
+///
+/// (See [SQLite doc](https://sqlite.org/c3ref/vtab.html))
+pub unsafe trait VTab<'vtab>: Sized {
+    /// Client data passed to [`Connection::create_module`].
+    type Aux;
+    /// Specific cursor implementation
+    type Cursor: VTabCursor;
+
+    /// Establish a new connection to an existing virtual table.
+    ///
+    /// (See [SQLite doc](https://sqlite.org/vtab.html#the_xconnect_method))
+    fn connect(
+        db: &mut VTabConnection,
+        aux: Option<&Self::Aux>,
+        args: &[&[u8]],
+    ) -> Result<(String, Self)>;
+
+    /// Determine the best way to access the virtual table.
+    /// (See [SQLite doc](https://sqlite.org/vtab.html#the_xbestindex_method))
+    fn best_index(&self, info: &mut IndexInfo) -> Result<()>;
+
+    /// Create a new cursor used for accessing a virtual table.
+    /// (See [SQLite doc](https://sqlite.org/vtab.html#the_xopen_method))
+    fn open(&'vtab mut self) -> Result<Self::Cursor>;
+}
+
+/// Read-only virtual table instance trait.
+///
+/// (See [SQLite doc](https://sqlite.org/c3ref/vtab.html))
+pub trait CreateVTab<'vtab>: VTab<'vtab> {
+    /// For [`EponymousOnly`](VTabKind::EponymousOnly),
+    /// [`create`](CreateVTab::create) and [`destroy`](CreateVTab::destroy) are
+    /// not called
+    const KIND: VTabKind;
+    /// Create a new instance of a virtual table in response to a CREATE VIRTUAL
+    /// TABLE statement. The `db` parameter is a pointer to the SQLite
+    /// database connection that is executing the CREATE VIRTUAL TABLE
+    /// statement.
+    ///
+    /// Call [`connect`](VTab::connect) by default.
+    /// (See [SQLite doc](https://sqlite.org/vtab.html#the_xcreate_method))
+    fn create(
+        db: &mut VTabConnection,
+        aux: Option<&Self::Aux>,
+        args: &[&[u8]],
+    ) -> Result<(String, Self)> {
+        Self::connect(db, aux, args)
+    }
+
+    /// Destroy the underlying table implementation. This method undoes the work
+    /// of [`create`](CreateVTab::create).
+    ///
+    /// Do nothing by default.
+    /// (See [SQLite doc](https://sqlite.org/vtab.html#the_xdestroy_method))
+    fn destroy(&self) -> Result<()> {
+        Ok(())
+    }
+}
+
+/// Writable virtual table instance trait.
+///
+/// (See [SQLite doc](https://sqlite.org/vtab.html#xupdate))
+pub trait UpdateVTab<'vtab>: CreateVTab<'vtab> {
+    /// Delete rowid or PK
+    fn delete(&mut self, arg: ValueRef<'_>) -> Result<()>;
+    /// Insert: `args[0] == NULL: old rowid or PK, args[1]: new rowid or PK,
+    /// args[2]: ...`
+    ///
+    /// Return the new rowid.
+    // TODO Make the distinction between argv[1] == NULL and argv[1] != NULL ?
+    fn insert(&mut self, args: &Values<'_>) -> Result<i64>;
+    /// Update: `args[0] != NULL: old rowid or PK, args[1]: new row id or PK,
+    /// args[2]: ...`
+    fn update(&mut self, args: &Values<'_>) -> Result<()>;
+}
+
+/// Index constraint operator.
+/// See [Virtual Table Constraint Operator Codes](https://sqlite.org/c3ref/c_index_constraint_eq.html) for details.
+#[derive(Debug, Eq, PartialEq)]
+#[allow(non_snake_case, non_camel_case_types, missing_docs)]
+#[allow(clippy::upper_case_acronyms)]
+pub enum IndexConstraintOp {
+    SQLITE_INDEX_CONSTRAINT_EQ,
+    SQLITE_INDEX_CONSTRAINT_GT,
+    SQLITE_INDEX_CONSTRAINT_LE,
+    SQLITE_INDEX_CONSTRAINT_LT,
+    SQLITE_INDEX_CONSTRAINT_GE,
+    SQLITE_INDEX_CONSTRAINT_MATCH,
+    SQLITE_INDEX_CONSTRAINT_LIKE,         // 3.10.0
+    SQLITE_INDEX_CONSTRAINT_GLOB,         // 3.10.0
+    SQLITE_INDEX_CONSTRAINT_REGEXP,       // 3.10.0
+    SQLITE_INDEX_CONSTRAINT_NE,           // 3.21.0
+    SQLITE_INDEX_CONSTRAINT_ISNOT,        // 3.21.0
+    SQLITE_INDEX_CONSTRAINT_ISNOTNULL,    // 3.21.0
+    SQLITE_INDEX_CONSTRAINT_ISNULL,       // 3.21.0
+    SQLITE_INDEX_CONSTRAINT_IS,           // 3.21.0
+    SQLITE_INDEX_CONSTRAINT_LIMIT,        // 3.38.0
+    SQLITE_INDEX_CONSTRAINT_OFFSET,       // 3.38.0
+    SQLITE_INDEX_CONSTRAINT_FUNCTION(u8), // 3.25.0
+}
+
+impl From<u8> for IndexConstraintOp {
+    fn from(code: u8) -> IndexConstraintOp {
+        match code {
+            2 => IndexConstraintOp::SQLITE_INDEX_CONSTRAINT_EQ,
+            4 => IndexConstraintOp::SQLITE_INDEX_CONSTRAINT_GT,
+            8 => IndexConstraintOp::SQLITE_INDEX_CONSTRAINT_LE,
+            16 => IndexConstraintOp::SQLITE_INDEX_CONSTRAINT_LT,
+            32 => IndexConstraintOp::SQLITE_INDEX_CONSTRAINT_GE,
+            64 => IndexConstraintOp::SQLITE_INDEX_CONSTRAINT_MATCH,
+            65 => IndexConstraintOp::SQLITE_INDEX_CONSTRAINT_LIKE,
+            66 => IndexConstraintOp::SQLITE_INDEX_CONSTRAINT_GLOB,
+            67 => IndexConstraintOp::SQLITE_INDEX_CONSTRAINT_REGEXP,
+            68 => IndexConstraintOp::SQLITE_INDEX_CONSTRAINT_NE,
+            69 => IndexConstraintOp::SQLITE_INDEX_CONSTRAINT_ISNOT,
+            70 => IndexConstraintOp::SQLITE_INDEX_CONSTRAINT_ISNOTNULL,
+            71 => IndexConstraintOp::SQLITE_INDEX_CONSTRAINT_ISNULL,
+            72 => IndexConstraintOp::SQLITE_INDEX_CONSTRAINT_IS,
+            73 => IndexConstraintOp::SQLITE_INDEX_CONSTRAINT_LIMIT,
+            74 => IndexConstraintOp::SQLITE_INDEX_CONSTRAINT_OFFSET,
+            v => IndexConstraintOp::SQLITE_INDEX_CONSTRAINT_FUNCTION(v),
+        }
+    }
+}
+
+bitflags::bitflags! {
+    /// Virtual table scan flags
+    /// See [Function Flags](https://sqlite.org/c3ref/c_index_scan_unique.html) for details.
+    #[repr(C)]
+    pub struct IndexFlags: ::std::os::raw::c_int {
+        /// Default
+        const NONE     = 0;
+        /// Scan visits at most 1 row.
+        const SQLITE_INDEX_SCAN_UNIQUE  = ffi::SQLITE_INDEX_SCAN_UNIQUE;
+    }
+}
+
+/// Pass information into and receive the reply from the
+/// [`VTab::best_index`] method.
+///
+/// (See [SQLite doc](http://sqlite.org/c3ref/index_info.html))
+#[derive(Debug)]
+pub struct IndexInfo(*mut ffi::sqlite3_index_info);
+
+impl IndexInfo {
+    /// Iterate on index constraint and its associated usage.
+    #[inline]
+    pub fn constraints_and_usages(&mut self) -> IndexConstraintAndUsageIter<'_> {
+        let constraints =
+            unsafe { slice::from_raw_parts((*self.0).aConstraint, (*self.0).nConstraint as usize) };
+        let constraint_usages = unsafe {
+            slice::from_raw_parts_mut((*self.0).aConstraintUsage, (*self.0).nConstraint as usize)
+        };
+        IndexConstraintAndUsageIter {
+            iter: constraints.iter().zip(constraint_usages.iter_mut()),
+        }
+    }
+
+    /// Record WHERE clause constraints.
+    #[inline]
+    #[must_use]
+    pub fn constraints(&self) -> IndexConstraintIter<'_> {
+        let constraints =
+            unsafe { slice::from_raw_parts((*self.0).aConstraint, (*self.0).nConstraint as usize) };
+        IndexConstraintIter {
+            iter: constraints.iter(),
+        }
+    }
+
+    /// Information about the ORDER BY clause.
+    #[inline]
+    #[must_use]
+    pub fn order_bys(&self) -> OrderByIter<'_> {
+        let order_bys =
+            unsafe { slice::from_raw_parts((*self.0).aOrderBy, (*self.0).nOrderBy as usize) };
+        OrderByIter {
+            iter: order_bys.iter(),
+        }
+    }
+
+    /// Number of terms in the ORDER BY clause
+    #[inline]
+    #[must_use]
+    pub fn num_of_order_by(&self) -> usize {
+        unsafe { (*self.0).nOrderBy as usize }
+    }
+
+    /// Information about what parameters to pass to [`VTabCursor::filter`].
+    #[inline]
+    pub fn constraint_usage(&mut self, constraint_idx: usize) -> IndexConstraintUsage<'_> {
+        let constraint_usages = unsafe {
+            slice::from_raw_parts_mut((*self.0).aConstraintUsage, (*self.0).nConstraint as usize)
+        };
+        IndexConstraintUsage(&mut constraint_usages[constraint_idx])
+    }
+
+    /// Number used to identify the index
+    #[inline]
+    pub fn set_idx_num(&mut self, idx_num: c_int) {
+        unsafe {
+            (*self.0).idxNum = idx_num;
+        }
+    }
+
+    /// String used to identify the index
+    pub fn set_idx_str(&mut self, idx_str: &str) {
+        unsafe {
+            (*self.0).idxStr = alloc(idx_str);
+            (*self.0).needToFreeIdxStr = 1;
+        }
+    }
+
+    /// True if output is already ordered
+    #[inline]
+    pub fn set_order_by_consumed(&mut self, order_by_consumed: bool) {
+        unsafe {
+            (*self.0).orderByConsumed = order_by_consumed as c_int;
+        }
+    }
+
+    /// Estimated cost of using this index
+    #[inline]
+    pub fn set_estimated_cost(&mut self, estimated_ost: f64) {
+        unsafe {
+            (*self.0).estimatedCost = estimated_ost;
+        }
+    }
+
+    /// Estimated number of rows returned.
+    #[inline]
+    pub fn set_estimated_rows(&mut self, estimated_rows: i64) {
+        unsafe {
+            (*self.0).estimatedRows = estimated_rows;
+        }
+    }
+
+    /// Mask of SQLITE_INDEX_SCAN_* flags.
+    #[inline]
+    pub fn set_idx_flags(&mut self, flags: IndexFlags) {
+        unsafe { (*self.0).idxFlags = flags.bits() };
+    }
+
+    /// Mask of columns used by statement
+    #[inline]
+    pub fn col_used(&self) -> u64 {
+        unsafe { (*self.0).colUsed }
+    }
+
+    /// Determine the collation for a virtual table constraint
+    #[cfg(feature = "modern_sqlite")] // SQLite >= 3.22.0
+    #[cfg_attr(docsrs, doc(cfg(feature = "modern_sqlite")))]
+    pub fn collation(&self, constraint_idx: usize) -> Result<&str> {
+        use std::ffi::CStr;
+        let idx = constraint_idx as c_int;
+        let collation = unsafe { ffi::sqlite3_vtab_collation(self.0, idx) };
+        if collation.is_null() {
+            return Err(Error::SqliteFailure(
+                ffi::Error::new(ffi::SQLITE_MISUSE),
+                Some(format!("{constraint_idx} is out of range")),
+            ));
+        }
+        Ok(unsafe { CStr::from_ptr(collation) }.to_str()?)
+    }
+
+    /*/// Determine if a virtual table query is DISTINCT
+    #[cfg(feature = "modern_sqlite")] // SQLite >= 3.38.0
+    #[cfg_attr(docsrs, doc(cfg(feature = "modern_sqlite")))]
+    pub fn distinct(&self) -> c_int {
+        unsafe { ffi::sqlite3_vtab_distinct(self.0) }
+    }
+
+    /// Constraint values
+    #[cfg(feature = "modern_sqlite")] // SQLite >= 3.38.0
+    #[cfg_attr(docsrs, doc(cfg(feature = "modern_sqlite")))]
+    pub fn set_rhs_value(&mut self, constraint_idx: c_int, value: ValueRef) -> Result<()> {
+        // TODO ValueRef to sqlite3_value
+        crate::error::check(unsafe { ffi::sqlite3_vtab_rhs_value(self.O, constraint_idx, value) })
+    }
+
+    /// Identify and handle IN constraints
+    #[cfg(feature = "modern_sqlite")] // SQLite >= 3.38.0
+    #[cfg_attr(docsrs, doc(cfg(feature = "modern_sqlite")))]
+    pub fn set_in_constraint(&mut self, constraint_idx: c_int, b_handle: c_int) -> bool {
+        unsafe { ffi::sqlite3_vtab_in(self.0, constraint_idx, b_handle) != 0 }
+    } // TODO sqlite3_vtab_in_first / sqlite3_vtab_in_next https://sqlite.org/c3ref/vtab_in_first.html
+    */
+}
+
+/// Iterate on index constraint and its associated usage.
+pub struct IndexConstraintAndUsageIter<'a> {
+    iter: std::iter::Zip<
+        slice::Iter<'a, ffi::sqlite3_index_constraint>,
+        slice::IterMut<'a, ffi::sqlite3_index_constraint_usage>,
+    >,
+}
+
+impl<'a> Iterator for IndexConstraintAndUsageIter<'a> {
+    type Item = (IndexConstraint<'a>, IndexConstraintUsage<'a>);
+
+    #[inline]
+    fn next(&mut self) -> Option<(IndexConstraint<'a>, IndexConstraintUsage<'a>)> {
+        self.iter
+            .next()
+            .map(|raw| (IndexConstraint(raw.0), IndexConstraintUsage(raw.1)))
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.iter.size_hint()
+    }
+}
+
+/// `feature = "vtab"`
+pub struct IndexConstraintIter<'a> {
+    iter: slice::Iter<'a, ffi::sqlite3_index_constraint>,
+}
+
+impl<'a> Iterator for IndexConstraintIter<'a> {
+    type Item = IndexConstraint<'a>;
+
+    #[inline]
+    fn next(&mut self) -> Option<IndexConstraint<'a>> {
+        self.iter.next().map(IndexConstraint)
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.iter.size_hint()
+    }
+}
+
+/// WHERE clause constraint.
+pub struct IndexConstraint<'a>(&'a ffi::sqlite3_index_constraint);
+
+impl IndexConstraint<'_> {
+    /// Column constrained.  -1 for ROWID
+    #[inline]
+    #[must_use]
+    pub fn column(&self) -> c_int {
+        self.0.iColumn
+    }
+
+    /// Constraint operator
+    #[inline]
+    #[must_use]
+    pub fn operator(&self) -> IndexConstraintOp {
+        IndexConstraintOp::from(self.0.op)
+    }
+
+    /// True if this constraint is usable
+    #[inline]
+    #[must_use]
+    pub fn is_usable(&self) -> bool {
+        self.0.usable != 0
+    }
+}
+
+/// Information about what parameters to pass to
+/// [`VTabCursor::filter`].
+pub struct IndexConstraintUsage<'a>(&'a mut ffi::sqlite3_index_constraint_usage);
+
+impl IndexConstraintUsage<'_> {
+    /// if `argv_index` > 0, constraint is part of argv to
+    /// [`VTabCursor::filter`]
+    #[inline]
+    pub fn set_argv_index(&mut self, argv_index: c_int) {
+        self.0.argvIndex = argv_index;
+    }
+
+    /// if `omit`, do not code a test for this constraint
+    #[inline]
+    pub fn set_omit(&mut self, omit: bool) {
+        self.0.omit = omit as std::os::raw::c_uchar;
+    }
+}
+
+/// `feature = "vtab"`
+pub struct OrderByIter<'a> {
+    iter: slice::Iter<'a, ffi::sqlite3_index_orderby>,
+}
+
+impl<'a> Iterator for OrderByIter<'a> {
+    type Item = OrderBy<'a>;
+
+    #[inline]
+    fn next(&mut self) -> Option<OrderBy<'a>> {
+        self.iter.next().map(OrderBy)
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.iter.size_hint()
+    }
+}
+
+/// A column of the ORDER BY clause.
+pub struct OrderBy<'a>(&'a ffi::sqlite3_index_orderby);
+
+impl OrderBy<'_> {
+    /// Column number
+    #[inline]
+    #[must_use]
+    pub fn column(&self) -> c_int {
+        self.0.iColumn
+    }
+
+    /// True for DESC.  False for ASC.
+    #[inline]
+    #[must_use]
+    pub fn is_order_by_desc(&self) -> bool {
+        self.0.desc != 0
+    }
+}
+
+/// Virtual table cursor trait.
+///
+/// # Safety
+///
+/// Implementations must be like:
+/// ```rust,ignore
+/// #[repr(C)]
+/// struct MyTabCursor {
+///    /// Base class. Must be first
+///    base: rusqlite::vtab::sqlite3_vtab_cursor,
+///    /* Virtual table implementations will typically add additional fields */
+/// }
+/// ```
+///
+/// (See [SQLite doc](https://sqlite.org/c3ref/vtab_cursor.html))
+pub unsafe trait VTabCursor: Sized {
+    /// Begin a search of a virtual table.
+    /// (See [SQLite doc](https://sqlite.org/vtab.html#the_xfilter_method))
+    fn filter(&mut self, idx_num: c_int, idx_str: Option<&str>, args: &Values<'_>) -> Result<()>;
+    /// Advance cursor to the next row of a result set initiated by
+    /// [`filter`](VTabCursor::filter). (See [SQLite doc](https://sqlite.org/vtab.html#the_xnext_method))
+    fn next(&mut self) -> Result<()>;
+    /// Must return `false` if the cursor currently points to a valid row of
+    /// data, or `true` otherwise.
+    /// (See [SQLite doc](https://sqlite.org/vtab.html#the_xeof_method))
+    fn eof(&self) -> bool;
+    /// Find the value for the `i`-th column of the current row.
+    /// `i` is zero-based so the first column is numbered 0.
+    /// May return its result back to SQLite using one of the specified `ctx`.
+    /// (See [SQLite doc](https://sqlite.org/vtab.html#the_xcolumn_method))
+    fn column(&self, ctx: &mut Context, i: c_int) -> Result<()>;
+    /// Return the rowid of row that the cursor is currently pointing at.
+    /// (See [SQLite doc](https://sqlite.org/vtab.html#the_xrowid_method))
+    fn rowid(&self) -> Result<i64>;
+}
+
+/// Context is used by [`VTabCursor::column`] to specify the
+/// cell value.
+pub struct Context(*mut ffi::sqlite3_context);
+
+impl Context {
+    /// Set current cell value
+    #[inline]
+    pub fn set_result<T: ToSql>(&mut self, value: &T) -> Result<()> {
+        let t = value.to_sql()?;
+        unsafe { set_result(self.0, &t) };
+        Ok(())
+    }
+
+    // TODO sqlite3_vtab_nochange (http://sqlite.org/c3ref/vtab_nochange.html) // 3.22.0 & xColumn
+}
+
+/// Wrapper to [`VTabCursor::filter`] arguments, the values
+/// requested by [`VTab::best_index`].
+pub struct Values<'a> {
+    args: &'a [*mut ffi::sqlite3_value],
+}
+
+impl Values<'_> {
+    /// Returns the number of values.
+    #[inline]
+    #[must_use]
+    pub fn len(&self) -> usize {
+        self.args.len()
+    }
+
+    /// Returns `true` if there is no value.
+    #[inline]
+    #[must_use]
+    pub fn is_empty(&self) -> bool {
+        self.args.is_empty()
+    }
+
+    /// Returns value at `idx`
+    pub fn get<T: FromSql>(&self, idx: usize) -> Result<T> {
+        let arg = self.args[idx];
+        let value = unsafe { ValueRef::from_value(arg) };
+        FromSql::column_result(value).map_err(|err| match err {
+            FromSqlError::InvalidType => Error::InvalidFilterParameterType(idx, value.data_type()),
+            FromSqlError::Other(err) => {
+                Error::FromSqlConversionFailure(idx, value.data_type(), err)
+            }
+            FromSqlError::InvalidBlobSize { .. } => {
+                Error::FromSqlConversionFailure(idx, value.data_type(), Box::new(err))
+            }
+            FromSqlError::OutOfRange(i) => Error::IntegralValueOutOfRange(idx, i),
+        })
+    }
+
+    // `sqlite3_value_type` returns `SQLITE_NULL` for pointer.
+    // So it seems not possible to enhance `ValueRef::from_value`.
+    #[cfg(feature = "array")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "array")))]
+    fn get_array(&self, idx: usize) -> Option<array::Array> {
+        use crate::types::Value;
+        let arg = self.args[idx];
+        let ptr = unsafe { ffi::sqlite3_value_pointer(arg, array::ARRAY_TYPE) };
+        if ptr.is_null() {
+            None
+        } else {
+            Some(unsafe {
+                let rc = array::Array::from_raw(ptr as *const Vec<Value>);
+                let array = rc.clone();
+                array::Array::into_raw(rc); // don't consume it
+                array
+            })
+        }
+    }
+
+    /// Turns `Values` into an iterator.
+    #[inline]
+    #[must_use]
+    pub fn iter(&self) -> ValueIter<'_> {
+        ValueIter {
+            iter: self.args.iter(),
+        }
+    }
+    // TODO sqlite3_vtab_in_first / sqlite3_vtab_in_next https://sqlite.org/c3ref/vtab_in_first.html & 3.38.0
+}
+
+impl<'a> IntoIterator for &'a Values<'a> {
+    type IntoIter = ValueIter<'a>;
+    type Item = ValueRef<'a>;
+
+    #[inline]
+    fn into_iter(self) -> ValueIter<'a> {
+        self.iter()
+    }
+}
+
+/// [`Values`] iterator.
+pub struct ValueIter<'a> {
+    iter: slice::Iter<'a, *mut ffi::sqlite3_value>,
+}
+
+impl<'a> Iterator for ValueIter<'a> {
+    type Item = ValueRef<'a>;
+
+    #[inline]
+    fn next(&mut self) -> Option<ValueRef<'a>> {
+        self.iter
+            .next()
+            .map(|&raw| unsafe { ValueRef::from_value(raw) })
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.iter.size_hint()
+    }
+}
+
+impl Connection {
+    /// Register a virtual table implementation.
+    ///
+    /// Step 3 of [Creating New Virtual Table
+    /// Implementations](https://sqlite.org/vtab.html#creating_new_virtual_table_implementations).
+    #[inline]
+    pub fn create_module<'vtab, T: VTab<'vtab>>(
+        &self,
+        module_name: &str,
+        module: &'static Module<'vtab, T>,
+        aux: Option<T::Aux>,
+    ) -> Result<()> {
+        self.db.borrow_mut().create_module(module_name, module, aux)
+    }
+}
+
+impl InnerConnection {
+    fn create_module<'vtab, T: VTab<'vtab>>(
+        &mut self,
+        module_name: &str,
+        module: &'static Module<'vtab, T>,
+        aux: Option<T::Aux>,
+    ) -> Result<()> {
+        use crate::version;
+        if version::version_number() < 3_009_000 && module.base.xCreate.is_none() {
+            return Err(Error::ModuleError(format!(
+                "Eponymous-only virtual table not supported by SQLite version {}",
+                version::version()
+            )));
+        }
+        let c_name = str_to_cstring(module_name)?;
+        let r = match aux {
+            Some(aux) => {
+                let boxed_aux: *mut T::Aux = Box::into_raw(Box::new(aux));
+                unsafe {
+                    ffi::sqlite3_create_module_v2(
+                        self.db(),
+                        c_name.as_ptr(),
+                        &module.base,
+                        boxed_aux.cast::<c_void>(),
+                        Some(free_boxed_value::<T::Aux>),
+                    )
+                }
+            }
+            None => unsafe {
+                ffi::sqlite3_create_module_v2(
+                    self.db(),
+                    c_name.as_ptr(),
+                    &module.base,
+                    ptr::null_mut(),
+                    None,
+                )
+            },
+        };
+        self.decode_result(r)
+    }
+}
+
+/// Escape double-quote (`"`) character occurrences by
+/// doubling them (`""`).
+#[must_use]
+pub fn escape_double_quote(identifier: &str) -> Cow<'_, str> {
+    if identifier.contains('"') {
+        // escape quote by doubling them
+        Owned(identifier.replace('"', "\"\""))
+    } else {
+        Borrowed(identifier)
+    }
+}
+/// Dequote string
+#[must_use]
+pub fn dequote(s: &str) -> &str {
+    if s.len() < 2 {
+        return s;
+    }
+    match s.bytes().next() {
+        Some(b) if b == b'"' || b == b'\'' => match s.bytes().rev().next() {
+            Some(e) if e == b => &s[1..s.len() - 1], // FIXME handle inner escaped quote(s)
+            _ => s,
+        },
+        _ => s,
+    }
+}
+/// The boolean can be one of:
+/// ```text
+/// 1 yes true on
+/// 0 no false off
+/// ```
+#[must_use]
+pub fn parse_boolean(s: &str) -> Option<bool> {
+    if s.eq_ignore_ascii_case("yes")
+        || s.eq_ignore_ascii_case("on")
+        || s.eq_ignore_ascii_case("true")
+        || s.eq("1")
+    {
+        Some(true)
+    } else if s.eq_ignore_ascii_case("no")
+        || s.eq_ignore_ascii_case("off")
+        || s.eq_ignore_ascii_case("false")
+        || s.eq("0")
+    {
+        Some(false)
+    } else {
+        None
+    }
+}
+
+/// `<param_name>=['"]?<param_value>['"]?` => `(<param_name>, <param_value>)`
+pub fn parameter(c_slice: &[u8]) -> Result<(&str, &str)> {
+    let arg = std::str::from_utf8(c_slice)?.trim();
+    let mut split = arg.split('=');
+    if let Some(key) = split.next() {
+        if let Some(value) = split.next() {
+            let param = key.trim();
+            let value = dequote(value);
+            return Ok((param, value));
+        }
+    }
+    Err(Error::ModuleError(format!("illegal argument: '{arg}'")))
+}
+
+// FIXME copy/paste from function.rs
+unsafe extern "C" fn free_boxed_value<T>(p: *mut c_void) {
+    drop(Box::from_raw(p.cast::<T>()));
+}
+
+unsafe extern "C" fn rust_create<'vtab, T>(
+    db: *mut ffi::sqlite3,
+    aux: *mut c_void,
+    argc: c_int,
+    argv: *const *const c_char,
+    pp_vtab: *mut *mut ffi::sqlite3_vtab,
+    err_msg: *mut *mut c_char,
+) -> c_int
+where
+    T: CreateVTab<'vtab>,
+{
+    use std::ffi::CStr;
+
+    let mut conn = VTabConnection(db);
+    let aux = aux.cast::<T::Aux>();
+    let args = slice::from_raw_parts(argv, argc as usize);
+    let vec = args
+        .iter()
+        .map(|&cs| CStr::from_ptr(cs).to_bytes()) // FIXME .to_str() -> Result<&str, Utf8Error>
+        .collect::<Vec<_>>();
+    match T::create(&mut conn, aux.as_ref(), &vec[..]) {
+        Ok((sql, vtab)) => match std::ffi::CString::new(sql) {
+            Ok(c_sql) => {
+                let rc = ffi::sqlite3_declare_vtab(db, c_sql.as_ptr());
+                if rc == ffi::SQLITE_OK {
+                    let boxed_vtab: *mut T = Box::into_raw(Box::new(vtab));
+                    *pp_vtab = boxed_vtab.cast::<ffi::sqlite3_vtab>();
+                    ffi::SQLITE_OK
+                } else {
+                    let err = error_from_sqlite_code(rc, None);
+                    *err_msg = alloc(&err.to_string());
+                    rc
+                }
+            }
+            Err(err) => {
+                *err_msg = alloc(&err.to_string());
+                ffi::SQLITE_ERROR
+            }
+        },
+        Err(Error::SqliteFailure(err, s)) => {
+            if let Some(s) = s {
+                *err_msg = alloc(&s);
+            }
+            err.extended_code
+        }
+        Err(err) => {
+            *err_msg = alloc(&err.to_string());
+            ffi::SQLITE_ERROR
+        }
+    }
+}
+
+unsafe extern "C" fn rust_connect<'vtab, T>(
+    db: *mut ffi::sqlite3,
+    aux: *mut c_void,
+    argc: c_int,
+    argv: *const *const c_char,
+    pp_vtab: *mut *mut ffi::sqlite3_vtab,
+    err_msg: *mut *mut c_char,
+) -> c_int
+where
+    T: VTab<'vtab>,
+{
+    use std::ffi::CStr;
+
+    let mut conn = VTabConnection(db);
+    let aux = aux.cast::<T::Aux>();
+    let args = slice::from_raw_parts(argv, argc as usize);
+    let vec = args
+        .iter()
+        .map(|&cs| CStr::from_ptr(cs).to_bytes()) // FIXME .to_str() -> Result<&str, Utf8Error>
+        .collect::<Vec<_>>();
+    match T::connect(&mut conn, aux.as_ref(), &vec[..]) {
+        Ok((sql, vtab)) => match std::ffi::CString::new(sql) {
+            Ok(c_sql) => {
+                let rc = ffi::sqlite3_declare_vtab(db, c_sql.as_ptr());
+                if rc == ffi::SQLITE_OK {
+                    let boxed_vtab: *mut T = Box::into_raw(Box::new(vtab));
+                    *pp_vtab = boxed_vtab.cast::<ffi::sqlite3_vtab>();
+                    ffi::SQLITE_OK
+                } else {
+                    let err = error_from_sqlite_code(rc, None);
+                    *err_msg = alloc(&err.to_string());
+                    rc
+                }
+            }
+            Err(err) => {
+                *err_msg = alloc(&err.to_string());
+                ffi::SQLITE_ERROR
+            }
+        },
+        Err(Error::SqliteFailure(err, s)) => {
+            if let Some(s) = s {
+                *err_msg = alloc(&s);
+            }
+            err.extended_code
+        }
+        Err(err) => {
+            *err_msg = alloc(&err.to_string());
+            ffi::SQLITE_ERROR
+        }
+    }
+}
+
+unsafe extern "C" fn rust_best_index<'vtab, T>(
+    vtab: *mut ffi::sqlite3_vtab,
+    info: *mut ffi::sqlite3_index_info,
+) -> c_int
+where
+    T: VTab<'vtab>,
+{
+    let vt = vtab.cast::<T>();
+    let mut idx_info = IndexInfo(info);
+    match (*vt).best_index(&mut idx_info) {
+        Ok(_) => ffi::SQLITE_OK,
+        Err(Error::SqliteFailure(err, s)) => {
+            if let Some(err_msg) = s {
+                set_err_msg(vtab, &err_msg);
+            }
+            err.extended_code
+        }
+        Err(err) => {
+            set_err_msg(vtab, &err.to_string());
+            ffi::SQLITE_ERROR
+        }
+    }
+}
+
+unsafe extern "C" fn rust_disconnect<'vtab, T>(vtab: *mut ffi::sqlite3_vtab) -> c_int
+where
+    T: VTab<'vtab>,
+{
+    if vtab.is_null() {
+        return ffi::SQLITE_OK;
+    }
+    let vtab = vtab.cast::<T>();
+    drop(Box::from_raw(vtab));
+    ffi::SQLITE_OK
+}
+
+unsafe extern "C" fn rust_destroy<'vtab, T>(vtab: *mut ffi::sqlite3_vtab) -> c_int
+where
+    T: CreateVTab<'vtab>,
+{
+    if vtab.is_null() {
+        return ffi::SQLITE_OK;
+    }
+    let vt = vtab.cast::<T>();
+    match (*vt).destroy() {
+        Ok(_) => {
+            drop(Box::from_raw(vt));
+            ffi::SQLITE_OK
+        }
+        Err(Error::SqliteFailure(err, s)) => {
+            if let Some(err_msg) = s {
+                set_err_msg(vtab, &err_msg);
+            }
+            err.extended_code
+        }
+        Err(err) => {
+            set_err_msg(vtab, &err.to_string());
+            ffi::SQLITE_ERROR
+        }
+    }
+}
+
+unsafe extern "C" fn rust_open<'vtab, T: 'vtab>(
+    vtab: *mut ffi::sqlite3_vtab,
+    pp_cursor: *mut *mut ffi::sqlite3_vtab_cursor,
+) -> c_int
+where
+    T: VTab<'vtab>,
+{
+    let vt = vtab.cast::<T>();
+    match (*vt).open() {
+        Ok(cursor) => {
+            let boxed_cursor: *mut T::Cursor = Box::into_raw(Box::new(cursor));
+            *pp_cursor = boxed_cursor.cast::<ffi::sqlite3_vtab_cursor>();
+            ffi::SQLITE_OK
+        }
+        Err(Error::SqliteFailure(err, s)) => {
+            if let Some(err_msg) = s {
+                set_err_msg(vtab, &err_msg);
+            }
+            err.extended_code
+        }
+        Err(err) => {
+            set_err_msg(vtab, &err.to_string());
+            ffi::SQLITE_ERROR
+        }
+    }
+}
+
+unsafe extern "C" fn rust_close<C>(cursor: *mut ffi::sqlite3_vtab_cursor) -> c_int
+where
+    C: VTabCursor,
+{
+    let cr = cursor.cast::<C>();
+    drop(Box::from_raw(cr));
+    ffi::SQLITE_OK
+}
+
+unsafe extern "C" fn rust_filter<C>(
+    cursor: *mut ffi::sqlite3_vtab_cursor,
+    idx_num: c_int,
+    idx_str: *const c_char,
+    argc: c_int,
+    argv: *mut *mut ffi::sqlite3_value,
+) -> c_int
+where
+    C: VTabCursor,
+{
+    use std::ffi::CStr;
+    use std::str;
+    let idx_name = if idx_str.is_null() {
+        None
+    } else {
+        let c_slice = CStr::from_ptr(idx_str).to_bytes();
+        Some(str::from_utf8_unchecked(c_slice))
+    };
+    let args = slice::from_raw_parts_mut(argv, argc as usize);
+    let values = Values { args };
+    let cr = cursor as *mut C;
+    cursor_error(cursor, (*cr).filter(idx_num, idx_name, &values))
+}
+
+unsafe extern "C" fn rust_next<C>(cursor: *mut ffi::sqlite3_vtab_cursor) -> c_int
+where
+    C: VTabCursor,
+{
+    let cr = cursor as *mut C;
+    cursor_error(cursor, (*cr).next())
+}
+
+unsafe extern "C" fn rust_eof<C>(cursor: *mut ffi::sqlite3_vtab_cursor) -> c_int
+where
+    C: VTabCursor,
+{
+    let cr = cursor.cast::<C>();
+    (*cr).eof() as c_int
+}
+
+unsafe extern "C" fn rust_column<C>(
+    cursor: *mut ffi::sqlite3_vtab_cursor,
+    ctx: *mut ffi::sqlite3_context,
+    i: c_int,
+) -> c_int
+where
+    C: VTabCursor,
+{
+    let cr = cursor.cast::<C>();
+    let mut ctxt = Context(ctx);
+    result_error(ctx, (*cr).column(&mut ctxt, i))
+}
+
+unsafe extern "C" fn rust_rowid<C>(
+    cursor: *mut ffi::sqlite3_vtab_cursor,
+    p_rowid: *mut ffi::sqlite3_int64,
+) -> c_int
+where
+    C: VTabCursor,
+{
+    let cr = cursor.cast::<C>();
+    match (*cr).rowid() {
+        Ok(rowid) => {
+            *p_rowid = rowid;
+            ffi::SQLITE_OK
+        }
+        err => cursor_error(cursor, err),
+    }
+}
+
+unsafe extern "C" fn rust_update<'vtab, T: 'vtab>(
+    vtab: *mut ffi::sqlite3_vtab,
+    argc: c_int,
+    argv: *mut *mut ffi::sqlite3_value,
+    p_rowid: *mut ffi::sqlite3_int64,
+) -> c_int
+where
+    T: UpdateVTab<'vtab>,
+{
+    assert!(argc >= 1);
+    let args = slice::from_raw_parts_mut(argv, argc as usize);
+    let vt = vtab.cast::<T>();
+    let r = if args.len() == 1 {
+        (*vt).delete(ValueRef::from_value(args[0]))
+    } else if ffi::sqlite3_value_type(args[0]) == ffi::SQLITE_NULL {
+        // TODO Make the distinction between argv[1] == NULL and argv[1] != NULL ?
+        let values = Values { args };
+        match (*vt).insert(&values) {
+            Ok(rowid) => {
+                *p_rowid = rowid;
+                Ok(())
+            }
+            Err(e) => Err(e),
+        }
+    } else {
+        let values = Values { args };
+        (*vt).update(&values)
+    };
+    match r {
+        Ok(_) => ffi::SQLITE_OK,
+        Err(Error::SqliteFailure(err, s)) => {
+            if let Some(err_msg) = s {
+                set_err_msg(vtab, &err_msg);
+            }
+            err.extended_code
+        }
+        Err(err) => {
+            set_err_msg(vtab, &err.to_string());
+            ffi::SQLITE_ERROR
+        }
+    }
+}
+
+/// Virtual table cursors can set an error message by assigning a string to
+/// `zErrMsg`.
+#[cold]
+unsafe fn cursor_error<T>(cursor: *mut ffi::sqlite3_vtab_cursor, result: Result<T>) -> c_int {
+    match result {
+        Ok(_) => ffi::SQLITE_OK,
+        Err(Error::SqliteFailure(err, s)) => {
+            if let Some(err_msg) = s {
+                set_err_msg((*cursor).pVtab, &err_msg);
+            }
+            err.extended_code
+        }
+        Err(err) => {
+            set_err_msg((*cursor).pVtab, &err.to_string());
+            ffi::SQLITE_ERROR
+        }
+    }
+}
+
+/// Virtual tables methods can set an error message by assigning a string to
+/// `zErrMsg`.
+#[cold]
+unsafe fn set_err_msg(vtab: *mut ffi::sqlite3_vtab, err_msg: &str) {
+    if !(*vtab).zErrMsg.is_null() {
+        ffi::sqlite3_free((*vtab).zErrMsg.cast::<c_void>());
+    }
+    (*vtab).zErrMsg = alloc(err_msg);
+}
+
+/// To raise an error, the `column` method should use this method to set the
+/// error message and return the error code.
+#[cold]
+unsafe fn result_error<T>(ctx: *mut ffi::sqlite3_context, result: Result<T>) -> c_int {
+    match result {
+        Ok(_) => ffi::SQLITE_OK,
+        Err(Error::SqliteFailure(err, s)) => {
+            match err.extended_code {
+                ffi::SQLITE_TOOBIG => {
+                    ffi::sqlite3_result_error_toobig(ctx);
+                }
+                ffi::SQLITE_NOMEM => {
+                    ffi::sqlite3_result_error_nomem(ctx);
+                }
+                code => {
+                    ffi::sqlite3_result_error_code(ctx, code);
+                    if let Some(Ok(cstr)) = s.map(|s| str_to_cstring(&s)) {
+                        ffi::sqlite3_result_error(ctx, cstr.as_ptr(), -1);
+                    }
+                }
+            };
+            err.extended_code
+        }
+        Err(err) => {
+            ffi::sqlite3_result_error_code(ctx, ffi::SQLITE_ERROR);
+            if let Ok(cstr) = str_to_cstring(&err.to_string()) {
+                ffi::sqlite3_result_error(ctx, cstr.as_ptr(), -1);
+            }
+            ffi::SQLITE_ERROR
+        }
+    }
+}
+
+// Space to hold this string must be obtained
+// from an SQLite memory allocation function
+fn alloc(s: &str) -> *mut c_char {
+    crate::util::SqliteMallocString::from_str(s).into_raw()
+}
+
+#[cfg(feature = "array")]
+#[cfg_attr(docsrs, doc(cfg(feature = "array")))]
+pub mod array;
+#[cfg(feature = "csvtab")]
+#[cfg_attr(docsrs, doc(cfg(feature = "csvtab")))]
+pub mod csvtab;
+#[cfg(feature = "series")]
+#[cfg_attr(docsrs, doc(cfg(feature = "series")))]
+pub mod series; // SQLite >= 3.9.0
+#[cfg(all(test, feature = "modern_sqlite"))]
+mod vtablog;
+
+#[cfg(test)]
+mod test {
+    #[test]
+    fn test_dequote() {
+        assert_eq!("", super::dequote(""));
+        assert_eq!("'", super::dequote("'"));
+        assert_eq!("\"", super::dequote("\""));
+        assert_eq!("'\"", super::dequote("'\""));
+        assert_eq!("", super::dequote("''"));
+        assert_eq!("", super::dequote("\"\""));
+        assert_eq!("x", super::dequote("'x'"));
+        assert_eq!("x", super::dequote("\"x\""));
+        assert_eq!("x", super::dequote("x"));
+    }
+    #[test]
+    fn test_parse_boolean() {
+        assert_eq!(None, super::parse_boolean(""));
+        assert_eq!(Some(true), super::parse_boolean("1"));
+        assert_eq!(Some(true), super::parse_boolean("yes"));
+        assert_eq!(Some(true), super::parse_boolean("on"));
+        assert_eq!(Some(true), super::parse_boolean("true"));
+        assert_eq!(Some(false), super::parse_boolean("0"));
+        assert_eq!(Some(false), super::parse_boolean("no"));
+        assert_eq!(Some(false), super::parse_boolean("off"));
+        assert_eq!(Some(false), super::parse_boolean("false"));
+    }
+}
diff --git a/crates/rusqlite/src/vtab/series.rs b/crates/rusqlite/src/vtab/series.rs
new file mode 100644
index 0000000..4b1993e
--- /dev/null
+++ b/crates/rusqlite/src/vtab/series.rs
@@ -0,0 +1,321 @@
+//! Generate series virtual table.
+//!
+//! Port of C [generate series
+//! "function"](http://www.sqlite.org/cgi/src/finfo?name=ext/misc/series.c):
+//! `https://www.sqlite.org/series.html`
+use std::default::Default;
+use std::marker::PhantomData;
+use std::os::raw::c_int;
+
+use crate::ffi;
+use crate::types::Type;
+use crate::vtab::{
+    eponymous_only_module, Context, IndexConstraintOp, IndexInfo, VTab, VTabConfig, VTabConnection,
+    VTabCursor, Values,
+};
+use crate::{Connection, Error, Result};
+
+/// Register the "generate_series" module.
+pub fn load_module(conn: &Connection) -> Result<()> {
+    let aux: Option<()> = None;
+    conn.create_module("generate_series", eponymous_only_module::<SeriesTab>(), aux)
+}
+
+// Column numbers
+// const SERIES_COLUMN_VALUE : c_int = 0;
+const SERIES_COLUMN_START: c_int = 1;
+const SERIES_COLUMN_STOP: c_int = 2;
+const SERIES_COLUMN_STEP: c_int = 3;
+
+bitflags::bitflags! {
+    #[derive(Clone, Copy)]
+    #[repr(C)]
+    struct QueryPlanFlags: ::std::os::raw::c_int {
+        // start = $value  -- constraint exists
+        const START = 1;
+        // stop = $value   -- constraint exists
+        const STOP  = 2;
+        // step = $value   -- constraint exists
+        const STEP  = 4;
+        // output in descending order
+        const DESC  = 8;
+        // output in ascending order
+        const ASC  = 16;
+        // Both start and stop
+        const BOTH  = QueryPlanFlags::START.bits() | QueryPlanFlags::STOP.bits();
+    }
+}
+
+/// An instance of the Series virtual table
+#[repr(C)]
+struct SeriesTab {
+    /// Base class. Must be first
+    base: ffi::sqlite3_vtab,
+}
+
+unsafe impl<'vtab> VTab<'vtab> for SeriesTab {
+    type Aux = ();
+    type Cursor = SeriesTabCursor<'vtab>;
+
+    fn connect(
+        db: &mut VTabConnection,
+        _aux: Option<&()>,
+        _args: &[&[u8]],
+    ) -> Result<(String, SeriesTab)> {
+        let vtab = SeriesTab {
+            base: ffi::sqlite3_vtab::default(),
+        };
+        db.config(VTabConfig::Innocuous)?;
+        Ok((
+            "CREATE TABLE x(value,start hidden,stop hidden,step hidden)".to_owned(),
+            vtab,
+        ))
+    }
+
+    fn best_index(&self, info: &mut IndexInfo) -> Result<()> {
+        // The query plan bitmask
+        let mut idx_num: QueryPlanFlags = QueryPlanFlags::empty();
+        // Mask of unusable constraints
+        let mut unusable_mask: QueryPlanFlags = QueryPlanFlags::empty();
+        // Constraints on start, stop, and step
+        let mut a_idx: [Option<usize>; 3] = [None, None, None];
+        for (i, constraint) in info.constraints().enumerate() {
+            if constraint.column() < SERIES_COLUMN_START {
+                continue;
+            }
+            let (i_col, i_mask) = match constraint.column() {
+                SERIES_COLUMN_START => (0, QueryPlanFlags::START),
+                SERIES_COLUMN_STOP => (1, QueryPlanFlags::STOP),
+                SERIES_COLUMN_STEP => (2, QueryPlanFlags::STEP),
+                _ => {
+                    unreachable!()
+                }
+            };
+            if !constraint.is_usable() {
+                unusable_mask |= i_mask;
+            } else if constraint.operator() == IndexConstraintOp::SQLITE_INDEX_CONSTRAINT_EQ {
+                idx_num |= i_mask;
+                a_idx[i_col] = Some(i);
+            }
+        }
+        // Number of arguments that SeriesTabCursor::filter expects
+        let mut n_arg = 0;
+        for j in a_idx.iter().flatten() {
+            n_arg += 1;
+            let mut constraint_usage = info.constraint_usage(*j);
+            constraint_usage.set_argv_index(n_arg);
+            constraint_usage.set_omit(true);
+            #[cfg(all(test, feature = "modern_sqlite"))]
+            debug_assert_eq!(Ok("BINARY"), info.collation(*j));
+        }
+        if !(unusable_mask & !idx_num).is_empty() {
+            return Err(Error::SqliteFailure(
+                ffi::Error::new(ffi::SQLITE_CONSTRAINT),
+                None,
+            ));
+        }
+        if idx_num.contains(QueryPlanFlags::BOTH) {
+            // Both start= and stop= boundaries are available.
+            #[allow(clippy::bool_to_int_with_if)]
+            info.set_estimated_cost(f64::from(
+                2 - if idx_num.contains(QueryPlanFlags::STEP) {
+                    1
+                } else {
+                    0
+                },
+            ));
+            info.set_estimated_rows(1000);
+            let order_by_consumed = {
+                let mut order_bys = info.order_bys();
+                if let Some(order_by) = order_bys.next() {
+                    if order_by.column() == 0 {
+                        if order_by.is_order_by_desc() {
+                            idx_num |= QueryPlanFlags::DESC;
+                        } else {
+                            idx_num |= QueryPlanFlags::ASC;
+                        }
+                        true
+                    } else {
+                        false
+                    }
+                } else {
+                    false
+                }
+            };
+            if order_by_consumed {
+                info.set_order_by_consumed(true);
+            }
+        } else {
+            // If either boundary is missing, we have to generate a huge span
+            // of numbers.  Make this case very expensive so that the query
+            // planner will work hard to avoid it.
+            info.set_estimated_rows(2_147_483_647);
+        }
+        info.set_idx_num(idx_num.bits());
+        Ok(())
+    }
+
+    fn open(&mut self) -> Result<SeriesTabCursor<'_>> {
+        Ok(SeriesTabCursor::new())
+    }
+}
+
+/// A cursor for the Series virtual table
+#[repr(C)]
+struct SeriesTabCursor<'vtab> {
+    /// Base class. Must be first
+    base: ffi::sqlite3_vtab_cursor,
+    /// True to count down rather than up
+    is_desc: bool,
+    /// The rowid
+    row_id: i64,
+    /// Current value ("value")
+    value: i64,
+    /// Minimum value ("start")
+    min_value: i64,
+    /// Maximum value ("stop")
+    max_value: i64,
+    /// Increment ("step")
+    step: i64,
+    phantom: PhantomData<&'vtab SeriesTab>,
+}
+
+impl SeriesTabCursor<'_> {
+    fn new<'vtab>() -> SeriesTabCursor<'vtab> {
+        SeriesTabCursor {
+            base: ffi::sqlite3_vtab_cursor::default(),
+            is_desc: false,
+            row_id: 0,
+            value: 0,
+            min_value: 0,
+            max_value: 0,
+            step: 0,
+            phantom: PhantomData,
+        }
+    }
+}
+#[allow(clippy::comparison_chain)]
+unsafe impl VTabCursor for SeriesTabCursor<'_> {
+    fn filter(&mut self, idx_num: c_int, _idx_str: Option<&str>, args: &Values<'_>) -> Result<()> {
+        let mut idx_num = QueryPlanFlags::from_bits_truncate(idx_num);
+        let mut i = 0;
+        if idx_num.contains(QueryPlanFlags::START) {
+            self.min_value = args.get(i)?;
+            i += 1;
+        } else {
+            self.min_value = 0;
+        }
+        if idx_num.contains(QueryPlanFlags::STOP) {
+            self.max_value = args.get(i)?;
+            i += 1;
+        } else {
+            self.max_value = 0xffff_ffff;
+        }
+        if idx_num.contains(QueryPlanFlags::STEP) {
+            self.step = args.get(i)?;
+            if self.step == 0 {
+                self.step = 1;
+            } else if self.step < 0 {
+                self.step = -self.step;
+                if !idx_num.contains(QueryPlanFlags::ASC) {
+                    idx_num |= QueryPlanFlags::DESC;
+                }
+            }
+        } else {
+            self.step = 1;
+        };
+        for arg in args.iter() {
+            if arg.data_type() == Type::Null {
+                // If any of the constraints have a NULL value, then return no rows.
+                self.min_value = 1;
+                self.max_value = 0;
+                break;
+            }
+        }
+        self.is_desc = idx_num.contains(QueryPlanFlags::DESC);
+        if self.is_desc {
+            self.value = self.max_value;
+            if self.step > 0 {
+                self.value -= (self.max_value - self.min_value) % self.step;
+            }
+        } else {
+            self.value = self.min_value;
+        }
+        self.row_id = 1;
+        Ok(())
+    }
+
+    fn next(&mut self) -> Result<()> {
+        if self.is_desc {
+            self.value -= self.step;
+        } else {
+            self.value += self.step;
+        }
+        self.row_id += 1;
+        Ok(())
+    }
+
+    fn eof(&self) -> bool {
+        if self.is_desc {
+            self.value < self.min_value
+        } else {
+            self.value > self.max_value
+        }
+    }
+
+    fn column(&self, ctx: &mut Context, i: c_int) -> Result<()> {
+        let x = match i {
+            SERIES_COLUMN_START => self.min_value,
+            SERIES_COLUMN_STOP => self.max_value,
+            SERIES_COLUMN_STEP => self.step,
+            _ => self.value,
+        };
+        ctx.set_result(&x)
+    }
+
+    fn rowid(&self) -> Result<i64> {
+        Ok(self.row_id)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::ffi;
+    use crate::vtab::series;
+    use crate::{Connection, Result};
+    use fallible_iterator::FallibleIterator;
+
+    #[test]
+    fn test_series_module() -> Result<()> {
+        let version = unsafe { ffi::sqlite3_libversion_number() };
+        if version < 3_008_012 {
+            return Ok(());
+        }
+
+        let db = Connection::open_in_memory()?;
+        series::load_module(&db)?;
+
+        let mut s = db.prepare("SELECT * FROM generate_series(0,20,5)")?;
+
+        let series = s.query_map([], |row| row.get::<_, i32>(0))?;
+
+        let mut expected = 0;
+        for value in series {
+            assert_eq!(expected, value?);
+            expected += 5;
+        }
+
+        let mut s =
+            db.prepare("SELECT * FROM generate_series WHERE start=1 AND stop=9 AND step=2")?;
+        let series: Vec<i32> = s.query([])?.map(|r| r.get(0)).collect()?;
+        assert_eq!(vec![1, 3, 5, 7, 9], series);
+        let mut s = db.prepare("SELECT * FROM generate_series LIMIT 5")?;
+        let series: Vec<i32> = s.query([])?.map(|r| r.get(0)).collect()?;
+        assert_eq!(vec![0, 1, 2, 3, 4], series);
+        let mut s = db.prepare("SELECT * FROM generate_series(0,32,5) ORDER BY value DESC")?;
+        let series: Vec<i32> = s.query([])?.map(|r| r.get(0)).collect()?;
+        assert_eq!(vec![30, 25, 20, 15, 10, 5, 0], series);
+
+        Ok(())
+    }
+}
diff --git a/crates/rusqlite/src/vtab/vtablog.rs b/crates/rusqlite/src/vtab/vtablog.rs
new file mode 100644
index 0000000..1b3e1b8
--- /dev/null
+++ b/crates/rusqlite/src/vtab/vtablog.rs
@@ -0,0 +1,300 @@
+///! Port of C [vtablog](http://www.sqlite.org/cgi/src/finfo?name=ext/misc/vtablog.c)
+use std::default::Default;
+use std::marker::PhantomData;
+use std::os::raw::c_int;
+use std::str::FromStr;
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+use crate::vtab::{
+    update_module, Context, CreateVTab, IndexInfo, UpdateVTab, VTab, VTabConnection, VTabCursor,
+    VTabKind, Values,
+};
+use crate::{ffi, ValueRef};
+use crate::{Connection, Error, Result};
+
+/// Register the "vtablog" module.
+pub fn load_module(conn: &Connection) -> Result<()> {
+    let aux: Option<()> = None;
+    conn.create_module("vtablog", update_module::<VTabLog>(), aux)
+}
+
+/// An instance of the vtablog virtual table
+#[repr(C)]
+struct VTabLog {
+    /// Base class. Must be first
+    base: ffi::sqlite3_vtab,
+    /// Number of rows in the table
+    n_row: i64,
+    /// Instance number for this vtablog table
+    i_inst: usize,
+    /// Number of cursors created
+    n_cursor: usize,
+}
+
+impl VTabLog {
+    fn connect_create(
+        _: &mut VTabConnection,
+        _: Option<&()>,
+        args: &[&[u8]],
+        is_create: bool,
+    ) -> Result<(String, VTabLog)> {
+        static N_INST: AtomicUsize = AtomicUsize::new(1);
+        let i_inst = N_INST.fetch_add(1, Ordering::SeqCst);
+        println!(
+            "VTabLog::{}(tab={}, args={:?}):",
+            if is_create { "create" } else { "connect" },
+            i_inst,
+            args,
+        );
+        let mut schema = None;
+        let mut n_row = None;
+
+        let args = &args[3..];
+        for c_slice in args {
+            let (param, value) = super::parameter(c_slice)?;
+            match param {
+                "schema" => {
+                    if schema.is_some() {
+                        return Err(Error::ModuleError(format!(
+                            "more than one '{}' parameter",
+                            param
+                        )));
+                    }
+                    schema = Some(value.to_owned())
+                }
+                "rows" => {
+                    if n_row.is_some() {
+                        return Err(Error::ModuleError(format!(
+                            "more than one '{}' parameter",
+                            param
+                        )));
+                    }
+                    if let Ok(n) = i64::from_str(value) {
+                        n_row = Some(n)
+                    }
+                }
+                _ => {
+                    return Err(Error::ModuleError(format!(
+                        "unrecognized parameter '{}'",
+                        param
+                    )));
+                }
+            }
+        }
+        if schema.is_none() {
+            return Err(Error::ModuleError("no schema defined".to_owned()));
+        }
+        let vtab = VTabLog {
+            base: ffi::sqlite3_vtab::default(),
+            n_row: n_row.unwrap_or(10),
+            i_inst,
+            n_cursor: 0,
+        };
+        Ok((schema.unwrap(), vtab))
+    }
+}
+
+impl Drop for VTabLog {
+    fn drop(&mut self) {
+        println!("VTabLog::drop({})", self.i_inst);
+    }
+}
+
+unsafe impl<'vtab> VTab<'vtab> for VTabLog {
+    type Aux = ();
+    type Cursor = VTabLogCursor<'vtab>;
+
+    fn connect(
+        db: &mut VTabConnection,
+        aux: Option<&Self::Aux>,
+        args: &[&[u8]],
+    ) -> Result<(String, Self)> {
+        VTabLog::connect_create(db, aux, args, false)
+    }
+
+    fn best_index(&self, info: &mut IndexInfo) -> Result<()> {
+        println!("VTabLog::best_index({})", self.i_inst);
+        info.set_estimated_cost(500.);
+        info.set_estimated_rows(500);
+        Ok(())
+    }
+
+    fn open(&'vtab mut self) -> Result<Self::Cursor> {
+        self.n_cursor += 1;
+        println!(
+            "VTabLog::open(tab={}, cursor={})",
+            self.i_inst, self.n_cursor
+        );
+        Ok(VTabLogCursor {
+            base: ffi::sqlite3_vtab_cursor::default(),
+            i_cursor: self.n_cursor,
+            row_id: 0,
+            phantom: PhantomData,
+        })
+    }
+}
+
+impl<'vtab> CreateVTab<'vtab> for VTabLog {
+    const KIND: VTabKind = VTabKind::Default;
+
+    fn create(
+        db: &mut VTabConnection,
+        aux: Option<&Self::Aux>,
+        args: &[&[u8]],
+    ) -> Result<(String, Self)> {
+        VTabLog::connect_create(db, aux, args, true)
+    }
+
+    fn destroy(&self) -> Result<()> {
+        println!("VTabLog::destroy({})", self.i_inst);
+        Ok(())
+    }
+}
+
+impl<'vtab> UpdateVTab<'vtab> for VTabLog {
+    fn delete(&mut self, arg: ValueRef<'_>) -> Result<()> {
+        println!("VTabLog::delete({}, {arg:?})", self.i_inst);
+        Ok(())
+    }
+
+    fn insert(&mut self, args: &Values<'_>) -> Result<i64> {
+        println!(
+            "VTabLog::insert({}, {:?})",
+            self.i_inst,
+            args.iter().collect::<Vec<ValueRef<'_>>>()
+        );
+        Ok(self.n_row)
+    }
+
+    fn update(&mut self, args: &Values<'_>) -> Result<()> {
+        println!(
+            "VTabLog::update({}, {:?})",
+            self.i_inst,
+            args.iter().collect::<Vec<ValueRef<'_>>>()
+        );
+        Ok(())
+    }
+}
+
+/// A cursor for the Series virtual table
+#[repr(C)]
+struct VTabLogCursor<'vtab> {
+    /// Base class. Must be first
+    base: ffi::sqlite3_vtab_cursor,
+    /// Cursor number
+    i_cursor: usize,
+    /// The rowid
+    row_id: i64,
+    phantom: PhantomData<&'vtab VTabLog>,
+}
+
+impl VTabLogCursor<'_> {
+    fn vtab(&self) -> &VTabLog {
+        unsafe { &*(self.base.pVtab as *const VTabLog) }
+    }
+}
+
+impl Drop for VTabLogCursor<'_> {
+    fn drop(&mut self) {
+        println!(
+            "VTabLogCursor::drop(tab={}, cursor={})",
+            self.vtab().i_inst,
+            self.i_cursor
+        );
+    }
+}
+
+unsafe impl VTabCursor for VTabLogCursor<'_> {
+    fn filter(&mut self, _: c_int, _: Option<&str>, _: &Values<'_>) -> Result<()> {
+        println!(
+            "VTabLogCursor::filter(tab={}, cursor={})",
+            self.vtab().i_inst,
+            self.i_cursor
+        );
+        self.row_id = 0;
+        Ok(())
+    }
+
+    fn next(&mut self) -> Result<()> {
+        println!(
+            "VTabLogCursor::next(tab={}, cursor={}): rowid {} -> {}",
+            self.vtab().i_inst,
+            self.i_cursor,
+            self.row_id,
+            self.row_id + 1
+        );
+        self.row_id += 1;
+        Ok(())
+    }
+
+    fn eof(&self) -> bool {
+        let eof = self.row_id >= self.vtab().n_row;
+        println!(
+            "VTabLogCursor::eof(tab={}, cursor={}): {}",
+            self.vtab().i_inst,
+            self.i_cursor,
+            eof,
+        );
+        eof
+    }
+
+    fn column(&self, ctx: &mut Context, i: c_int) -> Result<()> {
+        let value = if i < 26 {
+            format!(
+                "{}{}",
+                "abcdefghijklmnopqrstuvwyz".chars().nth(i as usize).unwrap(),
+                self.row_id
+            )
+        } else {
+            format!("{i}{}", self.row_id)
+        };
+        println!(
+            "VTabLogCursor::column(tab={}, cursor={}, i={}): {}",
+            self.vtab().i_inst,
+            self.i_cursor,
+            i,
+            value,
+        );
+        ctx.set_result(&value)
+    }
+
+    fn rowid(&self) -> Result<i64> {
+        println!(
+            "VTabLogCursor::rowid(tab={}, cursor={}): {}",
+            self.vtab().i_inst,
+            self.i_cursor,
+            self.row_id,
+        );
+        Ok(self.row_id)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::{Connection, Result};
+    #[test]
+    fn test_module() -> Result<()> {
+        let db = Connection::open_in_memory()?;
+        super::load_module(&db)?;
+
+        db.execute_batch(
+            "CREATE VIRTUAL TABLE temp.log USING vtablog(
+                    schema='CREATE TABLE x(a,b,c)',
+                    rows=25
+                );",
+        )?;
+        let mut stmt = db.prepare("SELECT * FROM log;")?;
+        let mut rows = stmt.query([])?;
+        while rows.next()?.is_some() {}
+        db.execute("DELETE FROM log WHERE a = ?1", ["a1"])?;
+        db.execute(
+            "INSERT INTO log (a, b, c) VALUES (?1, ?2, ?3)",
+            ["a", "b", "c"],
+        )?;
+        db.execute(
+            "UPDATE log SET b = ?1, c = ?2 WHERE a = ?3",
+            ["bn", "cn", "a1"],
+        )?;
+        Ok(())
+    }
+}
diff --git a/crates/rusqlite/test.csv b/crates/rusqlite/test.csv
new file mode 100644
index 0000000..708f93f
--- /dev/null
+++ b/crates/rusqlite/test.csv
@@ -0,0 +1,6 @@
+"colA","colB","colC"
+1,2,3
+a,b,c
+a,"b",c
+"a","b","c .. z"
+"a","b","c,d"
diff --git a/crates/rusqlite/tests/config_log.rs b/crates/rusqlite/tests/config_log.rs
new file mode 100644
index 0000000..0c28bdf
--- /dev/null
+++ b/crates/rusqlite/tests/config_log.rs
@@ -0,0 +1,34 @@
+//! This file contains unit tests for `rusqlite::trace::config_log`. This
+//! function affects SQLite process-wide and so is not safe to run as a normal
+//! #[test] in the library.
+
+#[cfg(feature = "trace")]
+fn main() {
+    use lazy_static::lazy_static;
+    use std::os::raw::c_int;
+    use std::sync::Mutex;
+
+    lazy_static! {
+        static ref LOGS_RECEIVED: Mutex<Vec<(c_int, String)>> = Mutex::new(Vec::new());
+    }
+
+    fn log_handler(err: c_int, message: &str) {
+        let mut logs_received = LOGS_RECEIVED.lock().unwrap();
+        logs_received.push((err, message.to_owned()));
+    }
+
+    use rusqlite::trace;
+
+    unsafe { trace::config_log(Some(log_handler)) }.unwrap();
+    trace::log(10, "First message from rusqlite");
+    unsafe { trace::config_log(None) }.unwrap();
+    trace::log(11, "Second message from rusqlite");
+
+    let logs_received = LOGS_RECEIVED.lock().unwrap();
+    assert_eq!(logs_received.len(), 1);
+    assert_eq!(logs_received[0].0, 10);
+    assert_eq!(logs_received[0].1, "First message from rusqlite");
+}
+
+#[cfg(not(feature = "trace"))]
+fn main() {}
diff --git a/crates/rusqlite/tests/deny_single_threaded_sqlite_config.rs b/crates/rusqlite/tests/deny_single_threaded_sqlite_config.rs
new file mode 100644
index 0000000..7118dab
--- /dev/null
+++ b/crates/rusqlite/tests/deny_single_threaded_sqlite_config.rs
@@ -0,0 +1,20 @@
+//! Ensure we reject connections when SQLite is in single-threaded mode, as it
+//! would violate safety if multiple Rust threads tried to use connections.
+
+use rusqlite::ffi;
+use rusqlite::Connection;
+
+#[test]
+fn test_error_when_singlethread_mode() {
+    // put SQLite into single-threaded mode
+    unsafe {
+        // Note: macOS system SQLite seems to return an error if you attempt to
+        // reconfigure to single-threaded mode.
+        if ffi::sqlite3_config(ffi::SQLITE_CONFIG_SINGLETHREAD) != ffi::SQLITE_OK {
+            return;
+        }
+        assert_eq!(ffi::sqlite3_initialize(), ffi::SQLITE_OK);
+    }
+    let res = Connection::open_in_memory();
+    res.unwrap_err();
+}
diff --git a/crates/rusqlite/tests/vtab.rs b/crates/rusqlite/tests/vtab.rs
new file mode 100644
index 0000000..6558206
--- /dev/null
+++ b/crates/rusqlite/tests/vtab.rs
@@ -0,0 +1,100 @@
+//! Ensure Virtual tables can be declared outside `rusqlite` crate.
+
+#[cfg(feature = "vtab")]
+#[test]
+fn test_dummy_module() -> rusqlite::Result<()> {
+    use rusqlite::vtab::{
+        eponymous_only_module, sqlite3_vtab, sqlite3_vtab_cursor, Context, IndexInfo, VTab,
+        VTabConnection, VTabCursor, Values,
+    };
+    use rusqlite::{version_number, Connection, Result};
+    use std::marker::PhantomData;
+    use std::os::raw::c_int;
+
+    let module = eponymous_only_module::<DummyTab>();
+
+    #[repr(C)]
+    struct DummyTab {
+        /// Base class. Must be first
+        base: sqlite3_vtab,
+    }
+
+    unsafe impl<'vtab> VTab<'vtab> for DummyTab {
+        type Aux = ();
+        type Cursor = DummyTabCursor<'vtab>;
+
+        fn connect(
+            _: &mut VTabConnection,
+            _aux: Option<&()>,
+            _args: &[&[u8]],
+        ) -> Result<(String, DummyTab)> {
+            let vtab = DummyTab {
+                base: sqlite3_vtab::default(),
+            };
+            Ok(("CREATE TABLE x(value)".to_owned(), vtab))
+        }
+
+        fn best_index(&self, info: &mut IndexInfo) -> Result<()> {
+            info.set_estimated_cost(1.);
+            Ok(())
+        }
+
+        fn open(&'vtab mut self) -> Result<DummyTabCursor<'vtab>> {
+            Ok(DummyTabCursor::default())
+        }
+    }
+
+    #[derive(Default)]
+    #[repr(C)]
+    struct DummyTabCursor<'vtab> {
+        /// Base class. Must be first
+        base: sqlite3_vtab_cursor,
+        /// The rowid
+        row_id: i64,
+        phantom: PhantomData<&'vtab DummyTab>,
+    }
+
+    unsafe impl VTabCursor for DummyTabCursor<'_> {
+        fn filter(
+            &mut self,
+            _idx_num: c_int,
+            _idx_str: Option<&str>,
+            _args: &Values<'_>,
+        ) -> Result<()> {
+            self.row_id = 1;
+            Ok(())
+        }
+
+        fn next(&mut self) -> Result<()> {
+            self.row_id += 1;
+            Ok(())
+        }
+
+        fn eof(&self) -> bool {
+            self.row_id > 1
+        }
+
+        fn column(&self, ctx: &mut Context, _: c_int) -> Result<()> {
+            ctx.set_result(&self.row_id)
+        }
+
+        fn rowid(&self) -> Result<i64> {
+            Ok(self.row_id)
+        }
+    }
+
+    let db = Connection::open_in_memory()?;
+
+    db.create_module::<DummyTab>("dummy", module, None)?;
+
+    let version = version_number();
+    if version < 3_009_000 {
+        return Ok(());
+    }
+
+    let mut s = db.prepare("SELECT * FROM dummy()")?;
+
+    let dummy = s.query_row([], |row| row.get::<_, i32>(0))?;
+    assert_eq!(1, dummy);
+    Ok(())
+}
diff --git a/crates/rustc-demangle/.cargo-checksum.json b/crates/rustc-demangle/.cargo-checksum.json
new file mode 100644
index 0000000..9ddcdb2
--- /dev/null
+++ b/crates/rustc-demangle/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"f4132bc65d5e58e2f27b9f9ef197b1c286582137b65285292b75a5a230fc81c8","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"378f5840b258e2779c39418f3f2d7b2ba96f1c7917dd6be0713f88305dbda397","README.md":"3bb7af78423e95b207beebd452cdd973d65663cf25a0fc9358c588f53783293c","src/legacy.rs":"b4d5a140ed0bf2d792431961d6fd44a21c99235489a2c9f6717d1577a42c09ce","src/lib.rs":"607fe60c1e65da3f86a0b4b8fececb7db79049a0cd4cb316492e8e6593bf39c6","src/v0-large-test-symbols/early-recursion-limit":"96861a7042db35ee0bd04802820d0f2d6a3b534ce13547912b6364001ffd1494","src/v0.rs":"4e5bd069aa61def3dc732b3a285861914895272668ddfcb6b9eef46dd5713041"},"package":"d626bb9dae77e28219937af045c257c28bfd3f69333c512553507f5f9798cb76"}
\ No newline at end of file
diff --git a/crates/rustc-demangle/Android.bp b/crates/rustc-demangle/Android.bp
new file mode 100644
index 0000000..46115e8
--- /dev/null
+++ b/crates/rustc-demangle/Android.bp
@@ -0,0 +1,54 @@
+// This file is generated by cargo_embargo.
+// Do not modify this file because the changes will be overridden on upgrade.
+
+package {
+    default_applicable_licenses: ["external_rust_crates_rustc-demangle_license"],
+    default_team: "trendy_team_android_rust",
+}
+
+license {
+    name: "external_rust_crates_rustc-demangle_license",
+    visibility: [":__subpackages__"],
+    license_kinds: ["SPDX-license-identifier-Apache-2.0"],
+    license_text: ["LICENSE"],
+}
+
+rust_library {
+    name: "librustc_demangle",
+    host_supported: true,
+    crate_name: "rustc_demangle",
+    cargo_env_compat: true,
+    cargo_pkg_version: "0.1.23",
+    crate_root: "src/lib.rs",
+    edition: "2015",
+    features: ["std"],
+    apex_available: [
+        "//apex_available:platform",
+        "com.android.runtime",
+        "com.android.art.debug",
+        "com.android.art",
+    ],
+    native_bridge_supported: true,
+    product_available: true,
+    recovery_available: true,
+    vendor_available: true,
+    vendor_ramdisk_available: true,
+    ramdisk_available: true,
+    min_sdk_version: "S",
+}
+
+rust_test {
+    name: "rustc-demangle_test_src_lib",
+    host_supported: true,
+    crate_name: "rustc_demangle",
+    cargo_env_compat: true,
+    cargo_pkg_version: "0.1.23",
+    crate_root: "src/lib.rs",
+    test_suites: ["general-tests"],
+    auto_gen_config: true,
+    test_options: {
+        unit_test: true,
+    },
+    edition: "2015",
+    features: ["std"],
+}
diff --git a/crates/rustc-demangle/Cargo.lock b/crates/rustc-demangle/Cargo.lock
new file mode 100644
index 0000000..cb3d557
--- /dev/null
+++ b/crates/rustc-demangle/Cargo.lock
@@ -0,0 +1,23 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "compiler_builtins"
+version = "0.1.123"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b47fcbecb558bdad78c7d3a998523c60a50dd6cd046d5fe74163e309e878fff7"
+
+[[package]]
+name = "rustc-demangle"
+version = "0.1.23"
+dependencies = [
+ "compiler_builtins",
+ "rustc-std-workspace-core",
+]
+
+[[package]]
+name = "rustc-std-workspace-core"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1956f5517128a2b6f23ab2dadf1a976f4f5b27962e7724c2bf3d45e539ec098c"
diff --git a/crates/rustc-demangle/Cargo.toml b/crates/rustc-demangle/Cargo.toml
new file mode 100644
index 0000000..61238e3
--- /dev/null
+++ b/crates/rustc-demangle/Cargo.toml
@@ -0,0 +1,49 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+name = "rustc-demangle"
+version = "0.1.23"
+authors = ["Alex Crichton <alex@alexcrichton.com>"]
+description = """
+Rust compiler symbol demangling.
+"""
+homepage = "https://github.com/alexcrichton/rustc-demangle"
+documentation = "https://docs.rs/rustc-demangle"
+readme = "README.md"
+license = "MIT/Apache-2.0"
+repository = "https://github.com/alexcrichton/rustc-demangle"
+
+[package.metadata.docs.rs]
+features = ["std"]
+rustdoc-args = [
+    "--cfg",
+    "docsrs",
+]
+
+[profile.release]
+lto = true
+
+[dependencies.compiler_builtins]
+version = "0.1.2"
+optional = true
+
+[dependencies.core]
+version = "1.0.0"
+optional = true
+package = "rustc-std-workspace-core"
+
+[features]
+rustc-dep-of-std = [
+    "core",
+    "compiler_builtins",
+]
+std = []
diff --git a/crates/rustc-demangle/LICENSE b/crates/rustc-demangle/LICENSE
new file mode 120000
index 0000000..6b579aa
--- /dev/null
+++ b/crates/rustc-demangle/LICENSE
@@ -0,0 +1 @@
+LICENSE-APACHE
\ No newline at end of file
diff --git a/crates/rustc-demangle/LICENSE-APACHE b/crates/rustc-demangle/LICENSE-APACHE
new file mode 100644
index 0000000..16fe87b
--- /dev/null
+++ b/crates/rustc-demangle/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/crates/rustc-demangle/LICENSE-MIT b/crates/rustc-demangle/LICENSE-MIT
new file mode 100644
index 0000000..39e0ed6
--- /dev/null
+++ b/crates/rustc-demangle/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2014 Alex Crichton
+
+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/crates/rustc-demangle/METADATA b/crates/rustc-demangle/METADATA
new file mode 100644
index 0000000..a03a568
--- /dev/null
+++ b/crates/rustc-demangle/METADATA
@@ -0,0 +1,20 @@
+# This project was upgraded with external_updater.
+# Usage: tools/external_updater/updater.sh update external/rust/crates/rustc-demangle
+# For more info, check https://cs.android.com/android/platform/superproject/+/main:tools/external_updater/README.md
+
+name: "rustc-demangle"
+description: "Rust compiler symbol demangling."
+third_party {
+  license_type: NOTICE
+  last_upgrade_date {
+    year: 2024
+    month: 2
+    day: 8
+  }
+  homepage: "https://crates.io/crates/rustc-demangle"
+  identifier {
+    type: "Archive"
+    value: "https://static.crates.io/crates/rustc-demangle/rustc-demangle-0.1.23.crate"
+    version: "0.1.23"
+  }
+}
diff --git a/crates/rustc-demangle/MODULE_LICENSE_APACHE2 b/crates/rustc-demangle/MODULE_LICENSE_APACHE2
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/crates/rustc-demangle/MODULE_LICENSE_APACHE2
diff --git a/crates/rustc-demangle/README.md b/crates/rustc-demangle/README.md
new file mode 100644
index 0000000..0833e1e
--- /dev/null
+++ b/crates/rustc-demangle/README.md
@@ -0,0 +1,48 @@
+# rustc-demangle
+
+Demangling for Rust symbols, written in Rust.
+
+[Documentation](https://docs.rs/rustc-demangle)
+
+## Usage
+
+You can add this as a dependency via your `Cargo.toml`
+
+```toml
+[dependencies]
+rustc-demangle = "0.1"
+```
+
+and then be sure to check out the [crate
+documentation](https://docs.rs/rustc-demangle) for usage.
+
+## Usage from non-Rust languages
+
+You can also use this crate from other languages via the C API wrapper in the
+`crates/capi` directory. This can be build with:
+
+```sh
+$ cargo build -p rustc-demangle-capi --release
+```
+
+You'll then find `target/release/librustc_demangle.a` and
+`target/release/librustc_demangle.so` (or a different name depending on your
+platform). These objects implement the interface specified in
+`crates/capi/include/rustc_demangle.h`.
+
+# License
+
+This project is licensed under either of
+
+ * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
+   http://www.apache.org/licenses/LICENSE-2.0)
+ * MIT license ([LICENSE-MIT](LICENSE-MIT) or
+   http://opensource.org/licenses/MIT)
+
+at your option.
+
+### Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in rustc-demangle you, as defined in the Apache-2.0 license, shall
+be dual licensed as above, without any additional terms or conditions.
diff --git a/crates/rustc-demangle/TEST_MAPPING b/crates/rustc-demangle/TEST_MAPPING
new file mode 100644
index 0000000..fe4f528
--- /dev/null
+++ b/crates/rustc-demangle/TEST_MAPPING
@@ -0,0 +1,18 @@
+// Generated by update_crate_tests.py for tests that depend on this crate.
+{
+  "imports": [
+    {
+      "path": "external/rust/crates/rustc-demangle-capi"
+    }
+  ],
+  "presubmit": [
+    {
+      "name": "rustc-demangle_test_src_lib"
+    }
+  ],
+  "presubmit-rust": [
+    {
+      "name": "rustc-demangle_test_src_lib"
+    }
+  ]
+}
diff --git a/crates/rustc-demangle/cargo_embargo.json b/crates/rustc-demangle/cargo_embargo.json
new file mode 100644
index 0000000..de782dc
--- /dev/null
+++ b/crates/rustc-demangle/cargo_embargo.json
@@ -0,0 +1,16 @@
+{
+  "features": ["std"],
+  "apex_available": [
+    "//apex_available:platform",
+    "com.android.runtime",
+    "com.android.art.debug",
+    "com.android.art"
+  ],
+  "min_sdk_version": "S",
+  "native_bridge_supported": true,
+  "ramdisk_available": true,
+  "recovery_available": true,
+  "run_cargo": false,
+  "tests": true,
+  "vendor_ramdisk_available": true
+}
diff --git a/crates/rustc-demangle/src/legacy.rs b/crates/rustc-demangle/src/legacy.rs
new file mode 100644
index 0000000..d55f3a1
--- /dev/null
+++ b/crates/rustc-demangle/src/legacy.rs
@@ -0,0 +1,392 @@
+use core::char;
+use core::fmt;
+
+/// Representation of a demangled symbol name.
+pub struct Demangle<'a> {
+    inner: &'a str,
+    /// The number of ::-separated elements in the original name.
+    elements: usize,
+}
+
+/// De-mangles a Rust symbol into a more readable version
+///
+/// All Rust symbols by default are mangled as they contain characters that
+/// cannot be represented in all object files. The mangling mechanism is similar
+/// to C++'s, but Rust has a few specifics to handle items like lifetimes in
+/// symbols.
+///
+/// This function will take a **mangled** symbol and return a value. When printed,
+/// the de-mangled version will be written. If the symbol does not look like
+/// a mangled symbol, the original value will be written instead.
+///
+/// # Examples
+///
+/// ```
+/// use rustc_demangle::demangle;
+///
+/// assert_eq!(demangle("_ZN4testE").to_string(), "test");
+/// assert_eq!(demangle("_ZN3foo3barE").to_string(), "foo::bar");
+/// assert_eq!(demangle("foo").to_string(), "foo");
+/// ```
+
+// All Rust symbols are in theory lists of "::"-separated identifiers. Some
+// assemblers, however, can't handle these characters in symbol names. To get
+// around this, we use C++-style mangling. The mangling method is:
+//
+// 1. Prefix the symbol with "_ZN"
+// 2. For each element of the path, emit the length plus the element
+// 3. End the path with "E"
+//
+// For example, "_ZN4testE" => "test" and "_ZN3foo3barE" => "foo::bar".
+//
+// We're the ones printing our backtraces, so we can't rely on anything else to
+// demangle our symbols. It's *much* nicer to look at demangled symbols, so
+// this function is implemented to give us nice pretty output.
+//
+// Note that this demangler isn't quite as fancy as it could be. We have lots
+// of other information in our symbols like hashes, version, type information,
+// etc. Additionally, this doesn't handle glue symbols at all.
+pub fn demangle(s: &str) -> Result<(Demangle, &str), ()> {
+    // First validate the symbol. If it doesn't look like anything we're
+    // expecting, we just print it literally. Note that we must handle non-Rust
+    // symbols because we could have any function in the backtrace.
+    let inner = if s.starts_with("_ZN") {
+        &s[3..]
+    } else if s.starts_with("ZN") {
+        // On Windows, dbghelp strips leading underscores, so we accept "ZN...E"
+        // form too.
+        &s[2..]
+    } else if s.starts_with("__ZN") {
+        // On OSX, symbols are prefixed with an extra _
+        &s[4..]
+    } else {
+        return Err(());
+    };
+
+    // only work with ascii text
+    if inner.bytes().any(|c| c & 0x80 != 0) {
+        return Err(());
+    }
+
+    let mut elements = 0;
+    let mut chars = inner.chars();
+    let mut c = chars.next().ok_or(())?;
+    while c != 'E' {
+        // Decode an identifier element's length.
+        if !c.is_digit(10) {
+            return Err(());
+        }
+        let mut len = 0usize;
+        while let Some(d) = c.to_digit(10) {
+            len = len
+                .checked_mul(10)
+                .and_then(|len| len.checked_add(d as usize))
+                .ok_or(())?;
+            c = chars.next().ok_or(())?;
+        }
+
+        // `c` already contains the first character of this identifier, skip it and
+        // all the other characters of this identifier, to reach the next element.
+        for _ in 0..len {
+            c = chars.next().ok_or(())?;
+        }
+
+        elements += 1;
+    }
+
+    Ok((Demangle { inner, elements }, chars.as_str()))
+}
+
+// Rust hashes are hex digits with an `h` prepended.
+fn is_rust_hash(s: &str) -> bool {
+    s.starts_with('h') && s[1..].chars().all(|c| c.is_digit(16))
+}
+
+impl<'a> fmt::Display for Demangle<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        // Alright, let's do this.
+        let mut inner = self.inner;
+        for element in 0..self.elements {
+            let mut rest = inner;
+            while rest.chars().next().unwrap().is_digit(10) {
+                rest = &rest[1..];
+            }
+            let i: usize = inner[..(inner.len() - rest.len())].parse().unwrap();
+            inner = &rest[i..];
+            rest = &rest[..i];
+            // Skip printing the hash if alternate formatting
+            // was requested.
+            if f.alternate() && element + 1 == self.elements && is_rust_hash(&rest) {
+                break;
+            }
+            if element != 0 {
+                f.write_str("::")?;
+            }
+            if rest.starts_with("_$") {
+                rest = &rest[1..];
+            }
+            loop {
+                if rest.starts_with('.') {
+                    if let Some('.') = rest[1..].chars().next() {
+                        f.write_str("::")?;
+                        rest = &rest[2..];
+                    } else {
+                        f.write_str(".")?;
+                        rest = &rest[1..];
+                    }
+                } else if rest.starts_with('$') {
+                    let (escape, after_escape) = if let Some(end) = rest[1..].find('$') {
+                        (&rest[1..=end], &rest[end + 2..])
+                    } else {
+                        break;
+                    };
+
+                    // see src/librustc_codegen_utils/symbol_names/legacy.rs for these mappings
+                    let unescaped = match escape {
+                        "SP" => "@",
+                        "BP" => "*",
+                        "RF" => "&",
+                        "LT" => "<",
+                        "GT" => ">",
+                        "LP" => "(",
+                        "RP" => ")",
+                        "C" => ",",
+
+                        _ => {
+                            if escape.starts_with('u') {
+                                let digits = &escape[1..];
+                                let all_lower_hex = digits.chars().all(|c| match c {
+                                    '0'..='9' | 'a'..='f' => true,
+                                    _ => false,
+                                });
+                                let c = u32::from_str_radix(digits, 16)
+                                    .ok()
+                                    .and_then(char::from_u32);
+                                if let (true, Some(c)) = (all_lower_hex, c) {
+                                    // FIXME(eddyb) do we need to filter out control codepoints?
+                                    if !c.is_control() {
+                                        c.fmt(f)?;
+                                        rest = after_escape;
+                                        continue;
+                                    }
+                                }
+                            }
+                            break;
+                        }
+                    };
+                    f.write_str(unescaped)?;
+                    rest = after_escape;
+                } else if let Some(i) = rest.find(|c| c == '$' || c == '.') {
+                    f.write_str(&rest[..i])?;
+                    rest = &rest[i..];
+                } else {
+                    break;
+                }
+            }
+            f.write_str(rest)?;
+        }
+
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::prelude::v1::*;
+
+    macro_rules! t {
+        ($a:expr, $b:expr) => {
+            assert!(ok($a, $b))
+        };
+    }
+
+    macro_rules! t_err {
+        ($a:expr) => {
+            assert!(ok_err($a))
+        };
+    }
+
+    macro_rules! t_nohash {
+        ($a:expr, $b:expr) => {{
+            assert_eq!(format!("{:#}", ::demangle($a)), $b);
+        }};
+    }
+
+    fn ok(sym: &str, expected: &str) -> bool {
+        match ::try_demangle(sym) {
+            Ok(s) => {
+                if s.to_string() == expected {
+                    true
+                } else {
+                    println!("\n{}\n!=\n{}\n", s, expected);
+                    false
+                }
+            }
+            Err(_) => {
+                println!("error demangling");
+                false
+            }
+        }
+    }
+
+    fn ok_err(sym: &str) -> bool {
+        match ::try_demangle(sym) {
+            Ok(_) => {
+                println!("succeeded in demangling");
+                false
+            }
+            Err(_) => ::demangle(sym).to_string() == sym,
+        }
+    }
+
+    #[test]
+    fn demangle() {
+        t_err!("test");
+        t!("_ZN4testE", "test");
+        t_err!("_ZN4test");
+        t!("_ZN4test1a2bcE", "test::a::bc");
+    }
+
+    #[test]
+    fn demangle_dollars() {
+        t!("_ZN4$RP$E", ")");
+        t!("_ZN8$RF$testE", "&test");
+        t!("_ZN8$BP$test4foobE", "*test::foob");
+        t!("_ZN9$u20$test4foobE", " test::foob");
+        t!("_ZN35Bar$LT$$u5b$u32$u3b$$u20$4$u5d$$GT$E", "Bar<[u32; 4]>");
+    }
+
+    #[test]
+    fn demangle_many_dollars() {
+        t!("_ZN13test$u20$test4foobE", "test test::foob");
+        t!("_ZN12test$BP$test4foobE", "test*test::foob");
+    }
+
+    #[test]
+    fn demangle_osx() {
+        t!(
+            "__ZN5alloc9allocator6Layout9for_value17h02a996811f781011E",
+            "alloc::allocator::Layout::for_value::h02a996811f781011"
+        );
+        t!("__ZN38_$LT$core..option..Option$LT$T$GT$$GT$6unwrap18_MSG_FILE_LINE_COL17haf7cb8d5824ee659E", "<core::option::Option<T>>::unwrap::_MSG_FILE_LINE_COL::haf7cb8d5824ee659");
+        t!("__ZN4core5slice89_$LT$impl$u20$core..iter..traits..IntoIterator$u20$for$u20$$RF$$u27$a$u20$$u5b$T$u5d$$GT$9into_iter17h450e234d27262170E", "core::slice::<impl core::iter::traits::IntoIterator for &'a [T]>::into_iter::h450e234d27262170");
+    }
+
+    #[test]
+    fn demangle_windows() {
+        t!("ZN4testE", "test");
+        t!("ZN13test$u20$test4foobE", "test test::foob");
+        t!("ZN12test$RF$test4foobE", "test&test::foob");
+    }
+
+    #[test]
+    fn demangle_elements_beginning_with_underscore() {
+        t!("_ZN13_$LT$test$GT$E", "<test>");
+        t!("_ZN28_$u7b$$u7b$closure$u7d$$u7d$E", "{{closure}}");
+        t!("_ZN15__STATIC_FMTSTRE", "__STATIC_FMTSTR");
+    }
+
+    #[test]
+    fn demangle_trait_impls() {
+        t!(
+            "_ZN71_$LT$Test$u20$$u2b$$u20$$u27$static$u20$as$u20$foo..Bar$LT$Test$GT$$GT$3barE",
+            "<Test + 'static as foo::Bar<Test>>::bar"
+        );
+    }
+
+    #[test]
+    fn demangle_without_hash() {
+        let s = "_ZN3foo17h05af221e174051e9E";
+        t!(s, "foo::h05af221e174051e9");
+        t_nohash!(s, "foo");
+    }
+
+    #[test]
+    fn demangle_without_hash_edgecases() {
+        // One element, no hash.
+        t_nohash!("_ZN3fooE", "foo");
+        // Two elements, no hash.
+        t_nohash!("_ZN3foo3barE", "foo::bar");
+        // Longer-than-normal hash.
+        t_nohash!("_ZN3foo20h05af221e174051e9abcE", "foo");
+        // Shorter-than-normal hash.
+        t_nohash!("_ZN3foo5h05afE", "foo");
+        // Valid hash, but not at the end.
+        t_nohash!("_ZN17h05af221e174051e93fooE", "h05af221e174051e9::foo");
+        // Not a valid hash, missing the 'h'.
+        t_nohash!("_ZN3foo16ffaf221e174051e9E", "foo::ffaf221e174051e9");
+        // Not a valid hash, has a non-hex-digit.
+        t_nohash!("_ZN3foo17hg5af221e174051e9E", "foo::hg5af221e174051e9");
+    }
+
+    #[test]
+    fn demangle_thinlto() {
+        // One element, no hash.
+        t!("_ZN3fooE.llvm.9D1C9369", "foo");
+        t!("_ZN3fooE.llvm.9D1C9369@@16", "foo");
+        t_nohash!(
+            "_ZN9backtrace3foo17hbb467fcdaea5d79bE.llvm.A5310EB9",
+            "backtrace::foo"
+        );
+    }
+
+    #[test]
+    fn demangle_llvm_ir_branch_labels() {
+        t!("_ZN4core5slice77_$LT$impl$u20$core..ops..index..IndexMut$LT$I$GT$$u20$for$u20$$u5b$T$u5d$$GT$9index_mut17haf9727c2edfbc47bE.exit.i.i", "core::slice::<impl core::ops::index::IndexMut<I> for [T]>::index_mut::haf9727c2edfbc47b.exit.i.i");
+        t_nohash!("_ZN4core5slice77_$LT$impl$u20$core..ops..index..IndexMut$LT$I$GT$$u20$for$u20$$u5b$T$u5d$$GT$9index_mut17haf9727c2edfbc47bE.exit.i.i", "core::slice::<impl core::ops::index::IndexMut<I> for [T]>::index_mut.exit.i.i");
+    }
+
+    #[test]
+    fn demangle_ignores_suffix_that_doesnt_look_like_a_symbol() {
+        t_err!("_ZN3fooE.llvm moocow");
+    }
+
+    #[test]
+    fn dont_panic() {
+        ::demangle("_ZN2222222222222222222222EE").to_string();
+        ::demangle("_ZN5*70527e27.ll34csaғE").to_string();
+        ::demangle("_ZN5*70527a54.ll34_$b.1E").to_string();
+        ::demangle(
+            "\
+             _ZN5~saäb4e\n\
+             2734cOsbE\n\
+             5usage20h)3\0\0\0\0\0\0\07e2734cOsbE\
+             ",
+        )
+        .to_string();
+    }
+
+    #[test]
+    fn invalid_no_chop() {
+        t_err!("_ZNfooE");
+    }
+
+    #[test]
+    fn handle_assoc_types() {
+        t!("_ZN151_$LT$alloc..boxed..Box$LT$alloc..boxed..FnBox$LT$A$C$$u20$Output$u3d$R$GT$$u20$$u2b$$u20$$u27$a$GT$$u20$as$u20$core..ops..function..FnOnce$LT$A$GT$$GT$9call_once17h69e8f44b3723e1caE", "<alloc::boxed::Box<alloc::boxed::FnBox<A, Output=R> + 'a> as core::ops::function::FnOnce<A>>::call_once::h69e8f44b3723e1ca");
+    }
+
+    #[test]
+    fn handle_bang() {
+        t!(
+            "_ZN88_$LT$core..result..Result$LT$$u21$$C$$u20$E$GT$$u20$as$u20$std..process..Termination$GT$6report17hfc41d0da4a40b3e8E",
+            "<core::result::Result<!, E> as std::process::Termination>::report::hfc41d0da4a40b3e8"
+        );
+    }
+
+    #[test]
+    fn demangle_utf8_idents() {
+        t_nohash!(
+            "_ZN11utf8_idents157_$u10e1$$u10d0$$u10ed$$u10db$$u10d4$$u10da$$u10d0$$u10d3$_$u10d2$$u10d4$$u10db$$u10e0$$u10d8$$u10d4$$u10da$$u10d8$_$u10e1$$u10d0$$u10d3$$u10d8$$u10da$$u10d8$17h21634fd5714000aaE",
+            "utf8_idents::საჭმელად_გემრიელი_სადილი"
+        );
+    }
+
+    #[test]
+    fn demangle_issue_60925() {
+        t_nohash!(
+            "_ZN11issue_609253foo37Foo$LT$issue_60925..llv$u6d$..Foo$GT$3foo17h059a991a004536adE",
+            "issue_60925::foo::Foo<issue_60925::llvm::Foo>::foo"
+        );
+    }
+}
diff --git a/crates/rustc-demangle/src/lib.rs b/crates/rustc-demangle/src/lib.rs
new file mode 100644
index 0000000..cafec2f
--- /dev/null
+++ b/crates/rustc-demangle/src/lib.rs
@@ -0,0 +1,588 @@
+//! Demangle Rust compiler symbol names.
+//!
+//! This crate provides a `demangle` function which will return a `Demangle`
+//! sentinel value that can be used to learn about the demangled version of a
+//! symbol name. The demangled representation will be the same as the original
+//! if it doesn't look like a mangled symbol name.
+//!
+//! `Demangle` can be formatted with the `Display` trait. The alternate
+//! modifier (`#`) can be used to format the symbol name without the
+//! trailing hash value.
+//!
+//! # Examples
+//!
+//! ```
+//! use rustc_demangle::demangle;
+//!
+//! assert_eq!(demangle("_ZN4testE").to_string(), "test");
+//! assert_eq!(demangle("_ZN3foo3barE").to_string(), "foo::bar");
+//! assert_eq!(demangle("foo").to_string(), "foo");
+//! // With hash
+//! assert_eq!(format!("{}", demangle("_ZN3foo17h05af221e174051e9E")), "foo::h05af221e174051e9");
+//! // Without hash
+//! assert_eq!(format!("{:#}", demangle("_ZN3foo17h05af221e174051e9E")), "foo");
+//! ```
+
+#![no_std]
+#![deny(missing_docs)]
+#![cfg_attr(docsrs, feature(doc_cfg))]
+
+#[cfg(any(test, feature = "std"))]
+#[macro_use]
+extern crate std;
+
+// HACK(eddyb) helper macros for tests.
+#[cfg(test)]
+macro_rules! assert_contains {
+    ($s:expr, $needle:expr) => {{
+        let (s, needle) = ($s, $needle);
+        assert!(
+            s.contains(needle),
+            "{:?} should've contained {:?}",
+            s,
+            needle
+        );
+    }};
+}
+#[cfg(test)]
+macro_rules! assert_ends_with {
+    ($s:expr, $suffix:expr) => {{
+        let (s, suffix) = ($s, $suffix);
+        assert!(
+            s.ends_with(suffix),
+            "{:?} should've ended in {:?}",
+            s,
+            suffix
+        );
+    }};
+}
+
+mod legacy;
+mod v0;
+
+use core::fmt::{self, Write as _};
+
+/// Representation of a demangled symbol name.
+pub struct Demangle<'a> {
+    style: Option<DemangleStyle<'a>>,
+    original: &'a str,
+    suffix: &'a str,
+}
+
+enum DemangleStyle<'a> {
+    Legacy(legacy::Demangle<'a>),
+    V0(v0::Demangle<'a>),
+}
+
+/// De-mangles a Rust symbol into a more readable version
+///
+/// This function will take a **mangled** symbol and return a value. When printed,
+/// the de-mangled version will be written. If the symbol does not look like
+/// a mangled symbol, the original value will be written instead.
+///
+/// # Examples
+///
+/// ```
+/// use rustc_demangle::demangle;
+///
+/// assert_eq!(demangle("_ZN4testE").to_string(), "test");
+/// assert_eq!(demangle("_ZN3foo3barE").to_string(), "foo::bar");
+/// assert_eq!(demangle("foo").to_string(), "foo");
+/// ```
+pub fn demangle(mut s: &str) -> Demangle {
+    // During ThinLTO LLVM may import and rename internal symbols, so strip out
+    // those endings first as they're one of the last manglings applied to symbol
+    // names.
+    let llvm = ".llvm.";
+    if let Some(i) = s.find(llvm) {
+        let candidate = &s[i + llvm.len()..];
+        let all_hex = candidate.chars().all(|c| match c {
+            'A'..='F' | '0'..='9' | '@' => true,
+            _ => false,
+        });
+
+        if all_hex {
+            s = &s[..i];
+        }
+    }
+
+    let mut suffix = "";
+    let mut style = match legacy::demangle(s) {
+        Ok((d, s)) => {
+            suffix = s;
+            Some(DemangleStyle::Legacy(d))
+        }
+        Err(()) => match v0::demangle(s) {
+            Ok((d, s)) => {
+                suffix = s;
+                Some(DemangleStyle::V0(d))
+            }
+            // FIXME(eddyb) would it make sense to treat an unknown-validity
+            // symbol (e.g. one that errored with `RecursedTooDeep`) as
+            // v0-mangled, and have the error show up in the demangling?
+            // (that error already gets past this initial check, and therefore
+            // will show up in the demangling, if hidden behind a backref)
+            Err(v0::ParseError::Invalid) | Err(v0::ParseError::RecursedTooDeep) => None,
+        },
+    };
+
+    // Output like LLVM IR adds extra period-delimited words. See if
+    // we are in that case and save the trailing words if so.
+    if !suffix.is_empty() {
+        if suffix.starts_with('.') && is_symbol_like(suffix) {
+            // Keep the suffix.
+        } else {
+            // Reset the suffix and invalidate the demangling.
+            suffix = "";
+            style = None;
+        }
+    }
+
+    Demangle {
+        style,
+        original: s,
+        suffix,
+    }
+}
+
+#[cfg(feature = "std")]
+fn demangle_line(
+    line: &str,
+    output: &mut impl std::io::Write,
+    include_hash: bool,
+) -> std::io::Result<()> {
+    let mut head = 0;
+    while head < line.len() {
+        // Move to the next potential match
+        let next_head = match (line[head..].find("_ZN"), line[head..].find("_R")) {
+            (Some(idx), None) | (None, Some(idx)) => head + idx,
+            (Some(idx1), Some(idx2)) => head + idx1.min(idx2),
+            (None, None) => {
+                // No more matches...
+                line.len()
+            }
+        };
+        output.write_all(line[head..next_head].as_bytes())?;
+        head = next_head;
+        // Find the non-matching character.
+        //
+        // If we do not find a character, then until the end of the line is the
+        // thing to demangle.
+        let match_end = line[head..]
+            .find(|ch: char| !(ch == '$' || ch == '.' || ch == '_' || ch.is_ascii_alphanumeric()))
+            .map(|idx| head + idx)
+            .unwrap_or(line.len());
+
+        let mangled = &line[head..match_end];
+        head = head + mangled.len();
+        if let Ok(demangled) = try_demangle(mangled) {
+            if include_hash {
+                write!(output, "{}", demangled)?;
+            } else {
+                write!(output, "{:#}", demangled)?;
+            }
+        } else {
+            output.write_all(mangled.as_bytes())?;
+        }
+    }
+    Ok(())
+}
+
+/// Process a stream of data from `input` into the provided `output`, demangling any symbols found
+/// within.
+///
+/// Note that the underlying implementation will perform many relatively small writes to the
+/// output. If the output is expensive to write to (e.g., requires syscalls), consider using
+/// `std::io::BufWriter`.
+#[cfg(feature = "std")]
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
+pub fn demangle_stream<R: std::io::BufRead, W: std::io::Write>(
+    input: &mut R,
+    output: &mut W,
+    include_hash: bool,
+) -> std::io::Result<()> {
+    let mut buf = std::string::String::new();
+    // We read in lines to reduce the memory usage at any time.
+    //
+    // demangle_line is also more efficient with relatively small buffers as it will copy around
+    // trailing data during demangling. In the future we might directly stream to the output but at
+    // least right now that seems to be less efficient.
+    while input.read_line(&mut buf)? > 0 {
+        demangle_line(&buf, output, include_hash)?;
+        buf.clear();
+    }
+    Ok(())
+}
+
+/// Error returned from the `try_demangle` function below when demangling fails.
+#[derive(Debug, Clone)]
+pub struct TryDemangleError {
+    _priv: (),
+}
+
+/// The same as `demangle`, except return an `Err` if the string does not appear
+/// to be a Rust symbol, rather than "demangling" the given string as a no-op.
+///
+/// ```
+/// extern crate rustc_demangle;
+///
+/// let not_a_rust_symbol = "la la la";
+///
+/// // The `try_demangle` function will reject strings which are not Rust symbols.
+/// assert!(rustc_demangle::try_demangle(not_a_rust_symbol).is_err());
+///
+/// // While `demangle` will just pass the non-symbol through as a no-op.
+/// assert_eq!(rustc_demangle::demangle(not_a_rust_symbol).as_str(), not_a_rust_symbol);
+/// ```
+pub fn try_demangle(s: &str) -> Result<Demangle, TryDemangleError> {
+    let sym = demangle(s);
+    if sym.style.is_some() {
+        Ok(sym)
+    } else {
+        Err(TryDemangleError { _priv: () })
+    }
+}
+
+impl<'a> Demangle<'a> {
+    /// Returns the underlying string that's being demangled.
+    pub fn as_str(&self) -> &'a str {
+        self.original
+    }
+}
+
+fn is_symbol_like(s: &str) -> bool {
+    s.chars().all(|c| {
+        // Once `char::is_ascii_punctuation` and `char::is_ascii_alphanumeric`
+        // have been stable for long enough, use those instead for clarity
+        is_ascii_alphanumeric(c) || is_ascii_punctuation(c)
+    })
+}
+
+// Copied from the documentation of `char::is_ascii_alphanumeric`
+fn is_ascii_alphanumeric(c: char) -> bool {
+    match c {
+        '\u{0041}'..='\u{005A}' | '\u{0061}'..='\u{007A}' | '\u{0030}'..='\u{0039}' => true,
+        _ => false,
+    }
+}
+
+// Copied from the documentation of `char::is_ascii_punctuation`
+fn is_ascii_punctuation(c: char) -> bool {
+    match c {
+        '\u{0021}'..='\u{002F}'
+        | '\u{003A}'..='\u{0040}'
+        | '\u{005B}'..='\u{0060}'
+        | '\u{007B}'..='\u{007E}' => true,
+        _ => false,
+    }
+}
+
+impl<'a> fmt::Display for DemangleStyle<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            DemangleStyle::Legacy(ref d) => fmt::Display::fmt(d, f),
+            DemangleStyle::V0(ref d) => fmt::Display::fmt(d, f),
+        }
+    }
+}
+
+// Maximum size of the symbol that we'll print.
+const MAX_SIZE: usize = 1_000_000;
+
+#[derive(Copy, Clone, Debug)]
+struct SizeLimitExhausted;
+
+struct SizeLimitedFmtAdapter<F> {
+    remaining: Result<usize, SizeLimitExhausted>,
+    inner: F,
+}
+
+impl<F: fmt::Write> fmt::Write for SizeLimitedFmtAdapter<F> {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        self.remaining = self
+            .remaining
+            .and_then(|r| r.checked_sub(s.len()).ok_or(SizeLimitExhausted));
+
+        match self.remaining {
+            Ok(_) => self.inner.write_str(s),
+            Err(SizeLimitExhausted) => Err(fmt::Error),
+        }
+    }
+}
+
+impl<'a> fmt::Display for Demangle<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self.style {
+            None => f.write_str(self.original)?,
+            Some(ref d) => {
+                let alternate = f.alternate();
+                let mut size_limited_fmt = SizeLimitedFmtAdapter {
+                    remaining: Ok(MAX_SIZE),
+                    inner: &mut *f,
+                };
+                let fmt_result = if alternate {
+                    write!(size_limited_fmt, "{:#}", d)
+                } else {
+                    write!(size_limited_fmt, "{}", d)
+                };
+                let size_limit_result = size_limited_fmt.remaining.map(|_| ());
+
+                // Translate a `fmt::Error` generated by `SizeLimitedFmtAdapter`
+                // into an error message, instead of propagating it upwards
+                // (which could cause panicking from inside e.g. `std::io::print`).
+                match (fmt_result, size_limit_result) {
+                    (Err(_), Err(SizeLimitExhausted)) => f.write_str("{size limit reached}")?,
+
+                    _ => {
+                        fmt_result?;
+                        size_limit_result
+                            .expect("`fmt::Error` from `SizeLimitedFmtAdapter` was discarded");
+                    }
+                }
+            }
+        }
+        f.write_str(self.suffix)
+    }
+}
+
+impl<'a> fmt::Debug for Demangle<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Display::fmt(self, f)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::prelude::v1::*;
+
+    macro_rules! t {
+        ($a:expr, $b:expr) => {
+            assert!(ok($a, $b))
+        };
+    }
+
+    macro_rules! t_err {
+        ($a:expr) => {
+            assert!(ok_err($a))
+        };
+    }
+
+    macro_rules! t_nohash {
+        ($a:expr, $b:expr) => {{
+            assert_eq!(format!("{:#}", super::demangle($a)), $b);
+        }};
+    }
+
+    fn ok(sym: &str, expected: &str) -> bool {
+        match super::try_demangle(sym) {
+            Ok(s) => {
+                if s.to_string() == expected {
+                    true
+                } else {
+                    println!("\n{}\n!=\n{}\n", s, expected);
+                    false
+                }
+            }
+            Err(_) => {
+                println!("error demangling");
+                false
+            }
+        }
+    }
+
+    fn ok_err(sym: &str) -> bool {
+        match super::try_demangle(sym) {
+            Ok(_) => {
+                println!("succeeded in demangling");
+                false
+            }
+            Err(_) => super::demangle(sym).to_string() == sym,
+        }
+    }
+
+    #[test]
+    fn demangle() {
+        t_err!("test");
+        t!("_ZN4testE", "test");
+        t_err!("_ZN4test");
+        t!("_ZN4test1a2bcE", "test::a::bc");
+    }
+
+    #[test]
+    fn demangle_dollars() {
+        t!("_ZN4$RP$E", ")");
+        t!("_ZN8$RF$testE", "&test");
+        t!("_ZN8$BP$test4foobE", "*test::foob");
+        t!("_ZN9$u20$test4foobE", " test::foob");
+        t!("_ZN35Bar$LT$$u5b$u32$u3b$$u20$4$u5d$$GT$E", "Bar<[u32; 4]>");
+    }
+
+    #[test]
+    fn demangle_many_dollars() {
+        t!("_ZN13test$u20$test4foobE", "test test::foob");
+        t!("_ZN12test$BP$test4foobE", "test*test::foob");
+    }
+
+    #[test]
+    fn demangle_osx() {
+        t!(
+            "__ZN5alloc9allocator6Layout9for_value17h02a996811f781011E",
+            "alloc::allocator::Layout::for_value::h02a996811f781011"
+        );
+        t!("__ZN38_$LT$core..option..Option$LT$T$GT$$GT$6unwrap18_MSG_FILE_LINE_COL17haf7cb8d5824ee659E", "<core::option::Option<T>>::unwrap::_MSG_FILE_LINE_COL::haf7cb8d5824ee659");
+        t!("__ZN4core5slice89_$LT$impl$u20$core..iter..traits..IntoIterator$u20$for$u20$$RF$$u27$a$u20$$u5b$T$u5d$$GT$9into_iter17h450e234d27262170E", "core::slice::<impl core::iter::traits::IntoIterator for &'a [T]>::into_iter::h450e234d27262170");
+    }
+
+    #[test]
+    fn demangle_windows() {
+        t!("ZN4testE", "test");
+        t!("ZN13test$u20$test4foobE", "test test::foob");
+        t!("ZN12test$RF$test4foobE", "test&test::foob");
+    }
+
+    #[test]
+    fn demangle_elements_beginning_with_underscore() {
+        t!("_ZN13_$LT$test$GT$E", "<test>");
+        t!("_ZN28_$u7b$$u7b$closure$u7d$$u7d$E", "{{closure}}");
+        t!("_ZN15__STATIC_FMTSTRE", "__STATIC_FMTSTR");
+    }
+
+    #[test]
+    fn demangle_trait_impls() {
+        t!(
+            "_ZN71_$LT$Test$u20$$u2b$$u20$$u27$static$u20$as$u20$foo..Bar$LT$Test$GT$$GT$3barE",
+            "<Test + 'static as foo::Bar<Test>>::bar"
+        );
+    }
+
+    #[test]
+    fn demangle_without_hash() {
+        let s = "_ZN3foo17h05af221e174051e9E";
+        t!(s, "foo::h05af221e174051e9");
+        t_nohash!(s, "foo");
+    }
+
+    #[test]
+    fn demangle_without_hash_edgecases() {
+        // One element, no hash.
+        t_nohash!("_ZN3fooE", "foo");
+        // Two elements, no hash.
+        t_nohash!("_ZN3foo3barE", "foo::bar");
+        // Longer-than-normal hash.
+        t_nohash!("_ZN3foo20h05af221e174051e9abcE", "foo");
+        // Shorter-than-normal hash.
+        t_nohash!("_ZN3foo5h05afE", "foo");
+        // Valid hash, but not at the end.
+        t_nohash!("_ZN17h05af221e174051e93fooE", "h05af221e174051e9::foo");
+        // Not a valid hash, missing the 'h'.
+        t_nohash!("_ZN3foo16ffaf221e174051e9E", "foo::ffaf221e174051e9");
+        // Not a valid hash, has a non-hex-digit.
+        t_nohash!("_ZN3foo17hg5af221e174051e9E", "foo::hg5af221e174051e9");
+    }
+
+    #[test]
+    fn demangle_thinlto() {
+        // One element, no hash.
+        t!("_ZN3fooE.llvm.9D1C9369", "foo");
+        t!("_ZN3fooE.llvm.9D1C9369@@16", "foo");
+        t_nohash!(
+            "_ZN9backtrace3foo17hbb467fcdaea5d79bE.llvm.A5310EB9",
+            "backtrace::foo"
+        );
+    }
+
+    #[test]
+    fn demangle_llvm_ir_branch_labels() {
+        t!("_ZN4core5slice77_$LT$impl$u20$core..ops..index..IndexMut$LT$I$GT$$u20$for$u20$$u5b$T$u5d$$GT$9index_mut17haf9727c2edfbc47bE.exit.i.i", "core::slice::<impl core::ops::index::IndexMut<I> for [T]>::index_mut::haf9727c2edfbc47b.exit.i.i");
+        t_nohash!("_ZN4core5slice77_$LT$impl$u20$core..ops..index..IndexMut$LT$I$GT$$u20$for$u20$$u5b$T$u5d$$GT$9index_mut17haf9727c2edfbc47bE.exit.i.i", "core::slice::<impl core::ops::index::IndexMut<I> for [T]>::index_mut.exit.i.i");
+    }
+
+    #[test]
+    fn demangle_ignores_suffix_that_doesnt_look_like_a_symbol() {
+        t_err!("_ZN3fooE.llvm moocow");
+    }
+
+    #[test]
+    fn dont_panic() {
+        super::demangle("_ZN2222222222222222222222EE").to_string();
+        super::demangle("_ZN5*70527e27.ll34csaғE").to_string();
+        super::demangle("_ZN5*70527a54.ll34_$b.1E").to_string();
+        super::demangle(
+            "\
+             _ZN5~saäb4e\n\
+             2734cOsbE\n\
+             5usage20h)3\0\0\0\0\0\0\07e2734cOsbE\
+             ",
+        )
+        .to_string();
+    }
+
+    #[test]
+    fn invalid_no_chop() {
+        t_err!("_ZNfooE");
+    }
+
+    #[test]
+    fn handle_assoc_types() {
+        t!("_ZN151_$LT$alloc..boxed..Box$LT$alloc..boxed..FnBox$LT$A$C$$u20$Output$u3d$R$GT$$u20$$u2b$$u20$$u27$a$GT$$u20$as$u20$core..ops..function..FnOnce$LT$A$GT$$GT$9call_once17h69e8f44b3723e1caE", "<alloc::boxed::Box<alloc::boxed::FnBox<A, Output=R> + 'a> as core::ops::function::FnOnce<A>>::call_once::h69e8f44b3723e1ca");
+    }
+
+    #[test]
+    fn handle_bang() {
+        t!(
+            "_ZN88_$LT$core..result..Result$LT$$u21$$C$$u20$E$GT$$u20$as$u20$std..process..Termination$GT$6report17hfc41d0da4a40b3e8E",
+            "<core::result::Result<!, E> as std::process::Termination>::report::hfc41d0da4a40b3e8"
+        );
+    }
+
+    #[test]
+    fn limit_recursion() {
+        assert_contains!(
+            super::demangle("_RNvB_1a").to_string(),
+            "{recursion limit reached}"
+        );
+        assert_contains!(
+            super::demangle("_RMC0RB2_").to_string(),
+            "{recursion limit reached}"
+        );
+    }
+
+    #[test]
+    fn limit_output() {
+        assert_ends_with!(
+            super::demangle("RYFG_FGyyEvRYFF_EvRYFFEvERLB_B_B_ERLRjB_B_B_").to_string(),
+            "{size limit reached}"
+        );
+        // NOTE(eddyb) somewhat reduced version of the above, effectively
+        // `<for<...> fn()>` with a larger number of lifetimes in `...`.
+        assert_ends_with!(
+            super::demangle("_RMC0FGZZZ_Eu").to_string(),
+            "{size limit reached}"
+        );
+    }
+
+    #[cfg(feature = "std")]
+    fn demangle_str(input: &str) -> String {
+        let mut output = Vec::new();
+        super::demangle_line(input, &mut output, false);
+        String::from_utf8(output).unwrap()
+    }
+
+    #[test]
+    #[cfg(feature = "std")]
+    fn find_multiple() {
+        assert_eq!(
+            demangle_str("_ZN3fooE.llvm moocow _ZN3fooE.llvm"),
+            "foo.llvm moocow foo.llvm"
+        );
+    }
+
+    #[test]
+    #[cfg(feature = "std")]
+    fn interleaved_new_legacy() {
+        assert_eq!(
+            demangle_str("_ZN3fooE.llvm moocow _RNvMNtNtNtNtCs8a2262Dv4r_3mio3sys4unix8selector5epollNtB2_8Selector6select _ZN3fooE.llvm"),
+            "foo.llvm moocow <mio::sys::unix::selector::epoll::Selector>::select foo.llvm"
+        );
+    }
+}
diff --git a/crates/rustc-demangle/src/v0-large-test-symbols/early-recursion-limit b/crates/rustc-demangle/src/v0-large-test-symbols/early-recursion-limit
new file mode 100644
index 0000000..914d416
--- /dev/null
+++ b/crates/rustc-demangle/src/v0-large-test-symbols/early-recursion-limit
@@ -0,0 +1,10 @@
+# NOTE: empty lines, and lines starting with `#`, are ignored.
+
+# Large test symbols for `v0::test::demangling_limits`, that specifically cause
+# a `RecursedTooDeep` error from `v0::demangle`'s shallow traversal (sanity check)
+# of the mangled symbol, i.e. before any printing coudl be attempted.
+
+RICu4$TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOSOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTxxxxxRICu4,-xOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTxxxxxRICu4,-xOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTxxxxxRICu4,-xOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTxxxxxRICu4,-xOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTxxxxxRICu4,-xOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTxxxxxRICu4,-xOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTxxxxxRICu4,-xOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTxxxxxRICu4,-xOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTYTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTxxxxxRICu4,-xOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTxxxxxRICu4,-xOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTxxxxxRICu5,-xOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTxxxxxRICu3.,-xOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOxxxRICu4,-xxxxffff..ffffffffffffffffffffffffffffffffffffffffffffffffffffffffxxxxxxxxxxxxxxxxxxxRaRBRaR>R>xxxu2IC,-xxxxxxRIC4xxxOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTxxxxxRICu4.,-xOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOTTTOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOxxxRICu4,-xxxxffff..ffffffffffffffffffffffffffffffffffffffffffffffffffffffffxxxxxxxxxxxxxxxxxxxRaRBRaR>R>xxxu2IC,-xxxxxxRIC4xxx..K..xRBRaR>RICu6$-RBKIQARICu6$-RBKIQAA........TvvKKKKKKKKKxxxxxxxxxxxxxxxBKIQARICu6$-RBKIQAA...._.xxx
+RIYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRYYYYYYYYYXB_RXB_lYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRXB_RXYYYYYYYYYYYYYYYYYYYYYXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYyYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYyYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYyYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYyYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYyYYYYYYMYYYYYYYRXB_RXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYyYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRXB_RXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYyYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYyYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRYYYYYYYYYXB_RXB_lYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRXB_RXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYyYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYyYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRYFhhhhYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYyYYYYYYMYYYYNYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYyYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRYYYYYYYYYXB_RXB_lYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRXB_RXYYYYYYYYYYYYYYYYYYYYYXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYyYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYyYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYyYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYyYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRYYYYYYYYYXB_RXB_lYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRXB_RXYYYYYYYYYYYYYYYYYYYYYXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYNYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRYYYYYYYYYXB_RXB_lYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRXB_RXYYYYYYYYYYYYYYYYYYYYYXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYyYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYyYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYyYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYyYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYyYYYYYYMYYYYYYYRXB_RXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYyYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRXB_RXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYyYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYyYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYSYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRYYYYYYYYYXB_RXB_lYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRXB_RXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYyYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYyYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRYFhhhhYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYyYYYYYYMYYYYNYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYyYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRYYYYYYYYYXB_RXB_lYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRXB_RXYYYYYYYYYYYYYYYYYYYYYXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYyYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYyYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYyYYYYYYMYYYYYYYRXB_RXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYyYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRXB_RXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYyYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYyYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRYYYYYYYYYXB_RXB_lYYYYYYYYYYYYYYYYYYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRYYYYYYYYYXB_RXB_lYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRXB_RXYYYYYYYYYYYYYYYYYYYYYXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYMYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYyYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRXB_RXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYIBRIIRIIBRCIByEEj_ByEEj_EEj
+RYYYYYSSSSSSSSSSSSSSSSSSSSSSSSSSSYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRRRRRRRRRRRSSSSSSRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYRRRRRRSSSSSSSYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYyYYYbYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYmYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYYYYYbYYYYYYYYYRYYYYYYYYYYYYYYYYYYSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYmYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYYYYYbYYYYYYYYYRYYYYYYYYYYYYYYYYYYSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSYYYYYYYYYYYYRRRRRRRRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYyYYYbYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYmYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYYYYYbYYYYYYYYYRYYYYYYYYYYYYYYYYYYSSSYYYYSSSSSSSSSSSSSSSSSYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYRRRRRRSSSSSSSYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYyYYYbYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYSSSSRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYyYYYbYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYmYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYYYYYbYYYYYYYYYRYYYYYYYYYYYYYYYYYYSSSSSSSSSSSSSSSSSYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYRRRRRRSSSSSSSYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYyYYYbYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYmYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYYYYYbYYYYYYYYYRYYYYYYYYYYYYYYYYYYSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYyYYYbYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYmYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYYYYYbYYYYYYYYYRYYYYYYYYYYYYYYYYYYSSSSSSSSSSSSRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYRRRRRRSSSSSSSYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYyYYYbYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYmYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYYYYYbYYYYYYYYYRYYYYYYYYYYYYYYYYYYSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRSSSSSSSRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYyYYYbYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYmYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYYYYYbYYYYYYYYYRYYYYYYYYYYYYYYYYYYSSSSSSSSSSSSSSSSSYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYRRRRRRSSSSSSSYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYyYYYbYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYmYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYYYYYbYYYYYYYYYRYYYYYYYYYYYYYYYYYYSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSYYYYYYYYYYYYRRRRRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYRRRRRRSSSSSSSYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYPYYYYYYbYYYYYYYYYRYYYYYYYYYYYYYYYYYYSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYyYYYbYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYmYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYYYYYbYYYYYYYYYRYYYYYYYYYYYYYYYYYYSSSSSSSSSSSSRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYyYYYbYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYmYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYYYYYbYYYYYYYYYRYYYYYYYYYYYYYYYYYYSSSSSSSSSSSSYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYPYYyYYYbYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYmYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYYYYYbYYYYYYYYYRYYYYYYYYYYYYYYYYYYSSSSSSSSSSSSSSSSSYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYRRRRRRSSSSSSSYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYyYYYbYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYmYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYYYYYbYYYYYYYYYRYYYYYYYYYYYYYYYYYYSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYyYYYbYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYmYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYYYYYbYYYYYYYYYRYYYYYYYYYYYYYYYYYYSSSSSSSSSSSSRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYRRRRRRSSSSSSSYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYyYYYbYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYmYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYYYYYbYYYYYYYYYRYYYYYYYYYYYYYYYYYYSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRSSSSSSSRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYyYYYbYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYmYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYYYYYbYYYYYYYYYRYYYYYYYYYYYYYYYYYYSSSSSSSSSSSSSSSSSYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYRRRRRRSSSSSSSYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYyYYYbYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYmYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYYYYYbYYYYYYYYYRYYYYYYYYYYYYYYYYYYSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYyYYYbYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYmYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYYYYYbYYYYYYYYYRYYYYYYYYYYYYYYYYYYSSSSSSSSSSSSRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYmYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYYYYYbYYYYYYYYYRYYYYYYYYYYYYYYYYYYSSSSSSSSSSSSRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYyYYYbYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYmYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYYYYYbYYYYYYYYYRYYYYYYYYYYYYYYYYYYSSSSSSSSSSSSSSSSSYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYRRRRRRSSSSSSSYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYyYYYbYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYmYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYYYYYbYYYYYYYYYRYYYYYYYYYYYYYYYYYYSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYyYYYbYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYmYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYYYYYbYYYYYYYYYRYYYYYYYYYYYYYYYYYYSSSSSSSSSSSSRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYmYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYYYYYbYYYYYYYYYRYYYYYYYYYYYYYYYYYYSSSSSSSSSSSSSSSSSYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYRRRRRRSSSSSSSYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYPYYYYYYbYYYYYYYYYRYYYYYYYYYYYYYYYYYYSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYyYYYbYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYmYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYYYYYbYYYYYYYYYRYYYYYYYYYYYYYYYYYYSSSSSSSSSSSSRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYyYYYbYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYmYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYYYYYbYYYYYYYYYRYYYYYYYYYYYYYYYYYYSSSSSSSSSSSSRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYyYYYbYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYmYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYYYYYbYYYYYYYYYRYYYYYYYYYYYYYYYYYYSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYyYYYbYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYmYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYYYYYbYYYYYYYYYRYYYYYYYYYYYYYYYYYYSSSSSSSSSSSSRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYmYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYYYYYbYYYYYYYYYRYYYYYYYYYYYYYYYYYYSSSSSSSSSSSSSSSSSYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYRRRRRRSSSSSSSYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYPYYYYYYbYYYYYYYYYRYYYYYYYYYYYYYYYYYYSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYyYYYbYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYmYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYYYYYbYYYYYYYYYRYYYYYYYYYYYYYYYYYYSSSSSSSSSSSSRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYyYYYbYYYYYYYYYYYYYYRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRYYYYYYYYYYYYYmYYYYYYYYYYYYYYYYYYYYYRCu3YYYYYYYYYYYPYYYYYYbYYYYYYYYYRYYYYYYYYYYYYYYYYYYSSSSSSSSSSSS
+RYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYyYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYR;
diff --git a/crates/rustc-demangle/src/v0.rs b/crates/rustc-demangle/src/v0.rs
new file mode 100644
index 0000000..3e88fa6
--- /dev/null
+++ b/crates/rustc-demangle/src/v0.rs
@@ -0,0 +1,1530 @@
+use core::convert::TryFrom;
+use core::{char, fmt, iter, mem, str};
+
+#[allow(unused_macros)]
+macro_rules! write {
+    ($($ignored:tt)*) => {
+        compile_error!(
+            "use `self.print(value)` or `fmt::Trait::fmt(&value, self.out)`, \
+             instead of `write!(self.out, \"{...}\", value)`"
+        )
+    };
+}
+
+// Maximum recursion depth when parsing symbols before we just bail out saying
+// "this symbol is invalid"
+const MAX_DEPTH: u32 = 500;
+
+/// Representation of a demangled symbol name.
+pub struct Demangle<'a> {
+    inner: &'a str,
+}
+
+#[derive(PartialEq, Eq, Debug)]
+pub enum ParseError {
+    /// Symbol doesn't match the expected `v0` grammar.
+    Invalid,
+
+    /// Parsing the symbol crossed the recursion limit (see `MAX_DEPTH`).
+    RecursedTooDeep,
+}
+
+/// De-mangles a Rust symbol into a more readable version
+///
+/// This function will take a **mangled** symbol and return a value. When printed,
+/// the de-mangled version will be written. If the symbol does not look like
+/// a mangled symbol, the original value will be written instead.
+pub fn demangle(s: &str) -> Result<(Demangle, &str), ParseError> {
+    // First validate the symbol. If it doesn't look like anything we're
+    // expecting, we just print it literally. Note that we must handle non-Rust
+    // symbols because we could have any function in the backtrace.
+    let inner;
+    if s.len() > 2 && s.starts_with("_R") {
+        inner = &s[2..];
+    } else if s.len() > 1 && s.starts_with('R') {
+        // On Windows, dbghelp strips leading underscores, so we accept "R..."
+        // form too.
+        inner = &s[1..];
+    } else if s.len() > 3 && s.starts_with("__R") {
+        // On OSX, symbols are prefixed with an extra _
+        inner = &s[3..];
+    } else {
+        return Err(ParseError::Invalid);
+    }
+
+    // Paths always start with uppercase characters.
+    match inner.as_bytes()[0] {
+        b'A'..=b'Z' => {}
+        _ => return Err(ParseError::Invalid),
+    }
+
+    // only work with ascii text
+    if inner.bytes().any(|c| c & 0x80 != 0) {
+        return Err(ParseError::Invalid);
+    }
+
+    // Verify that the symbol is indeed a valid path.
+    let try_parse_path = |parser| {
+        let mut dummy_printer = Printer {
+            parser: Ok(parser),
+            out: None,
+            bound_lifetime_depth: 0,
+        };
+        dummy_printer
+            .print_path(false)
+            .expect("`fmt::Error`s should be impossible without a `fmt::Formatter`");
+        dummy_printer.parser
+    };
+    let mut parser = Parser {
+        sym: inner,
+        next: 0,
+        depth: 0,
+    };
+    parser = try_parse_path(parser)?;
+
+    // Instantiating crate (paths always start with uppercase characters).
+    if let Some(&(b'A'..=b'Z')) = parser.sym.as_bytes().get(parser.next) {
+        parser = try_parse_path(parser)?;
+    }
+
+    Ok((Demangle { inner }, &parser.sym[parser.next..]))
+}
+
+impl<'s> fmt::Display for Demangle<'s> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let mut printer = Printer {
+            parser: Ok(Parser {
+                sym: self.inner,
+                next: 0,
+                depth: 0,
+            }),
+            out: Some(f),
+            bound_lifetime_depth: 0,
+        };
+        printer.print_path(true)
+    }
+}
+
+struct Ident<'s> {
+    /// ASCII part of the identifier.
+    ascii: &'s str,
+    /// Punycode insertion codes for Unicode codepoints, if any.
+    punycode: &'s str,
+}
+
+const SMALL_PUNYCODE_LEN: usize = 128;
+
+impl<'s> Ident<'s> {
+    /// Attempt to decode punycode on the stack (allocation-free),
+    /// and pass the char slice to the closure, if successful.
+    /// This supports up to `SMALL_PUNYCODE_LEN` characters.
+    fn try_small_punycode_decode<F: FnOnce(&[char]) -> R, R>(&self, f: F) -> Option<R> {
+        let mut out = ['\0'; SMALL_PUNYCODE_LEN];
+        let mut out_len = 0;
+        let r = self.punycode_decode(|i, c| {
+            // Check there's space left for another character.
+            out.get(out_len).ok_or(())?;
+
+            // Move the characters after the insert position.
+            let mut j = out_len;
+            out_len += 1;
+
+            while j > i {
+                out[j] = out[j - 1];
+                j -= 1;
+            }
+
+            // Insert the new character.
+            out[i] = c;
+
+            Ok(())
+        });
+        if r.is_ok() {
+            Some(f(&out[..out_len]))
+        } else {
+            None
+        }
+    }
+
+    /// Decode punycode as insertion positions and characters
+    /// and pass them to the closure, which can return `Err(())`
+    /// to stop the decoding process.
+    fn punycode_decode<F: FnMut(usize, char) -> Result<(), ()>>(
+        &self,
+        mut insert: F,
+    ) -> Result<(), ()> {
+        let mut punycode_bytes = self.punycode.bytes().peekable();
+        if punycode_bytes.peek().is_none() {
+            return Err(());
+        }
+
+        let mut len = 0;
+
+        // Populate initial output from ASCII fragment.
+        for c in self.ascii.chars() {
+            insert(len, c)?;
+            len += 1;
+        }
+
+        // Punycode parameters and initial state.
+        let base = 36;
+        let t_min = 1;
+        let t_max = 26;
+        let skew = 38;
+        let mut damp = 700;
+        let mut bias = 72;
+        let mut i: usize = 0;
+        let mut n: usize = 0x80;
+
+        loop {
+            // Read one delta value.
+            let mut delta: usize = 0;
+            let mut w = 1;
+            let mut k: usize = 0;
+            loop {
+                use core::cmp::{max, min};
+
+                k += base;
+                let t = min(max(k.saturating_sub(bias), t_min), t_max);
+
+                let d = match punycode_bytes.next() {
+                    Some(d @ b'a'..=b'z') => d - b'a',
+                    Some(d @ b'0'..=b'9') => 26 + (d - b'0'),
+                    _ => return Err(()),
+                };
+                let d = d as usize;
+                delta = delta.checked_add(d.checked_mul(w).ok_or(())?).ok_or(())?;
+                if d < t {
+                    break;
+                }
+                w = w.checked_mul(base - t).ok_or(())?;
+            }
+
+            // Compute the new insert position and character.
+            len += 1;
+            i = i.checked_add(delta).ok_or(())?;
+            n = n.checked_add(i / len).ok_or(())?;
+            i %= len;
+
+            let n_u32 = n as u32;
+            let c = if n_u32 as usize == n {
+                char::from_u32(n_u32).ok_or(())?
+            } else {
+                return Err(());
+            };
+
+            // Insert the new character and increment the insert position.
+            insert(i, c)?;
+            i += 1;
+
+            // If there are no more deltas, decoding is complete.
+            if punycode_bytes.peek().is_none() {
+                return Ok(());
+            }
+
+            // Perform bias adaptation.
+            delta /= damp;
+            damp = 2;
+
+            delta += delta / len;
+            let mut k = 0;
+            while delta > ((base - t_min) * t_max) / 2 {
+                delta /= base - t_min;
+                k += base;
+            }
+            bias = k + ((base - t_min + 1) * delta) / (delta + skew);
+        }
+    }
+}
+
+impl<'s> fmt::Display for Ident<'s> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.try_small_punycode_decode(|chars| {
+            for &c in chars {
+                c.fmt(f)?;
+            }
+            Ok(())
+        })
+        .unwrap_or_else(|| {
+            if !self.punycode.is_empty() {
+                f.write_str("punycode{")?;
+
+                // Reconstruct a standard Punycode encoding,
+                // by using `-` as the separator.
+                if !self.ascii.is_empty() {
+                    f.write_str(self.ascii)?;
+                    f.write_str("-")?;
+                }
+                f.write_str(self.punycode)?;
+
+                f.write_str("}")
+            } else {
+                f.write_str(self.ascii)
+            }
+        })
+    }
+}
+
+/// Sequence of lowercase hexadecimal nibbles (`0-9a-f`), used by leaf consts.
+struct HexNibbles<'s> {
+    nibbles: &'s str,
+}
+
+impl<'s> HexNibbles<'s> {
+    /// Decode an integer value (with the "most significant nibble" first),
+    /// returning `None` if it can't fit in an `u64`.
+    // FIXME(eddyb) should this "just" use `u128` instead?
+    fn try_parse_uint(&self) -> Option<u64> {
+        let nibbles = self.nibbles.trim_start_matches("0");
+
+        if nibbles.len() > 16 {
+            return None;
+        }
+
+        let mut v = 0;
+        for nibble in nibbles.chars() {
+            v = (v << 4) | (nibble.to_digit(16).unwrap() as u64);
+        }
+        Some(v)
+    }
+
+    /// Decode a UTF-8 byte sequence (with each byte using a pair of nibbles)
+    /// into individual `char`s, returning `None` for invalid UTF-8.
+    fn try_parse_str_chars(&self) -> Option<impl Iterator<Item = char> + 's> {
+        if self.nibbles.len() % 2 != 0 {
+            return None;
+        }
+
+        // FIXME(eddyb) use `array_chunks` instead, when that becomes stable.
+        let mut bytes = self
+            .nibbles
+            .as_bytes()
+            .chunks_exact(2)
+            .map(|slice| match slice {
+                [a, b] => [a, b],
+                _ => unreachable!(),
+            })
+            .map(|[&hi, &lo]| {
+                let half = |nibble: u8| (nibble as char).to_digit(16).unwrap() as u8;
+                (half(hi) << 4) | half(lo)
+            });
+
+        let chars = iter::from_fn(move || {
+            // As long as there are any bytes left, there's at least one more
+            // UTF-8-encoded `char` to decode (or the possibility of error).
+            bytes.next().map(|first_byte| -> Result<char, ()> {
+                // FIXME(eddyb) this `enum` and `fn` should be somewhere in `core`.
+                enum Utf8FirstByteError {
+                    ContinuationByte,
+                    TooLong,
+                }
+                fn utf8_len_from_first_byte(byte: u8) -> Result<usize, Utf8FirstByteError> {
+                    match byte {
+                        0x00..=0x7f => Ok(1),
+                        0x80..=0xbf => Err(Utf8FirstByteError::ContinuationByte),
+                        0xc0..=0xdf => Ok(2),
+                        0xe0..=0xef => Ok(3),
+                        0xf0..=0xf7 => Ok(4),
+                        0xf8..=0xff => Err(Utf8FirstByteError::TooLong),
+                    }
+                }
+
+                // Collect the appropriate amount of bytes (up to 4), according
+                // to the UTF-8 length implied by the first byte.
+                let utf8_len = utf8_len_from_first_byte(first_byte).map_err(|_| ())?;
+                let utf8 = &mut [first_byte, 0, 0, 0][..utf8_len];
+                for i in 1..utf8_len {
+                    utf8[i] = bytes.next().ok_or(())?;
+                }
+
+                // Fully validate the UTF-8 sequence.
+                let s = str::from_utf8(utf8).map_err(|_| ())?;
+
+                // Since we included exactly one UTF-8 sequence, and validation
+                // succeeded, `str::chars` should return exactly one `char`.
+                let mut chars = s.chars();
+                match (chars.next(), chars.next()) {
+                    (Some(c), None) => Ok(c),
+                    _ => unreachable!(
+                        "str::from_utf8({:?}) = {:?} was expected to have 1 char, \
+                         but {} chars were found",
+                        utf8,
+                        s,
+                        s.chars().count()
+                    ),
+                }
+            })
+        });
+
+        // HACK(eddyb) doing a separate validation iteration like this might be
+        // wasteful, but it's easier to avoid starting to print a string literal
+        // in the first place, than to abort it mid-string.
+        if chars.clone().any(|r| r.is_err()) {
+            None
+        } else {
+            Some(chars.map(Result::unwrap))
+        }
+    }
+}
+
+fn basic_type(tag: u8) -> Option<&'static str> {
+    Some(match tag {
+        b'b' => "bool",
+        b'c' => "char",
+        b'e' => "str",
+        b'u' => "()",
+        b'a' => "i8",
+        b's' => "i16",
+        b'l' => "i32",
+        b'x' => "i64",
+        b'n' => "i128",
+        b'i' => "isize",
+        b'h' => "u8",
+        b't' => "u16",
+        b'm' => "u32",
+        b'y' => "u64",
+        b'o' => "u128",
+        b'j' => "usize",
+        b'f' => "f32",
+        b'd' => "f64",
+        b'z' => "!",
+        b'p' => "_",
+        b'v' => "...",
+
+        _ => return None,
+    })
+}
+
+struct Parser<'s> {
+    sym: &'s str,
+    next: usize,
+    depth: u32,
+}
+
+impl<'s> Parser<'s> {
+    fn push_depth(&mut self) -> Result<(), ParseError> {
+        self.depth += 1;
+        if self.depth > MAX_DEPTH {
+            Err(ParseError::RecursedTooDeep)
+        } else {
+            Ok(())
+        }
+    }
+
+    fn pop_depth(&mut self) {
+        self.depth -= 1;
+    }
+
+    fn peek(&self) -> Option<u8> {
+        self.sym.as_bytes().get(self.next).cloned()
+    }
+
+    fn eat(&mut self, b: u8) -> bool {
+        if self.peek() == Some(b) {
+            self.next += 1;
+            true
+        } else {
+            false
+        }
+    }
+
+    fn next(&mut self) -> Result<u8, ParseError> {
+        let b = self.peek().ok_or(ParseError::Invalid)?;
+        self.next += 1;
+        Ok(b)
+    }
+
+    fn hex_nibbles(&mut self) -> Result<HexNibbles<'s>, ParseError> {
+        let start = self.next;
+        loop {
+            match self.next()? {
+                b'0'..=b'9' | b'a'..=b'f' => {}
+                b'_' => break,
+                _ => return Err(ParseError::Invalid),
+            }
+        }
+        Ok(HexNibbles {
+            nibbles: &self.sym[start..self.next - 1],
+        })
+    }
+
+    fn digit_10(&mut self) -> Result<u8, ParseError> {
+        let d = match self.peek() {
+            Some(d @ b'0'..=b'9') => d - b'0',
+            _ => return Err(ParseError::Invalid),
+        };
+        self.next += 1;
+        Ok(d)
+    }
+
+    fn digit_62(&mut self) -> Result<u8, ParseError> {
+        let d = match self.peek() {
+            Some(d @ b'0'..=b'9') => d - b'0',
+            Some(d @ b'a'..=b'z') => 10 + (d - b'a'),
+            Some(d @ b'A'..=b'Z') => 10 + 26 + (d - b'A'),
+            _ => return Err(ParseError::Invalid),
+        };
+        self.next += 1;
+        Ok(d)
+    }
+
+    fn integer_62(&mut self) -> Result<u64, ParseError> {
+        if self.eat(b'_') {
+            return Ok(0);
+        }
+
+        let mut x: u64 = 0;
+        while !self.eat(b'_') {
+            let d = self.digit_62()? as u64;
+            x = x.checked_mul(62).ok_or(ParseError::Invalid)?;
+            x = x.checked_add(d).ok_or(ParseError::Invalid)?;
+        }
+        x.checked_add(1).ok_or(ParseError::Invalid)
+    }
+
+    fn opt_integer_62(&mut self, tag: u8) -> Result<u64, ParseError> {
+        if !self.eat(tag) {
+            return Ok(0);
+        }
+        self.integer_62()?.checked_add(1).ok_or(ParseError::Invalid)
+    }
+
+    fn disambiguator(&mut self) -> Result<u64, ParseError> {
+        self.opt_integer_62(b's')
+    }
+
+    fn namespace(&mut self) -> Result<Option<char>, ParseError> {
+        match self.next()? {
+            // Special namespaces, like closures and shims.
+            ns @ b'A'..=b'Z' => Ok(Some(ns as char)),
+
+            // Implementation-specific/unspecified namespaces.
+            b'a'..=b'z' => Ok(None),
+
+            _ => Err(ParseError::Invalid),
+        }
+    }
+
+    fn backref(&mut self) -> Result<Parser<'s>, ParseError> {
+        let s_start = self.next - 1;
+        let i = self.integer_62()?;
+        if i >= s_start as u64 {
+            return Err(ParseError::Invalid);
+        }
+        let mut new_parser = Parser {
+            sym: self.sym,
+            next: i as usize,
+            depth: self.depth,
+        };
+        new_parser.push_depth()?;
+        Ok(new_parser)
+    }
+
+    fn ident(&mut self) -> Result<Ident<'s>, ParseError> {
+        let is_punycode = self.eat(b'u');
+        let mut len = self.digit_10()? as usize;
+        if len != 0 {
+            while let Ok(d) = self.digit_10() {
+                len = len.checked_mul(10).ok_or(ParseError::Invalid)?;
+                len = len.checked_add(d as usize).ok_or(ParseError::Invalid)?;
+            }
+        }
+
+        // Skip past the optional `_` separator.
+        self.eat(b'_');
+
+        let start = self.next;
+        self.next = self.next.checked_add(len).ok_or(ParseError::Invalid)?;
+        if self.next > self.sym.len() {
+            return Err(ParseError::Invalid);
+        }
+
+        let ident = &self.sym[start..self.next];
+
+        if is_punycode {
+            let ident = match ident.bytes().rposition(|b| b == b'_') {
+                Some(i) => Ident {
+                    ascii: &ident[..i],
+                    punycode: &ident[i + 1..],
+                },
+                None => Ident {
+                    ascii: "",
+                    punycode: ident,
+                },
+            };
+            if ident.punycode.is_empty() {
+                return Err(ParseError::Invalid);
+            }
+            Ok(ident)
+        } else {
+            Ok(Ident {
+                ascii: ident,
+                punycode: "",
+            })
+        }
+    }
+}
+
+struct Printer<'a, 'b: 'a, 's> {
+    /// The input parser to demangle from, or `Err` if any (parse) error was
+    /// encountered (in order to disallow further likely-incorrect demangling).
+    ///
+    /// See also the documentation on the `invalid!` and `parse!` macros below.
+    parser: Result<Parser<'s>, ParseError>,
+
+    /// The output formatter to demangle to, or `None` while skipping printing.
+    out: Option<&'a mut fmt::Formatter<'b>>,
+
+    /// Cumulative number of lifetimes bound by `for<...>` binders ('G'),
+    /// anywhere "around" the current entity (e.g. type) being demangled.
+    /// This value is not tracked while skipping printing, as it'd be unused.
+    ///
+    /// See also the documentation on the `Printer::in_binder` method.
+    bound_lifetime_depth: u32,
+}
+
+impl ParseError {
+    /// Snippet to print when the error is initially encountered.
+    fn message(&self) -> &str {
+        match self {
+            ParseError::Invalid => "{invalid syntax}",
+            ParseError::RecursedTooDeep => "{recursion limit reached}",
+        }
+    }
+}
+
+/// Mark the parser as errored (with `ParseError::Invalid`), print the
+/// appropriate message (see `ParseError::message`) and return early.
+macro_rules! invalid {
+    ($printer:ident) => {{
+        let err = ParseError::Invalid;
+        $printer.print(err.message())?;
+        $printer.parser = Err(err);
+        return Ok(());
+    }};
+}
+
+/// Call a parser method (if the parser hasn't errored yet),
+/// and mark the parser as errored if it returns `Err`.
+///
+/// If the parser errored, before or now, this returns early,
+/// from the current function, after printing either:
+/// * for a new error, the appropriate message (see `ParseError::message`)
+/// * for an earlier error, only `?` -  this allows callers to keep printing
+///   the approximate syntax of the path/type/const, despite having errors,
+///   e.g. `Vec<[(A, ?); ?]>` instead of `Vec<[(A, ?`
+macro_rules! parse {
+    ($printer:ident, $method:ident $(($($arg:expr),*))*) => {
+        match $printer.parser {
+            Ok(ref mut parser) => match parser.$method($($($arg),*)*) {
+                Ok(x) => x,
+                Err(err) => {
+                    $printer.print(err.message())?;
+                    $printer.parser = Err(err);
+                    return Ok(());
+                }
+            }
+            Err(_) => return $printer.print("?"),
+        }
+    };
+}
+
+impl<'a, 'b, 's> Printer<'a, 'b, 's> {
+    /// Eat the given character from the parser,
+    /// returning `false` if the parser errored.
+    fn eat(&mut self, b: u8) -> bool {
+        self.parser.as_mut().map(|p| p.eat(b)) == Ok(true)
+    }
+
+    /// Skip printing (i.e. `self.out` will be `None`) for the duration of the
+    /// given closure. This should not change parsing behavior, only disable the
+    /// output, but there may be optimizations (such as not traversing backrefs).
+    fn skipping_printing<F>(&mut self, f: F)
+    where
+        F: FnOnce(&mut Self) -> fmt::Result,
+    {
+        let orig_out = self.out.take();
+        f(self).expect("`fmt::Error`s should be impossible without a `fmt::Formatter`");
+        self.out = orig_out;
+    }
+
+    /// Print the target of a backref, using the given closure.
+    /// When printing is being skipped, the backref will only be parsed,
+    /// ignoring the backref's target completely.
+    fn print_backref<F>(&mut self, f: F) -> fmt::Result
+    where
+        F: FnOnce(&mut Self) -> fmt::Result,
+    {
+        let backref_parser = parse!(self, backref);
+
+        if self.out.is_none() {
+            return Ok(());
+        }
+
+        let orig_parser = mem::replace(&mut self.parser, Ok(backref_parser));
+        let r = f(self);
+        self.parser = orig_parser;
+        r
+    }
+
+    fn pop_depth(&mut self) {
+        if let Ok(ref mut parser) = self.parser {
+            parser.pop_depth();
+        }
+    }
+
+    /// Output the given value to `self.out` (using `fmt::Display` formatting),
+    /// if printing isn't being skipped.
+    fn print(&mut self, x: impl fmt::Display) -> fmt::Result {
+        if let Some(out) = &mut self.out {
+            fmt::Display::fmt(&x, out)?;
+        }
+        Ok(())
+    }
+
+    /// Output the given `char`s (escaped using `char::escape_debug`), with the
+    /// whole sequence wrapped in quotes, for either a `char` or `&str` literal,
+    /// if printing isn't being skipped.
+    fn print_quoted_escaped_chars(
+        &mut self,
+        quote: char,
+        chars: impl Iterator<Item = char>,
+    ) -> fmt::Result {
+        if let Some(out) = &mut self.out {
+            use core::fmt::Write;
+
+            out.write_char(quote)?;
+            for c in chars {
+                // Special-case not escaping a single/double quote, when
+                // inside the opposite kind of quote.
+                if matches!((quote, c), ('\'', '"') | ('"', '\'')) {
+                    out.write_char(c)?;
+                    continue;
+                }
+
+                for escaped in c.escape_debug() {
+                    out.write_char(escaped)?;
+                }
+            }
+            out.write_char(quote)?;
+        }
+        Ok(())
+    }
+
+    /// Print the lifetime according to the previously decoded index.
+    /// An index of `0` always refers to `'_`, but starting with `1`,
+    /// indices refer to late-bound lifetimes introduced by a binder.
+    fn print_lifetime_from_index(&mut self, lt: u64) -> fmt::Result {
+        // Bound lifetimes aren't tracked when skipping printing.
+        if self.out.is_none() {
+            return Ok(());
+        }
+
+        self.print("'")?;
+        if lt == 0 {
+            return self.print("_");
+        }
+        match (self.bound_lifetime_depth as u64).checked_sub(lt) {
+            Some(depth) => {
+                // Try to print lifetimes alphabetically first.
+                if depth < 26 {
+                    let c = (b'a' + depth as u8) as char;
+                    self.print(c)
+                } else {
+                    // Use `'_123` after running out of letters.
+                    self.print("_")?;
+                    self.print(depth)
+                }
+            }
+            None => invalid!(self),
+        }
+    }
+
+    /// Optionally enter a binder ('G') for late-bound lifetimes,
+    /// printing e.g. `for<'a, 'b> ` before calling the closure,
+    /// and make those lifetimes visible to it (via depth level).
+    fn in_binder<F>(&mut self, f: F) -> fmt::Result
+    where
+        F: FnOnce(&mut Self) -> fmt::Result,
+    {
+        let bound_lifetimes = parse!(self, opt_integer_62(b'G'));
+
+        // Don't track bound lifetimes when skipping printing.
+        if self.out.is_none() {
+            return f(self);
+        }
+
+        if bound_lifetimes > 0 {
+            self.print("for<")?;
+            for i in 0..bound_lifetimes {
+                if i > 0 {
+                    self.print(", ")?;
+                }
+                self.bound_lifetime_depth += 1;
+                self.print_lifetime_from_index(1)?;
+            }
+            self.print("> ")?;
+        }
+
+        let r = f(self);
+
+        // Restore `bound_lifetime_depth` to the previous value.
+        self.bound_lifetime_depth -= bound_lifetimes as u32;
+
+        r
+    }
+
+    /// Print list elements using the given closure and separator,
+    /// until the end of the list ('E') is found, or the parser errors.
+    /// Returns the number of elements printed.
+    fn print_sep_list<F>(&mut self, f: F, sep: &str) -> Result<usize, fmt::Error>
+    where
+        F: Fn(&mut Self) -> fmt::Result,
+    {
+        let mut i = 0;
+        while self.parser.is_ok() && !self.eat(b'E') {
+            if i > 0 {
+                self.print(sep)?;
+            }
+            f(self)?;
+            i += 1;
+        }
+        Ok(i)
+    }
+
+    fn print_path(&mut self, in_value: bool) -> fmt::Result {
+        parse!(self, push_depth);
+
+        let tag = parse!(self, next);
+        match tag {
+            b'C' => {
+                let dis = parse!(self, disambiguator);
+                let name = parse!(self, ident);
+
+                self.print(name)?;
+                if let Some(out) = &mut self.out {
+                    if !out.alternate() {
+                        out.write_str("[")?;
+                        fmt::LowerHex::fmt(&dis, out)?;
+                        out.write_str("]")?;
+                    }
+                }
+            }
+            b'N' => {
+                let ns = parse!(self, namespace);
+
+                self.print_path(in_value)?;
+
+                // HACK(eddyb) if the parser is already marked as having errored,
+                // `parse!` below will print a `?` without its preceding `::`
+                // (because printing the `::` is skipped in certain conditions,
+                // i.e. a lowercase namespace with an empty identifier),
+                // so in order to get `::?`, the `::` has to be printed here.
+                if self.parser.is_err() {
+                    self.print("::")?;
+                }
+
+                let dis = parse!(self, disambiguator);
+                let name = parse!(self, ident);
+
+                match ns {
+                    // Special namespaces, like closures and shims.
+                    Some(ns) => {
+                        self.print("::{")?;
+                        match ns {
+                            'C' => self.print("closure")?,
+                            'S' => self.print("shim")?,
+                            _ => self.print(ns)?,
+                        }
+                        if !name.ascii.is_empty() || !name.punycode.is_empty() {
+                            self.print(":")?;
+                            self.print(name)?;
+                        }
+                        self.print("#")?;
+                        self.print(dis)?;
+                        self.print("}")?;
+                    }
+
+                    // Implementation-specific/unspecified namespaces.
+                    None => {
+                        if !name.ascii.is_empty() || !name.punycode.is_empty() {
+                            self.print("::")?;
+                            self.print(name)?;
+                        }
+                    }
+                }
+            }
+            b'M' | b'X' | b'Y' => {
+                if tag != b'Y' {
+                    // Ignore the `impl`'s own path.
+                    parse!(self, disambiguator);
+                    self.skipping_printing(|this| this.print_path(false));
+                }
+
+                self.print("<")?;
+                self.print_type()?;
+                if tag != b'M' {
+                    self.print(" as ")?;
+                    self.print_path(false)?;
+                }
+                self.print(">")?;
+            }
+            b'I' => {
+                self.print_path(in_value)?;
+                if in_value {
+                    self.print("::")?;
+                }
+                self.print("<")?;
+                self.print_sep_list(Self::print_generic_arg, ", ")?;
+                self.print(">")?;
+            }
+            b'B' => {
+                self.print_backref(|this| this.print_path(in_value))?;
+            }
+            _ => invalid!(self),
+        }
+
+        self.pop_depth();
+        Ok(())
+    }
+
+    fn print_generic_arg(&mut self) -> fmt::Result {
+        if self.eat(b'L') {
+            let lt = parse!(self, integer_62);
+            self.print_lifetime_from_index(lt)
+        } else if self.eat(b'K') {
+            self.print_const(false)
+        } else {
+            self.print_type()
+        }
+    }
+
+    fn print_type(&mut self) -> fmt::Result {
+        let tag = parse!(self, next);
+
+        if let Some(ty) = basic_type(tag) {
+            return self.print(ty);
+        }
+
+        parse!(self, push_depth);
+
+        match tag {
+            b'R' | b'Q' => {
+                self.print("&")?;
+                if self.eat(b'L') {
+                    let lt = parse!(self, integer_62);
+                    if lt != 0 {
+                        self.print_lifetime_from_index(lt)?;
+                        self.print(" ")?;
+                    }
+                }
+                if tag != b'R' {
+                    self.print("mut ")?;
+                }
+                self.print_type()?;
+            }
+
+            b'P' | b'O' => {
+                self.print("*")?;
+                if tag != b'P' {
+                    self.print("mut ")?;
+                } else {
+                    self.print("const ")?;
+                }
+                self.print_type()?;
+            }
+
+            b'A' | b'S' => {
+                self.print("[")?;
+                self.print_type()?;
+                if tag == b'A' {
+                    self.print("; ")?;
+                    self.print_const(true)?;
+                }
+                self.print("]")?;
+            }
+            b'T' => {
+                self.print("(")?;
+                let count = self.print_sep_list(Self::print_type, ", ")?;
+                if count == 1 {
+                    self.print(",")?;
+                }
+                self.print(")")?;
+            }
+            b'F' => self.in_binder(|this| {
+                let is_unsafe = this.eat(b'U');
+                let abi = if this.eat(b'K') {
+                    if this.eat(b'C') {
+                        Some("C")
+                    } else {
+                        let abi = parse!(this, ident);
+                        if abi.ascii.is_empty() || !abi.punycode.is_empty() {
+                            invalid!(this);
+                        }
+                        Some(abi.ascii)
+                    }
+                } else {
+                    None
+                };
+
+                if is_unsafe {
+                    this.print("unsafe ")?;
+                }
+
+                if let Some(abi) = abi {
+                    this.print("extern \"")?;
+
+                    // If the ABI had any `-`, they were replaced with `_`,
+                    // so the parts between `_` have to be re-joined with `-`.
+                    let mut parts = abi.split('_');
+                    this.print(parts.next().unwrap())?;
+                    for part in parts {
+                        this.print("-")?;
+                        this.print(part)?;
+                    }
+
+                    this.print("\" ")?;
+                }
+
+                this.print("fn(")?;
+                this.print_sep_list(Self::print_type, ", ")?;
+                this.print(")")?;
+
+                if this.eat(b'u') {
+                    // Skip printing the return type if it's 'u', i.e. `()`.
+                } else {
+                    this.print(" -> ")?;
+                    this.print_type()?;
+                }
+
+                Ok(())
+            })?,
+            b'D' => {
+                self.print("dyn ")?;
+                self.in_binder(|this| {
+                    this.print_sep_list(Self::print_dyn_trait, " + ")?;
+                    Ok(())
+                })?;
+
+                if !self.eat(b'L') {
+                    invalid!(self);
+                }
+                let lt = parse!(self, integer_62);
+                if lt != 0 {
+                    self.print(" + ")?;
+                    self.print_lifetime_from_index(lt)?;
+                }
+            }
+            b'B' => {
+                self.print_backref(Self::print_type)?;
+            }
+            _ => {
+                // Go back to the tag, so `print_path` also sees it.
+                let _ = self.parser.as_mut().map(|p| p.next -= 1);
+                self.print_path(false)?;
+            }
+        }
+
+        self.pop_depth();
+        Ok(())
+    }
+
+    /// A trait in a trait object may have some "existential projections"
+    /// (i.e. associated type bindings) after it, which should be printed
+    /// in the `<...>` of the trait, e.g. `dyn Trait<T, U, Assoc=X>`.
+    /// To this end, this method will keep the `<...>` of an 'I' path
+    /// open, by omitting the `>`, and return `Ok(true)` in that case.
+    fn print_path_maybe_open_generics(&mut self) -> Result<bool, fmt::Error> {
+        if self.eat(b'B') {
+            // NOTE(eddyb) the closure may not run if printing is being skipped,
+            // but in that case the returned boolean doesn't matter.
+            let mut open = false;
+            self.print_backref(|this| {
+                open = this.print_path_maybe_open_generics()?;
+                Ok(())
+            })?;
+            Ok(open)
+        } else if self.eat(b'I') {
+            self.print_path(false)?;
+            self.print("<")?;
+            self.print_sep_list(Self::print_generic_arg, ", ")?;
+            Ok(true)
+        } else {
+            self.print_path(false)?;
+            Ok(false)
+        }
+    }
+
+    fn print_dyn_trait(&mut self) -> fmt::Result {
+        let mut open = self.print_path_maybe_open_generics()?;
+
+        while self.eat(b'p') {
+            if !open {
+                self.print("<")?;
+                open = true;
+            } else {
+                self.print(", ")?;
+            }
+
+            let name = parse!(self, ident);
+            self.print(name)?;
+            self.print(" = ")?;
+            self.print_type()?;
+        }
+
+        if open {
+            self.print(">")?;
+        }
+
+        Ok(())
+    }
+
+    fn print_const(&mut self, in_value: bool) -> fmt::Result {
+        let tag = parse!(self, next);
+
+        parse!(self, push_depth);
+
+        // Only literals (and the names of `const` generic parameters, but they
+        // don't get mangled at all), can appear in generic argument position
+        // without any disambiguation, all other expressions require braces.
+        // To avoid duplicating the mapping between `tag` and what syntax gets
+        // used (especially any special-casing), every case that needs braces
+        // has to call `open_brace(self)?` (and the closing brace is automatic).
+        let mut opened_brace = false;
+        let mut open_brace_if_outside_expr = |this: &mut Self| {
+            // If this expression is nested in another, braces aren't required.
+            if in_value {
+                return Ok(());
+            }
+
+            opened_brace = true;
+            this.print("{")
+        };
+
+        match tag {
+            b'p' => self.print("_")?,
+
+            // Primitive leaves with hex-encoded values (see `basic_type`).
+            b'h' | b't' | b'm' | b'y' | b'o' | b'j' => self.print_const_uint(tag)?,
+            b'a' | b's' | b'l' | b'x' | b'n' | b'i' => {
+                if self.eat(b'n') {
+                    self.print("-")?;
+                }
+
+                self.print_const_uint(tag)?;
+            }
+            b'b' => match parse!(self, hex_nibbles).try_parse_uint() {
+                Some(0) => self.print("false")?,
+                Some(1) => self.print("true")?,
+                _ => invalid!(self),
+            },
+            b'c' => {
+                let valid_char = parse!(self, hex_nibbles)
+                    .try_parse_uint()
+                    .and_then(|v| u32::try_from(v).ok())
+                    .and_then(char::from_u32);
+                match valid_char {
+                    Some(c) => self.print_quoted_escaped_chars('\'', iter::once(c))?,
+                    None => invalid!(self),
+                }
+            }
+            b'e' => {
+                // NOTE(eddyb) a string literal `"..."` has type `&str`, so
+                // to get back the type `str`, `*"..."` syntax is needed
+                // (even if that may not be valid in Rust itself).
+                open_brace_if_outside_expr(self)?;
+                self.print("*")?;
+
+                self.print_const_str_literal()?;
+            }
+
+            b'R' | b'Q' => {
+                // NOTE(eddyb) this prints `"..."` instead of `&*"..."`, which
+                // is what `Re..._` would imply (see comment for `str` above).
+                if tag == b'R' && self.eat(b'e') {
+                    self.print_const_str_literal()?;
+                } else {
+                    open_brace_if_outside_expr(self)?;
+                    self.print("&")?;
+                    if tag != b'R' {
+                        self.print("mut ")?;
+                    }
+                    self.print_const(true)?;
+                }
+            }
+            b'A' => {
+                open_brace_if_outside_expr(self)?;
+                self.print("[")?;
+                self.print_sep_list(|this| this.print_const(true), ", ")?;
+                self.print("]")?;
+            }
+            b'T' => {
+                open_brace_if_outside_expr(self)?;
+                self.print("(")?;
+                let count = self.print_sep_list(|this| this.print_const(true), ", ")?;
+                if count == 1 {
+                    self.print(",")?;
+                }
+                self.print(")")?;
+            }
+            b'V' => {
+                open_brace_if_outside_expr(self)?;
+                self.print_path(true)?;
+                match parse!(self, next) {
+                    b'U' => {}
+                    b'T' => {
+                        self.print("(")?;
+                        self.print_sep_list(|this| this.print_const(true), ", ")?;
+                        self.print(")")?;
+                    }
+                    b'S' => {
+                        self.print(" { ")?;
+                        self.print_sep_list(
+                            |this| {
+                                parse!(this, disambiguator);
+                                let name = parse!(this, ident);
+                                this.print(name)?;
+                                this.print(": ")?;
+                                this.print_const(true)
+                            },
+                            ", ",
+                        )?;
+                        self.print(" }")?;
+                    }
+                    _ => invalid!(self),
+                }
+            }
+            b'B' => {
+                self.print_backref(|this| this.print_const(in_value))?;
+            }
+            _ => invalid!(self),
+        }
+
+        if opened_brace {
+            self.print("}")?;
+        }
+
+        self.pop_depth();
+        Ok(())
+    }
+
+    fn print_const_uint(&mut self, ty_tag: u8) -> fmt::Result {
+        let hex = parse!(self, hex_nibbles);
+
+        match hex.try_parse_uint() {
+            Some(v) => self.print(v)?,
+
+            // Print anything that doesn't fit in `u64` verbatim.
+            None => {
+                self.print("0x")?;
+                self.print(hex.nibbles)?;
+            }
+        }
+
+        if let Some(out) = &mut self.out {
+            if !out.alternate() {
+                let ty = basic_type(ty_tag).unwrap();
+                self.print(ty)?;
+            }
+        }
+
+        Ok(())
+    }
+
+    fn print_const_str_literal(&mut self) -> fmt::Result {
+        match parse!(self, hex_nibbles).try_parse_str_chars() {
+            Some(chars) => self.print_quoted_escaped_chars('"', chars),
+            None => invalid!(self),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::prelude::v1::*;
+
+    macro_rules! t {
+        ($a:expr, $b:expr) => {{
+            assert_eq!(format!("{}", ::demangle($a)), $b);
+        }};
+    }
+    macro_rules! t_nohash {
+        ($a:expr, $b:expr) => {{
+            assert_eq!(format!("{:#}", ::demangle($a)), $b);
+        }};
+    }
+    macro_rules! t_nohash_type {
+        ($a:expr, $b:expr) => {
+            t_nohash!(concat!("_RMC0", $a), concat!("<", $b, ">"))
+        };
+    }
+    macro_rules! t_const {
+        ($mangled:expr, $value:expr) => {
+            t_nohash!(
+                concat!("_RIC0K", $mangled, "E"),
+                concat!("::<", $value, ">")
+            )
+        };
+    }
+    macro_rules! t_const_suffixed {
+        ($mangled:expr, $value:expr, $value_ty_suffix:expr) => {{
+            t_const!($mangled, $value);
+            t!(
+                concat!("_RIC0K", $mangled, "E"),
+                concat!("[0]::<", $value, $value_ty_suffix, ">")
+            );
+        }};
+    }
+
+    #[test]
+    fn demangle_crate_with_leading_digit() {
+        t_nohash!("_RNvC6_123foo3bar", "123foo::bar");
+    }
+
+    #[test]
+    fn demangle_utf8_idents() {
+        t_nohash!(
+            "_RNqCs4fqI2P2rA04_11utf8_identsu30____7hkackfecea1cbdathfdh9hlq6y",
+            "utf8_idents::საჭმელად_გემრიელი_სადილი"
+        );
+    }
+
+    #[test]
+    fn demangle_closure() {
+        t_nohash!(
+            "_RNCNCNgCs6DXkGYLi8lr_2cc5spawn00B5_",
+            "cc::spawn::{closure#0}::{closure#0}"
+        );
+        t_nohash!(
+            "_RNCINkXs25_NgCsbmNqQUJIY6D_4core5sliceINyB9_4IterhENuNgNoBb_4iter8iterator8Iterator9rpositionNCNgNpB9_6memchr7memrchrs_0E0Bb_",
+            "<core::slice::Iter<u8> as core::iter::iterator::Iterator>::rposition::<core::slice::memchr::memrchr::{closure#1}>::{closure#0}"
+        );
+    }
+
+    #[test]
+    fn demangle_dyn_trait() {
+        t_nohash!(
+            "_RINbNbCskIICzLVDPPb_5alloc5alloc8box_freeDINbNiB4_5boxed5FnBoxuEp6OutputuEL_ECs1iopQbuBiw2_3std",
+            "alloc::alloc::box_free::<dyn alloc::boxed::FnBox<(), Output = ()>>"
+        );
+    }
+
+    #[test]
+    fn demangle_const_generics_preview() {
+        // NOTE(eddyb) this was hand-written, before rustc had working
+        // const generics support (but the mangling format did include them).
+        t_nohash_type!(
+            "INtC8arrayvec8ArrayVechKj7b_E",
+            "arrayvec::ArrayVec<u8, 123>"
+        );
+        t_const_suffixed!("j7b_", "123", "usize");
+    }
+
+    #[test]
+    fn demangle_min_const_generics() {
+        t_const!("p", "_");
+        t_const_suffixed!("hb_", "11", "u8");
+        t_const_suffixed!("off00ff00ff00ff00ff_", "0xff00ff00ff00ff00ff", "u128");
+        t_const_suffixed!("s98_", "152", "i16");
+        t_const_suffixed!("anb_", "-11", "i8");
+        t_const!("b0_", "false");
+        t_const!("b1_", "true");
+        t_const!("c76_", "'v'");
+        t_const!("c22_", r#"'"'"#);
+        t_const!("ca_", "'\\n'");
+        t_const!("c2202_", "'∂'");
+    }
+
+    #[test]
+    fn demangle_const_str() {
+        t_const!("e616263_", "{*\"abc\"}");
+        t_const!("e27_", r#"{*"'"}"#);
+        t_const!("e090a_", "{*\"\\t\\n\"}");
+        t_const!("ee28882c3bc_", "{*\"∂ü\"}");
+        t_const!(
+            "ee183a1e18390e183ade1839be18394e1839ae18390e183935fe18392e18394e1839b\
+              e183a0e18398e18394e1839ae183985fe183a1e18390e18393e18398e1839ae18398_",
+            "{*\"საჭმელად_გემრიელი_სადილი\"}"
+        );
+        t_const!(
+            "ef09f908af09fa688f09fa686f09f90ae20c2a720f09f90b6f09f9192e298\
+              95f09f94a520c2a720f09fa7a1f09f929bf09f929af09f9299f09f929c_",
+            "{*\"🐊🦈🦆🐮 § 🐶👒☕🔥 § 🧡💛💚💙💜\"}"
+        );
+    }
+
+    // NOTE(eddyb) this uses the same strings as `demangle_const_str` and should
+    // be kept in sync with it - while a macro could be used to generate both
+    // `str` and `&str` tests, from a single list of strings, this seems clearer.
+    #[test]
+    fn demangle_const_ref_str() {
+        t_const!("Re616263_", "\"abc\"");
+        t_const!("Re27_", r#""'""#);
+        t_const!("Re090a_", "\"\\t\\n\"");
+        t_const!("Ree28882c3bc_", "\"∂ü\"");
+        t_const!(
+            "Ree183a1e18390e183ade1839be18394e1839ae18390e183935fe18392e18394e1839b\
+               e183a0e18398e18394e1839ae183985fe183a1e18390e18393e18398e1839ae18398_",
+            "\"საჭმელად_გემრიელი_სადილი\""
+        );
+        t_const!(
+            "Ref09f908af09fa688f09fa686f09f90ae20c2a720f09f90b6f09f9192e298\
+               95f09f94a520c2a720f09fa7a1f09f929bf09f929af09f9299f09f929c_",
+            "\"🐊🦈🦆🐮 § 🐶👒☕🔥 § 🧡💛💚💙💜\""
+        );
+    }
+
+    #[test]
+    fn demangle_const_ref() {
+        t_const!("Rp", "{&_}");
+        t_const!("Rh7b_", "{&123}");
+        t_const!("Rb0_", "{&false}");
+        t_const!("Rc58_", "{&'X'}");
+        t_const!("RRRh0_", "{&&&0}");
+        t_const!("RRRe_", "{&&\"\"}");
+        t_const!("QAE", "{&mut []}");
+    }
+
+    #[test]
+    fn demangle_const_array() {
+        t_const!("AE", "{[]}");
+        t_const!("Aj0_E", "{[0]}");
+        t_const!("Ah1_h2_h3_E", "{[1, 2, 3]}");
+        t_const!("ARe61_Re62_Re63_E", "{[\"a\", \"b\", \"c\"]}");
+        t_const!("AAh1_h2_EAh3_h4_EE", "{[[1, 2], [3, 4]]}");
+    }
+
+    #[test]
+    fn demangle_const_tuple() {
+        t_const!("TE", "{()}");
+        t_const!("Tj0_E", "{(0,)}");
+        t_const!("Th1_b0_E", "{(1, false)}");
+        t_const!(
+            "TRe616263_c78_RAh1_h2_h3_EE",
+            "{(\"abc\", 'x', &[1, 2, 3])}"
+        );
+    }
+
+    #[test]
+    fn demangle_const_adt() {
+        t_const!(
+            "VNvINtNtC4core6option6OptionjE4NoneU",
+            "{core::option::Option::<usize>::None}"
+        );
+        t_const!(
+            "VNvINtNtC4core6option6OptionjE4SomeTj0_E",
+            "{core::option::Option::<usize>::Some(0)}"
+        );
+        t_const!(
+            "VNtC3foo3BarS1sRe616263_2chc78_5sliceRAh1_h2_h3_EE",
+            "{foo::Bar { s: \"abc\", ch: 'x', slice: &[1, 2, 3] }}"
+        );
+    }
+
+    #[test]
+    fn demangle_exponential_explosion() {
+        // NOTE(eddyb) because of the prefix added by `t_nohash_type!` is
+        // 3 bytes long, `B2_` refers to the start of the type, not `B_`.
+        // 6 backrefs (`B8_E` through `B3_E`) result in 2^6 = 64 copies of `_`.
+        // Also, because the `p` (`_`) type is after all of the starts of the
+        // backrefs, it can be replaced with any other type, independently.
+        t_nohash_type!(
+            concat!("TTTTTT", "p", "B8_E", "B7_E", "B6_E", "B5_E", "B4_E", "B3_E"),
+            "((((((_, _), (_, _)), ((_, _), (_, _))), (((_, _), (_, _)), ((_, _), (_, _)))), \
+             ((((_, _), (_, _)), ((_, _), (_, _))), (((_, _), (_, _)), ((_, _), (_, _))))), \
+             (((((_, _), (_, _)), ((_, _), (_, _))), (((_, _), (_, _)), ((_, _), (_, _)))), \
+             ((((_, _), (_, _)), ((_, _), (_, _))), (((_, _), (_, _)), ((_, _), (_, _))))))"
+        );
+    }
+
+    #[test]
+    fn demangle_thinlto() {
+        t_nohash!("_RC3foo.llvm.9D1C9369", "foo");
+        t_nohash!("_RC3foo.llvm.9D1C9369@@16", "foo");
+        t_nohash!("_RNvC9backtrace3foo.llvm.A5310EB9", "backtrace::foo");
+    }
+
+    #[test]
+    fn demangle_extra_suffix() {
+        // From alexcrichton/rustc-demangle#27:
+        t_nohash!(
+            "_RNvNtNtNtNtCs92dm3009vxr_4rand4rngs7adapter9reseeding4fork23FORK_HANDLER_REGISTERED.0.0",
+            "rand::rngs::adapter::reseeding::fork::FORK_HANDLER_REGISTERED.0.0"
+        );
+    }
+
+    #[test]
+    fn demangling_limits() {
+        // Stress tests found via fuzzing.
+
+        for sym in include_str!("v0-large-test-symbols/early-recursion-limit")
+            .lines()
+            .filter(|line| !line.is_empty() && !line.starts_with('#'))
+        {
+            assert_eq!(
+                super::demangle(sym).map(|_| ()),
+                Err(super::ParseError::RecursedTooDeep)
+            );
+        }
+
+        assert_contains!(
+            ::demangle(
+                "RIC20tRYIMYNRYFG05_EB5_B_B6_RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR\
+        RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRB_E",
+            )
+            .to_string(),
+            "{recursion limit reached}"
+        );
+    }
+
+    #[test]
+    fn recursion_limit_leaks() {
+        // NOTE(eddyb) this test checks that both paths and types support the
+        // recursion limit correctly, i.e. matching `push_depth` and `pop_depth`,
+        // and don't leak "recursion levels" and trip the limit.
+        // The test inputs are generated on the fly, using a repeated pattern,
+        // as hardcoding the actual strings would be too verbose.
+        // Also, `MAX_DEPTH` can be directly used, instead of assuming its value.
+        for &(sym_leaf, expected_leaf) in &[("p", "_"), ("Rp", "&_"), ("C1x", "x")] {
+            let mut sym = format!("_RIC0p");
+            let mut expected = format!("::<_");
+            for _ in 0..(super::MAX_DEPTH * 2) {
+                sym.push_str(sym_leaf);
+                expected.push_str(", ");
+                expected.push_str(expected_leaf);
+            }
+            sym.push('E');
+            expected.push('>');
+
+            t_nohash!(&sym, expected);
+        }
+    }
+
+    #[test]
+    fn recursion_limit_backref_free_bypass() {
+        // NOTE(eddyb) this test checks that long symbols cannot bypass the
+        // recursion limit by not using backrefs, and cause a stack overflow.
+
+        // This value was chosen to be high enough that stack overflows were
+        // observed even with `cargo test --release`.
+        let depth = 100_000;
+
+        // In order to hide the long mangling from the initial "shallow" parse,
+        // it's nested in an identifier (crate name), preceding its use.
+        let mut sym = format!("_RIC{}", depth);
+        let backref_start = sym.len() - 2;
+        for _ in 0..depth {
+            sym.push('R');
+        }
+
+        // Write a backref to just after the length of the identifier.
+        sym.push('B');
+        sym.push(char::from_digit((backref_start - 1) as u32, 36).unwrap());
+        sym.push('_');
+
+        // Close the `I` at the start.
+        sym.push('E');
+
+        assert_contains!(::demangle(&sym).to_string(), "{recursion limit reached}");
+    }
+}
diff --git a/crates/rustc-hash/.cargo-checksum.json b/crates/rustc-hash/.cargo-checksum.json
new file mode 100644
index 0000000..544af9f
--- /dev/null
+++ b/crates/rustc-hash/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"CODE_OF_CONDUCT.md":"edca092fde496419a9f1ba640048aa0270b62dfea576cd3175f0b53e3c230470","Cargo.toml":"647814b27b6fc4fbef1df70d796b53b723e776b68467372044e4182763007379","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","README.md":"cac8197ac869d64a6efc26cab883a269392ae6db51f7453bca722f8f31d67c7c","src/lib.rs":"ddecafb5db609d0d8eebd19e4d98dc865e7e9282a4183421f9bd765c01a231c0"},"package":"08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"}
\ No newline at end of file
diff --git a/crates/rustc-hash/Android.bp b/crates/rustc-hash/Android.bp
new file mode 100644
index 0000000..3ccf3bf
--- /dev/null
+++ b/crates/rustc-hash/Android.bp
@@ -0,0 +1,34 @@
+// This file is generated by cargo_embargo.
+// Do not modify this file because the changes will be overridden on upgrade.
+
+package {
+    default_applicable_licenses: ["external_rust_crates_rustc-hash_license"],
+    default_team: "trendy_team_android_rust",
+}
+
+license {
+    name: "external_rust_crates_rustc-hash_license",
+    visibility: [":__subpackages__"],
+    license_kinds: ["SPDX-license-identifier-Apache-2.0"],
+    license_text: ["LICENSE"],
+}
+
+rust_library {
+    name: "librustc_hash",
+    host_supported: true,
+    crate_name: "rustc_hash",
+    cargo_env_compat: true,
+    cargo_pkg_version: "1.1.0",
+    crate_root: "src/lib.rs",
+    edition: "2015",
+    features: [
+        "default",
+        "std",
+    ],
+    apex_available: [
+        "//apex_available:platform",
+        "//apex_available:anyapex",
+    ],
+    product_available: true,
+    vendor_available: true,
+}
diff --git a/crates/rustc-hash/CODE_OF_CONDUCT.md b/crates/rustc-hash/CODE_OF_CONDUCT.md
new file mode 100644
index 0000000..d70b2b5
--- /dev/null
+++ b/crates/rustc-hash/CODE_OF_CONDUCT.md
@@ -0,0 +1,40 @@
+# The Rust Code of Conduct
+
+A version of this document [can be found online](https://www.rust-lang.org/conduct.html).
+
+## Conduct
+
+**Contact**: [rust-mods@rust-lang.org](mailto:rust-mods@rust-lang.org)
+
+* We are committed to providing a friendly, safe and welcoming environment for all, regardless of level of experience, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, religion, nationality, or other similar characteristic.
+* On IRC, please avoid using overtly sexual nicknames or other nicknames that might detract from a friendly, safe and welcoming environment for all.
+* Please be kind and courteous. There's no need to be mean or rude.
+* Respect that people have differences of opinion and that every design or implementation choice carries a trade-off and numerous costs. There is seldom a right answer.
+* Please keep unstructured critique to a minimum. If you have solid ideas you want to experiment with, make a fork and see how it works.
+* We will exclude you from interaction if you insult, demean or harass anyone. That is not welcome behavior. We interpret the term "harassment" as including the definition in the <a href="http://citizencodeofconduct.org/">Citizen Code of Conduct</a>; if you have any lack of clarity about what might be included in that concept, please read their definition. In particular, we don't tolerate behavior that excludes people in socially marginalized groups.
+* Private harassment is also unacceptable. No matter who you are, if you feel you have been or are being harassed or made uncomfortable by a community member, please contact one of the channel ops or any of the [Rust moderation team][mod_team] immediately. Whether you're a regular contributor or a newcomer, we care about making this community a safe place for you and we've got your back.
+* Likewise any spamming, trolling, flaming, baiting or other attention-stealing behavior is not welcome.
+
+## Moderation
+
+
+These are the policies for upholding our community's standards of conduct. If you feel that a thread needs moderation, please contact the [Rust moderation team][mod_team].
+
+1. Remarks that violate the Rust standards of conduct, including hateful, hurtful, oppressive, or exclusionary remarks, are not allowed. (Cursing is allowed, but never targeting another user, and never in a hateful manner.)
+2. Remarks that moderators find inappropriate, whether listed in the code of conduct or not, are also not allowed.
+3. Moderators will first respond to such remarks with a warning.
+4. If the warning is unheeded, the user will be "kicked," i.e., kicked out of the communication channel to cool off.
+5. If the user comes back and continues to make trouble, they will be banned, i.e., indefinitely excluded.
+6. Moderators may choose at their discretion to un-ban the user if it was a first offense and they offer the offended party a genuine apology.
+7. If a moderator bans someone and you think it was unjustified, please take it up with that moderator, or with a different moderator, **in private**. Complaints about bans in-channel are not allowed.
+8. Moderators are held to a higher standard than other community members. If a moderator creates an inappropriate situation, they should expect less leeway than others.
+
+In the Rust community we strive to go the extra step to look out for each other. Don't just aim to be technically unimpeachable, try to be your best self. In particular, avoid flirting with offensive or sensitive issues, particularly if they're off-topic; this all too often leads to unnecessary fights, hurt feelings, and damaged trust; worse, it can drive people away from the community entirely.
+
+And if someone takes issue with something you said or did, resist the urge to be defensive. Just stop doing what it was they complained about and apologize. Even if you feel you were misinterpreted or unfairly accused, chances are good there was something you could've communicated better — remember that it's your responsibility to make your fellow Rustaceans comfortable. Everyone wants to get along and we are all here first and foremost because we want to talk about cool technology. You will find that people will be eager to assume good intent and forgive as long as you earn their trust.
+
+The enforcement policies listed above apply to all official Rust venues; including official IRC channels (#rust, #rust-internals, #rust-tools, #rust-libs, #rustc, #rust-beginners, #rust-docs, #rust-community, #rust-lang, and #cargo); GitHub repositories under rust-lang, rust-lang-nursery, and rust-lang-deprecated; and all forums under rust-lang.org (users.rust-lang.org, internals.rust-lang.org). For other projects adopting the Rust Code of Conduct, please contact the maintainers of those projects for enforcement. If you wish to use this code of conduct for your own project, consider explicitly mentioning your moderation policy or making a copy with your own moderation policy so as to avoid confusion.
+
+*Adapted from the [Node.js Policy on Trolling](http://blog.izs.me/post/30036893703/policy-on-trolling) as well as the [Contributor Covenant v1.3.0](https://www.contributor-covenant.org/version/1/3/0/).*
+
+[mod_team]: https://www.rust-lang.org/team.html#Moderation-team
diff --git a/crates/rustc-hash/Cargo.lock b/crates/rustc-hash/Cargo.lock
new file mode 100644
index 0000000..018d0d5
--- /dev/null
+++ b/crates/rustc-hash/Cargo.lock
@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "rustc-hash"
+version = "1.1.0"
diff --git a/crates/rustc-hash/Cargo.toml b/crates/rustc-hash/Cargo.toml
new file mode 100644
index 0000000..47330b7
--- /dev/null
+++ b/crates/rustc-hash/Cargo.toml
@@ -0,0 +1,25 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies
+#
+# If you believe there's an error in this file please file an
+# issue against the rust-lang/cargo repository. If you're
+# editing this file be aware that the upstream Cargo.toml
+# will likely look very different (and much more reasonable)
+
+[package]
+name = "rustc-hash"
+version = "1.1.0"
+authors = ["The Rust Project Developers"]
+description = "speed, non-cryptographic hash used in rustc"
+readme = "README.md"
+keywords = ["hash", "fxhash", "rustc"]
+license = "Apache-2.0/MIT"
+repository = "https://github.com/rust-lang-nursery/rustc-hash"
+
+[features]
+default = ["std"]
+std = []
diff --git a/crates/rustc-hash/LICENSE b/crates/rustc-hash/LICENSE
new file mode 120000
index 0000000..6b579aa
--- /dev/null
+++ b/crates/rustc-hash/LICENSE
@@ -0,0 +1 @@
+LICENSE-APACHE
\ No newline at end of file
diff --git a/crates/rustc-hash/LICENSE-APACHE b/crates/rustc-hash/LICENSE-APACHE
new file mode 100644
index 0000000..16fe87b
--- /dev/null
+++ b/crates/rustc-hash/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/crates/rustc-hash/LICENSE-MIT b/crates/rustc-hash/LICENSE-MIT
new file mode 100644
index 0000000..31aa793
--- /dev/null
+++ b/crates/rustc-hash/LICENSE-MIT
@@ -0,0 +1,23 @@
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/crates/rustc-hash/METADATA b/crates/rustc-hash/METADATA
new file mode 100644
index 0000000..6f1612e
--- /dev/null
+++ b/crates/rustc-hash/METADATA
@@ -0,0 +1,19 @@
+name: "rustc-hash"
+description: "speed, non-cryptographic hash used in rustc"
+third_party {
+  url {
+    type: HOMEPAGE
+    value: "https://crates.io/crates/rustc-hash"
+  }
+  url {
+    type: ARCHIVE
+    value: "https://static.crates.io/crates/rustc-hash/rustc-hash-1.1.0.crate"
+  }
+  version: "1.1.0"
+  license_type: NOTICE
+  last_upgrade_date {
+    year: 2020
+    month: 3
+    day: 31
+  }
+}
diff --git a/crates/rustc-hash/MODULE_LICENSE_APACHE2 b/crates/rustc-hash/MODULE_LICENSE_APACHE2
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/crates/rustc-hash/MODULE_LICENSE_APACHE2
diff --git a/crates/rustc-hash/README.md b/crates/rustc-hash/README.md
new file mode 100644
index 0000000..e33057a
--- /dev/null
+++ b/crates/rustc-hash/README.md
@@ -0,0 +1,38 @@
+# rustc-hash
+
+[![crates.io](https://img.shields.io/crates/v/rustc-hash.svg)](https://crates.io/crates/rustc-hash)
+[![Documentation](https://docs.rs/rustc-hash/badge.svg)](https://docs.rs/rustc-hash)
+
+A speedy hash algorithm used within rustc. The hashmap in liballoc by
+default uses SipHash which isn't quite as speedy as we want. In the
+compiler we're not really worried about DOS attempts, so we use a fast
+non-cryptographic hash.
+
+This is the same as the algorithm used by Firefox -- which is a
+homespun one not based on any widely-known algorithm -- though
+modified to produce 64-bit hash values instead of 32-bit hash
+values. It consistently out-performs an FNV-based hash within rustc
+itself -- the collision rate is similar or slightly worse than FNV,
+but the speed of the hash function itself is much higher because it
+works on up to 8 bytes at a time.
+
+## Usage
+
+```rust
+use rustc_hash::FxHashMap;
+
+let mut map: FxHashMap<u32, u32> = FxHashMap::default();
+map.insert(22, 44);
+```
+
+### `no_std`
+
+This crate can be used as a `no_std` crate by disabling the `std`
+feature, which is on by default, as follows:
+
+```toml
+rustc-hash = { version = "1.0", default-features = false }
+```
+
+In this configuration, `FxHasher` is the only export, and the
+`FxHashMap`/`FxHashSet` type aliases are omitted.
diff --git a/crates/rustc-hash/TEST_MAPPING b/crates/rustc-hash/TEST_MAPPING
new file mode 100644
index 0000000..23bbdf9
--- /dev/null
+++ b/crates/rustc-hash/TEST_MAPPING
@@ -0,0 +1,14 @@
+// Generated by update_crate_tests.py for tests that depend on this crate.
+{
+  "imports": [
+    {
+      "path": "external/rust/crates/libsqlite3-sys"
+    },
+    {
+      "path": "system/security/keystore2"
+    },
+    {
+      "path": "system/security/keystore2/legacykeystore"
+    }
+  ]
+}
diff --git a/crates/rustc-hash/cargo_embargo.json b/crates/rustc-hash/cargo_embargo.json
new file mode 100644
index 0000000..cb908d7
--- /dev/null
+++ b/crates/rustc-hash/cargo_embargo.json
@@ -0,0 +1,3 @@
+{
+  "run_cargo": false
+}
diff --git a/crates/rustc-hash/src/lib.rs b/crates/rustc-hash/src/lib.rs
new file mode 100644
index 0000000..ee9ad31
--- /dev/null
+++ b/crates/rustc-hash/src/lib.rs
@@ -0,0 +1,148 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Fast, non-cryptographic hash used by rustc and Firefox.
+//!
+//! # Example
+//!
+//! ```rust
+//! # #[cfg(feature = "std")]
+//! # fn main() {
+//! use rustc_hash::FxHashMap;
+//! let mut map: FxHashMap<u32, u32> = FxHashMap::default();
+//! map.insert(22, 44);
+//! # }
+//! # #[cfg(not(feature = "std"))]
+//! # fn main() { }
+//! ```
+
+#![no_std]
+
+#[cfg(feature = "std")]
+extern crate std;
+
+use core::convert::TryInto;
+use core::default::Default;
+#[cfg(feature = "std")]
+use core::hash::BuildHasherDefault;
+use core::hash::Hasher;
+use core::mem::size_of;
+use core::ops::BitXor;
+#[cfg(feature = "std")]
+use std::collections::{HashMap, HashSet};
+
+/// Type alias for a hashmap using the `fx` hash algorithm.
+#[cfg(feature = "std")]
+pub type FxHashMap<K, V> = HashMap<K, V, BuildHasherDefault<FxHasher>>;
+
+/// Type alias for a hashmap using the `fx` hash algorithm.
+#[cfg(feature = "std")]
+pub type FxHashSet<V> = HashSet<V, BuildHasherDefault<FxHasher>>;
+
+/// A speedy hash algorithm for use within rustc. The hashmap in liballoc
+/// by default uses SipHash which isn't quite as speedy as we want. In the
+/// compiler we're not really worried about DOS attempts, so we use a fast
+/// non-cryptographic hash.
+///
+/// This is the same as the algorithm used by Firefox -- which is a homespun
+/// one not based on any widely-known algorithm -- though modified to produce
+/// 64-bit hash values instead of 32-bit hash values. It consistently
+/// out-performs an FNV-based hash within rustc itself -- the collision rate is
+/// similar or slightly worse than FNV, but the speed of the hash function
+/// itself is much higher because it works on up to 8 bytes at a time.
+pub struct FxHasher {
+    hash: usize,
+}
+
+#[cfg(target_pointer_width = "32")]
+const K: usize = 0x9e3779b9;
+#[cfg(target_pointer_width = "64")]
+const K: usize = 0x517cc1b727220a95;
+
+impl Default for FxHasher {
+    #[inline]
+    fn default() -> FxHasher {
+        FxHasher { hash: 0 }
+    }
+}
+
+impl FxHasher {
+    #[inline]
+    fn add_to_hash(&mut self, i: usize) {
+        self.hash = self.hash.rotate_left(5).bitxor(i).wrapping_mul(K);
+    }
+}
+
+impl Hasher for FxHasher {
+    #[inline]
+    fn write(&mut self, mut bytes: &[u8]) {
+        #[cfg(target_pointer_width = "32")]
+        let read_usize = |bytes: &[u8]| u32::from_ne_bytes(bytes[..4].try_into().unwrap());
+        #[cfg(target_pointer_width = "64")]
+        let read_usize = |bytes: &[u8]| u64::from_ne_bytes(bytes[..8].try_into().unwrap());
+
+        let mut hash = FxHasher { hash: self.hash };
+        assert!(size_of::<usize>() <= 8);
+        while bytes.len() >= size_of::<usize>() {
+            hash.add_to_hash(read_usize(bytes) as usize);
+            bytes = &bytes[size_of::<usize>()..];
+        }
+        if (size_of::<usize>() > 4) && (bytes.len() >= 4) {
+            hash.add_to_hash(u32::from_ne_bytes(bytes[..4].try_into().unwrap()) as usize);
+            bytes = &bytes[4..];
+        }
+        if (size_of::<usize>() > 2) && bytes.len() >= 2 {
+            hash.add_to_hash(u16::from_ne_bytes(bytes[..2].try_into().unwrap()) as usize);
+            bytes = &bytes[2..];
+        }
+        if (size_of::<usize>() > 1) && bytes.len() >= 1 {
+            hash.add_to_hash(bytes[0] as usize);
+        }
+        self.hash = hash.hash;
+    }
+
+    #[inline]
+    fn write_u8(&mut self, i: u8) {
+        self.add_to_hash(i as usize);
+    }
+
+    #[inline]
+    fn write_u16(&mut self, i: u16) {
+        self.add_to_hash(i as usize);
+    }
+
+    #[inline]
+    fn write_u32(&mut self, i: u32) {
+        self.add_to_hash(i as usize);
+    }
+
+    #[cfg(target_pointer_width = "32")]
+    #[inline]
+    fn write_u64(&mut self, i: u64) {
+        self.add_to_hash(i as usize);
+        self.add_to_hash((i >> 32) as usize);
+    }
+
+    #[cfg(target_pointer_width = "64")]
+    #[inline]
+    fn write_u64(&mut self, i: u64) {
+        self.add_to_hash(i as usize);
+    }
+
+    #[inline]
+    fn write_usize(&mut self, i: usize) {
+        self.add_to_hash(i);
+    }
+
+    #[inline]
+    fn finish(&self) -> u64 {
+        self.hash as u64
+    }
+}
diff --git a/crates/rustversion/.cargo-checksum.json b/crates/rustversion/.cargo-checksum.json
new file mode 100644
index 0000000..73195db
--- /dev/null
+++ b/crates/rustversion/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"9c8ebdae8c4ca651ae8a15b4438668c74cb8e0bf6cd06b785e540f6117852d2a","LICENSE-APACHE":"62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","README.md":"9ba51325297bd22446d8cc89b60e10aaedc0a248ddaad9f12322e233032ac595","build/build.rs":"a5ac3f88a152167bdf624d18346b6db6459828bdbd1162a275fcde9c36e3ade6","build/rustc.rs":"0de80a0590facf36d76fa89c566789c774f5bfc3b787fe8d5b61f668deaed3f9","src/attr.rs":"9301cd4aff5a9648c057d5d8de9eb66921f0c3a715c51ada4459576bd49c8b19","src/bound.rs":"44bda74d3aacfeeeac9dae2f7eef3acc844d4c3c7eaa9d3e6288e5aeff269dff","src/constfn.rs":"613b8f53b21cc06b4f619fce9000993d3e7873b650701ca01cef1e53bed5b40a","src/date.rs":"454c749a60db8144a706a813e06fe3ae39c981920ba9832ef82f3f9debe1f052","src/error.rs":"cb37102f03ebbaca313d80f9714fe08dfef92fe956789ee87d93eb6121705f4f","src/expand.rs":"cfd1772b1af090532de1f318e1b61cc79c8004941a8c56a1a7f4962324b81c9d","src/expr.rs":"8e8ca76f4f5838436d9d7273f499c698bb41f6c15bc07d32ec5c1cb8bd3dd731","src/iter.rs":"8d4b817b9abc4e817105b673e15f29ef9bb8284a010ce01ac2d83387fe136947","src/lib.rs":"39d1d6b9c7837f15a5028d225d3538d33e6331e880b7844f7e3c1c0a2be0de06","src/release.rs":"abb8ddd877c39a023bf5e7bd67063d6e4144e79758a8bafa338167f9d15b89f1","src/time.rs":"bdd05a743b07a6bbfa0dbc9d4e415e051aba4a51a430c3be1e23447eae298c8b","src/token.rs":"824ce765f692db73afa02d3ebb0281c750748035efc98fa547be29d3072665ce","src/version.rs":"afdb048bba95bbb885945eba5527b6bf0eca0105642bfc304c2f82a8b7d556df","tests/compiletest.rs":"022a8e400ef813d7ea1875b944549cee5125f6a995dc33e93b48cba3e1b57bd1","tests/test_const.rs":"44d72ea92a81544692ccabe7e93f5d560d29828e79835e9f9839fbb40acc499a","tests/test_eval.rs":"6f0ee3f49c9a0d0c374a4d0e9a9dce753cd9fc2ca7725e000a435dbd5f4a9ce3","tests/test_parse.rs":"a9d262ea18109f792da719c29f3434a2f6a5e5723286385a099359795495b6fb","tests/ui/bad-bound.rs":"25bde278fcaabf62868417148a5e5f2006bf589d7ebd7bf6004fb8d78e47594f","tests/ui/bad-bound.stderr":"96b5549a312cd64d503c560026a6f0e97ac2173fe7c136a14425f19dcb5968e3","tests/ui/bad-date.rs":"6e23714dae8b6346fefe50dacd4abba3265248bbadfdd60c739138aa8a0037ba","tests/ui/bad-date.stderr":"3cc6d10572b80d397954737340d444c541d2c0e54e7d26495861d6189b6b2a55","tests/ui/bad-not.rs":"f003df8bd245e9dd8edc3a6d94078ee5162fac7a98db881271f0f5b6db98d45d","tests/ui/bad-not.stderr":"1aebb3121d067d432a32dd95ff380ceac15a0531c34f90cee950582558841c56","tests/ui/bad-version.rs":"f4ea2cd038e6c63deb9c2e3ceffce93dbf179d9ce18c16d88f3b6cd7138a8c8e","tests/ui/bad-version.stderr":"e9421586d59cb9135123bd97710655014f95cc5f55b0f9611e1d2e8ce9e29a5d","tests/ui/const-not-fn.rs":"10bbe38f0d89391fff0698756e4cfd4e72a41090360393a0c951b67df14d1c35","tests/ui/const-not-fn.stderr":"1180662fd3b8c4426d46923918a2e58dd9b6259f1a364469ae13d5fc3d69ce6c"},"package":"7ffc183a10b4478d04cbbbfc96d0873219d962dd5accaff2ffbd4ceb7df837f4"}
\ No newline at end of file
diff --git a/crates/rustversion/Android.bp b/crates/rustversion/Android.bp
new file mode 100644
index 0000000..c4f32a0
--- /dev/null
+++ b/crates/rustversion/Android.bp
@@ -0,0 +1,25 @@
+// This file is generated by cargo_embargo.
+// Do not modify this file because the changes will be overridden on upgrade.
+
+package {
+    default_applicable_licenses: ["external_rust_crates_rustversion_license"],
+    default_team: "trendy_team_android_rust",
+}
+
+license {
+    name: "external_rust_crates_rustversion_license",
+    visibility: [":__subpackages__"],
+    license_kinds: ["SPDX-license-identifier-Apache-2.0"],
+    license_text: ["LICENSE"],
+}
+
+rust_proc_macro {
+    name: "librustversion",
+    crate_name: "rustversion",
+    cargo_env_compat: true,
+    cargo_pkg_version: "1.0.14",
+    crate_root: "src/lib.rs",
+    edition: "2018",
+    product_available: true,
+    vendor_available: true,
+}
diff --git a/crates/rustversion/Cargo.lock b/crates/rustversion/Cargo.lock
new file mode 100644
index 0000000..0b54b79
--- /dev/null
+++ b/crates/rustversion/Cargo.lock
@@ -0,0 +1,287 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+[[package]]
+name = "dissimilar"
+version = "1.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "equivalent"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "glob"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "hashbrown"
+version = "0.14.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "indexmap"
+version = "2.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "equivalent 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "hashbrown 0.14.5 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "memchr"
+version = "2.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.86"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "unicode-ident 1.0.12 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "proc-macro2 1.0.86 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.14"
+dependencies = [
+ "trybuild 1.0.99 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "ryu"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "serde"
+version = "1.0.209"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "serde_derive 1.0.209 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.209"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "proc-macro2 1.0.86 (registry+https://github.com/rust-lang/crates.io-index)",
+ "quote 1.0.37 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 2.0.76 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.127"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "itoa 1.0.11 (registry+https://github.com/rust-lang/crates.io-index)",
+ "memchr 2.7.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ryu 1.0.18 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde 1.0.209 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "serde_spanned"
+version = "0.6.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "serde 1.0.209 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.76"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "proc-macro2 1.0.86 (registry+https://github.com/rust-lang/crates.io-index)",
+ "quote 1.0.37 (registry+https://github.com/rust-lang/crates.io-index)",
+ "unicode-ident 1.0.12 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "termcolor"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "winapi-util 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "toml"
+version = "0.8.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "serde 1.0.209 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde_spanned 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)",
+ "toml_datetime 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
+ "toml_edit 0.22.20 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "0.6.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "serde 1.0.209 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.22.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "indexmap 2.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde 1.0.209 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde_spanned 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)",
+ "toml_datetime 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
+ "winnow 0.6.18 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "trybuild"
+version = "1.0.99"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "dissimilar 1.0.9 (registry+https://github.com/rust-lang/crates.io-index)",
+ "glob 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde 1.0.209 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde_derive 1.0.209 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde_json 1.0.127 (registry+https://github.com/rust-lang/crates.io-index)",
+ "termcolor 1.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "toml 0.8.19 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "windows-sys 0.59.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "windows-targets 0.52.6 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "windows_aarch64_gnullvm 0.52.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "windows_aarch64_msvc 0.52.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "windows_i686_gnu 0.52.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "windows_i686_gnullvm 0.52.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "windows_i686_msvc 0.52.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "windows_x86_64_gnu 0.52.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "windows_x86_64_gnullvm 0.52.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "windows_x86_64_msvc 0.52.6 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "winnow"
+version = "0.6.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "memchr 2.7.4 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[metadata]
+"checksum dissimilar 1.0.9 (registry+https://github.com/rust-lang/crates.io-index)" = "59f8e79d1fbf76bdfbde321e902714bf6c49df88a7dda6fc682fc2979226962d"
+"checksum equivalent 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
+"checksum glob 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"
+"checksum hashbrown 0.14.5 (registry+https://github.com/rust-lang/crates.io-index)" = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
+"checksum indexmap 2.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "93ead53efc7ea8ed3cfb0c79fc8023fbb782a5432b52830b6518941cebe6505c"
+"checksum itoa 1.0.11 (registry+https://github.com/rust-lang/crates.io-index)" = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
+"checksum memchr 2.7.4 (registry+https://github.com/rust-lang/crates.io-index)" = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
+"checksum proc-macro2 1.0.86 (registry+https://github.com/rust-lang/crates.io-index)" = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
+"checksum quote 1.0.37 (registry+https://github.com/rust-lang/crates.io-index)" = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
+"checksum ryu 1.0.18 (registry+https://github.com/rust-lang/crates.io-index)" = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
+"checksum serde 1.0.209 (registry+https://github.com/rust-lang/crates.io-index)" = "99fce0ffe7310761ca6bf9faf5115afbc19688edd00171d81b1bb1b116c63e09"
+"checksum serde_derive 1.0.209 (registry+https://github.com/rust-lang/crates.io-index)" = "a5831b979fd7b5439637af1752d535ff49f4860c0f341d1baeb6faf0f4242170"
+"checksum serde_json 1.0.127 (registry+https://github.com/rust-lang/crates.io-index)" = "8043c06d9f82bd7271361ed64f415fe5e12a77fdb52e573e7f06a516dea329ad"
+"checksum serde_spanned 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)" = "eb5b1b31579f3811bf615c144393417496f152e12ac8b7663bf664f4a815306d"
+"checksum syn 2.0.76 (registry+https://github.com/rust-lang/crates.io-index)" = "578e081a14e0cefc3279b0472138c513f37b41a08d5a3cca9b6e4e8ceb6cd525"
+"checksum termcolor 1.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755"
+"checksum toml 0.8.19 (registry+https://github.com/rust-lang/crates.io-index)" = "a1ed1f98e3fdc28d6d910e6737ae6ab1a93bf1985935a1193e68f93eeb68d24e"
+"checksum toml_datetime 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)" = "0dd7358ecb8fc2f8d014bf86f6f638ce72ba252a2c3a2572f2a795f1d23efb41"
+"checksum toml_edit 0.22.20 (registry+https://github.com/rust-lang/crates.io-index)" = "583c44c02ad26b0c3f3066fe629275e50627026c51ac2e595cca4c230ce1ce1d"
+"checksum trybuild 1.0.99 (registry+https://github.com/rust-lang/crates.io-index)" = "207aa50d36c4be8d8c6ea829478be44a372c6a77669937bb39c698e52f1491e8"
+"checksum unicode-ident 1.0.12 (registry+https://github.com/rust-lang/crates.io-index)" = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
+"checksum winapi-util 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
+"checksum windows-sys 0.59.0 (registry+https://github.com/rust-lang/crates.io-index)" = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+"checksum windows-targets 0.52.6 (registry+https://github.com/rust-lang/crates.io-index)" = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+"checksum windows_aarch64_gnullvm 0.52.6 (registry+https://github.com/rust-lang/crates.io-index)" = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+"checksum windows_aarch64_msvc 0.52.6 (registry+https://github.com/rust-lang/crates.io-index)" = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+"checksum windows_i686_gnu 0.52.6 (registry+https://github.com/rust-lang/crates.io-index)" = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+"checksum windows_i686_gnullvm 0.52.6 (registry+https://github.com/rust-lang/crates.io-index)" = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+"checksum windows_i686_msvc 0.52.6 (registry+https://github.com/rust-lang/crates.io-index)" = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+"checksum windows_x86_64_gnu 0.52.6 (registry+https://github.com/rust-lang/crates.io-index)" = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+"checksum windows_x86_64_gnullvm 0.52.6 (registry+https://github.com/rust-lang/crates.io-index)" = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+"checksum windows_x86_64_msvc 0.52.6 (registry+https://github.com/rust-lang/crates.io-index)" = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+"checksum winnow 0.6.18 (registry+https://github.com/rust-lang/crates.io-index)" = "68a9bda4691f099d435ad181000724da8e5899daa10713c2d432552b9ccd3a6f"
diff --git a/crates/rustversion/Cargo.toml b/crates/rustversion/Cargo.toml
new file mode 100644
index 0000000..6125165
--- /dev/null
+++ b/crates/rustversion/Cargo.toml
@@ -0,0 +1,39 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2018"
+rust-version = "1.31"
+name = "rustversion"
+version = "1.0.14"
+authors = ["David Tolnay <dtolnay@gmail.com>"]
+build = "build/build.rs"
+description = "Conditional compilation according to rustc compiler version"
+documentation = "https://docs.rs/rustversion"
+readme = "README.md"
+categories = [
+    "development-tools::build-utils",
+    "no-std",
+    "no-std::no-alloc",
+]
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/dtolnay/rustversion"
+
+[package.metadata.docs.rs]
+rustdoc-args = ["--generate-link-to-definition"]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[lib]
+proc-macro = true
+
+[dev-dependencies.trybuild]
+version = "1.0.49"
+features = ["diff"]
diff --git a/crates/rustversion/LICENSE b/crates/rustversion/LICENSE
new file mode 120000
index 0000000..6b579aa
--- /dev/null
+++ b/crates/rustversion/LICENSE
@@ -0,0 +1 @@
+LICENSE-APACHE
\ No newline at end of file
diff --git a/crates/rustversion/LICENSE-APACHE b/crates/rustversion/LICENSE-APACHE
new file mode 100644
index 0000000..1b5ec8b
--- /dev/null
+++ b/crates/rustversion/LICENSE-APACHE
@@ -0,0 +1,176 @@
+                              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
diff --git a/crates/rustversion/LICENSE-MIT b/crates/rustversion/LICENSE-MIT
new file mode 100644
index 0000000..31aa793
--- /dev/null
+++ b/crates/rustversion/LICENSE-MIT
@@ -0,0 +1,23 @@
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/crates/rustversion/METADATA b/crates/rustversion/METADATA
new file mode 100644
index 0000000..9d4120c
--- /dev/null
+++ b/crates/rustversion/METADATA
@@ -0,0 +1,20 @@
+# This project was upgraded with external_updater.
+# Usage: tools/external_updater/updater.sh update external/rust/crates/rustversion
+# For more info, check https://cs.android.com/android/platform/superproject/+/main:tools/external_updater/README.md
+
+name: "rustversion"
+description: "Conditional compilation according to rustc compiler version"
+third_party {
+  license_type: NOTICE
+  last_upgrade_date {
+    year: 2024
+    month: 2
+    day: 7
+  }
+  homepage: "https://crates.io/crates/rustversion"
+  identifier {
+    type: "Archive"
+    value: "https://static.crates.io/crates/rustversion/rustversion-1.0.14.crate"
+    version: "1.0.14"
+  }
+}
diff --git a/crates/rustversion/MODULE_LICENSE_APACHE2 b/crates/rustversion/MODULE_LICENSE_APACHE2
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/crates/rustversion/MODULE_LICENSE_APACHE2
diff --git a/crates/rustversion/README.md b/crates/rustversion/README.md
new file mode 100644
index 0000000..2c4be07
--- /dev/null
+++ b/crates/rustversion/README.md
@@ -0,0 +1,139 @@
+Compiler version cfg
+====================
+
+[<img alt="github" src="https://img.shields.io/badge/github-dtolnay/rustversion-8da0cb?style=for-the-badge&labelColor=555555&logo=github" height="20">](https://github.com/dtolnay/rustversion)
+[<img alt="crates.io" src="https://img.shields.io/crates/v/rustversion.svg?style=for-the-badge&color=fc8d62&logo=rust" height="20">](https://crates.io/crates/rustversion)
+[<img alt="docs.rs" src="https://img.shields.io/badge/docs.rs-rustversion-66c2a5?style=for-the-badge&labelColor=555555&logo=docs.rs" height="20">](https://docs.rs/rustversion)
+[<img alt="build status" src="https://img.shields.io/github/actions/workflow/status/dtolnay/rustversion/ci.yml?branch=master&style=for-the-badge" height="20">](https://github.com/dtolnay/rustversion/actions?query=branch%3Amaster)
+
+This crate provides macros for conditional compilation according to rustc
+compiler version, analogous to [`#[cfg(...)]`][cfg] and
+[`#[cfg_attr(...)]`][cfg_attr].
+
+[cfg]: https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg-attribute
+[cfg_attr]: https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg_attr-attribute
+
+```toml
+[dependencies]
+rustversion = "1.0"
+```
+
+<br>
+
+## Selectors
+
+- <b>`#[rustversion::stable]`</b>
+  —<br>
+  True on any stable compiler.
+
+- <b>`#[rustversion::stable(1.34)]`</b>
+  —<br>
+  True on exactly the specified stable compiler.
+
+- <b>`#[rustversion::beta]`</b>
+  —<br>
+  True on any beta compiler.
+
+- <b>`#[rustversion::nightly]`</b>
+  —<br>
+  True on any nightly compiler or dev build.
+
+- <b>`#[rustversion::nightly(2019-01-01)]`</b>
+  —<br>
+  True on exactly one nightly.
+
+- <b>`#[rustversion::since(1.34)]`</b>
+  —<br>
+  True on that stable release and any later compiler, including beta and
+  nightly.
+
+- <b>`#[rustversion::since(2019-01-01)]`</b>
+  —<br>
+  True on that nightly and all newer ones.
+
+- <b>`#[rustversion::before(`</b><i>version or date</i><b>`)]`</b>
+  —<br>
+  Negative of *#[rustversion::since(...)]*.
+
+- <b>`#[rustversion::not(`</b><i>selector</i><b>`)]`</b>
+  —<br>
+  Negative of any selector; for example *#[rustversion::not(nightly)]*.
+
+- <b>`#[rustversion::any(`</b><i>selectors...</i><b>`)]`</b>
+  —<br>
+  True if any of the comma-separated selectors is true; for example
+  *#[rustversion::any(stable, beta)]*.
+
+- <b>`#[rustversion::all(`</b><i>selectors...</i><b>`)]`</b>
+  —<br>
+  True if all of the comma-separated selectors are true; for example
+  *#[rustversion::all(since(1.31), before(1.34))]*.
+
+- <b>`#[rustversion::attr(`</b><i>selector</i><b>`, `</b><i>attribute</i><b>`)]`</b>
+  —<br>
+  For conditional inclusion of attributes; analogous to `cfg_attr`.
+
+<br>
+
+## Use cases
+
+Providing additional trait impls as types are stabilized in the standard library
+without breaking compatibility with older compilers; in this case Pin\<P\>
+stabilized in [Rust 1.33][pin]:
+
+[pin]: https://blog.rust-lang.org/2019/02/28/Rust-1.33.0.html#pinning
+
+```rust
+#[rustversion::since(1.33)]
+use std::pin::Pin;
+
+#[rustversion::since(1.33)]
+impl<P: MyTrait> MyTrait for Pin<P> {
+    /* ... */
+}
+```
+
+Similar but for language features; the ability to control alignment greater than
+1 of packed structs was stabilized in [Rust 1.33][packed].
+
+[packed]: https://github.com/rust-lang/rust/blob/master/RELEASES.md#version-1330-2019-02-28
+
+```rust
+#[rustversion::attr(before(1.33), repr(packed))]
+#[rustversion::attr(since(1.33), repr(packed(2)))]
+struct Six(i16, i32);
+
+fn main() {
+    println!("{}", std::mem::align_of::<Six>());
+}
+```
+
+Augmenting code with `const` as const impls are stabilized in the standard
+library. This use of `const` as an attribute is recognized as a special case by
+the rustversion::attr macro.
+
+```rust
+use std::time::Duration;
+
+#[rustversion::attr(since(1.32), const)]
+fn duration_as_days(dur: Duration) -> u64 {
+    dur.as_secs() / 60 / 60 / 24
+}
+```
+
+<br>
+
+#### License
+
+<sup>
+Licensed under either of <a href="LICENSE-APACHE">Apache License, Version
+2.0</a> or <a href="LICENSE-MIT">MIT license</a> at your option.
+</sup>
+
+<br>
+
+<sub>
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in this crate by you, as defined in the Apache-2.0 license, shall
+be dual licensed as above, without any additional terms or conditions.
+</sub>
diff --git a/crates/rustversion/TEST_MAPPING b/crates/rustversion/TEST_MAPPING
new file mode 100644
index 0000000..ed43c73
--- /dev/null
+++ b/crates/rustversion/TEST_MAPPING
@@ -0,0 +1,20 @@
+// Generated by update_crate_tests.py for tests that depend on this crate.
+{
+  "imports": [
+    {
+      "path": "external/rust/crates/async-stream"
+    },
+    {
+      "path": "external/rust/crates/bitflags"
+    },
+    {
+      "path": "external/rust/crates/crossbeam-epoch"
+    },
+    {
+      "path": "external/rust/crates/crossbeam-utils"
+    },
+    {
+      "path": "external/rust/crates/slab"
+    }
+  ]
+}
diff --git a/crates/rustversion/build/build.rs b/crates/rustversion/build/build.rs
new file mode 100644
index 0000000..0a45f4c
--- /dev/null
+++ b/crates/rustversion/build/build.rs
@@ -0,0 +1,75 @@
+#![allow(
+    clippy::enum_glob_use,
+    clippy::must_use_candidate,
+    clippy::single_match_else
+)]
+
+mod rustc;
+
+use std::env;
+use std::ffi::OsString;
+use std::fs;
+use std::path::Path;
+use std::process::{self, Command};
+
+fn main() {
+    println!("cargo:rerun-if-changed=build/build.rs");
+
+    let rustc = env::var_os("RUSTC").unwrap_or_else(|| OsString::from("rustc"));
+
+    let mut is_clippy_driver = false;
+    let version = loop {
+        let mut command = Command::new(&rustc);
+        if is_clippy_driver {
+            command.arg("--rustc");
+        }
+        command.arg("--version");
+
+        let output = match command.output() {
+            Ok(output) => output,
+            Err(e) => {
+                let rustc = rustc.to_string_lossy();
+                eprintln!("Error: failed to run `{} --version`: {}", rustc, e);
+                process::exit(1);
+            }
+        };
+
+        let string = match String::from_utf8(output.stdout) {
+            Ok(string) => string,
+            Err(e) => {
+                let rustc = rustc.to_string_lossy();
+                eprintln!(
+                    "Error: failed to parse output of `{} --version`: {}",
+                    rustc, e,
+                );
+                process::exit(1);
+            }
+        };
+
+        break match rustc::parse(&string) {
+            rustc::ParseResult::Success(version) => version,
+            rustc::ParseResult::OopsClippy if !is_clippy_driver => {
+                is_clippy_driver = true;
+                continue;
+            }
+            rustc::ParseResult::Unrecognized | rustc::ParseResult::OopsClippy => {
+                eprintln!(
+                    "Error: unexpected output from `rustc --version`: {:?}\n\n\
+                    Please file an issue in https://github.com/dtolnay/rustversion",
+                    string
+                );
+                process::exit(1);
+            }
+        };
+    };
+
+    if version.minor < 38 {
+        // Prior to 1.38, a #[proc_macro] is not allowed to be named `cfg`.
+        println!("cargo:rustc-cfg=cfg_macro_not_allowed");
+    }
+
+    let version = format!("{:#?}\n", version);
+    let out_dir = env::var_os("OUT_DIR").expect("OUT_DIR not set");
+    let out_file = Path::new(&out_dir).join("version.expr");
+    fs::write(out_file, version).expect("failed to write version.expr");
+}
diff --git a/crates/rustversion/build/rustc.rs b/crates/rustversion/build/rustc.rs
new file mode 100644
index 0000000..71a830b
--- /dev/null
+++ b/crates/rustversion/build/rustc.rs
@@ -0,0 +1,124 @@
+use self::Channel::*;
+use std::fmt::{self, Debug};
+
+pub enum ParseResult {
+    Success(Version),
+    OopsClippy,
+    Unrecognized,
+}
+
+#[cfg_attr(test, derive(PartialEq))]
+pub struct Version {
+    pub minor: u16,
+    pub patch: u16,
+    pub channel: Channel,
+}
+
+#[cfg_attr(test, derive(PartialEq))]
+pub enum Channel {
+    Stable,
+    Beta,
+    Nightly(Date),
+    Dev,
+}
+
+#[cfg_attr(test, derive(PartialEq))]
+pub struct Date {
+    pub year: u16,
+    pub month: u8,
+    pub day: u8,
+}
+
+pub fn parse(string: &str) -> ParseResult {
+    let last_line = string.lines().last().unwrap_or(string);
+    let mut words = last_line.trim().split(' ');
+
+    match words.next() {
+        Some("rustc") => {}
+        Some(word) if word.starts_with("clippy") => return ParseResult::OopsClippy,
+        Some(_) | None => return ParseResult::Unrecognized,
+    }
+
+    parse_words(&mut words).map_or(ParseResult::Unrecognized, ParseResult::Success)
+}
+
+fn parse_words(words: &mut dyn Iterator<Item = &str>) -> Option<Version> {
+    let mut version_channel = words.next()?.split('-');
+    let version = version_channel.next()?;
+    let channel = version_channel.next();
+
+    let mut digits = version.split('.');
+    let major = digits.next()?;
+    if major != "1" {
+        return None;
+    }
+    let minor = digits.next()?.parse().ok()?;
+    let patch = digits.next().unwrap_or("0").parse().ok()?;
+
+    let channel = match channel {
+        None => Stable,
+        Some(channel) if channel == "dev" => Dev,
+        Some(channel) if channel.starts_with("beta") => Beta,
+        Some(channel) if channel == "nightly" => match words.next() {
+            Some(hash) if hash.starts_with('(') => match words.next() {
+                None if hash.ends_with(')') => Dev,
+                Some(date) if date.ends_with(')') => {
+                    let mut date = date[..date.len() - 1].split('-');
+                    let year = date.next()?.parse().ok()?;
+                    let month = date.next()?.parse().ok()?;
+                    let day = date.next()?.parse().ok()?;
+                    match date.next() {
+                        None => Nightly(Date { year, month, day }),
+                        Some(_) => return None,
+                    }
+                }
+                None | Some(_) => return None,
+            },
+            Some(_) => return None,
+            None => Dev,
+        },
+        Some(_) => return None,
+    };
+
+    Some(Version {
+        minor,
+        patch,
+        channel,
+    })
+}
+
+impl Debug for Version {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter
+            .debug_struct("crate::version::Version")
+            .field("minor", &self.minor)
+            .field("patch", &self.patch)
+            .field("channel", &self.channel)
+            .finish()
+    }
+}
+
+impl Debug for Channel {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Channel::Stable => formatter.write_str("crate::version::Channel::Stable"),
+            Channel::Beta => formatter.write_str("crate::version::Channel::Beta"),
+            Channel::Nightly(date) => formatter
+                .debug_tuple("crate::version::Channel::Nightly")
+                .field(date)
+                .finish(),
+            Channel::Dev => formatter.write_str("crate::version::Channel::Dev"),
+        }
+    }
+}
+
+impl Debug for Date {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter
+            .debug_struct("crate::date::Date")
+            .field("year", &self.year)
+            .field("month", &self.month)
+            .field("day", &self.day)
+            .finish()
+    }
+}
diff --git a/crates/rustversion/cargo_embargo.json b/crates/rustversion/cargo_embargo.json
new file mode 100644
index 0000000..cb908d7
--- /dev/null
+++ b/crates/rustversion/cargo_embargo.json
@@ -0,0 +1,3 @@
+{
+  "run_cargo": false
+}
diff --git a/crates/rustversion/patches/version.diff b/crates/rustversion/patches/version.diff
new file mode 100644
index 0000000..3eb570b
--- /dev/null
+++ b/crates/rustversion/patches/version.diff
@@ -0,0 +1,53 @@
+diff --git a/src/lib.rs b/src/lib.rs
+index 2e8f1b9..e826b25 100644
+--- a/src/lib.rs
++++ b/src/lib.rs
+@@ -182,7 +182,16 @@ use crate::error::Error;
+ use crate::version::Version;
+ use proc_macro::TokenStream;
+ 
+-const RUSTVERSION: Version = include!(concat!(env!("OUT_DIR"), "/version.expr"));
++// ANDROID: Soong is providing the version of rustc via an env variable.
++const ANDROID_RUSTVERSION: Option<&str> = option_env!("ANDROID_RUST_VERSION");
++fn rust_version() -> Version {
++    let v: Vec<&str> = ANDROID_RUSTVERSION.unwrap().split('.').collect();
++    Version {
++        minor: v[1].parse().unwrap(),
++        patch: v[2].parse().unwrap(),
++        channel: version::Channel::Stable,
++    }
++}
+ 
+ #[proc_macro_attribute]
+ pub fn stable(args: TokenStream, input: TokenStream) -> TokenStream {
+@@ -239,7 +248,7 @@ pub fn cfg(input: TokenStream) -> TokenStream {
+         let ref mut args = iter::new(input);
+         let expr = expr::parse(args)?;
+         token::parse_end(args)?;
+-        let boolean = expr.eval(RUSTVERSION);
++        let boolean = expr.eval(rust_version());
+         let ident = Ident::new(&boolean.to_string(), Span::call_site());
+         Ok(TokenStream::from(TokenTree::Ident(ident)))
+     })()
+diff --git a/src/expand.rs b/src/expand.rs
+index 813ba85..3d4e314 100644
+--- a/src/expand.rs
++++ b/src/expand.rs
+@@ -23,7 +23,7 @@ fn try_cfg(introducer: &str, args: TokenStream, input: TokenStream) -> Result<To
+     let expr = expr::parse(full_args)?;
+     token::parse_end(full_args)?;
+ 
+-    if expr.eval(crate::RUSTVERSION) {
++    if expr.eval(crate::rust_version()) {
+         Ok(input)
+     } else {
+         Ok(TokenStream::new())
+@@ -31,7 +31,7 @@ fn try_cfg(introducer: &str, args: TokenStream, input: TokenStream) -> Result<To
+ }
+ 
+ pub fn try_attr(args: attr::Args, input: TokenStream) -> Result<TokenStream> {
+-    if !args.condition.eval(crate::RUSTVERSION) {
++    if !args.condition.eval(crate::rust_version()) {
+         return Ok(input);
+     }
+ 
diff --git a/crates/rustversion/src/attr.rs b/crates/rustversion/src/attr.rs
new file mode 100644
index 0000000..6023d1e
--- /dev/null
+++ b/crates/rustversion/src/attr.rs
@@ -0,0 +1,35 @@
+use crate::error::{Error, Result};
+use crate::expr::{self, Expr};
+use crate::{iter, token};
+use proc_macro::{Span, TokenStream};
+
+pub struct Args {
+    pub condition: Expr,
+    pub then: Then,
+}
+
+pub enum Then {
+    Const(Span),
+    Attribute(TokenStream),
+}
+
+pub fn parse(input: TokenStream) -> Result<Args> {
+    let ref mut input = iter::new(input);
+    let condition = expr::parse(input)?;
+
+    token::parse_punct(input, ',')?;
+    if input.peek().is_none() {
+        return Err(Error::new(Span::call_site(), "expected one or more attrs"));
+    }
+
+    let const_span = token::parse_optional_keyword(input, "const");
+    let then = if let Some(const_span) = const_span {
+        token::parse_optional_punct(input, ',');
+        token::parse_end(input)?;
+        Then::Const(const_span)
+    } else {
+        Then::Attribute(input.collect())
+    };
+
+    Ok(Args { condition, then })
+}
diff --git a/crates/rustversion/src/bound.rs b/crates/rustversion/src/bound.rs
new file mode 100644
index 0000000..a667a5b
--- /dev/null
+++ b/crates/rustversion/src/bound.rs
@@ -0,0 +1,63 @@
+use crate::date::{self, Date};
+use crate::error::{Error, Result};
+use crate::iter::Iter;
+use crate::release::{self, Release};
+use crate::time;
+use crate::version::{Channel::*, Version};
+use proc_macro::{Group, TokenTree};
+use std::cmp::Ordering;
+
+pub enum Bound {
+    Nightly(Date),
+    Stable(Release),
+}
+
+pub fn parse(paren: Group, iter: Iter) -> Result<Bound> {
+    if let Some(TokenTree::Literal(literal)) = iter.peek() {
+        let repr = literal.to_string();
+        if repr.starts_with(|ch: char| ch.is_ascii_digit()) {
+            if repr.contains('.') {
+                return release::parse(paren, iter).map(Bound::Stable);
+            } else {
+                return date::parse(paren, iter).map(Bound::Nightly);
+            }
+        }
+    }
+    let msg = format!(
+        "expected rustc release number like 1.31, or nightly date like {}",
+        time::today(),
+    );
+    Err(Error::group(paren, msg))
+}
+
+impl PartialEq<Bound> for Version {
+    fn eq(&self, rhs: &Bound) -> bool {
+        match rhs {
+            Bound::Nightly(date) => match self.channel {
+                Stable | Beta | Dev => false,
+                Nightly(nightly) => nightly == *date,
+            },
+            Bound::Stable(release) => {
+                self.minor == release.minor
+                    && release.patch.map_or(true, |patch| self.patch == patch)
+            }
+        }
+    }
+}
+
+impl PartialOrd<Bound> for Version {
+    fn partial_cmp(&self, rhs: &Bound) -> Option<Ordering> {
+        match rhs {
+            Bound::Nightly(date) => match self.channel {
+                Stable | Beta => Some(Ordering::Less),
+                Nightly(nightly) => Some(nightly.cmp(date)),
+                Dev => Some(Ordering::Greater),
+            },
+            Bound::Stable(release) => {
+                let version = (self.minor, self.patch);
+                let bound = (release.minor, release.patch.unwrap_or(0));
+                Some(version.cmp(&bound))
+            }
+        }
+    }
+}
diff --git a/crates/rustversion/src/constfn.rs b/crates/rustversion/src/constfn.rs
new file mode 100644
index 0000000..0e50c03
--- /dev/null
+++ b/crates/rustversion/src/constfn.rs
@@ -0,0 +1,58 @@
+use crate::error::{Error, Result};
+use proc_macro::{Ident, Span, TokenStream, TokenTree};
+use std::iter;
+
+#[derive(PartialOrd, PartialEq)]
+enum Qualifiers {
+    None,
+    Async,
+    Unsafe,
+    Extern,
+    Abi,
+}
+
+impl Qualifiers {
+    fn from_ident(ident: &Ident) -> Self {
+        match ident.to_string().as_str() {
+            "async" => Qualifiers::Async,
+            "unsafe" => Qualifiers::Unsafe,
+            "extern" => Qualifiers::Extern,
+            _ => Qualifiers::None,
+        }
+    }
+}
+
+pub(crate) fn insert_const(input: TokenStream, const_span: Span) -> Result<TokenStream> {
+    let ref mut input = crate::iter::new(input);
+    let mut out = TokenStream::new();
+    let mut qualifiers = Qualifiers::None;
+    let mut pending = Vec::new();
+
+    while let Some(token) = input.next() {
+        match token {
+            TokenTree::Ident(ref ident) if ident.to_string() == "fn" => {
+                let const_ident = Ident::new("const", const_span);
+                out.extend(iter::once(TokenTree::Ident(const_ident)));
+                out.extend(pending);
+                out.extend(iter::once(token));
+                out.extend(input);
+                return Ok(out);
+            }
+            TokenTree::Ident(ref ident) if Qualifiers::from_ident(ident) > qualifiers => {
+                qualifiers = Qualifiers::from_ident(ident);
+                pending.push(token);
+            }
+            TokenTree::Literal(_) if qualifiers == Qualifiers::Extern => {
+                qualifiers = Qualifiers::Abi;
+                pending.push(token);
+            }
+            _ => {
+                qualifiers = Qualifiers::None;
+                out.extend(pending.drain(..));
+                out.extend(iter::once(token));
+            }
+        }
+    }
+
+    Err(Error::new(const_span, "only allowed on a fn item"))
+}
diff --git a/crates/rustversion/src/date.rs b/crates/rustversion/src/date.rs
new file mode 100644
index 0000000..5cdb691
--- /dev/null
+++ b/crates/rustversion/src/date.rs
@@ -0,0 +1,50 @@
+use crate::error::{Error, Result};
+use crate::iter::Iter;
+use crate::{time, token};
+use proc_macro::Group;
+use std::fmt::{self, Display};
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Date {
+    pub year: u16,
+    pub month: u8,
+    pub day: u8,
+}
+
+impl Display for Date {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            formatter,
+            "{:04}-{:02}-{:02}",
+            self.year, self.month, self.day,
+        )
+    }
+}
+
+pub fn parse(paren: Group, iter: Iter) -> Result<Date> {
+    try_parse(iter).map_err(|_| {
+        let msg = format!("expected nightly date, like {}", time::today());
+        Error::group(paren, msg)
+    })
+}
+
+fn try_parse(iter: Iter) -> Result<Date, ()> {
+    let year = token::parse_literal(iter).map_err(drop)?;
+    token::parse_punct(iter, '-').map_err(drop)?;
+    let month = token::parse_literal(iter).map_err(drop)?;
+    token::parse_punct(iter, '-').map_err(drop)?;
+    let day = token::parse_literal(iter).map_err(drop)?;
+
+    let year = year.to_string().parse::<u64>().map_err(drop)?;
+    let month = month.to_string().parse::<u64>().map_err(drop)?;
+    let day = day.to_string().parse::<u64>().map_err(drop)?;
+    if year >= 3000 || month > 12 || day > 31 {
+        return Err(());
+    }
+
+    Ok(Date {
+        year: year as u16,
+        month: month as u8,
+        day: day as u8,
+    })
+}
diff --git a/crates/rustversion/src/error.rs b/crates/rustversion/src/error.rs
new file mode 100644
index 0000000..a99625b
--- /dev/null
+++ b/crates/rustversion/src/error.rs
@@ -0,0 +1,56 @@
+use proc_macro::{Delimiter, Group, Ident, Literal, Punct, Spacing, Span, TokenStream, TokenTree};
+use std::fmt::Display;
+use std::iter::FromIterator;
+
+pub type Result<T, E = Error> = std::result::Result<T, E>;
+
+pub struct Error {
+    begin: Span,
+    end: Span,
+    msg: String,
+}
+
+impl Error {
+    pub fn new(span: Span, msg: impl Display) -> Self {
+        Self::new2(span, span, msg)
+    }
+
+    pub fn new2(begin: Span, end: Span, msg: impl Display) -> Self {
+        Error {
+            begin,
+            end,
+            msg: msg.to_string(),
+        }
+    }
+
+    pub fn group(group: Group, msg: impl Display) -> Self {
+        let mut iter = group.stream().into_iter();
+        let delimiter = group.span();
+        let begin = iter.next().map_or(delimiter, |t| t.span());
+        let end = iter.last().map_or(begin, |t| t.span());
+        Self::new2(begin, end, msg)
+    }
+
+    pub fn into_compile_error(self) -> TokenStream {
+        // compile_error! { $msg }
+        TokenStream::from_iter(vec![
+            TokenTree::Ident(Ident::new("compile_error", self.begin)),
+            TokenTree::Punct({
+                let mut punct = Punct::new('!', Spacing::Alone);
+                punct.set_span(self.begin);
+                punct
+            }),
+            TokenTree::Group({
+                let mut group = Group::new(Delimiter::Brace, {
+                    TokenStream::from_iter(vec![TokenTree::Literal({
+                        let mut string = Literal::string(&self.msg);
+                        string.set_span(self.end);
+                        string
+                    })])
+                });
+                group.set_span(self.end);
+                group
+            }),
+        ])
+    }
+}
diff --git a/crates/rustversion/src/expand.rs b/crates/rustversion/src/expand.rs
new file mode 100644
index 0000000..3d4e314
--- /dev/null
+++ b/crates/rustversion/src/expand.rs
@@ -0,0 +1,72 @@
+use crate::attr::{self, Then};
+use crate::error::{Error, Result};
+use crate::{constfn, expr, iter, token};
+use proc_macro::{Delimiter, Group, Ident, Punct, Spacing, Span, TokenStream, TokenTree};
+use std::iter::FromIterator;
+
+pub fn cfg(introducer: &str, args: TokenStream, input: TokenStream) -> TokenStream {
+    try_cfg(introducer, args, input).unwrap_or_else(Error::into_compile_error)
+}
+
+fn try_cfg(introducer: &str, args: TokenStream, input: TokenStream) -> Result<TokenStream> {
+    let introducer = Ident::new(introducer, Span::call_site());
+
+    let mut full_args = TokenStream::from(TokenTree::Ident(introducer));
+    if !args.is_empty() {
+        full_args.extend(std::iter::once(TokenTree::Group(Group::new(
+            Delimiter::Parenthesis,
+            args,
+        ))));
+    }
+
+    let ref mut full_args = iter::new(full_args);
+    let expr = expr::parse(full_args)?;
+    token::parse_end(full_args)?;
+
+    if expr.eval(crate::rust_version()) {
+        Ok(input)
+    } else {
+        Ok(TokenStream::new())
+    }
+}
+
+pub fn try_attr(args: attr::Args, input: TokenStream) -> Result<TokenStream> {
+    if !args.condition.eval(crate::rust_version()) {
+        return Ok(input);
+    }
+
+    match args.then {
+        Then::Const(const_token) => constfn::insert_const(input, const_token),
+        Then::Attribute(then) => {
+            // #[cfg_attr(all(), #then)]
+            Ok(TokenStream::from_iter(
+                vec![
+                    TokenTree::Punct(Punct::new('#', Spacing::Alone)),
+                    TokenTree::Group(Group::new(
+                        Delimiter::Bracket,
+                        TokenStream::from_iter(vec![
+                            TokenTree::Ident(Ident::new("cfg_attr", Span::call_site())),
+                            TokenTree::Group(Group::new(
+                                Delimiter::Parenthesis,
+                                TokenStream::from_iter(
+                                    vec![
+                                        TokenTree::Ident(Ident::new("all", Span::call_site())),
+                                        TokenTree::Group(Group::new(
+                                            Delimiter::Parenthesis,
+                                            TokenStream::new(),
+                                        )),
+                                        TokenTree::Punct(Punct::new(',', Spacing::Alone)),
+                                    ]
+                                    .into_iter()
+                                    .chain(then),
+                                ),
+                            )),
+                        ]),
+                    )),
+                ]
+                .into_iter()
+                .chain(input),
+            ))
+        }
+    }
+}
diff --git a/crates/rustversion/src/expr.rs b/crates/rustversion/src/expr.rs
new file mode 100644
index 0000000..45ed7d2
--- /dev/null
+++ b/crates/rustversion/src/expr.rs
@@ -0,0 +1,163 @@
+use crate::bound::{self, Bound};
+use crate::date::{self, Date};
+use crate::error::{Error, Result};
+use crate::iter::{self, Iter};
+use crate::release::{self, Release};
+use crate::token;
+use crate::version::{Channel, Version};
+use proc_macro::{Ident, Span, TokenTree};
+
+pub enum Expr {
+    Stable,
+    Beta,
+    Nightly,
+    Date(Date),
+    Since(Bound),
+    Before(Bound),
+    Release(Release),
+    Not(Box<Expr>),
+    Any(Vec<Expr>),
+    All(Vec<Expr>),
+}
+
+impl Expr {
+    pub fn eval(&self, rustc: Version) -> bool {
+        use self::Expr::*;
+
+        match self {
+            Stable => rustc.channel == Channel::Stable,
+            Beta => rustc.channel == Channel::Beta,
+            Nightly => match rustc.channel {
+                Channel::Nightly(_) | Channel::Dev => true,
+                Channel::Stable | Channel::Beta => false,
+            },
+            Date(date) => match rustc.channel {
+                Channel::Nightly(rustc) => rustc == *date,
+                Channel::Stable | Channel::Beta | Channel::Dev => false,
+            },
+            Since(bound) => rustc >= *bound,
+            Before(bound) => rustc < *bound,
+            Release(release) => {
+                rustc.channel == Channel::Stable
+                    && rustc.minor == release.minor
+                    && release.patch.map_or(true, |patch| rustc.patch == patch)
+            }
+            Not(expr) => !expr.eval(rustc),
+            Any(exprs) => exprs.iter().any(|e| e.eval(rustc)),
+            All(exprs) => exprs.iter().all(|e| e.eval(rustc)),
+        }
+    }
+}
+
+pub fn parse(iter: Iter) -> Result<Expr> {
+    match &iter.next() {
+        Some(TokenTree::Ident(i)) if i.to_string() == "stable" => parse_stable(iter),
+        Some(TokenTree::Ident(i)) if i.to_string() == "beta" => Ok(Expr::Beta),
+        Some(TokenTree::Ident(i)) if i.to_string() == "nightly" => parse_nightly(iter),
+        Some(TokenTree::Ident(i)) if i.to_string() == "since" => parse_since(i, iter),
+        Some(TokenTree::Ident(i)) if i.to_string() == "before" => parse_before(i, iter),
+        Some(TokenTree::Ident(i)) if i.to_string() == "not" => parse_not(i, iter),
+        Some(TokenTree::Ident(i)) if i.to_string() == "any" => parse_any(i, iter),
+        Some(TokenTree::Ident(i)) if i.to_string() == "all" => parse_all(i, iter),
+        unexpected => {
+            let span = unexpected
+                .as_ref()
+                .map_or_else(Span::call_site, TokenTree::span);
+            Err(Error::new(span, "expected one of `stable`, `beta`, `nightly`, `since`, `before`, `not`, `any`, `all`"))
+        }
+    }
+}
+
+fn parse_nightly(iter: Iter) -> Result<Expr> {
+    let paren = match token::parse_optional_paren(iter) {
+        Some(group) => group,
+        None => return Ok(Expr::Nightly),
+    };
+
+    let ref mut inner = iter::new(paren.stream());
+    let date = date::parse(paren, inner)?;
+    token::parse_optional_punct(inner, ',');
+    token::parse_end(inner)?;
+
+    Ok(Expr::Date(date))
+}
+
+fn parse_stable(iter: Iter) -> Result<Expr> {
+    let paren = match token::parse_optional_paren(iter) {
+        Some(group) => group,
+        None => return Ok(Expr::Stable),
+    };
+
+    let ref mut inner = iter::new(paren.stream());
+    let release = release::parse(paren, inner)?;
+    token::parse_optional_punct(inner, ',');
+    token::parse_end(inner)?;
+
+    Ok(Expr::Release(release))
+}
+
+fn parse_since(introducer: &Ident, iter: Iter) -> Result<Expr> {
+    let paren = token::parse_paren(introducer, iter)?;
+
+    let ref mut inner = iter::new(paren.stream());
+    let bound = bound::parse(paren, inner)?;
+    token::parse_optional_punct(inner, ',');
+    token::parse_end(inner)?;
+
+    Ok(Expr::Since(bound))
+}
+
+fn parse_before(introducer: &Ident, iter: Iter) -> Result<Expr> {
+    let paren = token::parse_paren(introducer, iter)?;
+
+    let ref mut inner = iter::new(paren.stream());
+    let bound = bound::parse(paren, inner)?;
+    token::parse_optional_punct(inner, ',');
+    token::parse_end(inner)?;
+
+    Ok(Expr::Before(bound))
+}
+
+fn parse_not(introducer: &Ident, iter: Iter) -> Result<Expr> {
+    let paren = token::parse_paren(introducer, iter)?;
+
+    let ref mut inner = iter::new(paren.stream());
+    let expr = self::parse(inner)?;
+    token::parse_optional_punct(inner, ',');
+    token::parse_end(inner)?;
+
+    Ok(Expr::Not(Box::new(expr)))
+}
+
+fn parse_any(introducer: &Ident, iter: Iter) -> Result<Expr> {
+    let paren = token::parse_paren(introducer, iter)?;
+
+    let ref mut inner = iter::new(paren.stream());
+    let exprs = parse_comma_separated(inner)?;
+
+    Ok(Expr::Any(exprs.into_iter().collect()))
+}
+
+fn parse_all(introducer: &Ident, iter: Iter) -> Result<Expr> {
+    let paren = token::parse_paren(introducer, iter)?;
+
+    let ref mut inner = iter::new(paren.stream());
+    let exprs = parse_comma_separated(inner)?;
+
+    Ok(Expr::All(exprs.into_iter().collect()))
+}
+
+fn parse_comma_separated(iter: Iter) -> Result<Vec<Expr>> {
+    let mut exprs = Vec::new();
+
+    while iter.peek().is_some() {
+        let expr = self::parse(iter)?;
+        exprs.push(expr);
+        if iter.peek().is_none() {
+            break;
+        }
+        token::parse_punct(iter, ',')?;
+    }
+
+    Ok(exprs)
+}
diff --git a/crates/rustversion/src/iter.rs b/crates/rustversion/src/iter.rs
new file mode 100644
index 0000000..722013c
--- /dev/null
+++ b/crates/rustversion/src/iter.rs
@@ -0,0 +1,42 @@
+use proc_macro::{token_stream, Delimiter, TokenStream, TokenTree};
+
+pub type Iter<'a> = &'a mut IterImpl;
+
+pub struct IterImpl {
+    stack: Vec<token_stream::IntoIter>,
+    peeked: Option<TokenTree>,
+}
+
+pub fn new(tokens: TokenStream) -> IterImpl {
+    IterImpl {
+        stack: vec![tokens.into_iter()],
+        peeked: None,
+    }
+}
+
+impl IterImpl {
+    pub fn peek(&mut self) -> Option<&TokenTree> {
+        self.peeked = self.next();
+        self.peeked.as_ref()
+    }
+}
+
+impl Iterator for IterImpl {
+    type Item = TokenTree;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if let Some(tt) = self.peeked.take() {
+            return Some(tt);
+        }
+        loop {
+            let top = self.stack.last_mut()?;
+            match top.next() {
+                None => drop(self.stack.pop()),
+                Some(TokenTree::Group(ref group)) if group.delimiter() == Delimiter::None => {
+                    self.stack.push(group.stream().into_iter());
+                }
+                Some(tt) => return Some(tt),
+            }
+        }
+    }
+}
diff --git a/crates/rustversion/src/lib.rs b/crates/rustversion/src/lib.rs
new file mode 100644
index 0000000..1bf0f1d
--- /dev/null
+++ b/crates/rustversion/src/lib.rs
@@ -0,0 +1,257 @@
+//! [![github]](https://github.com/dtolnay/rustversion)&ensp;[![crates-io]](https://crates.io/crates/rustversion)&ensp;[![docs-rs]](https://docs.rs/rustversion)
+//!
+//! [github]: https://img.shields.io/badge/github-8da0cb?style=for-the-badge&labelColor=555555&logo=github
+//! [crates-io]: https://img.shields.io/badge/crates.io-fc8d62?style=for-the-badge&labelColor=555555&logo=rust
+//! [docs-rs]: https://img.shields.io/badge/docs.rs-66c2a5?style=for-the-badge&labelColor=555555&logo=docs.rs
+//!
+//! <br>
+//!
+//! This crate provides macros for conditional compilation according to rustc
+//! compiler version, analogous to [`#[cfg(...)]`][cfg] and
+//! [`#[cfg_attr(...)]`][cfg_attr].
+//!
+//! [cfg]: https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg-attribute
+//! [cfg_attr]: https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg_attr-attribute
+//!
+//! <br>
+//!
+//! # Selectors
+//!
+//! - <p style="margin-left:50px;text-indent:-50px">
+//!   <b><code>#[rustversion::stable]</code></b>
+//!   —<br>
+//!   True on any stable compiler.
+//!   </p>
+//!
+//! - <p style="margin-left:50px;text-indent:-50px">
+//!   <b><code>#[rustversion::stable(1.34)]</code></b>
+//!   —<br>
+//!   True on exactly the specified stable compiler.
+//!   </p>
+//!
+//! - <p style="margin-left:50px;text-indent:-50px">
+//!   <b><code>#[rustversion::beta]</code></b>
+//!   —<br>
+//!   True on any beta compiler.
+//!   </p>
+//!
+//! - <p style="margin-left:50px;text-indent:-50px">
+//!   <b><code>#[rustversion::nightly]</code></b>
+//!   —<br>
+//!   True on any nightly compiler or dev build.
+//!   </p>
+//!
+//! - <p style="margin-left:50px;text-indent:-50px">
+//!   <b><code>#[rustversion::nightly(2019-01-01)]</code></b>
+//!   —<br>
+//!   True on exactly one nightly.
+//!   </p>
+//!
+//! - <p style="margin-left:50px;text-indent:-50px">
+//!   <b><code>#[rustversion::since(1.34)]</code></b>
+//!   —<br>
+//!   True on that stable release and any later compiler, including beta and
+//!   nightly.
+//!   </p>
+//!
+//! - <p style="margin-left:50px;text-indent:-50px">
+//!   <b><code>#[rustversion::since(2019-01-01)]</code></b>
+//!   —<br>
+//!   True on that nightly and all newer ones.
+//!   </p>
+//!
+//! - <p style="margin-left:50px;text-indent:-50px">
+//!   <b><code>#[rustversion::before(</code></b><i>version or date</i><b><code>)]</code></b>
+//!   —<br>
+//!   Negative of <i>#[rustversion::since(...)]</i>.
+//!   </p>
+//!
+//! - <p style="margin-left:50px;text-indent:-50px">
+//!   <b><code>#[rustversion::not(</code></b><i>selector</i><b><code>)]</code></b>
+//!   —<br>
+//!   Negative of any selector; for example <i>#[rustversion::not(nightly)]</i>.
+//!   </p>
+//!
+//! - <p style="margin-left:50px;text-indent:-50px">
+//!   <b><code>#[rustversion::any(</code></b><i>selectors...</i><b><code>)]</code></b>
+//!   —<br>
+//!   True if any of the comma-separated selectors is true; for example
+//!   <i>#[rustversion::any(stable, beta)]</i>.
+//!   </p>
+//!
+//! - <p style="margin-left:50px;text-indent:-50px">
+//!   <b><code>#[rustversion::all(</code></b><i>selectors...</i><b><code>)]</code></b>
+//!   —<br>
+//!   True if all of the comma-separated selectors are true; for example
+//!   <i>#[rustversion::all(since(1.31), before(1.34))]</i>.
+//!   </p>
+//!
+//! - <p style="margin-left:50px;text-indent:-50px">
+//!   <b><code>#[rustversion::attr(</code></b><i>selector</i><b><code>, </code></b><i>attribute</i><b><code>)]</code></b>
+//!   —<br>
+//!   For conditional inclusion of attributes; analogous to
+//!   <code>cfg_attr</code>.
+//!   </p>
+//!
+//! <br>
+//!
+//! # Use cases
+//!
+//! Providing additional trait impls as types are stabilized in the standard library
+//! without breaking compatibility with older compilers; in this case Pin\<P\>
+//! stabilized in [Rust 1.33][pin]:
+//!
+//! [pin]: https://blog.rust-lang.org/2019/02/28/Rust-1.33.0.html#pinning
+//!
+//! ```
+//! # trait MyTrait {}
+//! #
+//! #[rustversion::since(1.33)]
+//! use std::pin::Pin;
+//!
+//! #[rustversion::since(1.33)]
+//! impl<P: MyTrait> MyTrait for Pin<P> {
+//!     /* ... */
+//! }
+//! ```
+//!
+//! Similar but for language features; the ability to control alignment greater than
+//! 1 of packed structs was stabilized in [Rust 1.33][packed].
+//!
+//! [packed]: https://github.com/rust-lang/rust/blob/master/RELEASES.md#version-1330-2019-02-28
+//!
+//! ```
+//! #[rustversion::attr(before(1.33), repr(packed))]
+//! #[rustversion::attr(since(1.33), repr(packed(2)))]
+//! struct Six(i16, i32);
+//!
+//! fn main() {
+//!     println!("{}", std::mem::align_of::<Six>());
+//! }
+//! ```
+//!
+//! Augmenting code with `const` as const impls are stabilized in the standard
+//! library. This use of `const` as an attribute is recognized as a special case
+//! by the rustversion::attr macro.
+//!
+//! ```
+//! use std::time::Duration;
+//!
+//! #[rustversion::attr(since(1.32), const)]
+//! fn duration_as_days(dur: Duration) -> u64 {
+//!     dur.as_secs() / 60 / 60 / 24
+//! }
+//! ```
+//!
+//! <br>
+
+#![doc(html_root_url = "https://docs.rs/rustversion/1.0.14")]
+#![allow(
+    clippy::cast_lossless,
+    clippy::cast_possible_truncation,
+    clippy::derive_partial_eq_without_eq,
+    clippy::doc_markdown,
+    clippy::enum_glob_use,
+    clippy::from_iter_instead_of_collect,
+    // https://github.com/rust-lang/rust-clippy/issues/8539
+    clippy::iter_with_drain,
+    clippy::module_name_repetitions,
+    clippy::must_use_candidate,
+    clippy::needless_doctest_main,
+    clippy::needless_pass_by_value,
+    clippy::redundant_else,
+    clippy::toplevel_ref_arg,
+    clippy::unreadable_literal
+)]
+
+extern crate proc_macro;
+
+mod attr;
+mod bound;
+mod constfn;
+mod date;
+mod error;
+mod expand;
+mod expr;
+mod iter;
+mod release;
+mod time;
+mod token;
+mod version;
+
+use crate::error::Error;
+use crate::version::Version;
+use proc_macro::TokenStream;
+
+// ANDROID: Soong is providing the version of rustc via an env variable.
+const ANDROID_RUSTVERSION: Option<&str> = option_env!("ANDROID_RUST_VERSION");
+fn rust_version() -> Version {
+    let v: Vec<&str> = ANDROID_RUSTVERSION.unwrap().split('.').collect();
+    Version {
+        minor: v[1].parse().unwrap(),
+        patch: v[2].parse().unwrap(),
+        channel: version::Channel::Stable,
+    }
+}
+
+#[proc_macro_attribute]
+pub fn stable(args: TokenStream, input: TokenStream) -> TokenStream {
+    expand::cfg("stable", args, input)
+}
+
+#[proc_macro_attribute]
+pub fn beta(args: TokenStream, input: TokenStream) -> TokenStream {
+    expand::cfg("beta", args, input)
+}
+
+#[proc_macro_attribute]
+pub fn nightly(args: TokenStream, input: TokenStream) -> TokenStream {
+    expand::cfg("nightly", args, input)
+}
+
+#[proc_macro_attribute]
+pub fn since(args: TokenStream, input: TokenStream) -> TokenStream {
+    expand::cfg("since", args, input)
+}
+
+#[proc_macro_attribute]
+pub fn before(args: TokenStream, input: TokenStream) -> TokenStream {
+    expand::cfg("before", args, input)
+}
+
+#[proc_macro_attribute]
+pub fn not(args: TokenStream, input: TokenStream) -> TokenStream {
+    expand::cfg("not", args, input)
+}
+
+#[proc_macro_attribute]
+pub fn any(args: TokenStream, input: TokenStream) -> TokenStream {
+    expand::cfg("any", args, input)
+}
+
+#[proc_macro_attribute]
+pub fn all(args: TokenStream, input: TokenStream) -> TokenStream {
+    expand::cfg("all", args, input)
+}
+
+#[proc_macro_attribute]
+pub fn attr(args: TokenStream, input: TokenStream) -> TokenStream {
+    attr::parse(args)
+        .and_then(|args| expand::try_attr(args, input))
+        .unwrap_or_else(Error::into_compile_error)
+}
+
+#[cfg(not(cfg_macro_not_allowed))]
+#[proc_macro]
+pub fn cfg(input: TokenStream) -> TokenStream {
+    use proc_macro::{Ident, Span, TokenTree};
+    (|| {
+        let ref mut args = iter::new(input);
+        let expr = expr::parse(args)?;
+        token::parse_end(args)?;
+        let boolean = expr.eval(rust_version());
+        let ident = Ident::new(&boolean.to_string(), Span::call_site());
+        Ok(TokenStream::from(TokenTree::Ident(ident)))
+    })()
+    .unwrap_or_else(Error::into_compile_error)
+}
diff --git a/crates/rustversion/src/release.rs b/crates/rustversion/src/release.rs
new file mode 100644
index 0000000..3f421c6
--- /dev/null
+++ b/crates/rustversion/src/release.rs
@@ -0,0 +1,34 @@
+use crate::error::{Error, Result};
+use crate::iter::Iter;
+use crate::token;
+use proc_macro::Group;
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Release {
+    pub minor: u16,
+    pub patch: Option<u16>,
+}
+
+pub fn parse(paren: Group, iter: Iter) -> Result<Release> {
+    try_parse(iter).map_err(|_| Error::group(paren, "expected rustc release number, like 1.31"))
+}
+
+fn try_parse(iter: Iter) -> Result<Release, ()> {
+    let major_minor = token::parse_literal(iter).map_err(drop)?;
+    let string = major_minor.to_string();
+
+    if !string.starts_with("1.") {
+        return Err(());
+    }
+
+    let minor: u16 = string[2..].parse().map_err(drop)?;
+
+    let patch = if token::parse_optional_punct(iter, '.').is_some() {
+        let int = token::parse_literal(iter).map_err(drop)?;
+        Some(int.to_string().parse().map_err(drop)?)
+    } else {
+        None
+    };
+
+    Ok(Release { minor, patch })
+}
diff --git a/crates/rustversion/src/time.rs b/crates/rustversion/src/time.rs
new file mode 100644
index 0000000..3c21463
--- /dev/null
+++ b/crates/rustversion/src/time.rs
@@ -0,0 +1,51 @@
+use crate::date::Date;
+use std::env;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+// Timestamp of 2016-03-01 00:00:00 in UTC.
+const BASE: u64 = 1456790400;
+const BASE_YEAR: u16 = 2016;
+const BASE_MONTH: u8 = 3;
+
+// Days between leap days.
+const CYCLE: u64 = 365 * 4 + 1;
+
+const DAYS_BY_MONTH: [u8; 12] = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+
+pub fn today() -> Date {
+    let default = Date {
+        year: 2020,
+        month: 2,
+        day: 25,
+    };
+    try_today().unwrap_or(default)
+}
+
+fn try_today() -> Option<Date> {
+    if let Some(pkg_name) = env::var_os("CARGO_PKG_NAME") {
+        if pkg_name.to_str() == Some("rustversion-tests") {
+            return None; // Stable date for ui testing.
+        }
+    }
+
+    let now = SystemTime::now();
+    let since_epoch = now.duration_since(UNIX_EPOCH).ok()?;
+    let secs = since_epoch.as_secs();
+
+    let approx_days = secs.checked_sub(BASE)? / 60 / 60 / 24;
+    let cycle = approx_days / CYCLE;
+    let mut rem = approx_days % CYCLE;
+
+    let mut year = BASE_YEAR + cycle as u16 * 4;
+    let mut month = BASE_MONTH;
+    loop {
+        let days_in_month = DAYS_BY_MONTH[month as usize - 1];
+        if rem < days_in_month as u64 {
+            let day = rem as u8 + 1;
+            return Some(Date { year, month, day });
+        }
+        rem -= days_in_month as u64;
+        year += (month == 12) as u16;
+        month = month % 12 + 1;
+    }
+}
diff --git a/crates/rustversion/src/token.rs b/crates/rustversion/src/token.rs
new file mode 100644
index 0000000..ebb6f1c
--- /dev/null
+++ b/crates/rustversion/src/token.rs
@@ -0,0 +1,78 @@
+use crate::error::{Error, Result};
+use crate::iter::Iter;
+use proc_macro::{Delimiter, Group, Ident, Literal, Span, TokenTree};
+
+pub fn parse_punct(iter: Iter, ch: char) -> Result<()> {
+    match iter.next() {
+        Some(TokenTree::Punct(ref punct)) if punct.as_char() == ch => Ok(()),
+        unexpected => {
+            let span = unexpected
+                .as_ref()
+                .map_or_else(Span::call_site, TokenTree::span);
+            Err(Error::new(span, format!("expected `{}`", ch)))
+        }
+    }
+}
+
+pub fn parse_optional_punct(iter: Iter, ch: char) -> Option<()> {
+    match iter.peek() {
+        Some(TokenTree::Punct(punct)) if punct.as_char() == ch => iter.next().map(drop),
+        _ => None,
+    }
+}
+
+pub fn parse_optional_keyword(iter: Iter, keyword: &str) -> Option<Span> {
+    match iter.peek() {
+        Some(TokenTree::Ident(ident)) if ident.to_string() == keyword => {
+            Some(iter.next().unwrap().span())
+        }
+        _ => None,
+    }
+}
+
+pub fn parse_literal(iter: Iter) -> Result<Literal> {
+    match iter.next() {
+        Some(TokenTree::Literal(literal)) => Ok(literal),
+        unexpected => {
+            let span = unexpected
+                .as_ref()
+                .map_or_else(Span::call_site, TokenTree::span);
+            Err(Error::new(span, "expected literal"))
+        }
+    }
+}
+
+pub fn parse_paren(introducer: &Ident, iter: Iter) -> Result<Group> {
+    match iter.peek() {
+        Some(TokenTree::Group(group)) if group.delimiter() == Delimiter::Parenthesis => {
+            match iter.next() {
+                Some(TokenTree::Group(group)) => Ok(group),
+                _ => unreachable!(),
+            }
+        }
+        Some(unexpected) => Err(Error::new(unexpected.span(), "expected `(`")),
+        None => Err(Error::new(
+            introducer.span(),
+            format!("expected `(` after `{}`", introducer),
+        )),
+    }
+}
+
+pub fn parse_optional_paren(iter: Iter) -> Option<Group> {
+    match iter.peek() {
+        Some(TokenTree::Group(group)) if group.delimiter() == Delimiter::Parenthesis => {
+            match iter.next() {
+                Some(TokenTree::Group(group)) => Some(group),
+                _ => unreachable!(),
+            }
+        }
+        _ => None,
+    }
+}
+
+pub fn parse_end(iter: Iter) -> Result<()> {
+    match iter.next() {
+        None => Ok(()),
+        Some(unexpected) => Err(Error::new(unexpected.span(), "unexpected token")),
+    }
+}
diff --git a/crates/rustversion/src/version.rs b/crates/rustversion/src/version.rs
new file mode 100644
index 0000000..f4a69f5
--- /dev/null
+++ b/crates/rustversion/src/version.rs
@@ -0,0 +1,18 @@
+#![allow(dead_code)]
+
+use crate::date::Date;
+
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub struct Version {
+    pub minor: u16,
+    pub patch: u16,
+    pub channel: Channel,
+}
+
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub enum Channel {
+    Stable,
+    Beta,
+    Nightly(Date),
+    Dev,
+}
diff --git a/crates/rustversion/tests/compiletest.rs b/crates/rustversion/tests/compiletest.rs
new file mode 100644
index 0000000..7974a62
--- /dev/null
+++ b/crates/rustversion/tests/compiletest.rs
@@ -0,0 +1,7 @@
+#[rustversion::attr(not(nightly), ignore)]
+#[cfg_attr(miri, ignore)]
+#[test]
+fn ui() {
+    let t = trybuild::TestCases::new();
+    t.compile_fail("tests/ui/*.rs");
+}
diff --git a/crates/rustversion/tests/test_const.rs b/crates/rustversion/tests/test_const.rs
new file mode 100644
index 0000000..3c4f7d5
--- /dev/null
+++ b/crates/rustversion/tests/test_const.rs
@@ -0,0 +1,39 @@
+#![allow(clippy::semicolon_if_nothing_returned)] // https://github.com/rust-lang/rust-clippy/issues/7324
+
+#[rustversion::attr(all(), const)]
+fn _basic() {}
+const _BASIC: () = _basic();
+
+#[rustversion::attr(all(), const)]
+unsafe fn _unsafe() {}
+const _UNSAFE: () = unsafe { _unsafe() };
+
+macro_rules! item {
+    ($i:item) => {
+        #[rustversion::attr(all(), const)]
+        $i
+    };
+}
+
+item! {fn _item() {}}
+const _ITEM: () = _item();
+
+macro_rules! ident {
+    ($fn:ident) => {
+        #[rustversion::attr(all(), const)]
+        $fn _ident() {}
+    };
+}
+
+ident! {fn}
+const _IDENT: () = _ident();
+
+#[rustversion::attr(all(), const)]
+/// doc
+fn _doc_below() {}
+const _DOC_BELOW: () = _doc_below();
+
+/// doc
+#[rustversion::attr(all(), const)]
+fn _doc_above() {}
+const _DOC_ABOVE: () = _doc_above();
diff --git a/crates/rustversion/tests/test_eval.rs b/crates/rustversion/tests/test_eval.rs
new file mode 100644
index 0000000..c044e85
--- /dev/null
+++ b/crates/rustversion/tests/test_eval.rs
@@ -0,0 +1,20 @@
+#[rustversion::any(
+    stable,
+    stable(1.34),
+    stable(1.34.0),
+    beta,
+    nightly,
+    nightly(2020-02-25),
+    since(1.34),
+    since(2020-02-25),
+    before(1.34),
+    before(2020-02-25),
+    not(nightly),
+    all(stable, beta, nightly),
+)]
+fn success() {}
+
+#[test]
+fn test() {
+    success();
+}
diff --git a/crates/rustversion/tests/test_parse.rs b/crates/rustversion/tests/test_parse.rs
new file mode 100644
index 0000000..95064ee
--- /dev/null
+++ b/crates/rustversion/tests/test_parse.rs
@@ -0,0 +1,103 @@
+#![allow(
+    clippy::derive_partial_eq_without_eq,
+    clippy::enum_glob_use,
+    clippy::must_use_candidate
+)]
+
+include!("../build/rustc.rs");
+
+#[test]
+fn test_parse() {
+    let cases = &[
+        (
+            "rustc 1.0.0 (a59de37e9 2015-05-13) (built 2015-05-14)",
+            Version {
+                minor: 0,
+                patch: 0,
+                channel: Stable,
+            },
+        ),
+        (
+            "rustc 1.18.0",
+            Version {
+                minor: 18,
+                patch: 0,
+                channel: Stable,
+            },
+        ),
+        (
+            "rustc 1.24.1 (d3ae9a9e0 2018-02-27)",
+            Version {
+                minor: 24,
+                patch: 1,
+                channel: Stable,
+            },
+        ),
+        (
+            "rustc 1.35.0-beta.3 (c13114dc8 2019-04-27)",
+            Version {
+                minor: 35,
+                patch: 0,
+                channel: Beta,
+            },
+        ),
+        (
+            "rustc 1.36.0-nightly (938d4ffe1 2019-04-27)",
+            Version {
+                minor: 36,
+                patch: 0,
+                channel: Nightly(Date {
+                    year: 2019,
+                    month: 4,
+                    day: 27,
+                }),
+            },
+        ),
+        (
+            "rustc 1.36.0-dev",
+            Version {
+                minor: 36,
+                patch: 0,
+                channel: Dev,
+            },
+        ),
+        (
+            "rustc 1.36.0-nightly",
+            Version {
+                minor: 36,
+                patch: 0,
+                channel: Dev,
+            },
+        ),
+        (
+            "warning: invalid logging spec 'warning', ignoring it
+             rustc 1.30.0-nightly (3bc2ca7e4 2018-09-20)",
+            Version {
+                minor: 30,
+                patch: 0,
+                channel: Nightly(Date {
+                    year: 2018,
+                    month: 9,
+                    day: 20,
+                }),
+            },
+        ),
+        (
+            "rustc 1.52.1-nightly (gentoo)",
+            Version {
+                minor: 52,
+                patch: 1,
+                channel: Dev,
+            },
+        ),
+    ];
+
+    for (string, expected) in cases {
+        match parse(string) {
+            ParseResult::Success(version) => assert_eq!(version, *expected),
+            ParseResult::OopsClippy | ParseResult::Unrecognized => {
+                panic!("unrecognized: {:?}", string);
+            }
+        }
+    }
+}
diff --git a/crates/rustversion/tests/ui/bad-bound.rs b/crates/rustversion/tests/ui/bad-bound.rs
new file mode 100644
index 0000000..add8792
--- /dev/null
+++ b/crates/rustversion/tests/ui/bad-bound.rs
@@ -0,0 +1,7 @@
+#[rustversion::since(stable)]
+struct S;
+
+#[rustversion::any(since(stable))]
+struct S;
+
+fn main() {}
diff --git a/crates/rustversion/tests/ui/bad-bound.stderr b/crates/rustversion/tests/ui/bad-bound.stderr
new file mode 100644
index 0000000..77956c6
--- /dev/null
+++ b/crates/rustversion/tests/ui/bad-bound.stderr
@@ -0,0 +1,11 @@
+error: expected rustc release number like 1.31, or nightly date like 2020-02-25
+ --> tests/ui/bad-bound.rs:1:22
+  |
+1 | #[rustversion::since(stable)]
+  |                      ^^^^^^
+
+error: expected rustc release number like 1.31, or nightly date like 2020-02-25
+ --> tests/ui/bad-bound.rs:4:26
+  |
+4 | #[rustversion::any(since(stable))]
+  |                          ^^^^^^
diff --git a/crates/rustversion/tests/ui/bad-date.rs b/crates/rustversion/tests/ui/bad-date.rs
new file mode 100644
index 0000000..0984625
--- /dev/null
+++ b/crates/rustversion/tests/ui/bad-date.rs
@@ -0,0 +1,7 @@
+#[rustversion::nightly(stable)]
+struct S;
+
+#[rustversion::any(nightly(stable))]
+struct S;
+
+fn main() {}
diff --git a/crates/rustversion/tests/ui/bad-date.stderr b/crates/rustversion/tests/ui/bad-date.stderr
new file mode 100644
index 0000000..378b00e
--- /dev/null
+++ b/crates/rustversion/tests/ui/bad-date.stderr
@@ -0,0 +1,11 @@
+error: expected nightly date, like 2020-02-25
+ --> tests/ui/bad-date.rs:1:24
+  |
+1 | #[rustversion::nightly(stable)]
+  |                        ^^^^^^
+
+error: expected nightly date, like 2020-02-25
+ --> tests/ui/bad-date.rs:4:28
+  |
+4 | #[rustversion::any(nightly(stable))]
+  |                            ^^^^^^
diff --git a/crates/rustversion/tests/ui/bad-not.rs b/crates/rustversion/tests/ui/bad-not.rs
new file mode 100644
index 0000000..058f340
--- /dev/null
+++ b/crates/rustversion/tests/ui/bad-not.rs
@@ -0,0 +1,7 @@
+#[rustversion::any(not)]
+struct S;
+
+#[rustversion::any(not, not)]
+struct S;
+
+fn main() {}
diff --git a/crates/rustversion/tests/ui/bad-not.stderr b/crates/rustversion/tests/ui/bad-not.stderr
new file mode 100644
index 0000000..2b0c699
--- /dev/null
+++ b/crates/rustversion/tests/ui/bad-not.stderr
@@ -0,0 +1,11 @@
+error: expected `(` after `not`
+ --> tests/ui/bad-not.rs:1:20
+  |
+1 | #[rustversion::any(not)]
+  |                    ^^^
+
+error: expected `(`
+ --> tests/ui/bad-not.rs:4:23
+  |
+4 | #[rustversion::any(not, not)]
+  |                       ^
diff --git a/crates/rustversion/tests/ui/bad-version.rs b/crates/rustversion/tests/ui/bad-version.rs
new file mode 100644
index 0000000..1fe8dba
--- /dev/null
+++ b/crates/rustversion/tests/ui/bad-version.rs
@@ -0,0 +1,7 @@
+#[rustversion::stable(nightly)]
+struct S;
+
+#[rustversion::any(stable(nightly))]
+struct S;
+
+fn main() {}
diff --git a/crates/rustversion/tests/ui/bad-version.stderr b/crates/rustversion/tests/ui/bad-version.stderr
new file mode 100644
index 0000000..bf3f144
--- /dev/null
+++ b/crates/rustversion/tests/ui/bad-version.stderr
@@ -0,0 +1,11 @@
+error: expected rustc release number, like 1.31
+ --> tests/ui/bad-version.rs:1:23
+  |
+1 | #[rustversion::stable(nightly)]
+  |                       ^^^^^^^
+
+error: expected rustc release number, like 1.31
+ --> tests/ui/bad-version.rs:4:27
+  |
+4 | #[rustversion::any(stable(nightly))]
+  |                           ^^^^^^^
diff --git a/crates/rustversion/tests/ui/const-not-fn.rs b/crates/rustversion/tests/ui/const-not-fn.rs
new file mode 100644
index 0000000..215df7d
--- /dev/null
+++ b/crates/rustversion/tests/ui/const-not-fn.rs
@@ -0,0 +1,4 @@
+#[rustversion::attr(all(), const)]
+pub struct S;
+
+fn main() {}
diff --git a/crates/rustversion/tests/ui/const-not-fn.stderr b/crates/rustversion/tests/ui/const-not-fn.stderr
new file mode 100644
index 0000000..d3cb4aa
--- /dev/null
+++ b/crates/rustversion/tests/ui/const-not-fn.stderr
@@ -0,0 +1,5 @@
+error: only allowed on a fn item
+ --> tests/ui/const-not-fn.rs:1:28
+  |
+1 | #[rustversion::attr(all(), const)]
+  |                            ^^^^^
diff --git a/crates/scopeguard/.cargo-checksum.json b/crates/scopeguard/.cargo-checksum.json
new file mode 100644
index 0000000..5afe735
--- /dev/null
+++ b/crates/scopeguard/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"Cargo.lock":"684e99cc5938e7e51e1c5808214f9125ccfe66efa6ca5392303a7ee5337e1294","Cargo.toml":"68899251551903e2e1ba03c927f12e4c19fc8a15e8bd3756610f53f5ec075b48","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"fb77f0a9c53e473abe5103c8632ef9f0f2874d4fb3f17cb2d8c661aab9cee9d7","README.md":"68d5a7beebf814cffaaf6fe5758984fd06554b3bb5a49b2e13fc101522909b91","examples/readme.rs":"c6b1b458a130e091b1465040184759f1cc7d4e8de8d9cb893def0107238c2964","src/lib.rs":"3fb8bba1227724954c01cf98ec984bcf49ee74624faa74eb1bcea9018682751c"},"package":"94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"}
\ No newline at end of file
diff --git a/crates/scopeguard/Android.bp b/crates/scopeguard/Android.bp
new file mode 100644
index 0000000..aeeac84
--- /dev/null
+++ b/crates/scopeguard/Android.bp
@@ -0,0 +1,54 @@
+// This file is generated by cargo_embargo.
+// Do not modify this file because the changes will be overridden on upgrade.
+
+package {
+    default_applicable_licenses: ["external_rust_crates_scopeguard_license"],
+    default_team: "trendy_team_android_rust",
+}
+
+license {
+    name: "external_rust_crates_scopeguard_license",
+    visibility: [":__subpackages__"],
+    license_kinds: ["SPDX-license-identifier-Apache-2.0"],
+    license_text: ["LICENSE"],
+}
+
+rust_library {
+    name: "libscopeguard",
+    host_supported: true,
+    crate_name: "scopeguard",
+    cargo_env_compat: true,
+    cargo_pkg_version: "1.2.0",
+    crate_root: "src/lib.rs",
+    edition: "2015",
+    features: [
+        "default",
+        "use_std",
+    ],
+    apex_available: [
+        "//apex_available:platform",
+        "//apex_available:anyapex",
+    ],
+    product_available: true,
+    vendor_available: true,
+    min_sdk_version: "29",
+}
+
+rust_test {
+    name: "scopeguard_test_src_lib",
+    host_supported: true,
+    crate_name: "scopeguard",
+    cargo_env_compat: true,
+    cargo_pkg_version: "1.2.0",
+    crate_root: "src/lib.rs",
+    test_suites: ["general-tests"],
+    auto_gen_config: true,
+    test_options: {
+        unit_test: true,
+    },
+    edition: "2015",
+    features: [
+        "default",
+        "use_std",
+    ],
+}
diff --git a/crates/scopeguard/Cargo.lock b/crates/scopeguard/Cargo.lock
new file mode 100644
index 0000000..ebfce51
--- /dev/null
+++ b/crates/scopeguard/Cargo.lock
@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "scopeguard"
+version = "1.2.0"
diff --git a/crates/scopeguard/Cargo.toml b/crates/scopeguard/Cargo.toml
new file mode 100644
index 0000000..acf5dce
--- /dev/null
+++ b/crates/scopeguard/Cargo.toml
@@ -0,0 +1,43 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+name = "scopeguard"
+version = "1.2.0"
+authors = ["bluss"]
+description = """
+A RAII scope guard that will run a given closure when it goes out of scope,
+even if the code between panics (assuming unwinding panic).
+
+Defines the macros `defer!`, `defer_on_unwind!`, `defer_on_success!` as
+shorthands for guards with one of the implemented strategies.
+"""
+documentation = "https://docs.rs/scopeguard/"
+readme = "README.md"
+keywords = [
+    "scope-guard",
+    "defer",
+    "panic",
+    "unwind",
+]
+categories = [
+    "rust-patterns",
+    "no-std",
+]
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/bluss/scopeguard"
+
+[package.metadata.release]
+no-dev-version = true
+
+[features]
+default = ["use_std"]
+use_std = []
diff --git a/crates/scopeguard/LICENSE b/crates/scopeguard/LICENSE
new file mode 120000
index 0000000..6b579aa
--- /dev/null
+++ b/crates/scopeguard/LICENSE
@@ -0,0 +1 @@
+LICENSE-APACHE
\ No newline at end of file
diff --git a/crates/scopeguard/LICENSE-APACHE b/crates/scopeguard/LICENSE-APACHE
new file mode 100644
index 0000000..16fe87b
--- /dev/null
+++ b/crates/scopeguard/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/crates/scopeguard/LICENSE-MIT b/crates/scopeguard/LICENSE-MIT
new file mode 100644
index 0000000..8514471
--- /dev/null
+++ b/crates/scopeguard/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2016-2019 Ulrik Sverdrup "bluss" and scopeguard developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/crates/scopeguard/METADATA b/crates/scopeguard/METADATA
new file mode 100644
index 0000000..63329c7
--- /dev/null
+++ b/crates/scopeguard/METADATA
@@ -0,0 +1,20 @@
+# This project was upgraded with external_updater.
+# Usage: tools/external_updater/updater.sh update external/rust/crates/scopeguard
+# For more info, check https://cs.android.com/android/platform/superproject/+/main:tools/external_updater/README.md
+
+name: "scopeguard"
+description: "A RAII scope guard that will run a given closure when it goes out of scope, even if the code between panics (assuming unwinding panic).  Defines the macros `defer!`, `defer_on_unwind!`, `defer_on_success!` as shorthands for guards with one of the implemented strategies."
+third_party {
+  license_type: NOTICE
+  last_upgrade_date {
+    year: 2024
+    month: 2
+    day: 7
+  }
+  homepage: "https://crates.io/crates/scopeguard"
+  identifier {
+    type: "Archive"
+    value: "https://static.crates.io/crates/scopeguard/scopeguard-1.2.0.crate"
+    version: "1.2.0"
+  }
+}
diff --git a/crates/scopeguard/MODULE_LICENSE_APACHE2 b/crates/scopeguard/MODULE_LICENSE_APACHE2
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/crates/scopeguard/MODULE_LICENSE_APACHE2
diff --git a/crates/scopeguard/README.md b/crates/scopeguard/README.md
new file mode 100644
index 0000000..01fa68c
--- /dev/null
+++ b/crates/scopeguard/README.md
@@ -0,0 +1,102 @@
+# scopeguard
+
+Rust crate for a convenient RAII scope guard that will run a given closure when
+it goes out of scope, even if the code between panics (assuming unwinding panic).
+
+The `defer!` macro and `guard` are `no_std` compatible (require only `core`),
+but the on unwinding / not on unwinding strategies require linking to `std`.
+By default, the `use_std` crate feature is enabled. Disable the default features
+for `no_std` support.
+
+Please read the [API documentation here](https://docs.rs/scopeguard/).
+
+Minimum supported Rust version: 1.20
+
+[![build_status](https://github.com/bluss/scopeguard/actions/workflows/ci.yaml/badge.svg)](https://github.com/bluss/scopeguard/actions/workflows/ci.yaml)
+[![crates](https://img.shields.io/crates/v/scopeguard.svg)](https://crates.io/crates/scopeguard)
+
+## How to use
+
+```rs
+#[macro_use(defer)]
+extern crate scopeguard;
+
+use scopeguard::guard;
+
+fn f() {
+    defer! {
+        println!("Called at return or panic");
+    }
+    panic!();
+}
+
+use std::fs::File;
+use std::io::Write;
+
+fn g() {
+    let f = File::create("newfile.txt").unwrap();
+    let mut file = guard(f, |f| {
+        // write file at return or panic
+        let _ = f.sync_all();
+    });
+    // access the file through the scope guard itself
+    file.write_all(b"test me\n").unwrap();
+}
+```
+
+## Recent Changes
+
+- 1.2.0
+
+  - Use ManuallyDrop instead of mem::forget in into_inner. (by @willtunnels)
+  - Warn if the guard is not assigned to a variable and is dropped immediately
+    instead of at the scope's end. (by @sergey-v-galtsev)
+
+- 1.1.0
+
+  - Change macros (`defer!`, `defer_on_success!` and `defer_on_unwind!`)
+    to accept statements. (by @konsumlamm)
+
+- 1.0.0
+
+  - Change the closure type from `FnMut(&mut T)` to `FnOnce(T)`:
+    Passing the inner value by value instead of a mutable reference is a
+    breaking change, but allows the guard closure to consume it. (by @tormol)
+
+  - Add `defer_on_success!`, `guard_on_success()` and `OnSuccess`
+    strategy, which triggers when scope is exited *without* panic. It's the
+    opposite to `defer_on_unwind!` / `guard_on_unwind()` / `OnUnwind`.
+
+  - Add `ScopeGuard::into_inner()`, which "defuses" the guard and returns the
+    guarded value. (by @tormol)
+
+  - Implement `Sync` for guards with non-`Sync` closures.
+
+  - Require Rust 1.20
+
+- 0.3.3
+
+  - Use `#[inline]` on a few more functions by @stjepang (#14)
+  - Add examples to crate documentation
+
+- 0.3.2
+
+  - Add crate categories
+
+- 0.3.1
+
+  - Add `defer_on_unwind!`, `Strategy` trait
+  - Rename `Guard` → `ScopeGuard`
+  - Add `ScopeGuard::with_strategy`.
+  - `ScopeGuard` now implements `Debug`.
+  - Require Rust 1.11
+
+- 0.2.0
+
+  - Require Rust 1.6
+  - Use `no_std` unconditionally
+  - No other changes
+
+- 0.1.2
+
+  - Add macro `defer!`
diff --git a/crates/scopeguard/TEST_MAPPING b/crates/scopeguard/TEST_MAPPING
new file mode 100644
index 0000000..26eebef
--- /dev/null
+++ b/crates/scopeguard/TEST_MAPPING
@@ -0,0 +1,54 @@
+// Generated by update_crate_tests.py for tests that depend on this crate.
+{
+  "imports": [
+    {
+      "path": "external/rust/crates/base64"
+    },
+    {
+      "path": "external/rust/crates/crossbeam-deque"
+    },
+    {
+      "path": "external/rust/crates/crossbeam-epoch"
+    },
+    {
+      "path": "external/rust/crates/hashbrown"
+    },
+    {
+      "path": "external/rust/crates/tinytemplate"
+    },
+    {
+      "path": "external/rust/crates/tinyvec"
+    },
+    {
+      "path": "external/rust/crates/unicode-xid"
+    },
+    {
+      "path": "external/rust/crates/vulkano"
+    },
+    {
+      "path": "packages/modules/Virtualization/apkdmverity"
+    },
+    {
+      "path": "packages/modules/Virtualization/libs/capabilities"
+    },
+    {
+      "path": "packages/modules/Virtualization/libs/devicemapper"
+    },
+    {
+      "path": "packages/modules/Virtualization/microdroid_manager"
+    },
+    {
+      "path": "packages/modules/Virtualization/zipfuse"
+    }
+  ],
+  "presubmit": [
+    {
+      "name": "scopeguard_test_src_lib"
+    }
+  ],
+  "presubmit-rust": [
+    {
+      "name": "scopeguard_test_src_lib"
+    }
+  ]
+}
diff --git a/crates/scopeguard/cargo_embargo.json b/crates/scopeguard/cargo_embargo.json
new file mode 100644
index 0000000..16616e0
--- /dev/null
+++ b/crates/scopeguard/cargo_embargo.json
@@ -0,0 +1,5 @@
+{
+  "min_sdk_version": "29",
+  "run_cargo": false,
+  "tests": true
+}
diff --git a/crates/scopeguard/examples/readme.rs b/crates/scopeguard/examples/readme.rs
new file mode 100644
index 0000000..c4567e5
--- /dev/null
+++ b/crates/scopeguard/examples/readme.rs
@@ -0,0 +1,29 @@
+#[macro_use(defer)]
+extern crate scopeguard;
+
+use scopeguard::guard;
+
+fn f() {
+    defer! {
+        println!("Called at return or panic");
+    }
+    panic!();
+}
+
+use std::fs::File;
+use std::io::Write;
+
+fn g() {
+    let f = File::create("newfile.txt").unwrap();
+    let mut file = guard(f, |f| {
+        // write file at return or panic
+        let _ = f.sync_all();
+    });
+    // access the file through the scope guard itself
+    file.write_all(b"test me\n").unwrap();
+}
+
+fn main() {
+    f();
+    g();
+}
diff --git a/crates/scopeguard/patches/disable_panic_tests.patch b/crates/scopeguard/patches/disable_panic_tests.patch
new file mode 100644
index 0000000..97615cd
--- /dev/null
+++ b/crates/scopeguard/patches/disable_panic_tests.patch
@@ -0,0 +1,20 @@
+diff --git a/src/lib.rs b/src/lib.rs
+index d33c2b6..39f5026 100644
+--- a/src/lib.rs
++++ b/src/lib.rs
+@@ -500,6 +500,7 @@ mod tests {
+ 
+     #[cfg(feature = "use_std")]
+     #[test]
++    #[ignore = "Android uses panic_abort"]
+     fn test_defer_success_2() {
+         let drops = Cell::new(0);
+         let _ = catch_unwind(AssertUnwindSafe(|| {
+@@ -511,6 +512,7 @@ mod tests {
+ 
+     #[cfg(feature = "use_std")]
+     #[test]
++    #[ignore = "Android uses panic_abort"]
+     fn test_defer_unwind_1() {
+         let drops = Cell::new(0);
+         let _ = catch_unwind(AssertUnwindSafe(|| {
diff --git a/crates/scopeguard/src/lib.rs b/crates/scopeguard/src/lib.rs
new file mode 100644
index 0000000..d94129f
--- /dev/null
+++ b/crates/scopeguard/src/lib.rs
@@ -0,0 +1,597 @@
+#![cfg_attr(not(any(test, feature = "use_std")), no_std)]
+#![doc(html_root_url = "https://docs.rs/scopeguard/1/")]
+
+//! A scope guard will run a given closure when it goes out of scope,
+//! even if the code between panics.
+//! (as long as panic doesn't abort)
+//!
+//! # Examples
+//!
+//! ## Hello World
+//!
+//! This example creates a scope guard with an example function:
+//!
+//! ```
+//! extern crate scopeguard;
+//!
+//! fn f() {
+//!     let _guard = scopeguard::guard((), |_| {
+//!         println!("Hello Scope Exit!");
+//!     });
+//!
+//!     // rest of the code here.
+//!
+//!     // Here, at the end of `_guard`'s scope, the guard's closure is called.
+//!     // It is also called if we exit this scope through unwinding instead.
+//! }
+//! # fn main() {
+//! #    f();
+//! # }
+//! ```
+//!
+//! ## `defer!`
+//!
+//! Use the `defer` macro to run an operation at scope exit,
+//! either regular scope exit or during unwinding from a panic.
+//!
+//! ```
+//! #[macro_use(defer)] extern crate scopeguard;
+//!
+//! use std::cell::Cell;
+//!
+//! fn main() {
+//!     // use a cell to observe drops during and after the scope guard is active
+//!     let drop_counter = Cell::new(0);
+//!     {
+//!         // Create a scope guard using `defer!` for the current scope
+//!         defer! {
+//!             drop_counter.set(1 + drop_counter.get());
+//!         }
+//!
+//!         // Do regular operations here in the meantime.
+//!
+//!         // Just before scope exit: it hasn't run yet.
+//!         assert_eq!(drop_counter.get(), 0);
+//!
+//!         // The following scope end is where the defer closure is called
+//!     }
+//!     assert_eq!(drop_counter.get(), 1);
+//! }
+//! ```
+//!
+//! ## Scope Guard with Value
+//!
+//! If the scope guard closure needs to access an outer value that is also
+//! mutated outside of the scope guard, then you may want to use the scope guard
+//! with a value. The guard works like a smart pointer, so the inner value can
+//! be accessed by reference or by mutable reference.
+//!
+//! ### 1. The guard owns a file
+//!
+//! In this example, the scope guard owns a file and ensures pending writes are
+//! synced at scope exit.
+//!
+//! ```
+//! extern crate scopeguard;
+//!
+//! use std::fs::*;
+//! use std::io::{self, Write};
+//! # // Mock file so that we don't actually write a file
+//! # struct MockFile;
+//! # impl MockFile {
+//! #     fn create(_s: &str) -> io::Result<Self> { Ok(MockFile) }
+//! #     fn write_all(&self, _b: &[u8]) -> io::Result<()> { Ok(()) }
+//! #     fn sync_all(&self) -> io::Result<()> { Ok(()) }
+//! # }
+//! # use self::MockFile as File;
+//!
+//! fn try_main() -> io::Result<()> {
+//!     let f = File::create("newfile.txt")?;
+//!     let mut file = scopeguard::guard(f, |f| {
+//!         // ensure we flush file at return or panic
+//!         let _ = f.sync_all();
+//!     });
+//!     // Access the file through the scope guard itself
+//!     file.write_all(b"test me\n").map(|_| ())
+//! }
+//!
+//! fn main() {
+//!     try_main().unwrap();
+//! }
+//!
+//! ```
+//!
+//! ### 2. The guard restores an invariant on scope exit
+//!
+//! ```
+//! extern crate scopeguard;
+//!
+//! use std::mem::ManuallyDrop;
+//! use std::ptr;
+//!
+//! // This function, just for this example, takes the first element
+//! // and inserts it into the assumed sorted tail of the vector.
+//! //
+//! // For optimization purposes we temporarily violate an invariant of the
+//! // Vec, that it owns all of its elements.
+//! //
+//! // The safe approach is to use swap, which means two writes to memory,
+//! // the optimization is to use a “hole” which uses only one write of memory
+//! // for each position it moves.
+//! //
+//! // We *must* use a scope guard to run this code safely. We
+//! // are running arbitrary user code (comparison operators) that may panic.
+//! // The scope guard ensures we restore the invariant after successful
+//! // exit or during unwinding from panic.
+//! fn insertion_sort_first<T>(v: &mut Vec<T>)
+//!     where T: PartialOrd
+//! {
+//!     struct Hole<'a, T: 'a> {
+//!         v: &'a mut Vec<T>,
+//!         index: usize,
+//!         value: ManuallyDrop<T>,
+//!     }
+//!
+//!     unsafe {
+//!         // Create a moved-from location in the vector, a “hole”.
+//!         let value = ptr::read(&v[0]);
+//!         let mut hole = Hole { v: v, index: 0, value: ManuallyDrop::new(value) };
+//!
+//!         // Use a scope guard with a value.
+//!         // At scope exit, plug the hole so that the vector is fully
+//!         // initialized again.
+//!         // The scope guard owns the hole, but we can access it through the guard.
+//!         let mut hole_guard = scopeguard::guard(hole, |hole| {
+//!             // plug the hole in the vector with the value that was // taken out
+//!             let index = hole.index;
+//!             ptr::copy_nonoverlapping(&*hole.value, &mut hole.v[index], 1);
+//!         });
+//!
+//!         // run algorithm that moves the hole in the vector here
+//!         // move the hole until it's in a sorted position
+//!         for i in 1..hole_guard.v.len() {
+//!             if *hole_guard.value >= hole_guard.v[i] {
+//!                 // move the element back and the hole forward
+//!                 let index = hole_guard.index;
+//!                 hole_guard.v.swap(index, index + 1);
+//!                 hole_guard.index += 1;
+//!             } else {
+//!                 break;
+//!             }
+//!         }
+//!
+//!         // When the scope exits here, the Vec becomes whole again!
+//!     }
+//! }
+//!
+//! fn main() {
+//!     let string = String::from;
+//!     let mut data = vec![string("c"), string("a"), string("b"), string("d")];
+//!     insertion_sort_first(&mut data);
+//!     assert_eq!(data, vec!["a", "b", "c", "d"]);
+//! }
+//!
+//! ```
+//!
+//!
+//! # Crate Features
+//!
+//! - `use_std`
+//!   + Enabled by default. Enables the `OnUnwind` and `OnSuccess` strategies.
+//!   + Disable to use `no_std`.
+//!
+//! # Rust Version
+//!
+//! This version of the crate requires Rust 1.20 or later.
+//!
+//! The scopeguard 1.x release series will use a carefully considered version
+//! upgrade policy, where in a later 1.x version, we will raise the minimum
+//! required Rust version.
+
+#[cfg(not(any(test, feature = "use_std")))]
+extern crate core as std;
+
+use std::fmt;
+use std::marker::PhantomData;
+use std::mem::ManuallyDrop;
+use std::ops::{Deref, DerefMut};
+use std::ptr;
+
+/// Controls in which cases the associated code should be run
+pub trait Strategy {
+    /// Return `true` if the guard’s associated code should run
+    /// (in the context where this method is called).
+    fn should_run() -> bool;
+}
+
+/// Always run on scope exit.
+///
+/// “Always” run: on regular exit from a scope or on unwinding from a panic.
+/// Can not run on abort, process exit, and other catastrophic events where
+/// destructors don’t run.
+#[derive(Debug)]
+pub enum Always {}
+
+/// Run on scope exit through unwinding.
+///
+/// Requires crate feature `use_std`.
+#[cfg(feature = "use_std")]
+#[derive(Debug)]
+pub enum OnUnwind {}
+
+/// Run on regular scope exit, when not unwinding.
+///
+/// Requires crate feature `use_std`.
+#[cfg(feature = "use_std")]
+#[derive(Debug)]
+pub enum OnSuccess {}
+
+impl Strategy for Always {
+    #[inline(always)]
+    fn should_run() -> bool {
+        true
+    }
+}
+
+#[cfg(feature = "use_std")]
+impl Strategy for OnUnwind {
+    #[inline]
+    fn should_run() -> bool {
+        std::thread::panicking()
+    }
+}
+
+#[cfg(feature = "use_std")]
+impl Strategy for OnSuccess {
+    #[inline]
+    fn should_run() -> bool {
+        !std::thread::panicking()
+    }
+}
+
+/// Macro to create a `ScopeGuard` (always run).
+///
+/// The macro takes statements, which are the body of a closure
+/// that will run when the scope is exited.
+#[macro_export]
+macro_rules! defer {
+    ($($t:tt)*) => {
+        let _guard = $crate::guard((), |()| { $($t)* });
+    };
+}
+
+/// Macro to create a `ScopeGuard` (run on successful scope exit).
+///
+/// The macro takes statements, which are the body of a closure
+/// that will run when the scope is exited.
+///
+/// Requires crate feature `use_std`.
+#[cfg(feature = "use_std")]
+#[macro_export]
+macro_rules! defer_on_success {
+    ($($t:tt)*) => {
+        let _guard = $crate::guard_on_success((), |()| { $($t)* });
+    };
+}
+
+/// Macro to create a `ScopeGuard` (run on unwinding from panic).
+///
+/// The macro takes statements, which are the body of a closure
+/// that will run when the scope is exited.
+///
+/// Requires crate feature `use_std`.
+#[cfg(feature = "use_std")]
+#[macro_export]
+macro_rules! defer_on_unwind {
+    ($($t:tt)*) => {
+        let _guard = $crate::guard_on_unwind((), |()| { $($t)* });
+    };
+}
+
+/// `ScopeGuard` is a scope guard that may own a protected value.
+///
+/// If you place a guard in a local variable, the closure can
+/// run regardless how you leave the scope — through regular return or panic
+/// (except if panic or other code aborts; so as long as destructors run).
+/// It is run only once.
+///
+/// The `S` parameter for [`Strategy`](trait.Strategy.html) determines if
+/// the closure actually runs.
+///
+/// The guard's closure will be called with the held value in the destructor.
+///
+/// The `ScopeGuard` implements `Deref` so that you can access the inner value.
+pub struct ScopeGuard<T, F, S = Always>
+where
+    F: FnOnce(T),
+    S: Strategy,
+{
+    value: ManuallyDrop<T>,
+    dropfn: ManuallyDrop<F>,
+    // fn(S) -> S is used, so that the S is not taken into account for auto traits.
+    strategy: PhantomData<fn(S) -> S>,
+}
+
+impl<T, F, S> ScopeGuard<T, F, S>
+where
+    F: FnOnce(T),
+    S: Strategy,
+{
+    /// Create a `ScopeGuard` that owns `v` (accessible through deref) and calls
+    /// `dropfn` when its destructor runs.
+    ///
+    /// The `Strategy` decides whether the scope guard's closure should run.
+    #[inline]
+    #[must_use]
+    pub fn with_strategy(v: T, dropfn: F) -> ScopeGuard<T, F, S> {
+        ScopeGuard {
+            value: ManuallyDrop::new(v),
+            dropfn: ManuallyDrop::new(dropfn),
+            strategy: PhantomData,
+        }
+    }
+
+    /// “Defuse” the guard and extract the value without calling the closure.
+    ///
+    /// ```
+    /// extern crate scopeguard;
+    ///
+    /// use scopeguard::{guard, ScopeGuard};
+    ///
+    /// fn conditional() -> bool { true }
+    ///
+    /// fn main() {
+    ///     let mut guard = guard(Vec::new(), |mut v| v.clear());
+    ///     guard.push(1);
+    ///
+    ///     if conditional() {
+    ///         // a condition maybe makes us decide to
+    ///         // “defuse” the guard and get back its inner parts
+    ///         let value = ScopeGuard::into_inner(guard);
+    ///     } else {
+    ///         // guard still exists in this branch
+    ///     }
+    /// }
+    /// ```
+    #[inline]
+    pub fn into_inner(guard: Self) -> T {
+        // Cannot move out of `Drop`-implementing types,
+        // so `ptr::read` the value and forget the guard.
+        let mut guard = ManuallyDrop::new(guard);
+        unsafe {
+            let value = ptr::read(&*guard.value);
+            // Drop the closure after `value` has been read, so that if the
+            // closure's `drop` function panics, unwinding still tries to drop
+            // `value`.
+            ManuallyDrop::drop(&mut guard.dropfn);
+            value
+        }
+    }
+}
+
+/// Create a new `ScopeGuard` owning `v` and with deferred closure `dropfn`.
+#[inline]
+#[must_use]
+pub fn guard<T, F>(v: T, dropfn: F) -> ScopeGuard<T, F, Always>
+where
+    F: FnOnce(T),
+{
+    ScopeGuard::with_strategy(v, dropfn)
+}
+
+/// Create a new `ScopeGuard` owning `v` and with deferred closure `dropfn`.
+///
+/// Requires crate feature `use_std`.
+#[cfg(feature = "use_std")]
+#[inline]
+#[must_use]
+pub fn guard_on_success<T, F>(v: T, dropfn: F) -> ScopeGuard<T, F, OnSuccess>
+where
+    F: FnOnce(T),
+{
+    ScopeGuard::with_strategy(v, dropfn)
+}
+
+/// Create a new `ScopeGuard` owning `v` and with deferred closure `dropfn`.
+///
+/// Requires crate feature `use_std`.
+///
+/// ## Examples
+///
+/// For performance reasons, or to emulate “only run guard on unwind” in
+/// no-std environments, we can also use the default guard and simply manually
+/// defuse it at the end of scope like the following example. (The performance
+/// reason would be if the [`OnUnwind`]'s call to [std::thread::panicking()] is
+/// an issue.)
+///
+/// ```
+/// extern crate scopeguard;
+///
+/// use scopeguard::ScopeGuard;
+/// # fn main() {
+/// {
+///     let guard = scopeguard::guard((), |_| {});
+///
+///     // rest of the code here
+///
+///     // we reached the end of scope without unwinding - defuse it
+///     ScopeGuard::into_inner(guard);
+/// }
+/// # }
+/// ```
+#[cfg(feature = "use_std")]
+#[inline]
+#[must_use]
+pub fn guard_on_unwind<T, F>(v: T, dropfn: F) -> ScopeGuard<T, F, OnUnwind>
+where
+    F: FnOnce(T),
+{
+    ScopeGuard::with_strategy(v, dropfn)
+}
+
+// ScopeGuard can be Sync even if F isn't because the closure is
+// not accessible from references.
+// The guard does not store any instance of S, so it is also irrelevant.
+unsafe impl<T, F, S> Sync for ScopeGuard<T, F, S>
+where
+    T: Sync,
+    F: FnOnce(T),
+    S: Strategy,
+{
+}
+
+impl<T, F, S> Deref for ScopeGuard<T, F, S>
+where
+    F: FnOnce(T),
+    S: Strategy,
+{
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        &*self.value
+    }
+}
+
+impl<T, F, S> DerefMut for ScopeGuard<T, F, S>
+where
+    F: FnOnce(T),
+    S: Strategy,
+{
+    fn deref_mut(&mut self) -> &mut T {
+        &mut *self.value
+    }
+}
+
+impl<T, F, S> Drop for ScopeGuard<T, F, S>
+where
+    F: FnOnce(T),
+    S: Strategy,
+{
+    fn drop(&mut self) {
+        // This is OK because the fields are `ManuallyDrop`s
+        // which will not be dropped by the compiler.
+        let (value, dropfn) = unsafe { (ptr::read(&*self.value), ptr::read(&*self.dropfn)) };
+        if S::should_run() {
+            dropfn(value);
+        }
+    }
+}
+
+impl<T, F, S> fmt::Debug for ScopeGuard<T, F, S>
+where
+    T: fmt::Debug,
+    F: FnOnce(T),
+    S: Strategy,
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct(stringify!(ScopeGuard))
+            .field("value", &*self.value)
+            .finish()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::cell::Cell;
+    use std::panic::catch_unwind;
+    use std::panic::AssertUnwindSafe;
+
+    #[test]
+    fn test_defer() {
+        let drops = Cell::new(0);
+        defer!(drops.set(1000));
+        assert_eq!(drops.get(), 0);
+    }
+
+    #[cfg(feature = "use_std")]
+    #[test]
+    fn test_defer_success_1() {
+        let drops = Cell::new(0);
+        {
+            defer_on_success!(drops.set(1));
+            assert_eq!(drops.get(), 0);
+        }
+        assert_eq!(drops.get(), 1);
+    }
+
+    #[cfg(feature = "use_std")]
+    #[test]
+    #[ignore = "Android uses panic_abort"]
+    fn test_defer_success_2() {
+        let drops = Cell::new(0);
+        let _ = catch_unwind(AssertUnwindSafe(|| {
+            defer_on_success!(drops.set(1));
+            panic!("failure")
+        }));
+        assert_eq!(drops.get(), 0);
+    }
+
+    #[cfg(feature = "use_std")]
+    #[test]
+    #[ignore = "Android uses panic_abort"]
+    fn test_defer_unwind_1() {
+        let drops = Cell::new(0);
+        let _ = catch_unwind(AssertUnwindSafe(|| {
+            defer_on_unwind!(drops.set(1));
+            assert_eq!(drops.get(), 0);
+            panic!("failure")
+        }));
+        assert_eq!(drops.get(), 1);
+    }
+
+    #[cfg(feature = "use_std")]
+    #[test]
+    fn test_defer_unwind_2() {
+        let drops = Cell::new(0);
+        {
+            defer_on_unwind!(drops.set(1));
+        }
+        assert_eq!(drops.get(), 0);
+    }
+
+    #[test]
+    fn test_only_dropped_by_closure_when_run() {
+        let value_drops = Cell::new(0);
+        let value = guard((), |()| value_drops.set(1 + value_drops.get()));
+        let closure_drops = Cell::new(0);
+        let guard = guard(value, |_| closure_drops.set(1 + closure_drops.get()));
+        assert_eq!(value_drops.get(), 0);
+        assert_eq!(closure_drops.get(), 0);
+        drop(guard);
+        assert_eq!(value_drops.get(), 1);
+        assert_eq!(closure_drops.get(), 1);
+    }
+
+    #[cfg(feature = "use_std")]
+    #[test]
+    fn test_dropped_once_when_not_run() {
+        let value_drops = Cell::new(0);
+        let value = guard((), |()| value_drops.set(1 + value_drops.get()));
+        let captured_drops = Cell::new(0);
+        let captured = guard((), |()| captured_drops.set(1 + captured_drops.get()));
+        let closure_drops = Cell::new(0);
+        let guard = guard_on_unwind(value, |value| {
+            drop(value);
+            drop(captured);
+            closure_drops.set(1 + closure_drops.get())
+        });
+        assert_eq!(value_drops.get(), 0);
+        assert_eq!(captured_drops.get(), 0);
+        assert_eq!(closure_drops.get(), 0);
+        drop(guard);
+        assert_eq!(value_drops.get(), 1);
+        assert_eq!(captured_drops.get(), 1);
+        assert_eq!(closure_drops.get(), 0);
+    }
+
+    #[test]
+    fn test_into_inner() {
+        let dropped = Cell::new(false);
+        let value = guard(42, |_| dropped.set(true));
+        let guard = guard(value, |_| dropped.set(true));
+        let inner = ScopeGuard::into_inner(guard);
+        assert_eq!(dropped.get(), false);
+        assert_eq!(*inner, 42);
+    }
+}
diff --git a/pseudo_crate/Cargo.lock b/pseudo_crate/Cargo.lock
index f5e40e1..e33cc20 100644
--- a/pseudo_crate/Cargo.lock
+++ b/pseudo_crate/Cargo.lock
@@ -4,9 +4,9 @@
 
 [[package]]
 name = "addr2line"
-version = "0.22.0"
+version = "0.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e4503c46a5c0c7844e948c9a4d6acd9f50cccb4de1c48eb9e291ea17470c678"
+checksum = "8a30b2e23b9e17a9f90641c7ab1549cd9b44f296d3ccbf309d2863cfe398a0cb"
 dependencies = [
  "gimli",
 ]
@@ -51,20 +51,11 @@
 ]
 
 [[package]]
-name = "aho-corasick"
-version = "1.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
-dependencies = [
- "memchr",
-]
-
-[[package]]
 name = "android-pseudo-crate"
 version = "0.1.0"
 dependencies = [
  "ahash 0.8.11",
- "aho-corasick 0.7.20",
+ "aho-corasick",
  "android_log-sys",
  "android_logger",
  "anes 0.2.0",
@@ -200,6 +191,31 @@
  "pest_derive",
  "pest_generator",
  "pest_meta",
+ "pin-project",
+ "pin-project-internal",
+ "pin-project-lite",
+ "pkcs1",
+ "pkcs8",
+ "plotters-backend",
+ "plotters-svg",
+ "ppv-lite86",
+ "predicates-core",
+ "predicates-tree",
+ "prettyplease 0.2.6",
+ "proc-macro2",
+ "rand",
+ "rand_chacha",
+ "rand_core",
+ "rand_xorshift",
+ "rayon",
+ "rayon-core",
+ "regex",
+ "regex-syntax",
+ "rusqlite",
+ "rustc-demangle",
+ "rustc-hash",
+ "rustversion",
+ "scopeguard",
 ]
 
 [[package]]
@@ -272,7 +288,7 @@
  "argh_shared",
  "proc-macro2",
  "quote",
- "syn 2.0.74",
+ "syn 2.0.43",
 ]
 
 [[package]]
@@ -312,7 +328,7 @@
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.74",
+ "syn 2.0.43",
 ]
 
 [[package]]
@@ -329,7 +345,7 @@
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.74",
+ "syn 2.0.43",
 ]
 
 [[package]]
@@ -409,9 +425,9 @@
 
 [[package]]
 name = "backtrace"
-version = "0.3.73"
+version = "0.3.71"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5cc23269a4f8976d0a4d2e7109211a419fe30e8d88d677cd60b6bc79c5732e0a"
+checksum = "26b05800d2e817c8b3b4b54abd461726265fa9789ae34330622f2db9ee696f9d"
 dependencies = [
  "addr2line",
  "cc",
@@ -481,7 +497,7 @@
 dependencies = [
  "memchr",
  "once_cell",
- "regex-automata 0.1.10",
+ "regex-automata",
  "serde",
 ]
 
@@ -517,7 +533,7 @@
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.74",
+ "syn 2.0.43",
 ]
 
 [[package]]
@@ -650,7 +666,7 @@
  "heck",
  "proc-macro2",
  "quote",
- "syn 2.0.74",
+ "syn 2.0.43",
 ]
 
 [[package]]
@@ -853,7 +869,7 @@
  "proc-macro2",
  "quote",
  "strsim",
- "syn 2.0.74",
+ "syn 2.0.43",
 ]
 
 [[package]]
@@ -864,7 +880,7 @@
 dependencies = [
  "darling_core",
  "quote",
- "syn 2.0.74",
+ "syn 2.0.43",
 ]
 
 [[package]]
@@ -891,6 +907,9 @@
 version = "0.7.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fffa369a668c8af7dbf8b5e56c9f744fbd399949ed171606040001947de40b1c"
+dependencies = [
+ "const-oid",
+]
 
 [[package]]
 name = "der_derive"
@@ -900,7 +919,7 @@
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.74",
+ "syn 2.0.43",
 ]
 
 [[package]]
@@ -911,7 +930,7 @@
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.74",
+ "syn 2.0.43",
 ]
 
 [[package]]
@@ -932,7 +951,7 @@
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.74",
+ "syn 2.0.43",
 ]
 
 [[package]]
@@ -1018,7 +1037,7 @@
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.74",
+ "syn 2.0.43",
 ]
 
 [[package]]
@@ -1202,7 +1221,7 @@
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.74",
+ "syn 2.0.43",
 ]
 
 [[package]]
@@ -1299,9 +1318,9 @@
 
 [[package]]
 name = "gimli"
-version = "0.29.0"
+version = "0.28.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40ecd4077b5ae9fd2e9e169b102c6c330d0605168eb0e8bf79952b256dbefffd"
+checksum = "4271d37baee1b8c7e4b708028c57d816cf9d2434acb33a549475f78c181f6253"
 
 [[package]]
 name = "glob"
@@ -1328,7 +1347,7 @@
 checksum = "ed3057b7d1e628480193188ccb1a7850d034a3add3a350f4ed921b48e287ada9"
 dependencies = [
  "quote",
- "syn 2.0.74",
+ "syn 2.0.43",
 ]
 
 [[package]]
@@ -1625,6 +1644,16 @@
 ]
 
 [[package]]
+name = "libsqlite3-sys"
+version = "0.26.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "afc22eff61b133b115c6e8c74e818c628d6d5e7a502afea6f64dee076dd94326"
+dependencies = [
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
 name = "linked-hash-map"
 version = "0.5.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1647,7 +1676,7 @@
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.74",
+ "syn 2.0.43",
 ]
 
 [[package]]
@@ -1756,7 +1785,7 @@
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.74",
+ "syn 2.0.43",
 ]
 
 [[package]]
@@ -1794,7 +1823,7 @@
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.74",
+ "syn 2.0.43",
 ]
 
 [[package]]
@@ -1862,7 +1891,7 @@
  "darling",
  "proc-macro2",
  "quote",
- "syn 2.0.74",
+ "syn 2.0.43",
 ]
 
 [[package]]
@@ -1906,7 +1935,7 @@
  "cfg-if",
  "proc-macro2",
  "quote",
- "syn 2.0.74",
+ "syn 2.0.43",
 ]
 
 [[package]]
@@ -1942,7 +1971,7 @@
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.74",
+ "syn 2.0.43",
 ]
 
 [[package]]
@@ -1986,9 +2015,9 @@
 
 [[package]]
 name = "object"
-version = "0.36.3"
+version = "0.32.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "27b64972346851a39438c60b341ebc01bba47464ae329e55cf343eb93964efd9"
+checksum = "a6a622008b6e321afc04970976f62ee297fdbaa6f95318ca343e3eebb9648441"
 dependencies = [
  "memchr",
 ]
@@ -2122,7 +2151,7 @@
  "pest_meta",
  "proc-macro2",
  "quote",
- "syn 2.0.74",
+ "syn 2.0.43",
 ]
 
 [[package]]
@@ -2138,29 +2167,29 @@
 
 [[package]]
 name = "pin-project"
-version = "1.1.5"
+version = "1.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6bf43b791c5b9e34c3d182969b4abb522f9343702850a2e57f460d00d09b4b3"
+checksum = "fda4ed1c6c173e3fc7a83629421152e01d7b1f9b7f65fb301e490e8cfc656422"
 dependencies = [
  "pin-project-internal",
 ]
 
 [[package]]
 name = "pin-project-internal"
-version = "1.1.5"
+version = "1.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f38a4412a78282e09a2cf38d195ea5420d15ba0602cb375210efbc877243965"
+checksum = "4359fd9c9171ec6e8c62926d6faaf553a8dc3f64e1507e76da7911b4f6a04405"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.74",
+ "syn 2.0.43",
 ]
 
 [[package]]
 name = "pin-project-lite"
-version = "0.2.14"
+version = "0.2.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bda66fc9667c18cb2758a2ac84d1167245054bcf85d5d1aaa6923f45801bdd02"
+checksum = "8afb450f006bf6385ca15ef45d71d2288452bc3683ce2e2cacc0d18e4be60b58"
 
 [[package]]
 name = "pin-utils"
@@ -2169,6 +2198,26 @@
 checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
 
 [[package]]
+name = "pkcs1"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8ffb9f10fa047879315e6625af03c164b16962a5368d724ed16323b68ace47f"
+dependencies = [
+ "der",
+ "spki",
+]
+
+[[package]]
+name = "pkcs8"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
+dependencies = [
+ "der",
+ "spki",
+]
+
+[[package]]
 name = "pkg-config"
 version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -2176,9 +2225,9 @@
 
 [[package]]
 name = "plotters"
-version = "0.3.6"
+version = "0.3.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a15b6eccb8484002195a3e44fe65a4ce8e93a625797a063735536fd59cb01cf3"
+checksum = "d2c224ba00d7cadd4d5c660deaf2098e5e80e07846537c51f9cfa4be50c1fd45"
 dependencies = [
  "num-traits",
  "plotters-backend",
@@ -2189,15 +2238,15 @@
 
 [[package]]
 name = "plotters-backend"
-version = "0.3.6"
+version = "0.3.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "414cec62c6634ae900ea1c56128dfe87cf63e7caece0852ec76aba307cebadb7"
+checksum = "9e76628b4d3a7581389a35d5b6e2139607ad7c75b17aed325f210aa91f4a9609"
 
 [[package]]
 name = "plotters-svg"
-version = "0.3.6"
+version = "0.3.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81b30686a7d9c3e010b84284bdd26a29f2138574f52f5eb6f794fc0ad924e705"
+checksum = "38f6d39893cca0701371e3c27294f09797214b86f1fb951b89ade8ec04e2abab"
 dependencies = [
  "plotters-backend",
 ]
@@ -2210,12 +2259,9 @@
 
 [[package]]
 name = "ppv-lite86"
-version = "0.2.20"
+version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04"
-dependencies = [
- "zerocopy",
-]
+checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
 
 [[package]]
 name = "predicates"
@@ -2229,15 +2275,15 @@
 
 [[package]]
 name = "predicates-core"
-version = "1.0.8"
+version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae8177bee8e75d6846599c6b9ff679ed51e882816914eec639944d7c9aa11931"
+checksum = "b794032607612e7abeb4db69adb4e33590fa6cf1149e95fd7cb00e634b92f174"
 
 [[package]]
 name = "predicates-tree"
-version = "1.0.11"
+version = "1.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41b740d195ed3166cd147c8047ec98db0e22ec019eb8eeb76d343b795304fb13"
+checksum = "368ba315fb8c5052ab692e68a0eefec6ec57b23a36959c14496f0b0df2c0cecf"
 dependencies = [
  "predicates-core",
  "termtree",
@@ -2254,6 +2300,16 @@
 ]
 
 [[package]]
+name = "prettyplease"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b69d39aab54d069e7f2fe8cb970493e7834601ca2d8c65fd7bbd183578080d1"
+dependencies = [
+ "proc-macro2",
+ "syn 2.0.43",
+]
+
+[[package]]
 name = "proc-macro-crate"
 version = "3.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -2288,9 +2344,9 @@
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.86"
+version = "1.0.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
+checksum = "134c189feb4956b20f6f547d2cf727d4c0fe06722b20a0eec87ed445a97f92da"
 dependencies = [
  "unicode-ident",
 ]
@@ -2306,9 +2362,9 @@
 
 [[package]]
 name = "quote"
-version = "1.0.36"
+version = "1.0.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7"
+checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae"
 dependencies = [
  "proc-macro2",
 ]
@@ -2344,10 +2400,19 @@
 ]
 
 [[package]]
-name = "rayon"
-version = "1.10.0"
+name = "rand_xorshift"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa"
+checksum = "d25bf25ec5ae4a3f1b92f929810509a2f53d7dca2f50b794ff57e3face536c8f"
+dependencies = [
+ "rand_core",
+]
+
+[[package]]
+name = "rayon"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa7237101a77a10773db45d62004a272517633fbcc3df19d96455ede1122e051"
 dependencies = [
  "either",
  "rayon-core",
@@ -2374,13 +2439,12 @@
 
 [[package]]
 name = "regex"
-version = "1.10.6"
+version = "1.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4219d74c6b67a3654a9fbebc4b419e22126d13d2f3c4a07ee0cb61ff79a79619"
+checksum = "8b1f693b24f6ac912f4893ef08244d70b6067480d2f1a46e950c9691e6749d1d"
 dependencies = [
- "aho-corasick 1.1.3",
+ "aho-corasick",
  "memchr",
- "regex-automata 0.4.7",
  "regex-syntax",
 ]
 
@@ -2391,27 +2455,36 @@
 checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"
 
 [[package]]
-name = "regex-automata"
-version = "0.4.7"
+name = "regex-syntax"
+version = "0.6.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38caf58cc5ef2fed281f89292ef23f6365465ed9a41b7a7754eb4e26496c92df"
+checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"
+
+[[package]]
+name = "rusqlite"
+version = "0.29.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "549b9d036d571d42e6e85d1c1425e2ac83491075078ca9a15be021c56b1641f2"
 dependencies = [
- "aho-corasick 1.1.3",
- "memchr",
- "regex-syntax",
+ "bitflags 2.6.0",
+ "fallible-iterator",
+ "fallible-streaming-iterator",
+ "hashlink",
+ "libsqlite3-sys",
+ "smallvec",
 ]
 
 [[package]]
-name = "regex-syntax"
-version = "0.8.4"
+name = "rustc-demangle"
+version = "0.1.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a66a03ae7c801facd77a29370b4faec201768915ac14a721ba36f20bc9c209b"
+checksum = "d626bb9dae77e28219937af045c257c28bfd3f69333c512553507f5f9798cb76"
 
 [[package]]
-name = "rustc-demangle"
-version = "0.1.24"
+name = "rustc-hash"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "719b953e2095829ee67db738b3bfa9fa368c94900df327b3f07fe6e794d2fe1f"
+checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
 [[package]]
 name = "rustix"
@@ -2428,9 +2501,9 @@
 
 [[package]]
 name = "rustversion"
-version = "1.0.17"
+version = "1.0.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "955d28af4278de8121b7ebeb796b6a45735dc01436d898801014aced2773a3d6"
+checksum = "7ffc183a10b4478d04cbbbfc96d0873219d962dd5accaff2ffbd4ceb7df837f4"
 
 [[package]]
 name = "ryu"
@@ -2476,7 +2549,7 @@
  "proc-macro-error",
  "proc-macro2",
  "quote",
- "syn 2.0.74",
+ "syn 2.0.43",
  "thiserror",
 ]
 
@@ -2487,7 +2560,7 @@
 checksum = "7cdcb365894c49e42b5413def59ac644ea085bbbdee535d7c80b2b008a345686"
 dependencies = [
  "macro_rules_attribute",
- "prettyplease",
+ "prettyplease 0.1.25",
  "proc-macro2",
  "quote",
  "syn 1.0.109",
@@ -2516,41 +2589,40 @@
 
 [[package]]
 name = "serde"
-version = "1.0.207"
+version = "1.0.193"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5665e14a49a4ea1b91029ba7d3bca9f299e1f7cfa194388ccc20f14743e784f2"
+checksum = "25dd9975e68d0cb5aa1120c288333fc98731bd1dd12f561e468ea4728c042b89"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.207"
+version = "1.0.193"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6aea2634c86b0e8ef2cfdc0c340baede54ec27b1e46febd7f80dffb2aa44a00e"
+checksum = "43576ca501357b9b071ac53cdc7da8ef0cbd9493d8df094cd821777ea6e894d3"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.74",
+ "syn 2.0.43",
 ]
 
 [[package]]
 name = "serde_json"
-version = "1.0.124"
+version = "1.0.109"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "66ad62847a56b3dba58cc891acd13884b9c61138d330c0d7b6181713d4fce38d"
+checksum = "cb0652c533506ad7a2e353cce269330d6afd8bdfb6d75e0ace5b35aacbd7b9e9"
 dependencies = [
  "itoa",
- "memchr",
  "ryu",
  "serde",
 ]
 
 [[package]]
 name = "serde_path_to_error"
-version = "0.1.16"
+version = "0.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af99884400da37c88f5e9146b7f1fd0fbcae8f6eec4e9da38b67d05486f814a6"
+checksum = "4beec8bce849d58d06238cb50db2e1c417cfeafa4c63f692b15c82b7c80f8335"
 dependencies = [
  "itoa",
  "serde",
@@ -2626,6 +2698,15 @@
 ]
 
 [[package]]
+name = "spki"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
+dependencies = [
+ "der",
+]
+
+[[package]]
 name = "stabby"
 version = "36.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -2684,9 +2765,9 @@
 
 [[package]]
 name = "syn"
-version = "2.0.74"
+version = "2.0.43"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fceb41e3d546d0bd83421d3409b1460cc7444cd389341a4c880fe7a042cb3d7"
+checksum = "ee659fb5f3d355364e1f3e5bc10fb82068efbf824a1e9d1c9504244a6469ad53"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2722,22 +2803,22 @@
 
 [[package]]
 name = "thiserror"
-version = "1.0.63"
+version = "1.0.55"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0342370b38b6a11b6cc11d6a805569958d54cfa061a29969c3b5ce2ea405724"
+checksum = "6e3de26b0965292219b4287ff031fcba86837900fe9cd2b34ea8ad893c0953d2"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.63"
+version = "1.0.55"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4558b58466b9ad7ca0f102865eccc95938dca1a74a856f2b57b6629050da261"
+checksum = "268026685b2be38d7103e9e507c938a1fcb3d7e6eb15e87870b617bf37b6d581"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.74",
+ "syn 2.0.43",
 ]
 
 [[package]]
@@ -2929,6 +3010,12 @@
 checksum = "0976c77def3f1f75c4ef892a292c31c0bbe9e3d0702c63044d7c76db298171a3"
 
 [[package]]
+name = "vcpkg"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
+
+[[package]]
 name = "version_check"
 version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -2981,7 +3068,7 @@
  "once_cell",
  "proc-macro2",
  "quote",
- "syn 2.0.74",
+ "syn 2.0.43",
  "wasm-bindgen-shared",
 ]
 
@@ -3003,7 +3090,7 @@
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.74",
+ "syn 2.0.43",
  "wasm-bindgen-backend",
  "wasm-bindgen-shared",
 ]
@@ -3344,7 +3431,6 @@
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
 dependencies = [
- "byteorder",
  "zerocopy-derive",
 ]
 
@@ -3356,7 +3442,7 @@
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.74",
+ "syn 2.0.43",
 ]
 
 [[package]]
@@ -3376,5 +3462,5 @@
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.74",
+ "syn 2.0.43",
 ]
diff --git a/pseudo_crate/Cargo.toml b/pseudo_crate/Cargo.toml
index 1d62e09..e40f43a 100644
--- a/pseudo_crate/Cargo.toml
+++ b/pseudo_crate/Cargo.toml
@@ -143,3 +143,28 @@
 pest_derive = "=2.7.6"
 pest_generator = "=2.7.6"
 pest_meta = "=2.7.6"
+pin-project = "=1.1.3"
+pin-project-internal = "=1.1.3"
+pin-project-lite = "=0.2.13"
+pkcs1 = "=0.7.5"
+pkcs8 = "=0.10.2"
+plotters-backend = "=0.3.5"
+plotters-svg = "=0.3.5"
+ppv-lite86 = "=0.2.17"
+predicates-core = "=1.0.6"
+predicates-tree = "=1.0.9"
+prettyplease = "=0.2.6"
+proc-macro2 = "=1.0.69"
+rand = "=0.8.5"
+rand_chacha = "=0.3.1"
+rand_core = "=0.6.4"
+rand_xorshift = "=0.3.0"
+rayon = "=1.8.1"
+rayon-core = "=1.12.1"
+regex = "=1.7.3"
+regex-syntax = "=0.6.29"
+rusqlite = "=0.29.0"
+rustc-demangle = "=0.1.23"
+rustc-hash = "=1.1.0"
+rustversion = "=1.0.14"
+scopeguard = "=1.2.0"